codepiper 0.1.0

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

@@ -0,0 +1,185 @@
+import { daemonFetch, daemonJson, daemonPost } from "../lib/api";
+import { getFlag, getOption, getPositional, getSocket } from "../lib/args";
+import { colors, formatDate, info, success, table } from "../lib/format";
+
+interface PolicySet {
+  id: string;
+  name: string;
+  description?: string;
+  isDefault: boolean;
+  createdAt: string;
+  updatedAt: string;
+  policies?: Array<{ id: string; name: string; enabled: boolean; priority: number }>;
+}
+
+async function listPolicySets(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const data = await daemonJson<{ policySets: PolicySet[] }>("/policy-sets", { socket });
+
+  if (data.policySets.length === 0) {
+    console.log("No policy sets found.");
+    return;
+  }
+
+  const rows = data.policySets.map((ps) => [
+    ps.id.slice(0, 8),
+    ps.name,
+    ps.isDefault ? `${colors.green}yes${colors.reset}` : "no",
+    ps.description || `${colors.dim}-${colors.reset}`,
+    formatDate(ps.createdAt),
+  ]);
+
+  console.log(table(["ID", "NAME", "DEFAULT", "DESCRIPTION", "CREATED"], rows));
+  console.log(`\n${colors.bold}Total:${colors.reset} ${data.policySets.length} policy set(s)`);
+}
+
+async function getPolicySet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy-set ID is required");
+
+  const data = await daemonJson<{ policySet: PolicySet }>(`/policy-sets/${id}`, { socket });
+  const ps = data.policySet;
+
+  console.log(`${colors.bold}Policy Set ${ps.id.slice(0, 8)}${colors.reset}`);
+  info("Name", ps.name);
+  if (ps.description) info("Description", ps.description);
+  info("Default", ps.isDefault ? `${colors.green}yes${colors.reset}` : "no");
+  info("Created", formatDate(ps.createdAt));
+  info("Updated", formatDate(ps.updatedAt));
+
+  if (ps.policies && ps.policies.length > 0) {
+    console.log(`\n${colors.bold}Policies:${colors.reset}`);
+    const rows = ps.policies.map((p) => [
+      p.id.slice(0, 8),
+      p.name,
+      p.enabled ? `${colors.green}yes${colors.reset}` : `${colors.gray}no${colors.reset}`,
+      String(p.priority),
+    ]);
+    console.log(table(["ID", "NAME", "ENABLED", "PRI"], rows));
+  } else {
+    console.log(`\n${colors.dim}No policies in this set.${colors.reset}`);
+  }
+}
+
+async function createPolicySet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const name = getOption(args, "name");
+  const description = getOption(args, "description");
+  const isDefault = getFlag(args, "default");
+
+  if (!name) throw new Error("--name is required");
+
+  const body: Record<string, unknown> = {
+    id: crypto.randomUUID(),
+    name,
+  };
+  if (description) body.description = description;
+  if (isDefault) body.isDefault = true;
+
+  const data = await daemonPost<{ policySet: PolicySet }>("/policy-sets", body, { socket });
+
+  success(
+    `Policy set created: ${colors.bold}${data.policySet.name}${colors.reset} (ID: ${data.policySet.id})`
+  );
+}
+
+async function updatePolicySet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy-set ID is required");
+
+  const body: Record<string, unknown> = {};
+  const name = getOption(args, "name");
+  const description = getOption(args, "description");
+  const isDefault = getFlag(args, "default");
+
+  if (name) body.name = name;
+  if (description) body.description = description;
+  if (isDefault) body.isDefault = true;
+
+  if (Object.keys(body).length === 0) {
+    throw new Error("at least one field to update is required (--name, --description, --default)");
+  }
+
+  await daemonFetch(`/policy-sets/${id}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    socket,
+  });
+
+  success(`Policy set #${id} updated`);
+}
+
+async function deletePolicySet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy-set ID is required");
+
+  await daemonFetch(`/policy-sets/${id}`, { method: "DELETE", socket });
+
+  success(`Policy set #${id} deleted`);
+}
+
+async function addPolicyToSet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const setId = getPositional(args, 0);
+  const policyId = getPositional(args, 1);
+
+  if (!setId) throw new Error("policy-set ID is required");
+  if (!policyId) throw new Error("policy ID is required");
+
+  await daemonPost(`/policy-sets/${setId}/policies`, { policyId }, { socket });
+
+  success(`Policy #${policyId} added to set #${setId}`);
+}
+
+async function removePolicyFromSet(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const setId = getPositional(args, 0);
+  const policyId = getPositional(args, 1);
+
+  if (!setId) throw new Error("policy-set ID is required");
+  if (!policyId) throw new Error("policy ID is required");
+
+  await daemonFetch(`/policy-sets/${setId}/policies/${policyId}`, {
+    method: "DELETE",
+    socket,
+  });
+
+  success(`Policy #${policyId} removed from set #${setId}`);
+}
+
+export async function runPolicySetCommand(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    throw new Error(
+      "subcommand required (list, get, create, update, delete, add-policy, remove-policy)"
+    );
+  }
+
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      return listPolicySets(subArgs);
+    case "get":
+    case "show":
+      return getPolicySet(subArgs);
+    case "create":
+      return createPolicySet(subArgs);
+    case "update":
+      return updatePolicySet(subArgs);
+    case "delete":
+    case "rm":
+      return deletePolicySet(subArgs);
+    case "add-policy":
+      return addPolicyToSet(subArgs);
+    case "remove-policy":
+      return removePolicyFromSet(subArgs);
+    default:
+      throw new Error(`Unknown policy-set subcommand: ${subcommand}`);
+  }
+}

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

@@ -0,0 +1,227 @@
+import { daemonFetch, daemonJson, daemonPost } from "../lib/api";
+import { getOption, getPositional, getSocket } from "../lib/args";
+import { colors, formatDate, info, success, table } from "../lib/format";
+
+interface Policy {
+  id: string;
+  name: string;
+  description?: string;
+  enabled: boolean;
+  priority: number;
+  sessionId: string | null;
+  rules: Array<Record<string, unknown>>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+async function listPolicies(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const sessionId = getOption(args, "session");
+
+  const params = sessionId ? `?sessionId=${sessionId}` : "";
+  const data = await daemonJson<{ policies: Policy[] }>(`/policies${params}`, { socket });
+
+  if (data.policies.length === 0) {
+    console.log("No policies found.");
+    return;
+  }
+
+  const rows = data.policies.map((p) => [
+    p.id.slice(0, 8),
+    p.name,
+    p.enabled ? `${colors.green}yes${colors.reset}` : `${colors.gray}no${colors.reset}`,
+    String(p.priority),
+    p.sessionId ? p.sessionId.slice(0, 8) : `${colors.dim}global${colors.reset}`,
+    formatDate(p.createdAt),
+  ]);
+
+  console.log(table(["ID", "NAME", "ENABLED", "PRI", "SCOPE", "CREATED"], rows));
+  console.log(`\n${colors.bold}Total:${colors.reset} ${data.policies.length} policy(ies)`);
+}
+
+async function getPolicy(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy ID is required");
+
+  const data = await daemonJson<{ policy: Policy }>(`/policies/${id}`, { socket });
+  const p = data.policy;
+
+  console.log(`${colors.bold}Policy ${p.id.slice(0, 8)}${colors.reset}`);
+  info("ID", p.id);
+  info("Name", p.name);
+  if (p.description) info("Description", p.description);
+  info(
+    "Enabled",
+    p.enabled ? `${colors.green}yes${colors.reset}` : `${colors.red}no${colors.reset}`
+  );
+  info("Priority", String(p.priority));
+  info("Scope", p.sessionId ? `session ${p.sessionId.slice(0, 8)}...` : "global");
+  info("Created", formatDate(p.createdAt));
+  info("Updated", formatDate(p.updatedAt));
+  console.log(`\n${colors.bold}Rules:${colors.reset}`);
+  console.log(JSON.stringify(p.rules, null, 2));
+}
+
+async function createPolicy(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const name = getOption(args, "name");
+  const rulesStr = getOption(args, "rules");
+  const priority = getOption(args, "priority");
+  const sessionId = getOption(args, "session");
+
+  if (!name) throw new Error("--name is required");
+  if (!rulesStr) throw new Error("--rules is required (JSON string)");
+
+  let rules: unknown;
+  try {
+    rules = JSON.parse(rulesStr);
+  } catch {
+    throw new Error("--rules must be valid JSON");
+  }
+
+  const body: Record<string, unknown> = {
+    id: crypto.randomUUID(),
+    name,
+    rules,
+    enabled: true,
+    priority: priority ? Number.parseInt(priority, 10) : 0,
+    sessionId: sessionId ?? null,
+  };
+
+  const data = await daemonPost<{ policy: Policy }>("/policies", body, { socket });
+
+  success(
+    `Policy created: ${colors.bold}${data.policy.name}${colors.reset} (ID: ${data.policy.id})`
+  );
+}
+
+async function updatePolicy(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy ID is required");
+
+  const body: Record<string, unknown> = {};
+  const name = getOption(args, "name");
+  const rulesStr = getOption(args, "rules");
+  const priority = getOption(args, "priority");
+  const enabled = getOption(args, "enabled");
+
+  if (name) body.name = name;
+  if (rulesStr) {
+    try {
+      body.rules = JSON.parse(rulesStr);
+    } catch {
+      throw new Error("--rules must be valid JSON");
+    }
+  }
+  if (priority) body.priority = Number.parseInt(priority, 10);
+  if (enabled !== undefined) body.enabled = enabled === "true";
+
+  if (Object.keys(body).length === 0) {
+    throw new Error(
+      "at least one field to update is required (--name, --rules, --priority, --enabled)"
+    );
+  }
+
+  await daemonFetch(`/policies/${id}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    socket,
+  });
+
+  success(`Policy #${id} updated`);
+}
+
+async function deletePolicy(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy ID is required");
+
+  await daemonFetch(`/policies/${id}`, { method: "DELETE", socket });
+
+  success(`Policy #${id} deleted`);
+}
+
+async function togglePolicy(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const id = getPositional(args, 0);
+  if (!id) throw new Error("policy ID is required");
+
+  // Get current state
+  const data = await daemonJson<{ policy: Policy }>(`/policies/${id}`, { socket });
+  const newEnabled = !data.policy.enabled;
+
+  await daemonFetch(`/policies/${id}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ enabled: newEnabled }),
+    socket,
+  });
+
+  const state = newEnabled
+    ? `${colors.green}enabled${colors.reset}`
+    : `${colors.red}disabled${colors.reset}`;
+  success(`Policy #${id} ${state}`);
+}
+
+async function defaultPolicyAction(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const action = getPositional(args, 0);
+
+  if (!action) {
+    // Show current default
+    const data = await daemonJson<{ settings: { defaultPolicyAction: string } }>(
+      "/settings/daemon",
+      { socket }
+    );
+    info("Default policy action", data.settings.defaultPolicyAction);
+    return;
+  }
+
+  if (action !== "ask" && action !== "deny") {
+    throw new Error('action must be "ask" or "deny"');
+  }
+
+  await daemonFetch("/settings/daemon", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ defaultPolicyAction: action }),
+    socket,
+  });
+
+  success(`Default policy action set to ${colors.bold}${action}${colors.reset}`);
+}
+
+export async function runPolicyCommand(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    throw new Error("subcommand required (list, get, create, update, delete, toggle, default)");
+  }
+
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      return listPolicies(subArgs);
+    case "get":
+    case "show":
+      return getPolicy(subArgs);
+    case "create":
+    case "add":
+      return createPolicy(subArgs);
+    case "update":
+      return updatePolicy(subArgs);
+    case "delete":
+    case "rm":
+      return deletePolicy(subArgs);
+    case "toggle":
+      return togglePolicy(subArgs);
+    case "default":
+      return defaultPolicyAction(subArgs);
+    default:
+      throw new Error(`Unknown policy subcommand: ${subcommand}`);
+  }
+}

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

@@ -0,0 +1,114 @@
+import { readErrorJson, readJson, responseErrorMessage } from "../lib/api";
+import { getRequiredValue } from "../lib/args";
+import { colors, table } from "../lib/format";
+
+type OutputFormat = "table" | "json";
+
+interface ProviderCapabilities {
+  nativeHooks: boolean;
+  supportsDangerousMode: boolean;
+  supportsModelSwitch: boolean;
+  supportsTranscriptTailing: boolean;
+  supportsTmuxAdoption: boolean;
+  policyChannel: "native-hooks" | "input-preflight" | "none";
+  metricsChannel: "transcript" | "pty" | "none";
+}
+
+interface ProviderInfo {
+  id: string;
+  label: string;
+  runtime: "tmux" | "pty";
+  capabilities: ProviderCapabilities;
+}
+
+export interface ProvidersOptions {
+  socket: string;
+  format: OutputFormat;
+}
+
+const VALID_FORMATS: OutputFormat[] = ["table", "json"];
+
+export function parseProvidersOptions(args: string[]): ProvidersOptions {
+  let socket = "/tmp/codepiper.sock";
+  let format: OutputFormat = "table";
+
+  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++;
+      continue;
+    }
+
+    if (arg === "--format" || arg === "-f") {
+      const formatValue = getRequiredValue(args, i, arg);
+      i++;
+      if (!VALID_FORMATS.includes(formatValue as OutputFormat)) {
+        throw new Error(
+          `Invalid format: ${formatValue}. Valid options: ${VALID_FORMATS.join(", ")}`
+        );
+      }
+      format = formatValue as OutputFormat;
+    }
+  }
+
+  return { socket, format };
+}
+
+export async function listProviders(options: ProvidersOptions): Promise<ProviderInfo[]> {
+  try {
+    const response = await fetch("http://localhost/providers", {
+      unix: options.socket,
+      method: "GET",
+    });
+
+    if (!response.ok) {
+      const errorData = await readErrorJson(response);
+      throw new Error(responseErrorMessage(response, errorData));
+    }
+
+    const data = await readJson<{ providers?: ProviderInfo[] }>(response);
+    return data.providers ?? [];
+  } catch (error: any) {
+    if (error.code === "ENOENT" || error.message?.includes("ENOENT")) {
+      throw new Error(`Failed to connect to daemon at ${options.socket}. Is the daemon running?`);
+    }
+    throw error;
+  }
+}
+
+function printProviderTable(providers: ProviderInfo[]): void {
+  if (providers.length === 0) {
+    console.log(`${colors.dim}No providers reported by daemon.${colors.reset}`);
+    return;
+  }
+
+  const rows = providers.map((provider) => [
+    provider.id,
+    provider.runtime,
+    provider.capabilities.nativeHooks ? "yes" : "no",
+    provider.capabilities.policyChannel,
+    provider.capabilities.metricsChannel,
+    provider.capabilities.supportsModelSwitch ? "yes" : "no",
+    provider.capabilities.supportsDangerousMode ? "yes" : "no",
+  ]);
+
+  console.log(`${colors.bold}Available Providers${colors.reset}\n`);
+  console.log(table(["ID", "RUNTIME", "HOOKS", "POLICY", "METRICS", "MODEL", "DANGEROUS"], rows));
+}
+
+export async function runProvidersCommand(args: string[]): Promise<void> {
+  const options = parseProvidersOptions(args);
+  const providers = await listProviders(options);
+
+  if (options.format === "json") {
+    console.log(JSON.stringify(providers, null, 2));
+    return;
+  }
+
+  printProviderTable(providers);
+}

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

@@ -0,0 +1,34 @@
+import { daemonPost } from "../lib/api";
+import { getSocket } from "../lib/args";
+import { colors, success } from "../lib/format";
+
+export async function runResizeCommand(args: string[]): Promise<void> {
+  const positionals = args.filter((a) => !a.startsWith("-"));
+
+  if (positionals.length < 3) {
+    throw new Error("Usage: codepiper resize <session-id> <cols> <rows>");
+  }
+
+  const sessionId = positionals[0];
+  const colsStr = positionals[1];
+  const rowsStr = positionals[2];
+
+  if (sessionId === undefined || colsStr === undefined || rowsStr === undefined) {
+    throw new Error("Usage: codepiper resize <session-id> <cols> <rows>");
+  }
+
+  const cols = Number.parseInt(colsStr, 10);
+  const rows = Number.parseInt(rowsStr, 10);
+
+  if (Number.isNaN(cols) || Number.isNaN(rows) || cols < 1 || rows < 1) {
+    throw new Error("cols and rows must be positive integers");
+  }
+
+  const socket = getSocket(args);
+
+  await daemonPost(`/sessions/${sessionId}/resize`, { cols, rows }, { socket });
+
+  success(
+    `Session ${colors.cyan}${sessionId.slice(0, 8)}...${colors.reset} resized to ${cols}x${rows}`
+  );
+}