codeam-cli 2.4.0 → 2.4.2

package/README.md

@@ -46,6 +46,28 @@ That's it. Open the [CodeAgent Mobile app](https://codeagent-mobile.com), enter
 | `codeam sessions` | List all paired devices |
 | `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` — 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.
+
+```bash
+codeam deploy
+```
+
+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.
+
+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.
+
+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.0",
+  version: "2.4.2",
   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: {
@@ -5080,11 +5080,12 @@ async function logout() {
 var fs8 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 var path8 = __toESM(require("path"));
-var import_picocolors7 = __toESM(require("picocolors"));
+var import_picocolors8 = __toESM(require("picocolors"));
 
 // src/services/providers/github-codespaces.ts
 var import_child_process5 = require("child_process");
 var import_util2 = require("util");
+var import_picocolors7 = __toESM(require("picocolors"));
 var execFileP2 = (0, import_util2.promisify)(import_child_process5.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 var GitHubCodespacesProvider = class {
@@ -5096,16 +5097,21 @@ var GitHubCodespacesProvider = class {
     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")
-      );
+      await this.tryInstallGh();
+      try {
+        await execFileP2("gh", ["--version"], { maxBuffer: MAX_BUFFER });
+      } catch {
+        throw new Error(
+          [
+            "GitHub CLI (`gh`) is still not on PATH.",
+            "Install it manually 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 `codeam deploy` again."
+          ].join("\n")
+        );
+      }
     }
     try {
       await execFileP2("gh", ["auth", "status"], { maxBuffer: MAX_BUFFER });
@@ -5123,6 +5129,95 @@ var GitHubCodespacesProvider = class {
       proc.on("error", reject);
     });
   }
+  /**
+   * Try to install the `gh` CLI for the user. Opt-in via a confirm
+   * prompt — we never run `brew` / `winget` / `apt` without explicit
+   * consent. Strategy per platform:
+   *
+   *   - macOS:   `brew install gh` (requires Homebrew)
+   *   - Windows: `winget install --id GitHub.cli -e --silent`
+   *   - Linux:   too many distros / package managers to be safe; we
+   *              point the user at the official install doc instead.
+   *
+   * Stdio is inherited so any sudo / authentication prompt the package
+   * manager surfaces (e.g. macOS keychain, Windows UAC) lands in this
+   * terminal. On failure or an unsupported platform we just return —
+   * the caller will re-check `gh --version` and surface the manual-
+   * install error if it's still missing.
+   */
+  async tryInstallGh() {
+    const platform = process.platform;
+    wt(
+      `GitHub CLI (${import_picocolors7.default.cyan("gh")}) is required for Codespaces deploys but isn't on your PATH.`,
+      "Heads up"
+    );
+    if (platform === "linux") {
+      wt(
+        [
+          "On Linux, please install gh from the official guide:",
+          "  https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
+          "Re-run `codeam deploy` once it is on your PATH."
+        ].join("\n"),
+        "Install gh on Linux"
+      );
+      return;
+    }
+    let installCmd = null;
+    if (platform === "darwin") {
+      try {
+        await execFileP2("brew", ["--version"], { maxBuffer: MAX_BUFFER });
+      } catch {
+        wt(
+          [
+            "Homebrew (`brew`) is not installed.",
+            "Install it from https://brew.sh and re-run `codeam deploy`,",
+            "or install gh manually: https://cli.github.com/"
+          ].join("\n"),
+          "Cannot auto-install on macOS"
+        );
+        return;
+      }
+      installCmd = {
+        exe: "brew",
+        args: ["install", "gh"],
+        describe: "brew install gh"
+      };
+    } else if (platform === "win32") {
+      try {
+        await execFileP2("winget", ["--version"], { maxBuffer: MAX_BUFFER });
+      } catch {
+        wt(
+          [
+            "winget is not available on this machine.",
+            "Install gh manually: https://github.com/cli/cli/releases/latest"
+          ].join("\n"),
+          "Cannot auto-install on Windows"
+        );
+        return;
+      }
+      installCmd = {
+        exe: "winget",
+        args: ["install", "--id", "GitHub.cli", "-e", "--silent"],
+        describe: "winget install --id GitHub.cli"
+      };
+    } else {
+      return;
+    }
+    const proceed = await ot2({
+      message: `Run ${import_picocolors7.default.cyan(installCmd.describe)} now?`,
+      initialValue: true
+    });
+    if (q(proceed) || !proceed) return;
+    const installStep = fe();
+    installStep.start(`Installing gh via ${installCmd.describe}\u2026`);
+    const ok = await new Promise((resolve2) => {
+      const proc = (0, import_child_process5.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
+      proc.on("exit", (code) => resolve2(code === 0));
+      proc.on("error", () => resolve2(false));
+    });
+    if (ok) installStep.stop("\u2713 gh installed");
+    else installStep.stop("\u2717 gh install failed");
+  }
   async listProjects() {
     const { stdout } = await execFileP2(
       "gh",
@@ -5146,10 +5241,51 @@ var GitHubCodespacesProvider = class {
       private: !!r.isPrivate
     }));
   }
-  async createWorkspace(projectId) {
+  /**
+   * Return the machine types available to the user for this repo. The
+   * `gh api /repos/.../codespaces/machines` endpoint reports CPU / RAM /
+   * storage, so we hand all three to the picker for a clean label.
+   *
+   * We filter out anything below 8 GB RAM — Claude Code wants headroom
+   * for `tsc`, build tools, and parallel test runners; the 4 GB tier
+   * (when available) is too tight in practice.
+   */
+  async listMachineTypes(projectId) {
+    try {
+      const { stdout } = await execFileP2(
+        "gh",
+        ["api", `/repos/${projectId}/codespaces/machines`],
+        { maxBuffer: MAX_BUFFER }
+      );
+      const data = JSON.parse(stdout);
+      const machines = data.machines ?? [];
+      const GB = 1024 ** 3;
+      return machines.map((m) => {
+        const memoryGb = m.memory_in_bytes ? Math.round(m.memory_in_bytes / GB) : 0;
+        const storageGb = m.storage_in_bytes ? Math.round(m.storage_in_bytes / GB) : void 0;
+        const parts = [];
+        if (m.cpus) parts.push(`${m.cpus} ${m.cpus === 1 ? "core" : "cores"}`);
+        if (memoryGb) parts.push(`${memoryGb} GB RAM`);
+        if (storageGb) parts.push(`${storageGb} GB storage`);
+        return {
+          id: m.name,
+          label: m.display_name ?? (parts.join(" \xB7 ") || m.name),
+          memoryGb,
+          cpus: m.cpus,
+          storageGb
+        };
+      }).filter((m) => m.memoryGb >= 8).sort((a, b) => a.memoryGb - b.memoryGb || (a.cpus ?? 0) - (b.cpus ?? 0));
+    } catch {
+      return [];
+    }
+  }
+  async createWorkspace(projectId, machineTypeId) {
+    const machine = machineTypeId ?? await this.pickDefaultMachine(projectId);
+    const args2 = ["codespace", "create", "-R", projectId, "--default-permissions"];
+    if (machine) args2.push("-m", machine);
     const { stdout } = await execFileP2(
       "gh",
-      ["codespace", "create", "-R", projectId, "--default-permissions"],
+      args2,
       { maxBuffer: MAX_BUFFER, timeout: 12e4 }
     );
     const name = stdout.trim().split("\n").filter(Boolean).pop() ?? "";
@@ -5163,6 +5299,27 @@ var GitHubCodespacesProvider = class {
       webUrl: `https://github.com/codespaces/${name}`
     };
   }
+  /**
+   * Fallback machine picker for when the orchestrator didn't ask the
+   * user — defaults to the cheapest 8 GB tier (`basicLinux32gb`) and
+   * walks up only if the repo restricts that tier. Returns `null` if
+   * the API call fails entirely; the caller will then omit `-m` and
+   * let `gh` use the repo/org default.
+   */
+  async pickDefaultMachine(projectId) {
+    const machines = await this.listMachineTypes(projectId);
+    if (machines.length === 0) return null;
+    const preferenceOrder = [
+      "basicLinux32gb",
+      "standardLinux32gb",
+      "premiumLinux",
+      "largePremiumLinux"
+    ];
+    for (const pref of preferenceOrder) {
+      if (machines.some((m) => m.id === pref)) return pref;
+    }
+    return machines[0].id;
+  }
   async waitUntilAvailable(name) {
     const deadline = Date.now() + 5 * 60 * 1e3;
     while (Date.now() < deadline) {
@@ -5231,7 +5388,7 @@ var PROVIDERS = [
 // src/commands/deploy.ts
 async function deploy() {
   console.log();
-  mt(import_picocolors7.default.bgMagenta(import_picocolors7.default.white(" codeam deploy ")));
+  mt(import_picocolors8.default.bgMagenta(import_picocolors8.default.white(" codeam deploy ")));
   const provider = await pickProvider();
   if (!provider) {
     pt("No provider selected.");
@@ -5275,11 +5432,43 @@ async function deploy() {
     process.exit(0);
   }
   const project = projects.find((proj) => proj.id === projectId);
+  let machineTypeId;
+  if (provider.listMachineTypes) {
+    const machineStep = fe();
+    machineStep.start("Loading machine types\u2026");
+    let machines = [];
+    try {
+      machines = await provider.listMachineTypes(project.id);
+      machineStep.stop(
+        machines.length > 0 ? `\u2713 ${machines.length} machine type${machines.length === 1 ? "" : "s"} available` : "\xB7 No machine types reported (using provider default)"
+      );
+    } catch {
+      machineStep.stop("\xB7 Could not list machine types \u2014 using provider default");
+    }
+    if (machines.length > 1) {
+      const picked = await _t({
+        message: "Pick a machine size (starts at 8 GB RAM):",
+        initialValue: machines[0].id,
+        options: machines.map((m) => ({
+          value: m.id,
+          label: m.label,
+          hint: `${m.memoryGb} GB RAM`
+        }))
+      });
+      if (q(picked)) {
+        pt("Cancelled.");
+        process.exit(0);
+      }
+      machineTypeId = picked;
+    } else if (machines.length === 1) {
+      machineTypeId = machines[0].id;
+    }
+  }
   const createStep = fe();
   createStep.start(`Creating workspace for ${project.fullName}\u2026`);
   let workspace;
   try {
-    workspace = await provider.createWorkspace(project.id);
+    workspace = await provider.createWorkspace(project.id, machineTypeId);
     createStep.stop(`\u2713 Workspace ready: ${workspace.displayName ?? workspace.id}`);
   } catch (err) {
     createStep.stop(`\u2717 Workspace creation failed`);
@@ -5299,21 +5488,36 @@ async function deploy() {
   }
   claudeStep.stop("\u2713 Claude CLI installed");
   const localClaudeDir = path8.join(os6.homedir(), ".claude");
-  if (fs8.existsSync(localClaudeDir) && fs8.statSync(localClaudeDir).isDirectory()) {
+  const haveLocalClaude = fs8.existsSync(localClaudeDir) && fs8.statSync(localClaudeDir).isDirectory();
+  if (haveLocalClaude) {
     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");
+      copyStep.stop("\u26A0 Could not copy Claude config \u2014 falling back to remote login");
       void err;
+      await runRemoteClaudeLogin(provider, workspace.id);
     }
   } else {
     wt(
-      "No local ~/.claude config found. You can authenticate Claude in the workspace shell when needed.",
-      "Heads up"
+      [
+        "No local ~/.claude config found.",
+        "We can run `claude login` inside the workspace right now \u2014 the URL",
+        "will print here, you open it in your browser, paste the code back,",
+        "and the workspace gets authenticated. (Skip if you'd rather do it",
+        "manually later from inside the codespace.)"
+      ].join("\n"),
+      "Claude credentials"
     );
+    const proceed = await ot2({
+      message: "Run `claude login` on the workspace now?",
+      initialValue: true
+    });
+    if (!q(proceed) && proceed) {
+      await runRemoteClaudeLogin(provider, workspace.id);
+    }
   }
   const cliStep = fe();
   cliStep.start("Installing codeam-cli on workspace\u2026");
@@ -5326,8 +5530,8 @@ async function deploy() {
   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)}` : "",
+      `Workspace: ${import_picocolors8.default.cyan(workspace.displayName ?? workspace.id)}`,
+      workspace.webUrl ? `Web:       ${import_picocolors8.default.cyan(workspace.webUrl)}` : "",
       "",
       "Starting `codeam pair` on the workspace.",
       "Scan the QR code below with the CodeAgent Mobile app to finish pairing."
@@ -5336,9 +5540,28 @@ async function deploy() {
   );
   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.`));
+    gt(import_picocolors8.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.`));
+    gt(import_picocolors8.default.yellow(`Pairing exited with code ${code}. Run "codeam pair" inside the codespace if needed.`));
+  }
+}
+async function runRemoteClaudeLogin(provider, workspaceId) {
+  wt(
+    [
+      "A login URL will print below. Open it in your local browser, sign in,",
+      "and paste any code Claude asks for back into this terminal."
+    ].join("\n"),
+    "Authenticating Claude on workspace"
+  );
+  const result = await provider.streamCommand(
+    workspaceId,
+    'bash -lc "claude login || claude /login || true"'
+  );
+  if (result.code !== 0) {
+    wt(
+      "claude login exited non-zero. You can re-run it manually inside the codespace later.",
+      "Heads up"
+    );
   }
 }
 async function pickProvider() {
@@ -5348,7 +5571,7 @@ async function pickProvider() {
     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)")}`,
+      label: prov.available ? prov.displayName : `${prov.displayName} ${import_picocolors8.default.dim("(coming soon)")}`,
       hint: prov.tagline
     }))
   });

package/package.json

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