codeam-cli 2.15.8 → 2.16.0

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.15.8] — 2026-05-21
+
+### Fixed
+
+- **cli:** Pairing-box alignment + countdown actually ticks (#39)
+
+## [2.15.7] — 2026-05-21
+
+### Fixed
+
+- **clients:** Point default API URL at api.codeagent-mobile.com + centralize via shared constant (#38)
+
 ## [2.15.6] — 2026-05-20
 
 ### Added

package/dist/index.js

@@ -389,7 +389,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.15.8",
+  version: "2.16.0",
   description: "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device \u2014 async. The terminal companion for CodeAgent Mobile.",
   type: "commonjs",
   main: "dist/index.js",
@@ -646,8 +646,84 @@ function pollStatus(pluginId, onPaired, onTimeout) {
 }
 var _transport = {
   postJson: _postJson,
-  getJson: _getJson
+  getJson: _getJson,
+  postJsonAuthed: _postJsonAuthed
 };
+async function postLinkCredential(input) {
+  const body = {
+    sessionId: input.sessionId,
+    pluginId: input.pluginId,
+    method: input.method,
+    credential: input.credential
+  };
+  if (input.modelPreference) {
+    body.modelPreference = input.modelPreference;
+  }
+  try {
+    await _transport.postJsonAuthed(
+      `${API_BASE}/api/plugin/agents/${input.agentId}/link`,
+      body,
+      input.pluginAuthToken
+    );
+    return { ok: true };
+  } catch (err) {
+    const e = err;
+    return {
+      ok: false,
+      status: typeof e.statusCode === "number" ? e.statusCode : 0,
+      message: e.message || "unknown"
+    };
+  }
+}
+async function _postJsonAuthed(url, body, pluginAuthToken) {
+  return new Promise((resolve2, reject) => {
+    const data = JSON.stringify(body);
+    const u2 = new URL(url);
+    const transport = u2.protocol === "https:" ? https : http;
+    const req = transport.request(
+      {
+        hostname: u2.hostname,
+        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
+        path: u2.pathname + u2.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+          "X-Plugin-Auth-Token": pluginAuthToken,
+          ...vercelBypassHeader()
+        },
+        timeout: 15e3
+      },
+      (res) => {
+        res.on("error", reject);
+        let responseBody = "";
+        res.on("data", (chunk) => {
+          responseBody += chunk.toString();
+        });
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 400) {
+            const err = new Error(`HTTP ${res.statusCode}: ${responseBody.slice(0, 200)}`);
+            err.statusCode = res.statusCode;
+            reject(err);
+            return;
+          }
+          try {
+            resolve2(JSON.parse(responseBody));
+          } catch {
+            resolve2(null);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.write(data);
+    req.end();
+  });
+}
 async function _postJson(url, body) {
   return new Promise((resolve2, reject) => {
     const data = JSON.stringify(body);
@@ -8521,12 +8597,12 @@ function readTokenFromArgs(args2) {
   }
   const fileFlag = args2.find((a) => a.startsWith("--token-file="));
   if (fileFlag) {
-    const path25 = fileFlag.slice("--token-file=".length);
+    const path27 = fileFlag.slice("--token-file=".length);
     try {
-      const content = fs15.readFileSync(path25, "utf8").trim();
-      if (content.length === 0) fail(`--token-file ${path25} is empty`);
+      const content = fs15.readFileSync(path27, "utf8").trim();
+      if (content.length === 0) fail(`--token-file ${path27} is empty`);
       try {
-        fs15.unlinkSync(path25);
+        fs15.unlinkSync(path27);
       } catch {
       }
       return content;
@@ -10630,74 +10706,336 @@ async function probeCodeamPair(provider, workspace) {
 }
 async function stopWorkspaceFromLocal(target) {
   if (target.provider.id === "github-codespaces") {
-    const { execFile: execFile7 } = await import("child_process");
-    const { promisify: promisify7 } = await import("util");
-    const execFileP7 = promisify7(execFile7);
-    await execFileP7("gh", ["codespace", "stop", "-c", target.id], { maxBuffer: 8 * 1024 * 1024 });
+    const { execFile: execFile8 } = await import("child_process");
+    const { promisify: promisify8 } = await import("util");
+    const execFileP8 = promisify8(execFile8);
+    await execFileP8("gh", ["codespace", "stop", "-c", target.id], { maxBuffer: 8 * 1024 * 1024 });
     return;
   }
 }
 
-// src/commands/version.ts
+// src/commands/link.ts
+var import_node_child_process3 = require("child_process");
+var import_node_crypto = require("crypto");
 var import_picocolors11 = __toESM(require("picocolors"));
+
+// src/agents/claude/local-token.ts
+var import_node_child_process2 = require("child_process");
+var fs16 = __toESM(require("fs"));
+var os15 = __toESM(require("os"));
+var path24 = __toESM(require("path"));
+var import_node_util3 = require("util");
+var execFileP7 = (0, import_node_util3.promisify)(import_node_child_process2.execFile);
+function claudeCredentialsPath() {
+  return path24.join(os15.homedir(), ".claude", ".credentials.json");
+}
+async function extractLocalClaudeToken() {
+  const flat = claudeCredentialsPath();
+  if (fs16.existsSync(flat)) {
+    const credential = fs16.readFileSync(flat, "utf8").trim();
+    if (credential.length > 0) {
+      return { method: "oauth", credential, source: "flat-file" };
+    }
+  }
+  if (process.platform === "darwin") {
+    try {
+      const { stdout } = await execFileP7(
+        "security",
+        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+        { maxBuffer: 1024 * 1024 }
+      );
+      const credential = stdout.trim();
+      if (credential.length > 0) {
+        return { method: "oauth", credential, source: "macos-keychain" };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function claudeCredentialsMtime() {
+  const flat = claudeCredentialsPath();
+  try {
+    return fs16.statSync(flat).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+// src/agents/codex/local-token.ts
+var fs17 = __toESM(require("fs"));
+var os16 = __toESM(require("os"));
+var path25 = __toESM(require("path"));
+function codexCredentialsPath() {
+  return path25.join(os16.homedir(), ".codex", "auth.json");
+}
+async function extractLocalCodexToken() {
+  const file = codexCredentialsPath();
+  if (!fs17.existsSync(file)) return null;
+  const credential = fs17.readFileSync(file, "utf8").trim();
+  if (credential.length === 0) return null;
+  return { method: "oauth", credential, source: "flat-file" };
+}
+function codexCredentialsMtime() {
+  const file = codexCredentialsPath();
+  try {
+    return fs17.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/link.ts
+var AGENT_META = {
+  claude: {
+    internalId: "claude",
+    publicId: "claude_code",
+    binary: "claude",
+    loginArgs: ["login"],
+    displayName: "Claude Code",
+    vendor: "Anthropic",
+    credentialsHint: "~/.claude/.credentials.json (or macOS Keychain)",
+    extract: extractLocalClaudeToken,
+    mtime: claudeCredentialsMtime
+  },
+  codex: {
+    internalId: "codex",
+    publicId: "codex",
+    binary: "codex",
+    loginArgs: ["login"],
+    displayName: "Codex",
+    vendor: "OpenAI",
+    credentialsHint: "~/.codex/auth.json",
+    extract: extractLocalCodexToken,
+    mtime: codexCredentialsMtime
+  }
+};
+function parseLinkArgs(args2) {
+  const positional = args2.find((a) => !a.startsWith("--"));
+  if (!positional) {
+    throw new Error(
+      `Usage: codeam link <agent>
+         agent: ${Object.keys(AGENT_META).join(" | ")}`
+    );
+  }
+  const normalised = positional === "claude_code" ? "claude" : positional;
+  if (normalised !== "claude" && normalised !== "codex") {
+    throw new Error(
+      `Unknown agent "${positional}". Valid: ${Object.keys(AGENT_META).join(", ")}`
+    );
+  }
+  const reuseExisting = args2.includes("--reuse-existing");
+  return { agent: normalised, reuseExisting };
+}
+async function link(args2 = []) {
+  const { agent, reuseExisting } = parseLinkArgs(args2);
+  const meta = AGENT_META[agent];
+  showIntro();
+  console.log(
+    import_picocolors11.default.bold(`  Link ${meta.displayName}`) + import_picocolors11.default.dim(`  \xB7  ${meta.vendor}`)
+  );
+  console.log("");
+  const pluginId = (0, import_node_crypto.randomUUID)();
+  const spin = dist_exports.spinner();
+  spin.start("Requesting pairing code...");
+  const pairing = await requestCode(pluginId);
+  if (!pairing) {
+    spin.stop("Failed");
+    showError("Could not reach the server. Check your connection and try again.");
+    process.exit(1);
+  }
+  spin.stop("Got pairing code");
+  showPairingCode(pairing.code);
+  console.log(import_picocolors11.default.dim("  Scan the QR or enter the code in CodeAgent Mobile."));
+  console.log("");
+  const waitSpin = dist_exports.spinner();
+  const waitMsg = () => `Waiting for mobile pair... \xB7 expires in ${formatRemaining(pairing.expiresAt)}`;
+  waitSpin.start(waitMsg());
+  const countdown = setInterval(() => waitSpin.message(waitMsg()), 1e3);
+  countdown.unref?.();
+  const paired = await new Promise((resolve2, reject) => {
+    let stopPoll = null;
+    const sigint = () => {
+      clearInterval(countdown);
+      stopPoll?.();
+      reject(new Error("cancelled"));
+    };
+    stopPoll = pollStatus(
+      pluginId,
+      (info) => {
+        process.removeListener("SIGINT", sigint);
+        clearInterval(countdown);
+        waitSpin.stop("Paired");
+        resolve2(info);
+      },
+      () => {
+        clearInterval(countdown);
+        waitSpin.stop("Timed out");
+        reject(new Error("Pairing timed out after 5 minutes. Run codeam link again."));
+      }
+    );
+    process.once("SIGINT", sigint);
+  });
+  if (!paired.pluginAuthToken) {
+    showError(
+      "Backend did not return a pluginAuthToken \u2014 upgrade api-v2 (deploy includes the link endpoint)."
+    );
+    process.exit(1);
+  }
+  addSession({
+    id: paired.sessionId,
+    pluginId,
+    userName: paired.userName,
+    userEmail: paired.userEmail,
+    plan: paired.plan,
+    pairedAt: Date.now(),
+    pluginAuthToken: paired.pluginAuthToken,
+    agent: meta.internalId
+  });
+  saveCliConfig({ ...loadCliConfig(), preferredAgent: meta.internalId });
+  let token = await meta.extract();
+  if (token && reuseExisting) {
+    showInfo(`Reusing existing ${meta.displayName} token at ${import_picocolors11.default.bold(meta.credentialsHint)}.`);
+  } else {
+    const beforeMtime = meta.mtime();
+    showInfo(`Launching ${import_picocolors11.default.bold(`${meta.binary} ${meta.loginArgs.join(" ")}`)} \u2014 complete the sign-in in your browser, then return here.`);
+    console.log("");
+    const code = await runAgentLogin(meta);
+    console.log("");
+    if (code !== 0) {
+      showError(
+        `${meta.binary} ${meta.loginArgs.join(" ")} exited with code ${code}. Re-run when ready.`
+      );
+      process.exit(1);
+    }
+    const refreshed = await meta.extract();
+    const afterMtime = meta.mtime();
+    if (!refreshed) {
+      showError(
+        `${meta.displayName} login finished but no credential was found at ${meta.credentialsHint}. Re-run when ready.`
+      );
+      process.exit(1);
+    }
+    if (token && refreshed.credential === token.credential && beforeMtime !== null && afterMtime !== null && afterMtime <= beforeMtime) {
+      showError(
+        `${meta.displayName} login didn't produce a fresh token. Re-run when ready, or pass --reuse-existing to keep the current one.`
+      );
+      process.exit(1);
+    }
+    token = refreshed;
+  }
+  const uploadSpin = dist_exports.spinner();
+  uploadSpin.start("Sealing credential in your vault...");
+  const result = await postLinkCredential({
+    agentId: meta.publicId,
+    sessionId: paired.sessionId,
+    pluginId,
+    pluginAuthToken: paired.pluginAuthToken,
+    method: token.method,
+    credential: token.credential
+  });
+  if (!result.ok) {
+    uploadSpin.stop("Failed");
+    if (result.status === 401) {
+      showError(
+        "Pair token rejected by the backend (401). Re-run `codeam link` to start fresh."
+      );
+    } else if (result.status === 404) {
+      showError(
+        `${meta.displayName} link endpoint not available on this backend (404). The api-v2 deployment may not yet include the /api/plugin/agents/:agentId/link route.`
+      );
+    } else {
+      showError(`Upload failed: ${result.message}`);
+    }
+    process.exit(1);
+  }
+  uploadSpin.stop("Linked");
+  console.log("");
+  showSuccess(`${meta.displayName} is now linked to ${paired.userEmail || paired.userName}.`);
+  showInfo(
+    `Your codespaces and @codeagent mentions can now use ${meta.displayName} without you signing in again.`
+  );
+  console.log("");
+}
+function runAgentLogin(meta) {
+  return new Promise((resolve2) => {
+    const child = (0, import_node_child_process3.spawn)(meta.binary, meta.loginArgs, { stdio: "inherit" });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        showError(
+          `${meta.binary} binary not found on PATH. Install ${meta.displayName} first, then re-run \`codeam link ${meta.internalId}\`.`
+        );
+        resolve2(127);
+        return;
+      }
+      showError(`Failed to launch ${meta.binary}: ${err.message}`);
+      resolve2(1);
+    });
+    child.on("exit", (code) => resolve2(code ?? 1));
+  });
+}
+
+// src/commands/version.ts
+var import_picocolors12 = __toESM(require("picocolors"));
 function version() {
-  const v = true ? "2.15.8" : "unknown";
-  console.log(`${import_picocolors11.default.bold("codeam-cli")} ${import_picocolors11.default.cyan(v)}`);
+  const v = true ? "2.16.0" : "unknown";
+  console.log(`${import_picocolors12.default.bold("codeam-cli")} ${import_picocolors12.default.cyan(v)}`);
 }
 
 // src/commands/help.ts
-var import_picocolors12 = __toESM(require("picocolors"));
+var import_picocolors13 = __toESM(require("picocolors"));
 function help() {
   const lines = [
     "",
-    `  ${import_picocolors12.default.bold(import_picocolors12.default.magenta("codeam-cli"))}  ${import_picocolors12.default.dim("\u2014 remote-control AI coding agents from your phone")}`,
+    `  ${import_picocolors13.default.bold(import_picocolors13.default.magenta("codeam-cli"))}  ${import_picocolors13.default.dim("\u2014 remote-control AI coding agents from your phone")}`,
     "",
-    `  ${import_picocolors12.default.bold("Usage")}`,
-    `     ${import_picocolors12.default.cyan("codeam")} ${import_picocolors12.default.dim("[command]")}`,
+    `  ${import_picocolors13.default.bold("Usage")}`,
+    `     ${import_picocolors13.default.cyan("codeam")} ${import_picocolors13.default.dim("[command]")}`,
     "",
-    `  ${import_picocolors12.default.bold("Commands")}`,
-    `     ${import_picocolors12.default.white("codeam")}                       ${import_picocolors12.default.dim("start the active agent with mobile control")}`,
-    `     ${import_picocolors12.default.white("codeam <agent>")}               ${import_picocolors12.default.dim("start a specific agent \u2014 e.g. claude, codex")}`,
-    `     ${import_picocolors12.default.white("codeam pair")}                  ${import_picocolors12.default.dim("pair a new mobile device (interactive)")}`,
-    `     ${import_picocolors12.default.white("codeam pair --agent <id>")}     ${import_picocolors12.default.dim("pair non-interactively for a specific agent")}`,
-    `     ${import_picocolors12.default.white("codeam sessions")}              ${import_picocolors12.default.dim("list paired devices")}`,
-    `     ${import_picocolors12.default.white("codeam sessions switch")}       ${import_picocolors12.default.dim("switch the active paired session")}`,
-    `     ${import_picocolors12.default.white("codeam sessions delete <id>")}  ${import_picocolors12.default.dim("remove a specific paired session")}`,
-    `     ${import_picocolors12.default.white("codeam status")}                ${import_picocolors12.default.dim("show connection info")}`,
-    `     ${import_picocolors12.default.white("codeam logout")}                ${import_picocolors12.default.dim("remove all paired sessions")}`,
-    `     ${import_picocolors12.default.white("codeam deploy")}                ${import_picocolors12.default.dim("provision a cloud workspace (Codespaces) and pair it")}`,
-    `     ${import_picocolors12.default.white("codeam deploy ls | list")}      ${import_picocolors12.default.dim("list deployed cloud workspaces")}`,
-    `     ${import_picocolors12.default.white("codeam deploy stop | remove")}  ${import_picocolors12.default.dim("stop a deployed workspace session")}`,
+    `  ${import_picocolors13.default.bold("Commands")}`,
+    `     ${import_picocolors13.default.white("codeam")}                       ${import_picocolors13.default.dim("start the active agent with mobile control")}`,
+    `     ${import_picocolors13.default.white("codeam <agent>")}               ${import_picocolors13.default.dim("start a specific agent \u2014 e.g. claude, codex")}`,
+    `     ${import_picocolors13.default.white("codeam pair")}                  ${import_picocolors13.default.dim("pair a new mobile device (interactive)")}`,
+    `     ${import_picocolors13.default.white("codeam pair --agent <id>")}     ${import_picocolors13.default.dim("pair non-interactively for a specific agent")}`,
+    `     ${import_picocolors13.default.white("codeam sessions")}              ${import_picocolors13.default.dim("list paired devices")}`,
+    `     ${import_picocolors13.default.white("codeam sessions switch")}       ${import_picocolors13.default.dim("switch the active paired session")}`,
+    `     ${import_picocolors13.default.white("codeam sessions delete <id>")}  ${import_picocolors13.default.dim("remove a specific paired session")}`,
+    `     ${import_picocolors13.default.white("codeam status")}                ${import_picocolors13.default.dim("show connection info")}`,
+    `     ${import_picocolors13.default.white("codeam logout")}                ${import_picocolors13.default.dim("remove all paired sessions")}`,
+    `     ${import_picocolors13.default.white("codeam link <agent>")}          ${import_picocolors13.default.dim("link an agent (claude, codex) to your CodeAgent account")}`,
+    `     ${import_picocolors13.default.white("codeam deploy")}                ${import_picocolors13.default.dim("provision a cloud workspace (Codespaces) and pair it")}`,
+    `     ${import_picocolors13.default.white("codeam deploy ls | list")}      ${import_picocolors13.default.dim("list deployed cloud workspaces")}`,
+    `     ${import_picocolors13.default.white("codeam deploy stop | remove")}  ${import_picocolors13.default.dim("stop a deployed workspace session")}`,
     "",
-    `  ${import_picocolors12.default.bold("Flags")}`,
-    `     ${import_picocolors12.default.white("-v, --version")}                ${import_picocolors12.default.dim("print the CLI version")}`,
-    `     ${import_picocolors12.default.white("-h, --help")}                   ${import_picocolors12.default.dim("show this help")}`,
+    `  ${import_picocolors13.default.bold("Flags")}`,
+    `     ${import_picocolors13.default.white("-v, --version")}                ${import_picocolors13.default.dim("print the CLI version")}`,
+    `     ${import_picocolors13.default.white("-h, --help")}                   ${import_picocolors13.default.dim("show this help")}`,
     "",
-    `  ${import_picocolors12.default.bold("Links")}`,
-    `     ${import_picocolors12.default.dim("Docs:")}     ${import_picocolors12.default.green("https://www.codeagent-mobile.com")}`,
-    `     ${import_picocolors12.default.dim("Issues:")}   ${import_picocolors12.default.green("https://github.com/edgar-durand/codeagent-mobile-clients/issues")}`,
+    `  ${import_picocolors13.default.bold("Links")}`,
+    `     ${import_picocolors13.default.dim("Docs:")}     ${import_picocolors13.default.green("https://www.codeagent-mobile.com")}`,
+    `     ${import_picocolors13.default.dim("Issues:")}   ${import_picocolors13.default.green("https://github.com/edgar-durand/codeagent-mobile-clients/issues")}`,
     ""
   ];
   process.stdout.write(lines.join("\n") + "\n");
 }
 
 // src/lib/updateNotifier.ts
-var fs16 = __toESM(require("fs"));
-var os15 = __toESM(require("os"));
-var path24 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var os17 = __toESM(require("os"));
+var path26 = __toESM(require("path"));
 var https7 = __toESM(require("https"));
-var import_picocolors13 = __toESM(require("picocolors"));
+var import_picocolors14 = __toESM(require("picocolors"));
 var PKG_NAME = "codeam-cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}/latest`;
 var TTL_MS = 24 * 60 * 60 * 1e3;
 var REQUEST_TIMEOUT_MS = 1500;
 function cachePath() {
-  const dir = path24.join(os15.homedir(), ".codeam");
-  return path24.join(dir, "update-check.json");
+  const dir = path26.join(os17.homedir(), ".codeam");
+  return path26.join(dir, "update-check.json");
 }
 function readCache() {
   try {
-    const raw = fs16.readFileSync(cachePath(), "utf8");
+    const raw = fs18.readFileSync(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.fetchedAt !== "number" || typeof parsed.latest !== "string") return null;
     return parsed;
@@ -10708,8 +11046,8 @@ function readCache() {
 function writeCache(cache) {
   try {
     const file = cachePath();
-    fs16.mkdirSync(path24.dirname(file), { recursive: true });
-    fs16.writeFileSync(file, JSON.stringify(cache));
+    fs18.mkdirSync(path26.dirname(file), { recursive: true });
+    fs18.writeFileSync(file, JSON.stringify(cache));
   } catch {
   }
 }
@@ -10765,11 +11103,11 @@ function fetchLatest() {
 }
 function notifyIfStale(currentVersion, latest) {
   if (compareSemver(latest, currentVersion) <= 0) return;
-  const arrow = import_picocolors13.default.dim("\u2192");
-  const cmd = import_picocolors13.default.cyan("npm install -g codeam-cli");
+  const arrow = import_picocolors14.default.dim("\u2192");
+  const cmd = import_picocolors14.default.cyan("npm install -g codeam-cli");
   const lines = [
     "",
-    `  ${import_picocolors13.default.yellow("\u25CF")} ${import_picocolors13.default.bold("Update available")} ${import_picocolors13.default.dim(currentVersion)} ${arrow} ${import_picocolors13.default.green(latest)}`,
+    `  ${import_picocolors14.default.yellow("\u25CF")} ${import_picocolors14.default.bold("Update available")} ${import_picocolors14.default.dim(currentVersion)} ${arrow} ${import_picocolors14.default.green(latest)}`,
     `    Run ${cmd} to upgrade.`,
     ""
   ];
@@ -10780,7 +11118,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current = true ? "2.15.8" : null;
+  const current = true ? "2.16.0" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -10818,6 +11156,8 @@ async function main() {
       return status();
     case "logout":
       return logout();
+    case "link":
+      return link(args);
     case "deploy":
       if (args[0] === "ls" || args[0] === "list") return deployList();
       if (args[0] === "stop" || args[0] === "remove") return deployStop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.15.8",
+  "version": "2.16.0",
   "description": "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device — async. The terminal companion for CodeAgent Mobile.",
   "type": "commonjs",
   "main": "dist/index.js",