codeam-cli 2.4.5 → 2.4.7

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.5] — 2026-05-03
+
+### Fixed
+
+- **cli:** Clearer guidance when gh refresh hits multi-account browser (v2.4.5)
+
+## [2.4.4] — 2026-05-03
+
+### Fixed
+
+- **cli:** Unblock interactive gh prompts inside codeam deploy (v2.4.4)
+
 ## [2.4.3] — 2026-05-03
 
 ### Fixed

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.5",
+  version: "2.4.7",
   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: {
@@ -5077,15 +5077,18 @@ async function logout() {
 }
 
 // src/commands/deploy.ts
+var import_child_process6 = require("child_process");
 var fs8 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path8 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
+var import_util3 = require("util");
 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 path8 = __toESM(require("path"));
 var execFileP2 = (0, import_util2.promisify)(import_child_process5.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
@@ -5464,21 +5467,130 @@ var GitHubCodespacesProvider = class {
     return new Promise((resolve2, reject) => {
       const proc = (0, import_child_process5.spawn)(
         "gh",
-        ["codespace", "ssh", "-c", workspaceId, "-t", "--", command2],
+        ["codespace", "ssh", "-c", workspaceId, "--", "-tt", 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 }
-    );
+  async uploadDirectory(workspaceId, localDir, remoteDir, options = {}) {
+    const tarArgs = ["-czf", "-", "-C", localDir];
+    for (const pattern of options.exclude ?? []) {
+      tarArgs.push(`--exclude=${pattern}`);
+    }
+    tarArgs.push(".");
+    const sshArgs = [
+      "codespace",
+      "ssh",
+      "-c",
+      workspaceId,
+      "--",
+      `mkdir -p ${shellQuote(remoteDir)} && tar -xzf - -C ${shellQuote(remoteDir)}`
+    ];
+    await new Promise((resolve2, reject) => {
+      const tar = (0, import_child_process5.spawn)("tar", tarArgs, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const ssh = (0, import_child_process5.spawn)("gh", sshArgs, {
+        stdio: [tar.stdout, "pipe", "pipe"]
+      });
+      let tarErr = "";
+      let sshErr = "";
+      tar.stderr?.on("data", (d3) => {
+        tarErr += d3.toString();
+      });
+      ssh.stderr?.on("data", (d3) => {
+        sshErr += d3.toString();
+      });
+      tar.on("error", reject);
+      ssh.on("error", reject);
+      ssh.on("exit", (code) => {
+        if (code === 0) {
+          resolve2();
+        } else {
+          const reason = (sshErr || tarErr || `exit ${code}`).trim().slice(0, 500);
+          reject(new Error(`Remote tar failed: ${reason}`));
+        }
+      });
+    });
+  }
+  async uploadFile(workspaceId, remotePath, contents, options = {}) {
+    const remoteDir = path8.posix.dirname(remotePath);
+    const parts = [
+      `mkdir -p ${shellQuote(remoteDir)}`,
+      `cat > ${shellQuote(remotePath)}`
+    ];
+    if (options.mode != null) {
+      parts.push(`chmod ${options.mode.toString(8)} ${shellQuote(remotePath)}`);
+    }
+    const cmd = parts.join(" && ");
+    await new Promise((resolve2, reject) => {
+      const proc = (0, import_child_process5.spawn)(
+        "gh",
+        ["codespace", "ssh", "-c", workspaceId, "--", cmd],
+        { stdio: ["pipe", "pipe", "pipe"] }
+      );
+      let stderr = "";
+      proc.stderr?.on("data", (d3) => {
+        stderr += d3.toString();
+      });
+      proc.on("error", reject);
+      proc.on("exit", (code) => {
+        if (code === 0) resolve2();
+        else reject(new Error(`Remote write failed: ${(stderr || `exit ${code}`).trim().slice(0, 500)}`));
+      });
+      proc.stdin?.write(contents);
+      proc.stdin?.end();
+    });
+  }
+  async listExistingWorkspaces(projectId) {
+    try {
+      const { stdout } = await execFileP2(
+        "gh",
+        [
+          "codespace",
+          "list",
+          "--repo",
+          projectId,
+          "--json",
+          "name,displayName,state,lastUsedAt"
+        ],
+        { maxBuffer: MAX_BUFFER }
+      );
+      const list = JSON.parse(stdout);
+      return list.map((c2) => ({
+        id: c2.name,
+        displayName: c2.displayName || c2.name,
+        webUrl: `https://github.com/codespaces/${c2.name}`,
+        state: c2.state,
+        lastUsedAt: c2.lastUsedAt
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async startWorkspace(workspaceId) {
+    try {
+      await execFileP2(
+        "gh",
+        ["api", "-X", "POST", `/user/codespaces/${workspaceId}/start`],
+        { maxBuffer: MAX_BUFFER, timeout: 6e4 }
+      );
+    } catch (err) {
+      void err;
+    }
+    await this.waitUntilAvailable(workspaceId);
+    return {
+      id: workspaceId,
+      displayName: workspaceId,
+      webUrl: `https://github.com/codespaces/${workspaceId}`
+    };
   }
 };
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
 
 // src/services/providers/index.ts
 var PROVIDERS = [
@@ -5490,6 +5602,7 @@ var PROVIDERS = [
 ];
 
 // src/commands/deploy.ts
+var execFileP3 = (0, import_util3.promisify)(import_child_process6.execFile);
 async function deploy() {
   console.log();
   mt(import_picocolors8.default.bgMagenta(import_picocolors8.default.white(" codeam deploy ")));
@@ -5535,8 +5648,53 @@ async function deploy() {
     process.exit(0);
   }
   const project = projects.find((proj) => proj.id === projectId);
+  let workspace = null;
+  if (provider.listExistingWorkspaces && provider.startWorkspace) {
+    const existingStep = fe();
+    existingStep.start("Checking for existing workspaces\u2026");
+    let existing = [];
+    try {
+      existing = await provider.listExistingWorkspaces(project.id);
+      existingStep.stop(
+        existing.length === 0 ? "\xB7 No existing workspaces \u2014 will create a fresh one" : `\u2713 ${existing.length} existing workspace${existing.length === 1 ? "" : "s"} found`
+      );
+    } catch {
+      existingStep.stop("\xB7 Could not list existing workspaces \u2014 will create a fresh one");
+    }
+    if (existing.length > 0) {
+      const choice = await _t({
+        message: "Reuse an existing workspace or create a new one?",
+        options: [
+          ...existing.map((w3) => ({
+            value: w3.id,
+            label: w3.displayName ?? w3.id,
+            hint: [w3.state, formatLastUsed(w3.lastUsedAt)].filter(Boolean).join(" \xB7 ")
+          })),
+          { value: "__new__", label: import_picocolors8.default.green("+ Create a new workspace"), hint: "fresh codespace" }
+        ]
+      });
+      if (q(choice)) {
+        pt("Cancelled.");
+        process.exit(0);
+      }
+      if (choice !== "__new__") {
+        const reuseStep = fe();
+        const picked = existing.find((w3) => w3.id === choice);
+        const needsStart = picked.state && picked.state !== "Available";
+        reuseStep.start(needsStart ? `Starting ${picked.displayName ?? picked.id}\u2026` : `Connecting to ${picked.displayName ?? picked.id}\u2026`);
+        try {
+          workspace = await provider.startWorkspace(picked.id);
+          reuseStep.stop(`\u2713 Reusing ${workspace.displayName ?? workspace.id}`);
+        } catch (err) {
+          reuseStep.stop("\u2717 Could not start the existing workspace");
+          pt(err instanceof Error ? err.message : String(err));
+          process.exit(1);
+        }
+      }
+    }
+  }
   let machineTypeId;
-  if (provider.listMachineTypes) {
+  if (!workspace && provider.listMachineTypes) {
     const machineStep = fe();
     machineStep.start("Loading machine types\u2026");
     let machines = [];
@@ -5567,16 +5725,17 @@ async function deploy() {
       machineTypeId = machines[0].id;
     }
   }
-  const createStep = fe();
-  createStep.start(`Creating workspace for ${project.fullName}\u2026`);
-  let workspace;
-  try {
-    workspace = await provider.createWorkspace(project.id, machineTypeId);
-    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);
+  if (!workspace) {
+    const createStep = fe();
+    createStep.start(`Creating workspace for ${project.fullName}\u2026`);
+    try {
+      workspace = await provider.createWorkspace(project.id, machineTypeId);
+      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");
@@ -5590,19 +5749,74 @@ async function deploy() {
     process.exit(1);
   }
   claudeStep.stop("\u2713 Claude CLI installed");
-  const localClaudeDir = path8.join(os6.homedir(), ".claude");
+  const localClaudeDir = path9.join(os6.homedir(), ".claude");
   const haveLocalClaude = fs8.existsSync(localClaudeDir) && fs8.statSync(localClaudeDir).isDirectory();
   if (haveLocalClaude) {
     const copyStep = fe();
     copyStep.start("Copying local Claude config to workspace\u2026");
+    let configUploaded = false;
     try {
-      await provider.uploadDirectory(workspace.id, localClaudeDir, "/home/codespace/.claude");
-      copyStep.stop("\u2713 Claude config copied \u2014 no re-auth needed");
+      await provider.uploadDirectory(
+        workspace.id,
+        localClaudeDir,
+        "/home/codespace/.claude",
+        {
+          exclude: [
+            "./projects",
+            // per-project conversation history (often 700MB+)
+            "./file-history",
+            // per-project file diffs
+            "./downloads",
+            // downloaded artifacts
+            "./image-cache",
+            // cached images
+            "./paste-cache",
+            // clipboard/paste cache
+            "./backups",
+            // local backups
+            "./shell-snapshots",
+            // shell history snapshots
+            "./telemetry",
+            // analytics dumps
+            "./statsig",
+            // feature-flag cache
+            "./cache",
+            // generic cache dir
+            "./history.jsonl",
+            // global REPL history
+            "./ide",
+            // local IDE bridge state
+            "./todos",
+            // local todo state
+            "./tasks"
+            // local task state
+          ]
+        }
+      );
+      configUploaded = true;
+      copyStep.stop("\u2713 Claude config uploaded");
     } catch (err) {
-      copyStep.stop("\u26A0 Could not copy Claude config \u2014 falling back to remote login");
+      copyStep.stop("\u26A0 Could not upload Claude config \u2014 falling back to remote login");
       void err;
       await runRemoteClaudeLogin(provider, workspace.id);
     }
+    if (configUploaded) {
+      const credStep = fe();
+      credStep.start("Bridging Claude credentials\u2026");
+      const bridged = await bridgeClaudeCredentials(provider, workspace.id, localClaudeDir);
+      switch (bridged) {
+        case "flat-file":
+          credStep.stop("\u2713 Credentials in tar \u2014 no re-auth needed");
+          break;
+        case "macos-keychain":
+          credStep.stop("\u2713 Credentials extracted from macOS Keychain \u2014 no re-auth needed");
+          break;
+        case "none":
+          credStep.stop("\u26A0 No transferable Claude credentials found \u2014 falling back to remote login");
+          await runRemoteClaudeLogin(provider, workspace.id);
+          break;
+      }
+    }
   } else {
     wt(
       [
@@ -5667,6 +5881,52 @@ async function runRemoteClaudeLogin(provider, workspaceId) {
     );
   }
 }
+async function bridgeClaudeCredentials(provider, workspaceId, localClaudeDir) {
+  const fileBased = path9.join(localClaudeDir, ".credentials.json");
+  if (fs8.existsSync(fileBased)) return "flat-file";
+  if (process.platform === "darwin") {
+    try {
+      const { stdout } = await execFileP3(
+        "security",
+        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+        { maxBuffer: 1024 * 1024 }
+      );
+      const json = stdout.trim();
+      if (json.length === 0) return "none";
+      await provider.uploadFile(
+        workspaceId,
+        "/home/codespace/.claude/.credentials.json",
+        json,
+        { mode: 384 }
+      );
+      return "macos-keychain";
+    } catch {
+      return "none";
+    }
+  }
+  return "none";
+}
+function formatLastUsed(iso) {
+  if (!iso) return "";
+  const t2 = Date.parse(iso);
+  if (Number.isNaN(t2)) return "";
+  const diffMs = Date.now() - t2;
+  if (diffMs < 0) return "in the future";
+  const minute = 6e4;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  if (diffMs < minute) return "just now";
+  if (diffMs < hour) {
+    const m = Math.round(diffMs / minute);
+    return `${m} min${m === 1 ? "" : "s"} ago`;
+  }
+  if (diffMs < day) {
+    const h = Math.round(diffMs / hour);
+    return `${h} hour${h === 1 ? "" : "s"} ago`;
+  }
+  const d3 = Math.round(diffMs / day);
+  return `${d3} day${d3 === 1 ? "" : "s"} ago`;
+}
 async function pickProvider() {
   const ready = PROVIDERS.filter((prov) => prov.available);
   if (ready.length === 1) return ready[0];

package/package.json

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