anywhere-ai 0.0.3 → 0.0.4

package/dist/cli.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 // src/cli.ts
 import fs from "fs/promises";
 import { readFileSync } from "fs";
@@ -173,4 +175,4 @@ if (isVPS) {
   console.log("  Make sure port " + port + " is open in your firewall.");
 }
 console.log();
-import("./server-AGLOR4NI.js");
+import("./server-Q5IYQIHO.js");

package/dist/server-Q5IYQIHO.js

@@ -0,0 +1,585 @@
+#!/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 } from "fs/promises";
+import { streamSSE } from "hono/streaming";
+
+// src/chats.ts
+import {
+  unstable_v2_createSession,
+  unstable_v2_prompt,
+  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);
+      });
+    });
+  };
+}
+async function generateBranchName(prompt) {
+  try {
+    const start = Date.now();
+    const result = await unstable_v2_prompt(
+      `Generate a short git branch name (2-4 words, lowercase, kebab-case, no prefix) for this task: "${prompt.slice(0, 200)}". Reply with ONLY the branch name, nothing else.`,
+      { model: "claude-haiku-4-5" }
+    );
+    console.log(`[branch-name] took ${Date.now() - start}ms`);
+    if (result.subtype === "success") {
+      return result.result.trim().replace(/[^a-z0-9-]/g, "").slice(0, 40);
+    }
+  } catch (e) {
+    console.error("[branch-name] failed:", e);
+  }
+  return `chat-${Date.now()}`;
+}
+var setupRepo = async (repo, prompt) => {
+  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 = `chat/${await generateBranchName(prompt)}`;
+  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, prompt || "chat") : void 0;
+  const tempId = `temp_${Date.now()}`;
+  const mode = permission || "acceptEdits";
+  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)) {
+    session.close();
+    sessions.delete(sessionId);
+    session = void 0;
+  }
+  if (!session) {
+    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);
+  }
+  return session;
+};
+
+// src/routes/chats/index.ts
+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 } = 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(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);
+      } 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" })
+        });
+      } 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 cwdSlug = process.cwd().replaceAll("/", "-");
+    const chatsDir = path2.join(os2.homedir(), ".claude", "projects", cwdSlug);
+    const files = (await readdir(chatsDir)).filter((f) => f.endsWith(".jsonl"));
+    const result = await Promise.all(
+      files.map(async (file) => {
+        const filePath = path2.join(chatsDir, file);
+        const content = await readFile(filePath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const sessionId = file.replace(".jsonl", "");
+        let preview = "";
+        let timestamp = "";
+        for (const line of lines) {
+          const obj = JSON.parse(line);
+          if (obj.type === "user" && !obj.isMeta) {
+            const content2 = obj.message.content;
+            if (typeof content2 === "string") {
+              preview = content2.slice(0, 100);
+            } else {
+              preview = content2.filter((b) => b.type === "text").map((b) => b.text).join("").slice(0, 100);
+            }
+            timestamp = obj.timestamp;
+            break;
+          }
+        }
+        return {
+          sessionId,
+          text: preview,
+          timestamp,
+          isActive: activeSessions.has(sessionId)
+        };
+      })
+    );
+    return c.json({ result });
+  } catch (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 cwdSlug = process.cwd().replaceAll("/", "-");
+    const chatsDir = path2.join(os2.homedir(), ".claude", "projects", cwdSlug);
+    const file = path2.join(chatsDir, `${sessionId}.jsonl`);
+    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) {
+    try {
+      const { stdout } = await execAsync("git rev-parse --show-toplevel");
+      _repoRoot = stdout.trim();
+    } catch {
+      _repoRoot = process.cwd();
+    }
+  }
+  return _repoRoot;
+}
+var git = new Hono2();
+git.get("/status", async (c) => {
+  try {
+    const root = await getRepoRoot();
+    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();
+  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 execSync2 } 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(
+      execSync2(`gh repo list ${fields}`, { encoding: "utf-8" })
+    );
+    let orgRepos = [];
+    try {
+      const orgs = execSync2("gh api user/orgs --jq '.[].login'", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+      for (const org of orgs) {
+        const repos = JSON.parse(
+          execSync2(`gh repo list ${org} ${fields}`, { encoding: "utf-8" })
+        );
+        orgRepos.push(...repos);
+      }
+    } catch {
+    }
+    const username = execSync2("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 on http://localhost:${info.port}`);
+  }
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anywhere-ai",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "description": "Code on any repo from your phone",
   "bin": {
@@ -33,6 +33,6 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "dev": "tsx watch --env-file=.env src/server.ts",
     "start": "tsx --env-file=.env src/server.ts",
-    "build": "tsup src/cli.ts --format esm --outDir dist"
+    "build": "tsup"
   }
 }