anywhere-ai 0.0.9 → 0.0.10

package/dist/cli.js

@@ -10,7 +10,7 @@ import { spawnSync, execSync } from "child_process";
 import readline from "readline";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
-  console.log(`anywhere-ai v${"0.0.9"}`);
+  console.log(`anywhere-ai v${"0.0.10"}`);
   process.exit(0);
 }
 function ask(question, preserveCase = false) {
@@ -184,4 +184,4 @@ if (isVPS) {
   console.log("  Make sure port " + port + " is open in your firewall.");
 }
 console.log();
-import("./server-KMHUP4CE.js");
+import("./server-QUVKJH7W.js");

package/dist/server-QUVKJH7W.js

@@ -0,0 +1,661 @@
+#!/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 os2 from "os";
+import path2 from "path";
+import { readdir, readFile, stat } 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";
+var ANYWHERE_DIR = path.join(os.homedir(), ".anywhere");
+var PROJECTS_DIR = path.join(ANYWHERE_DIR, "projects");
+var WORKTREES_DIR = path.join(ANYWHERE_DIR, "worktrees");
+var sessions = /* @__PURE__ */ new Map();
+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) => {
+    console.log(
+      `[canUseTool] tool=${toolName} reason=${options.decisionReason ?? "none"} mode=${permissionMode}`
+    );
+    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) => {
+  console.log(`[setupRepo] repo=${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);
+    console.log(`[setupRepo] repo exists at ${repoPath}, fetching origin`);
+    execSync("git fetch origin", { cwd: repoPath, encoding: "utf-8" });
+  } catch {
+    console.log(`[setupRepo] cloning repo ${repo} to ${repoPath}`);
+    execSync(`gh repo clone ${repo} ${repoPath}`, { encoding: "utf-8" });
+  }
+  const branchName = `chat/chat-${Date.now()}`;
+  console.log(`[setupRepo] branchName=${branchName}`);
+  const worktreePath = path.join(WORKTREES_DIR, branchName);
+  console.log(`[setupRepo] creating worktree at ${worktreePath}`);
+  execSync(`git worktree add ${worktreePath} -b ${branchName}`, {
+    cwd: repoPath,
+    encoding: "utf-8"
+  });
+  console.log(`[setupRepo] worktree ready at ${worktreePath}`);
+  return worktreePath;
+};
+var createChat = async ({
+  model,
+  permission,
+  repo,
+  prompt
+}) => {
+  console.log(`[createChat] model=${model} permission=${permission} repo=${repo} prompt="${prompt?.slice(0, 50)}"`);
+  const repoPath = repo ? await setupRepo(repo) : void 0;
+  console.log(`[createChat] cwd=${repoPath || process.cwd()}`);
+  const tempId = `temp_${Date.now()}`;
+  const mode = permission || "acceptEdits";
+  console.log(`[createChat] tempId=${tempId} mode=${mode}`);
+  const session = unstable_v2_createSession({
+    model: model || "claude-opus-4-6",
+    permissionMode: mode,
+    canUseTool: makeCanUseTool(tempId, mode),
+    ...repoPath ? { cwd: repoPath } : {}
+  });
+  return { session, tempId };
+};
+var sendMessage = async ({
+  prompt,
+  session
+}) => {
+  await session.send(prompt);
+};
+var getSession = async ({
+  sessionId,
+  model,
+  permission
+}) => {
+  let session = sessions.get(sessionId);
+  if (session && (model || permission)) {
+    console.log(`[getSession] ${sessionId} re-creating (model=${model} permission=${permission})`);
+    session.close();
+    sessions.delete(sessionId);
+    session = void 0;
+  }
+  if (!session) {
+    console.log(`[getSession] ${sessionId} resuming from JSONL`);
+    const mode = permission || "acceptEdits";
+    session = unstable_v2_resumeSession(sessionId, {
+      model: model || "claude-opus-4-6",
+      permissionMode: mode,
+      canUseTool: makeCanUseTool(sessionId, mode)
+    });
+    sessions.set(sessionId, session);
+  } else {
+    console.log(`[getSession] ${sessionId} found in memory`);
+  }
+  return session;
+};
+
+// src/routes/chats/index.ts
+var repoNameCache = /* @__PURE__ */ new Map();
+function deriveRepoName(cwd) {
+  if (!cwd) return "Unknown";
+  const cached = repoNameCache.get(cwd);
+  if (cached) return cached;
+  let name = "Unknown";
+  try {
+    const url = execSync2("git remote get-url origin 2>/dev/null", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    const match = url.match(/[:/]([^/]+\/[^/.]+?)(?:\.git)?$/);
+    if (match?.[1]) name = match[1];
+  } catch {
+    try {
+      const root = execSync2("git rev-parse --show-toplevel 2>/dev/null", {
+        cwd,
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      name = root.split("/").filter(Boolean).pop() || "Unknown";
+    } catch {
+      const segments = cwd.split("/").filter(Boolean);
+      name = segments[segments.length - 1] || "Unknown";
+    }
+  }
+  repoNameCache.set(cwd, name);
+  return name;
+}
+async function findSessionFile(sessionId) {
+  const projectsBase = path2.join(os2.homedir(), ".claude", "projects");
+  try {
+    const dirs = await readdir(projectsBase);
+    for (const dir of dirs) {
+      const filePath = path2.join(projectsBase, dir, `${sessionId}.jsonl`);
+      try {
+        await stat(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();
+  console.log(`[POST /new] prompt="${prompt?.slice(0, 50)}" model=${model} repo=${repo}`);
+  if (!prompt) return c.json({ error: "Prompt is required" }, 400);
+  try {
+    const { session, tempId } = await createChat({ model, permission, repo, prompt });
+    await sendMessage({ prompt, session });
+    return streamSSE(c, async (stream) => {
+      let finalSessionId = "";
+      console.log(`[POST /new] SSE stream started, tempId=${tempId}`);
+      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;
+            console.log(`[POST /new] sessionId received: ${finalSessionId}`);
+            activeSessions.add(finalSessionId);
+            setPermissionCallback(tempId, null);
+            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);
+          console.log(`[POST /new] session stored: ${finalSessionId}`);
+        }
+      } 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");
+  console.log(`[POST /:id/message] sessionId=${sessionId} prompt="${prompt?.slice(0, 50)}"`);
+  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" })
+        });
+      } 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 = path2.join(os2.homedir(), ".claude", "projects");
+    const dirs = await readdir(projectsBase);
+    const allChats = [];
+    for (const dir of dirs) {
+      const dirPath = path2.join(projectsBase, dir);
+      try {
+        const s = await stat(dirPath);
+        if (!s.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const files = (await readdir(dirPath)).filter(
+        (f) => f.endsWith(".jsonl")
+      );
+      for (const file of files) {
+        const filePath = path2.join(dirPath, file);
+        const content = await readFile(filePath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const sessionId = file.replace(".jsonl", "");
+        let preview = "";
+        let timestamp = "";
+        let cwd = "";
+        let gitBranch = "";
+        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) {
+                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;
+                break;
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (!timestamp) continue;
+        allChats.push({
+          sessionId,
+          text: preview,
+          timestamp,
+          isActive: activeSessions.has(sessionId),
+          repo: deriveRepoName(cwd),
+          cwd,
+          gitBranch
+        });
+      }
+    }
+    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 readFile(file, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const parsed = lines.map((line) => JSON.parse(line));
+    let model;
+    let permissionMode;
+    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);
+    });
+    return c.json({ messages, model, permissionMode });
+  } 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 readFile2 } from "fs/promises";
+import path3 from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var _repoRoot = null;
+async function getRepoRoot() {
+  if (_repoRoot === null) {
+    try {
+      const { stdout } = await execAsync("git rev-parse --show-toplevel");
+      _repoRoot = stdout.trim();
+    } catch {
+      _repoRoot = false;
+    }
+  }
+  return _repoRoot || null;
+}
+var git = new Hono2();
+git.get("/status", async (c) => {
+  try {
+    const root = await getRepoRoot();
+    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 readFile2(path3.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 root = await getRepoRoot();
+  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 readFile2(path3.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);
+  }
+});
+
+// src/routes/gh/index.ts
+import { Hono as Hono3 } from "hono";
+import { execSync as execSync3 } from "child_process";
+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([]);
+  }
+});
+
+// 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) => {
+    console.log("Server is running");
+  }
+);

package/package.json

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