codeam-cli 2.2.2 → 2.4.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.2",
+  version: "2.4.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);
@@ -2212,8 +2220,8 @@ function isUnder(parent, candidate) {
 }
 async function isExistingFile(absPath) {
   try {
-    const stat2 = await fs5.stat(absPath);
-    return stat2.isFile();
+    const stat3 = await fs5.stat(absPath);
+    return stat3.isFile();
   } catch {
     return false;
   }
@@ -2286,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)) {
@@ -2318,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;
   });
 }
@@ -2396,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" }
@@ -2429,7 +2686,7 @@ except Exception:sys.exit(0)
         } catch {
         }
         try {
-          fs6.unlinkSync(helperPath);
+          fs7.unlinkSync(helperPath);
         } catch {
         }
         quotaFetchInProgress = false;
@@ -2479,7 +2736,7 @@ except Exception:sys.exit(0)
           setTimeout(() => {
             for (const p2 of paths) {
               try {
-                fs6.unlinkSync(p2);
+                fs7.unlinkSync(p2);
               } catch {
               }
             }
@@ -2571,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({
@@ -2598,7 +2911,7 @@ except Exception:sys.exit(0)
           setTimeout(() => {
             for (const p2 of paths) {
               try {
-                fs6.unlinkSync(p2);
+                fs7.unlinkSync(p2);
               } catch {
               }
             }
@@ -4763,6 +5076,294 @@ async function logout() {
   console.log(import_picocolors6.default.green("\n  \u2713 Done. All sessions removed.\n"));
 }
 
+// src/commands/deploy.ts
+var fs8 = __toESM(require("fs"));
+var os6 = __toESM(require("os"));
+var path8 = __toESM(require("path"));
+var import_picocolors7 = __toESM(require("picocolors"));
+
+// src/services/providers/github-codespaces.ts
+var import_child_process5 = require("child_process");
+var import_util2 = require("util");
+var execFileP2 = (0, import_util2.promisify)(import_child_process5.execFile);
+var MAX_BUFFER = 8 * 1024 * 1024;
+var GitHubCodespacesProvider = class {
+  id = "github-codespaces";
+  displayName = "GitHub Codespaces";
+  tagline = "Cloud dev environment from any GitHub repo";
+  available = true;
+  async authorize() {
+    try {
+      await execFileP2("gh", ["--version"], { maxBuffer: MAX_BUFFER });
+    } catch {
+      throw new Error(
+        [
+          "GitHub CLI (`gh`) is required for Codespaces deploys.",
+          "Install it with:",
+          "  \u2022 macOS:   brew install gh",
+          "  \u2022 Linux:   https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
+          "  \u2022 Windows: winget install --id GitHub.cli",
+          "Then run `gh auth login` and try `codeam deploy` again."
+        ].join("\n")
+      );
+    }
+    try {
+      await execFileP2("gh", ["auth", "status"], { maxBuffer: MAX_BUFFER });
+      return;
+    } catch {
+    }
+    await new Promise((resolve2, reject) => {
+      const proc = (0, import_child_process5.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
+        stdio: "inherit"
+      });
+      proc.on("exit", (code) => {
+        if (code === 0) resolve2();
+        else reject(new Error("gh auth login failed."));
+      });
+      proc.on("error", reject);
+    });
+  }
+  async listProjects() {
+    const { stdout } = await execFileP2(
+      "gh",
+      [
+        "repo",
+        "list",
+        "--json",
+        "name,nameWithOwner,description,defaultBranchRef,isPrivate",
+        "--limit",
+        "200"
+      ],
+      { maxBuffer: MAX_BUFFER }
+    );
+    const raw = JSON.parse(stdout);
+    return raw.map((r) => ({
+      id: r.nameWithOwner,
+      name: r.name,
+      fullName: r.nameWithOwner,
+      description: r.description ?? void 0,
+      defaultBranch: r.defaultBranchRef?.name,
+      private: !!r.isPrivate
+    }));
+  }
+  async createWorkspace(projectId) {
+    const { stdout } = await execFileP2(
+      "gh",
+      ["codespace", "create", "-R", projectId, "--default-permissions"],
+      { maxBuffer: MAX_BUFFER, timeout: 12e4 }
+    );
+    const name = stdout.trim().split("\n").filter(Boolean).pop() ?? "";
+    if (!name) {
+      throw new Error("GitHub did not return a codespace name.");
+    }
+    await this.waitUntilAvailable(name);
+    return {
+      id: name,
+      displayName: name,
+      webUrl: `https://github.com/codespaces/${name}`
+    };
+  }
+  async waitUntilAvailable(name) {
+    const deadline = Date.now() + 5 * 60 * 1e3;
+    while (Date.now() < deadline) {
+      const { stdout } = await execFileP2(
+        "gh",
+        ["codespace", "list", "--json", "name,state"],
+        { maxBuffer: MAX_BUFFER }
+      );
+      const list = JSON.parse(stdout);
+      const me2 = list.find((c2) => c2.name === name);
+      if (!me2) throw new Error("Codespace disappeared from the list.");
+      if (me2.state === "Available") return;
+      if (me2.state === "Failed" || me2.state === "Unavailable") {
+        throw new Error(`Codespace state: ${me2.state}.`);
+      }
+      await new Promise((r) => setTimeout(r, 3e3));
+    }
+    throw new Error("Codespace did not become Available within 5 minutes.");
+  }
+  async exec(workspaceId, command2) {
+    try {
+      const { stdout, stderr } = await execFileP2(
+        "gh",
+        ["codespace", "ssh", "-c", workspaceId, "--", command2],
+        { maxBuffer: MAX_BUFFER, timeout: 6e5 }
+      );
+      return { stdout, stderr, code: 0 };
+    } catch (err) {
+      const e = err;
+      return {
+        stdout: e.stdout ?? "",
+        stderr: e.stderr ?? e.message ?? "gh codespace ssh failed",
+        code: typeof e.code === "number" ? e.code : 1
+      };
+    }
+  }
+  async streamCommand(workspaceId, command2) {
+    return new Promise((resolve2, reject) => {
+      const proc = (0, import_child_process5.spawn)(
+        "gh",
+        ["codespace", "ssh", "-c", workspaceId, "-t", "--", command2],
+        { stdio: "inherit" }
+      );
+      proc.on("exit", (code) => resolve2({ code: code ?? 0 }));
+      proc.on("error", reject);
+    });
+  }
+  async uploadDirectory(workspaceId, localDir, remoteDir) {
+    await execFileP2(
+      "gh",
+      ["codespace", "cp", "-r", "-c", workspaceId, localDir, `remote:${remoteDir}`],
+      { maxBuffer: MAX_BUFFER, timeout: 3e5 }
+    );
+  }
+};
+
+// src/services/providers/index.ts
+var PROVIDERS = [
+  new GitHubCodespacesProvider()
+  // Sketches for future providers — uncomment + implement when ready.
+  // new GitpodProvider(),
+  // new CoderProvider(),
+  // new GitLabWebIDEProvider(),
+];
+
+// src/commands/deploy.ts
+async function deploy() {
+  console.log();
+  mt(import_picocolors7.default.bgMagenta(import_picocolors7.default.white(" codeam deploy ")));
+  const provider = await pickProvider();
+  if (!provider) {
+    pt("No provider selected.");
+    process.exit(0);
+  }
+  const authStep = fe();
+  authStep.start(`Authorizing with ${provider.displayName}\u2026`);
+  try {
+    await provider.authorize();
+    authStep.stop(`\u2713 Authorized with ${provider.displayName}`);
+  } catch (err) {
+    authStep.stop(`\u2717 Authorization failed`);
+    pt(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const listStep = fe();
+  listStep.start("Loading your projects\u2026");
+  let projects = [];
+  try {
+    projects = await provider.listProjects();
+    listStep.stop(`\u2713 ${projects.length} project${projects.length === 1 ? "" : "s"} available`);
+  } catch (err) {
+    listStep.stop(`\u2717 Could not list projects`);
+    pt(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (projects.length === 0) {
+    pt("No projects found on the account.");
+    process.exit(0);
+  }
+  const projectId = await _t({
+    message: "Select a project to deploy:",
+    options: projects.slice(0, 50).map((proj) => ({
+      value: proj.id,
+      label: proj.fullName,
+      hint: proj.description ? proj.description.slice(0, 80) : proj.private ? "private" : "public"
+    }))
+  });
+  if (q(projectId) || typeof projectId !== "string") {
+    pt("Cancelled.");
+    process.exit(0);
+  }
+  const project = projects.find((proj) => proj.id === projectId);
+  const createStep = fe();
+  createStep.start(`Creating workspace for ${project.fullName}\u2026`);
+  let workspace;
+  try {
+    workspace = await provider.createWorkspace(project.id);
+    createStep.stop(`\u2713 Workspace ready: ${workspace.displayName ?? workspace.id}`);
+  } catch (err) {
+    createStep.stop(`\u2717 Workspace creation failed`);
+    pt(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const claudeStep = fe();
+  claudeStep.start("Installing Claude CLI on workspace\u2026");
+  const installResult = await provider.exec(
+    workspace.id,
+    "curl -fsSL https://claude.ai/install.sh | bash"
+  );
+  if (installResult.code !== 0) {
+    claudeStep.stop("\u2717 Claude CLI install failed");
+    pt(installResult.stderr.slice(0, 1e3));
+    process.exit(1);
+  }
+  claudeStep.stop("\u2713 Claude CLI installed");
+  const localClaudeDir = path8.join(os6.homedir(), ".claude");
+  if (fs8.existsSync(localClaudeDir) && fs8.statSync(localClaudeDir).isDirectory()) {
+    const copyStep = fe();
+    copyStep.start("Copying local Claude config to workspace\u2026");
+    try {
+      await provider.uploadDirectory(workspace.id, localClaudeDir, "/home/codespace/.claude");
+      copyStep.stop("\u2713 Claude config copied \u2014 no re-auth needed");
+    } catch (err) {
+      copyStep.stop("\u26A0 Could not copy Claude config \u2014 you may need to login on the workspace");
+      void err;
+    }
+  } else {
+    wt(
+      "No local ~/.claude config found. You can authenticate Claude in the workspace shell when needed.",
+      "Heads up"
+    );
+  }
+  const cliStep = fe();
+  cliStep.start("Installing codeam-cli on workspace\u2026");
+  const cliInstall = await provider.exec(workspace.id, "npm install -g codeam-cli@latest");
+  if (cliInstall.code !== 0) {
+    cliStep.stop("\u2717 codeam-cli install failed");
+    pt(cliInstall.stderr.slice(0, 1e3));
+    process.exit(1);
+  }
+  cliStep.stop("\u2713 codeam-cli installed");
+  wt(
+    [
+      `Workspace: ${import_picocolors7.default.cyan(workspace.displayName ?? workspace.id)}`,
+      workspace.webUrl ? `Web:       ${import_picocolors7.default.cyan(workspace.webUrl)}` : "",
+      "",
+      "Starting `codeam pair` on the workspace.",
+      "Scan the QR code below with the CodeAgent Mobile app to finish pairing."
+    ].filter(Boolean).join("\n"),
+    "Almost there"
+  );
+  const code = (await provider.streamCommand(workspace.id, "codeam pair")).code;
+  if (code === 0) {
+    gt(import_picocolors7.default.green(`\u2713 Workspace deployed and paired. Drive from your phone, anywhere.`));
+  } else {
+    gt(import_picocolors7.default.yellow(`Pairing exited with code ${code}. Run "codeam pair" inside the codespace if needed.`));
+  }
+}
+async function pickProvider() {
+  const ready = PROVIDERS.filter((prov) => prov.available);
+  if (ready.length === 1) return ready[0];
+  const selection = await _t({
+    message: "Where do you want to deploy?",
+    options: PROVIDERS.map((prov) => ({
+      value: prov.id,
+      label: prov.available ? prov.displayName : `${prov.displayName} ${import_picocolors7.default.dim("(coming soon)")}`,
+      hint: prov.tagline
+    }))
+  });
+  if (q(selection) || typeof selection !== "string") return null;
+  const found = PROVIDERS.find((prov) => prov.id === selection);
+  if (!found || !found.available) {
+    wt(
+      `${found?.displayName ?? "That provider"} isn\u2019t implemented yet \u2014 we'll ping you on Twitter/X when it ships.`,
+      "Heads up"
+    );
+    return null;
+  }
+  return found;
+}
+
 // src/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
@@ -4775,6 +5376,8 @@ async function main() {
       return status();
     case "logout":
       return logout();
+    case "deploy":
+      return deploy();
     default:
       return start();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.2.2",
+  "version": "2.4.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": {