codeam-cli 2.4.1 → 2.4.3

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.4.1] — 2026-05-03
+
+### Added
+
+- **cli:** Interactive `claude login` fallback when no local config (v2.4.1)
+
+## [2.4.0] — 2026-05-03
+
+### Added
+
+- **cli:** `codeam deploy` — provision a paired cloud workspace in one command (v2.4.0)
+
 ## [2.2.2] — 2026-05-02
 
 ### Fixed

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.1",
+  version: "2.4.3",
   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,32 +5097,175 @@ 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")
+        );
+      }
     }
+    let isAuthed = false;
     try {
       await execFileP2("gh", ["auth", "status"], { maxBuffer: MAX_BUFFER });
-      return;
+      isAuthed = true;
     } catch {
     }
-    await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process5.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
-        stdio: "inherit"
+    if (!isAuthed) {
+      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);
       });
-      proc.on("exit", (code) => {
-        if (code === 0) resolve2();
-        else reject(new Error("gh auth login failed."));
+      return;
+    }
+    const hasScope = await this.hasCodespaceScope();
+    if (!hasScope) {
+      wt(
+        [
+          "Your existing GitHub login is missing the `codespace` scope.",
+          "I'll run `gh auth refresh` to add it \u2014 your browser will open",
+          "for a one-tap approval."
+        ].join("\n"),
+        "One more permission needed"
+      );
+      await new Promise((resolve2, reject) => {
+        const proc = (0, import_child_process5.spawn)(
+          "gh",
+          ["auth", "refresh", "-h", "github.com", "-s", "codespace"],
+          { stdio: "inherit" }
+        );
+        proc.on("exit", (code) => {
+          if (code === 0) resolve2();
+          else reject(new Error("gh auth refresh failed \u2014 re-run `gh auth refresh -h github.com -s codespace` manually."));
+        });
+        proc.on("error", reject);
       });
-      proc.on("error", reject);
+    }
+  }
+  /**
+   * Check whether the current `gh` token includes the `codespace`
+   * OAuth scope. We hit `/user` with `-i` so GitHub echoes the granted
+   * scopes back in the `X-OAuth-Scopes` response header — the most
+   * authoritative source (more reliable than scraping `gh auth status`,
+   * whose format has shifted across `gh` versions).
+   */
+  async hasCodespaceScope() {
+    try {
+      const { stdout } = await execFileP2(
+        "gh",
+        ["api", "-i", "user"],
+        { maxBuffer: MAX_BUFFER }
+      );
+      const m = stdout.match(/^x-oauth-scopes:\s*(.+)$/im);
+      if (!m) return false;
+      const scopes = m[1].split(",").map((s) => s.trim().toLowerCase());
+      return scopes.includes("codespace");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 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(
@@ -5146,10 +5290,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 +5348,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 +5437,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 +5481,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`);
@@ -5341,8 +5579,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."
@@ -5351,9 +5589,9 @@ 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) {
@@ -5382,7 +5620,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.1",
+  "version": "2.4.3",
   "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": {