anywhere-ai 0.0.22 → 0.0.24

package/dist/cli.js

@@ -11,7 +11,7 @@ import readline from "readline";
 import qrcode from "qrcode";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
-  console.log(`anywhere-ai v${"0.0.22"}`);
+  console.log(`anywhere-ai v${"0.0.24"}`);
   process.exit(0);
 }
 function ask(question, preserveCase = false) {
@@ -170,7 +170,39 @@ try {
 } catch {
 }
 var isVPS = publicIP && localIP && publicIP !== localIP;
-await import("./server-SPM3PZ5G.js");
+var MAX_RESTARTS = 5;
+var RESTART_WINDOW = 6e4;
+var RESTART_DELAY = 2e3;
+var restartTimestamps = [];
+var intentionalShutdown = false;
+var serverProcess = null;
+function startServer() {
+  const serverPath = new URL("./server.js", import.meta.url).pathname;
+  serverProcess = spawn(process.execPath, [serverPath], {
+    stdio: "inherit",
+    env: { ...process.env }
+  });
+  serverProcess.on("exit", (code, signal) => {
+    serverProcess = null;
+    if (intentionalShutdown) return;
+    const now = Date.now();
+    restartTimestamps.push(now);
+    while (restartTimestamps.length > 0 && now - restartTimestamps[0] > RESTART_WINDOW) {
+      restartTimestamps.shift();
+    }
+    if (restartTimestamps.length >= MAX_RESTARTS) {
+      console.error(`
+Server crashed ${MAX_RESTARTS} times in ${RESTART_WINDOW / 1e3}s. Giving up.`);
+      cleanup();
+      return;
+    }
+    console.log(`
+Server exited (code=${code}, signal=${signal}). Restarting in ${RESTART_DELAY / 1e3}s...`);
+    setTimeout(startServer, RESTART_DELAY);
+  });
+}
+startServer();
+await new Promise((resolve) => setTimeout(resolve, 1e3));
 var tunnelURL = null;
 var tunnelProcess = null;
 async function printBanner(serverURL2, localURL2) {
@@ -218,11 +250,12 @@ if (!args.includes("--no-tunnel")) {
     }
   }
   if (cloudflaredBin) {
-    console.log("Starting tunnel...");
+    process.stdout.write("Starting tunnel");
     const tunnelArgs = cloudflaredBin === "npx" ? ["cloudflared", "tunnel", "--url", `http://localhost:${port}`] : ["tunnel", "--url", `http://localhost:${port}`];
     tunnelProcess = spawn(cloudflaredBin, tunnelArgs, {
       stdio: ["ignore", "pipe", "pipe"]
     });
+    const dots = setInterval(() => process.stdout.write("."), 1e3);
     tunnelURL = await new Promise((resolve) => {
       const timeout = setTimeout(() => resolve(null), 15e3);
       const urlRegex = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
@@ -247,10 +280,11 @@ if (!args.includes("--no-tunnel")) {
         resolve(null);
       });
     });
+    clearInterval(dots);
     if (tunnelURL) {
-      console.log("Tunnel established!");
+      console.log(" done!");
     } else {
-      console.log("Tunnel failed, using local address.");
+      console.log(" failed, using local address.");
     }
   }
 }
@@ -258,6 +292,11 @@ var localURL = isVPS ? "http://" + publicIP + ":" + port : "http://" + (localIP
 var serverURL = tunnelURL || localURL;
 await printBanner(serverURL, localURL);
 function cleanup() {
+  intentionalShutdown = true;
+  if (serverProcess) {
+    serverProcess.kill();
+    serverProcess = null;
+  }
   if (tunnelProcess) {
     tunnelProcess.kill();
     tunnelProcess = null;

package/dist/server.js

@@ -0,0 +1,901 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { Hono as Hono4 } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+
+// src/routes/chats/index.ts
+import { Hono } from "hono";
+import os3 from "os";
+import path3 from "path";
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { execSync as execSync2 } from "child_process";
+import { streamSSE } from "hono/streaming";
+
+// src/chats.ts
+import {
+  unstable_v2_createSession,
+  unstable_v2_resumeSession
+} from "@anthropic-ai/claude-agent-sdk";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { execSync } from "child_process";
+import generate from "@good-ghosting/random-name-generator";
+var ANYWHERE_DIR = path.join(os.homedir(), ".anywhere");
+var cwdLock = Promise.resolve();
+function withCwd(cwd, fn) {
+  const prev = cwdLock;
+  let release;
+  cwdLock = new Promise((r) => release = r);
+  return prev.then(() => {
+    const original = process.cwd();
+    if (cwd) process.chdir(cwd);
+    try {
+      return fn();
+    } finally {
+      if (cwd) process.chdir(original);
+      release();
+    }
+  });
+}
+var PROJECTS_DIR = path.join(ANYWHERE_DIR, "projects");
+var WORKTREES_DIR = path.join(ANYWHERE_DIR, "worktrees");
+var sessions = /* @__PURE__ */ new Map();
+var sessionConfig = /* @__PURE__ */ new Map();
+var sessionCwds = /* @__PURE__ */ new Map();
+async function getCwdFromJSONL(sessionId) {
+  const projectsBase = path.join(os.homedir(), ".claude", "projects");
+  try {
+    const dirs = await fs.readdir(projectsBase);
+    for (const dir of dirs) {
+      const filePath = path.join(projectsBase, dir, `${sessionId}.jsonl`);
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        for (const line of content.split("\n")) {
+          if (!line) continue;
+          const obj = JSON.parse(line);
+          if (obj.type === "user" && obj.cwd) return obj.cwd;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+var activeSessions = /* @__PURE__ */ new Set();
+var pendingPermissions = /* @__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("");
+}
+var permissionCallbacks = /* @__PURE__ */ new Map();
+function setPermissionCallback(sessionId, cb) {
+  if (cb) {
+    permissionCallbacks.set(sessionId, cb);
+  } else {
+    permissionCallbacks.delete(sessionId);
+  }
+}
+var permReqCounter = 0;
+function makeCanUseTool(sessionHint, permissionMode) {
+  return async (toolName, input, options) => {
+    const requestId = `perm_${++permReqCounter}_${Date.now()}`;
+    const req = {
+      requestId,
+      toolName,
+      input,
+      description: input.description,
+      decisionReason: options.decisionReason,
+      suggestions: options.suggestions
+    };
+    const cb = permissionCallbacks.get(sessionHint);
+    if (cb) cb(req);
+    return new Promise((resolve) => {
+      pendingPermissions.set(requestId, resolve);
+      const timeout = setTimeout(
+        () => {
+          if (pendingPermissions.has(requestId)) {
+            pendingPermissions.delete(requestId);
+            resolve({
+              behavior: "deny",
+              message: "Permission request timed out"
+            });
+          }
+        },
+        5 * 60 * 1e3
+      );
+      options.signal.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        if (pendingPermissions.has(requestId)) {
+          pendingPermissions.delete(requestId);
+          resolve({ behavior: "deny", message: "Request aborted" });
+        }
+      });
+      const origResolve = resolve;
+      pendingPermissions.set(requestId, (result) => {
+        clearTimeout(timeout);
+        pendingPermissions.delete(requestId);
+        origResolve(result);
+      });
+    });
+  };
+}
+var setupRepo = async (repo) => {
+  await fs.mkdir(PROJECTS_DIR, { recursive: true });
+  await fs.mkdir(WORKTREES_DIR, { recursive: true });
+  const repoPath = path.join(PROJECTS_DIR, repo);
+  try {
+    await fs.access(repoPath);
+    execSync("git fetch origin", { cwd: repoPath, encoding: "utf-8" });
+  } catch {
+    execSync(`gh repo clone ${repo} ${repoPath}`, { encoding: "utf-8" });
+  }
+  const branchName = generate({ words: 3 }).dashed;
+  const worktreePath = path.join(WORKTREES_DIR, branchName);
+  execSync(`git worktree add ${worktreePath} -b ${branchName}`, {
+    cwd: repoPath,
+    encoding: "utf-8"
+  });
+  return worktreePath;
+};
+var createChat = async ({
+  model,
+  permission,
+  repo,
+  prompt
+}) => {
+  const repoPath = repo ? await setupRepo(repo) : void 0;
+  const 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)
+    })
+  );
+  if (repoPath) sessionCwds.set(tempId, repoPath);
+  return { session, tempId, repoPath };
+};
+var sendMessage = async ({
+  prompt,
+  session
+}) => {
+  await session.send(prompt);
+};
+var getSession = async ({
+  sessionId,
+  model,
+  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();
+    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);
+  }
+  return session;
+};
+
+// src/chat-names.ts
+import { unstable_v2_prompt } from "@anthropic-ai/claude-agent-sdk";
+import { mkdir, readFile, writeFile, readdir, stat, unlink } from "fs/promises";
+import path2 from "path";
+import os2 from "os";
+var ANYWHERE_DIR2 = path2.join(os2.homedir(), ".anywhere");
+var NAMES_FILE = path2.join(ANYWHERE_DIR2, "chat-names.json");
+var CLAUDE_PROJECTS_DIR = path2.join(os2.homedir(), ".claude", "projects");
+var chatNames = {};
+var loaded = false;
+var pendingNames = /* @__PURE__ */ new Set();
+var TRIVIAL_RE = /^(hi|hey|hello|sup|yo|what'?s\s*up|greetings|hola|howdy|gm|good\s*(morning|afternoon|evening))[\s!?.,:]*$/i;
+function isTrivialPrompt(prompt) {
+  return TRIVIAL_RE.test(prompt.trim());
+}
+async function ensureDir() {
+  await mkdir(ANYWHERE_DIR2, { recursive: true });
+}
+async function load() {
+  if (loaded) return;
+  await ensureDir();
+  try {
+    chatNames = JSON.parse(await readFile(NAMES_FILE, "utf-8"));
+  } catch {
+    chatNames = {};
+  }
+  loaded = true;
+}
+async function saveNames() {
+  await ensureDir();
+  await writeFile(NAMES_FILE, JSON.stringify(chatNames, null, 2));
+}
+async function getChatName(sessionId) {
+  await load();
+  return chatNames[sessionId];
+}
+async function getAllChatNames() {
+  await load();
+  return { ...chatNames };
+}
+async function cleanupNamegenJsonl(namegenSessionId) {
+  try {
+    const dirs = await readdir(CLAUDE_PROJECTS_DIR);
+    for (const dir of dirs) {
+      const filePath = path2.join(CLAUDE_PROJECTS_DIR, dir, `${namegenSessionId}.jsonl`);
+      try {
+        await stat(filePath);
+        await unlink(filePath);
+        return;
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+async function generateChatName(prompt, sessionId) {
+  if (isTrivialPrompt(prompt)) return;
+  await load();
+  if (chatNames[sessionId]) return;
+  if (pendingNames.has(sessionId)) return;
+  pendingNames.add(sessionId);
+  try {
+    const namePrompt = `Generate a concise 3-6 word title for a coding chat that starts with this message. Output ONLY the title, nothing else. No quotes, no punctuation at the end.
+
+${prompt.slice(0, 500)}`;
+    const result = await unstable_v2_prompt(namePrompt, {
+      model: "claude-haiku-4-5"
+    });
+    if (result.subtype === "success") {
+      cleanupNamegenJsonl(result.session_id);
+      const name = result.result.trim().replace(/^["']|["']$/g, "").trim();
+      if (name && name.length > 0 && name.length < 80) {
+        chatNames[sessionId] = name;
+        await saveNames();
+      }
+    }
+  } catch (err) {
+    console.error(`[chatName] failed for ${sessionId}:`, err);
+  } finally {
+    pendingNames.delete(sessionId);
+  }
+}
+
+// src/routes/chats/index.ts
+var repoNameCache = /* @__PURE__ */ new Map();
+function isHomeDir(dir) {
+  const home = os3.homedir();
+  if (dir === home) return true;
+  if (dir === "/root" || dir === "/") return true;
+  if (/^\/home\/[^/]+\/?$/.test(dir)) return true;
+  if (/^\/Users\/[^/]+\/?$/.test(dir)) return true;
+  return false;
+}
+function deriveRepoName(cwd) {
+  if (!cwd) return "";
+  if (repoNameCache.has(cwd)) return repoNameCache.get(cwd);
+  if (isHomeDir(cwd)) {
+    repoNameCache.set(cwd, "");
+    return "";
+  }
+  let name = "";
+  let tryDir = cwd;
+  let foundGit = false;
+  while (tryDir && !isHomeDir(tryDir) && tryDir !== "/") {
+    try {
+      const url = execSync2("git remote get-url origin 2>/dev/null", {
+        cwd: tryDir,
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      const match = url.match(/[:/]([^/]+\/[^/.]+?)(?:\.git)?$/);
+      if (match?.[1]) name = match[1];
+      foundGit = true;
+      break;
+    } catch {
+      const parent = path3.dirname(tryDir);
+      if (parent === tryDir) break;
+      tryDir = parent;
+    }
+  }
+  if (!foundGit) {
+    tryDir = cwd;
+    while (tryDir && !isHomeDir(tryDir) && tryDir !== "/") {
+      try {
+        const root = execSync2("git rev-parse --show-toplevel 2>/dev/null", {
+          cwd: tryDir,
+          encoding: "utf-8",
+          timeout: 3e3
+        }).trim();
+        if (!isHomeDir(root)) {
+          name = root.split("/").filter(Boolean).pop() || "";
+        }
+        break;
+      } catch {
+        const parent = path3.dirname(tryDir);
+        if (parent === tryDir) break;
+        tryDir = parent;
+      }
+    }
+  }
+  repoNameCache.set(cwd, name);
+  return name;
+}
+async function findSessionFile(sessionId) {
+  const projectsBase = path3.join(os3.homedir(), ".claude", "projects");
+  try {
+    const dirs = await readdir2(projectsBase);
+    for (const dir of dirs) {
+      const filePath = path3.join(projectsBase, dir, `${sessionId}.jsonl`);
+      try {
+        await stat2(filePath);
+        return filePath;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+var chats = new Hono();
+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) => {
+        try {
+          await stream.writeSSE({
+            data: JSON.stringify({
+              type: "permission_request",
+              ...req,
+              sessionId: finalSessionId || "pending"
+            })
+          });
+        } catch (e) {
+          console.error("Failed to send permission SSE:", e);
+        }
+      };
+      setPermissionCallback(tempId, sendPerm);
+      try {
+        for await (const msg of session.stream()) {
+          if (msg.session_id && !finalSessionId) {
+            finalSessionId = msg.session_id;
+            activeSessions.add(finalSessionId);
+            setPermissionCallback(finalSessionId, sendPerm);
+          }
+          const text = getAssistantText(msg);
+          if (text)
+            await stream.writeSSE({
+              data: JSON.stringify({
+                response: text.trim(),
+                sessionId: msg.session_id
+              })
+            });
+        }
+        if (finalSessionId) {
+          sessions.set(finalSessionId, session);
+          sessionConfig.set(finalSessionId, {
+            model: model || "claude-opus-4-6",
+            permission: permission || "acceptEdits"
+          });
+          if (repoPath) sessionCwds.set(finalSessionId, repoPath);
+          generateChatName(prompt, finalSessionId).catch(() => {
+          });
+        }
+      } catch (err) {
+        console.error(err);
+        await stream.writeSSE({
+          data: JSON.stringify({ error: "Stream error" })
+        });
+      } finally {
+        setPermissionCallback(tempId, null);
+        if (finalSessionId) {
+          setPermissionCallback(finalSessionId, null);
+          activeSessions.delete(finalSessionId);
+        }
+      }
+    });
+  } catch (error) {
+    console.error(error);
+    return c.json({ error: "Failed to create new chat" }, 400);
+  }
+});
+chats.post("/:id/message", async (c) => {
+  const { prompt, model, permission } = await c.req.json();
+  const sessionId = c.req.param("id");
+  if (!prompt || !sessionId || /[\/\\]/.test(sessionId))
+    return c.json({ error: "Invalid request" }, 400);
+  try {
+    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) => {
+        try {
+          await stream.writeSSE({
+            data: JSON.stringify({
+              type: "permission_request",
+              ...req,
+              sessionId
+            })
+          });
+        } catch (e) {
+          console.error("Failed to send permission SSE:", e);
+        }
+      });
+      try {
+        for await (const msg of session.stream()) {
+          const text = getAssistantText(msg);
+          if (text)
+            await stream.writeSSE({
+              data: JSON.stringify({
+                response: text?.trim() || null,
+                sessionId: msg.session_id
+              })
+            });
+        }
+      } catch (err) {
+        console.error(err);
+        await stream.writeSSE({
+          data: JSON.stringify({ error: "Stream error" })
+        });
+        generateChatName(prompt, sessionId).catch(() => {
+        });
+      } finally {
+        setPermissionCallback(sessionId, null);
+        activeSessions.delete(sessionId);
+      }
+    });
+  } catch (error) {
+    console.error(error);
+    return c.json({ error: "Failed to send message" }, 400);
+  }
+});
+chats.post("/:id/permission", async (c) => {
+  const { requestId, behavior, updatedPermissions } = await c.req.json();
+  if (!requestId || !behavior)
+    return c.json({ error: "requestId and behavior are required" }, 400);
+  const resolve = pendingPermissions.get(requestId);
+  if (!resolve)
+    return c.json({ error: "No pending permission request found" }, 404);
+  if (behavior === "allow") {
+    resolve({
+      behavior: "allow",
+      ...updatedPermissions ? { updatedPermissions } : {}
+    });
+  } else {
+    resolve({ behavior: "deny", message: "User denied permission" });
+  }
+  return c.json({ ok: true });
+});
+chats.get("/", async (c) => {
+  try {
+    const projectsBase = path3.join(os3.homedir(), ".claude", "projects");
+    const dirs = await readdir2(projectsBase);
+    const chatNamesMap = await getAllChatNames();
+    const allChats = [];
+    for (const dir of dirs) {
+      const dirPath = path3.join(projectsBase, dir);
+      try {
+        const s = await stat2(dirPath);
+        if (!s.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const files = (await readdir2(dirPath)).filter(
+        (f) => f.endsWith(".jsonl")
+      );
+      for (const file of files) {
+        const filePath = path3.join(dirPath, file);
+        const content = await readFile2(filePath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const sessionId = file.replace(".jsonl", "");
+        let preview = "";
+        let timestamp = "";
+        let cwd = "";
+        let gitBranch = "";
+        let lastMessage = "";
+        let lastTimestamp = "";
+        for (const line of lines) {
+          try {
+            const obj = JSON.parse(line);
+            if (obj.type === "user") {
+              if (!cwd && obj.cwd) cwd = obj.cwd;
+              if (!gitBranch && obj.gitBranch) gitBranch = obj.gitBranch;
+              if (!obj.isMeta) {
+                if (!preview) {
+                  const msgContent = obj.message.content;
+                  if (typeof msgContent === "string") {
+                    preview = msgContent.slice(0, 100);
+                  } else {
+                    preview = msgContent.filter((b) => b.type === "text").map((b) => b.text).join("").slice(0, 100);
+                  }
+                  timestamp = obj.timestamp;
+                }
+                if (obj.timestamp) lastTimestamp = obj.timestamp;
+              }
+            }
+            if (obj.type === "assistant") {
+              if (obj.timestamp) lastTimestamp = obj.timestamp;
+              const content2 = obj.message?.content;
+              if (typeof content2 === "string") {
+                lastMessage = content2.slice(0, 120);
+              } else if (Array.isArray(content2)) {
+                const text = content2.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+                if (text) lastMessage = text.slice(0, 120);
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (!timestamp) continue;
+        const fileStat = await stat2(filePath);
+        const updatedAt = lastTimestamp || fileStat.mtime.toISOString();
+        const repo = deriveRepoName(cwd);
+        allChats.push({
+          sessionId,
+          text: preview,
+          timestamp,
+          updatedAt,
+          lastMessage,
+          isActive: activeSessions.has(sessionId),
+          repo,
+          cwd,
+          gitBranch,
+          chatName: chatNamesMap[sessionId] || ""
+        });
+      }
+    }
+    return c.json({ result: allChats });
+  } catch (error) {
+    console.error("[GET /chats] error:", error);
+    return c.json({ result: [] });
+  }
+});
+chats.get("/:id", async (c) => {
+  const sessionId = c.req.param("id");
+  if (!sessionId || /[\/\\]/.test(sessionId))
+    return c.json({ error: "Invalid session id" }, 400);
+  try {
+    const file = await findSessionFile(sessionId);
+    if (!file) return c.json({ error: "Chat not found" }, 404);
+    const content = await readFile2(file, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const parsed = lines.map((line) => JSON.parse(line));
+    let model;
+    let permissionMode;
+    let cwd;
+    for (const obj of parsed) {
+      if (obj.type === "user" && obj.cwd && !cwd) cwd = obj.cwd;
+    }
+    for (const obj of [...parsed].reverse()) {
+      if (!model && obj.type === "assistant") model = obj.message?.model;
+      if (!permissionMode && obj.type === "user" && !obj.isMeta)
+        permissionMode = obj.permissionMode;
+      if (model && permissionMode) break;
+    }
+    const messages = parsed.filter(
+      (obj) => obj.type === "user" && !obj.isMeta || obj.type === "assistant"
+    ).flatMap((obj) => {
+      const content2 = obj.message.content;
+      if (typeof content2 === "string") {
+        return [
+          {
+            role: obj.message.role,
+            type: "text",
+            text: content2.trim(),
+            timestamp: obj.timestamp
+          }
+        ];
+      }
+      return content2.filter(
+        (b) => ["text", "tool_use", "tool_result"].includes(b.type)
+      ).map((b) => {
+        if (b.type === "text") {
+          return {
+            role: obj.message.role,
+            type: "text",
+            text: b.text.trim(),
+            timestamp: obj.timestamp
+          };
+        }
+        if (b.type === "tool_use") {
+          return {
+            role: obj.message.role,
+            type: "tool_use",
+            name: b.name,
+            input: b.input,
+            timestamp: obj.timestamp
+          };
+        }
+        if (b.type === "tool_result") {
+          const resultText = Array.isArray(b.content) ? b.content.filter((r) => r.type === "text").map((r) => r.text).join("") : b.content ?? "";
+          return {
+            role: obj.message.role,
+            type: "tool_result",
+            text: resultText.trim(),
+            timestamp: obj.timestamp
+          };
+        }
+      }).filter(Boolean);
+    });
+    const chatName = await getChatName(sessionId);
+    return c.json({ messages, model, permissionMode, cwd, chatName: chatName || "" });
+  } catch {
+    return c.json({ error: "Chat not found" }, 404);
+  }
+});
+
+// src/routes/git/index.ts
+import { Hono as Hono2 } from "hono";
+import { exec } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+import path4 from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function getRepoRoot(cwd) {
+  try {
+    const { stdout } = await execAsync("git rev-parse --show-toplevel", {
+      cwd: cwd || process.cwd()
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+var git = new Hono2();
+git.get("/status", async (c) => {
+  try {
+    const cwd = c.req.query("cwd");
+    const root = await getRepoRoot(cwd);
+    if (!root) return c.json({ files: [], error: "Not a git repository" });
+    const { stdout: statusOut } = await execAsync("git status --porcelain", {
+      cwd: root
+    });
+    const [{ stdout: unstagedNum }, { stdout: stagedNum }] = await Promise.all([
+      execAsync("git diff --numstat", { cwd: root }).catch(() => ({
+        stdout: ""
+      })),
+      execAsync("git diff --cached --numstat", { cwd: root }).catch(() => ({
+        stdout: ""
+      }))
+    ]);
+    const parseNumstat = (raw) => {
+      const map = /* @__PURE__ */ new Map();
+      for (const line of raw.split("\n").filter(Boolean)) {
+        const [add, del, file] = line.split("	");
+        if (file) {
+          map.set(file, {
+            additions: add === "-" ? 0 : parseInt(add, 10),
+            deletions: del === "-" ? 0 : parseInt(del, 10)
+          });
+        }
+      }
+      return map;
+    };
+    const unstagedStats = parseNumstat(unstagedNum);
+    const stagedStats = parseNumstat(stagedNum);
+    const files = [];
+    for (const line of statusOut.split("\n").filter(Boolean)) {
+      const xy = line.slice(0, 2);
+      const filePath = line.slice(3).trim();
+      let status = "M";
+      let staged = false;
+      if (xy === "??") {
+        status = "?";
+      } else if (xy === "!!") {
+        continue;
+      } else {
+        const indexStatus = xy[0];
+        const worktreeStatus = xy[1];
+        if (indexStatus !== " " && indexStatus !== "?") {
+          staged = true;
+          if (indexStatus === "A") status = "A";
+          else if (indexStatus === "D") status = "D";
+          else if (indexStatus === "R") status = "R";
+          else status = "M";
+        } else {
+          if (worktreeStatus === "D") status = "D";
+          else status = "M";
+        }
+      }
+      const stats = staged ? stagedStats.get(filePath) : unstagedStats.get(filePath);
+      let additions = stats?.additions ?? 0;
+      let deletions = stats?.deletions ?? 0;
+      if (status === "?") {
+        try {
+          const content = await readFile3(path4.join(root, filePath), "utf-8");
+          additions = content.split("\n").length;
+        } catch {
+          additions = 0;
+        }
+      }
+      files.push({ path: filePath, status, staged, additions, deletions });
+    }
+    return c.json({ files });
+  } catch (error) {
+    console.error("git status error:", error);
+    return c.json({ files: [] });
+  }
+});
+git.get("/diff", async (c) => {
+  const filePath = c.req.query("file");
+  if (!filePath) return c.json({ error: "file parameter required" }, 400);
+  if (filePath.includes("..")) return c.json({ error: "Invalid path" }, 400);
+  const cwd = c.req.query("cwd");
+  const root = await getRepoRoot(cwd);
+  if (!root) return c.json({ error: "Not a git repository" }, 400);
+  const safePath = filePath.replace(/'/g, "'\\''");
+  try {
+    let oldContent = "";
+    let newContent = "";
+    try {
+      const { stdout } = await execAsync(`git show 'HEAD:${safePath}'`, {
+        cwd: root,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      oldContent = stdout;
+    } catch {
+      oldContent = "";
+    }
+    try {
+      newContent = await readFile3(path4.join(root, filePath), "utf-8");
+    } catch (e) {
+      console.error("readFile error for", filePath, e);
+      newContent = "";
+    }
+    return c.json({ path: filePath, oldContent, newContent });
+  } catch (error) {
+    console.error("git diff error:", error);
+    return c.json({ error: "Failed to get diff" }, 500);
+  }
+});
+git.get("/branch", async (c) => {
+  try {
+    const cwd = c.req.query("cwd");
+    const root = await getRepoRoot(cwd);
+    if (!root) return c.json({ error: "Not a git repository" }, 400);
+    const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd: root });
+    return c.json({ branch: stdout.trim() });
+  } catch (error) {
+    console.error("git branch error:", error);
+    return c.json({ error: "Failed to get branch" }, 500);
+  }
+});
+git.post("/branch/rename", async (c) => {
+  try {
+    const { newName, cwd } = await c.req.json();
+    if (!newName || !/^[a-zA-Z0-9._\/-]+$/.test(newName)) {
+      return c.json({ error: "Invalid branch name" }, 400);
+    }
+    const root = await getRepoRoot(cwd);
+    if (!root) return c.json({ error: "Not a git repository" }, 400);
+    await execAsync(`git branch -m ${newName}`, { cwd: root });
+    return c.json({ ok: true, branch: newName });
+  } catch (error) {
+    console.error("git branch rename error:", error);
+    return c.json({ error: "Failed to rename branch" }, 500);
+  }
+});
+
+// src/routes/gh/index.ts
+import { Hono as Hono3 } from "hono";
+import { exec as exec2, execSync as execSync3 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var gh = new Hono3();
+gh.get("/repos", async (c) => {
+  const fields = "--json name,nameWithOwner,description,url,isPrivate,updatedAt --limit 100";
+  try {
+    const personal = JSON.parse(
+      execSync3(`gh repo list ${fields}`, { encoding: "utf-8" })
+    );
+    let orgRepos = [];
+    try {
+      const orgs = execSync3("gh api user/orgs --jq '.[].login'", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+      for (const org of orgs) {
+        const repos = JSON.parse(
+          execSync3(`gh repo list ${org} ${fields}`, { encoding: "utf-8" })
+        );
+        orgRepos.push(...repos);
+      }
+    } catch {
+    }
+    const username = execSync3("gh api user --jq '.login'", { encoding: "utf-8" }).trim();
+    const all = [...personal, ...orgRepos].sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+    return c.json({ username, repos: all });
+  } catch (error) {
+    return c.json([]);
+  }
+});
+gh.get("/pr", async (c) => {
+  try {
+    const cwd = c.req.query("cwd");
+    const root = await getRepoRoot(cwd);
+    if (!root) return c.json({ exists: false });
+    const { stdout } = await execAsync2(
+      "gh pr view --json number,title,url",
+      { cwd: root }
+    );
+    const pr = JSON.parse(stdout);
+    return c.json({ exists: true, pr });
+  } catch {
+    return c.json({ exists: false });
+  }
+});
+gh.post("/pr", async (c) => {
+  try {
+    const { cwd } = await c.req.json().catch(() => ({ cwd: void 0 }));
+    const root = await getRepoRoot(cwd);
+    if (!root) return c.json({ error: "Not a git repository" }, 400);
+    await execAsync2("git push -u origin HEAD", { cwd: root });
+    await execAsync2("gh pr create --fill", { cwd: root });
+    const { stdout } = await execAsync2(
+      "gh pr view --json number,title,url",
+      { cwd: root }
+    );
+    const pr = JSON.parse(stdout);
+    return c.json(pr);
+  } catch (error) {
+    console.error("gh pr create error:", error);
+    const msg = error?.stderr || error?.message || "Failed to create PR";
+    return c.json({ error: msg }, 500);
+  }
+});
+
+// src/server.ts
+import { bearerAuth } from "hono/bearer-auth";
+var app = new Hono4();
+var token = process.env.AUTH_TOKEN;
+if (!token) {
+  console.error("AUTH_TOKEN is not set. Run `anywhere-ai init` first.");
+  process.exit(1);
+}
+app.use("*", cors());
+app.get("/health", async (c) => {
+  return c.json({ message: "server is healthy" }, 200);
+});
+app.use("/v1/*", bearerAuth({ token }));
+app.route("/v1/chats", chats);
+app.route("/v1/git", git);
+app.route("/v1/gh", gh);
+serve(
+  {
+    fetch: app.fetch,
+    hostname: "0.0.0.0",
+    port: parseInt(process.env.PORT || "3847")
+  },
+  (info) => {
+  }
+);

package/package.json

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