codeam-cli 1.0.0

package/README.md

@@ -0,0 +1,25 @@
+# codeam-cli
+
+Remote control [Claude Code](https://claude.ai/code) from your mobile device using [CodeAgent Mobile](https://codeagentmobile.com).
+
+## Install
+
+```bash
+npm install -g codeam-cli
+```
+
+## Usage
+
+```bash
+codeam pair        # Pair with your mobile device
+codeam             # Start Claude Code with mobile control
+codeam sessions    # List paired sessions
+codeam status      # Show connection status
+codeam logout      # Remove all sessions
+```
+
+## Requirements
+
+- Node.js 18+
+- Claude Code installed (`npm install -g @anthropic-ai/claude-code`)
+- [CodeAgent Mobile](https://codeagentmobile.com) app on your phone

package/dist/index.js

@@ -0,0 +1,813 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/commands/start.ts
+var import_picocolors2 = __toESM(require("picocolors"));
+
+// src/config.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var EMPTY_CONFIG = () => ({
+  pluginId: crypto.randomUUID(),
+  activeSessionId: null,
+  sessions: []
+});
+function makeConfig(baseDir) {
+  const dir = path.join(baseDir ?? os.homedir(), ".codeam");
+  const file = path.join(dir, "config.json");
+  function load() {
+    try {
+      const raw = JSON.parse(fs.readFileSync(file, "utf-8"));
+      return {
+        pluginId: typeof raw.pluginId === "string" ? raw.pluginId : crypto.randomUUID(),
+        activeSessionId: typeof raw.activeSessionId === "string" ? raw.activeSessionId : null,
+        sessions: Array.isArray(raw.sessions) ? raw.sessions : []
+      };
+    } catch {
+      return EMPTY_CONFIG();
+    }
+  }
+  function save(c) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs.writeFileSync(file, JSON.stringify(c, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+  function getConfig2() {
+    return load();
+  }
+  function ensurePluginId2() {
+    const c = load();
+    save(c);
+    return c.pluginId;
+  }
+  function addSession2(session) {
+    const c = load();
+    c.sessions = c.sessions.filter((s) => s.id !== session.id);
+    c.sessions.unshift(session);
+    if (!c.activeSessionId) c.activeSessionId = session.id;
+    save(c);
+  }
+  function removeSession2(sessionId) {
+    const c = load();
+    c.sessions = c.sessions.filter((s) => s.id !== sessionId);
+    if (c.activeSessionId === sessionId) {
+      c.activeSessionId = c.sessions[0]?.id ?? null;
+    }
+    save(c);
+  }
+  function setActiveSession2(sessionId) {
+    const c = load();
+    c.activeSessionId = sessionId;
+    save(c);
+  }
+  function getActiveSession2() {
+    const c = load();
+    if (!c.activeSessionId) return null;
+    const session = c.sessions.find((s) => s.id === c.activeSessionId) ?? null;
+    if (!session) {
+      c.activeSessionId = null;
+      save(c);
+    }
+    return session;
+  }
+  function clearAll2() {
+    try {
+      fs.unlinkSync(file);
+    } catch {
+    }
+  }
+  return { getConfig: getConfig2, ensurePluginId: ensurePluginId2, addSession: addSession2, removeSession: removeSession2, setActiveSession: setActiveSession2, getActiveSession: getActiveSession2, clearAll: clearAll2 };
+}
+var _default = makeConfig();
+var { getConfig, ensurePluginId, addSession, removeSession, setActiveSession, getActiveSession, clearAll } = _default;
+
+// src/ui/banner.ts
+var import_picocolors = __toESM(require("picocolors"));
+var VERSION = "1.0.0";
+function showIntro() {
+  console.log("");
+  console.log(`  ${import_picocolors.default.bold(import_picocolors.default.cyan("codeam"))}  ${import_picocolors.default.dim(`v${VERSION}`)}`);
+  console.log("");
+}
+function showSuccess(msg) {
+  console.log(`  ${import_picocolors.default.green("\u2713")} ${msg}`);
+}
+function showError(msg) {
+  console.log(`  ${import_picocolors.default.red("\u2717")} ${msg}`);
+}
+function showInfo(msg) {
+  console.log(`  ${import_picocolors.default.dim("\xB7")} ${msg}`);
+}
+function showPairingCode(code, expiresAt) {
+  const secs = Math.max(0, Math.floor((expiresAt - Date.now()) / 1e3));
+  const timer = `${Math.floor(secs / 60)}:${String(secs % 60).padStart(2, "0")}`;
+  console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  const codePad = " ".repeat(Math.max(0, 19 - code.length));
+  const timerPad = " ".repeat(Math.max(0, 15 - timer.length));
+  console.log(`  \u2502  Code:  ${import_picocolors.default.bold(import_picocolors.default.yellow(code))}${codePad}\u2502`);
+  console.log(`  \u2502  Expires in: ${import_picocolors.default.dim(timer)}${timerPad}\u2502`);
+  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  console.log("");
+}
+
+// src/services/websocket.service.ts
+var import_ws = __toESM(require("ws"));
+var API_BASE = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var WS_URL = API_BASE.replace("https://", "wss://").replace("http://", "ws://") + "/api/ws";
+var HEARTBEAT_MS = 3e4;
+var MAX_RECONNECT = 10;
+var WebSocketService = class {
+  constructor(sessionId, pluginId) {
+    this.sessionId = sessionId;
+    this.pluginId = pluginId;
+  }
+  sessionId;
+  pluginId;
+  client = null;
+  heartbeat = null;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  handlers = [];
+  _connected = false;
+  get connected() {
+    return this._connected;
+  }
+  addHandler(h) {
+    this.handlers.push(h);
+  }
+  connect() {
+    this.disconnect();
+    try {
+      this.client = new import_ws.default(WS_URL);
+      this.client.on("open", () => {
+        this._connected = true;
+        this.reconnectAttempts = 0;
+        this.client.send(JSON.stringify({
+          type: "auth",
+          payload: { token: null, sessionId: this.sessionId, pluginId: this.pluginId },
+          timestamp: Date.now()
+        }));
+        this.startHeartbeat();
+        this.handlers.forEach((h) => h.onConnected());
+      });
+      this.client.on("message", (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          if (msg.type === "pong" || msg.type === "auth_success" || msg.type === "auth_error") return;
+          this.handlers.forEach((h) => h.onMessage(msg.type, msg.payload ?? {}));
+        } catch {
+        }
+      });
+      this.client.on("close", () => {
+        this._connected = false;
+        this.stopHeartbeat();
+        this.handlers.forEach((h) => h.onDisconnected());
+        if (this.reconnectAttempts < MAX_RECONNECT) {
+          this.reconnectAttempts++;
+          const delay = Math.min(1e3 * 2 ** this.reconnectAttempts, 3e4);
+          this.reconnectTimer = setTimeout(() => this.connect(), delay);
+        }
+      });
+      this.client.on("error", () => {
+      });
+    } catch {
+    }
+  }
+  send(type, payload) {
+    if (!this._connected || !this.client) return;
+    this.client.send(JSON.stringify({ type, payload, timestamp: Date.now() }));
+  }
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.reconnectAttempts = 0;
+    this.stopHeartbeat();
+    this.client?.removeAllListeners();
+    this.client?.close();
+    this.client = null;
+    this._connected = false;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeat = setInterval(() => {
+      if (this._connected) this.client?.send(JSON.stringify({ type: "ping", timestamp: Date.now() }));
+    }, HEARTBEAT_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeat) {
+      clearInterval(this.heartbeat);
+      this.heartbeat = null;
+    }
+  }
+};
+
+// src/services/pairing.service.ts
+var https = __toESM(require("https"));
+var http = __toESM(require("http"));
+var os2 = __toESM(require("os"));
+var API_BASE2 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+async function requestCode(pluginId) {
+  try {
+    const result = await _transport.postJson(`${API_BASE2}/api/pairing/code`, {
+      pluginId,
+      ideName: "Terminal (codeam-cli)",
+      ideVersion: "1.0.0",
+      hostname: os2.hostname()
+    });
+    const data = result?.data;
+    if (!data?.code) return null;
+    return { code: data.code, expiresAt: data.expiresAt };
+  } catch {
+    return null;
+  }
+}
+function pollStatus(pluginId, onPaired, onTimeout) {
+  let stopped = false;
+  const interval = setInterval(async () => {
+    if (stopped) return;
+    try {
+      const result = await _transport.getJson(
+        `${API_BASE2}/api/pairing/status?pluginId=${pluginId}`
+      );
+      const data = result?.data;
+      if (data?.paired) {
+        stop();
+        const user = data.user ?? {};
+        onPaired({
+          sessionId: data.sessionId,
+          userName: user.name || "",
+          userEmail: user.email || "",
+          plan: user.plan || "FREE"
+        });
+      }
+    } catch {
+    }
+  }, 3e3);
+  const timeout = setTimeout(() => {
+    stop();
+    onTimeout();
+  }, 3e5);
+  function stop() {
+    stopped = true;
+    clearInterval(interval);
+    clearTimeout(timeout);
+  }
+  return stop;
+}
+var _transport = {
+  postJson: _postJson,
+  getJson: _getJson
+};
+async function _postJson(url, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const transport = u.protocol === "https:" ? https : http;
+    const req = transport.request(
+      {
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname + u.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data)
+        },
+        timeout: 1e4
+      },
+      (res) => {
+        res.on("error", reject);
+        let body2 = "";
+        res.on("data", (chunk) => {
+          body2 += chunk.toString();
+        });
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(body2));
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+async function _getJson(url) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const transport = u.protocol === "https:" ? https : http;
+    const req = transport.request(
+      {
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname + u.search,
+        method: "GET",
+        timeout: 1e4
+      },
+      (res) => {
+        res.on("error", reject);
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(body));
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.end();
+  });
+}
+
+// src/services/command-relay.service.ts
+var API_BASE3 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var CommandRelayService = class {
+  constructor(pluginId, onCommand) {
+    this.pluginId = pluginId;
+    this.onCommand = onCommand;
+  }
+  pluginId;
+  onCommand;
+  _running = false;
+  pollTimer = null;
+  heartbeatTimer = null;
+  start() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this._running = true;
+    this.sendHeartbeat(true);
+    this.heartbeatTimer = setInterval(() => this.sendHeartbeat(true), 2e4);
+    void this.pollLoop();
+    this.reportAgents();
+  }
+  stop() {
+    if (!this._running) return;
+    this._running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.sendHeartbeat(false).catch(() => {
+    });
+  }
+  async sendResult(commandId, status2, result) {
+    await _postJson(`${API_BASE3}/api/commands/result`, { commandId, status: status2, result });
+  }
+  async pollLoop() {
+    if (!this._running) return;
+    await this.poll();
+    if (this._running) {
+      this.pollTimer = setTimeout(() => this.pollLoop(), 2e3);
+    }
+  }
+  async poll() {
+    try {
+      const data = await _getJson(
+        `${API_BASE3}/api/commands/pending?pluginId=${this.pluginId}`
+      );
+      const commands = data?.data;
+      if (!Array.isArray(commands)) return;
+      for (const obj of commands) {
+        this.onCommand({
+          id: obj.id,
+          sessionId: obj.sessionId,
+          type: obj.type,
+          payload: obj.payload ?? {}
+        });
+      }
+    } catch {
+    }
+  }
+  async sendHeartbeat(online) {
+    await _postJson(`${API_BASE3}/api/plugin/heartbeat`, {
+      pluginId: this.pluginId,
+      online
+    }).catch(() => {
+    });
+  }
+  reportAgents() {
+    _postJson(`${API_BASE3}/api/plugin/agents`, {
+      pluginId: this.pluginId,
+      agents: [{ id: "claude-code", name: "Claude Code", icon: "\u{1F916}", installed: true }]
+    }).catch(() => {
+    });
+  }
+};
+
+// src/services/claude.service.ts
+var pty = __toESM(require("node-pty"));
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var ClaudeService = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  proc = null;
+  spawn() {
+    if (this.proc) {
+      this.cleanup();
+      this.proc.kill();
+      this.proc = null;
+    }
+    const claudePath = findInPath("claude") ?? findInPath("claude-code");
+    if (!claudePath) {
+      console.error(
+        "\n  \u2717 claude not found in PATH.\n    Install it with: npm install -g @anthropic-ai/claude-code\n"
+      );
+      process.exit(1);
+    }
+    this.proc = pty.spawn(claudePath, [], {
+      name: "xterm-256color",
+      cols: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24,
+      cwd: this.opts.cwd,
+      env: process.env
+    });
+    this.proc.onData((data) => {
+      process.stdout.write(data);
+      this.opts.onData?.(data);
+    });
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", this.stdinHandler);
+    process.on("SIGWINCH", this.handleResize);
+    this.proc.onExit(({ exitCode }) => {
+      this.cleanup();
+      this.opts.onExit(exitCode ?? 0);
+    });
+  }
+  /** Send a command to Claude's stdin (remote control) */
+  sendCommand(text) {
+    this.proc?.write(text + "\r");
+  }
+  /** Send Ctrl+C to Claude */
+  interrupt() {
+    this.proc?.write("");
+  }
+  kill() {
+    this.proc?.kill();
+    this.cleanup();
+  }
+  stdinHandler = (chunk) => {
+    this.proc?.write(chunk.toString());
+  };
+  handleResize = () => {
+    this.proc?.resize(process.stdout.columns ?? 80, process.stdout.rows ?? 24);
+  };
+  cleanup() {
+    process.removeListener("SIGWINCH", this.handleResize);
+    process.stdin.removeListener("data", this.stdinHandler);
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+    }
+  }
+};
+function findInPath(name) {
+  const dirs = (process.env.PATH ?? "").split(path2.delimiter);
+  for (const dir of dirs) {
+    const full = `${dir}/${name}`;
+    try {
+      fs2.accessSync(full, fs2.constants.X_OK);
+      return full;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/start.ts
+async function start() {
+  showIntro();
+  const session = getActiveSession();
+  if (!session) {
+    console.log(`  ${import_picocolors2.default.dim("No paired session found.")}`);
+    console.log(`  ${import_picocolors2.default.dim(`Run ${import_picocolors2.default.white("codeam pair")} to connect your mobile app.`)}
+`);
+    process.exit(0);
+  }
+  const pluginId = ensurePluginId();
+  showInfo(`${session.userName}  \xB7  ${import_picocolors2.default.cyan(session.plan)}`);
+  showInfo("Launching Claude Code...\n");
+  const ws = new WebSocketService(session.id, pluginId);
+  const relay = new CommandRelayService(pluginId, (cmd) => {
+    switch (cmd.type) {
+      case "start_task": {
+        const prompt = cmd.payload.prompt;
+        if (prompt) claude.sendCommand(prompt);
+        break;
+      }
+      case "provide_input": {
+        const input = cmd.payload.input;
+        if (input) claude.sendCommand(input);
+        break;
+      }
+      case "stop_task":
+        claude.interrupt();
+        break;
+    }
+  });
+  ws.addHandler({
+    onConnected() {
+    },
+    onDisconnected() {
+    },
+    onMessage(type, payload) {
+      if (type !== "agent_command") return;
+      const cmdType = payload.type;
+      const inner = payload.payload ?? {};
+      if (cmdType === "start_task") {
+        const prompt = inner.prompt;
+        if (prompt) claude.sendCommand(prompt);
+      } else if (cmdType === "provide_input") {
+        const input = inner.input;
+        if (input) claude.sendCommand(input);
+      } else if (cmdType === "stop_task") {
+        claude.interrupt();
+      }
+    }
+  });
+  ws.connect();
+  relay.start();
+  const claude = new ClaudeService({
+    cwd: process.cwd(),
+    onExit(code) {
+      process.removeListener("SIGINT", sigintHandler);
+      relay.stop();
+      ws.disconnect();
+      process.exit(code);
+    }
+  });
+  function sigintHandler() {
+    claude.kill();
+    relay.stop();
+    ws.disconnect();
+    process.exit(0);
+  }
+  process.once("SIGINT", sigintHandler);
+  claude.spawn();
+}
+
+// src/commands/pair.ts
+var import_picocolors3 = __toESM(require("picocolors"));
+
+// src/ui/prompts.ts
+var p = __toESM(require("@clack/prompts"));
+async function confirmAction(message) {
+  const result = await p.confirm({ message });
+  if (p.isCancel(result)) return false;
+  return result;
+}
+async function selectSession(sessions2, activeId) {
+  const result = await p.select({
+    message: "Select active session:",
+    options: sessions2.map((s) => ({
+      value: s.id,
+      label: `${s.userName}  ${s.plan}`,
+      hint: s.id === activeId ? "active" : `paired ${new Date(s.pairedAt).toLocaleDateString()}`
+    })),
+    initialValue: activeId ?? void 0
+  });
+  if (p.isCancel(result)) return null;
+  return result;
+}
+
+// src/commands/pair.ts
+async function pair() {
+  showIntro();
+  const pluginId = ensurePluginId();
+  const spin = p.spinner();
+  spin.start("Requesting pairing code...");
+  const result = await requestCode(pluginId);
+  if (!result) {
+    spin.stop("Failed");
+    showError("Could not reach the server. Check your connection and try again.");
+    process.exit(1);
+  }
+  spin.stop("Got pairing code");
+  showPairingCode(result.code, result.expiresAt);
+  console.log(import_picocolors3.default.dim("  Open CodeAgent Mobile and enter this code."));
+  console.log("");
+  const waitSpin = p.spinner();
+  waitSpin.start("Waiting for mobile app...");
+  await new Promise((resolve) => {
+    let stopPolling = null;
+    function sigintHandler() {
+      stopPolling?.();
+      console.log("");
+      process.exit(0);
+    }
+    stopPolling = pollStatus(
+      pluginId,
+      (info) => {
+        process.removeListener("SIGINT", sigintHandler);
+        waitSpin.stop("Paired!");
+        addSession({
+          id: info.sessionId,
+          userName: info.userName,
+          userEmail: info.userEmail,
+          plan: info.plan,
+          pairedAt: Date.now()
+        });
+        showSuccess(`Paired with ${info.userName} (${info.plan})`);
+        console.log(
+          import_picocolors3.default.dim(`
+  Session saved. Run ${import_picocolors3.default.white("codeam")} to start.
+`)
+        );
+        resolve();
+      },
+      () => {
+        waitSpin.stop("Timed out");
+        showError("Pairing timed out after 5 minutes. Run codeam pair to try again.");
+        process.exit(1);
+      }
+    );
+    process.once("SIGINT", sigintHandler);
+  });
+}
+
+// src/commands/sessions.ts
+var import_picocolors4 = __toESM(require("picocolors"));
+async function sessions(args2) {
+  const [sub, id] = args2;
+  if (sub === "switch") return switchSession();
+  if (sub === "delete") {
+    if (!id) {
+      showError("Usage: codeam sessions delete <session-id>");
+      process.exit(1);
+    }
+    return deleteSession(id);
+  }
+  return listSessions();
+}
+function listSessions() {
+  showIntro();
+  const config = getConfig();
+  if (config.sessions.length === 0) {
+    console.log(import_picocolors4.default.dim("  No paired sessions. Run codeam pair to connect.\n"));
+    return;
+  }
+  console.log(import_picocolors4.default.bold("  Paired sessions:\n"));
+  for (const s of config.sessions) {
+    const isActive = s.id === config.activeSessionId;
+    const bullet = isActive ? import_picocolors4.default.green("  \u25CF") : import_picocolors4.default.dim("  \u25CB");
+    const name = isActive ? import_picocolors4.default.bold(s.userName) : s.userName;
+    const plan = import_picocolors4.default.cyan(s.plan);
+    const date = import_picocolors4.default.dim(new Date(s.pairedAt).toLocaleDateString());
+    console.log(`${bullet}  ${name}  ${plan}  ${date}`);
+    console.log(import_picocolors4.default.dim(`       ${s.id}`));
+  }
+  console.log("");
+}
+async function switchSession() {
+  showIntro();
+  const config = getConfig();
+  if (config.sessions.length === 0) {
+    showError("No paired sessions. Run codeam pair to connect.");
+    process.exit(1);
+  }
+  const chosen = await selectSession(config.sessions, config.activeSessionId);
+  if (!chosen) {
+    console.log("");
+    return;
+  }
+  setActiveSession(chosen);
+  const s = config.sessions.find((x) => x.id === chosen);
+  console.log(import_picocolors4.default.green(`
+  \u2713 Switched to ${s?.userName ?? chosen}
+`));
+}
+async function deleteSession(id) {
+  showIntro();
+  const config = getConfig();
+  const session = config.sessions.find((s) => s.id === id);
+  if (!session) {
+    showError(`Session not found: ${id}`);
+    process.exit(1);
+  }
+  const ok = await confirmAction(`Delete session for ${session.userName}?`);
+  if (!ok) {
+    console.log("");
+    return;
+  }
+  removeSession(id);
+  console.log(import_picocolors4.default.green("\n  \u2713 Session deleted\n"));
+}
+
+// src/commands/status.ts
+var import_picocolors5 = __toESM(require("picocolors"));
+function status() {
+  showIntro();
+  const config = getConfig();
+  const active = config.sessions.find((s) => s.id === config.activeSessionId) ?? null;
+  console.log(import_picocolors5.default.bold("  Status\n"));
+  console.log(`  Plugin ID   ${import_picocolors5.default.dim(config.pluginId || "not generated yet")}`);
+  console.log(`  Sessions    ${config.sessions.length} paired`);
+  if (active) {
+    console.log(`  Active      ${import_picocolors5.default.bold(active.userName)}  ${import_picocolors5.default.cyan(active.plan)}`);
+    console.log(`  Session ID  ${import_picocolors5.default.dim(active.id)}`);
+  } else {
+    console.log(`  Active      ${import_picocolors5.default.yellow("none")}  ${import_picocolors5.default.dim("run codeam pair to connect")}`);
+  }
+  console.log("");
+}
+
+// src/commands/logout.ts
+var import_picocolors6 = __toESM(require("picocolors"));
+async function logout() {
+  showIntro();
+  const ok = await confirmAction("Remove all sessions and local config?");
+  if (!ok) {
+    console.log("");
+    return;
+  }
+  clearAll();
+  console.log(import_picocolors6.default.green("\n  \u2713 Done. All sessions removed.\n"));
+}
+
+// src/index.ts
+var [, , command, ...args] = process.argv;
+async function main() {
+  switch (command) {
+    case "pair":
+      return pair();
+    case "sessions":
+      return sessions(args);
+    case "status":
+      return status();
+    case "logout":
+      return logout();
+    default:
+      return start();
+  }
+}
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(`
+  ${msg}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "codeam-cli",
+  "version": "1.0.0",
+  "description": "Remote control Claude Code from your mobile device",
+  "main": "dist/index.js",
+  "bin": {
+    "codeam": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "cli",
+    "remote-control",
+    "codeagent"
+  ],
+  "author": "Edgar Durand",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/edgardurand/codeagent-mobile.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "node-pty": "^1.0.0",
+    "picocolors": "^1.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.0"
+  }
+}