airloom 0.1.3 → 0.1.4

package/dist/index.js

@@ -267,7 +267,7 @@ var Channel = class extends EventEmitter2 {
   }
   waitForReady(timeoutMs = 3e4) {
     if (this._ready) return Promise.resolve();
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const cleanup = () => {
         clearTimeout(timer);
         this.removeListener("ready", onReady);
@@ -276,7 +276,7 @@ var Channel = class extends EventEmitter2 {
       };
       const onReady = () => {
         cleanup();
-        resolve2();
+        resolve3();
       };
       const onError = (err) => {
         cleanup();
@@ -373,14 +373,14 @@ var WebSocketAdapter = class {
   }
   async doConnect() {
     const ws = await this.createWebSocket(this.url);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       ws.onopen = () => {
         this._connected = true;
         this.shouldReconnect = true;
         this.reconnectAttempts = 0;
         const msg = this.role === "host" ? { type: "create", sessionToken: this.sessionToken } : { type: "join", sessionToken: this.sessionToken };
         ws.send(JSON.stringify(msg));
-        resolve2();
+        resolve3();
       };
       ws.onmessage = (event) => {
         const raw = event.data;
@@ -510,8 +510,8 @@ var AblyAdapter = class {
       clientOpts.token = this.opts.token;
     }
     this.ably = new Realtime(clientOpts);
-    await new Promise((resolve2, reject) => {
-      this.ably.connection.once("connected", () => resolve2());
+    await new Promise((resolve3, reject) => {
+      this.ably.connection.once("connected", () => resolve3());
       this.ably.connection.once("failed", (stateChange) => {
         reject(new Error(stateChange?.reason?.message ?? "Ably connection failed"));
       });
@@ -598,14 +598,14 @@ var AblyAdapter = class {
 import { sha256 as sha2562 } from "@noble/hashes/sha256";
 import { networkInterfaces } from "os";
 import { fileURLToPath } from "url";
-import { dirname, resolve } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { existsSync as existsSync3 } from "fs";
 import QRCode from "qrcode";
 
 // src/server.ts
 import express from "express";
 import { createServer } from "http";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/adapters/anthropic.ts
@@ -739,85 +739,266 @@ var OpenAIAdapter = class {
 
 // src/adapters/cli.ts
 import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { delimiter, isAbsolute, join, resolve } from "path";
 var CLI_PRESETS = [
   {
     id: "devin",
     name: "Devin",
-    command: "devin --permission-mode dangerous -p --",
-    description: "Devin CLI in non-interactive print mode"
+    command: "devin",
+    description: "Devin CLI (persistent REPL session)",
+    mode: "repl",
+    silenceTimeout: 8e3
   },
   {
     id: "claude-code",
     name: "Claude Code",
+    command: "claude",
+    description: "Claude Code (persistent REPL session)",
+    mode: "repl",
+    silenceTimeout: 8e3
+  },
+  {
+    id: "claude-code-oneshot",
+    name: "Claude Code (one-shot)",
     command: "claude -p --output-format text",
-    description: "Claude Code in print mode"
+    description: "Claude Code in print mode (new process per prompt)",
+    mode: "oneshot"
   },
   {
     id: "codex",
     name: "Codex",
     command: "codex exec --full-auto",
-    description: "OpenAI Codex CLI in non-interactive exec mode"
+    description: "OpenAI Codex CLI in non-interactive exec mode",
+    mode: "oneshot"
   },
   {
     id: "aider",
     name: "Aider",
     command: "aider --yes --no-auto-commits --message",
-    description: "Aider in scripting mode (prompt via --message)"
+    description: "Aider in scripting mode (prompt via --message)",
+    mode: "oneshot"
   },
   {
     id: "custom",
     name: "Custom",
     command: "",
-    description: "Custom command \u2014 prompt appended as last argument"
+    description: "Custom command (default: one-shot, prompt appended as last arg)",
+    mode: "oneshot"
   }
 ];
+var ANSI_RE = /[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nq-uy=><~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[^[\]()#;?][^\x1b]?|\r/g;
+var stripAnsi = (s) => s.replace(ANSI_RE, "");
+var isDecorativeLine = (line) => {
+  const t = line.trim();
+  if (!t) return false;
+  return /^[╭╰╮╯│├┤┬┴┼─━═┄┈┌┐└┘║╔╗╚╝╠╣╦╩╬▔▁░▒▓█\-+|=*~_\s]+$/.test(t);
+};
+var isNoiseLine = (line) => {
+  const t = line.trim();
+  if (!t) return false;
+  return t === "#" || t.includes("Devin for Terminal") || /^v\d{4}\./.test(t) || t.startsWith("Mode: ") || t.includes("Tip: Use shift+tab") || t.startsWith("Update v") || t.includes("\u2219 Pro");
+};
+function resolveExecutable(command, envPath = process.env.PATH ?? "") {
+  if (!command) return null;
+  if (isAbsolute(command) && existsSync(command)) return command;
+  if (command.includes("/")) {
+    const candidate = resolve(process.cwd(), command);
+    return existsSync(candidate) ? candidate : null;
+  }
+  for (const dir of envPath.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"), command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
 var CLIAdapter = class {
   name = "cli";
   model;
   command;
   args;
+  mode;
+  silenceTimeout;
+  pty = null;
+  ptyState = "starting";
+  startupResolve = null;
+  startupTimer = null;
+  activeStream = null;
+  activeResolve = null;
+  silenceTimer = null;
+  lastInput = "";
   constructor(config) {
     if (!config.command) throw new Error("Command is required for CLI adapter");
-    const parts = config.command.split(" ");
+    const parts = config.command.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [config.command];
     this.command = parts[0];
-    this.args = parts.slice(1);
-    this.model = config.model || config.command;
+    this.args = parts.slice(1).map((a) => a.replace(/^"|"$/g, ""));
+    this.mode = config.mode ?? "oneshot";
+    this.silenceTimeout = config.silenceTimeout ?? 5e3;
+    this.model = config.model || `${config.command} (${this.mode})`;
   }
   async streamResponse(messages, stream) {
+    if (this.mode === "repl") return this.replResponse(messages, stream);
+    return this.oneshotResponse(messages, stream);
+  }
+  destroy() {
+    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+    if (this.startupTimer) clearTimeout(this.startupTimer);
+    try {
+      this.pty?.kill();
+    } catch {
+    }
+    this.pty = null;
+    this.finishResponse();
+  }
+  // --- oneshot ----------------------------------------------------------------
+  async oneshotResponse(messages, stream) {
     const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
     if (!lastUserMsg) {
       stream.write("[No user message provided]");
       stream.end();
       return;
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolvePromise) => {
       const args = [...this.args, lastUserMsg.content];
-      const proc = spawn(this.command, args, {
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+      const proc = spawn(this.command, args, { stdio: ["pipe", "pipe", "pipe"] });
       proc.stdin.end();
       proc.stdout.on("data", (data) => stream.write(stripAnsi(data.toString())));
       proc.stderr.on("data", (data) => stream.write(stripAnsi(data.toString())));
       proc.on("close", () => {
         stream.end();
-        resolve2();
+        resolvePromise();
       });
       proc.on("error", (err) => {
         stream.write(`[Error: ${err.message}]`);
         stream.end();
-        resolve2();
+        resolvePromise();
       });
     });
   }
+  // --- repl -------------------------------------------------------------------
+  async ensurePty() {
+    if (this.pty) return this.pty;
+    const nodePty = await import("node-pty");
+    const executable = resolveExecutable(this.command) ?? this.command;
+    console.log(`[cli-repl] Spawning PTY: ${executable} ${this.args.join(" ")}`);
+    const pty = nodePty.spawn(executable, this.args, {
+      name: "xterm-256color",
+      cols: 120,
+      rows: 40,
+      cwd: process.cwd(),
+      env: { ...process.env, NO_COLOR: "1" }
+    });
+    pty.onData((data) => this.onData(data));
+    pty.onExit(({ exitCode }) => {
+      console.log(`[cli-repl] PTY exited (code ${exitCode})`);
+      this.pty = null;
+      this.ptyState = "idle";
+      this.finishResponse();
+    });
+    this.pty = pty;
+    this.ptyState = "starting";
+    await new Promise((resolvePromise) => {
+      this.startupResolve = resolvePromise;
+      const maxTimer = setTimeout(() => {
+        if (this.ptyState === "starting") {
+          this.ptyState = "idle";
+          this.startupResolve?.();
+          this.startupResolve = null;
+        }
+        if (this.startupTimer) {
+          clearTimeout(this.startupTimer);
+          this.startupTimer = null;
+        }
+      }, 5e3);
+      pty.onExit(() => {
+        clearTimeout(maxTimer);
+        resolvePromise();
+      });
+    });
+    return pty;
+  }
+  onData(raw) {
+    const clean = stripAnsi(raw);
+    switch (this.ptyState) {
+      case "starting":
+        if (this.startupTimer) clearTimeout(this.startupTimer);
+        this.startupTimer = setTimeout(() => {
+          this.ptyState = "idle";
+          this.startupResolve?.();
+          this.startupResolve = null;
+        }, 2e3);
+        break;
+      case "idle":
+        break;
+      case "responding": {
+        if (!this.activeStream || !clean) break;
+        const filtered = this.filterOutput(clean);
+        if (filtered) this.activeStream.write(filtered);
+        this.resetSilenceTimer();
+        break;
+      }
+    }
+  }
+  filterOutput(text) {
+    const lines = text.split("\n");
+    const kept = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        kept.push(line);
+        continue;
+      }
+      if (this.lastInput && (trimmed === this.lastInput.trim() || trimmed === `> ${this.lastInput.trim()}`)) continue;
+      if (isDecorativeLine(line) || isNoiseLine(line)) continue;
+      kept.push(line);
+    }
+    return kept.join("\n").replace(/^\n+/, "");
+  }
+  resetSilenceTimer() {
+    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+    this.silenceTimer = setTimeout(() => {
+      this.ptyState = "idle";
+      this.finishResponse();
+    }, this.silenceTimeout);
+  }
+  finishResponse() {
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+      this.silenceTimer = null;
+    }
+    const stream = this.activeStream;
+    const resolvePromise = this.activeResolve;
+    this.activeStream = null;
+    this.activeResolve = null;
+    if (stream && !stream.ended) stream.end();
+    resolvePromise?.();
+  }
+  async replResponse(messages, stream) {
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+    if (!lastUserMsg) {
+      stream.write("[No user message provided]");
+      stream.end();
+      return;
+    }
+    const pty = await this.ensurePty();
+    return new Promise((resolvePromise) => {
+      this.activeStream = stream;
+      this.activeResolve = resolvePromise;
+      this.ptyState = "responding";
+      this.lastInput = lastUserMsg.content;
+      pty.write(lastUserMsg.content + "\r");
+      this.resetSilenceTimer();
+    });
+  }
 };
 
 // src/config.ts
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-var CONFIG_DIR = join(homedir(), ".config", "airloom");
-var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+import { join as join2 } from "path";
+var CONFIG_DIR = join2(homedir(), ".config", "airloom");
+var CONFIG_PATH = join2(CONFIG_DIR, "config.json");
 function loadConfig() {
   try {
     const raw = readFileSync(CONFIG_PATH, "utf-8");
@@ -858,7 +1039,7 @@ function createHostServer(opts) {
   app.get("/", (_req, res) => {
     res.type("html").send(HOST_HTML);
   });
-  if (opts.viewerDir && existsSync(opts.viewerDir)) {
+  if (opts.viewerDir && existsSync2(opts.viewerDir)) {
     app.use("/viewer", express.static(opts.viewerDir));
   }
   app.get("/api/status", (_req, res) => {
@@ -912,7 +1093,13 @@ function createHostServer(opts) {
             res.status(400).json({ error: "CLI adapter requires a command (or set AIRLOOM_CLI_COMMAND env var)" });
             return;
           }
-          opts.state.adapter = new CLIAdapter({ command: cmd, model });
+          const presetInfo = preset ? CLI_PRESETS.find((p) => p.id === preset) : void 0;
+          opts.state.adapter = new CLIAdapter({
+            command: cmd,
+            model,
+            mode: presetInfo?.mode,
+            silenceTimeout: presetInfo?.silenceTimeout
+          });
           break;
         }
         default:
@@ -957,11 +1144,11 @@ function createHostServer(opts) {
       if (ws.readyState === WebSocket.OPEN) ws.send(msg);
     }
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     server.listen(opts.port, "0.0.0.0", () => {
       const addr = server.address();
       const actualPort = typeof addr === "object" && addr ? addr.port : opts.port;
-      resolve2({ server, broadcast, port: actualPort });
+      resolve3({ server, broadcast, port: actualPort });
     });
     server.on("error", (err) => {
       console.error(`[host] Server error: ${err.message}`);
@@ -972,19 +1159,25 @@ function createHostServer(opts) {
 async function handleAIResponse(channel, adapter, state, broadcast) {
   const stream = channel.createStream({ model: adapter.model });
   let fullResponse = "";
-  const batcher = new Batcher({
+  const uiBatcher = new Batcher({
     interval: 100,
     onFlush: (data) => broadcast({ type: "stream_chunk", data })
   });
   const origWrite = stream.write.bind(stream);
+  const relayBatcher = new Batcher({
+    interval: 500,
+    maxBytes: 4096,
+    onFlush: (data) => origWrite(data)
+  });
   stream.write = (data) => {
     fullResponse += data;
-    batcher.write(data);
-    origWrite(data);
+    uiBatcher.write(data);
+    relayBatcher.write(data);
   };
   const origEnd = stream.end.bind(stream);
   stream.end = () => {
-    batcher.flush();
+    uiBatcher.flush();
+    relayBatcher.flush();
     broadcast({ type: "stream_end" });
     state.messages.push({ role: "assistant", content: fullResponse, timestamp: Date.now() });
     trimMessages(state.messages);
@@ -998,7 +1191,8 @@ async function handleAIResponse(channel, adapter, state, broadcast) {
       stream.write(`[Error: ${message}]`);
       stream.end();
     }
-    batcher.destroy();
+    uiBatcher.destroy();
+    relayBatcher.destroy();
   }
 }
 var HOST_HTML = `<!DOCTYPE html>
@@ -1239,10 +1433,10 @@ function getLanIP() {
   return void 0;
 }
 function resolveViewerDir() {
-  const prod = resolve(__dirname, "viewer");
-  if (existsSync2(prod)) return prod;
-  const dev = resolve(__dirname, "../../viewer/dist");
-  if (existsSync2(dev)) return dev;
+  const prod = resolve2(__dirname, "viewer");
+  if (existsSync3(prod)) return prod;
+  const dev = resolve2(__dirname, "../../viewer/dist");
+  if (existsSync3(dev)) return dev;
   return void 0;
 }
 async function main() {
@@ -1308,17 +1502,22 @@ async function main() {
   };
   if (cliArgs.cli || cliArgs.preset) {
     let command = cliArgs.cli;
-    if (!command && cliArgs.preset) {
-      const preset = CLI_PRESETS.find((p) => p.id === cliArgs.preset);
-      if (!preset) {
+    let presetInfo;
+    if (cliArgs.preset) {
+      presetInfo = CLI_PRESETS.find((p) => p.id === cliArgs.preset);
+      if (!presetInfo) {
         console.error(`[host] Unknown preset "${cliArgs.preset}". Available: ${CLI_PRESETS.map((p) => p.id).join(", ")}`);
         process.exit(1);
       }
-      command = preset.command;
+      if (!command) command = presetInfo.command;
     }
     if (command) {
-      state.adapter = new CLIAdapter({ command });
-      console.log(`[host] CLI adapter: ${command}`);
+      state.adapter = new CLIAdapter({
+        command,
+        mode: presetInfo?.mode,
+        silenceTimeout: presetInfo?.silenceTimeout
+      });
+      console.log(`[host] CLI adapter: ${command} (${presetInfo?.mode ?? "oneshot"})`);
     }
   } else {
     const saved = loadConfig();
@@ -1341,8 +1540,14 @@ async function main() {
           }
           case "cli": {
             const cmd = saved.command || process.env.AIRLOOM_CLI_COMMAND;
+            const savedPreset = saved.preset ? CLI_PRESETS.find((p) => p.id === saved.preset) : void 0;
             if (cmd) {
-              state.adapter = new CLIAdapter({ command: cmd, model: saved.model });
+              state.adapter = new CLIAdapter({
+                command: cmd,
+                model: saved.model,
+                mode: savedPreset?.mode,
+                silenceTimeout: savedPreset?.silenceTimeout
+              });
             }
             break;
           }
@@ -1418,6 +1623,7 @@ async function main() {
     if (shuttingDown) return;
     shuttingDown = true;
     console.log("\n[host] Shutting down...");
+    state.adapter?.destroy?.();
     try {
       channel.close();
     } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airloom",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Run AI on your computer, control it from your phone. E2E encrypted.",
   "type": "module",
   "bin": {
@@ -15,6 +15,7 @@
     "ably": "^2.20.0",
     "events": "^3.3.0",
     "express": "^5.1.0",
+    "node-pty": "^1.1.0",
     "qrcode": "^1.5.0",
     "tweetnacl": "^1.0.3",
     "ws": "^8.18.0"