anywhere-ai 0.0.27 → 0.0.29

package/dist/chunk-PDX44BCA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/cli.js

@@ -2,47 +2,144 @@
 
 // src/cli.ts
 import fs from "fs/promises";
-import { readFileSync } from "fs";
+import { readFileSync, existsSync, writeFileSync, unlinkSync, openSync } from "fs";
 import os from "os";
 import path from "path";
 import crypto from "crypto";
 import { spawn, spawnSync, execSync } from "child_process";
 import readline from "readline";
 import qrcode from "qrcode";
+var ANYWHERE_DIR = path.join(os.homedir(), ".anywhere");
+var CONFIG_PATH = path.join(ANYWHERE_DIR, "config.json");
+var PID_PATH = path.join(ANYWHERE_DIR, "server.pid");
+var LOG_PATH = path.join(ANYWHERE_DIR, "server.log");
+var STATUS_PATH = path.join(ANYWHERE_DIR, "status.json");
 var args = process.argv.slice(2);
 var command = args.find((a) => !a.startsWith("-"));
 if (args.includes("--version") || args.includes("-v")) {
-  console.log(`anywhere-ai v${"0.0.27"}`);
+  console.log(`anywhere-ai v${"0.0.29"}`);
   process.exit(0);
 }
 if (args.includes("--help") || args.includes("-h") || command === "help") {
-  console.log(`anywhere-ai v${"0.0.27"} \u2014 Mobile coding agent
+  console.log(`anywhere-ai v${"0.0.29"} \u2014 Mobile coding agent
 
 Usage: anywhere-ai [command] [options]
 
 Commands:
+  status               Show server status and connection info
+  stop                 Stop the background server
+  logs                 Tail server logs
   regenerate-token     Generate a new auth token
 
 Options:
   --help, -h           Show this help message
   --version, -v        Show version
+  --daemon, -d         Run server in background
   --no-tunnel          Skip Cloudflare tunnel`);
   process.exit(0);
 }
+function getDaemonPid() {
+  try {
+    const pid = parseInt(readFileSync(PID_PATH, "utf-8").trim(), 10);
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    try {
+      unlinkSync(PID_PATH);
+    } catch {
+    }
+    return null;
+  }
+}
+if (command === "stop" || args.includes("--stop")) {
+  const pid = getDaemonPid();
+  if (!pid) {
+    console.log("No server running.");
+    process.exit(0);
+  }
+  process.kill(pid, "SIGTERM");
+  try {
+    unlinkSync(PID_PATH);
+  } catch {
+  }
+  try {
+    unlinkSync(STATUS_PATH);
+  } catch {
+  }
+  console.log(`Server stopped (PID ${pid}).`);
+  process.exit(0);
+}
+if (command === "status") {
+  const pid = getDaemonPid();
+  if (!pid) {
+    console.log("No server running.");
+    process.exit(0);
+  }
+  try {
+    const status = JSON.parse(readFileSync(STATUS_PATH, "utf-8"));
+    const uptimeMs = Date.now() - status.startedAt;
+    const hours = Math.floor(uptimeMs / 36e5);
+    const mins = Math.floor(uptimeMs % 36e5 / 6e4);
+    console.log(`Anywhere server running (PID ${pid})`);
+    console.log(`  Tunnel:  ${status.serverURL}`);
+    if (status.localURL && status.localURL !== status.serverURL) {
+      console.log(`  Direct:  ${status.localURL}`);
+    }
+    console.log(`  Token:   ${status.authToken}`);
+    console.log(`  Uptime:  ${hours}h ${mins}m`);
+    console.log(`  Logs:    ${LOG_PATH}`);
+  } catch {
+    console.log(`Server running (PID ${pid}) but no status info available.`);
+    console.log(`  Logs: ${LOG_PATH}`);
+  }
+  process.exit(0);
+}
+if (command === "logs") {
+  if (!existsSync(LOG_PATH)) {
+    console.log("No log file found. Start the server first.");
+    process.exit(0);
+  }
+  const tail = spawn("tail", ["-f", "-n", "50", LOG_PATH], { stdio: "inherit" });
+  tail.on("exit", () => process.exit(0));
+  process.on("SIGINT", () => {
+    tail.kill();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
 if (command === "regenerate-token") {
-  const configPath = path.join(os.homedir(), ".anywhere", "config.json");
   try {
-    await fs.access(configPath);
+    await fs.access(CONFIG_PATH);
   } catch {
     console.error("No config found. Run `anywhere-ai` first to set up.");
     process.exit(1);
   }
-  const config2 = JSON.parse(await fs.readFile(configPath, "utf-8"));
+  const config2 = JSON.parse(await fs.readFile(CONFIG_PATH, "utf-8"));
   config2.authToken = crypto.randomBytes(16).toString("hex");
-  await fs.writeFile(configPath, JSON.stringify(config2, null, 2));
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(config2, null, 2));
   console.log("New auth token: " + config2.authToken);
   process.exit(0);
 }
+var existingPid = getDaemonPid();
+if (existingPid) {
+  console.log(`Server already running (PID ${existingPid}). Use 'anywhere-ai stop' first.`);
+  process.exit(1);
+}
+async function checkForUpdate() {
+  try {
+    const res = await fetch("https://registry.npmjs.org/anywhere-ai/latest", { signal: AbortSignal.timeout(3e3) });
+    const data = await res.json();
+    if (data.version && data.version !== "0.0.29") {
+      console.log(`
+  Update available: v${"0.0.29"} \u2192 v${data.version}`);
+      console.log(`  Run: npx anywhere-ai@latest
+`);
+    }
+  } catch {
+  }
+}
+checkForUpdate();
 function ask(question, preserveCase = false) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
@@ -52,8 +149,6 @@ function ask(question, preserveCase = false) {
     });
   });
 }
-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);
@@ -319,7 +414,52 @@ if (!args.includes("--no-tunnel")) {
 }
 var localURL = isVPS ? "http://" + publicIP + ":" + port : "http://" + (localIP || "localhost") + ":" + port;
 var serverURL = tunnelURL || localURL;
-await printBanner(serverURL, localURL);
+var isDaemonized = args.includes("--_daemonized");
+if (!isDaemonized) {
+  await printBanner(serverURL, localURL);
+}
+writeFileSync(PID_PATH, String(process.pid));
+writeFileSync(STATUS_PATH, JSON.stringify({
+  serverURL,
+  localURL,
+  authToken: config.authToken,
+  startedAt: Date.now(),
+  pid: process.pid
+}, null, 2));
+var isDaemon = args.includes("--daemon") || args.includes("-d");
+if (isDaemon) {
+  const logFd = openSync(LOG_PATH, "a");
+  const child = spawn(process.execPath, [new URL(import.meta.url).pathname, ...args.filter((a) => a !== "--daemon" && a !== "-d"), "--_daemonized"], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  writeFileSync(PID_PATH, String(child.pid));
+  writeFileSync(STATUS_PATH, JSON.stringify({
+    serverURL,
+    localURL,
+    authToken: config.authToken,
+    startedAt: Date.now(),
+    pid: child.pid
+  }, null, 2));
+  console.log(`
+  Running in background (PID ${child.pid})`);
+  console.log(`  Logs:    ${LOG_PATH}`);
+  console.log(`  Status:  anywhere-ai status`);
+  console.log(`  Stop:    anywhere-ai stop
+`);
+  intentionalShutdown = true;
+  if (serverProcess) {
+    serverProcess.kill();
+    serverProcess = null;
+  }
+  if (tunnelProcess) {
+    tunnelProcess.kill();
+    tunnelProcess = null;
+  }
+  process.exit(0);
+}
 function cleanup() {
   intentionalShutdown = true;
   if (serverProcess) {
@@ -330,6 +470,14 @@ function cleanup() {
     tunnelProcess.kill();
     tunnelProcess = null;
   }
+  try {
+    unlinkSync(PID_PATH);
+  } catch {
+  }
+  try {
+    unlinkSync(STATUS_PATH);
+  } catch {
+  }
   process.exit();
 }
 process.on("SIGINT", cleanup);

package/dist/server.js

@@ -501,9 +501,7 @@ chats.post("/:id/message", async (c) => {
           const blocks = msg.message?.content;
           if (Array.isArray(blocks)) {
             for (const b of blocks) {
-              if (b.type === "tool_use") {
-                console.log(`[stream] tool_use: ${b.name}`);
-              } else if (b.type === "tool_result" && b.is_error) {
+              if (b.type === "tool_result" && b.is_error) {
                 const resultText = Array.isArray(b.content) ? b.content.filter((r) => r.type === "text").map((r) => r.text).join("").slice(0, 1e3) : String(b.content ?? "").slice(0, 1e3);
                 console.log(`[stream] tool_result ERROR: ${resultText.slice(0, 500)}`);
               }
@@ -899,19 +897,15 @@ gh.get("/repos", async (c) => {
 gh.get("/pr", async (c) => {
   try {
     const cwd = c.req.query("cwd");
-    console.log("[gh/pr GET] cwd:", cwd);
     const root = await getRepoRoot(cwd);
-    console.log("[gh/pr GET] resolved root:", root);
     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);
-    console.log("[gh/pr GET] found PR:", pr);
     return c.json({ exists: true, pr });
-  } catch (err) {
-    console.log("[gh/pr GET] no PR found:", err?.stderr?.trim() || err?.message);
+  } catch {
     return c.json({ exists: false });
   }
 });

package/package.json

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