codepiper 0.1.0

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "codepiper",
+  "version": "0.1.0",
+  "description": "CodePiper — Multi-session CLI orchestrator for Claude Code",
+  "bin": {
+    "codepiper": "./packages/cli/src/main.ts"
+  },
+  "files": [
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "LEGAL_NOTICE.md",
+    ".env.example",
+    "package.json",
+    "scripts/postinstall-link-workspaces.mjs",
+    "packages/cli/package.json",
+    "packages/cli/src/**/*.ts",
+    "!packages/cli/src/**/*.test.ts",
+    "packages/core/package.json",
+    "packages/core/src/**/*.ts",
+    "!packages/core/src/**/*.test.ts",
+    "packages/daemon/package.json",
+    "packages/daemon/src/**/*.ts",
+    "packages/daemon/src/**/*.sql",
+    "!packages/daemon/src/**/*.test.ts",
+    "!packages/daemon/src/**/*.example.ts",
+    "!packages/daemon/src/**/example.ts",
+    "!packages/daemon/src/**/demo.ts",
+    "packages/providers/claude-code/package.json",
+    "packages/providers/claude-code/src/**/*.ts",
+    "!packages/providers/claude-code/src/**/*.test.ts",
+    "packages/web/dist/**"
+  ],
+  "workspaces": [
+    "packages/*",
+    "packages/providers/*"
+  ],
+  "scripts": {
+    "daemon": "bun run packages/daemon/src/main.ts",
+    "daemon:web": "bun run packages/daemon/src/main.ts --web",
+    "build:web": "bun run --cwd packages/web build",
+    "dev:web": "bun run --cwd packages/web dev",
+    "cli": "bun run packages/cli/src/main.ts",
+    "test": "bun test",
+    "test:integration": "bun test --integration",
+    "typecheck": "bunx tsc -b tsconfig.json",
+    "typecheck:strict:daemon": "bunx tsc -p packages/daemon/tsconfig.strict.json --pretty false",
+    "typecheck:strict:provider": "bunx tsc -p packages/providers/claude-code/tsconfig.strict.json --pretty false",
+    "typecheck:strict": "bun run typecheck:strict:daemon && bun run typecheck:strict:provider",
+    "release:smoke": "bash scripts/release-smoke.sh",
+    "bench:ws-transport": "bun run scripts/bench/ws-transport-bench.ts",
+    "bench:ws-transport:artifact": "bun run scripts/bench/ws-transport-bench.ts --json --artifact-dir benchmarks/ws-transport",
+    "bench:ws-transport:bun-pty-prototype": "bun run scripts/bench/ws-transport-bench.ts --bun-pty-prototype",
+    "security:deps": "node scripts/security/check-deps.mjs",
+    "security:secrets": "node scripts/security/check-secrets.mjs",
+    "security:check": "bun run security:secrets && bun run security:deps",
+    "pack:check": "node scripts/check-packaging.mjs",
+    "pack:check:fast": "node scripts/check-packaging.mjs --skip-build",
+    "pack:smoke": "node scripts/pack-runtime-smoke.mjs",
+    "pack:smoke:fast": "node scripts/pack-runtime-smoke.mjs --skip-build",
+    "prepack": "node scripts/check-packaging.mjs --prepack",
+    "postinstall": "node scripts/postinstall-link-workspaces.mjs",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run typecheck:strict && bun test",
+    "pre-commit": "bun run lint:fix && bun run typecheck && bun run typecheck:strict && bun test"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.2",
+    "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "@types/qrcode": "^1.5.6",
+    "@types/web-push": "^3.6.4",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.3.5"
+  },
+  "dependencies": {
+    "@types/micromatch": "^4.0.10",
+    "js-yaml": "^4.1.1",
+    "jsonpath-plus": "^10.3.0",
+    "micromatch": "^4.0.8",
+    "otpauth": "^9.5.0",
+    "qrcode": "^1.5.4",
+    "web-push": "^3.6.7"
+  }
+}

package/packages/cli/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@codepiper/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./src/main.ts",
+  "types": "./src/main.ts",
+  "dependencies": {
+    "@codepiper/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

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

@@ -0,0 +1,157 @@
+import { daemonJson } from "../lib/api";
+import { getOption, getSocket } from "../lib/args";
+import { colors, info, table } from "../lib/format";
+
+function daysToRange(days: string): string {
+  switch (days) {
+    case "1":
+      return "today";
+    case "30":
+      return "30d";
+    case "0":
+      return "all";
+    default:
+      return "7d";
+  }
+}
+
+async function showOverview(socket: string, range: string): Promise<void> {
+  const data = await daemonJson<{
+    sessionsCount: number;
+    activeSessions: number;
+    totalTokens: number;
+    totalMessages: number;
+    cacheHitRate: number;
+    costEstimate: number;
+  }>(`/analytics/overview?range=${range}`, { socket });
+
+  console.log(`${colors.bold}Analytics Overview${colors.reset} (range: ${range})\n`);
+  info("Total sessions", String(data.sessionsCount ?? 0));
+  info("Active sessions", String(data.activeSessions ?? 0));
+  info("Total tokens", (data.totalTokens ?? 0).toLocaleString());
+  info("Total messages", String(data.totalMessages ?? 0));
+  info("Cache hit rate", `${data.cacheHitRate ?? 0}%`);
+  if (data.costEstimate !== undefined) {
+    info("Estimated cost", `$${data.costEstimate.toFixed(2)}`);
+  }
+}
+
+async function showTokens(socket: string, range: string): Promise<void> {
+  const data = await daemonJson<
+    Array<{
+      model: string;
+      tokens: number;
+      prompt_tokens: number;
+      completion_tokens: number;
+      cache_read: number;
+      cache_creation: number;
+      requests: number;
+      costEstimate: number;
+    }>
+  >(`/analytics/tokens-by-model?range=${range}`, { socket });
+
+  console.log(`${colors.bold}Tokens by Model${colors.reset} (range: ${range})\n`);
+
+  if (!data || data.length === 0) {
+    console.log("No token data available.");
+    return;
+  }
+
+  const rows = data.map((m) => [
+    m.model || "unknown",
+    (m.tokens ?? 0).toLocaleString(),
+    (m.prompt_tokens ?? 0).toLocaleString(),
+    (m.completion_tokens ?? 0).toLocaleString(),
+    String(m.requests ?? 0),
+    m.costEstimate !== undefined ? `$${m.costEstimate.toFixed(2)}` : "-",
+  ]);
+
+  console.log(table(["MODEL", "TOTAL", "PROMPT", "COMPLETION", "REQUESTS", "COST"], rows));
+}
+
+async function showTools(socket: string, range: string): Promise<void> {
+  const data = await daemonJson<Array<{ tool: string; count: number }>>(
+    `/analytics/tool-usage?range=${range}`,
+    { socket }
+  );
+
+  console.log(`${colors.bold}Tool Usage${colors.reset} (range: ${range})\n`);
+
+  if (!data || data.length === 0) {
+    console.log("No tool usage data available.");
+    return;
+  }
+
+  const rows = data.map((t) => [t.tool || "-", String(t.count ?? 0)]);
+
+  console.log(table(["TOOL", "USES"], rows));
+}
+
+async function showActivity(socket: string, range: string): Promise<void> {
+  const data = await daemonJson<
+    Array<{
+      date: string;
+      user_messages: number;
+      assistant_messages: number;
+      total: number;
+    }>
+  >(`/analytics/activity-timeline?range=${range}`, { socket });
+
+  console.log(`${colors.bold}Activity Timeline${colors.reset} (range: ${range})\n`);
+
+  if (!data || data.length === 0) {
+    console.log("No activity data available.");
+    return;
+  }
+
+  const rows = data.map((a) => [
+    a.date || "-",
+    String(a.user_messages ?? 0),
+    String(a.assistant_messages ?? 0),
+    String(a.total ?? 0),
+  ]);
+
+  console.log(table(["DATE", "USER", "ASSISTANT", "TOTAL"], rows));
+}
+
+async function showSessions(socket: string, range: string): Promise<void> {
+  const data = await daemonJson<Array<{ provider: string; count: number }>>(
+    `/analytics/sessions-by-provider?range=${range}`,
+    { socket }
+  );
+
+  console.log(`${colors.bold}Sessions by Provider${colors.reset} (range: ${range})\n`);
+
+  if (!data || data.length === 0) {
+    console.log("No session data available.");
+    return;
+  }
+
+  const rows = data.map((s) => [s.provider || "-", String(s.count ?? 0)]);
+
+  console.log(table(["PROVIDER", "SESSIONS"], rows));
+}
+
+export async function runAnalyticsCommand(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const days = getOption(args, "days") || "7";
+  const range = daysToRange(days);
+  const subcommand = args.find((a) => !a.startsWith("-")) || "overview";
+
+  switch (subcommand) {
+    case "overview":
+      return showOverview(socket, range);
+    case "tokens":
+      return showTokens(socket, range);
+    case "tools":
+      return showTools(socket, range);
+    case "activity":
+      return showActivity(socket, range);
+    case "sessions":
+      return showSessions(socket, range);
+    default:
+      throw new Error(
+        `Unknown analytics subcommand: ${subcommand}. Use: overview, tokens, tools, activity, sessions`
+      );
+  }
+}

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

@@ -0,0 +1,299 @@
+import * as os from "node:os";
+import { readErrorJson, readJson, responseErrorMessage } from "../lib/api";
+import { getRequiredValue } from "../lib/args";
+
+export interface AttachOptions {
+  sessionId: string;
+  socket: string;
+  follow: boolean;
+}
+
+export function parseAttachOptions(args: string[]): AttachOptions {
+  let sessionId: string | undefined;
+  let socket = "/tmp/codepiper.sock";
+  let follow = false;
+
+  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++;
+    } else if (arg === "--follow" || arg === "-f") {
+      follow = true;
+    } else if (!(arg.startsWith("-") || sessionId)) {
+      sessionId = arg;
+    }
+  }
+
+  if (!sessionId) {
+    throw new Error("session-id is required");
+  }
+
+  return { sessionId, socket, follow };
+}
+
+interface TerminalState {
+  originalRawMode: boolean;
+  originalIsTTY: boolean;
+}
+
+class SessionOutputUnavailableError extends Error {}
+
+function getHomeDir(): string {
+  return process.env.HOME || os.homedir();
+}
+
+export async function verifySessionExists(sessionId: string, socket: string): Promise<void> {
+  try {
+    const response = await fetch(`http://localhost/sessions/${sessionId}`, {
+      unix: socket,
+      method: "GET",
+    });
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const errorData = await readErrorJson(response);
+      throw new Error(responseErrorMessage(response, errorData));
+    }
+  } 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;
+  }
+}
+
+async function displayHistoricalOutput(sessionId: string): Promise<void> {
+  // Try to read historical output from log file
+  const outputLogPath = `${getHomeDir()}/.codepiper/sessions/${sessionId}/output.log`;
+
+  try {
+    const fs = require("node:fs");
+    const content = await fs.promises.readFile(outputLogPath, "utf-8");
+    if (content) {
+      process.stdout.write(content);
+    }
+  } catch (_err) {
+    // Log file doesn't exist yet, or is empty - that's okay
+  }
+}
+
+async function setupTerminal(follow: boolean): Promise<TerminalState> {
+  const originalRawMode = process.stdin.isRaw ?? false;
+  const originalIsTTY = process.stdin.isTTY ?? false;
+
+  if (!follow && originalIsTTY) {
+    // Interactive mode: enable raw mode for direct key forwarding
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+  }
+
+  return {
+    originalRawMode,
+    originalIsTTY,
+  };
+}
+
+async function restoreTerminal(state: TerminalState): Promise<void> {
+  if (process.stdin.setRawMode && state.originalIsTTY) {
+    process.stdin.setRawMode(state.originalRawMode);
+  }
+  if (!state.originalRawMode) {
+    process.stdin.pause();
+  }
+}
+
+export async function fetchSessionOutput(sessionId: string, socket: string): Promise<string> {
+  try {
+    const response = await fetch(`http://localhost/sessions/${sessionId}/output`, {
+      unix: socket,
+      method: "GET",
+    });
+
+    if (!response.ok) {
+      const errorData = await readErrorJson(response);
+      const message = responseErrorMessage(response, errorData);
+      if (response.status === 404 || response.status === 409) {
+        throw new SessionOutputUnavailableError(message);
+      }
+      throw new Error(message);
+    }
+
+    const data = await readJson<{ output?: string }>(response);
+    return typeof data.output === "string" ? data.output : "";
+  } 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 function writeOutputDelta(previous: string, current: string): void {
+  if (current.length === 0 || current === previous) {
+    return;
+  }
+
+  if (!previous) {
+    process.stdout.write(current);
+    return;
+  }
+
+  // Fast path for append-only changes.
+  if (current.startsWith(previous)) {
+    process.stdout.write(current.slice(previous.length));
+    return;
+  }
+
+  // Fallback: emit changed suffix from common prefix.
+  const max = Math.min(previous.length, current.length);
+  let idx = 0;
+  while (idx < max && previous[idx] === current[idx]) {
+    idx++;
+  }
+  process.stdout.write(current.slice(idx));
+}
+
+async function connectAndStream(sessionId: string, socket: string, follow: boolean): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let isClosing = false;
+    let polling = false;
+    let lastOutput = "";
+    let pollTimer: Timer | undefined;
+
+    const stop = (finish: "resolve" | "reject", error?: unknown) => {
+      if (isClosing) {
+        return;
+      }
+      isClosing = true;
+
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = undefined;
+      }
+      process.off("SIGINT", sigintHandler);
+
+      if (!follow) {
+        process.stdin.off("data", stdinHandler);
+      }
+
+      if (finish === "resolve") {
+        resolve();
+      } else {
+        reject(error);
+      }
+    };
+
+    const pollOutput = async () => {
+      if (isClosing || polling) {
+        return;
+      }
+      polling = true;
+
+      try {
+        const output = await fetchSessionOutput(sessionId, socket);
+        if (!isClosing) {
+          writeOutputDelta(lastOutput, output);
+          lastOutput = output;
+        }
+      } catch (error) {
+        if (!isClosing) {
+          if (error instanceof SessionOutputUnavailableError) {
+            stop("resolve");
+            return;
+          }
+          stop("reject", error);
+        }
+      } finally {
+        polling = false;
+      }
+    };
+
+    // Handle stdin in interactive mode
+    const stdinHandler = async (chunk: Buffer) => {
+      const text = chunk.toString();
+
+      // Check for Ctrl+C (0x03)
+      if (text === "\x03") {
+        stop("resolve");
+        return;
+      }
+
+      // Echo input locally in raw mode (so user can see what they're typing)
+      // Output polling will also reflect terminal state.
+      process.stdout.write(text);
+
+      // Send input to session
+      try {
+        await fetch(`http://localhost/sessions/${sessionId}/send`, {
+          unix: socket,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            text,
+            newline: false,
+          }),
+        });
+      } catch (err) {
+        if (!isClosing) {
+          stop("reject", err);
+        }
+      }
+    };
+
+    if (!follow) {
+      process.stdin.on("data", stdinHandler);
+    }
+
+    // Handle SIGINT (Ctrl+C from terminal, not from stdin in raw mode)
+    const sigintHandler = () => {
+      if (!isClosing) {
+        stop("resolve");
+      }
+    };
+
+    process.on("SIGINT", sigintHandler);
+
+    pollTimer = setInterval(() => {
+      void pollOutput();
+    }, 100);
+    void pollOutput();
+  });
+}
+
+export async function attachToSession(options: AttachOptions): Promise<void> {
+  // 1. Verify session exists
+  await verifySessionExists(options.sessionId, options.socket);
+
+  console.log(`Attaching to session ${options.sessionId}...`);
+  console.log(`Mode: ${options.follow ? "follow (read-only)" : "interactive"}`);
+  console.log(`Press Ctrl+C to detach.\n`);
+
+  // 2. Setup terminal
+  const terminalState = await setupTerminal(options.follow);
+
+  try {
+    // 3. Display historical output first
+    await displayHistoricalOutput(options.sessionId);
+
+    // 4. Connect and stream new output
+    await connectAndStream(options.sessionId, options.socket, options.follow);
+  } finally {
+    // 5. Always restore terminal state
+    await restoreTerminal(terminalState);
+    console.log("\nDetached.");
+  }
+}
+
+export async function runAttachCommand(args: string[]): Promise<void> {
+  const options = parseAttachOptions(args);
+  await attachToSession(options);
+}

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

@@ -0,0 +1,50 @@
+import { daemonJson } from "../lib/api";
+import { getOption, getSocket } from "../lib/args";
+import { colors, formatDate, table } from "../lib/format";
+
+interface PolicyDecision {
+  id: number;
+  sessionId: string;
+  policyId?: number;
+  toolName: string;
+  decision: string;
+  reason?: string;
+  timestamp: string;
+}
+
+export async function runAuditCommand(args: string[]): Promise<void> {
+  const socket = getSocket(args);
+  const sessionId = getOption(args, "session");
+  const limit = getOption(args, "limit") || "50";
+
+  const params = new URLSearchParams();
+  if (sessionId) params.set("sessionId", sessionId);
+  params.set("limit", limit);
+
+  const query = params.toString();
+  const data = await daemonJson<{ decisions: PolicyDecision[] }>(`/policy-decisions?${query}`, {
+    socket,
+  });
+
+  if (data.decisions.length === 0) {
+    console.log("No policy decisions found.");
+    return;
+  }
+
+  const rows = data.decisions.map((d) => {
+    const decisionColor =
+      d.decision === "allow" ? colors.green : d.decision === "deny" ? colors.red : colors.yellow;
+
+    return [
+      formatDate(d.timestamp),
+      d.sessionId.slice(0, 8),
+      d.toolName,
+      `${decisionColor}${d.decision}${colors.reset}`,
+      d.policyId ? `#${d.policyId}` : `${colors.dim}-${colors.reset}`,
+      d.reason || `${colors.dim}-${colors.reset}`,
+    ];
+  });
+
+  console.log(table(["TIMESTAMP", "SESSION", "TOOL", "DECISION", "POLICY", "REASON"], rows));
+  console.log(`\n${colors.bold}Total:${colors.reset} ${data.decisions.length} decision(s)`);
+}