codepiper 0.1.0

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

@@ -0,0 +1,127 @@
+import { daemonFetch, daemonJson, daemonPost } from "../lib/api";
+import { getOption, getPositional, getSocket } from "../lib/args";
+import { colors, formatDate, info, success, table } from "../lib/format";
+
+interface Workspace {
+  id: string;
+  name: string;
+  path: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+async function listWorkspaces(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const data = await daemonJson<{ workspaces: Workspace[] }>("/workspaces", { socket });
+
+  if (data.workspaces.length === 0) {
+    console.log("No workspaces found.");
+    return;
+  }
+
+  const rows = data.workspaces.map((w) => [
+    w.id.slice(0, 8),
+    w.name,
+    w.path,
+    formatDate(w.createdAt),
+  ]);
+
+  console.log(table(["ID", "NAME", "PATH", "CREATED"], rows));
+  console.log(`\n${colors.bold}Total:${colors.reset} ${data.workspaces.length} workspace(s)`);
+}
+
+async function getWorkspace(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("workspace ID is required");
+
+  const data = await daemonJson<{ workspace: Workspace }>(`/workspaces/${id}`, { socket });
+  const w = data.workspace;
+
+  console.log(`${colors.bold}Workspace ${w.id.slice(0, 8)}${colors.reset}`);
+  info("ID", w.id);
+  info("Name", w.name);
+  info("Path", w.path);
+  info("Created", formatDate(w.createdAt));
+  info("Updated", formatDate(w.updatedAt));
+}
+
+async function createWorkspace(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const name = getOption(args, "name");
+  const wsPath = getOption(args, "path");
+
+  if (!name) throw new Error("--name is required");
+  if (!wsPath) throw new Error("--path is required");
+
+  const body: Record<string, unknown> = { name, path: wsPath };
+
+  const data = await daemonPost<{ workspace: Workspace }>("/workspaces", body, { socket });
+
+  success(
+    `Workspace created: ${colors.bold}${data.workspace.name}${colors.reset} (ID: ${data.workspace.id})`
+  );
+}
+
+async function updateWorkspace(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("workspace ID is required");
+
+  const body: Record<string, unknown> = {};
+  const name = getOption(args, "name");
+  const wsPath = getOption(args, "path");
+
+  if (name) body.name = name;
+  if (wsPath) body.path = wsPath;
+
+  if (Object.keys(body).length === 0) {
+    throw new Error("at least one field to update is required (--name, --path)");
+  }
+
+  await daemonFetch(`/workspaces/${id}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    socket,
+  });
+
+  success(`Workspace #${id} updated`);
+}
+
+async function deleteWorkspace(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("workspace ID is required");
+
+  await daemonFetch(`/workspaces/${id}`, { method: "DELETE", socket });
+
+  success(`Workspace #${id} deleted`);
+}
+
+export async function runWorkspaceCommand(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 listWorkspaces(subArgs);
+    case "get":
+    case "show":
+      return getWorkspace(subArgs);
+    case "create":
+      return createWorkspace(subArgs);
+    case "update":
+      return updateWorkspace(subArgs);
+    case "delete":
+    case "rm":
+      return deleteWorkspace(subArgs);
+    default:
+      throw new Error(`Unknown workspace subcommand: ${subcommand}`);
+  }
+}

package/packages/cli/src/lib/api.ts

@@ -0,0 +1,78 @@
+const DEFAULT_SOCKET = "/tmp/codepiper.sock";
+
+export interface DaemonErrorBody {
+  error?: string;
+  [key: string]: unknown;
+}
+
+export async function readJson<T>(response: Response): Promise<T> {
+  return (await response.json()) as T;
+}
+
+export async function readErrorJson(response: Response): Promise<DaemonErrorBody> {
+  return (await response.json().catch(() => ({}))) as DaemonErrorBody;
+}
+
+export function responseErrorMessage(response: Response, data?: DaemonErrorBody): string {
+  return typeof data?.error === "string" && data.error.length > 0
+    ? data.error
+    : `HTTP ${response.status}: ${response.statusText}`;
+}
+
+export function getSocketPath(): string {
+  return process.env.CODEPIPER_SOCKET || DEFAULT_SOCKET;
+}
+
+export async function daemonFetch(
+  path: string,
+  opts?: RequestInit & { socket?: string }
+): Promise<Response> {
+  const socket = opts?.socket || getSocketPath();
+  const { socket: _, ...fetchOpts } = opts || {};
+
+  try {
+    const response = await fetch(`http://localhost${path}`, {
+      unix: socket,
+      ...fetchOpts,
+    });
+
+    if (!response.ok) {
+      const errorData = await readErrorJson(response);
+      throw new Error(responseErrorMessage(response, errorData));
+    }
+
+    return response;
+  } catch (error: any) {
+    if (error.code === "ENOENT" || error.message?.includes("ENOENT")) {
+      throw new Error(`Failed to connect to daemon at ${socket}. Is the daemon running?`);
+    }
+    throw error;
+  }
+}
+
+export async function daemonJson<T>(
+  path: string,
+  opts?: RequestInit & { socket?: string }
+): Promise<T> {
+  const response = await daemonFetch(path, opts);
+  return readJson<T>(response);
+}
+
+export async function daemonPost<T>(
+  path: string,
+  body?: unknown,
+  opts?: { socket?: string }
+): Promise<T> {
+  const request: RequestInit & { socket?: string } = {
+    method: "POST",
+  };
+  if (body !== undefined) {
+    request.headers = { "Content-Type": "application/json" };
+    request.body = JSON.stringify(body);
+  }
+  if (opts?.socket !== undefined) {
+    request.socket = opts.socket;
+  }
+
+  return daemonJson<T>(path, request);
+}

package/packages/cli/src/lib/args.ts

@@ -0,0 +1,72 @@
+export function getFlag(args: string[], flag: string): boolean {
+  return args.includes(`--${flag}`);
+}
+
+export function getOption(args: string[], flag: string): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === `--${flag}` && i + 1 < args.length) {
+      const value = args[i + 1];
+      if (value !== undefined) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function getOptionShort(args: string[], long: string, short?: string): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === `--${long}` || (short && args[i] === `-${short}`)) && i + 1 < args.length) {
+      const value = args[i + 1];
+      if (value !== undefined) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function getAllOptions(args: string[], flag: string): string[] {
+  const values: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === `--${flag}` && i + 1 < args.length) {
+      const value = args[i + 1];
+      if (value !== undefined) {
+        values.push(value);
+      }
+    }
+  }
+  return values;
+}
+
+export function getSubcommand(args: string[]): string | undefined {
+  for (const arg of args) {
+    if (!arg.startsWith("-")) return arg;
+  }
+  return undefined;
+}
+
+export function getPositional(args: string[], index: number): string | undefined {
+  let count = 0;
+  for (const arg of args) {
+    if (!arg.startsWith("-")) {
+      if (count === index) return arg;
+      count++;
+    }
+  }
+  return undefined;
+}
+
+export function getSocket(args: string[]): string {
+  return (
+    getOptionShort(args, "socket", "s") || process.env.CODEPIPER_SOCKET || "/tmp/codepiper.sock"
+  );
+}
+
+export function getRequiredValue(args: string[], index: number, flag: string): string {
+  const value = args[index + 1];
+  if (value === undefined) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}

package/packages/cli/src/lib/format.ts

@@ -0,0 +1,93 @@
+// ANSI color codes
+export const colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+};
+
+export function formatStatus(status: string): string {
+  switch (status) {
+    case "RUNNING":
+      return `${colors.green}${status}${colors.reset}`;
+    case "STARTING":
+      return `${colors.yellow}${status}${colors.reset}`;
+    case "STOPPED":
+      return `${colors.gray}${status}${colors.reset}`;
+    case "CRASHED":
+      return `${colors.red}${status}${colors.reset}`;
+    case "NEEDS_PERMISSION":
+      return `${colors.blue}${status}${colors.reset}`;
+    case "NEEDS_INPUT":
+      return `${colors.cyan}${status}${colors.reset}`;
+    default:
+      return status;
+  }
+}
+
+export function formatDate(iso: string): string {
+  return new Date(iso).toLocaleString();
+}
+
+export function truncate(str: string, maxLen: number): string {
+  if (str.length <= maxLen) return str;
+  return `...${str.slice(-(maxLen - 3))}`;
+}
+
+export function table(headers: string[], rows: string[][]): string {
+  // Calculate column widths
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length))
+  );
+
+  const lines: string[] = [];
+
+  // Header
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i] ?? h.length)).join("  ");
+  lines.push(`${colors.bold}${headerLine}${colors.reset}`);
+  lines.push(
+    colors.dim +
+      "─".repeat(widths.reduce((a, b) => a + b, 0) + (widths.length - 1) * 2) +
+      colors.reset
+  );
+
+  // Rows
+  for (const row of rows) {
+    const line = row
+      .map((cell, i) => {
+        const value = cell ?? "";
+        const stripped = stripAnsi(value);
+        const width = widths[i] ?? stripped.length;
+        const padding = width - stripped.length;
+        return value + " ".repeat(Math.max(0, padding));
+      })
+      .join("  ");
+    lines.push(line);
+  }
+
+  return lines.join("\n");
+}
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: stripping ANSI escape codes requires matching control chars
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+function stripAnsi(str: string): string {
+  return str.replace(ANSI_RE, "");
+}
+
+export function success(msg: string): void {
+  console.log(`${colors.green}✓${colors.reset} ${msg}`);
+}
+
+export function error(msg: string): void {
+  console.error(`${colors.red}✗${colors.reset} ${msg}`);
+}
+
+export function info(label: string, value: string): void {
+  console.log(`  ${colors.dim}${label}:${colors.reset} ${value}`);
+}