airloom 0.1.32 → 0.1.34

package/dist/index.js

@@ -652,15 +652,28 @@ var AnthropicAdapter = class {
       messages: chatMsgs
     };
     if (systemMsg) body.system = systemMsg;
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify(body)
-    });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 6e4);
+    let response;
+    try {
+      response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      const msg = err.name === "AbortError" ? "Request timed out" : err.message;
+      stream.write(`[Error: ${msg}]`);
+      stream.end();
+      return;
+    }
+    clearTimeout(timeout);
     if (!response.ok) {
       const error = await response.text();
       stream.write(`[Error: ${response.status} ${error}]`);
@@ -714,14 +727,27 @@ var OpenAIAdapter = class {
     this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
   }
   async streamResponse(messages, stream) {
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({ model: this.model, stream: true, messages })
-    });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 6e4);
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, stream: true, messages }),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      const msg = err.name === "AbortError" ? "Request timed out" : err.message;
+      stream.write(`[Error: ${msg}]`);
+      stream.end();
+      return;
+    }
+    clearTimeout(timeout);
     if (!response.ok) {
       const error = await response.text();
       stream.write(`[Error: ${response.status} ${error}]`);
@@ -850,7 +876,7 @@ function resolveExecutable(command, envPath = process.env.PATH ?? "") {
   }
   for (const dir of envPath.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join(dir.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"), command);
+    const candidate = join(dir.replace(/^~(?=$|\/)/, process.env.HOME || process.env.USERPROFILE || "~"), command);
     if (existsSync(candidate)) return candidate;
   }
   return null;
@@ -1123,7 +1149,8 @@ function resolveExecutable2(command, envPath = process.env.PATH ?? "") {
   }
   for (const dir of envPath.split(delimiter2)) {
     if (!dir) continue;
-    const candidate = join3(dir.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"), command);
+    const home = process.env.HOME || process.env.USERPROFILE || "~";
+    const candidate = join3(dir.replace(/^~(?=$|\/)/, home), command);
     if (existsSync2(candidate)) return candidate;
   }
   return null;
@@ -1138,14 +1165,16 @@ function parseCommand(command) {
 function getDefaultTerminalCommand(explicitCommand) {
   const configured = explicitCommand?.trim() || process.env.AIRLOOM_TERMINAL_COMMAND?.trim();
   if (configured) return parseCommand(configured);
+  const shell = process.env.SHELL;
+  if (shell) {
+    const name = basename(shell);
+    if (name === "bash" || name === "zsh" || name === "sh") return { file: shell, args: ["-il"] };
+    return { file: shell, args: ["-i"] };
+  }
   if (process.platform === "win32") {
-    const file = process.env.COMSPEC || "powershell.exe";
-    return { file, args: [] };
+    return { file: process.env.COMSPEC || "powershell.exe", args: [] };
   }
-  const shell = process.env.SHELL || "/bin/bash";
-  const name = basename(shell);
-  if (name === "bash" || name === "zsh" || name === "sh") return { file: shell, args: ["-il"] };
-  return { file: shell, args: ["-i"] };
+  return { file: "/bin/bash", args: ["-il"] };
 }
 var AdaptiveOutputBatcher = class {
   constructor(onFlush, fastInterval = 16, slowInterval = 80, interactiveWindow = 250, maxBytes = 4096) {
@@ -1220,8 +1249,8 @@ var TerminalSession = class {
     const file = resolveExecutable2(command.file) ?? command.file;
     const cwd = process.cwd();
     log(`[host] PTY spawn: ${file} ${command.args.join(" ")} (${this.cols}x${this.rows}) node=${process.version}`);
-    const env2 = { ...process.env, TERM: "xterm-256color" };
-    const spawnOpts = { name: "xterm-256color", cols: this.cols, rows: this.rows, cwd, env: env2 };
+    const env = { ...process.env, TERM: "xterm-256color" };
+    const spawnOpts = { name: "xterm-256color", cols: this.cols, rows: this.rows, cwd, env };
     let nodePty;
     try {
       nodePty = requireNodePty();
@@ -2176,8 +2205,8 @@ function parseRelayUrl(value) {
   }
   return parsed.toString();
 }
-function parseHostBind(value, isDev) {
-  const bind = value?.trim() || (isDev ? "0.0.0.0" : DEFAULT_HOST_BIND);
+function parseHostBind(value, isDev, isSSH) {
+  const bind = value?.trim() || (isDev || isSSH ? "0.0.0.0" : DEFAULT_HOST_BIND);
   if (bind === "localhost" || isIP(bind) !== 0) return bind;
   if (/^[A-Za-z0-9.-]+$/.test(bind)) return bind;
   throw new Error("HOST_BIND must be localhost, an IP address, or a hostname");
@@ -2186,11 +2215,12 @@ function isLoopbackBind(bind) {
   return bind === "127.0.0.1" || bind === "::1" || bind === "localhost";
 }
 function parseHostEnv(cliPort, isDev = false) {
+  const isSSH = !!(process.env.SSH_CONNECTION || process.env.SSH_TTY || process.env.SSH_CLIENT);
   const relayUrl = parseRelayUrl(process.env.RELAY_URL);
   const ablyApiKey = process.env.ABLY_API_KEY ?? (relayUrl ? void 0 : DEFAULT_ABLY_KEY);
   const ablyTokenTtlMs = parseInteger("ABLY_TOKEN_TTL", process.env.ABLY_TOKEN_TTL, DEFAULT_ABLY_TOKEN_TTL_MS, 6e4, 31 * 24 * 60 * 60 * 1e3);
   const hostPort = cliPort ?? parseInteger("HOST_PORT", process.env.HOST_PORT, DEFAULT_HOST_PORT, 0, 65535);
-  const hostBind = parseHostBind(process.env.HOST_BIND, isDev);
+  const hostBind = parseHostBind(process.env.HOST_BIND, isDev, isSSH);
   const viewerUrl = parseViewerUrl(process.env.VIEWER_URL);
   return {
     viewerUrl,
@@ -2200,7 +2230,8 @@ function parseHostEnv(cliPort, isDev = false) {
     hostPort,
     hostBind,
     useAbly: !!ablyApiKey,
-    isDefaultAblyKey: !!ablyApiKey && ablyApiKey === DEFAULT_ABLY_KEY
+    isDefaultAblyKey: !!ablyApiKey && ablyApiKey === DEFAULT_ABLY_KEY,
+    isSSH
   };
 }
 
@@ -2236,13 +2267,213 @@ function loadOrCreateAblySessionToken() {
   return ablySessionToken;
 }
 
+// src/daemon.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync, readdirSync, openSync, closeSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+var SESSIONS_DIR = join5(homedir3(), ".config", "airloom", "sessions");
+function ensureDir() {
+  mkdirSync3(SESSIONS_DIR, { recursive: true });
+}
+function sessionPath(name) {
+  return join5(SESSIONS_DIR, `${name}.json`);
+}
+function logFilePath(name) {
+  return join5(SESSIONS_DIR, `${name}.log`);
+}
+function validateName(name) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error(`Invalid session name "${name}". Use only letters, numbers, hyphens, and underscores.`);
+  }
+}
+function readSession(name) {
+  try {
+    const raw = readFileSync3(sessionPath(name), "utf-8");
+    const data = JSON.parse(raw);
+    if (!data || typeof data.pid !== "number") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeSession(name, info) {
+  ensureDir();
+  writeFileSync3(sessionPath(name), JSON.stringify(info, null, 2) + "\n", { mode: 384 });
+}
+function removeSession(name) {
+  try {
+    unlinkSync(sessionPath(name));
+  } catch {
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listAllSessions() {
+  ensureDir();
+  let files;
+  try {
+    files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const file of files) {
+    const name = file.replace(/\.json$/, "");
+    const info = readSession(name);
+    if (!info) continue;
+    if (!isAlive(info.pid)) {
+      removeSession(name);
+      continue;
+    }
+    results.push({ name, info });
+  }
+  return results;
+}
+function formatAge(ms) {
+  const sec = Math.floor(ms / 1e3);
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ${min % 60}m ago`;
+  return `${Math.floor(hr / 24)}d ago`;
+}
+async function handleStart(name, hostArgs) {
+  validateName(name);
+  const existing = readSession(name);
+  if (existing && isAlive(existing.pid)) {
+    console.error(`Session "${name}" is already running (PID ${existing.pid}, port ${existing.port})`);
+    console.error(`Host UI: ${existing.controlUrl}`);
+    process.exit(1);
+  }
+  if (existing) removeSession(name);
+  ensureDir();
+  const logFile = logFilePath(name);
+  const logFd = openSync(logFile, "w");
+  const child = spawn2(
+    process.execPath,
+    [...process.execArgv, process.argv[1], ...hostArgs, "--_daemon"],
+    {
+      detached: true,
+      stdio: ["ignore", logFd, logFd, "ipc"],
+      cwd: process.cwd(),
+      env: process.env
+    }
+  );
+  try {
+    const info = await new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Timed out waiting for daemon to start (30s). Check log: ${logFile}`));
+      }, 3e4);
+      child.on("message", (msg) => {
+        const m = msg;
+        if (m.type === "ready") {
+          clearTimeout(timer);
+          resolve4({
+            pid: child.pid,
+            port: m.port,
+            controlUrl: m.controlUrl,
+            viewerUrl: m.viewerUrl,
+            pairingCode: m.pairingCode,
+            cwd: process.cwd(),
+            startedAt: Date.now(),
+            logFile
+          });
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        reject(new Error(`Daemon exited with code ${code}. Check log: ${logFile}`));
+      });
+    });
+    writeSession(name, info);
+    child.disconnect();
+    child.unref();
+    closeSync(logFd);
+    console.log(`
+Airloom session "${name}" started (PID ${info.pid})
+`);
+    console.log(`Pairing Code: ${info.pairingCode}`);
+    console.log(`Viewer URL:   ${info.viewerUrl}`);
+    console.log(`Host UI:      ${info.controlUrl}`);
+    console.log(`Log:          ${info.logFile}
+`);
+  } catch (err) {
+    closeSync(logFd);
+    try {
+      child.kill();
+    } catch {
+    }
+    throw err;
+  }
+}
+function handleStop(nameOrNull, all) {
+  if (all) {
+    const sessions = listAllSessions();
+    if (sessions.length === 0) {
+      console.log("No running sessions.");
+      return;
+    }
+    for (const { name, info: info2 } of sessions) {
+      try {
+        process.kill(info2.pid, "SIGTERM");
+      } catch {
+      }
+      removeSession(name);
+      console.log(`Stopped "${name}" (PID ${info2.pid})`);
+    }
+    return;
+  }
+  const target = nameOrNull || "default";
+  const info = readSession(target);
+  if (!info) {
+    console.error(`No session named "${target}" found.`);
+    process.exit(1);
+  }
+  if (!isAlive(info.pid)) {
+    removeSession(target);
+    console.log(`Session "${target}" was not running (cleaned up stale entry).`);
+    return;
+  }
+  try {
+    process.kill(info.pid, "SIGTERM");
+  } catch {
+  }
+  removeSession(target);
+  console.log(`Stopped "${target}" (PID ${info.pid})`);
+}
+function handleList() {
+  const sessions = listAllSessions();
+  if (sessions.length === 0) {
+    console.log("No running sessions.");
+    return;
+  }
+  console.log("NAME            PORT   PID      STARTED          CWD");
+  for (const { name, info } of sessions) {
+    const age = formatAge(Date.now() - info.startedAt);
+    console.log(
+      name.padEnd(16) + String(info.port).padEnd(7) + String(info.pid).padEnd(9) + age.padEnd(17) + info.cwd
+    );
+  }
+}
+
 // src/index.ts
 var QRCode = null;
 async function getQRCode() {
   if (!QRCode) QRCode = await import("qrcode");
   return QRCode;
 }
-log("[host] Module loaded");
 function parseArgs(argv) {
   const args = {};
   const rest = argv.slice(2);
@@ -2272,7 +2503,15 @@ function printHelp() {
 Airloom \u2014 Run AI on your computer, control it from your phone.
 
 Usage:
-  airloom [options]
+  airloom [options]            Start in foreground (default)
+  airloom start [options]      Start as a background daemon
+  airloom stop [name]          Stop a background session
+  airloom stop --all           Stop all background sessions
+  airloom list                 List running background sessions
+
+Background options:
+  --name <name>     Session name (default: "default").
+                    Allows multiple independent sessions.
 
 Options:
   --cli <command>     CLI command to use as the AI adapter.
@@ -2297,22 +2536,6 @@ Environment variables:
   HOST_BIND           Host bind address (default: 127.0.0.1).
 `.trimStart());
 }
-var cliArgs = parseArgs(process.argv);
-if (cliArgs.help) {
-  printHelp();
-  process.exit(0);
-}
-var IS_DEV = !process.env.VIEWER_URL && !new URL(import.meta.url).pathname.includes("node_modules");
-var env = parseHostEnv(cliArgs.port, IS_DEV);
-var VIEWER_URL = env.viewerUrl;
-var RELAY_URL = env.relayUrl;
-var ABLY_API_KEY = env.ablyApiKey;
-var ABLY_TOKEN_TTL = env.ablyTokenTtlMs;
-var HOST_PORT = env.hostPort;
-var HOST_BIND = env.hostBind;
-var useAbly = env.useAbly;
-var isDefaultKey = env.isDefaultAblyKey;
-var __dirname = dirname2(fileURLToPath(import.meta.url));
 function getLanIP() {
   for (const ifaces of Object.values(networkInterfaces())) {
     for (const iface of ifaces ?? []) {
@@ -2321,14 +2544,31 @@ function getLanIP() {
   }
   return void 0;
 }
-function resolveViewerDir() {
-  const prod = resolve3(__dirname, "viewer");
+function resolveViewerDir(base) {
+  const prod = resolve3(base, "viewer");
   if (existsSync4(prod)) return prod;
-  const dev = resolve3(__dirname, "../../viewer/dist");
+  const dev = resolve3(base, "../../viewer/dist");
   if (existsSync4(dev)) return dev;
   return void 0;
 }
 async function main() {
+  const cliArgs = parseArgs(process.argv);
+  if (cliArgs.help) {
+    printHelp();
+    process.exit(0);
+  }
+  const IS_DEV = !process.env.VIEWER_URL && !new URL(import.meta.url).pathname.includes("node_modules");
+  const env = parseHostEnv(cliArgs.port, IS_DEV);
+  const VIEWER_URL = env.viewerUrl;
+  const RELAY_URL = env.relayUrl;
+  const ABLY_API_KEY = env.ablyApiKey;
+  const ABLY_TOKEN_TTL = env.ablyTokenTtlMs;
+  const HOST_PORT = env.hostPort;
+  const HOST_BIND = env.hostBind;
+  const useAbly = env.useAbly;
+  const isDefaultKey = env.isDefaultAblyKey;
+  const isDaemonChild = process.argv.includes("--_daemon");
+  const __dirname = dirname2(fileURLToPath(import.meta.url));
   console.log("Airloom - Host");
   console.log("==============\n");
   if (useAbly) {
@@ -2480,7 +2720,7 @@ async function main() {
       }
     }
   }
-  const viewerDir = resolveViewerDir();
+  const viewerDir = resolveViewerDir(__dirname);
   if (viewerDir) {
     log(`[host] Viewer files: ${viewerDir}`);
   } else {
@@ -2517,16 +2757,23 @@ async function main() {
     if (lanViewerUrl) console.log(`LAN Viewer:  ${lanViewerUrl}`);
   }
   if (!useAbly) console.log(`Relay: ${RELAY_URL}`);
-  const localUrl = `http://localhost:${port}`;
-  const controlUrl = encodeControlUrl(localUrl, controlToken);
+  const controlBase = isLoopbackBind(HOST_BIND) ? `http://localhost:${port}` : lanBaseUrl;
+  const controlUrl = encodeControlUrl(controlBase, controlToken);
   console.log(`Host UI:    ${controlUrl}`);
-  const isSSH = !!(process.env.SSH_CONNECTION || process.env.SSH_TTY || process.env.SSH_CLIENT);
-  if (isSSH) {
-    console.log("\n  (SSH session detected \u2014 open the Host UI URL above in a local browser)");
+  if (isDaemonChild && typeof process.send === "function") {
+    process.send({ type: "ready", port, controlUrl, viewerUrl: qrTarget, pairingCode: displayCode });
+  }
+  if (isDaemonChild) {
+  } else if (env.isSSH) {
+    if (isLoopbackBind(HOST_BIND)) {
+      console.log("\n  (SSH session detected but server is bound to localhost \u2014 set HOST_BIND=0.0.0.0 to allow remote access)");
+    } else {
+      console.log("\n  (SSH session \u2014 open the Host UI URL above in a browser on your local machine)");
+    }
   } else {
-    import("node:child_process").then(({ exec }) => {
+    import("node:child_process").then(({ execFile }) => {
       const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-      exec(`${cmd} ${controlUrl}`);
+      execFile(cmd, [controlUrl]);
     }).catch(() => {
     });
   }
@@ -2593,7 +2840,44 @@ async function main() {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
-main().catch((err) => {
-  logError("Fatal error:", err);
-  process.exit(1);
-});
+var _cmd = process.argv[2];
+if (_cmd === "start" || _cmd === "stop" || _cmd === "list") {
+  (async () => {
+    const _args = process.argv.slice(3);
+    if (_cmd === "list") {
+      handleList();
+      return;
+    }
+    if (_cmd === "stop") {
+      let stopName = null;
+      let stopAll = false;
+      for (const a of _args) {
+        if (a === "--all") stopAll = true;
+        else if (!a.startsWith("-")) stopName = a;
+      }
+      handleStop(stopName, stopAll);
+      return;
+    }
+    let startName = "default";
+    const hostArgs = [];
+    for (let i = 0; i < _args.length; i++) {
+      const a = _args[i];
+      if (a === "--name" && i + 1 < _args.length) {
+        startName = _args[++i];
+      } else if (a.startsWith("--name=")) {
+        startName = a.slice(7);
+      } else {
+        hostArgs.push(a);
+      }
+    }
+    await handleStart(startName, hostArgs);
+  })().catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+  });
+} else {
+  main().catch((err) => {
+    logError("Fatal error:", err);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airloom",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Run AI on your computer, control it from your phone. E2E encrypted.",
   "type": "module",
   "bin": {