anywhere-ai 0.0.26 → 0.0.27

package/dist/cli.js

@@ -12,11 +12,11 @@ import qrcode from "qrcode";
 var args = process.argv.slice(2);
 var command = args.find((a) => !a.startsWith("-"));
 if (args.includes("--version") || args.includes("-v")) {
-  console.log(`anywhere-ai v${"0.0.26"}`);
+  console.log(`anywhere-ai v${"0.0.27"}`);
   process.exit(0);
 }
 if (args.includes("--help") || args.includes("-h") || command === "help") {
-  console.log(`anywhere-ai v${"0.0.26"} \u2014 Mobile coding agent
+  console.log(`anywhere-ai v${"0.0.27"} \u2014 Mobile coding agent
 
 Usage: anywhere-ai [command] [options]
 

package/dist/server.js

@@ -67,6 +67,8 @@ async function getCwdFromJSONL(sessionId) {
 }
 var activeSessions = /* @__PURE__ */ new Set();
 var pendingPermissions = /* @__PURE__ */ new Map();
+var permissionToolUseIDs = /* @__PURE__ */ new Map();
+var permissionInputs = /* @__PURE__ */ new Map();
 function getAssistantText(msg) {
   if (msg.type !== "assistant") return null;
   return msg.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
@@ -83,22 +85,33 @@ var permReqCounter = 0;
 function makeCanUseTool(sessionHint, permissionMode) {
   return async (toolName, input, options) => {
     const requestId = `perm_${++permReqCounter}_${Date.now()}`;
+    console.log(`[perm] canUseTool: ${toolName} requestId=${requestId}`);
     const req = {
       requestId,
       toolName,
       input,
       description: input.description,
       decisionReason: options.decisionReason,
-      suggestions: options.suggestions
+      suggestions: options.suggestions,
+      toolUseID: options.toolUseID
     };
     const cb = permissionCallbacks.get(sessionHint);
-    if (cb) cb(req);
+    if (cb) {
+      cb(req);
+    } else {
+      console.log(`[perm] WARNING: no callback for session=${sessionHint}, requestId=${requestId}`);
+    }
+    if (options.toolUseID) permissionToolUseIDs.set(requestId, options.toolUseID);
+    permissionInputs.set(requestId, input);
     return new Promise((resolve) => {
       pendingPermissions.set(requestId, resolve);
       const timeout = setTimeout(
         () => {
           if (pendingPermissions.has(requestId)) {
             pendingPermissions.delete(requestId);
+            permissionToolUseIDs.delete(requestId);
+            permissionInputs.delete(requestId);
+            console.log(`[perm] TIMEOUT: ${requestId}`);
             resolve({
               behavior: "deny",
               message: "Permission request timed out"
@@ -111,13 +124,18 @@ function makeCanUseTool(sessionHint, permissionMode) {
         clearTimeout(timeout);
         if (pendingPermissions.has(requestId)) {
           pendingPermissions.delete(requestId);
+          permissionToolUseIDs.delete(requestId);
+          console.log(`[perm] ABORT: ${requestId}`);
           resolve({ behavior: "deny", message: "Request aborted" });
+        } else {
         }
       });
       const origResolve = resolve;
       pendingPermissions.set(requestId, (result) => {
         clearTimeout(timeout);
         pendingPermissions.delete(requestId);
+        permissionToolUseIDs.delete(requestId);
+        console.log(`[perm] resolved: ${requestId} \u2192 ${result.behavior}`);
         origResolve(result);
       });
     });
@@ -145,21 +163,22 @@ var createChat = async ({
   model,
   permission,
   repo,
-  prompt
+  prompt,
+  tempId
 }) => {
   const repoPath = repo ? await setupRepo(repo) : void 0;
-  const tempId = `temp_${Date.now()}`;
+  const id = tempId || `temp_${Date.now()}`;
   const mode = permission || "acceptEdits";
   const session = await withCwd(
     repoPath,
     () => unstable_v2_createSession({
       model: model || "claude-opus-4-6",
       permissionMode: mode,
-      canUseTool: makeCanUseTool(tempId, mode)
+      canUseTool: makeCanUseTool(id, mode)
     })
   );
-  if (repoPath) sessionCwds.set(tempId, repoPath);
-  return { session, tempId, repoPath };
+  if (repoPath) sessionCwds.set(id, repoPath);
+  return { session, tempId: id, repoPath };
 };
 var sendMessage = async ({
   prompt,
@@ -173,31 +192,26 @@ var getSession = async ({
   permission,
   cwd
 }) => {
-  let session = sessions.get(sessionId);
-  const currentConfig = sessionConfig.get(sessionId);
-  const requestedModel = model || "claude-opus-4-6";
-  const requestedPermission = permission || "acceptEdits";
-  const configChanged = session && currentConfig && (requestedModel !== currentConfig.model || requestedPermission !== currentConfig.permission);
-  if (session && configChanged) {
-    session.close();
+  const existing = sessions.get(sessionId);
+  if (existing) {
+    existing.close();
     sessions.delete(sessionId);
     sessionConfig.delete(sessionId);
-    session = void 0;
-  }
-  if (!session) {
-    const sessionCwd = cwd || sessionCwds.get(sessionId) || await getCwdFromJSONL(sessionId);
-    session = await withCwd(
-      sessionCwd,
-      () => unstable_v2_resumeSession(sessionId, {
-        model: requestedModel,
-        permissionMode: requestedPermission,
-        canUseTool: makeCanUseTool(sessionId, requestedPermission)
-      })
-    );
-    sessions.set(sessionId, session);
-    sessionConfig.set(sessionId, { model: requestedModel, permission: requestedPermission });
-    if (sessionCwd) sessionCwds.set(sessionId, sessionCwd);
   }
+  const requestedModel = model || "claude-opus-4-6";
+  const requestedPermission = permission || "acceptEdits";
+  const sessionCwd = cwd || sessionCwds.get(sessionId) || await getCwdFromJSONL(sessionId);
+  const session = await withCwd(
+    sessionCwd,
+    () => unstable_v2_resumeSession(sessionId, {
+      model: requestedModel,
+      permissionMode: requestedPermission,
+      canUseTool: makeCanUseTool(sessionId, requestedPermission)
+    })
+  );
+  sessions.set(sessionId, session);
+  sessionConfig.set(sessionId, { model: requestedModel, permission: requestedPermission });
+  if (sessionCwd) sessionCwds.set(sessionId, sessionCwd);
   return session;
 };
 
@@ -365,13 +379,14 @@ chats.post("/new", async (c) => {
   const { prompt, model, permission, repo } = await c.req.json();
   if (!prompt) return c.json({ error: "Prompt is required" }, 400);
   try {
-    const { session, tempId, repoPath } = await createChat({ model, permission, repo, prompt });
-    await sendMessage({ prompt, session });
-    return streamSSE(c, async (stream) => {
-      let finalSessionId = "";
-      const sendPerm = async (req) => {
+    const tempId = `temp_${Date.now()}`;
+    let finalSessionId = "";
+    const pendingPermQueue = [];
+    let sseStream = null;
+    const permCallback = async (req) => {
+      if (sseStream) {
         try {
-          await stream.writeSSE({
+          await sseStream.writeSSE({
             data: JSON.stringify({
               type: "permission_request",
               ...req,
@@ -381,14 +396,31 @@ chats.post("/new", async (c) => {
         } catch (e) {
           console.error("Failed to send permission SSE:", e);
         }
-      };
-      setPermissionCallback(tempId, sendPerm);
+      } else {
+        pendingPermQueue.push(req);
+      }
+    };
+    setPermissionCallback(tempId, permCallback);
+    const { session, repoPath } = await createChat({ model, permission, repo, prompt, tempId });
+    await sendMessage({ prompt, session });
+    return streamSSE(c, async (stream) => {
+      sseStream = stream;
+      for (const req of pendingPermQueue) {
+        try {
+          await stream.writeSSE({
+            data: JSON.stringify({ type: "permission_request", ...req, sessionId: finalSessionId || "pending" })
+          });
+        } catch (e) {
+          console.error(`[perm] flush failed: ${req.requestId}`, e);
+        }
+      }
+      pendingPermQueue.length = 0;
       try {
         for await (const msg of session.stream()) {
           if (msg.session_id && !finalSessionId) {
             finalSessionId = msg.session_id;
             activeSessions.add(finalSessionId);
-            setPermissionCallback(finalSessionId, sendPerm);
+            setPermissionCallback(finalSessionId, permCallback);
           }
           const text = getAssistantText(msg);
           if (text)
@@ -433,26 +465,50 @@ chats.post("/:id/message", async (c) => {
   if (!prompt || !sessionId || /[\/\\]/.test(sessionId))
     return c.json({ error: "Invalid request" }, 400);
   try {
+    const pendingPermQueue = [];
+    let sseStream = null;
+    setPermissionCallback(sessionId, async (req) => {
+      if (sseStream) {
+        try {
+          await sseStream.writeSSE({
+            data: JSON.stringify({ type: "permission_request", ...req, sessionId })
+          });
+        } catch (e) {
+          console.error(`[perm] SSE write failed: ${req.requestId}`, e);
+        }
+      } else {
+        pendingPermQueue.push(req);
+      }
+    });
     const session = await getSession({ sessionId, model, permission });
     if (!session) return c.json({ error: "Session is required" }, 400);
     await sendMessage({ prompt, session });
     return streamSSE(c, async (stream) => {
       activeSessions.add(sessionId);
-      setPermissionCallback(sessionId, async (req) => {
+      sseStream = stream;
+      for (const req of pendingPermQueue) {
         try {
           await stream.writeSSE({
-            data: JSON.stringify({
-              type: "permission_request",
-              ...req,
-              sessionId
-            })
+            data: JSON.stringify({ type: "permission_request", ...req, sessionId })
           });
         } catch (e) {
-          console.error("Failed to send permission SSE:", e);
+          console.error(`[perm] flush failed: ${req.requestId}`, e);
         }
-      });
+      }
+      pendingPermQueue.length = 0;
       try {
         for await (const msg of session.stream()) {
+          const blocks = msg.message?.content;
+          if (Array.isArray(blocks)) {
+            for (const b of blocks) {
+              if (b.type === "tool_use") {
+                console.log(`[stream] tool_use: ${b.name}`);
+              } else if (b.type === "tool_result" && b.is_error) {
+                const resultText = Array.isArray(b.content) ? b.content.filter((r) => r.type === "text").map((r) => r.text).join("").slice(0, 1e3) : String(b.content ?? "").slice(0, 1e3);
+                console.log(`[stream] tool_result ERROR: ${resultText.slice(0, 500)}`);
+              }
+            }
+          }
           const text = getAssistantText(msg);
           if (text)
             await stream.writeSSE({
@@ -470,6 +526,7 @@ chats.post("/:id/message", async (c) => {
         generateChatName(prompt, sessionId).catch(() => {
         });
       } finally {
+        sseStream = null;
         setPermissionCallback(sessionId, null);
         activeSessions.delete(sessionId);
       }
@@ -484,13 +541,13 @@ chats.post("/:id/permission", async (c) => {
   if (!requestId || !behavior)
     return c.json({ error: "requestId and behavior are required" }, 400);
   const resolve = pendingPermissions.get(requestId);
-  if (!resolve)
+  if (!resolve) {
+    console.log(`[perm] no pending request: ${requestId}`);
     return c.json({ error: "No pending permission request found" }, 404);
+  }
   if (behavior === "allow") {
-    resolve({
-      behavior: "allow",
-      ...updatedPermissions ? { updatedPermissions } : {}
-    });
+    const originalInput = permissionInputs.get(requestId) || {};
+    resolve({ behavior: "allow", updatedInput: originalInput, ...updatedPermissions ? { updatedPermissions } : {} });
   } else {
     resolve({ behavior: "deny", message: "User denied permission" });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anywhere-ai",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "type": "module",
   "description": "Code on any repo from your phone",
   "bin": {