anywhere-ai 0.0.1

package/.env

@@ -0,0 +1,4 @@
+# SERVER_URL=168.119.231.95
+SERVER_URL=http://localhost:8080
+AUTH_TOKEN=E4PR6tWWyvluPgbNbrUsh9T9LerW803Obu7oaXQSRJA=
+CLAUDE_CODE_OAUTH_TOKEN=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

package/dist/cli.js

@@ -0,0 +1,99 @@
+// src/cli.ts
+import fs from "fs/promises";
+import { readFileSync } from "fs";
+import os from "os";
+import path from "path";
+import crypto from "crypto";
+import { spawnSync, execSync } from "child_process";
+var ANYWHERE_DIR = path.join(os.homedir(), ".anywhere");
+var CONFIG_PATH = path.join(ANYWHERE_DIR, "config.json");
+async function createConfigFile() {
+  try {
+    await fs.access(CONFIG_PATH);
+    console.log("Config.json already exists");
+  } catch (error) {
+    console.log("Config.json does not exists");
+    const token = crypto.randomBytes(16).toString("hex");
+    await fs.writeFile(
+      CONFIG_PATH,
+      JSON.stringify({ authToken: token }, null, 2)
+    );
+    console.log("Config.json created");
+  }
+}
+function isGhInstalled() {
+  try {
+    execSync("which gh", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureGhInstalled() {
+  if (isGhInstalled()) return;
+  const platform = os.platform();
+  console.log("gh CLI not found. Installing...");
+  if (platform === "darwin") {
+    const result = spawnSync("brew", ["install", "gh"], { stdio: "inherit" });
+    if (result.status !== 0) {
+      console.error(
+        "Failed to install gh via Homebrew. Install manually: https://cli.github.com"
+      );
+      process.exit(1);
+    }
+  } else if (platform === "linux") {
+    const commands = [
+      "curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg",
+      'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null',
+      "sudo apt update",
+      "sudo apt install -y gh"
+    ];
+    for (const cmd of commands) {
+      const result = spawnSync("sh", ["-c", cmd], { stdio: "inherit" });
+      if (result.status !== 0) {
+        console.error(`Failed during: ${cmd}`);
+        console.error("Install gh manually: https://cli.github.com");
+        process.exit(1);
+      }
+    }
+  } else {
+    console.error(
+      `Unsupported platform: ${platform}. Install gh manually: https://cli.github.com`
+    );
+    process.exit(1);
+  }
+  if (!isGhInstalled()) {
+    console.error("gh installation completed but binary not found in PATH.");
+    process.exit(1);
+  }
+  console.log("gh CLI installed successfully.");
+}
+function isGhAuthed() {
+  try {
+    execSync("gh auth status", { encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureGhAuth() {
+  if (isGhAuthed()) {
+    console.log("Gh authenticated");
+    return;
+  }
+  console.log("gh not authenticated, Launching gh auth login...");
+  const result = spawnSync("gh", ["auth", "login"], {
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.error("GitHub login failed");
+    process.exit(1);
+  }
+}
+await fs.mkdir(ANYWHERE_DIR, { recursive: true });
+await createConfigFile();
+ensureGhInstalled();
+ensureGhAuth();
+var config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+process.env.AUTH_TOKEN = config.authToken;
+import("./server-5PJ4IEOJ.js");

package/dist/server-5PJ4IEOJ.js

@@ -0,0 +1,459 @@
+// src/server.ts
+import { Hono as Hono3 } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+
+// src/routes/chats/index.ts
+import { Hono } from "hono";
+import os from "os";
+import path from "path";
+import { readdir, readFile } from "fs/promises";
+import { streamSSE } from "hono/streaming";
+
+// src/chats.ts
+import {
+  unstable_v2_createSession,
+  unstable_v2_resumeSession
+} from "@anthropic-ai/claude-agent-sdk";
+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 createChat = async ({
+  model,
+  permission
+}) => {
+  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)
+  });
+  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 } = await c.req.json();
+  if (!prompt) return c.json({ error: "Prompt is required" }, 400);
+  try {
+    const { session, tempId } = await createChat({ model, permission });
+    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 = path.join(os.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 = path.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 = path.join(os.homedir(), ".claude", "projects", cwdSlug);
+    const file = path.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 path2 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(path2.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(path2.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/server.ts
+import { bearerAuth } from "hono/bearer-auth";
+var app = new Hono3();
+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);
+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

@@ -0,0 +1,36 @@
+{
+  "name": "anywhere-ai",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Code on any repo from your phone",
+  "bin": {
+    "anywhere-ai": "./dist/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsx watch src/server.ts",
+    "start": "tsx src/server.ts",
+    "build": "tsup src/cli.ts --format esm --outDir dist"
+  },
+  "keywords": [
+    "claude",
+    "mobile",
+    "coding",
+    "agent"
+  ],
+  "author": "yogesharc",
+  "license": "MIT",
+  "packageManager": "pnpm@10.30.3",
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.69",
+    "@hono/node-server": "^1.19.11",
+    "dotenv": "^17.3.1",
+    "hono": "^4.12.5"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/chats.ts

@@ -0,0 +1,203 @@
+import {
+  unstable_v2_createSession,
+  PermissionMode,
+  PermissionResult,
+  SDKMessage,
+  SDKSession,
+  unstable_v2_resumeSession,
+} from "@anthropic-ai/claude-agent-sdk";
+
+export const sessions = new Map<string, SDKSession>();
+
+// Track which sessions are currently streaming
+export const activeSessions = new Set<string>();
+
+// Pending permission requests: requestId -> resolve function
+export const pendingPermissions = new Map<
+  string,
+  (result: PermissionResult) => void
+>();
+
+export function getAssistantText(msg: SDKMessage): string | null {
+  if (msg.type !== "assistant") return null;
+  return msg.message.content
+    .filter((block: any) => block.type === "text")
+    .map((block: any) => block.text)
+    .join("");
+}
+
+// Permission suggestion sent to the client
+export interface PermissionSuggestion {
+  type: string; // 'addRules' | 'replaceRules' | 'setMode' etc.
+  rules?: Array<{ toolName: string; ruleContent?: string }>;
+  behavior?: string;
+  destination?: string;
+  mode?: string;
+}
+
+// Permission request info sent to the client via SSE
+export interface PermissionRequest {
+  requestId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+  description?: string;
+  decisionReason?: string;
+  suggestions?: PermissionSuggestion[];
+}
+
+// Callback for notifying the SSE stream about permission requests
+type PermissionCallback = (req: PermissionRequest) => void;
+
+// Active permission callbacks per session (set during streaming)
+const permissionCallbacks = new Map<string, PermissionCallback>();
+
+export function setPermissionCallback(
+  sessionId: string,
+  cb: PermissionCallback | null,
+) {
+  if (cb) {
+    permissionCallbacks.set(sessionId, cb);
+  } else {
+    permissionCallbacks.delete(sessionId);
+  }
+}
+
+let permReqCounter = 0;
+
+function makeCanUseTool(sessionHint: string, permissionMode: PermissionMode) {
+  return async (
+    toolName: string,
+    input: Record<string, unknown>,
+    options: {
+      signal: AbortSignal;
+      suggestions?: any[];
+      blockedPath?: string;
+      decisionReason?: string;
+      toolUseID: string;
+      agentID?: string;
+    },
+  ): Promise<PermissionResult> => {
+    console.log(`[canUseTool] tool=${toolName} reason=${options.decisionReason ?? "none"} mode=${permissionMode}`);
+
+    // In acceptEdits mode: auto-allow file operations, only prompt for others
+    // The SDK calls canUseTool for tools that need a permission decision.
+    // We forward the decision to the client for interactive approval.
+    const requestId = `perm_${++permReqCounter}_${Date.now()}`;
+
+    const req: PermissionRequest = {
+      requestId,
+      toolName,
+      input,
+      description: (input as any).description,
+      decisionReason: options.decisionReason,
+      suggestions: options.suggestions as PermissionSuggestion[] | undefined,
+    };
+
+    // Notify the active SSE stream (if any)
+    const cb = permissionCallbacks.get(sessionHint);
+    if (cb) cb(req);
+
+    // Wait for the client to respond
+    return new Promise<PermissionResult>((resolve) => {
+      pendingPermissions.set(requestId, resolve);
+
+      // Timeout after 5 minutes — deny if no response
+      const timeout = setTimeout(() => {
+        if (pendingPermissions.has(requestId)) {
+          pendingPermissions.delete(requestId);
+          resolve({ behavior: "deny", message: "Permission request timed out" });
+        }
+      }, 5 * 60 * 1000);
+
+      // Clean up timeout if abort signal fires
+      options.signal.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        if (pendingPermissions.has(requestId)) {
+          pendingPermissions.delete(requestId);
+          resolve({ behavior: "deny", message: "Request aborted" });
+        }
+      });
+
+      // Also clean up on resolve
+      const origResolve = resolve;
+      pendingPermissions.set(requestId, (result) => {
+        clearTimeout(timeout);
+        pendingPermissions.delete(requestId);
+        origResolve(result);
+      });
+    });
+  };
+}
+
+export const createChat = async ({
+  model,
+  permission,
+}: {
+  model?: string;
+  permission?: PermissionMode;
+}) => {
+  // We pass a placeholder sessionId hint — we'll update the callback key
+  // once we know the real sessionId from the first streamed message
+  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),
+  });
+  return { session, tempId };
+};
+
+export const sendMessage = async ({
+  prompt,
+  session,
+}: {
+  prompt: string;
+  session: SDKSession;
+}): Promise<void> => {
+  await session.send(prompt);
+};
+
+export const streamMessage = async (
+  session: SDKSession,
+): Promise<{ text: string | null; sessionId: string }> => {
+  let sessionId = "";
+  let response = "";
+  for await (const msg of session.stream()) {
+    sessionId = msg.session_id;
+    const text = getAssistantText(msg);
+    if (text) response += text;
+  }
+  return { text: response || null, sessionId };
+};
+
+export const closeSession = (session: SDKSession) => {
+  session.close();
+};
+
+export const getSession = async ({
+  sessionId,
+  model,
+  permission,
+}: {
+  sessionId: string;
+  model?: string;
+  permission?: PermissionMode;
+}): Promise<SDKSession> => {
+  let session = sessions.get(sessionId);
+  if (session && (model || permission)) {
+    session.close();
+    sessions.delete(sessionId);
+    session = undefined;
+  }
+  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;
+};

package/src/cli.ts

@@ -0,0 +1,114 @@
+import fs from "fs/promises";
+import { readFileSync } from "fs";
+import os from "os";
+import path from "path";
+import crypto from "crypto";
+import { spawnSync, execSync } from "child_process";
+
+const ANYWHERE_DIR = path.join(os.homedir(), ".anywhere");
+const CONFIG_PATH = path.join(ANYWHERE_DIR, "config.json");
+
+async function createAnywhereDir() {
+  await fs.mkdir(ANYWHERE_DIR, { recursive: true });
+}
+
+async function createConfigFile() {
+  try {
+    await fs.access(CONFIG_PATH);
+    console.log("Config.json already exists");
+  } catch (error) {
+    console.log("Config.json does not exists");
+    const token = crypto.randomBytes(16).toString("hex");
+    await fs.writeFile(
+      CONFIG_PATH,
+      JSON.stringify({ authToken: token }, null, 2),
+    );
+    console.log("Config.json created");
+  }
+}
+
+function isGhInstalled(): boolean {
+  try {
+    execSync("which gh", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ensureGhInstalled() {
+  if (isGhInstalled()) return;
+
+  const platform = os.platform();
+  console.log("gh CLI not found. Installing...");
+
+  if (platform === "darwin") {
+    const result = spawnSync("brew", ["install", "gh"], { stdio: "inherit" });
+    if (result.status !== 0) {
+      console.error(
+        "Failed to install gh via Homebrew. Install manually: https://cli.github.com",
+      );
+      process.exit(1);
+    }
+  } else if (platform === "linux") {
+    const commands = [
+      "curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg",
+      'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null',
+      "sudo apt update",
+      "sudo apt install -y gh",
+    ];
+    for (const cmd of commands) {
+      const result = spawnSync("sh", ["-c", cmd], { stdio: "inherit" });
+      if (result.status !== 0) {
+        console.error(`Failed during: ${cmd}`);
+        console.error("Install gh manually: https://cli.github.com");
+        process.exit(1);
+      }
+    }
+  } else {
+    console.error(
+      `Unsupported platform: ${platform}. Install gh manually: https://cli.github.com`,
+    );
+    process.exit(1);
+  }
+
+  if (!isGhInstalled()) {
+    console.error("gh installation completed but binary not found in PATH.");
+    process.exit(1);
+  }
+  console.log("gh CLI installed successfully.");
+}
+
+function isGhAuthed(): boolean {
+  try {
+    execSync("gh auth status", { encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureGhAuth() {
+  if (isGhAuthed()) {
+    console.log("Gh authenticated");
+    return;
+  }
+  console.log("gh not authenticated, Launching gh auth login...");
+  const result = spawnSync("gh", ["auth", "login"], {
+    stdio: "inherit",
+  });
+  if (result.status !== 0) {
+    console.error("GitHub login failed");
+    process.exit(1);
+  }
+}
+
+// Setup
+await fs.mkdir(ANYWHERE_DIR, { recursive: true });
+await createConfigFile();
+ensureGhInstalled();
+ensureGhAuth();
+
+// Start server
+const config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+process.env.AUTH_TOKEN = config.authToken;
+import("./server.js");

package/src/routes/chats/index.ts

@@ -0,0 +1,257 @@
+import { Hono } from "hono";
+import os from "os";
+import path from "path";
+import { readdir, readFile } from "fs/promises";
+import { streamSSE } from "hono/streaming";
+
+import {
+  sessions,
+  activeSessions,
+  createChat,
+  sendMessage,
+  getSession,
+  getAssistantText,
+  pendingPermissions,
+  setPermissionCallback,
+  type PermissionRequest,
+} from "../../chats";
+
+export const chats = new Hono();
+
+chats.post("/new", async (c) => {
+  const { prompt, model, permission } = await c.req.json();
+  if (!prompt) return c.json({ error: "Prompt is required" }, 400);
+
+  try {
+    const { session, tempId } = await createChat({ model, permission });
+    await sendMessage({ prompt, session });
+
+    return streamSSE(c, async (stream) => {
+      let finalSessionId = "";
+
+      // Send permission requests directly from canUseTool callback
+      const sendPerm = async (req: PermissionRequest) => {
+        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);
+
+      // Permission requests are sent directly from the canUseTool callback
+      // (which runs on a different async context than the stream loop)
+      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);
+  }
+});
+
+// Respond to a pending permission request
+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 = path.join(os.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 = path.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 content = obj.message.content;
+            if (typeof content === "string") {
+              preview = content.slice(0, 100);
+            } else {
+              preview = content
+                .filter((b: any) => b.type === "text")
+                .map((b: any) => 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 = path.join(os.homedir(), ".claude", "projects", cwdSlug);
+    const file = path.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));
+
+    // Extract last known model and permissionMode from JSONL
+    let model: string | undefined;
+    let permissionMode: string | undefined;
+    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 content = obj.message.content;
+        if (typeof content === "string") {
+          return [{ role: obj.message.role, type: "text", text: content.trim(), timestamp: obj.timestamp }];
+        }
+        return content
+          .filter((b: any) => ["text", "tool_use", "tool_result"].includes(b.type))
+          .map((b: any) => {
+            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: any) => r.type === "text").map((r: any) => 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);
+  }
+});

package/src/routes/git/index.ts

@@ -0,0 +1,156 @@
+import { Hono } from "hono";
+import { exec } from "child_process";
+import { readFile } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+// Resolve git repo root lazily (process.cwd() may be a subdir like api/)
+let _repoRoot: string | null = null;
+async function getRepoRoot(): Promise<string> {
+  if (!_repoRoot) {
+    try {
+      const { stdout } = await execAsync("git rev-parse --show-toplevel");
+      _repoRoot = stdout.trim();
+    } catch {
+      _repoRoot = process.cwd();
+    }
+  }
+  return _repoRoot;
+}
+
+export const git = new Hono();
+
+interface FileChange {
+  path: string;
+  status: "M" | "A" | "D" | "?" | "R";
+  staged: boolean;
+  additions: number;
+  deletions: number;
+}
+
+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: string) => {
+      const map = new Map<string, { additions: number; deletions: number }>();
+      for (const line of raw.split("\n").filter(Boolean)) {
+        const [add, del, file] = line.split("\t");
+        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: FileChange[] = [];
+    for (const line of statusOut.split("\n").filter(Boolean)) {
+      const xy = line.slice(0, 2);
+      const filePath = line.slice(3).trim();
+
+      let status: FileChange["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 readFile(path.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 readFile(path.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);
+  }
+});

package/src/server.ts

@@ -0,0 +1,34 @@
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+import { chats } from "./routes/chats";
+import { git } from "./routes/git";
+import { bearerAuth } from "hono/bearer-auth";
+const app = new Hono();
+const 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);
+
+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/test.js

@@ -0,0 +1,12 @@
+const greet = (name) => `Yo, what's up ${name}?!`;
+console.log(greet("Yogesh"));
+
+const add = (a, b) => a + b;
+const multiply = (a, b) => a * b;
+const subtract = (a, b) => a - b;
+
+console.log(`2 + 3 = ${add(2, 3)}`);
+console.log(`4 x 5 = ${multiply(4, 5)}`);
+
+const fruits = ["apple", "banana", "mango", "kiwi"];
+fruits.forEach((fruit, i) => console.log(`${i + 1}. ${fruit}`));

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}