Release v0.0.64

Desktop v0.0.64

Author: serafimcloud

build/settingsTemplate.png

@@ -1,6 +1,6 @@
 {
   "name": "21st-desktop",
-  "version": "0.0.63",
+  "version": "0.0.64",
   "private": true,
   "description": "1Code - UI for parallel work with AI agents",
   "author": {

build/settingsTemplate@2x.png

@@ -1,5 +1,5 @@
 import * as Sentry from "@sentry/electron/main"
-import { app, BrowserWindow, Menu, session } from "electron"
+import { app, BrowserWindow, Menu, nativeImage, session } from "electron"
 import { existsSync, readFileSync, readlinkSync, unlinkSync } from "fs"
 import { createServer } from "http"
 import { join } from "path"
@@ -603,6 +603,15 @@ if (gotTheLock) {
     // Track devtools unlock state (hidden feature - 5 clicks on Beta tab)
     let devToolsUnlocked = false
 
+    // Menu icons: PNG template for settings (auto light/dark via "Template" suffix),
+    // macOS native SF Symbol for terminal
+    const settingsMenuIcon = nativeImage.createFromPath(
+      join(__dirname, "../../build/settingsTemplate.png")
+    )
+    const terminalMenuIcon = process.platform === "darwin"
+      ? nativeImage.createFromNamedImage("terminal")?.resize({ width: 12, height: 12 })
+      : null
+
     // Function to build and set application menu
     const buildMenu = () => {
       // Show devtools menu item only in dev mode or when unlocked
@@ -611,7 +620,10 @@ if (gotTheLock) {
         {
           label: app.name,
           submenu: [
-            { role: "about", label: "About 1Code" },
+            {
+              label: "About 1Code",
+              click: () => app.showAboutPanel(),
+            },
             {
               label: updateAvailable
                 ? `Update to v${availableVersion}...`
@@ -631,10 +643,23 @@ if (gotTheLock) {
               },
             },
             { type: "separator" },
+            {
+              label: "Settings...",
+              ...(settingsMenuIcon && { icon: settingsMenuIcon }),
+              accelerator: "CmdOrCtrl+,",
+              click: () => {
+                const win = getWindow()
+                if (win) {
+                  win.webContents.send("shortcut:open-settings")
+                }
+              },
+            },
+            { type: "separator" },
             {
               label: isCliInstalled()
                 ? "Uninstall '1code' Command..."
                 : "Install '1code' Command in PATH...",
+              ...(terminalMenuIcon && { icon: terminalMenuIcon }),
               click: async () => {
                 const { dialog } = await import("electron")
                 if (isCliInstalled()) {

bun.lockb

@@ -359,20 +359,7 @@ function preprocessCodexModelName(params: {
     return params.modelId
   }
 
-  if (params.modelId === "gpt-5.3-codex") {
-    return "gpt-5.2-codex/high"
-  }
-
-  const gpt53Prefix = "gpt-5.3-codex/"
-  if (params.modelId.startsWith(gpt53Prefix)) {
-    const requestedThinking = params.modelId.slice(gpt53Prefix.length)
-    const supportedThinkingLevels = new Set(["low", "medium", "high", "xhigh"])
-    const normalizedThinking = supportedThinkingLevels.has(requestedThinking)
-      ? requestedThinking
-      : "high"
-    return `gpt-5.2-codex/${normalizedThinking}`
-  }
-
+  // All model IDs now match the real API; pass through as-is
   return params.modelId
 }
 

package.json

@@ -15,6 +15,7 @@ export interface FileCommand {
   source: "user" | "project" | "plugin"
   pluginName?: string
   path: string
+  content: string
 }
 
 /**
@@ -57,6 +58,7 @@ async function scanCommandsDirectory(
   dir: string,
   source: "user" | "project" | "plugin",
   prefix = "",
+  basePath?: string,
 ): Promise<FileCommand[]> {
   const commands: FileCommand[] = []
 
@@ -85,23 +87,37 @@ async function scanCommandsDirectory(
           fullPath,
           source,
           prefix ? `${prefix}:${entry.name}` : entry.name,
+          basePath,
         )
         commands.push(...nestedCommands)
       } else if (isFile && entry.name.endsWith(".md")) {
         const baseName = entry.name.replace(/\.md$/, "")
         const fallbackName = prefix ? `${prefix}:${baseName}` : baseName
 
         try {
-          const content = await fs.readFile(fullPath, "utf-8")
-          const parsed = parseCommandMd(content)
+          const rawContent = await fs.readFile(fullPath, "utf-8")
+          const parsed = parseCommandMd(rawContent)
+          const { content: body } = matter(rawContent)
           const commandName = parsed.name || fallbackName
 
+          // Format display path: ~/... for user, relative for project
+          let displayPath: string
+          if (source === "project" && basePath) {
+            displayPath = path.relative(basePath, fullPath)
+          } else {
+            const homeDir = os.homedir()
+            displayPath = fullPath.startsWith(homeDir)
+              ? "~" + fullPath.slice(homeDir.length)
+              : fullPath
+          }
+
           commands.push({
             name: commandName,
             description: parsed.description || "",
             argumentHint: parsed.argumentHint,
             source,
-            path: fullPath,
+            path: displayPath,
+            content: body.trim(),
           })
         } catch (err) {
           console.warn(`[commands] Failed to read ${fullPath}:`, err)
@@ -115,6 +131,36 @@ async function scanCommandsDirectory(
   return commands
 }
 
+/**
+ * Generate command .md content from name, description, and body
+ */
+function generateCommandMd(command: { name: string; description: string; content: string; argumentHint?: string }): string {
+  const frontmatter: string[] = []
+  if (command.description) {
+    frontmatter.push(`description: ${command.description}`)
+  }
+  if (command.argumentHint) {
+    frontmatter.push(`argument-hint: ${command.argumentHint}`)
+  }
+  if (frontmatter.length === 0) {
+    return command.content
+  }
+  return `---\n${frontmatter.join("\n")}\n---\n\n${command.content}`
+}
+
+/**
+ * Resolve the absolute filesystem path of a command given its display path
+ */
+function resolveCommandPath(displayPath: string, projectPath?: string): string {
+  if (displayPath.startsWith("~")) {
+    return path.join(os.homedir(), displayPath.slice(1))
+  }
+  if (projectPath && !displayPath.startsWith("/")) {
+    return path.join(projectPath, displayPath)
+  }
+  return displayPath
+}
+
 export const commandsRouter = router({
   /**
    * List all commands from filesystem
@@ -143,6 +189,8 @@ export const commandsRouter = router({
         projectCommandsPromise = scanCommandsDirectory(
           projectCommandsDir,
           "project",
+          "",
+          input.projectPath,
         )
       }
 
@@ -181,20 +229,129 @@ export const commandsRouter = router({
    * Get content of a specific command file (without frontmatter)
    */
   getContent: publicProcedure
-    .input(z.object({ path: z.string() }))
+    .input(z.object({ path: z.string(), projectPath: z.string().optional() }))
     .query(async ({ input }) => {
       // Security: prevent path traversal
       if (input.path.includes("..")) {
         throw new Error("Invalid path")
       }
 
       try {
-        const content = await fs.readFile(input.path, "utf-8")
+        const absolutePath = resolveCommandPath(input.path, input.projectPath)
+        const content = await fs.readFile(absolutePath, "utf-8")
         const { content: body } = matter(content)
         return { content: body.trim() }
       } catch (err) {
         console.error(`[commands] Failed to read command content:`, err)
         return { content: "" }
       }
     }),
+
+  create: publicProcedure
+    .input(
+      z.object({
+        name: z.string(),
+        description: z.string(),
+        content: z.string(),
+        argumentHint: z.string().optional(),
+        source: z.enum(["user", "project"]),
+        projectPath: z.string().optional(),
+      })
+    )
+    .mutation(async ({ input }) => {
+      const safeName = input.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")
+      if (!safeName) {
+        throw new Error("Command name must contain at least one alphanumeric character")
+      }
+
+      let targetDir: string
+      if (input.source === "project") {
+        if (!input.projectPath) {
+          throw new Error("Project path required for project commands")
+        }
+        targetDir = path.join(input.projectPath, ".claude", "commands")
+      } else {
+        targetDir = path.join(os.homedir(), ".claude", "commands")
+      }
+
+      const commandPath = path.join(targetDir, `${safeName}.md`)
+
+      // Check if already exists
+      try {
+        await fs.access(commandPath)
+        throw new Error(`Command "${safeName}" already exists`)
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+          throw err
+        }
+      }
+
+      // Create directory and write command file
+      await fs.mkdir(targetDir, { recursive: true })
+      const fileContent = generateCommandMd({
+        name: safeName,
+        description: input.description,
+        content: input.content,
+        argumentHint: input.argumentHint,
+      })
+      await fs.writeFile(commandPath, fileContent, "utf-8")
+
+      return {
+        name: safeName,
+        path: commandPath,
+        source: input.source,
+      }
+    }),
+
+  update: publicProcedure
+    .input(
+      z.object({
+        path: z.string(),
+        name: z.string(),
+        description: z.string(),
+        content: z.string(),
+        argumentHint: z.string().optional(),
+        projectPath: z.string().optional(),
+      })
+    )
+    .mutation(async ({ input }) => {
+      // Security: prevent path traversal
+      if (input.path.includes("..")) {
+        throw new Error("Invalid path")
+      }
+
+      const absolutePath = resolveCommandPath(input.path, input.projectPath)
+
+      // Verify file exists before writing
+      await fs.access(absolutePath)
+
+      const fileContent = generateCommandMd({
+        name: input.name,
+        description: input.description,
+        content: input.content,
+        argumentHint: input.argumentHint,
+      })
+      await fs.writeFile(absolutePath, fileContent, "utf-8")
+
+      return { success: true }
+    }),
+
+  delete: publicProcedure
+    .input(
+      z.object({
+        path: z.string(),
+        projectPath: z.string().optional(),
+      })
+    )
+    .mutation(async ({ input }) => {
+      if (input.path.includes("..")) {
+        throw new Error("Invalid path")
+      }
+
+      const absolutePath = resolveCommandPath(input.path, input.projectPath)
+      await fs.access(absolutePath)
+      await fs.unlink(absolutePath)
+
+      return { success: true }
+    }),
 })

src/main/index.ts

@@ -275,6 +275,33 @@ export const skillsRouter = router({
 
       await fs.writeFile(absolutePath, fileContent, "utf-8")
 
+      return { success: true }
+    }),
+
+  /**
+   * Delete a skill directory
+   */
+  delete: publicProcedure
+    .input(
+      z.object({
+        path: z.string(),
+        cwd: z.string().optional(),
+      })
+    )
+    .mutation(async ({ input }) => {
+      if (input.path.includes("..")) {
+        throw new Error("Invalid path")
+      }
+
+      const absolutePath = input.cwd && !input.path.startsWith("~") && !input.path.startsWith("/")
+        ? path.join(input.cwd, input.path)
+        : resolveSkillPath(input.path)
+
+      // Skills are directories containing SKILL.md — delete the parent directory
+      const skillDir = path.dirname(absolutePath)
+      await fs.access(skillDir)
+      await fs.rm(skillDir, { recursive: true })
+
       return { success: true }
     }),
 })

src/main/lib/trpc/routers/codex.ts

@@ -208,7 +208,36 @@ function registerIpcHandlers(): void {
 
   // New window - optionally open with specific chat/subchat
   ipcMain.handle("window:new", (_event, options?: { chatId?: string; subChatId?: string }) => {
-    createWindow(options)
+    // If chatId specified, check ownership atomically via focusChatOwner
+    if (options?.chatId && windowManager.focusChatOwner(options.chatId)) {
+      return { blocked: true }
+    }
+
+    const win = createWindow(options)
+
+    // Pre-claim the chat for the new window
+    if (options?.chatId) {
+      windowManager.claimChat(options.chatId, win.id)
+    }
+
+    return { blocked: false }
+  })
+
+  // Chat ownership — prevent same chat open in multiple windows
+  ipcMain.handle("chat:claim", (event, chatId: string) => {
+    const win = getWindowFromEvent(event)
+    if (!win) return { ok: false, ownerStableId: "unknown" }
+    return windowManager.claimChat(chatId, win.id)
+  })
+
+  ipcMain.handle("chat:release", (event, chatId: string) => {
+    const win = getWindowFromEvent(event)
+    if (!win) return
+    windowManager.releaseChat(chatId, win.id)
+  })
+
+  ipcMain.handle("chat:focus-owner", (_event, chatId: string) => {
+    return windowManager.focusChatOwner(chatId)
   })
 
   // Set window title