codeam-cli 1.4.1 → 1.4.2

package/dist/index.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/commands/start.ts
-var fs4 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
+var path5 = __toESM(require("path"));
 var import_crypto = require("crypto");
 var import_picocolors2 = __toESM(require("picocolors"));
 
@@ -114,7 +114,7 @@ var import_picocolors = __toESM(require("picocolors"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "1.4.1",
+  version: "1.4.2",
   description: "Remote control Claude Code from your mobile device",
   main: "dist/index.js",
   bin: {
@@ -594,13 +594,13 @@ var UnixPtyStrategy = class {
   opts;
   proc = null;
   helperPath = null;
-  spawn(cmd, cwd) {
+  spawn(cmd, cwd, args2 = []) {
     const python = findInPath("python3") ?? findInPath("python");
     if (!python) {
       console.error(
         "  \xB7 python3 not found; mobile command injection may be limited.\n"
       );
-      this.spawnDirect(cmd, cwd);
+      this.spawnDirect(cmd, cwd, args2);
       return;
     }
     const shell = process.env.SHELL || "/bin/sh";
@@ -608,7 +608,8 @@ var UnixPtyStrategy = class {
     const rows = process.stdout.rows || 50;
     this.helperPath = path3.join(os3.tmpdir(), "codeam-pty-helper.py");
     fs3.writeFileSync(this.helperPath, PYTHON_PTY_HELPER, { mode: 420 });
-    this.proc = (0, import_child_process.spawn)(python, [this.helperPath, shell, "-c", `exec ${cmd}`], {
+    const fullCmd = args2.length > 0 ? `${cmd} ${args2.join(" ")}` : cmd;
+    this.proc = (0, import_child_process.spawn)(python, [this.helperPath, shell, "-c", `exec ${fullCmd}`], {
       stdio: ["pipe", "pipe", "inherit"],
       cwd,
       env: {
@@ -645,8 +646,8 @@ var UnixPtyStrategy = class {
    * Python-unavailable fallback: direct spawn without PTY.
    * Mobile command injection is limited (no real TTY for Claude).
    */
-  spawnDirect(cmd, cwd) {
-    this.proc = (0, import_child_process.spawn)(cmd, [], {
+  spawnDirect(cmd, cwd, args2 = []) {
+    this.proc = (0, import_child_process.spawn)(cmd, args2, {
       stdio: ["pipe", "inherit", "inherit"],
       cwd,
       env: process.env,
@@ -719,8 +720,8 @@ var WindowsPtyStrategy = class {
   }
   opts;
   proc = null;
-  spawn(cmd, cwd) {
-    this.proc = (0, import_child_process2.spawn)(cmd, [], {
+  spawn(cmd, cwd, args2 = []) {
+    this.proc = (0, import_child_process2.spawn)(cmd, args2, {
       stdio: ["pipe", "pipe", "inherit"],
       cwd,
       env: {
@@ -849,6 +850,17 @@ var ClaudeService = class {
   kill() {
     this.strategy.kill();
   }
+  /**
+   * Kill the current Claude process and relaunch it resuming the given session.
+   * Pass auto=true to add --dangerously-skip-permissions (no confirmation prompts).
+   */
+  restart(sessionId, auto = false) {
+    const claudeCmd = findInPath("claude") ? "claude" : "claude-code";
+    this.strategy.kill();
+    const args2 = ["--resume", sessionId];
+    if (auto) args2.push("--dangerously-skip-permissions");
+    this.strategy.spawn(claudeCmd, this.opts.cwd, args2);
+  }
 };
 
 // src/services/output.service.ts
@@ -1126,6 +1138,22 @@ var OutputService = class _OutputService {
     });
     this.pollTimer = setInterval(() => this.tick(), _OutputService.POLL_MS);
   }
+  /**
+   * Like newTurn() but signals clients that a session is being resumed.
+   * The resumedSessionId tells clients to fetch the conversation from the API.
+   * Awaits the POST so callers can guarantee the signal is sent before restarting Claude.
+   */
+  async newTurnResume(resumedSessionId) {
+    this.stopPoll();
+    this.rawBuffer = "";
+    this.lastSentContent = "";
+    this.lastPushTime = 0;
+    this.active = true;
+    this.startTime = Date.now();
+    await this.postChunk({ clear: true });
+    await this.postChunk({ type: "new_turn", resumedSessionId, content: "", done: false });
+    this.pollTimer = setInterval(() => this.tick(), _OutputService.POLL_MS);
+  }
   push(raw) {
     if (!this.active) return;
     this.rawBuffer += raw;
@@ -1242,12 +1270,162 @@ var OutputService = class _OutputService {
   }
 };
 
+// src/services/history.service.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var os4 = __toESM(require("os"));
+var https3 = __toESM(require("https"));
+var http3 = __toESM(require("http"));
+var API_BASE5 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+function encodeCwd(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((b) => b["type"] === "text").map((b) => b["text"]).join("\n");
+  }
+  return "";
+}
+function parseJsonl(filePath) {
+  const messages = [];
+  let raw;
+  try {
+    raw = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return messages;
+  }
+  const lines = raw.split("\n").filter(Boolean);
+  for (const line of lines) {
+    try {
+      const record = JSON.parse(line);
+      const type = record["type"];
+      const msg = record["message"];
+      const ts = record["timestamp"];
+      const timestamp = typeof ts === "string" ? new Date(ts).getTime() : typeof ts === "number" ? ts : Date.now();
+      const uuid = record["uuid"] ?? `${Date.now()}-${Math.random()}`;
+      if (type === "user" && msg) {
+        const text = extractText(msg["content"]).trim();
+        if (text) messages.push({ id: uuid, role: "user", text, timestamp });
+      } else if (type === "assistant" && msg) {
+        const text = extractText(msg["content"]).trim();
+        if (text) messages.push({ id: uuid, role: "agent", text, timestamp });
+      }
+    } catch {
+    }
+  }
+  return messages;
+}
+function post(endpoint, body) {
+  return new Promise((resolve) => {
+    const payload = JSON.stringify(body);
+    const u = new URL(`${API_BASE5}${endpoint}`);
+    const transport = u.protocol === "https:" ? https3 : http3;
+    const req = transport.request(
+      {
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        timeout: 8e3
+      },
+      (res) => {
+        res.resume();
+        resolve();
+      }
+    );
+    req.on("error", () => resolve());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+var HistoryService = class {
+  constructor(pluginId, cwd) {
+    this.pluginId = pluginId;
+    this.cwd = cwd;
+  }
+  pluginId;
+  cwd;
+  get projectDir() {
+    return path4.join(os4.homedir(), ".claude", "projects", encodeCwd(this.cwd));
+  }
+  /**
+   * Read session list from disk and POST it to the API.
+   * Called once ~2 s after Claude spawns (non-blocking).
+   */
+  async load() {
+    const dir = this.projectDir;
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const sessions2 = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+      const id = path4.basename(entry.name, ".jsonl");
+      const filePath = path4.join(dir, entry.name);
+      let mtime = Date.now();
+      try {
+        mtime = fs4.statSync(filePath).mtimeMs;
+      } catch {
+      }
+      let summary = "";
+      try {
+        const raw = fs4.readFileSync(filePath, "utf8");
+        for (const line of raw.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const record = JSON.parse(line);
+            if (record["type"] === "user") {
+              const msg = record["message"];
+              const text = extractText(msg?.["content"]).trim();
+              if (text) {
+                summary = text.slice(0, 120);
+                break;
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      if (summary) sessions2.push({ id, summary, timestamp: mtime });
+    }
+    if (sessions2.length === 0) return;
+    sessions2.sort((a, b) => b.timestamp - a.timestamp);
+    await post("/api/sessions/claude-sessions", { pluginId: this.pluginId, sessions: sessions2 });
+  }
+  /**
+   * Read a specific session's full conversation and POST it to the API.
+   * Called before sending the resume signal so clients can fetch it immediately.
+   */
+  async loadConversation(sessionId) {
+    const filePath = path4.join(this.projectDir, `${sessionId}.jsonl`);
+    const messages = parseJsonl(filePath);
+    await post("/api/sessions/claude-conversation", {
+      pluginId: this.pluginId,
+      sessionId,
+      messages
+    });
+  }
+};
+
 // src/commands/start.ts
 function saveFilesTemp(files) {
   return files.filter(({ base64 }) => base64 && base64.length > 0).map(({ filename, base64 }) => {
     const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
-    const tmpPath = path4.join(os4.tmpdir(), `codeam-${(0, import_crypto.randomUUID)()}-${safeName}`);
-    fs4.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+    const tmpPath = path5.join(os5.tmpdir(), `codeam-${(0, import_crypto.randomUUID)()}-${safeName}`);
+    fs5.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     return tmpPath;
   });
 }
@@ -1269,7 +1447,7 @@ async function start() {
     outputSvc.newTurn();
     claude.sendCommand(prompt);
   }
-  const relay = new CommandRelayService(pluginId, (cmd) => {
+  const relay = new CommandRelayService(pluginId, async (cmd) => {
     switch (cmd.type) {
       case "start_task": {
         const prompt = cmd.payload.prompt;
@@ -1283,7 +1461,7 @@ async function start() {
           setTimeout(() => {
             for (const p2 of paths) {
               try {
-                fs4.unlinkSync(p2);
+                fs5.unlinkSync(p2);
               } catch {
               }
             }
@@ -1312,6 +1490,15 @@ async function start() {
       case "stop_task":
         claude.interrupt();
         break;
+      case "resume_session": {
+        const id = cmd.payload.id;
+        const auto = cmd.payload.auto ?? false;
+        if (!id) break;
+        await historySvc.loadConversation(id);
+        await outputSvc.newTurnResume(id);
+        claude.restart(id, auto);
+        break;
+      }
     }
   });
   ws.addHandler({
@@ -1335,7 +1522,7 @@ async function start() {
           setTimeout(() => {
             for (const p2 of paths) {
               try {
-                fs4.unlinkSync(p2);
+                fs5.unlinkSync(p2);
               } catch {
               }
             }
@@ -1356,6 +1543,15 @@ async function start() {
         claude.sendEscape();
       } else if (cmdType === "stop_task") {
         claude.interrupt();
+      } else if (cmdType === "resume_session") {
+        const id = inner.id;
+        const auto = inner.auto ?? false;
+        if (id) {
+          historySvc.loadConversation(id).then(() => outputSvc.newTurnResume(id)).then(() => {
+            claude.restart(id, auto);
+          }).catch(() => {
+          });
+        }
       }
     }
   });
@@ -1383,6 +1579,11 @@ async function start() {
   }
   process.once("SIGINT", sigintHandler);
   claude.spawn();
+  const historySvc = new HistoryService(pluginId, process.cwd());
+  setTimeout(() => {
+    historySvc.load().catch(() => {
+    });
+  }, 2e3);
 }
 
 // src/commands/pair.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Remote control Claude Code from your mobile device",
   "main": "dist/index.js",
   "bin": {