codeam-cli 2.2.1 → 2.3.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `codeam-cli` are documented here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.2.2] — 2026-05-02
+
+### Fixed
+
+- **clients:** Recursive suffix search for read_file (v2.2.2)
+
+## [2.2.1] — 2026-05-02
+
+### Fixed
+
+- **cli:** Subdir fallback for read_file when CLI cwd is a monorepo parent (v2.2.1)
+
 ## [2.1.0] — 2026-04-25
 
 ### Added

package/dist/index.js

@@ -87,11 +87,11 @@ var require_src = __commonJS({
 });
 
 // src/commands/start.ts
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var import_crypto = require("crypto");
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_picocolors2 = __toESM(require("picocolors"));
 
 // src/config.ts
@@ -179,7 +179,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.2.1",
+  version: "2.3.0",
   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.",
   main: "dist/index.js",
   bin: {
@@ -2163,7 +2163,15 @@ var startCommandSchema = import_zod2.z.object({
   // `path` is bounded to 4096 chars (a comfortable POSIX path max) so a
   // malformed payload can't blow up the disk-side validator.
   path: import_zod2.z.string().min(1).max(4096).optional(),
-  content: import_zod2.z.string().optional()
+  content: import_zod2.z.string().optional(),
+  // Mini-IDE / project ops. `paths` (plural, strings) is used for
+  // git_commit's optional file selection — distinct from `files`
+  // (FileEntry[]) used by `start_task` for attachments.
+  query: import_zod2.z.string().max(256).optional(),
+  message: import_zod2.z.string().max(8e3).optional(),
+  paths: import_zod2.z.array(import_zod2.z.string().max(4096)).optional(),
+  side: import_zod2.z.enum(["ours", "theirs"]).optional(),
+  limit: import_zod2.z.number().int().min(1).max(500).optional()
 });
 function parsePayload(schema, raw) {
   const result = schema.safeParse(raw);
@@ -2174,6 +2182,8 @@ function parsePayload(schema, raw) {
 var fs5 = __toESM(require("fs/promises"));
 var path5 = __toESM(require("path"));
 var MAX_FILE_BYTES = 5 * 1024 * 1024;
+var MAX_WALK_DEPTH = 6;
+var MAX_VISITED_DIRS = 5e3;
 var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -2188,43 +2198,80 @@ var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   ".parcel-cache",
   ".idea",
   ".vscode",
+  ".vscode-test",
   "ios",
-  "android"
+  "android",
   // expo-managed native dirs are huge and rarely interesting
+  ".gradle",
+  ".cxx",
+  ".intellijPlatform",
+  ".kotlin",
+  "tmp",
+  "target",
+  "venv",
+  ".venv",
+  ".mypy_cache",
+  ".pytest_cache",
+  "__pycache__"
 ]);
-async function listSubdirs(dir) {
+function isUnder(parent, candidate) {
+  const rel = path5.relative(parent, candidate);
+  return rel === "" || !rel.startsWith("..") && !path5.isAbsolute(rel);
+}
+async function isExistingFile(absPath) {
   try {
-    const entries = await fs5.readdir(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") ? true : !SUBDIR_IGNORE.has(e.name)).filter((e) => e.isDirectory() && !SUBDIR_IGNORE.has(e.name)).map((e) => path5.join(dir, e.name));
+    const stat3 = await fs5.stat(absPath);
+    return stat3.isFile();
   } catch {
-    return [];
+    return false;
   }
 }
-function isUnder(parent, candidate) {
-  const rel = path5.relative(parent, candidate);
-  return !rel.startsWith("..") && !path5.isAbsolute(rel);
+async function walkForSuffix(dir, needleVariants, depth, ctx) {
+  if (depth > MAX_WALK_DEPTH) return;
+  if (ctx.visited > MAX_VISITED_DIRS) return;
+  if (ctx.matches.length >= ctx.cap) return;
+  ctx.visited++;
+  let entries = [];
+  try {
+    entries = await fs5.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (!e.isFile()) continue;
+    const full = path5.join(dir, e.name);
+    if (needleVariants.some((needle) => full.endsWith(needle))) {
+      ctx.matches.push(full);
+      if (ctx.matches.length >= ctx.cap) return;
+    }
+  }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (SUBDIR_IGNORE.has(e.name)) continue;
+    if (e.name.startsWith(".") && SUBDIR_IGNORE.has(e.name)) continue;
+    await walkForSuffix(path5.join(dir, e.name), needleVariants, depth + 1, ctx);
+    if (ctx.matches.length >= ctx.cap) return;
+  }
 }
 async function findFile(rawPath) {
   const cwd = process.cwd();
-  const candidates = [];
   if (path5.isAbsolute(rawPath)) {
-    candidates.push(path5.normalize(rawPath));
-  } else {
-    candidates.push(path5.resolve(cwd, rawPath));
-    const subdirs = await listSubdirs(cwd);
-    for (const sub of subdirs) {
-      candidates.push(path5.resolve(sub, rawPath));
-    }
-  }
-  for (const cand of candidates) {
-    if (!isUnder(cwd, cand)) continue;
-    try {
-      const stat2 = await fs5.stat(cand);
-      if (stat2.isFile()) return cand;
-    } catch {
-    }
-  }
-  return null;
+    const abs = path5.normalize(rawPath);
+    if (isUnder(cwd, abs) && await isExistingFile(abs)) return abs;
+  }
+  const direct = path5.resolve(cwd, rawPath);
+  if (isUnder(cwd, direct) && await isExistingFile(direct)) return direct;
+  const normalized = path5.normalize(rawPath).replace(/^[./\\]+/, "");
+  const needles = [
+    `${path5.sep}${normalized}`,
+    `/${normalized}`
+  ].filter((v, i, a) => a.indexOf(v) === i);
+  const ctx = { visited: 0, matches: [], cap: 16 };
+  await walkForSuffix(cwd, needles, 0, ctx);
+  const candidates = ctx.matches.filter((c2) => isUnder(cwd, c2));
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => a.length - b.length);
+  return candidates[0];
 }
 async function findWriteTarget(rawPath) {
   const found = await findFile(rawPath);
@@ -2247,9 +2294,9 @@ async function readProjectFile(rawPath) {
     if (!abs) {
       return { error: `File not found in the project tree: ${rawPath}` };
     }
-    const stat2 = await fs5.stat(abs);
-    if (stat2.size > MAX_FILE_BYTES) {
-      return { error: `File too large (${(stat2.size / 1024 / 1024).toFixed(1)} MB > ${MAX_FILE_BYTES / 1024 / 1024} MB).` };
+    const stat3 = await fs5.stat(abs);
+    if (stat3.size > MAX_FILE_BYTES) {
+      return { error: `File too large (${(stat3.size / 1024 / 1024).toFixed(1)} MB > ${MAX_FILE_BYTES / 1024 / 1024} MB).` };
     }
     const buf = await fs5.readFile(abs);
     if (looksBinary(buf)) {
@@ -2279,12 +2326,261 @@ async function writeProjectFile(rawPath, content) {
   }
 }
 
+// src/services/project-ops.service.ts
+var import_child_process3 = require("child_process");
+var import_util = require("util");
+var fs6 = __toESM(require("fs/promises"));
+var path6 = __toESM(require("path"));
+var execFileP = (0, import_util.promisify)(import_child_process3.execFile);
+var PROJECT_IGNORE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".expo",
+  "dist",
+  "build",
+  "out",
+  ".cache",
+  "coverage",
+  ".turbo",
+  ".parcel-cache",
+  ".idea",
+  ".vscode",
+  ".vscode-test",
+  "ios",
+  "android",
+  ".gradle",
+  ".cxx",
+  ".intellijPlatform",
+  ".kotlin",
+  "tmp",
+  "target",
+  "venv",
+  ".venv",
+  ".mypy_cache",
+  ".pytest_cache",
+  "__pycache__",
+  ".DS_Store"
+]);
+var MAX_TREE_FILES = 5e3;
+var MAX_DIFF_BYTES = 512 * 1024;
+var MAX_GIT_OUTPUT = 256 * 1024;
+async function listProjectFiles(opts = {}) {
+  const root = opts.cwd ?? process.cwd();
+  const cap = opts.cap ?? MAX_TREE_FILES;
+  const q2 = (opts.query ?? "").trim().toLowerCase();
+  const out = [];
+  let truncated = false;
+  async function walk(dir, depth) {
+    if (out.length >= cap) {
+      truncated = true;
+      return;
+    }
+    let entries = [];
+    try {
+      entries = await fs6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (out.length >= cap) {
+        truncated = true;
+        return;
+      }
+      if (PROJECT_IGNORE.has(e.name)) continue;
+      const full = path6.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (depth >= 12) continue;
+        await walk(full, depth + 1);
+      } else if (e.isFile()) {
+        const rel = path6.relative(root, full);
+        if (q2 && !rel.toLowerCase().includes(q2) && !e.name.toLowerCase().includes(q2)) {
+          continue;
+        }
+        let size = 0;
+        try {
+          const st3 = await fs6.stat(full);
+          size = st3.size;
+        } catch {
+        }
+        out.push({ path: rel, name: e.name, size });
+      }
+    }
+  }
+  await walk(root, 0);
+  out.sort((a, b) => a.path.localeCompare(b.path));
+  return { files: out, truncated, root };
+}
+async function git(args2, cwd) {
+  try {
+    const { stdout, stderr } = await execFileP("git", args2, {
+      cwd: cwd ?? process.cwd(),
+      maxBuffer: MAX_GIT_OUTPUT,
+      timeout: 3e4
+    });
+    return { stdout, stderr, code: 0 };
+  } catch (err) {
+    const e = err;
+    return {
+      stdout: e.stdout ?? "",
+      stderr: e.stderr ?? e.message ?? "git failed",
+      code: typeof e.code === "number" ? e.code : 1
+    };
+  }
+}
+async function gitStatus(cwd) {
+  const root = cwd ?? process.cwd();
+  const r = await git(["status", "--porcelain=v2", "--branch"], root);
+  if (r.code !== 0) {
+    return {
+      branch: null,
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      entries: [],
+      hasMergeInProgress: false,
+      error: r.stderr.trim()
+    };
+  }
+  const lines = r.stdout.split("\n").filter(Boolean);
+  let branch = null;
+  let upstream = null;
+  let ahead = 0;
+  let behind = 0;
+  const entries = [];
+  for (const line of lines) {
+    if (line.startsWith("# branch.head ")) branch = line.slice("# branch.head ".length).trim();
+    else if (line.startsWith("# branch.upstream ")) upstream = line.slice("# branch.upstream ".length).trim();
+    else if (line.startsWith("# branch.ab ")) {
+      const m = line.match(/\+(\d+)\s+-(\d+)/);
+      if (m) {
+        ahead = parseInt(m[1], 10);
+        behind = parseInt(m[2], 10);
+      }
+    } else if (line.startsWith("1 ")) {
+      const parts = line.split(" ");
+      const xy = parts[1];
+      const p2 = parts.slice(8).join(" ");
+      entries.push({
+        code: xy,
+        path: p2,
+        staged: xy[0] !== ".",
+        conflict: false
+      });
+    } else if (line.startsWith("2 ")) {
+      const parts = line.split(" ");
+      const xy = parts[1];
+      const tail = parts.slice(9).join(" ");
+      const [newPath, oldPath] = tail.split("	");
+      entries.push({
+        code: xy,
+        path: newPath ?? "",
+        oldPath: oldPath ?? void 0,
+        staged: xy[0] !== ".",
+        conflict: false
+      });
+    } else if (line.startsWith("? ")) {
+      entries.push({
+        code: "??",
+        path: line.slice(2),
+        staged: false,
+        conflict: false
+      });
+    } else if (line.startsWith("u ")) {
+      const parts = line.split(" ");
+      const xy = parts[1];
+      const p2 = parts.slice(10).join(" ");
+      entries.push({
+        code: xy,
+        path: p2,
+        staged: false,
+        conflict: true
+      });
+    }
+  }
+  let hasMergeInProgress = false;
+  try {
+    const gitDir = (await git(["rev-parse", "--git-dir"], root)).stdout.trim();
+    const mergeHead = path6.isAbsolute(gitDir) ? path6.join(gitDir, "MERGE_HEAD") : path6.join(root, gitDir, "MERGE_HEAD");
+    await fs6.access(mergeHead);
+    hasMergeInProgress = true;
+  } catch {
+  }
+  return { branch, upstream, ahead, behind, entries, hasMergeInProgress };
+}
+async function gitDiff(file, cwd) {
+  const args2 = ["diff", "--no-color", "--patch"];
+  if (file) args2.push("--", file);
+  const r = await git(args2, cwd);
+  if (r.code !== 0 && !r.stdout) {
+    return { diff: "", truncated: false, error: r.stderr.trim() };
+  }
+  const truncated = r.stdout.length >= MAX_DIFF_BYTES;
+  return { diff: r.stdout.slice(0, MAX_DIFF_BYTES), truncated };
+}
+async function gitDiffStaged(file, cwd) {
+  const args2 = ["diff", "--cached", "--no-color", "--patch"];
+  if (file) args2.push("--", file);
+  const r = await git(args2, cwd);
+  if (r.code !== 0 && !r.stdout) {
+    return { diff: "", truncated: false, error: r.stderr.trim() };
+  }
+  const truncated = r.stdout.length >= MAX_DIFF_BYTES;
+  return { diff: r.stdout.slice(0, MAX_DIFF_BYTES), truncated };
+}
+async function gitLog(limit = 30, cwd) {
+  const sep2 = "
";
+  const fmt = ["%H", "%h", "%an", "%aI", "%s"].join(sep2);
+  const r = await git(["log", `-n${Math.min(limit, 200)}`, `--pretty=format:${fmt}`], cwd);
+  if (r.code !== 0) return { commits: [], error: r.stderr.trim() };
+  const commits = r.stdout.split("\n").filter(Boolean).map((line) => {
+    const [hash, shortHash, author, date, subject] = line.split(sep2);
+    return { hash, shortHash, author, date, subject };
+  });
+  return { commits };
+}
+async function gitCommit(message, files, cwd) {
+  if (!message || message.trim().length === 0) {
+    return { error: "Commit message is required." };
+  }
+  if (files && files.length > 0) {
+    const r2 = await git(["add", "--", ...files], cwd);
+    if (r2.code !== 0) return { error: `git add failed: ${r2.stderr.trim()}` };
+  } else {
+    const r2 = await git(["add", "-A"], cwd);
+    if (r2.code !== 0) return { error: `git add failed: ${r2.stderr.trim()}` };
+  }
+  const r = await git(["commit", "-m", message], cwd);
+  if (r.code !== 0) {
+    return { error: r.stderr.trim() || "git commit failed" };
+  }
+  const head = await git(["rev-parse", "HEAD"], cwd);
+  return { ok: true, commit: head.stdout.trim() };
+}
+async function gitPush(cwd) {
+  const r = await git(["push"], cwd);
+  if (r.code !== 0) return { error: r.stderr.trim() || "git push failed" };
+  return { ok: true, output: (r.stdout + r.stderr).trim() };
+}
+async function gitPull(cwd) {
+  const r = await git(["pull", "--ff-only"], cwd);
+  if (r.code !== 0) return { error: r.stderr.trim() || "git pull failed" };
+  return { ok: true, output: (r.stdout + r.stderr).trim() };
+}
+async function gitResolve(file, side, cwd) {
+  const r = await git(["checkout", `--${side}`, "--", file], cwd);
+  if (r.code !== 0) return { error: r.stderr.trim() || `git checkout --${side} failed` };
+  const add = await git(["add", "--", file], cwd);
+  if (add.code !== 0) return { error: add.stderr.trim() || "git add (resolve) failed" };
+  return { ok: true };
+}
+
 // 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 = path6.join(os5.tmpdir(), `codeam-${(0, import_crypto.randomUUID)()}-${safeName}`);
-    fs6.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+    const tmpPath = path7.join(os5.tmpdir(), `codeam-${(0, import_crypto.randomUUID)()}-${safeName}`);
+    fs7.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     return tmpPath;
   });
 }
@@ -2357,14 +2653,14 @@ try:
     sys.exit((st>>8)&0xFF)
 except Exception:sys.exit(0)
 `;
-    const helperPath = path6.join(os5.tmpdir(), "codeam-quota-helper.py");
-    fs6.writeFileSync(helperPath, helperScript, { mode: 420 });
+    const helperPath = path7.join(os5.tmpdir(), "codeam-quota-helper.py");
+    fs7.writeFileSync(helperPath, helperScript, { mode: 420 });
     const python = findInPath("python3") ?? findInPath("python");
     if (!python) {
       quotaFetchInProgress = false;
       return;
     }
-    const proc = (0, import_child_process3.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
+    const proc = (0, import_child_process4.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
       stdio: ["pipe", "pipe", "ignore"],
       cwd: process.cwd(),
       env: { ...process.env, TERM: "dumb", COLUMNS: "120", LINES: "30" }
@@ -2390,7 +2686,7 @@ except Exception:sys.exit(0)
         } catch {
         }
         try {
-          fs6.unlinkSync(helperPath);
+          fs7.unlinkSync(helperPath);
         } catch {
         }
         quotaFetchInProgress = false;
@@ -2440,7 +2736,7 @@ except Exception:sys.exit(0)
           setTimeout(() => {
             for (const p2 of paths) {
               try {
-                fs6.unlinkSync(p2);
+                fs7.unlinkSync(p2);
               } catch {
               }
             }
@@ -2532,6 +2828,62 @@ except Exception:sys.exit(0)
         await relay.sendResult(cmd.id, "completed", result);
         break;
       }
+      case "list_files": {
+        const result = await listProjectFiles({ query: parsed.query });
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_status": {
+        const result = await gitStatus();
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_diff": {
+        const { path: filePath } = parsed;
+        const result = await gitDiff(filePath ?? null);
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_diff_staged": {
+        const { path: filePath } = parsed;
+        const result = await gitDiffStaged(filePath ?? null);
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_log": {
+        const result = await gitLog(parsed.limit ?? 30);
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_commit": {
+        if (!parsed.message) {
+          await relay.sendResult(cmd.id, "failed", { error: "Missing message" });
+          break;
+        }
+        const result = await gitCommit(parsed.message, parsed.paths);
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_push": {
+        const result = await gitPush();
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_pull": {
+        const result = await gitPull();
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
+      case "git_resolve": {
+        const { path: filePath, side } = parsed;
+        if (!filePath || !side) {
+          await relay.sendResult(cmd.id, "failed", { error: "Missing path or side" });
+          break;
+        }
+        const result = await gitResolve(filePath, side);
+        await relay.sendResult(cmd.id, "completed", result);
+        break;
+      }
     }
   });
   ws.addHandler({
@@ -2559,7 +2911,7 @@ except Exception:sys.exit(0)
           setTimeout(() => {
             for (const p2 of paths) {
               try {
-                fs6.unlinkSync(p2);
+                fs7.unlinkSync(p2);
               } catch {
               }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "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 — from anywhere.",
   "main": "dist/index.js",
   "bin": {