codeam-cli 2.3.0 → 2.4.0

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.3.0",
+  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: {
@@ -5076,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() {
@@ -5088,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.3.0",
+  "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": {