codeam-cli 2.4.17 → 2.4.19

package/CHANGELOG.md

@@ -4,6 +4,24 @@ 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.4.18] — 2026-05-03
+
+### Added
+
+- **cli:** Codeam deploy ls + stop, plus runtime tag for the apps (v2.4.18)
+
+## [2.4.17] — 2026-05-03
+
+### Fixed
+
+- **cli:** Show the QR in codeam deploy (tail -n +1) (v2.4.17)
+
+## [2.4.16] — 2026-05-03
+
+### Fixed
+
+- **cli:** Clean codeam deploy log output under PM2 (v2.4.16)
+
 ## [2.4.15] — 2026-05-03
 
 ### Fixed

package/README.md

@@ -47,12 +47,14 @@ That's it. Open the [CodeAgent Mobile app](https://codeagent-mobile.com), enter
 | `codeam status` | Show connection status |
 | `codeam logout` | Remove all paired sessions |
 | `codeam deploy` | Provision a cloud workspace (GitHub Codespaces) and pair it to your phone |
+| `codeam deploy ls` | List the cloud workspaces you've deployed (and which still have a session running) |
+| `codeam deploy stop` | Pick a deployed workspace and stop its codeam session (and optionally the workspace itself) |
 
 ---
 
 ## `codeam deploy` — drive a cloud workspace from your phone
 
-Don't want to keep your laptop running while you control Claude from the train? `codeam deploy` spins up a fresh **GitHub Codespace** for any of your repos, installs Claude Code + `codeam-cli` inside it, copies your local Claude credentials so you skip the re-auth (or runs `claude login` interactively if you don't have a local config yet), and finishes by streaming `codeam pair` from inside the codespace — so you get a pairing code on this terminal already wired to the remote workspace.
+Don't want to keep your laptop running while you control Claude from the train? `codeam deploy` spins up a fresh **GitHub Codespace** for any of your repos, installs Claude Code + `codeam-cli` inside it, copies your local Claude credentials so you skip the re-auth (or runs `claude login` interactively if you don't have a local config yet), supervises the agent with **PM2** so the session survives even after you close your laptop, and gives you a QR/code to pair your phone — straight from your local terminal.
 
 ```bash
 codeam deploy
@@ -62,11 +64,26 @@ That's it. You'll be guided through:
 
 1. **Pick a provider** (GitHub Codespaces today; more coming).
 2. **Pick a repo** from your account.
-3. **Wait ~1 minute** while the codespace boots and tools install.
-4. **Scan the QR / enter the code** on the CodeAgent Mobile app — same flow as `codeam pair`, only the agent is now running in the cloud.
+3. **Reuse an existing codespace or create a new one** — re-runs of `codeam deploy` against the same project don't pile up codespaces.
+4. **Wait ~1 minute** while the codespace boots and tools install.
+5. **Scan the QR / enter the code** on the CodeAgent Mobile app.
+6. Your local terminal **automatically disconnects** once Claude is ready — close the laptop, the agent keeps running on the codespace, and your phone stays connected.
 
 Requirements: the [GitHub CLI (`gh`)](https://cli.github.com/) installed and authenticated (`gh auth login`). The deploy flow re-uses `gh`'s OAuth — we don't ask for a separate token.
 
+### Managing your deployed workspaces
+
+```bash
+# Show every workspace you've deployed and whether codeam is still running on it.
+codeam deploy ls
+
+# Pick one and stop the codeam session — also offers to stop the workspace
+# itself so you don't burn compute hours.
+codeam deploy stop
+```
+
+Stopping a workspace via `codeam deploy stop` is non-destructive: the GitHub Codespace stays around (preserving your branch, files, and dotfiles); only the running compute is paused. Re-running `codeam deploy` will offer to resume that same codespace.
+
 Adding more cloud backends (Gitpod, Coder, your own SSH host, …) is a single new file in `apps/cli/src/services/providers/` — the `CloudProvider` interface keeps it pluggable.
 
 ---

package/dist/index.js

@@ -179,7 +179,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.4.17",
+  version: "2.4.19",
   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: {
@@ -406,11 +406,15 @@ var os2 = __toESM(require("os"));
 var API_BASE2 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 async function requestCode(pluginId) {
   try {
+    const runtime = process.env.CODESPACES === "true" ? "github-codespaces" : "local";
+    const codespaceName = process.env.CODESPACE_NAME;
     const result = await _transport.postJson(`${API_BASE2}/api/pairing/code`, {
       pluginId,
       ideName: "Terminal (codeam-cli)",
       ideVersion: package_default.version,
-      hostname: os2.hostname()
+      hostname: os2.hostname(),
+      runtime,
+      ...codespaceName ? { codespaceName } : {}
     });
     const data = result?.data;
     if (!data?.code) return null;
@@ -2766,6 +2770,28 @@ except Exception:sys.exit(0)
       case "stop_task":
         claude.interrupt();
         break;
+      case "shutdown_session": {
+        try {
+          await relay.sendResult(cmd.id, "success", { ok: true });
+        } catch {
+        }
+        try {
+          claude.kill();
+        } catch {
+        }
+        try {
+          const proc = (0, import_child_process4.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+            detached: true,
+            stdio: "ignore"
+          });
+          proc.unref();
+        } catch {
+        }
+        outputSvc.dispose();
+        relay.stop();
+        ws.disconnect();
+        process.exit(0);
+      }
       case "get_context": {
         const usage = historySvc.getCurrentUsage();
         const monthlyCost = historySvc.getMonthlyEstimatedCost();
@@ -5551,18 +5577,9 @@ var GitHubCodespacesProvider = class {
   }
   async listExistingWorkspaces(projectId) {
     try {
-      const { stdout } = await execFileP2(
-        "gh",
-        [
-          "codespace",
-          "list",
-          "--repo",
-          projectId,
-          "--json",
-          "name,displayName,state,lastUsedAt"
-        ],
-        { maxBuffer: MAX_BUFFER }
-      );
+      const args2 = ["codespace", "list", "--json", "name,displayName,state,lastUsedAt"];
+      if (projectId) args2.push("--repo", projectId);
+      const { stdout } = await execFileP2("gh", args2, { maxBuffer: MAX_BUFFER });
       const list = JSON.parse(stdout);
       return list.map((c2) => ({
         id: c2.name,
@@ -6134,6 +6151,144 @@ async function pickProvider() {
   return found;
 }
 
+// src/commands/deploy-manage.ts
+var import_picocolors9 = __toESM(require("picocolors"));
+async function deployList() {
+  console.log();
+  mt(import_picocolors9.default.bgMagenta(import_picocolors9.default.white(" codeam deploy ls ")));
+  const workspaces = await collectWorkspacesWithStatus();
+  if (workspaces.length === 0) {
+    gt(import_picocolors9.default.dim("No deployed workspaces found."));
+    return;
+  }
+  for (const w3 of workspaces) {
+    const tag = w3.codeamRunning ? import_picocolors9.default.green("\u25CF running") : w3.state === "Available" ? import_picocolors9.default.dim("\u25CB idle") : import_picocolors9.default.dim(`\u25CB ${w3.state ?? "stopped"}`);
+    console.log(`  ${tag}  ${import_picocolors9.default.cyan(w3.displayName ?? w3.id)}  ${import_picocolors9.default.dim("(" + w3.providerName + ")")}`);
+  }
+  gt(import_picocolors9.default.dim("Use `codeam deploy stop` to terminate a session."));
+}
+async function deployStop() {
+  console.log();
+  mt(import_picocolors9.default.bgMagenta(import_picocolors9.default.white(" codeam deploy stop ")));
+  const workspaces = await collectWorkspacesWithStatus();
+  if (workspaces.length === 0) {
+    gt(import_picocolors9.default.dim("No deployed workspaces found."));
+    return;
+  }
+  const choice = await _t({
+    message: "Pick a workspace to stop:",
+    options: workspaces.map((w3) => ({
+      value: w3.id,
+      label: w3.displayName ?? w3.id,
+      hint: [
+        w3.providerName,
+        w3.codeamRunning ? import_picocolors9.default.green("\u25CF codeam-pair running") : import_picocolors9.default.dim("\u25CB no codeam-pair"),
+        w3.state ?? ""
+      ].filter(Boolean).join(" \xB7 ")
+    }))
+  });
+  if (q(choice)) {
+    pt("Cancelled.");
+    process.exit(0);
+  }
+  const target = workspaces.find((w3) => w3.id === choice);
+  if (target.codeamRunning) {
+    const stopStep = fe();
+    stopStep.start("Stopping codeam-pair on the workspace\u2026");
+    try {
+      const result = await target.provider.exec(
+        target.id,
+        "pm2 delete codeam-pair >/dev/null 2>&1; pm2 list 2>/dev/null | grep -c codeam-pair || true"
+      );
+      void result;
+      stopStep.stop("\u2713 codeam-pair stopped \u2014 your phone is now disconnected from this workspace");
+    } catch (err) {
+      stopStep.stop("\u26A0 Could not reach the workspace to stop codeam-pair");
+      void err;
+    }
+  } else {
+    O2.info("No codeam-pair process to stop on this workspace.");
+  }
+  const alsoStop = await ot2({
+    message: `Also stop the workspace ${import_picocolors9.default.cyan(target.displayName ?? target.id)} to save compute hours?`,
+    initialValue: true
+  });
+  if (!q(alsoStop) && alsoStop) {
+    const cs = fe();
+    cs.start("Stopping workspace\u2026");
+    try {
+      const result = await target.provider.exec(
+        target.id,
+        // We'd ideally use a provider method; for now do it inline
+        // — works for the github-codespaces provider, no-op-ish for
+        // others (the command will fail and we fall back gracefully).
+        "echo stopping"
+      );
+      void result;
+      await stopWorkspaceFromLocal(target);
+      cs.stop(`\u2713 Workspace ${target.displayName ?? target.id} is stopping`);
+    } catch (err) {
+      cs.stop("\u26A0 Could not stop the workspace");
+      O2.warn(err instanceof Error ? err.message : String(err));
+    }
+  }
+  gt(import_picocolors9.default.green("\u2713 Done."));
+}
+async function collectWorkspacesWithStatus() {
+  const out = [];
+  const ready = PROVIDERS.filter((prov) => prov.available);
+  for (const provider of ready) {
+    if (!provider.listExistingWorkspaces) continue;
+    const probeStep = fe();
+    probeStep.start(`Listing ${provider.displayName} workspaces\u2026`);
+    let workspaces = [];
+    try {
+      await provider.authorize();
+      workspaces = await provider.listExistingWorkspaces();
+      probeStep.stop(`\u2713 ${workspaces.length} workspace${workspaces.length === 1 ? "" : "s"} on ${provider.displayName}`);
+    } catch (err) {
+      probeStep.stop(`\u2717 Could not list ${provider.displayName} workspaces`);
+      O2.warn(err instanceof Error ? err.message : String(err));
+      continue;
+    }
+    for (const w3 of workspaces) {
+      const codeamRunning = await probeCodeamPair(provider, w3);
+      out.push({
+        ...w3,
+        provider,
+        providerName: provider.displayName,
+        codeamRunning
+      });
+    }
+  }
+  return out;
+}
+async function probeCodeamPair(provider, workspace) {
+  if (workspace.state && workspace.state !== "Available") return false;
+  try {
+    const result = await provider.exec(
+      workspace.id,
+      // `online` is the only state we care about — `errored`, `stopped`,
+      // `stopping` all mean it's not actively serving the user's phone.
+      `pm2 jlist 2>/dev/null | grep -c '"name":"codeam-pair"[^}]*"status":"online"' || echo 0`
+    );
+    if (result.code !== 0) return false;
+    const n = parseInt(result.stdout.trim(), 10);
+    return Number.isFinite(n) && n > 0;
+  } catch {
+    return false;
+  }
+}
+async function stopWorkspaceFromLocal(target) {
+  if (target.provider.id === "github-codespaces") {
+    const { execFile: execFile4 } = await import("child_process");
+    const { promisify: promisify4 } = await import("util");
+    const execFileP4 = promisify4(execFile4);
+    await execFileP4("gh", ["codespace", "stop", "-c", target.id], { maxBuffer: 8 * 1024 * 1024 });
+    return;
+  }
+}
+
 // src/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
@@ -6147,6 +6302,8 @@ async function main() {
     case "logout":
       return logout();
     case "deploy":
+      if (args[0] === "ls" || args[0] === "list") return deployList();
+      if (args[0] === "stop" || args[0] === "remove") return deployStop();
       return deploy();
     default:
       return start();

package/package.json

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