replicas-cli 0.2.39 → 0.2.41

package/dist/index.mjs

@@ -0,0 +1,2201 @@
+#!/usr/bin/env bun
+import {
+  REPLICAS_CONFIG_FILENAMES,
+  SANDBOX_PATHS,
+  deleteConfig,
+  getCurrentUser,
+  getIdeCommand,
+  getOrganizationId,
+  getValidToken,
+  isAgentMode,
+  isAuthenticated,
+  parseAgentEvents,
+  readAgentConfig,
+  readConfig,
+  setIdeCommand,
+  setOrganizationId,
+  writeConfig
+} from "./chunk-IO4QHXPW.mjs";
+
+// src/index.ts
+import "dotenv/config";
+import { Command } from "commander";
+import chalk18 from "chalk";
+
+// src/commands/login.ts
+import http from "http";
+import { URL as URL2 } from "url";
+import open from "open";
+import chalk from "chalk";
+
+// src/lib/api.ts
+var MONOLITH_URL = process.env.REPLICAS_MONOLITH_URL || "https://api.replicas.dev";
+async function authenticatedFetch(url, options) {
+  const token = await getValidToken();
+  if (!token) {
+    throw new Error("No access token available");
+  }
+  const headers = {
+    "Authorization": `Bearer ${token}`,
+    "Content-Type": "application/json",
+    ...options?.headers || {}
+  };
+  const absoluteUrl = `${MONOLITH_URL}${url}`;
+  const requestInit = {
+    ...options,
+    headers,
+    body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+  };
+  const response = await fetchWithRedirects(absoluteUrl, requestInit);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Request failed" }));
+    throw new Error(error.error || `Request failed with status ${response.status}`);
+  }
+  return response.json();
+}
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var MAX_REDIRECTS = 5;
+async function fetchWithRedirects(url, init, attempt = 0) {
+  const response = await fetch(url, { ...init, redirect: "manual" });
+  if (REDIRECT_STATUSES.has(response.status)) {
+    if (attempt >= MAX_REDIRECTS) {
+      throw new Error("Too many redirects while contacting the Replicas API");
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+      throw new Error(`Redirect status ${response.status} missing Location header`);
+    }
+    const nextUrl = new URL(location, url).toString();
+    const shouldForceGet = response.status === 303 && init.method !== void 0 && init.method.toUpperCase() !== "GET";
+    const nextInit = {
+      ...init,
+      method: shouldForceGet ? "GET" : init.method,
+      body: shouldForceGet ? void 0 : init.body
+    };
+    return fetchWithRedirects(nextUrl, nextInit, attempt + 1);
+  }
+  return response;
+}
+async function orgAuthenticatedFetch(url, options) {
+  const token = await getValidToken();
+  const organizationId = getOrganizationId();
+  if (!organizationId) {
+    throw new Error(
+      'No organization selected. Please run "replicas org switch" to select an organization.'
+    );
+  }
+  const headers = {
+    "Authorization": `Bearer ${token}`,
+    "Replicas-Org-Id": organizationId,
+    "Content-Type": "application/json",
+    ...options?.headers || {}
+  };
+  const absoluteUrl = `${MONOLITH_URL}${url}`;
+  const requestInit = {
+    ...options,
+    headers,
+    body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+  };
+  const response = await fetchWithRedirects(absoluteUrl, requestInit);
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Request failed" }));
+    throw new Error(error.error || `Request failed with status ${response.status}`);
+  }
+  return response.json();
+}
+
+// src/lib/organization.ts
+async function fetchOrganizations() {
+  const response = await authenticatedFetch(
+    "/v1/user/organizations"
+  );
+  return response.organizations;
+}
+async function setActiveOrganization(organizationId) {
+  const organizations = await fetchOrganizations();
+  const organization = organizations.find((org2) => org2.id === organizationId);
+  if (!organization) {
+    throw new Error(`Organization with ID ${organizationId} not found or you don't have access to it.`);
+  }
+  setOrganizationId(organizationId);
+}
+async function ensureOrganization() {
+  const organizations = await fetchOrganizations();
+  if (organizations.length === 0) {
+    throw new Error("You are not a member of any organization. Please contact support.");
+  }
+  const defaultOrg = organizations[0];
+  setOrganizationId(defaultOrg.id);
+  return defaultOrg.id;
+}
+
+// src/commands/login.ts
+var WEB_APP_URL = process.env.REPLICAS_WEB_URL || "https://replicas.dev";
+function generateState() {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+async function loginCommand() {
+  const state = generateState();
+  return new Promise((resolve, reject) => {
+    let authTimeout;
+    let hasHandledCallback = false;
+    let lastRedirectUrl = null;
+    let lastMessage = null;
+    const pendingResponses = /* @__PURE__ */ new Set();
+    function respondWithRedirect(res) {
+      if (lastRedirectUrl) {
+        res.writeHead(302, {
+          "Location": lastRedirectUrl,
+          "Connection": "close"
+        });
+        res.end();
+      } else {
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Connection": "close"
+        });
+        res.end(`
+          <!DOCTYPE html>
+          <html lang="en">
+            <head>
+              <meta charset="utf-8" />
+              <title>Replicas CLI Login</title>
+              <style>
+                body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background:#09090b; color:#f4f4f5; display:flex; align-items:center; justify-content:center; height:100vh; margin:0; }
+                .card { border:1px solid #27272a; padding:32px; border-radius:12px; background:#0f0f12; max-width:420px; text-align:center; }
+                .title { font-size:20px; margin-bottom:12px; letter-spacing:0.08em; text-transform:uppercase; color:#a855f7; }
+                .message { font-family: 'Menlo', 'Source Code Pro', monospace; font-size:14px; line-height:1.6; color:#d4d4d8; white-space:pre-line; }
+              </style>
+            </head>
+            <body>
+              <div class="card">
+                <div class="title">Replicas CLI</div>
+                <div class="message">${lastMessage || "Authentication already processed. You can close this tab."}</div>
+              </div>
+            </body>
+          </html>
+        `);
+      }
+    }
+    function flushPendingResponses() {
+      for (const response of pendingResponses) {
+        respondWithRedirect(response);
+      }
+      pendingResponses.clear();
+    }
+    const server = http.createServer(async (req, res) => {
+      const url = new URL2(req.url || "", `http://${req.headers.host}`);
+      if (url.pathname === "/callback") {
+        if (hasHandledCallback) {
+          if (!lastRedirectUrl) {
+            pendingResponses.add(res);
+            res.on("close", () => pendingResponses.delete(res));
+            return;
+          }
+          respondWithRedirect(res);
+          return;
+        }
+        const returnedState = url.searchParams.get("state");
+        const accessToken = url.searchParams.get("access_token");
+        const refreshToken = url.searchParams.get("refresh_token");
+        const expiresAt = url.searchParams.get("expires_at");
+        const error = url.searchParams.get("error");
+        if (error) {
+          const errorUrl = `${WEB_APP_URL}/cli-login/error?message=${encodeURIComponent(error)}`;
+          lastRedirectUrl = errorUrl;
+          lastMessage = `Authentication failed: ${error}`;
+          respondWithRedirect(res);
+          flushPendingResponses();
+          clearTimeout(authTimeout);
+          setImmediate(() => {
+            server.closeAllConnections?.();
+            server.close();
+            reject(new Error(`Authentication failed: ${error}`));
+          });
+          return;
+        }
+        if (returnedState !== state) {
+          const errorUrl = `${WEB_APP_URL}/cli-login/error?message=${encodeURIComponent("Invalid state parameter. This might be a CSRF attack.")}`;
+          lastRedirectUrl = errorUrl;
+          lastMessage = "Invalid state parameter. This might be a CSRF attack.";
+          respondWithRedirect(res);
+          flushPendingResponses();
+          clearTimeout(authTimeout);
+          setImmediate(() => {
+            server.closeAllConnections?.();
+            server.close();
+            reject(new Error("Invalid state parameter"));
+          });
+          return;
+        }
+        if (!accessToken || !refreshToken || !expiresAt) {
+          const errorUrl = `${WEB_APP_URL}/cli-login/error?message=${encodeURIComponent("Missing required authentication tokens.")}`;
+          lastRedirectUrl = errorUrl;
+          lastMessage = "Missing required authentication tokens.";
+          respondWithRedirect(res);
+          flushPendingResponses();
+          clearTimeout(authTimeout);
+          setImmediate(() => {
+            server.closeAllConnections?.();
+            server.close();
+            reject(new Error("Missing authentication tokens"));
+          });
+          return;
+        }
+        hasHandledCallback = true;
+        const existingConfig = readConfig();
+        const config2 = {
+          access_token: accessToken,
+          refresh_token: refreshToken,
+          expires_at: parseInt(expiresAt, 10),
+          organization_id: existingConfig?.organization_id,
+          ide_command: existingConfig?.ide_command
+        };
+        try {
+          writeConfig(config2);
+          const user = await getCurrentUser();
+          try {
+            const orgId = await ensureOrganization();
+            console.log(chalk.gray(`  Organization: ${orgId}`));
+          } catch (orgError) {
+            console.log(chalk.yellow("  Warning: Could not fetch organizations"));
+            console.log(chalk.gray("  You can set your organization later with: replicas org switch"));
+          }
+          const successUrl = `${WEB_APP_URL}/cli-login/success?email=${encodeURIComponent(user.email)}`;
+          lastRedirectUrl = successUrl;
+          lastMessage = `Successfully logged in as ${user.email}. You can close this tab.`;
+          respondWithRedirect(res);
+          flushPendingResponses();
+          console.log(chalk.green("\n\u2713 Successfully logged in!"));
+          console.log(chalk.gray(`  Email: ${user.email}
+`));
+          clearTimeout(authTimeout);
+          setImmediate(() => {
+            server.closeAllConnections?.();
+            server.close();
+            resolve();
+          });
+        } catch (error2) {
+          const errorUrl = `${WEB_APP_URL}/cli-login/error?message=${encodeURIComponent("Failed to verify authentication.")}`;
+          lastRedirectUrl = errorUrl;
+          lastMessage = "Failed to verify authentication.";
+          respondWithRedirect(res);
+          flushPendingResponses();
+          clearTimeout(authTimeout);
+          setImmediate(() => {
+            server.closeAllConnections?.();
+            server.close();
+            reject(error2);
+          });
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(0, "localhost", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to start server"));
+        return;
+      }
+      const port = address.port;
+      const loginUrl = `${WEB_APP_URL}/cli-login?port=${port}&state=${state}`;
+      console.log(chalk.blue("\nOpening browser for authentication..."));
+      console.log(chalk.gray(`If the browser doesn't open automatically, visit:
+${loginUrl}
+`));
+      open(loginUrl).catch((error) => {
+        console.log(chalk.yellow("Failed to open browser automatically."));
+        console.log(chalk.gray(`Please open this URL manually:
+${loginUrl}
+`));
+      });
+    });
+    authTimeout = setTimeout(() => {
+      server.closeAllConnections?.();
+      server.close();
+      reject(new Error("Authentication timeout. Please try again."));
+    }, 5 * 60 * 1e3);
+  });
+}
+
+// src/commands/logout.ts
+import chalk2 from "chalk";
+function logoutCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk2.yellow("You are not logged in."));
+    return;
+  }
+  deleteConfig();
+  console.log(chalk2.green("\u2713 Successfully logged out!"));
+}
+
+// src/commands/whoami.ts
+import chalk3 from "chalk";
+async function whoamiCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk3.yellow("You are not logged in."));
+    console.log(chalk3.gray('Run "replicas login" to authenticate.'));
+    return;
+  }
+  try {
+    const user = await getCurrentUser();
+    console.log(chalk3.blue("\nCurrent User:"));
+    console.log(chalk3.gray(`  ID:    ${user.id}`));
+    console.log(chalk3.gray(`  Email: ${user.email}
+`));
+  } catch (error) {
+    console.error(chalk3.red("Failed to get user information."));
+    if (error instanceof Error) {
+      console.error(chalk3.gray(error.message));
+    }
+    console.log(chalk3.gray('\nTry running "replicas login" again.'));
+    process.exit(1);
+  }
+}
+
+// src/commands/connect.ts
+import chalk5 from "chalk";
+
+// src/lib/ssh.ts
+import { spawn } from "child_process";
+var SSH_OPTIONS = ["-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null"];
+async function connectSSH(token, host) {
+  return new Promise((resolve, reject) => {
+    const sshArgs = [...SSH_OPTIONS, `${token}@${host}`];
+    const ssh = spawn("ssh", sshArgs, {
+      stdio: "inherit"
+    });
+    ssh.on("close", () => {
+      resolve();
+    });
+    ssh.on("error", reject);
+  });
+}
+
+// src/lib/workspace-connection.ts
+import chalk4 from "chalk";
+import prompts from "prompts";
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+import path from "path";
+function getGitRoot() {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return root;
+  } catch (error) {
+    throw new Error("Not inside a git repository");
+  }
+}
+function getGitRepoName() {
+  const root = getGitRoot();
+  return path.basename(root);
+}
+function isInsideGitRepo() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/workspace-connection.ts
+async function prepareWorkspaceConnection(workspaceName) {
+  const orgId = getOrganizationId();
+  if (!orgId) {
+    throw new Error('No organization selected. Please run "replicas org switch" first.');
+  }
+  console.log(chalk4.blue(`
+Searching for workspace: ${workspaceName}...`));
+  const response = await orgAuthenticatedFetch(
+    `/v1/workspaces?name=${encodeURIComponent(workspaceName)}`
+  );
+  if (response.workspaces.length === 0) {
+    throw new Error(`No workspaces found with name matching "${workspaceName}".`);
+  }
+  let selectedWorkspace;
+  if (response.workspaces.length === 1) {
+    selectedWorkspace = response.workspaces[0];
+  } else {
+    console.log(chalk4.yellow(`
+Found ${response.workspaces.length} workspaces matching "${workspaceName}":`));
+    const selectResponse = await prompts({
+      type: "select",
+      name: "workspaceId",
+      message: "Select a workspace:",
+      choices: response.workspaces.map((ws) => ({
+        title: `${ws.name} (${ws.status || "unknown"})`,
+        value: ws.id,
+        description: `Status: ${ws.status || "unknown"}`
+      }))
+    });
+    if (!selectResponse.workspaceId) {
+      throw new Error("Workspace selection cancelled.");
+    }
+    selectedWorkspace = response.workspaces.find((ws) => ws.id === selectResponse.workspaceId);
+  }
+  console.log(chalk4.green(`
+\u2713 Selected workspace: ${selectedWorkspace.name}`));
+  console.log(chalk4.gray(`  Status: ${selectedWorkspace.status || "unknown"}`));
+  if (selectedWorkspace.status === "sleeping") {
+    throw new Error(
+      "Workspace is currently sleeping. Wake it using `replicas app` (press w on a sleeping workspace) or visit https://replicas.dev"
+    );
+  }
+  console.log(chalk4.blue("\nRequesting SSH access token..."));
+  const tokenResponse = await orgAuthenticatedFetch(
+    `/v1/workspaces/${selectedWorkspace.id}/ssh-token`,
+    { method: "POST" }
+  );
+  console.log(chalk4.green("\u2713 SSH token received"));
+  let repoName = null;
+  if (isInsideGitRepo()) {
+    try {
+      repoName = getGitRepoName();
+    } catch {
+    }
+  }
+  return {
+    workspace: selectedWorkspace,
+    sshToken: tokenResponse.token,
+    sshHost: tokenResponse.host,
+    repoName
+  };
+}
+
+// src/commands/connect.ts
+async function connectCommand(workspaceName) {
+  if (!isAuthenticated()) {
+    console.log(chalk5.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const { workspace, sshToken, sshHost } = await prepareWorkspaceConnection(workspaceName);
+    console.log(chalk5.blue(`
+Connecting to ${workspace.name}...`));
+    const sshCommand = `ssh ${sshToken}@${sshHost}`;
+    console.log(chalk5.gray(`SSH command: ${sshCommand}`));
+    console.log(chalk5.gray("\nPress Ctrl+D to disconnect.\n"));
+    await connectSSH(sshToken, sshHost);
+    console.log(chalk5.green("\n\u2713 Disconnected from workspace.\n"));
+  } catch (error) {
+    console.error(chalk5.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/code.ts
+import chalk6 from "chalk";
+import { spawn as spawn2 } from "child_process";
+
+// src/lib/ssh-config.ts
+import fs from "fs";
+import path2 from "path";
+import os from "os";
+var SSH_CONFIG_PATH = path2.join(os.homedir(), ".ssh", "config");
+var REPLICAS_MARKER_START = "# === REPLICAS CLI MANAGED ENTRY START ===";
+var REPLICAS_MARKER_END = "# === REPLICAS CLI MANAGED ENTRY END ===";
+function ensureSSHDir() {
+  const sshDir = path2.join(os.homedir(), ".ssh");
+  if (!fs.existsSync(sshDir)) {
+    fs.mkdirSync(sshDir, { recursive: true, mode: 448 });
+  }
+}
+function readSSHConfig() {
+  ensureSSHDir();
+  if (!fs.existsSync(SSH_CONFIG_PATH)) {
+    return "";
+  }
+  return fs.readFileSync(SSH_CONFIG_PATH, "utf-8");
+}
+function writeSSHConfig(content) {
+  ensureSSHDir();
+  fs.writeFileSync(SSH_CONFIG_PATH, content, { mode: 384 });
+}
+function generateConfigBlock(entry) {
+  const lines = [
+    REPLICAS_MARKER_START,
+    `Host ${entry.host}`,
+    `  HostName ${entry.hostname}`,
+    `  User ${entry.user}`,
+    `  StrictHostKeyChecking no`,
+    `  UserKnownHostsFile /dev/null`
+  ];
+  lines.push(REPLICAS_MARKER_END);
+  return lines.join("\n");
+}
+function addOrUpdateSSHConfigEntry(entry) {
+  let config2 = readSSHConfig();
+  const lines = config2.split("\n");
+  const result = [];
+  let inTargetBlock = false;
+  for (const line of lines) {
+    if (line.trim() === REPLICAS_MARKER_START) {
+      const nextLines = lines.slice(lines.indexOf(line) + 1, lines.indexOf(line) + 3);
+      const hostLine = nextLines.find((l) => l.trim().startsWith("Host "));
+      if (hostLine && hostLine.includes(entry.host)) {
+        inTargetBlock = true;
+        continue;
+      }
+      result.push(line);
+      continue;
+    }
+    if (line.trim() === REPLICAS_MARKER_END) {
+      if (inTargetBlock) {
+        inTargetBlock = false;
+        continue;
+      }
+      result.push(line);
+      continue;
+    }
+    if (inTargetBlock) {
+      continue;
+    }
+    result.push(line);
+  }
+  config2 = result.join("\n");
+  const newEntry = generateConfigBlock(entry);
+  let finalConfig = config2.trim();
+  if (finalConfig.length > 0) {
+    finalConfig += "\n\n";
+  }
+  finalConfig += newEntry + "\n";
+  writeSSHConfig(finalConfig);
+}
+function getWorkspaceHostAlias(workspaceName) {
+  return `replicas-${workspaceName.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+}
+
+// src/commands/code.ts
+async function codeCommand(workspaceName) {
+  if (!isAuthenticated()) {
+    console.log(chalk6.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const { workspace, sshToken, sshHost, repoName } = await prepareWorkspaceConnection(workspaceName);
+    const hostAlias = getWorkspaceHostAlias(workspace.name);
+    console.log(chalk6.blue("\nConfiguring SSH connection..."));
+    addOrUpdateSSHConfigEntry({
+      host: hostAlias,
+      hostname: sshHost,
+      user: sshToken
+    });
+    console.log(chalk6.green(`\u2713 SSH config entry created: ${hostAlias}`));
+    const remotePath = repoName ? `${SANDBOX_PATHS.WORKSPACES_DIR}/${repoName}` : SANDBOX_PATHS.HOME_DIR;
+    const ideCommand = getIdeCommand();
+    const fullCommand = `${ideCommand} --remote ssh-remote+${hostAlias} ${remotePath}`;
+    console.log(chalk6.blue(`
+Opening ${ideCommand} for workspace ${workspace.name}...`));
+    console.log(chalk6.gray(`Command: ${fullCommand}`));
+    console.log(chalk6.yellow(`
+Note: SSH tokens expire after 3 hours. Run this command again to refresh.`));
+    const ide = spawn2(ideCommand, [
+      "--remote",
+      `ssh-remote+${hostAlias}`,
+      remotePath
+    ], {
+      stdio: "inherit",
+      detached: false
+    });
+    ide.on("error", (error) => {
+      console.error(chalk6.red(`
+Failed to launch ${ideCommand}: ${error.message}`));
+      console.log(chalk6.yellow(`
+Make sure ${ideCommand} is installed and available in your PATH.`));
+      console.log(chalk6.gray(`You can configure a different IDE with: replicas config set ide <command>`));
+      process.exit(1);
+    });
+    ide.on("close", (code) => {
+      if (code === 0) {
+        console.log(chalk6.green(`
+\u2713 ${ideCommand} closed successfully.
+`));
+      }
+    });
+  } catch (error) {
+    console.error(chalk6.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/org.ts
+import chalk7 from "chalk";
+import prompts2 from "prompts";
+async function orgCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk7.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const currentOrgId = getOrganizationId();
+    const organizations = await fetchOrganizations();
+    if (!currentOrgId) {
+      console.log(chalk7.yellow("No organization selected."));
+      console.log(chalk7.gray('Run "replicas org switch" to select an organization.\n'));
+      return;
+    }
+    const currentOrg = organizations.find((org2) => org2.id === currentOrgId);
+    if (!currentOrg) {
+      console.log(chalk7.yellow(`Current organization ID (${currentOrgId}) not found.`));
+      console.log(chalk7.gray('Run "replicas org switch" to select a new organization.\n'));
+      return;
+    }
+    console.log(chalk7.green("\nCurrent organization:"));
+    console.log(chalk7.gray(`  Name: ${currentOrg.name}`));
+    console.log(chalk7.gray(`  ID: ${currentOrg.id}
+`));
+  } catch (error) {
+    console.error(chalk7.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function orgSwitchCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk7.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const organizations = await fetchOrganizations();
+    if (organizations.length === 0) {
+      console.log(chalk7.yellow("You are not a member of any organization."));
+      console.log(chalk7.gray("Please contact support.\n"));
+      return;
+    }
+    if (organizations.length === 1) {
+      await setActiveOrganization(organizations[0].id);
+      console.log(chalk7.green(`
+\u2713 Organization set to: ${organizations[0].name}
+`));
+      return;
+    }
+    const currentOrgId = getOrganizationId();
+    const response = await prompts2({
+      type: "select",
+      name: "organizationId",
+      message: "Select an organization:",
+      choices: organizations.map((org2) => ({
+        title: `${org2.name}${org2.id === currentOrgId ? " (current)" : ""}`,
+        value: org2.id,
+        description: org2.id
+      })),
+      initial: organizations.findIndex((org2) => org2.id === currentOrgId)
+    });
+    if (!response.organizationId) {
+      console.log(chalk7.yellow("\nCancelled."));
+      return;
+    }
+    await setActiveOrganization(response.organizationId);
+    const selectedOrg = organizations.find((org2) => org2.id === response.organizationId);
+    console.log(chalk7.green(`
+\u2713 Switched to organization: ${selectedOrg?.name}
+`));
+  } catch (error) {
+    console.error(chalk7.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/config.ts
+import chalk8 from "chalk";
+async function configGetCommand(key) {
+  if (!isAuthenticated()) {
+    console.log(chalk8.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    if (key === "ide") {
+      const ideCommand = getIdeCommand();
+      console.log(chalk8.green(`
+IDE command: ${ideCommand}
+`));
+    } else {
+      console.log(chalk8.red(`Unknown config key: ${key}`));
+      console.log(chalk8.gray("Available keys: ide"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function configSetCommand(key, value) {
+  if (!isAuthenticated()) {
+    console.log(chalk8.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    if (key === "ide") {
+      setIdeCommand(value);
+      console.log(chalk8.green(`
+\u2713 IDE command set to: ${value}
+`));
+    } else {
+      console.log(chalk8.red(`Unknown config key: ${key}`));
+      console.log(chalk8.gray("Available keys: ide"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function configListCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk8.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const config2 = readConfig();
+    if (!config2) {
+      console.log(chalk8.red("No config found. Please login first."));
+      process.exit(1);
+    }
+    console.log(chalk8.green("\nCurrent configuration:"));
+    console.log(chalk8.gray(`  Organization ID: ${config2.organization_id || "(not set)"}`));
+    console.log(chalk8.gray(`  IDE command: ${config2.ide_command || "code (default)"}`));
+    console.log();
+  } catch (error) {
+    console.error(chalk8.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/codex-auth.ts
+import chalk9 from "chalk";
+
+// src/lib/codex-oauth.ts
+import http2 from "http";
+import { URL as URL3 } from "url";
+import open2 from "open";
+
+// src/lib/pkce.ts
+import { createHash, randomBytes } from "crypto";
+function generatePkceCodes() {
+  const verifierBytes = randomBytes(32);
+  const codeVerifier = verifierBytes.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  const hash = createHash("sha256");
+  hash.update(codeVerifier);
+  const codeChallenge = hash.digest("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return {
+    codeVerifier,
+    codeChallenge
+  };
+}
+function generateState2() {
+  return randomBytes(16).toString("hex");
+}
+
+// src/lib/codex-oauth.ts
+var CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var AUTHORIZATION_ENDPOINT = "https://auth.openai.com/oauth/authorize";
+var TOKEN_ENDPOINT = "https://auth.openai.com/oauth/token";
+var CALLBACK_PORT = 1455;
+var CALLBACK_PATH = "/auth/callback";
+var WEB_APP_URL2 = process.env.REPLICAS_WEB_URL || "https://replicas.dev";
+function buildAuthorizationUrl(codeChallenge, state) {
+  const redirectUri = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: CODEX_OAUTH_CLIENT_ID,
+    redirect_uri: redirectUri,
+    scope: "openid profile email offline_access",
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    state,
+    originator: "codex_cli_rs"
+  });
+  return `${AUTHORIZATION_ENDPOINT}?${params.toString()}`;
+}
+async function exchangeCodeForTokens(code, codeVerifier) {
+  const redirectUri = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+  const params = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: CODEX_OAUTH_CLIENT_ID,
+    code_verifier: codeVerifier
+  });
+  const response = await fetch(TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to exchange code for tokens: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  return {
+    idToken: data.id_token,
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token
+  };
+}
+function startCallbackServer(expectedState, codeVerifier) {
+  return new Promise((resolve, reject) => {
+    const server = http2.createServer(async (req, res) => {
+      try {
+        if (!req.url) {
+          res.writeHead(400);
+          res.end("Bad Request");
+          return;
+        }
+        const url = new URL3(req.url, `http://127.0.0.1:${CALLBACK_PORT}`);
+        if (url.pathname === CALLBACK_PATH) {
+          const code = url.searchParams.get("code");
+          const state = url.searchParams.get("state");
+          const error = url.searchParams.get("error");
+          const errorDescription = url.searchParams.get("error_description");
+          if (error) {
+            const errorMessage = encodeURIComponent(`${error}: ${errorDescription || "Unknown error"}`);
+            res.writeHead(302, { "Location": `${WEB_APP_URL2}/codex/oauth/error?message=${errorMessage}` });
+            res.end();
+            server.close();
+            reject(new Error(`OAuth error: ${error} - ${errorDescription}`));
+            return;
+          }
+          if (state !== expectedState) {
+            const errorMessage = encodeURIComponent("State parameter mismatch. Possible CSRF attack.");
+            res.writeHead(302, { "Location": `${WEB_APP_URL2}/codex/oauth/error?message=${errorMessage}` });
+            res.end();
+            server.close();
+            reject(new Error("State mismatch - possible CSRF attack"));
+            return;
+          }
+          if (!code) {
+            const errorMessage = encodeURIComponent("No authorization code received.");
+            res.writeHead(302, { "Location": `${WEB_APP_URL2}/codex/oauth/error?message=${errorMessage}` });
+            res.end();
+            server.close();
+            reject(new Error("No authorization code received"));
+            return;
+          }
+          try {
+            const tokens = await exchangeCodeForTokens(code, codeVerifier);
+            res.writeHead(302, { "Location": `${WEB_APP_URL2}/codex/oauth/success` });
+            res.end();
+            server.close();
+            resolve(tokens);
+          } catch (tokenError) {
+            const errorMessage = encodeURIComponent(tokenError instanceof Error ? tokenError.message : "Unknown error");
+            res.writeHead(302, { "Location": `${WEB_APP_URL2}/codex/oauth/error?message=${errorMessage}` });
+            res.end();
+            server.close();
+            reject(tokenError);
+          }
+        } else {
+          res.writeHead(404);
+          res.end("Not Found");
+        }
+      } catch (serverError) {
+        res.writeHead(500);
+        res.end("Internal Server Error");
+        server.close();
+        reject(serverError);
+      }
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${CALLBACK_PORT} is already in use. Please close any other OAuth flows and try again.`));
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1");
+  });
+}
+async function runCodexOAuthFlow() {
+  const pkce = generatePkceCodes();
+  const state = generateState2();
+  const authUrl = buildAuthorizationUrl(pkce.codeChallenge, state);
+  const tokensPromise = startCallbackServer(state, pkce.codeVerifier);
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  console.log("If the browser does not open automatically, visit:");
+  console.log(authUrl);
+  console.log();
+  try {
+    await open2(authUrl);
+  } catch (openError) {
+    console.warn("Failed to open browser automatically. Please open the URL manually.");
+  }
+  console.log("Waiting for authentication...");
+  const tokens = await tokensPromise;
+  console.log("\u2713 Successfully obtained Codex credentials");
+  return tokens;
+}
+
+// src/commands/codex-auth.ts
+async function codexAuthCommand(options = {}) {
+  const isUserScoped = options.user === true;
+  const scopeLabel = isUserScoped ? "personal" : "organization";
+  console.log(chalk9.cyan(`Authenticating with Codex (${scopeLabel})...
+`));
+  try {
+    const tokens = await runCodexOAuthFlow();
+    console.log(chalk9.gray("\nUploading credentials to Replicas..."));
+    const endpoint = isUserScoped ? "/v1/codex/user/credentials" : "/v1/codex/credentials";
+    const response = await orgAuthenticatedFetch(
+      endpoint,
+      {
+        method: "POST",
+        body: {
+          access_token: tokens.accessToken,
+          refresh_token: tokens.refreshToken,
+          id_token: tokens.idToken
+        }
+      }
+    );
+    if (response.success) {
+      console.log(chalk9.green("\n\u2713 Codex authentication complete!"));
+      if (response.email) {
+        console.log(chalk9.gray(`  Account: ${response.email}`));
+      }
+      if (response.planType) {
+        console.log(chalk9.gray(`  Plan: ${response.planType}`));
+      }
+      if (isUserScoped) {
+        console.log(chalk9.gray("\nYour personal Codex credentials have been saved.\n"));
+      } else {
+        console.log(chalk9.gray("\nYou can now use Codex in your workspaces.\n"));
+      }
+    } else {
+      throw new Error(response.error || "Failed to upload Codex credentials to Replicas");
+    }
+  } catch (error) {
+    console.log(chalk9.red("\n\u2717 Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// src/commands/claude-auth.ts
+import chalk11 from "chalk";
+
+// src/lib/claude-oauth.ts
+import open3 from "open";
+import readline from "readline";
+import chalk10 from "chalk";
+var DEFAULT_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var CLAUDE_CLIENT_ID = process.env.CLAUDE_OAUTH_CLIENT_ID || DEFAULT_CLIENT_ID;
+var AUTHORIZATION_ENDPOINT2 = "https://claude.ai/oauth/authorize";
+var TOKEN_ENDPOINT2 = "https://console.anthropic.com/v1/oauth/token";
+var REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+var SCOPES = "org:create_api_key user:profile user:inference";
+function buildAuthorizationUrl2(codeChallenge, state) {
+  const params = new URLSearchParams({
+    code: "true",
+    client_id: CLAUDE_CLIENT_ID,
+    response_type: "code",
+    redirect_uri: REDIRECT_URI,
+    scope: SCOPES,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    state
+  });
+  return `${AUTHORIZATION_ENDPOINT2}?${params.toString()}`;
+}
+async function promptForAuthorizationCode(instruction) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(instruction, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function parseUserInput(input) {
+  if (!input.includes("#") && !input.includes("code=")) {
+    return { code: input };
+  }
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    try {
+      const url = new URL(input);
+      const fragment = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
+      const params = new URLSearchParams(fragment);
+      const code2 = params.get("code") ?? void 0;
+      const state2 = params.get("state") ?? void 0;
+      if (code2) {
+        return { code: code2, state: state2 };
+      }
+    } catch {
+    }
+  }
+  const [code, state] = input.split("#");
+  return { code, state };
+}
+async function exchangeCodeForTokens2(code, state, expectedState, codeVerifier) {
+  if (state && state !== expectedState) {
+    throw new Error("State mismatch detected. Please restart the authentication flow.");
+  }
+  const payload = {
+    code,
+    state: state ?? expectedState,
+    grant_type: "authorization_code",
+    client_id: CLAUDE_CLIENT_ID,
+    redirect_uri: REDIRECT_URI,
+    code_verifier: codeVerifier
+  };
+  const response = await fetch(TOKEN_ENDPOINT2, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to exchange authorization code: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  const now = Date.now();
+  const expiresAt = new Date(now + data.expires_in * 1e3).toISOString();
+  const refreshTokenExpiresAt = data.refresh_token_expires_in ? new Date(now + data.refresh_token_expires_in * 1e3).toISOString() : void 0;
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    tokenType: data.token_type,
+    scope: data.scope,
+    expiresAt,
+    refreshTokenExpiresAt
+  };
+}
+async function runClaudeOAuthFlow() {
+  const pkce = generatePkceCodes();
+  const state = generateState2();
+  const authUrl = buildAuthorizationUrl2(pkce.codeChallenge, state);
+  console.log(chalk10.gray("We will open your browser so you can authenticate with Claude Code."));
+  console.log(chalk10.gray("If the browser does not open automatically, use the URL below:\n"));
+  console.log(authUrl);
+  console.log();
+  try {
+    await open3(authUrl);
+  } catch {
+    console.warn(chalk10.yellow("Failed to open browser automatically. Please copy and open the URL manually."));
+  }
+  console.log(chalk10.cyan("After completing authentication, copy the code shown on the success page."));
+  console.log(chalk10.cyan("You can paste either the full URL, or a value formatted as CODE#STATE.\n"));
+  const userInput = await promptForAuthorizationCode("Paste the authorization code (or URL) here: ");
+  if (!userInput) {
+    throw new Error("No authorization code provided.");
+  }
+  const { code, state: returnedState } = parseUserInput(userInput);
+  if (!code) {
+    throw new Error("Unable to parse authorization code. Please try again.");
+  }
+  console.log(chalk10.gray("\nExchanging authorization code for tokens..."));
+  const tokens = await exchangeCodeForTokens2(code, returnedState, state, pkce.codeVerifier);
+  console.log(chalk10.green("\u2713 Successfully obtained Claude credentials"));
+  return tokens;
+}
+
+// src/commands/claude-auth.ts
+async function claudeAuthCommand(options = {}) {
+  const isUserScoped = options.user === true;
+  const scopeLabel = isUserScoped ? "personal" : "organization";
+  console.log(chalk11.cyan(`Authenticating with Claude Code (${scopeLabel})...
+`));
+  try {
+    const tokens = await runClaudeOAuthFlow();
+    console.log(chalk11.gray("\nUploading credentials to Replicas..."));
+    const endpoint = isUserScoped ? "/v1/claude/user/credentials" : "/v1/claude/credentials";
+    const response = await orgAuthenticatedFetch(
+      endpoint,
+      {
+        method: "POST",
+        body: {
+          access_token: tokens.accessToken,
+          refresh_token: tokens.refreshToken,
+          token_type: tokens.tokenType,
+          scope: tokens.scope,
+          expires_at: tokens.expiresAt,
+          refresh_token_expires_at: tokens.refreshTokenExpiresAt
+        }
+      }
+    );
+    if (!response.success) {
+      throw new Error(response.error || "Failed to upload Claude credentials to Replicas");
+    }
+    console.log(chalk11.green("\n\u2713 Claude authentication complete!"));
+    if (response.email) {
+      console.log(chalk11.gray(`  Account: ${response.email}`));
+    }
+    if (response.planType) {
+      console.log(chalk11.gray(`  Plan: ${response.planType}`));
+    }
+    if (isUserScoped) {
+      console.log(chalk11.gray("\nYour personal Claude credentials have been saved.\n"));
+    } else {
+      console.log(chalk11.gray("\nYou can now use Claude Code in your workspaces.\n"));
+    }
+  } catch (error) {
+    console.log(chalk11.red("\n\u2717 Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import chalk12 from "chalk";
+import fs2 from "fs";
+import path3 from "path";
+function getDefaultConfig() {
+  return {
+    systemPrompt: "",
+    startHook: {
+      timeout: 3e5,
+      commands: []
+    }
+  };
+}
+function getDefaultYamlContent() {
+  return `# Replicas workspace configuration
+# See: https://docs.replicas.dev/features/workspaces/repository-configuration
+
+systemPrompt: |
+  Add custom instructions for coding agents here.
+
+startHook:
+  timeout: 300000
+  commands: []
+`;
+}
+function initCommand(options) {
+  const isYaml = options.yaml ?? false;
+  const targetFilename = isYaml ? "replicas.yaml" : "replicas.json";
+  const configPath = path3.join(process.cwd(), targetFilename);
+  for (const filename of REPLICAS_CONFIG_FILENAMES) {
+    const existingPath = path3.join(process.cwd(), filename);
+    if (fs2.existsSync(existingPath) && !options.force) {
+      console.log(
+        chalk12.yellow(
+          `${filename} already exists in this directory.`
+        )
+      );
+      console.log(chalk12.gray("Use --force to overwrite the existing file."));
+      return;
+    }
+  }
+  let configContent;
+  if (isYaml) {
+    configContent = getDefaultYamlContent();
+  } else {
+    const defaultConfig = getDefaultConfig();
+    configContent = JSON.stringify(defaultConfig, null, 2) + "\n";
+  }
+  try {
+    fs2.writeFileSync(configPath, configContent, "utf-8");
+    console.log(chalk12.green(`\u2713 Created ${targetFilename}`));
+    for (const filename of REPLICAS_CONFIG_FILENAMES) {
+      if (filename === targetFilename) break;
+      const higherPath = path3.join(process.cwd(), filename);
+      if (fs2.existsSync(higherPath)) {
+        console.log("");
+        console.log(
+          chalk12.yellow(
+            `Warning: ${filename} already exists and takes priority over ${targetFilename}.`
+          )
+        );
+        console.log(chalk12.gray(`Remove or rename ${filename} for ${targetFilename} to take effect.`));
+      }
+    }
+    console.log("");
+    console.log(chalk12.gray("Configuration options:"));
+    console.log(
+      chalk12.gray("  systemPrompt - Custom instructions for AI coding assistants")
+    );
+    console.log(
+      chalk12.gray("  startHook   - Commands to run on workspace startup")
+    );
+    if (!isYaml) {
+      console.log("");
+      console.log(chalk12.gray("Tip: Use --yaml for YAML format with multiline system prompt support."));
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to create ${targetFilename}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/lib/version-check.ts
+import chalk13 from "chalk";
+var MONOLITH_URL2 = process.env.REPLICAS_MONOLITH_URL || "https://api.replicas.dev";
+var VERSION_CHECK_TIMEOUT = 2e3;
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const num1 = parts1[i] || 0;
+    const num2 = parts2[i] || 0;
+    if (num1 > num2) return 1;
+    if (num1 < num2) return -1;
+  }
+  return 0;
+}
+async function checkForUpdates(currentVersion) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), VERSION_CHECK_TIMEOUT);
+    const response = await fetch(`${MONOLITH_URL2}/v1/cli/version`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) return;
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (compareVersions(latestVersion, currentVersion) > 0) {
+      console.error(chalk13.yellow(`
+Update available: ${currentVersion} \u2192 ${latestVersion}`));
+      console.error(chalk13.cyan(`Run: curl -fsSL https://replicas.dev/install.sh | bash
+`));
+    }
+  } catch {
+  }
+}
+
+// src/commands/replica.ts
+import chalk14 from "chalk";
+import prompts3 from "prompts";
+function formatDate(dateString) {
+  return new Date(dateString).toLocaleString();
+}
+function formatStatus(status) {
+  switch (status) {
+    case "active":
+      return chalk14.green(status);
+    case "sleeping":
+      return chalk14.gray(status);
+    default:
+      return status;
+  }
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength) + "...";
+}
+function formatDisplayMessage(message) {
+  const time = new Date(message.timestamp).toLocaleTimeString();
+  switch (message.type) {
+    case "user":
+      console.log(chalk14.blue(`
+[${time}] USER:`));
+      console.log(chalk14.white(`  ${truncate(message.content, 500)}`));
+      break;
+    case "agent":
+      console.log(chalk14.green(`
+[${time}] ASSISTANT:`));
+      console.log(chalk14.white(`  ${truncate(message.content, 500)}`));
+      break;
+    case "reasoning":
+      console.log(chalk14.gray(`
+[${time}] THINKING:`));
+      console.log(chalk14.gray(`  ${truncate(message.content, 300)}`));
+      break;
+    case "command":
+      console.log(chalk14.magenta(`
+[${time}] COMMAND:`));
+      console.log(chalk14.white(`  $ ${message.command}`));
+      if (message.output) {
+        console.log(chalk14.gray(`  ${truncate(message.output, 200)}`));
+      }
+      if (message.exitCode !== void 0) {
+        const exitColor = message.exitCode === 0 ? chalk14.green : chalk14.red;
+        console.log(exitColor(`  Exit code: ${message.exitCode}`));
+      }
+      break;
+    case "file_change":
+      console.log(chalk14.yellow(`
+[${time}] FILE CHANGES:`));
+      for (const change of message.changes) {
+        const icon = change.kind === "add" ? "+" : change.kind === "delete" ? "-" : "~";
+        const color = change.kind === "add" ? chalk14.green : change.kind === "delete" ? chalk14.red : chalk14.yellow;
+        console.log(color(`  ${icon} ${change.path}`));
+      }
+      break;
+    case "patch":
+      console.log(chalk14.yellow(`
+[${time}] PATCH:`));
+      for (const op of message.operations) {
+        const icon = op.action === "add" ? "+" : op.action === "delete" ? "-" : "~";
+        const color = op.action === "add" ? chalk14.green : op.action === "delete" ? chalk14.red : chalk14.yellow;
+        console.log(color(`  ${icon} ${op.path}`));
+      }
+      break;
+    case "tool_call":
+      console.log(chalk14.cyan(`
+[${time}] TOOL: ${message.tool}`));
+      if (message.output) {
+        console.log(chalk14.gray(`  ${truncate(message.output, 200)}`));
+      }
+      break;
+    case "web_search":
+      console.log(chalk14.cyan(`
+[${time}] WEB SEARCH:`));
+      console.log(chalk14.white(`  "${message.query}"`));
+      break;
+    case "todo_list":
+      console.log(chalk14.blue(`
+[${time}] PLAN:`));
+      for (const item of message.items) {
+        const icon = item.completed ? chalk14.green("[x]") : chalk14.gray("[ ]");
+        console.log(`  ${icon} ${item.text}`);
+      }
+      break;
+    case "subagent":
+      console.log(chalk14.magenta(`
+[${time}] SUBAGENT: ${message.description}`));
+      if (message.output) {
+        console.log(chalk14.gray(`  ${truncate(message.output, 200)}`));
+      }
+      break;
+    case "error":
+      console.log(chalk14.red(`
+[${time}] ERROR:`));
+      console.log(chalk14.red(`  ${message.message}`));
+      break;
+  }
+}
+async function replicaListCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk14.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const params = new URLSearchParams();
+    if (options.page) params.set("page", options.page);
+    if (options.limit) params.set("limit", options.limit);
+    const query = params.toString();
+    const response = await orgAuthenticatedFetch(
+      `/v1/replica${query ? "?" + query : ""}`
+    );
+    if (response.replicas.length === 0) {
+      console.log(chalk14.yellow("\nNo replicas found.\n"));
+      return;
+    }
+    console.log(chalk14.green(`
+Replicas (Page ${response.page} of ${response.totalPages}, Total: ${response.total}):
+`));
+    for (const replica of response.replicas) {
+      console.log(chalk14.white(`  ${replica.name}`));
+      console.log(chalk14.gray(`    ID: ${replica.id}`));
+      if (replica.repositories.length > 0) {
+        console.log(chalk14.gray(`    Repositories: ${replica.repositories.map((repository) => repository.name).join(", ")}`));
+      }
+      console.log(chalk14.gray(`    Status: ${formatStatus(replica.status)}`));
+      console.log(chalk14.gray(`    Created: ${formatDate(replica.created_at)}`));
+      if (replica.pull_requests && replica.pull_requests.length > 0) {
+        console.log(chalk14.gray(`    Pull Requests:`));
+        for (const pr of replica.pull_requests) {
+          console.log(chalk14.cyan(`      - ${pr.repository} #${pr.number}: ${pr.url}`));
+        }
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(chalk14.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function replicaGetCommand(id) {
+  if (!isAuthenticated()) {
+    console.log(chalk14.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const response = await orgAuthenticatedFetch(`/v1/replica/${id}`);
+    const replica = response.replica;
+    console.log(chalk14.green(`
+Replica: ${replica.name}
+`));
+    console.log(chalk14.gray(`  ID: ${replica.id}`));
+    if (replica.repositories.length > 0) {
+      console.log(chalk14.gray(`  Repositories: ${replica.repositories.map((repository) => repository.name).join(", ")}`));
+    }
+    console.log(chalk14.gray(`  Status: ${formatStatus(replica.status)}`));
+    console.log(chalk14.gray(`  Created: ${formatDate(replica.created_at)}`));
+    if (replica.waking) {
+      console.log(chalk14.yellow("\n  Workspace is waking from sleep. Retry in 30-90 seconds for full details.\n"));
+    } else {
+      if (replica.coding_agent) {
+        console.log(chalk14.gray(`  Coding Agent: ${replica.coding_agent}`));
+      }
+      if (replica.repository_statuses && replica.repository_statuses.length > 0) {
+        console.log(chalk14.gray("  Repository Statuses:"));
+        for (const repositoryStatus of replica.repository_statuses) {
+          const changeText = repositoryStatus.git_diff ? ` (${chalk14.green(`+${repositoryStatus.git_diff.added}`)} / ${chalk14.red(`-${repositoryStatus.git_diff.removed}`)})` : "";
+          console.log(chalk14.gray(`    - ${repositoryStatus.repository}: ${repositoryStatus.branch || "unknown"}${changeText}`));
+        }
+      }
+    }
+    if (replica.pull_requests && replica.pull_requests.length > 0) {
+      console.log(chalk14.gray(`  Pull Requests:`));
+      for (const pr of replica.pull_requests) {
+        console.log(chalk14.cyan(`    - ${pr.repository} #${pr.number}: ${pr.url}`));
+      }
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk14.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function replicaCreateCommand(name, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk14.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const repoResponse = await orgAuthenticatedFetch("/v1/repositories");
+    const repositories = repoResponse.repositories;
+    if (repositories.length === 0) {
+      console.log(chalk14.red("No repositories found. Please add a repository first."));
+      process.exit(1);
+    }
+    let replicaName = name;
+    let message = options.message;
+    let selectedRepositories = options.repositories?.split(",").map((repository) => repository.trim()).filter((repository) => repository.length > 0);
+    let codingAgent = options.agent;
+    if (replicaName && /\s/.test(replicaName)) {
+      console.log(chalk14.red("Replica name cannot contain spaces."));
+      process.exit(1);
+    }
+    if (!replicaName) {
+      const response2 = await prompts3({
+        type: "text",
+        name: "name",
+        message: "Enter replica name (without spaces):",
+        validate: (value) => {
+          if (!value.trim()) return "Name is required";
+          if (/\s/.test(value)) return "Name cannot contain spaces";
+          return true;
+        }
+      });
+      if (!response2.name) {
+        console.log(chalk14.yellow("\nCancelled."));
+        return;
+      }
+      replicaName = response2.name;
+    }
+    if (!selectedRepositories || selectedRepositories.length === 0) {
+      const response2 = await prompts3({
+        type: "multiselect",
+        name: "repositories",
+        message: "Select repositories:",
+        choices: repositories.map((repo) => ({
+          title: repo.name,
+          value: repo.name,
+          description: repo.url
+        })),
+        min: 1
+      });
+      if (!response2.repositories || response2.repositories.length === 0) {
+        console.log(chalk14.yellow("\nCancelled."));
+        return;
+      }
+      selectedRepositories = response2.repositories;
+    }
+    if (!message) {
+      const response2 = await prompts3({
+        type: "text",
+        name: "message",
+        message: "Enter initial message for the replica:",
+        validate: (value) => value.trim() ? true : "Message is required"
+      });
+      if (!response2.message) {
+        console.log(chalk14.yellow("\nCancelled."));
+        return;
+      }
+      message = response2.message;
+    }
+    if (!codingAgent) {
+      const response2 = await prompts3({
+        type: "select",
+        name: "agent",
+        message: "Select coding agent:",
+        choices: [
+          { title: "Claude", value: "claude" },
+          { title: "Codex", value: "codex" }
+        ],
+        initial: 0
+      });
+      if (!response2.agent) {
+        console.log(chalk14.yellow("\nCancelled."));
+        return;
+      }
+      codingAgent = response2.agent;
+    }
+    if (!codingAgent || !["claude", "codex"].includes(codingAgent)) {
+      console.log(chalk14.red(`Invalid coding agent: ${codingAgent}. Must be one of: claude, codex`));
+      process.exit(1);
+    }
+    const body = {
+      name: replicaName,
+      message,
+      repositories: selectedRepositories,
+      coding_agent: codingAgent
+    };
+    console.log(chalk14.gray("\nCreating replica..."));
+    const response = await orgAuthenticatedFetch("/v1/replica", {
+      method: "POST",
+      body
+    });
+    const replica = response.replica;
+    console.log(chalk14.green(`
+Created replica: ${replica.name}`));
+    console.log(chalk14.gray(`  ID: ${replica.id}`));
+    console.log(chalk14.gray(`  Status: ${formatStatus(replica.status)}`));
+    if (replica.repositories.length > 0) {
+      console.log(chalk14.gray(`  Repositories: ${replica.repositories.map((repository) => repository.name).join(", ")}`));
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk14.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function replicaSendCommand(id, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk14.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    let message = options.message;
+    if (!message) {
+      const response2 = await prompts3({
+        type: "text",
+        name: "message",
+        message: "Enter message to send:",
+        validate: (value) => value.trim() ? true : "Message is required"
+      });
+      if (!response2.message) {
+        console.log(chalk14.yellow("\nCancelled."));
+        return;
+      }
+      message = response2.message;
+    }
+    const body = {
+      message
+    };
+    if (options.agent) {
+      if (!["claude", "codex"].includes(options.agent)) {
+        console.log(chalk14.red(`Invalid coding agent: ${options.agent}. Must be one of: claude, codex`));
+        process.exit(1);
+      }
+      body.coding_agent = options.agent;
+    }
+    const response = await orgAuthenticatedFetch(
+      `/v1/replica/${id}/send`,
+      {
+        method: "POST",
+        body
+      }
+    );
+    const statusColor = response.status === "sent" ? chalk14.green : chalk14.yellow;
+    console.log(statusColor(`
+Message ${response.status}`));
+    if (response.position !== void 0 && response.position > 0) {
+      console.log(chalk14.gray(`  Queue position: ${response.position}`));
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk14.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function replicaDeleteCommand(id, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk14.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    if (!options.force) {
+      const response = await prompts3({
+        type: "confirm",
+        name: "confirm",
+        message: `Are you sure you want to delete replica ${id}?`,
+        initial: false
+      });
+      if (!response.confirm) {
+        console.log(chalk14.yellow("\nCancelled."));
+        return;
+      }
+    }
+    await orgAuthenticatedFetch(`/v1/replica/${id}`, {
+      method: "DELETE"
+    });
+    console.log(chalk14.green(`
+Replica ${id} deleted.
+`));
+  } catch (error) {
+    console.error(chalk14.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+async function replicaReadCommand(id, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk14.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit);
+    if (options.offset) params.set("offset", options.offset);
+    const query = params.toString();
+    const response = await orgAuthenticatedFetch(
+      `/v1/replica/${id}/read${query ? "?" + query : ""}`
+    );
+    if (response.waking) {
+      console.log(chalk14.yellow("\nWorkspace is waking from sleep. Retry in 30-90 seconds.\n"));
+      return;
+    }
+    console.log(chalk14.green(`
+Conversation History
+`));
+    if (response.coding_agent) {
+      console.log(chalk14.gray(`  Agent: ${response.coding_agent}`));
+    }
+    if (response.thread_id) {
+      console.log(chalk14.gray(`  Thread ID: ${response.thread_id}`));
+    }
+    console.log(chalk14.gray(`  Total Events: ${response.total}`));
+    console.log(chalk14.gray(`  Showing: ${response.events.length} events`));
+    if (response.hasMore) {
+      console.log(chalk14.gray(`  Has More: yes (use --offset to paginate)`));
+    }
+    console.log();
+    if (response.events.length === 0) {
+      console.log(chalk14.yellow("  No events found.\n"));
+      return;
+    }
+    console.log(chalk14.gray("-".repeat(60)));
+    const agentType = response.coding_agent || "claude";
+    const displayMessages = parseAgentEvents(response.events, agentType);
+    for (const message of displayMessages) {
+      formatDisplayMessage(message);
+    }
+    console.log(chalk14.gray("\n" + "-".repeat(60)));
+    console.log();
+  } catch (error) {
+    console.error(chalk14.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/repositories.ts
+import chalk15 from "chalk";
+function formatDate2(dateString) {
+  return new Date(dateString).toLocaleString();
+}
+async function repositoriesListCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk15.red('Not logged in. Please run "replicas login" first.'));
+    process.exit(1);
+  }
+  try {
+    const response = await orgAuthenticatedFetch("/v1/repositories");
+    if (response.repositories.length === 0) {
+      console.log(chalk15.yellow("\nNo repositories found.\n"));
+      return;
+    }
+    console.log(chalk15.green(`
+Repositories (${response.repositories.length}):
+`));
+    for (const repo of response.repositories) {
+      console.log(chalk15.white(`  ${repo.name}`));
+      console.log(chalk15.gray(`    URL: ${repo.url}`));
+      console.log(chalk15.gray(`    Default Branch: ${repo.default_branch}`));
+      console.log(chalk15.gray(`    Created: ${formatDate2(repo.created_at)}`));
+      if (repo.github_repository_id) {
+        console.log(chalk15.gray(`    GitHub ID: ${repo.github_repository_id}`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(chalk15.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/preview.ts
+import chalk16 from "chalk";
+
+// src/lib/agent-api.ts
+var MONOLITH_URL3 = process.env.MONOLITH_URL || process.env.REPLICAS_MONOLITH_URL || "https://api.replicas.dev";
+var ENGINE_PORT = process.env.REPLICAS_ENGINE_PORT || "3737";
+async function agentFetch(path4, options) {
+  const config2 = readAgentConfig();
+  if (!config2) {
+    throw new Error("Agent mode config not found");
+  }
+  const headers = {
+    "Authorization": `Bearer ${config2.engine_secret}`,
+    "X-Workspace-Id": config2.workspace_id,
+    "Content-Type": "application/json",
+    ...options?.headers || {}
+  };
+  const response = await fetch(`${MONOLITH_URL3}${path4}`, {
+    ...options,
+    headers,
+    body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Request failed" }));
+    throw new Error(error.error || `Request failed with status ${response.status}`);
+  }
+  return response.json();
+}
+async function engineFetch(path4, options) {
+  const config2 = readAgentConfig();
+  if (!config2) {
+    throw new Error("Agent mode config not found");
+  }
+  const headers = {
+    "X-Replicas-Engine-Secret": config2.engine_secret,
+    "Content-Type": "application/json",
+    ...options?.headers || {}
+  };
+  const response = await fetch(`http://localhost:${ENGINE_PORT}${path4}`, {
+    ...options,
+    headers,
+    body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Request failed" }));
+    throw new Error(error.error || `Request failed with status ${response.status}`);
+  }
+  return response.json();
+}
+
+// src/commands/preview.ts
+async function previewCreateCommand(port, options) {
+  const portNum = parseInt(port, 10);
+  if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+    throw new Error("Port must be a number between 1 and 65535");
+  }
+  if (isAgentMode()) {
+    const result = await agentFetch("/v1/previews", {
+      method: "POST",
+      body: { port: portNum, authenticated: options.authenticated ?? false }
+    });
+    console.log(result.preview.publicUrl);
+  } else {
+    throw new Error("In human mode, use: replicas preview add <workspaceId> --port <port>");
+  }
+}
+async function previewListCommand(workspaceId) {
+  if (isAgentMode()) {
+    const result = await engineFetch("/previews");
+    if (result.previews.length === 0) {
+      console.log("No active previews");
+      return;
+    }
+    for (const preview2 of result.previews) {
+      console.log(`${preview2.port} -> ${preview2.publicUrl}`);
+    }
+  } else {
+    if (!workspaceId) {
+      throw new Error("Workspace ID is required: replicas preview list <workspaceId>");
+    }
+    const result = await orgAuthenticatedFetch(
+      `/v1/workspaces/${workspaceId}/previews`
+    );
+    if (result.previews.length === 0) {
+      console.log(chalk16.dim("No active previews"));
+      return;
+    }
+    for (const preview2 of result.previews) {
+      console.log(`  ${chalk16.cyan(String(preview2.port))} \u2192 ${chalk16.underline(preview2.publicUrl)}`);
+    }
+  }
+}
+async function previewAddCommand(workspaceId, options) {
+  const portNum = parseInt(options.port, 10);
+  if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+    throw new Error("Port must be a number between 1 and 65535");
+  }
+  const result = await orgAuthenticatedFetch(
+    `/v1/workspaces/${workspaceId}/previews`,
+    {
+      method: "POST",
+      body: { port: portNum, authenticated: options.authenticated ?? false }
+    }
+  );
+  console.log(chalk16.green(`Preview created: ${result.preview.publicUrl}`));
+}
+
+// src/commands/interactive.ts
+import chalk17 from "chalk";
+async function interactiveCommand() {
+  if (!isAuthenticated()) {
+    throw new Error(
+      'Not authenticated. Please run "replicas login" first.'
+    );
+  }
+  const organizationId = getOrganizationId();
+  if (!organizationId) {
+    throw new Error(
+      'No organization selected. Please run "replicas org switch" to select an organization.'
+    );
+  }
+  console.log(chalk17.gray("Starting interactive mode..."));
+  const { launchInteractive } = await import("./interactive-EQDMW2E3.mjs");
+  await launchInteractive();
+}
+
+// src/index.ts
+var CLI_VERSION = "0.2.41";
+var program = new Command();
+program.name("replicas").description("CLI for managing Replicas workspaces").version(CLI_VERSION);
+program.command("login").description("Authenticate with your Replicas account").action(async () => {
+  try {
+    await loginCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("init").description("Create a replicas.json or replicas.yaml configuration file").option("-f, --force", "Overwrite existing config file").option("-y, --yaml", "Create replicas.yaml instead of replicas.json").action((options) => {
+  try {
+    initCommand(options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("logout").description("Clear stored credentials").action(() => {
+  try {
+    logoutCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("whoami").description("Display current authenticated user").action(async () => {
+  try {
+    await whoamiCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("codex-auth").description("Authenticate Replicas with your Codex credentials").option("-u, --user", "Store credentials for your personal account").action(async (options) => {
+  try {
+    await codexAuthCommand(options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("claude-auth").description("Authenticate Replicas with your Claude Code credentials").option("-u, --user", "Store credentials for your personal account").action(async (options) => {
+  try {
+    await claudeAuthCommand(options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+var org = program.command("org").description("Manage organizations");
+org.command("switch").description("Switch to a different organization").action(async () => {
+  try {
+    await orgSwitchCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+org.action(async () => {
+  try {
+    await orgCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("connect <workspace-name>").description("Connect to a workspace via SSH").action(async (workspaceName) => {
+  try {
+    await connectCommand(workspaceName);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("code <workspace-name>").description("Open a workspace in VSCode/Cursor via Remote SSH").action(async (workspaceName) => {
+  try {
+    await codeCommand(workspaceName);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+var config = program.command("config").description("Manage CLI configuration");
+config.command("get <key>").description("Get a configuration value").action(async (key) => {
+  try {
+    await configGetCommand(key);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+config.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+  try {
+    await configSetCommand(key, value);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+config.command("list").description("List all configuration values").action(async () => {
+  try {
+    await configListCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("list").description("List all replicas").option("-p, --page <page>", "Page number").option("-l, --limit <limit>", "Number of items per page").action(async (options) => {
+  try {
+    await replicaListCommand(options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("get <id>").description("Get replica details by ID").action(async (id) => {
+  try {
+    await replicaGetCommand(id);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("create [name]").description("Create a new replica").option("-m, --message <message>", "Initial message for the replica").option("-r, --repositories <repositories>", "Comma-separated repository names").option("-a, --agent <agent>", "Coding agent (claude, codex)").action(async (name, options) => {
+  try {
+    await replicaCreateCommand(name, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("send <id>").description("Send a message to a replica").option("-m, --message <message>", "Message to send").option("-a, --agent <agent>", "Coding agent (claude, codex)").action(async (id, options) => {
+  try {
+    await replicaSendCommand(id, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("delete <id>").description("Delete a replica").option("-f, --force", "Skip confirmation prompt").action(async (id, options) => {
+  try {
+    await replicaDeleteCommand(id, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("read <id>").description("Read conversation history of a replica").option("-l, --limit <limit>", "Maximum number of events to return").option("-o, --offset <offset>", "Number of events to skip from the end").action(async (id, options) => {
+  try {
+    await replicaReadCommand(id, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+var repos = program.command("repos").description("Manage repositories");
+repos.command("list").description("List all repositories").action(async () => {
+  try {
+    await repositoriesListCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+repos.action(async () => {
+  try {
+    await repositoriesListCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+program.command("interactive").alias("i").description("Launch the interactive terminal dashboard").action(async () => {
+  try {
+    await interactiveCommand();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+var preview = program.command("preview").description("Manage preview URLs");
+if (isAgentMode()) {
+  preview.command("create <port>").description("Register a preview port").option(
+    "-a, --authenticated",
+    "Require cookie authentication for this preview. Use for user-facing frontends (e.g. web apps) where you want only logged-in Replicas users to access the preview. Do not use for backend APIs that are called by frontend code, as the frontend cannot forward the auth cookie."
+  ).action(async (port, options) => {
+    try {
+      await previewCreateCommand(port, options);
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error: ${error.message}`);
+      }
+      process.exit(1);
+    }
+  });
+  preview.command("list").description("List active preview URLs").action(async () => {
+    try {
+      await previewListCommand();
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error: ${error.message}`);
+      }
+      process.exit(1);
+    }
+  });
+} else {
+  preview.command("add <workspaceId>").description("Register a preview port for a workspace").requiredOption("-p, --port <port>", "Port number to preview").option(
+    "-a, --authenticated",
+    "Require cookie authentication for this preview. Use for user-facing frontends (e.g. web apps) where you want only logged-in Replicas users to access the preview. Do not use for backend APIs that are called by frontend code, as the frontend cannot forward the auth cookie."
+  ).action(async (workspaceId, options) => {
+    try {
+      await previewAddCommand(workspaceId, options);
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+  preview.command("list [workspaceId]").description("List active preview URLs for a workspace").action(async (workspaceId) => {
+    try {
+      await previewListCommand(workspaceId);
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk18.red(`
+\u2717 ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+}
+if (isAgentMode()) {
+  const previewCmd = program.commands.find((cmd) => cmd.name() === "preview");
+  const cmds = program.commands;
+  cmds.length = 0;
+  if (previewCmd) {
+    cmds.push(previewCmd);
+  }
+}
+var versionCheckPromise = checkForUpdates(CLI_VERSION);
+program.parse();
+versionCheckPromise.catch(() => {
+});
+export {
+  CLI_VERSION
+};