codeam-cli 2.15.1 → 2.15.5

package/dist/index.js

@@ -386,8 +386,8 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.15.1",
-  description: "Remote control Claude Code (and other AI coding agents) from your mobile phone. Pair your device, send prompts, stream responses in real-time, and approve commands \u2014 from anywhere.",
+  version: "2.15.5",
+  description: "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device \u2014 async. The terminal companion for CodeAgent Mobile.",
   type: "commonjs",
   main: "dist/index.js",
   bin: {
@@ -410,29 +410,29 @@ var package_default = {
   keywords: [
     "claude",
     "claude-code",
-    "claude-code-mobile",
     "ai",
     "ai-agent",
     "ai-coding",
-    "ai-pair-programming",
+    "ai-workflow",
+    "ai-workflow-continuity",
+    "async-ai-productivity",
+    "remote-ai-supervision",
     "cli",
-    "remote-control",
-    "remote-development",
-    "mobile-ide",
-    "mobile-coding",
-    "pair-programming",
+    "developer-tools",
+    "devtools",
     "codeagent",
     "codeam",
     "anthropic",
+    "openai-codex",
     "cursor",
     "copilot",
     "jetbrains",
     "vscode",
+    "windsurf",
     "mcp",
-    "code-from-phone",
-    "afk-coding",
-    "remote-pair-programming",
-    "agent-control"
+    "remote-development",
+    "agent-control",
+    "agent-operations"
   ],
   homepage: "https://codeagent-mobile.com",
   bugs: {
@@ -456,6 +456,7 @@ var package_default = {
   },
   dependencies: {
     "@clack/prompts": "^1.2.0",
+    chokidar: "^3.6.0",
     picocolors: "^1.1.0",
     "qrcode-terminal": "^0.12.0",
     ws: "^8.18.0",
@@ -6125,6 +6126,460 @@ var HistoryService = class _HistoryService {
   }
 };
 
+// src/services/file-watcher.service.ts
+var import_child_process6 = require("child_process");
+var path15 = __toESM(require("path"));
+
+// src/services/file-watcher/diff-parser.ts
+var HUNK_HEADER_RE = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+function parseUnifiedDiff(diff) {
+  if (!diff || diff.trim().length === 0) {
+    return {
+      fileStatus: "modified",
+      hunks: [],
+      totalLinesAdded: 0,
+      totalLinesRemoved: 0
+    };
+  }
+  const rawLines = diff.split(/\r?\n/);
+  const fileStatus = detectFileStatus(rawLines);
+  const hunks = [];
+  let current = null;
+  let oldLine = 0;
+  let newLine = 0;
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  for (const raw of rawLines) {
+    if (raw.startsWith("@@")) {
+      const match = raw.match(HUNK_HEADER_RE);
+      if (!match) continue;
+      if (current) hunks.push(current);
+      oldLine = parseInt(match[1], 10);
+      newLine = parseInt(match[2], 10);
+      current = {
+        header: raw,
+        lines: [],
+        linesAdded: 0,
+        linesRemoved: 0
+      };
+      continue;
+    }
+    if (current === null) continue;
+    if (raw.startsWith("\\ No newline")) continue;
+    if (raw.startsWith("+")) {
+      current.lines.push({ type: "add", lineNumber: newLine, text: raw.slice(1) });
+      current.linesAdded += 1;
+      totalAdded += 1;
+      newLine += 1;
+      continue;
+    }
+    if (raw.startsWith("-")) {
+      current.lines.push({ type: "remove", lineNumber: oldLine, text: raw.slice(1) });
+      current.linesRemoved += 1;
+      totalRemoved += 1;
+      oldLine += 1;
+      continue;
+    }
+    if (raw.startsWith(" ")) {
+      current.lines.push({ type: "context", lineNumber: newLine, text: raw.slice(1) });
+      newLine += 1;
+      oldLine += 1;
+      continue;
+    }
+  }
+  if (current) hunks.push(current);
+  return {
+    fileStatus,
+    hunks,
+    totalLinesAdded: totalAdded,
+    totalLinesRemoved: totalRemoved
+  };
+}
+function detectFileStatus(rawLines) {
+  for (const line of rawLines) {
+    if (line.startsWith("@@")) break;
+    if (line.startsWith("new file mode")) return "added";
+    if (line.startsWith("deleted file mode")) return "deleted";
+    if (line.startsWith("rename from ") || line.startsWith("rename to ")) {
+      return "renamed";
+    }
+    if (line.startsWith("--- /dev/null")) return "added";
+    if (line.startsWith("+++ /dev/null")) return "deleted";
+  }
+  return "modified";
+}
+
+// src/services/file-watcher/transport.ts
+var http5 = __toESM(require("http"));
+var https5 = __toESM(require("https"));
+var _transport3 = {
+  post: _post2
+};
+function _post2(url, headers, payload) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const lib = u2.protocol === "https:" ? https5 : http5;
+    const req = lib.request(
+      {
+        hostname: u2.hostname,
+        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
+        path: u2.pathname + u2.search,
+        method: "POST",
+        headers: {
+          ...headers,
+          ...vercelBypassHeader(),
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        timeout: 8e3
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (c2) => {
+          body += c2.toString();
+        });
+        res.on("end", () => {
+          if (settled) return;
+          settled = true;
+          resolve2({ statusCode: res.statusCode ?? 0, body });
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+// src/services/file-watcher.service.ts
+var API_BASE5 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var DEBOUNCE_MS = 250;
+var MAX_RETRIES = 2;
+var RETRY_BACKOFF_MS = 300;
+var FileWatcherService = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.apiBase = opts.apiBaseUrl ?? API_BASE5;
+  }
+  opts;
+  watcher = null;
+  pending = /* @__PURE__ */ new Map();
+  apiBase;
+  stopped = false;
+  /**
+   * Start watching `opts.workingDir`. Idempotent (second call is a
+   * no-op). Resolves once chokidar's initial scan completes; that
+   * way the `start.ts` orchestrator can sequence "agent up → watcher
+   * ready" deterministically if it wants to, though today it
+   * doesn't await this.
+   */
+  async start() {
+    if (this.watcher) return;
+    if (this.stopped) {
+      throw new Error("FileWatcherService has already been stopped \u2014 re-instantiate to restart.");
+    }
+    let chokidar;
+    try {
+      chokidar = require("chokidar");
+    } catch (err) {
+      log.warn(
+        "fileWatcher",
+        `chokidar unavailable \u2014 file change emission disabled`,
+        err
+      );
+      return;
+    }
+    const watcher = chokidar.watch(this.opts.workingDir, {
+      ignored: [
+        /(^|[\\/])\../,
+        // dot-files & dot-dirs (.git, .next, .expo, .DS_Store, …)
+        /node_modules/,
+        /dist/,
+        /build/,
+        /out/,
+        /coverage/,
+        /\.turbo/,
+        /\.cache/,
+        /\.parcel-cache/,
+        // Build outputs that aren't a typical "dist" target
+        /target\//,
+        /__pycache__/
+      ],
+      ignoreInitial: true,
+      // we only care about post-start changes
+      persistent: true,
+      awaitWriteFinish: {
+        // Coalesces rapid sequential writes (npm install spam, build
+        // tools emitting bursts). Lower than chokidar's default so
+        // the user sees their Files screen update within 0.5 s of
+        // saving.
+        stabilityThreshold: 150,
+        pollInterval: 50
+      }
+    });
+    watcher.on("add", (filePath) => this.schedule(filePath, "add"));
+    watcher.on("change", (filePath) => this.schedule(filePath, "change"));
+    watcher.on("unlink", (filePath) => this.schedule(filePath, "unlink"));
+    this.watcher = watcher;
+    log.info(
+      "fileWatcher",
+      `watching ${this.opts.workingDir} for session=${this.opts.sessionId.slice(0, 8)}`
+    );
+  }
+  /**
+   * Stop watching. Idempotent — safe to call multiple times. After
+   * stop, the instance is dead; create a new one to resume. (This
+   * matches the `OutputService` / `CommandRelayService` style.)
+   */
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+    }
+    this.pending.clear();
+    if (this.watcher) {
+      try {
+        await this.watcher.close();
+      } catch (err) {
+        log.warn("fileWatcher", "error closing chokidar", err);
+      }
+      this.watcher = null;
+    }
+    log.info("fileWatcher", `stopped (session=${this.opts.sessionId.slice(0, 8)})`);
+  }
+  /**
+   * Coalesce rapid writes per-file. Each fresh event resets the
+   * 250 ms debounce timer. When the timer fires, we compute the
+   * diff once and emit.
+   *
+   * `unlink` events bypass the diff path — we emit a synthetic
+   * deletion directly because `git diff <path>` for a removed file
+   * produces a diff that's already encoded as a deletion in
+   * `parseUnifiedDiff`, but in practice the file is gone and the
+   * synthetic path is simpler and avoids a race with git's index.
+   */
+  schedule(absPath, changeType) {
+    if (this.stopped) return;
+    const existing = this.pending.get(absPath);
+    if (existing) clearTimeout(existing.timer);
+    const timer = setTimeout(() => {
+      this.pending.delete(absPath);
+      void this.emitForFile(absPath, changeType);
+    }, DEBOUNCE_MS);
+    this.pending.set(absPath, {
+      lastEventAt: Date.now(),
+      timer,
+      changeType
+    });
+  }
+  /**
+   * Visible for tests — lets vitest pump a synthetic file event
+   * through the debounce + diff + emit pipeline without spinning up
+   * a real chokidar watcher.
+   */
+  /* @internal */
+  _scheduleForTest(absPath, changeType) {
+    this.schedule(absPath, changeType);
+  }
+  async emitForFile(absPath, changeType) {
+    if (this.stopped) return;
+    const relPath = path15.relative(this.opts.workingDir, absPath);
+    if (!relPath || relPath.startsWith("..")) {
+      return;
+    }
+    let diffText = "";
+    let fileStatus = "modified";
+    if (changeType === "unlink") {
+      const diff = await this.gitDiff(relPath);
+      if (diff !== null && diff.trim().length > 0) {
+        diffText = diff;
+      } else {
+        await this.postFileChanged({
+          sessionId: this.opts.sessionId,
+          pluginId: this.opts.pluginId,
+          filePath: relPath,
+          fileStatus: "deleted",
+          linesAdded: 0,
+          linesRemoved: 0,
+          hunkCount: 0
+        });
+        return;
+      }
+      fileStatus = "deleted";
+    } else {
+      const diff = await this.gitDiff(relPath);
+      if (diff === null) {
+        log.warn(
+          "fileWatcher",
+          `git diff failed for ${relPath} \u2014 emitting file-changed only`
+        );
+        await this.postFileChanged({
+          sessionId: this.opts.sessionId,
+          pluginId: this.opts.pluginId,
+          filePath: relPath,
+          fileStatus: changeType === "add" ? "added" : "modified",
+          linesAdded: 0,
+          linesRemoved: 0,
+          hunkCount: 0
+        });
+        return;
+      }
+      diffText = diff;
+    }
+    const parsed = parseUnifiedDiff(diffText);
+    const finalStatus = parsed.fileStatus !== "modified" ? parsed.fileStatus : changeType === "add" ? "added" : changeType === "unlink" ? "deleted" : fileStatus;
+    const reviewStatus = parsed.hunks.length > 0 ? "awaiting_review" : void 0;
+    await this.postFileChanged({
+      sessionId: this.opts.sessionId,
+      pluginId: this.opts.pluginId,
+      filePath: relPath,
+      fileStatus: finalStatus,
+      linesAdded: parsed.totalLinesAdded,
+      linesRemoved: parsed.totalLinesRemoved,
+      hunkCount: parsed.hunks.length,
+      reviewStatus
+    });
+    for (const hunk of parsed.hunks) {
+      await this.postReviewHunk({
+        sessionId: this.opts.sessionId,
+        pluginId: this.opts.pluginId,
+        filePath: relPath,
+        fileStatus: finalStatus,
+        hunkHeader: hunk.header,
+        lines: hunk.lines,
+        linesAdded: hunk.linesAdded,
+        linesRemoved: hunk.linesRemoved
+      });
+    }
+  }
+  /**
+   * Compute the unified diff for a single path relative to the
+   * working dir. Returns `null` when git is unavailable or the cwd
+   * is not a repo. Returns `''` when there's no diff (a touch that
+   * didn't change content).
+   *
+   * For tracked files we use `git diff --no-color -- <path>` which
+   * compares the worktree against HEAD's blob.
+   * For untracked files (`git ls-files --error-unmatch` exits non-
+   * zero) we use `git diff --no-color --no-index /dev/null <path>`,
+   * which produces an "added"-shaped diff against an empty source.
+   */
+  async gitDiff(relPath) {
+    const tracked = await runGit(
+      this.opts.workingDir,
+      ["diff", "--no-color", "--", relPath]
+    );
+    if (tracked === null) return null;
+    if (tracked.trim().length > 0) return tracked;
+    const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
+    const untracked = await runGit(
+      this.opts.workingDir,
+      ["diff", "--no-color", "--no-index", "--", devNull, relPath],
+      { allowNonZeroExit: true }
+    );
+    return untracked ?? "";
+  }
+  async postFileChanged(body) {
+    await this.postWithRetries(`${this.apiBase}/api/files/changed`, body);
+  }
+  async postReviewHunk(body) {
+    await this.postWithRetries(`${this.apiBase}/api/review/hunks`, body);
+  }
+  async postWithRetries(url, body) {
+    const payload = JSON.stringify(body);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Codeam-Protocol-Version": "2.0.0",
+      "X-Plugin-Auth-Token": this.opts.pluginAuthToken
+    };
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
+      try {
+        const { statusCode, body: resBody } = await _transport3.post(url, headers, payload);
+        if (statusCode >= 200 && statusCode < 300) {
+          log.trace(
+            "fileWatcher",
+            `post ok url=${url} status=${statusCode} path=${body.filePath}`
+          );
+          return;
+        }
+        if (statusCode === 410 || statusCode === 404) {
+          log.warn(
+            "fileWatcher",
+            `session dead (status=${statusCode}) \u2014 dropping ${body.filePath}`
+          );
+          this.stopped = true;
+          return;
+        }
+        log.warn(
+          "fileWatcher",
+          `post failed url=${url} status=${statusCode} attempt=${attempt + 1} body=${resBody.slice(0, 200)}`
+        );
+      } catch (err) {
+        log.warn(
+          "fileWatcher",
+          `post error url=${url} attempt=${attempt + 1}`,
+          err
+        );
+      }
+      if (attempt < MAX_RETRIES) {
+        await sleep(RETRY_BACKOFF_MS * (attempt + 1));
+      }
+    }
+    log.warn(
+      "fileWatcher",
+      `giving up after ${MAX_RETRIES + 1} attempts \u2014 path=${body.filePath}`
+    );
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function runGit(cwd, args2, opts = {}) {
+  return _runGit(cwd, args2, opts);
+}
+var _gitSeam = {
+  run: _runGitImpl
+};
+async function _runGitImpl(cwd, args2, opts = {}) {
+  return new Promise((resolve2) => {
+    let proc;
+    try {
+      proc = (0, import_child_process6.spawn)("git", args2, { cwd, env: process.env });
+    } catch {
+      resolve2(null);
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (c2) => {
+      stdout += c2.toString();
+    });
+    proc.stderr?.on("data", (c2) => {
+      stderr += c2.toString();
+    });
+    proc.on("error", () => resolve2(null));
+    proc.on("close", (code) => {
+      if (code === 0 || opts.allowNonZeroExit) {
+        resolve2(stdout);
+      } else {
+        log.trace("fileWatcher", `git ${args2.join(" ")} exited ${code} stderr=${stderr.slice(0, 200)}`);
+        resolve2(null);
+      }
+    });
+  });
+}
+function _runGit(cwd, args2, opts = {}) {
+  return _gitSeam.run(cwd, args2, opts);
+}
+
 // src/commands/start/quota-fetcher.ts
 var inProgress = false;
 function fetchQuotaUsage(runtime, historySvc) {
@@ -6140,13 +6595,13 @@ function fetchQuotaUsage(runtime, historySvc) {
 }
 
 // src/commands/start/keep-alive.ts
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 function buildKeepAlive(ctx) {
   let timer = null;
   async function setIdleTimeout(minutes) {
     if (!ctx.inCodespace || !ctx.codespaceName) return;
     await new Promise((resolve2) => {
-      const proc = (0, import_child_process6.spawn)(
+      const proc = (0, import_child_process7.spawn)(
         "gh",
         [
           "api",
@@ -6185,9 +6640,9 @@ function buildKeepAlive(ctx) {
 // src/commands/start/handlers.ts
 var fs14 = __toESM(require("fs"));
 var os13 = __toESM(require("os"));
-var path18 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var import_crypto2 = require("crypto");
-var import_child_process8 = require("child_process");
+var import_child_process10 = require("child_process");
 
 // src/lib/payload.ts
 var import_zod2 = require("zod");
@@ -6244,7 +6699,7 @@ function parsePayload(schema, raw) {
 
 // src/services/file-ops.service.ts
 var fs12 = __toESM(require("fs/promises"));
-var path15 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var MAX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_WALK_DEPTH = 6;
 var MAX_VISITED_DIRS = 5e3;
@@ -6279,8 +6734,8 @@ var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 function isUnder(parent, candidate) {
-  const rel = path15.relative(parent, candidate);
-  return rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel);
+  const rel = path16.relative(parent, candidate);
+  return rel === "" || !rel.startsWith("..") && !path16.isAbsolute(rel);
 }
 async function isExistingFile(absPath) {
   try {
@@ -6303,7 +6758,7 @@ async function walkForSuffix(dir, needleVariants, depth, ctx) {
   }
   for (const e of entries) {
     if (!e.isFile()) continue;
-    const full = path15.join(dir, e.name);
+    const full = path16.join(dir, e.name);
     if (needleVariants.some((needle) => full.endsWith(needle))) {
       ctx.matches.push(full);
       if (ctx.matches.length >= ctx.cap) return;
@@ -6313,21 +6768,21 @@ async function walkForSuffix(dir, needleVariants, depth, ctx) {
     if (!e.isDirectory()) continue;
     if (SUBDIR_IGNORE.has(e.name)) continue;
     if (e.name.startsWith(".") && SUBDIR_IGNORE.has(e.name)) continue;
-    await walkForSuffix(path15.join(dir, e.name), needleVariants, depth + 1, ctx);
+    await walkForSuffix(path16.join(dir, e.name), needleVariants, depth + 1, ctx);
     if (ctx.matches.length >= ctx.cap) return;
   }
 }
 async function findFile(rawPath) {
   const cwd = process.cwd();
-  if (path15.isAbsolute(rawPath)) {
-    const abs = path15.normalize(rawPath);
+  if (path16.isAbsolute(rawPath)) {
+    const abs = path16.normalize(rawPath);
     if (isUnder(cwd, abs) && await isExistingFile(abs)) return abs;
   }
-  const direct = path15.resolve(cwd, rawPath);
+  const direct = path16.resolve(cwd, rawPath);
   if (isUnder(cwd, direct) && await isExistingFile(direct)) return direct;
-  const normalized = path15.normalize(rawPath).replace(/^[./\\]+/, "");
+  const normalized = path16.normalize(rawPath).replace(/^[./\\]+/, "");
   const needles = [
-    `${path15.sep}${normalized}`,
+    `${path16.sep}${normalized}`,
     `/${normalized}`
   ].filter((v, i, a) => a.indexOf(v) === i);
   const ctx = { visited: 0, matches: [], cap: 16 };
@@ -6341,7 +6796,7 @@ async function findWriteTarget(rawPath) {
   const found = await findFile(rawPath);
   if (found) return found;
   const cwd = process.cwd();
-  const fallback = path15.isAbsolute(rawPath) ? path15.normalize(rawPath) : path15.resolve(cwd, rawPath);
+  const fallback = path16.isAbsolute(rawPath) ? path16.normalize(rawPath) : path16.resolve(cwd, rawPath);
   if (!isUnder(cwd, fallback)) return null;
   return fallback;
 }
@@ -6381,7 +6836,7 @@ async function writeProjectFile(rawPath, content) {
     if (Buffer.byteLength(content, "utf-8") > MAX_FILE_BYTES) {
       return { error: "Content too large." };
     }
-    await fs12.mkdir(path15.dirname(abs), { recursive: true });
+    await fs12.mkdir(path16.dirname(abs), { recursive: true });
     await fs12.writeFile(abs, content, "utf-8");
     return { ok: true };
   } catch (e) {
@@ -6391,11 +6846,11 @@ async function writeProjectFile(rawPath, content) {
 }
 
 // src/services/project-ops.service.ts
-var import_child_process7 = require("child_process");
+var import_child_process8 = require("child_process");
 var import_util2 = require("util");
 var fs13 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
-var execFileP2 = (0, import_util2.promisify)(import_child_process7.execFile);
+var path17 = __toESM(require("path"));
+var execFileP2 = (0, import_util2.promisify)(import_child_process8.execFile);
 var PROJECT_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -6452,12 +6907,12 @@ async function listProjectFiles(opts = {}) {
         return;
       }
       if (PROJECT_IGNORE.has(e.name)) continue;
-      const full = path16.join(dir, e.name);
+      const full = path17.join(dir, e.name);
       if (e.isDirectory()) {
         if (depth >= 12) continue;
         await walk(full, depth + 1);
       } else if (e.isFile()) {
-        const rel = path16.relative(root, full);
+        const rel = path17.relative(root, full);
         if (q2 && !rel.toLowerCase().includes(q2) && !e.name.toLowerCase().includes(q2)) {
           continue;
         }
@@ -6565,7 +7020,7 @@ async function gitStatus(cwd) {
   let hasMergeInProgress = false;
   try {
     const gitDir = (await git(["rev-parse", "--git-dir"], root)).stdout.trim();
-    const mergeHead = path16.isAbsolute(gitDir) ? path16.join(gitDir, "MERGE_HEAD") : path16.join(root, gitDir, "MERGE_HEAD");
+    const mergeHead = path17.isAbsolute(gitDir) ? path17.join(gitDir, "MERGE_HEAD") : path17.join(root, gitDir, "MERGE_HEAD");
     await fs13.access(mergeHead);
     hasMergeInProgress = true;
   } catch {
@@ -6712,7 +7167,7 @@ async function jsSearchFiles(opts, cwd, cap) {
     }
     let content = "";
     try {
-      content = await fs13.readFile(path16.join(cwd, f.path), "utf8");
+      content = await fs13.readFile(path17.join(cwd, f.path), "utf8");
     } catch {
       continue;
     }
@@ -6735,6 +7190,7 @@ async function jsSearchFiles(opts, cwd, cap) {
 }
 
 // src/services/terminal-ops.service.ts
+var import_child_process9 = require("child_process");
 var import_crypto = require("crypto");
 var import_path = __toESM(require("path"));
 var MAX_CONCURRENT_SESSIONS = 4;
@@ -6768,6 +7224,135 @@ function defaultShell() {
   }
   return process.env.SHELL ?? "/bin/bash";
 }
+var PYTHON_TERMINAL_HELPER = `import os,pty,sys,select,signal,struct,fcntl,termios,errno,re
+m,s=pty.openpty()
+try:
+    cols=int(os.environ.get('COLUMNS','80'))
+    rows=int(os.environ.get('LINES','24'))
+    fcntl.ioctl(s,termios.TIOCSWINSZ,struct.pack('HHHH',rows,cols,0,0))
+except Exception:pass
+pid=os.fork()
+if pid==0:
+    os.close(m)
+    os.setsid()
+    try:fcntl.ioctl(s,termios.TIOCSCTTY,0)
+    except Exception:pass
+    for fd in[0,1,2]:os.dup2(s,fd)
+    if s>2:os.close(s)
+    os.execvp(sys.argv[1],sys.argv[1:])
+    sys.exit(127)
+os.close(s)
+done=[False]
+def onchld(n,f):
+    try:os.waitpid(pid,os.WNOHANG)
+    except Exception:pass
+    done[0]=True
+signal.signal(signal.SIGCHLD,onchld)
+signal.signal(signal.SIGHUP,signal.SIG_IGN)
+i=sys.stdin.fileno()
+o=sys.stdout.fileno()
+in_buf=b''
+resize_re=re.compile(rb'\\x00CW (\\d+) (\\d+)\\n')
+while not done[0]:
+    try:r,_,_=select.select([i,m],[],[],0.1)
+    except OSError as e:
+        if e.errno==errno.EINTR:continue
+        break
+    if i in r:
+        try:
+            d=os.read(i,4096)
+            if not d:break
+            in_buf+=d
+            while True:
+                mo=resize_re.search(in_buf)
+                if not mo:break
+                try:
+                    rows=int(mo.group(1));cols=int(mo.group(2))
+                    fcntl.ioctl(m,termios.TIOCSWINSZ,struct.pack('HHHH',rows,cols,0,0))
+                except Exception:pass
+                in_buf=in_buf[:mo.start()]+in_buf[mo.end():]
+            if in_buf:
+                # Don't forward a dangling NUL that might be the
+                # start of an incomplete resize marker \u2014 hold it
+                # until the next read so the regex matches.
+                nul=in_buf.rfind(b'\\x00')
+                if nul>=0 and len(in_buf)-nul<32:
+                    tail=in_buf[nul:];body=in_buf[:nul]
+                    if body:os.write(m,body)
+                    in_buf=tail
+                else:
+                    os.write(m,in_buf);in_buf=b''
+        except OSError:break
+    if m in r:
+        try:
+            d=os.read(m,4096)
+            if d:os.write(o,d)
+        except OSError:done[0]=True
+try:os.kill(pid,signal.SIGTERM)
+except Exception:pass
+try:
+    _,st=os.waitpid(pid,0)
+    sys.exit((st>>8)&0xFF)
+except Exception:sys.exit(0)
+`;
+function findPython3() {
+  for (const name of ["python3", "python"]) {
+    try {
+      const out = require("child_process").spawnSync("which", [name], { encoding: "utf8" });
+      if (out.status === 0 && out.stdout?.trim()) return out.stdout.trim();
+    } catch {
+    }
+  }
+  return null;
+}
+function createPythonSession(id, shell, cwd, env, cols, rows) {
+  const python = findPython3();
+  if (!python) {
+    return { error: "python3 not found on PATH \u2014 required for terminal sessions on Linux/macOS without node-pty." };
+  }
+  let child;
+  try {
+    child = (0, import_child_process9.spawn)(python, ["-c", PYTHON_TERMINAL_HELPER, shell], {
+      cwd,
+      env: { ...env, COLUMNS: String(cols), LINES: String(rows) },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : "python spawn failed" };
+  }
+  child.stdout.on("data", (buf) => {
+    onDataHandler?.({ sessionId: id, data: buf.toString("utf8") });
+  });
+  child.stderr.on("data", (buf) => {
+    onDataHandler?.({ sessionId: id, data: buf.toString("utf8") });
+  });
+  child.on("exit", (code) => {
+    onExitHandler?.({ sessionId: id, exitCode: code ?? 0 });
+    sessions.delete(id);
+  });
+  return {
+    id,
+    write(data) {
+      try {
+        child.stdin.write(data);
+      } catch {
+      }
+    },
+    resize(cs, rs) {
+      try {
+        child.stdin.write(`\0CW ${rs} ${cs}
+`);
+      } catch {
+      }
+    },
+    kill() {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  };
+}
 function openTerminal(opts) {
   if (sessions.size >= MAX_CONCURRENT_SESSIONS) {
     return { error: `Too many open terminals (max ${MAX_CONCURRENT_SESSIONS})` };
@@ -6777,46 +7362,61 @@ function openTerminal(opts) {
   const env = {
     ...process.env,
     TERM: "xterm-256color",
-    COLORTERM: "truecolor"
+    COLORTERM: "truecolor",
+    FORCE_COLOR: "1"
   };
-  env.FORCE_COLOR = "1";
+  const cols = Math.max(1, Math.min(opts.cols ?? 80, 500));
+  const rows = Math.max(1, Math.min(opts.rows ?? 24, 200));
+  const id = (0, import_crypto.randomUUID)();
   const ptyMod = loadNodePty2();
-  if (!ptyMod) {
+  if (ptyMod) {
+    try {
+      const term = ptyMod.spawn(shell, [], {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd,
+        env,
+        useConpty: process.platform === "win32" ? true : void 0
+      });
+      const dataListener = term.onData((data) => {
+        onDataHandler?.({ sessionId: id, data });
+      });
+      const exitListener = term.onExit(({ exitCode }) => {
+        onExitHandler?.({ sessionId: id, exitCode });
+        sessions.delete(id);
+      });
+      sessions.set(id, {
+        id,
+        write: (d3) => term.write(d3),
+        resize: (cs, rs) => term.resize(cs, rs),
+        kill: () => {
+          dataListener.dispose();
+          exitListener.dispose();
+          term.kill();
+        }
+      });
+      return { sessionId: id };
+    } catch (e) {
+      if (process.platform === "win32") {
+        return { error: e instanceof Error ? e.message : "spawn failed" };
+      }
+    }
+  } else if (process.platform === "win32") {
     return {
       error: `node-pty native module unavailable on ${process.platform}-${process.arch}; terminal feature disabled for this platform`
     };
   }
-  try {
-    const term = ptyMod.spawn(shell, [], {
-      name: "xterm-256color",
-      cols: Math.max(1, Math.min(opts.cols ?? 80, 500)),
-      rows: Math.max(1, Math.min(opts.rows ?? 24, 200)),
-      cwd,
-      env,
-      // Windows-specific: ConPTY is the default on Win 10 1809+
-      // and is what we want. node-pty falls back to winpty
-      // automatically on older builds.
-      useConpty: process.platform === "win32" ? true : void 0
-    });
-    const id = (0, import_crypto.randomUUID)();
-    const dataListener = term.onData((data) => {
-      onDataHandler?.({ sessionId: id, data });
-    });
-    const exitListener = term.onExit(({ exitCode }) => {
-      onExitHandler?.({ sessionId: id, exitCode });
-      sessions.delete(id);
-    });
-    sessions.set(id, { id, pty: term, dataListener, exitListener });
-    return { sessionId: id };
-  } catch (e) {
-    return { error: e instanceof Error ? e.message : "spawn failed" };
-  }
+  const sess = createPythonSession(id, shell, cwd, env, cols, rows);
+  if ("error" in sess) return { error: sess.error };
+  sessions.set(id, sess);
+  return { sessionId: id };
 }
 function writeTerminal(sessionId, data) {
   const s = sessions.get(sessionId);
   if (!s) return { ok: false, error: "No such session" };
   try {
-    s.pty.write(data);
+    s.write(data);
     return { ok: true };
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : "write failed" };
@@ -6826,7 +7426,7 @@ function resizeTerminal(sessionId, cols, rows) {
   const s = sessions.get(sessionId);
   if (!s) return { ok: false, error: "No such session" };
   try {
-    s.pty.resize(Math.max(1, Math.min(cols, 500)), Math.max(1, Math.min(rows, 200)));
+    s.resize?.(Math.max(1, Math.min(cols, 500)), Math.max(1, Math.min(rows, 200)));
     return { ok: true };
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : "resize failed" };
@@ -6836,9 +7436,7 @@ function closeTerminal(sessionId) {
   const s = sessions.get(sessionId);
   if (!s) return { ok: true };
   try {
-    s.dataListener.dispose();
-    s.exitListener.dispose();
-    s.pty.kill();
+    s.kill();
   } catch {
   }
   sessions.delete(sessionId);
@@ -6849,7 +7447,7 @@ function closeTerminal(sessionId) {
 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 = path18.join(os13.tmpdir(), `codeam-${(0, import_crypto2.randomUUID)()}-${safeName}`);
+    const tmpPath = path19.join(os13.tmpdir(), `codeam-${(0, import_crypto2.randomUUID)()}-${safeName}`);
     fs14.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     return tmpPath;
   });
@@ -6981,7 +7579,7 @@ var sessionTerminated = (ctx) => {
   } catch {
   }
   try {
-    const proc = (0, import_child_process8.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+    const proc = (0, import_child_process10.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
       detached: true,
       stdio: "ignore"
     });
@@ -7003,7 +7601,7 @@ var shutdownSession = async (ctx, cmd) => {
   }
   if (ctx.keepAliveCtx.inCodespace && ctx.keepAliveCtx.codespaceName) {
     try {
-      const stopProc = (0, import_child_process8.spawn)(
+      const stopProc = (0, import_child_process10.spawn)(
         "bash",
         ["-lc", `sleep 1; gh codespace stop -c ${JSON.stringify(ctx.keepAliveCtx.codespaceName)} >/dev/null 2>&1 || true`],
         { detached: true, stdio: "ignore" }
@@ -7013,7 +7611,7 @@ var shutdownSession = async (ctx, cmd) => {
     }
   }
   try {
-    const proc = (0, import_child_process8.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+    const proc = (0, import_child_process10.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
       detached: true,
       stdio: "ignore"
     });
@@ -7232,6 +7830,12 @@ async function start(requestedAgent) {
     session.pluginAuthToken,
     runtime
   );
+  const fileWatcher = session.pluginAuthToken ? new FileWatcherService({
+    workingDir: cwd,
+    sessionId: session.id,
+    pluginId,
+    pluginAuthToken: session.pluginAuthToken
+  }) : null;
   const claude = new AgentService(
     runtime,
     {
@@ -7243,6 +7847,7 @@ async function start(requestedAgent) {
         process.removeListener("SIGINT", sigintHandler);
         outputSvc.dispose();
         relay.stop();
+        void fileWatcher?.stop();
         process.exit(code);
       }
     }
@@ -7272,12 +7877,17 @@ async function start(requestedAgent) {
     claude.kill();
     outputSvc.dispose();
     relay.stop();
+    void fileWatcher?.stop();
     process.exit(0);
   }
   process.once("SIGINT", sigintHandler);
   await claude.spawn();
   await outputSvc.startTerminalTurn();
   relay.start();
+  if (fileWatcher) {
+    fileWatcher.start().catch(() => {
+    });
+  }
   setTimeout(() => {
     historySvc.load().catch(() => {
     });
@@ -7406,7 +8016,7 @@ async function pair(args2 = []) {
 var fs15 = __toESM(require("fs"));
 var os14 = __toESM(require("os"));
 var import_crypto4 = require("crypto");
-var API_BASE5 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var API_BASE6 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 function fail(msg) {
   console.error(`
   ${msg}
@@ -7421,12 +8031,12 @@ function readTokenFromArgs(args2) {
   }
   const fileFlag = args2.find((a) => a.startsWith("--token-file="));
   if (fileFlag) {
-    const path24 = fileFlag.slice("--token-file=".length);
+    const path25 = fileFlag.slice("--token-file=".length);
     try {
-      const content = fs15.readFileSync(path24, "utf8").trim();
-      if (content.length === 0) fail(`--token-file ${path24} is empty`);
+      const content = fs15.readFileSync(path25, "utf8").trim();
+      if (content.length === 0) fail(`--token-file ${path25} is empty`);
       try {
-        fs15.unlinkSync(path24);
+        fs15.unlinkSync(path25);
       } catch {
       }
       return content;
@@ -7438,7 +8048,7 @@ function readTokenFromArgs(args2) {
   fail("codeam pair-auto requires --token-file=<path>, --token=<value>, or CODEAM_AUTO_TOKEN env");
 }
 async function claim(token, pluginId) {
-  const url = `${API_BASE5}/api/pairing/claim-auto-token`;
+  const url = `${API_BASE6}/api/pairing/claim-auto-token`;
   const body = {
     token,
     pluginId,
@@ -7593,11 +8203,11 @@ async function logout() {
 var import_picocolors9 = __toESM(require("picocolors"));
 
 // src/services/providers/github-codespaces.ts
-var import_child_process9 = require("child_process");
+var import_child_process11 = require("child_process");
 var import_util3 = require("util");
 var import_picocolors7 = __toESM(require("picocolors"));
-var path19 = __toESM(require("path"));
-var execFileP3 = (0, import_util3.promisify)(import_child_process9.execFile);
+var path20 = __toESM(require("path"));
+var execFileP3 = (0, import_util3.promisify)(import_child_process11.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
   if (process.stdin.isTTY) {
@@ -7641,7 +8251,7 @@ var GitHubCodespacesProvider = class {
     if (!isAuthed) {
       resetStdinForChild();
       await new Promise((resolve2, reject) => {
-        const proc = (0, import_child_process9.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
+        const proc = (0, import_child_process11.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
           stdio: "inherit"
         });
         proc.on("exit", (code) => {
@@ -7675,7 +8285,7 @@ var GitHubCodespacesProvider = class {
       wt(noteLines.join("\n"), "One more permission needed");
       resetStdinForChild();
       const refreshCode = await new Promise((resolve2, reject) => {
-        const proc = (0, import_child_process9.spawn)(
+        const proc = (0, import_child_process11.spawn)(
           "gh",
           ["auth", "refresh", "-h", "github.com", "-s", "codespace"],
           { stdio: "inherit" }
@@ -7825,7 +8435,7 @@ var GitHubCodespacesProvider = class {
     O2.step(`Installing gh via ${installCmd.describe}\u2026`);
     resetStdinForChild();
     const ok = await new Promise((resolve2) => {
-      const proc = (0, import_child_process9.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
+      const proc = (0, import_child_process11.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
       proc.on("exit", (code) => resolve2(code === 0));
       proc.on("error", () => resolve2(false));
     });
@@ -7852,7 +8462,7 @@ var GitHubCodespacesProvider = class {
     );
     resetStdinForChild();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process9.spawn)(
+      const proc = (0, import_child_process11.spawn)(
         "gh",
         ["auth", "refresh", "-h", "github.com", "-s", "repo,read:org"],
         { stdio: "inherit" }
@@ -8030,7 +8640,7 @@ var GitHubCodespacesProvider = class {
   async streamCommand(workspaceId, command2) {
     resetStdinForChild();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process9.spawn)(
+      const proc = (0, import_child_process11.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
@@ -8057,11 +8667,11 @@ var GitHubCodespacesProvider = class {
       `mkdir -p ${shellQuote(remoteDir)} && tar -xzf - -C ${shellQuote(remoteDir)}`
     ];
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process9.spawn)("tar", tarArgs, {
+      const tar = (0, import_child_process11.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
       });
-      const ssh = (0, import_child_process9.spawn)("gh", sshArgs, {
+      const ssh = (0, import_child_process11.spawn)("gh", sshArgs, {
         stdio: [tar.stdout, "pipe", "pipe"]
       });
       let tarErr = "";
@@ -8085,7 +8695,7 @@ var GitHubCodespacesProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path19.posix.dirname(remotePath);
+    const remoteDir = path20.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote(remoteDir)}`,
       `cat > ${shellQuote(remotePath)}`
@@ -8095,7 +8705,7 @@ var GitHubCodespacesProvider = class {
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process9.spawn)(
+      const proc = (0, import_child_process11.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8153,11 +8763,11 @@ function shellQuote(s) {
 }
 
 // src/services/providers/gitpod.ts
-var import_child_process10 = require("child_process");
+var import_child_process12 = require("child_process");
 var import_util4 = require("util");
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var import_picocolors8 = __toESM(require("picocolors"));
-var execFileP4 = (0, import_util4.promisify)(import_child_process10.execFile);
+var execFileP4 = (0, import_util4.promisify)(import_child_process12.execFile);
 var MAX_BUFFER2 = 8 * 1024 * 1024;
 function resetStdinForChild2() {
   if (process.stdin.isTTY) {
@@ -8197,7 +8807,7 @@ var GitpodProvider = class {
     );
     resetStdinForChild2();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process10.spawn)("gitpod", ["login"], { stdio: "inherit" });
+      const proc = (0, import_child_process12.spawn)("gitpod", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
         if (code === 0) resolve2();
         else reject(new Error("gitpod login failed."));
@@ -8349,7 +8959,7 @@ var GitpodProvider = class {
   async streamCommand(workspaceId, command2) {
     resetStdinForChild2();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process10.spawn)(
+      const proc = (0, import_child_process12.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
@@ -8369,11 +8979,11 @@ var GitpodProvider = class {
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote2(remoteDir)} && tar -xzf - -C ${shellQuote2(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process10.spawn)("tar", tarArgs, {
+      const tar = (0, import_child_process12.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
       });
-      const ssh = (0, import_child_process10.spawn)(
+      const ssh = (0, import_child_process12.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8395,7 +9005,7 @@ var GitpodProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path20.posix.dirname(remotePath);
+    const remoteDir = path21.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote2(remoteDir)}`,
       `cat > ${shellQuote2(remotePath)}`
@@ -8405,7 +9015,7 @@ var GitpodProvider = class {
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process10.spawn)(
+      const proc = (0, import_child_process12.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8429,10 +9039,10 @@ function shellQuote2(s) {
 }
 
 // src/services/providers/gitlab-workspaces.ts
-var import_child_process11 = require("child_process");
+var import_child_process13 = require("child_process");
 var import_util5 = require("util");
-var path21 = __toESM(require("path"));
-var execFileP5 = (0, import_util5.promisify)(import_child_process11.execFile);
+var path22 = __toESM(require("path"));
+var execFileP5 = (0, import_util5.promisify)(import_child_process13.execFile);
 var MAX_BUFFER3 = 8 * 1024 * 1024;
 var GITLAB_API_BASE = process.env.CODEAM_GITLAB_API_URL ?? "https://gitlab.com/api/v4";
 function resetStdinForChild3() {
@@ -8474,7 +9084,7 @@ var GitLabWorkspacesProvider = class {
     );
     resetStdinForChild3();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process11.spawn)(
+      const proc = (0, import_child_process13.spawn)(
         "glab",
         ["auth", "login", "--scopes", "api,read_user,read_repository"],
         { stdio: "inherit" }
@@ -8646,7 +9256,7 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
     resetStdinForChild3();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process11.spawn)(
+      const proc = (0, import_child_process13.spawn)(
         "ssh",
         ["-tt", "-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, command2],
         { stdio: "inherit" }
@@ -8667,8 +9277,8 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote3(remoteDir)} && tar -xzf - -C ${shellQuote3(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process11.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
-      const ssh = (0, import_child_process11.spawn)(
+      const tar = (0, import_child_process13.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
+      const ssh = (0, import_child_process13.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8691,14 +9301,14 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
-    const remoteDir = path21.posix.dirname(remotePath);
+    const remoteDir = path22.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote3(remoteDir)}`, `cat > ${shellQuote3(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote3(remotePath)}`);
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process11.spawn)(
+      const proc = (0, import_child_process13.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8757,10 +9367,10 @@ function shellQuote3(s) {
 }
 
 // src/services/providers/railway.ts
-var import_child_process12 = require("child_process");
+var import_child_process14 = require("child_process");
 var import_util6 = require("util");
-var path22 = __toESM(require("path"));
-var execFileP6 = (0, import_util6.promisify)(import_child_process12.execFile);
+var path23 = __toESM(require("path"));
+var execFileP6 = (0, import_util6.promisify)(import_child_process14.execFile);
 var MAX_BUFFER4 = 8 * 1024 * 1024;
 function resetStdinForChild4() {
   if (process.stdin.isTTY) {
@@ -8801,7 +9411,7 @@ var RailwayProvider = class {
     );
     resetStdinForChild4();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process12.spawn)("railway", ["login"], { stdio: "inherit" });
+      const proc = (0, import_child_process14.spawn)("railway", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
         if (code === 0) resolve2();
         else reject(new Error("railway login failed."));
@@ -8944,7 +9554,7 @@ var RailwayProvider = class {
     }
     resetStdinForChild4();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process12.spawn)(
+      const proc = (0, import_child_process14.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", command2],
         { stdio: "inherit" }
@@ -8968,8 +9578,8 @@ var RailwayProvider = class {
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote4(remoteDir)} && tar -xzf - -C ${shellQuote4(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process12.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
-      const sh = (0, import_child_process12.spawn)(
+      const tar = (0, import_child_process14.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
+      const sh = (0, import_child_process14.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8995,14 +9605,14 @@ var RailwayProvider = class {
     if (!projectId || !serviceId) {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
-    const remoteDir = path22.posix.dirname(remotePath);
+    const remoteDir = path23.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote4(remoteDir)}`, `cat > ${shellQuote4(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote4(remotePath)}`);
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process12.spawn)(
+      const proc = (0, import_child_process14.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -9537,7 +10147,7 @@ async function stopWorkspaceFromLocal(target) {
 // src/commands/version.ts
 var import_picocolors11 = __toESM(require("picocolors"));
 function version() {
-  const v = true ? "2.15.1" : "unknown";
+  const v = true ? "2.15.5" : "unknown";
   console.log(`${import_picocolors11.default.bold("codeam-cli")} ${import_picocolors11.default.cyan(v)}`);
 }
 
@@ -9580,16 +10190,16 @@ function help() {
 // src/lib/updateNotifier.ts
 var fs16 = __toESM(require("fs"));
 var os15 = __toESM(require("os"));
-var path23 = __toESM(require("path"));
-var https5 = __toESM(require("https"));
+var path24 = __toESM(require("path"));
+var https6 = __toESM(require("https"));
 var import_picocolors13 = __toESM(require("picocolors"));
 var PKG_NAME = "codeam-cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}/latest`;
 var TTL_MS = 24 * 60 * 60 * 1e3;
 var REQUEST_TIMEOUT_MS = 1500;
 function cachePath() {
-  const dir = path23.join(os15.homedir(), ".codeam");
-  return path23.join(dir, "update-check.json");
+  const dir = path24.join(os15.homedir(), ".codeam");
+  return path24.join(dir, "update-check.json");
 }
 function readCache() {
   try {
@@ -9604,7 +10214,7 @@ function readCache() {
 function writeCache(cache) {
   try {
     const file = cachePath();
-    fs16.mkdirSync(path23.dirname(file), { recursive: true });
+    fs16.mkdirSync(path24.dirname(file), { recursive: true });
     fs16.writeFileSync(file, JSON.stringify(cache));
   } catch {
   }
@@ -9624,7 +10234,7 @@ function compareSemver(a, b) {
 }
 function fetchLatest() {
   return new Promise((resolve2) => {
-    const req = https5.get(
+    const req = https6.get(
       REGISTRY_URL,
       { headers: { Accept: "application/json" }, timeout: REQUEST_TIMEOUT_MS },
       (res) => {
@@ -9676,7 +10286,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current = true ? "2.15.1" : null;
+  const current = true ? "2.15.5" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;