codepiper 0.1.0

package/packages/cli/src/commands/doctor.ts

@@ -0,0 +1,303 @@
+import { readJson } from "../lib/api";
+import { getRequiredValue } from "../lib/args";
+
+export interface DoctorOptions {
+  socket: string;
+}
+
+export interface ClaudeCheckResult {
+  installed: boolean;
+  path?: string;
+  version?: string;
+  error?: string;
+}
+
+export interface CodexCheckResult {
+  installed: boolean;
+  path?: string;
+  version?: string;
+  error?: string;
+}
+
+export interface TmuxCheckResult {
+  installed: boolean;
+  path?: string;
+  version?: string;
+  versionOk?: boolean;
+  error?: string;
+}
+
+export interface DaemonCheckResult {
+  running: boolean;
+  version?: string;
+  error?: string;
+}
+
+export interface PlatformCheckResult {
+  platform: string;
+  arch: string;
+  supported: boolean;
+}
+
+const SUPPORTED_PLATFORMS = new Set(["linux", "darwin"]);
+const SUPPORTED_ARCHITECTURES = new Set(["x64", "arm64"]);
+
+export function parseDoctorOptions(args: string[]): DoctorOptions {
+  let socket = "/tmp/codepiper.sock";
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === undefined) {
+      continue;
+    }
+
+    if (arg === "--socket" || arg === "-s") {
+      socket = getRequiredValue(args, i, arg);
+      i++;
+    }
+  }
+
+  return { socket };
+}
+
+async function readStream(stream: ReadableStream): Promise<string> {
+  const buffer = await new Response(stream).arrayBuffer();
+  return Buffer.from(buffer).toString("utf-8").trim();
+}
+
+/**
+ * Check whether a command exists in PATH and retrieve its version.
+ * Returns { path, version } on success, or { error } on failure.
+ */
+async function checkCommand(
+  name: string,
+  versionArgs: string[]
+): Promise<
+  { installed: true; path: string; version: string } | { installed: false; error: string }
+> {
+  try {
+    const whichProc = Bun.spawn(["which", name], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await whichProc.exited;
+
+    if ((await whichProc.exitCode) !== 0) {
+      return { installed: false, error: `${name} command not found in PATH` };
+    }
+
+    const cmdPath = await readStream(whichProc.stdout);
+
+    const versionProc = Bun.spawn(versionArgs, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await versionProc.exited;
+    const version = await readStream(versionProc.stdout);
+
+    return { installed: true, path: cmdPath, version };
+  } catch (error: any) {
+    return { installed: false, error: error.message };
+  }
+}
+
+export async function checkClaudeInstallation(): Promise<ClaudeCheckResult> {
+  return checkCommand("claude", ["claude", "-v"]);
+}
+
+export async function checkCodexInstallation(): Promise<CodexCheckResult> {
+  return checkCommand("codex", ["codex", "--version"]);
+}
+
+export async function checkTmux(): Promise<TmuxCheckResult> {
+  const result = await checkCommand("tmux", ["tmux", "-V"]);
+  if (!result.installed) return result;
+
+  // Parse version from "tmux 3.4" or "tmux 3.3a"
+  const match = result.version.match(/tmux\s+(\d+)\.(\d+)/);
+  const majorVersion = match?.[1];
+  const versionOk = majorVersion ? Number.parseInt(majorVersion, 10) >= 3 : false;
+
+  return { ...result, versionOk };
+}
+
+export async function checkDaemon(socket: string): Promise<DaemonCheckResult> {
+  try {
+    const response = await fetch("http://localhost/health", {
+      unix: socket,
+      method: "GET",
+    });
+
+    if (!response.ok) {
+      return {
+        running: false,
+        error: `HTTP ${response.status}: ${response.statusText}`,
+      };
+    }
+
+    const data = await readJson<{ version?: string }>(response);
+
+    const result: DaemonCheckResult = { running: true };
+    if (typeof data.version === "string" && data.version.length > 0) {
+      result.version = data.version;
+    }
+
+    return result;
+  } catch (error: any) {
+    return {
+      running: false,
+      error: error.message,
+    };
+  }
+}
+
+export function evaluatePlatform(platform: string, arch: string): PlatformCheckResult {
+  return {
+    platform,
+    arch,
+    supported: SUPPORTED_PLATFORMS.has(platform) && SUPPORTED_ARCHITECTURES.has(arch),
+  };
+}
+
+export function checkPlatform(): PlatformCheckResult {
+  return evaluatePlatform(process.platform, process.arch);
+}
+
+function checkEnvironment(): {
+  apiKeySet: boolean;
+  info: string;
+} {
+  const apiKeySet = !!process.env.ANTHROPIC_API_KEY;
+
+  if (apiKeySet) {
+    return {
+      apiKeySet: true,
+      info: 'ANTHROPIC_API_KEY detected. Sessions with billingMode "api" will use API billing. Default sessions will scrub this key and use subscription billing.',
+    };
+  }
+
+  return {
+    apiKeySet: false,
+    info: "ANTHROPIC_API_KEY not set. All sessions use subscription billing. Set it if you need API billing for automated use.",
+  };
+}
+
+function printCheckResult(
+  name: string,
+  status: "ok" | "warning" | "error",
+  message?: string
+): void {
+  const symbols = {
+    ok: "✓",
+    warning: "⚠",
+    error: "✗",
+  };
+
+  const colors = {
+    ok: "\x1b[32m", // green
+    warning: "\x1b[33m", // yellow
+    error: "\x1b[31m", // red
+    reset: "\x1b[0m",
+  };
+
+  const symbol = symbols[status];
+  const color = colors[status];
+
+  console.log(`${color}${symbol}${colors.reset} ${name}${message ? `: ${message}` : ""}`);
+}
+
+export async function runDoctorCommand(args: string[]): Promise<void> {
+  const options = parseDoctorOptions(args);
+
+  console.log("Running codepiper diagnostics...\n");
+
+  // Check platform
+  console.log("Checking platform...");
+  const platformCheck = checkPlatform();
+  const platformStatus = platformCheck.supported ? "ok" : "warning";
+  printCheckResult("Platform", platformStatus, `${platformCheck.platform}/${platformCheck.arch}`);
+  if (!platformCheck.supported) {
+    console.log(
+      "  CodePiper is tested on linux/darwin with x64/arm64 architectures.\n" +
+        "  Other platforms may work but are not currently in the supported target matrix."
+    );
+  }
+
+  // Check provider installations
+  console.log("Checking provider binaries...");
+  const claudeCheck = await checkClaudeInstallation();
+  const codexCheck = await checkCodexInstallation();
+  const hasAnyProvider = claudeCheck.installed || codexCheck.installed;
+
+  if (claudeCheck.installed) {
+    printCheckResult("Claude Code installed", "ok", `Found at ${claudeCheck.path}`);
+    if (claudeCheck.version) {
+      printCheckResult("Claude Code version", "ok", claudeCheck.version);
+    }
+  } else {
+    printCheckResult("Claude Code check", hasAnyProvider ? "warning" : "error", claudeCheck.error);
+    console.log("  Install Claude Code: https://code.claude.com/docs/en/installation");
+  }
+
+  if (codexCheck.installed) {
+    printCheckResult("Codex CLI installed", "ok", `Found at ${codexCheck.path}`);
+    if (codexCheck.version) {
+      printCheckResult("Codex CLI version", "ok", codexCheck.version);
+    }
+  } else {
+    printCheckResult("Codex CLI check", hasAnyProvider ? "warning" : "error", codexCheck.error);
+    console.log("  Install Codex CLI: https://developers.openai.com/codex");
+  }
+
+  if (!hasAnyProvider) {
+    console.log("\n  At least one provider binary is required to start sessions.\n");
+  } else {
+    console.log("");
+  }
+
+  // Check tmux
+  console.log("\nChecking tmux...");
+  const tmuxCheck = await checkTmux();
+
+  if (tmuxCheck.installed) {
+    printCheckResult("tmux installed", "ok", `Found at ${tmuxCheck.path}`);
+    if (tmuxCheck.version) {
+      const versionStatus = tmuxCheck.versionOk ? "ok" : "warning";
+      printCheckResult("tmux version", versionStatus, tmuxCheck.version);
+      if (!tmuxCheck.versionOk) {
+        console.log("\n  tmux 3.0+ is recommended for CodePiper sessions.\n");
+      }
+    }
+  } else {
+    printCheckResult("tmux check", "warning", tmuxCheck.error);
+    console.log("\n  Install tmux: https://github.com/tmux/tmux/wiki/Installing\n");
+  }
+
+  // Check environment
+  console.log("\nChecking environment...");
+  const envCheck = checkEnvironment();
+
+  printCheckResult("API key check", "ok", envCheck.info);
+
+  // Check daemon
+  console.log("\nChecking daemon...");
+  const daemonCheck = await checkDaemon(options.socket);
+
+  if (daemonCheck.running) {
+    printCheckResult("Daemon status", "ok", "Daemon is running");
+    if (daemonCheck.version) {
+      printCheckResult("Daemon version", "ok", daemonCheck.version);
+    }
+  } else {
+    printCheckResult("Daemon status", "error", "Daemon is not running");
+    console.log("\n  Start the daemon with:");
+    console.log("    codepiper daemon\n");
+  }
+
+  console.log("\nDiagnostics complete.");
+
+  // Exit with error code if critical checks failed
+  if (!(hasAnyProvider && daemonCheck.running)) {
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/env-set.ts

@@ -0,0 +1,162 @@
+import { daemonFetch, daemonJson, daemonPost } from "../lib/api";
+import { getOption, getPositional, getRequiredValue, getSocket } from "../lib/args";
+import { colors, formatDate, info, success, table } from "../lib/format";
+
+interface EnvSet {
+  id: string;
+  name: string;
+  description?: string;
+  maskedVars: Record<string, string>;
+  varCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+function parseVars(args: string[]): Record<string, string> {
+  const vars: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--var") {
+      const pair = getRequiredValue(args, i, "--var");
+      i++;
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx === -1) {
+        throw new Error(`Invalid variable format: ${pair}. Expected KEY=VALUE`);
+      }
+      vars[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+    }
+  }
+  return vars;
+}
+
+async function listEnvSets(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const data = await daemonJson<{ envSets: EnvSet[] }>("/env-sets", { socket });
+
+  if (data.envSets.length === 0) {
+    console.log("No environment sets found.");
+    return;
+  }
+
+  const rows = data.envSets.map((e) => [
+    String(e.id).slice(0, 8),
+    e.name,
+    String(e.varCount ?? Object.keys(e.maskedVars || {}).length),
+    e.description || `${colors.dim}-${colors.reset}`,
+    formatDate(e.createdAt),
+  ]);
+
+  console.log(table(["ID", "NAME", "VARS", "DESCRIPTION", "CREATED"], rows));
+  console.log(`\n${colors.bold}Total:${colors.reset} ${data.envSets.length} env set(s)`);
+}
+
+async function getEnvSet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("env-set ID is required");
+
+  const data = await daemonJson<{ envSet: EnvSet }>(`/env-sets/${id}`, { socket });
+  const e = data.envSet;
+
+  console.log(`${colors.bold}Env Set #${e.id}${colors.reset}`);
+  info("Name", e.name);
+  if (e.description) info("Description", e.description);
+  info("Created", formatDate(e.createdAt));
+  info("Updated", formatDate(e.updatedAt));
+
+  const vars = e.maskedVars || {};
+  const keys = Object.keys(vars);
+  if (keys.length > 0) {
+    console.log(`\n${colors.bold}Variables (masked):${colors.reset}`);
+    for (const key of keys) {
+      console.log(`  ${colors.cyan}${key}${colors.reset}=${vars[key]}`);
+    }
+  } else {
+    console.log(`\n${colors.dim}No variables defined.${colors.reset}`);
+  }
+}
+
+async function createEnvSet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const name = getOption(args, "name");
+  const description = getOption(args, "description");
+  const variables = parseVars(args);
+
+  if (!name) throw new Error("--name is required");
+  if (Object.keys(variables).length === 0) {
+    throw new Error("at least one --var KEY=VALUE is required");
+  }
+
+  const body: Record<string, unknown> = { name, vars: variables };
+  if (description) body.description = description;
+
+  const data = await daemonPost<{ envSet: EnvSet }>("/env-sets", body, { socket });
+
+  success(
+    `Env set created: ${colors.bold}${data.envSet.name}${colors.reset} (ID: ${data.envSet.id})`
+  );
+}
+
+async function updateEnvSet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("env-set ID is required");
+
+  const body: Record<string, unknown> = {};
+  const name = getOption(args, "name");
+  const description = getOption(args, "description");
+  const variables = parseVars(args);
+
+  if (name) body.name = name;
+  if (description) body.description = description;
+  if (Object.keys(variables).length > 0) body.vars = variables;
+
+  if (Object.keys(body).length === 0) {
+    throw new Error("at least one field to update is required (--name, --description, --var)");
+  }
+
+  await daemonFetch(`/env-sets/${id}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    socket,
+  });
+
+  success(`Env set #${id} updated`);
+}
+
+async function deleteEnvSet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("env-set ID is required");
+
+  await daemonFetch(`/env-sets/${id}`, { method: "DELETE", socket });
+
+  success(`Env set #${id} deleted`);
+}
+
+export async function runEnvSetCommand(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    throw new Error("subcommand required (list, get, create, update, delete)");
+  }
+
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      return listEnvSets(subArgs);
+    case "get":
+    case "show":
+      return getEnvSet(subArgs);
+    case "create":
+      return createEnvSet(subArgs);
+    case "update":
+      return updateEnvSet(subArgs);
+    case "delete":
+    case "rm":
+      return deleteEnvSet(subArgs);
+    default:
+      throw new Error(`Unknown env-set subcommand: ${subcommand}`);
+  }
+}