@punkcode/cli 0.1.11 → 0.1.13

package/dist/cli.js

@@ -164,6 +164,7 @@ function runClaude(options, callbacks) {
         ...opts.model && { model: opts.model },
         ...opts.allowedTools && { allowedTools: opts.allowedTools },
         ...opts.disallowedTools && { disallowedTools: opts.disallowedTools },
+        ...opts.effort && { effort: opts.effort },
         ...opts.maxTurns && { maxTurns: opts.maxTurns },
         systemPrompt: opts.systemPrompt ?? { type: "preset", preset: "claude_code" },
         ...options.workingDirectory && { cwd: options.workingDirectory },
@@ -205,6 +206,8 @@ function runClaude(options, callbacks) {
       abort: () => {
       },
       resolvePermission: () => {
+      },
+      setPermissionMode: async () => {
       }
     };
   }
@@ -286,6 +289,10 @@ function runClaude(options, callbacks) {
               };
               logger.info({ sessionId: sessionInfo.sessionId, commands: sessionInfo.slashCommands.length }, "New chat session info");
               callbacks.onSessionCreated(sessionInfo);
+            } else if (sys.subtype === "task_started" && callbacks.onTaskStarted) {
+              callbacks.onTaskStarted(sys.task_id, sys.description ?? "", sys.tool_use_id);
+            } else if (sys.subtype === "task_notification" && callbacks.onTaskNotification) {
+              callbacks.onTaskNotification(sys.task_id, sys.status ?? "completed", sys.summary ?? "", sys.tool_use_id);
             }
             break;
           }
@@ -316,7 +323,8 @@ function runClaude(options, callbacks) {
     },
     resolvePermission: (toolUseId, allow, answers, feedback) => {
       pendingPermissions.get(toolUseId)?.({ allow, answers, feedback });
-    }
+    },
+    setPermissionMode: (mode) => q.setPermissionMode(mode)
   };
 }
 
@@ -504,12 +512,41 @@ async function loadSession(sessionId) {
     const sessionPath = join2(CLAUDE_DIR, projectDir, sessionFile);
     try {
       const content = await readFile2(sessionPath, "utf-8");
-      return parseSessionFile(content);
+      const messages = parseSessionFile(content);
+      const subagentsDir = join2(CLAUDE_DIR, projectDir, sessionId, "subagents");
+      await attachSubagentData(messages, subagentsDir);
+      return messages;
     } catch {
     }
   }
   return null;
 }
+var AGENT_ID_RE = /agentId: (\w+)/;
+async function attachSubagentData(messages, subagentsDir) {
+  const taskBlocks = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    const blocks = msg.content;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (block.type !== "tool_use" || block.name !== "Task") continue;
+      const result = block.result;
+      if (typeof result !== "string") continue;
+      const match = result.match(AGENT_ID_RE);
+      if (match) {
+        taskBlocks.push({ block, agentId: match[1] });
+      }
+    }
+  }
+  if (taskBlocks.length === 0) return;
+  await Promise.all(taskBlocks.map(async ({ block, agentId }) => {
+    try {
+      const content = await readFile2(join2(subagentsDir, `agent-${agentId}.jsonl`), "utf-8");
+      block.subagentMessages = parseSessionFile(content);
+    } catch {
+    }
+  }));
+}
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function isValidSessionUUID(name) {
   return UUID_RE.test(name);
@@ -773,8 +810,8 @@ function parseSessionFile(content) {
         if (toolUse) {
           if (dataUri) toolUse.imageUri = dataUri;
           if (resultText) toolUse.result = resultText;
+          break;
         }
-        break;
       }
     }
   }
@@ -907,7 +944,7 @@ function escapeRegex(str) {
 
 // src/lib/directory-discovery.ts
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-async function findProjectDirectory(description, searchRoot, rejections) {
+async function findProjectDirectory(description, searchRoot, rejections, signal) {
   let prompt2 = `Find up to 3 project directories on this machine that best match: "${description}"
 
 Search starting from ${searchRoot}. Rank by relevance. Include a brief reason for each match.`;
@@ -953,6 +990,8 @@ Search starting from ${searchRoot}. Rank by relevance. Include a brief reason fo
       }
     }
   });
+  const onAbort = () => q.close();
+  signal?.addEventListener("abort", onAbort, { once: true });
   try {
     for await (const msg of q) {
       if (msg.type === "result") {
@@ -965,10 +1004,10 @@ Search starting from ${searchRoot}. Rank by relevance. Include a brief reason fo
           }
           const result = resultMsg.result?.trim();
           if (result && result !== "null" && result.startsWith("/")) {
-            const path3 = result.split("\n")[0].trim();
-            const name = path3.split("/").pop() ?? path3;
-            logger.info({ path: path3, name }, "Project directory found (text fallback)");
-            return [{ path: path3, name, reason: "Best match" }];
+            const path4 = result.split("\n")[0].trim();
+            const name = path4.split("/").pop() ?? path4;
+            logger.info({ path: path4, name }, "Project directory found (text fallback)");
+            return [{ path: path4, name, reason: "Best match" }];
           }
           logger.info("No matching directories found");
           return [];
@@ -978,11 +1017,82 @@ Search starting from ${searchRoot}. Rank by relevance. Include a brief reason fo
       }
     }
   } finally {
+    signal?.removeEventListener("abort", onAbort);
+    q.close();
+  }
+  return [];
+}
+async function suggestProjectLocation(description, searchRoot, name, signal) {
+  const prompt2 = `Suggest up to 3 suitable locations on this machine to create a new project.
+
+User's description: "${description}"
+${name ? `Desired project name: "${name}"` : ""}
+
+Search starting from ${searchRoot}. Look at common project directories (e.g. ~/github, ~/projects, ~/code, ~/Desktop).
+For each suggestion, provide the full path WHERE the project folder would be created (including the project name as the last segment), a human-readable name, and a brief reason.`;
+  const q = query2({
+    prompt: prompt2,
+    options: {
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        append: "IMPORTANT: When searching for directories, always try listing likely parent directories with ls FIRST (e.g. ls ~/github, ls ~/projects). Only use find as a last resort, and always with -maxdepth 3. Never scan the entire home directory. The path in each suggestion must be the FULL path including the new project folder name."
+      },
+      permissionMode: "bypassPermissions",
+      persistSession: false,
+      cwd: searchRoot,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            suggestions: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  path: { type: "string", description: "Absolute path for the new project directory (including project folder name)" },
+                  name: { type: "string", description: "Human-readable project name" },
+                  reason: { type: "string", description: "Brief reason why this location is suitable" }
+                },
+                required: ["path", "name", "reason"]
+              }
+            }
+          },
+          required: ["suggestions"]
+        }
+      }
+    }
+  });
+  const onAbort = () => q.close();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for await (const msg of q) {
+      if (msg.type === "result") {
+        const resultMsg = msg;
+        if (resultMsg.subtype === "success") {
+          const structured = resultMsg.structured_output;
+          if (structured?.suggestions?.length) {
+            logger.info({ count: structured.suggestions.length }, "Location suggestions found (structured)");
+            return structured.suggestions;
+          }
+          logger.info("No location suggestions found");
+          return [];
+        }
+        logger.warn({ subtype: resultMsg.subtype }, "Location suggestion query failed");
+        return [];
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
     q.close();
   }
   return [];
 }
 
+// src/commands/connect.ts
+import path3 from "path";
+
 // src/lib/auth.ts
 import fs2 from "fs";
 import path2 from "path";
@@ -1167,6 +1277,16 @@ async function connect(server, options) {
     socket.emit("register", deviceInfo, (response) => {
       if (response.success) {
         logger.info({ deviceId }, "Registered");
+      } else {
+        logger.warn("Registration failed, retrying in 2s...");
+        setTimeout(() => {
+          if (socket.connected) {
+            socket.emit("register", collectDeviceInfo(deviceId, options.name, options.tag, defaultCwd), (r) => {
+              if (r.success) logger.info({ deviceId }, "Registered (retry)");
+              else logger.error("Registration failed after retry");
+            });
+          }
+        }, 2e3);
       }
     });
   });
@@ -1197,7 +1317,22 @@ async function connect(server, options) {
   });
   socket.on("find-project", (msg) => {
     if (msg.type === "find-project") {
-      handleFindProject(socket, msg, defaultCwd);
+      handleFindProject(socket, msg, defaultCwd, activeSessions);
+    }
+  });
+  socket.on("suggest-project-location", (msg) => {
+    if (msg.type === "suggest-project-location") {
+      handleSuggestProjectLocation(socket, msg, activeSessions);
+    }
+  });
+  socket.on("create-project", (msg) => {
+    if (msg.type === "create-project") {
+      handleCreateProject(socket, msg);
+    }
+  });
+  socket.on("check-path", (msg) => {
+    if (msg.type === "check-path") {
+      handleCheckPath(socket, msg);
     }
   });
   socket.on("cancel", (msg) => {
@@ -1205,9 +1340,13 @@ async function connect(server, options) {
   });
   socket.on("permission-response", (msg) => {
     const log2 = createChildLogger({ sessionId: msg.requestId });
-    log2.info({ toolUseId: msg.toolUseId, allowed: msg.allow }, msg.allow ? "Permission accepted" : "Permission denied");
+    log2.info({ toolUseId: msg.toolUseId, allowed: msg.allow, permissionMode: msg.permissionMode }, msg.allow ? "Permission accepted" : "Permission denied");
     const session = activeSessions.get(msg.requestId);
     if (session) {
+      if (msg.permissionMode) {
+        session.setPermissionMode(msg.permissionMode).catch(() => {
+        });
+      }
       session.resolvePermission(msg.toolUseId, msg.allow, msg.answers, msg.feedback);
     }
   });
@@ -1217,10 +1356,6 @@ async function connect(server, options) {
   socket.io.on("reconnect_attempt", () => {
     logger.info("Reconnecting...");
   });
-  socket.on("reconnect", (attemptNumber) => {
-    logger.info({ attemptNumber }, "Reconnected");
-    socket.emit("register", collectDeviceInfo(deviceId, options.name, options.tag, defaultCwd));
-  });
   socket.on("connect_error", (err) => {
     const { reason, ...detail } = formatConnectionError(err);
     logger.error(detail, `Connection error: ${reason}`);
@@ -1352,6 +1487,14 @@ function handlePrompt(socket, msg, activeSessions) {
           reason: req.reason,
           blockedPath: req.blockedPath
         });
+      },
+      onTaskStarted: (taskId, description, toolUseId) => {
+        log2.info({ taskId, toolUseId, description }, "Task started");
+        send(socket, "response", { type: "task_started", taskId, description, toolUseId, requestId: id });
+      },
+      onTaskNotification: (taskId, status, summary, toolUseId) => {
+        log2.info({ taskId, toolUseId, status, summary }, "Task notification");
+        send(socket, "response", { type: "task_notification", taskId, status, summary, toolUseId, requestId: id });
       }
     }
   );
@@ -1363,6 +1506,8 @@ function handleCancel(id, activeSessions) {
     session.abort();
     activeSessions.delete(id);
     logger.info({ sessionId: id }, "Session cancelled");
+  } else {
+    logger.warn({ sessionId: id }, "Cancel: session not found in activeSessions");
   }
 }
 async function handleListSessions(socket, msg, defaultCwd) {
@@ -1400,20 +1545,100 @@ async function handleGetCommands(socket, msg) {
     log2.error({ err }, "Commands error");
   }
 }
-async function handleFindProject(socket, msg, _defaultCwd) {
+async function handleFindProject(socket, msg, _defaultCwd, activeSessions) {
   const { id, description, rootDirectory, rejections } = msg;
   const searchRoot = rootDirectory ?? os3.homedir();
   const log2 = createChildLogger({ requestId: id });
   log2.info({ description, searchRoot }, "Finding project directory...");
+  const ac = new AbortController();
+  const handle = {
+    abort: () => ac.abort(),
+    resolvePermission: () => {
+    },
+    setPermissionMode: async () => {
+    }
+  };
+  activeSessions.set(id, handle);
   try {
-    const suggestions = await findProjectDirectory(description, searchRoot, rejections);
+    const suggestions = await findProjectDirectory(description, searchRoot, rejections, ac.signal);
     send(socket, "response", { type: "project_suggestions", suggestions, requestId: id });
     log2.info({ count: suggestions.length }, "Project suggestions sent");
   } catch (err) {
+    if (ac.signal.aborted) {
+      log2.info("Find project cancelled");
+      return;
+    }
     const message = err instanceof Error ? err.message : String(err);
     send(socket, "response", { type: "error", message, requestId: id });
     log2.error({ err }, "Find project error");
+  } finally {
+    activeSessions.delete(id);
+  }
+}
+async function handleSuggestProjectLocation(socket, msg, activeSessions) {
+  const { id, description, name, rootDirectory } = msg;
+  const searchRoot = rootDirectory ?? os3.homedir();
+  const log2 = createChildLogger({ requestId: id });
+  log2.info({ description, name, searchRoot }, "Suggesting project location...");
+  const ac = new AbortController();
+  const handle = {
+    abort: () => ac.abort(),
+    resolvePermission: () => {
+    },
+    setPermissionMode: async () => {
+    }
+  };
+  activeSessions.set(id, handle);
+  try {
+    const suggestions = await suggestProjectLocation(description, searchRoot, name, ac.signal);
+    send(socket, "response", { type: "project_suggestions", suggestions, requestId: id });
+    log2.info({ count: suggestions.length }, "Location suggestions sent");
+  } catch (err) {
+    if (ac.signal.aborted) {
+      log2.info("Suggest project location cancelled");
+      return;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    send(socket, "response", { type: "error", message, requestId: id });
+    log2.error({ err }, "Suggest project location error");
+  } finally {
+    activeSessions.delete(id);
+  }
+}
+function handleCreateProject(socket, msg) {
+  const { id, path: projectPath } = msg;
+  const log2 = createChildLogger({ requestId: id });
+  log2.info({ path: projectPath }, "Creating project directory...");
+  try {
+    fs3.mkdirSync(projectPath, { recursive: true });
+    send(socket, "response", { type: "project_created", path: projectPath, requestId: id });
+    log2.info({ path: projectPath }, "Project directory created");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    send(socket, "response", { type: "error", message, requestId: id });
+    log2.error({ err }, "Create project error");
+  }
+}
+function handleCheckPath(socket, msg) {
+  const { id, path: checkTarget } = msg;
+  const log2 = createChildLogger({ requestId: id });
+  log2.info({ path: checkTarget }, "Checking path...");
+  let exists = false;
+  let isDirectory = false;
+  let parentExists = false;
+  try {
+    const stat2 = fs3.statSync(checkTarget);
+    exists = true;
+    isDirectory = stat2.isDirectory();
+  } catch {
+  }
+  try {
+    const parentStat = fs3.statSync(path3.dirname(checkTarget));
+    parentExists = parentStat.isDirectory();
+  } catch {
   }
+  send(socket, "response", { type: "path_check", exists, isDirectory, parentExists, requestId: id });
+  log2.info({ exists, isDirectory, parentExists }, "Path check complete");
 }
 async function handleGetContext(socket, msg, defaultCwd) {
   const { id, sessionId } = msg;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punkcode/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Control Claude Code from your phone",
   "type": "module",
   "bin": {
@@ -53,8 +53,8 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.37",
-    "@anthropic-ai/sdk": "^0.72.1",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.49",
+    "@anthropic-ai/sdk": "^0.78.0",
     "commander": "^14.0.3",
     "execa": "^9.6.1",
     "pino": "^10.3.1",