@creativeintelligence/abbie 0.1.0

package/src/cli/commands/login.ts

@@ -0,0 +1,236 @@
+/**
+ * abbie login — authenticate this device via browser-based pairing.
+ *
+ * Flow:
+ * 1. Generate device ID (stable UUID for this machine)
+ * 2. Create auth code in Convex (8-char, 10min TTL)
+ * 3. Open browser to web app auth page
+ * 4. Poll until browser confirms (user clicks "authorize")
+ * 5. Save clerkId to ~/.abbie/config.json
+ * 6. Optionally trigger initial sync
+ */
+
+import { Flags } from "@oclif/core";
+import { getDeviceInfo, getStoredClerkId, saveClerkId, getWebUrl } from "@abbie/sdk/config";
+import { api, getHttpClient, isConvexConfigured } from "@abbie/sdk/convex";
+import { BaseCommand } from "../base-command.js";
+
+const POLL_INTERVAL_MS = 1_500;
+const MAX_POLL_DURATION_MS = 10 * 60 * 1_000; // 10 minutes (matches code TTL)
+
+type LoginResult = {
+  status: "authenticated" | "already-authenticated" | "expired" | "error";
+  clerkId?: string;
+  deviceId?: string;
+  error?: string;
+};
+
+export default class LoginCommand extends BaseCommand {
+  static override summary = "Authenticate this device with abbie";
+
+  static override description = `Pairs this device with your abbie account via browser login.
+
+Opens your browser to authorize this CLI. After you confirm in the browser,
+the CLI saves your credentials locally and is ready to sync.
+
+If already authenticated, shows current status. Use --force to re-authenticate.`;
+
+  static override examples = [
+    "$ abbie login",
+    "$ abbie login --force",
+    "$ abbie login --no-open",
+    "$ abbie login --json --quiet",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    force: Flags.boolean({
+      char: "f",
+      description: "Re-authenticate even if already logged in",
+      default: false,
+    }),
+    open: Flags.boolean({
+      description: "Open browser automatically",
+      default: true,
+      allowNo: true,
+    }),
+    sync: Flags.boolean({
+      description: "Run initial sync after login",
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  async execute(): Promise<LoginResult> {
+    const { flags } = await this.parse(LoginCommand);
+    this.parsedFlags = flags;
+
+    // Check if Convex is reachable
+    if (!isConvexConfigured()) {
+      this.logWarn("Convex not configured. Set CONVEX_URL env var or convexUrl in ~/.abbie/config.json");
+      return { status: "error", error: "convex-not-configured" };
+    }
+
+    // Check existing auth
+    const existingClerkId = getStoredClerkId();
+    if (existingClerkId && !flags.force) {
+      this.logInfo(`already authenticated (${existingClerkId.slice(0, 12)}...)`);
+      return {
+        status: "already-authenticated",
+        clerkId: existingClerkId,
+        deviceId: getDeviceInfo().deviceId,
+      };
+    }
+
+    const client = getHttpClient();
+    const device = getDeviceInfo();
+
+    // Step 1: Create auth code
+    this.logInfo("creating auth code...");
+
+    let code: string;
+    let expiresAt: number;
+    try {
+      const result = await client.mutation(api.functions.auth.tokens.createAuthCode, {
+        deviceId: device.deviceId,
+      });
+      code = result.code;
+      expiresAt = result.expiresAt;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logWarn(`failed to create auth code: ${message}`);
+      return { status: "error", error: message };
+    }
+
+    // Step 2: Open browser
+    const webUrl = getWebUrl();
+    const authUrl = `${webUrl}/auth/cli?code=${code}`;
+
+    this.log("");
+    this.log("  open this URL to authorize:");
+    this.log(`  ${authUrl}`);
+    this.log("");
+    this.log(`  code: ${code}`);
+    this.log(`  device: ${device.hostname} (${device.deviceId.slice(0, 8)}...)`);
+    this.log("");
+
+    if (flags.open) {
+      try {
+        const { exec } = await import("node:child_process");
+        const cmd = process.platform === "darwin"
+          ? `open "${authUrl}"`
+          : process.platform === "win32"
+            ? `start "${authUrl}"`
+            : `xdg-open "${authUrl}"`;
+        exec(cmd);
+      } catch {
+        // Silently ignore — user can open manually
+      }
+    }
+
+    // Step 3: Poll for completion
+    this.logInfo("waiting for browser authorization...");
+
+    const startTime = Date.now();
+    let clerkId: string | undefined;
+
+    while (Date.now() - startTime < MAX_POLL_DURATION_MS) {
+      try {
+        const result = await client.query(api.functions.auth.tokens.pollAuth, {
+          code,
+          deviceId: device.deviceId,
+        });
+
+        if (result.status === "completed" && result.clerkId) {
+          clerkId = result.clerkId;
+          break;
+        }
+
+        if (result.status === "expired") {
+          this.logWarn("auth code expired. run `abbie login` again.");
+          return { status: "expired", deviceId: device.deviceId };
+        }
+
+        if (result.status === "invalid") {
+          this.logWarn("auth code invalid.");
+          return { status: "error", error: "invalid-code", deviceId: device.deviceId };
+        }
+      } catch {
+        // Network hiccup — retry
+      }
+
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+
+    if (!clerkId) {
+      this.logWarn("timed out waiting for authorization.");
+      return { status: "expired", deviceId: device.deviceId };
+    }
+
+    // Step 4: Save credentials
+    saveClerkId(clerkId);
+
+    this.log("");
+    this.log("  ✓ authenticated");
+    this.log(`    user: ${clerkId.slice(0, 16)}...`);
+    this.log(`    device: ${device.hostname}`);
+    this.log("");
+
+    // Step 5: Optional initial sync
+    if (flags.sync) {
+      this.logInfo("running initial sync...");
+      try {
+        await this.runInitialSync(clerkId);
+        this.log("  ✓ synced");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.logWarn(`sync failed (non-fatal): ${message}`);
+        this.logInfo("run `abbie sync --apply` manually to sync.");
+      }
+    }
+
+    this.logInfo("run `abbie daemon` to start live sync.");
+
+    return {
+      status: "authenticated",
+      clerkId,
+      deviceId: device.deviceId,
+    };
+  }
+
+  private async runInitialSync(clerkId: string): Promise<void> {
+    const client = getHttpClient();
+
+    // Import sync runners lazily to avoid circular deps
+    const { ConfigSyncRunner } = await import("../../lib/config-sync/index.js");
+    const { ContentSyncRunner } = await import("../../lib/content-sync/index.js");
+
+    let decryptFn: ((v: string) => Promise<string>) | undefined;
+    try {
+      const { decryptIfEncrypted } = await import("@lnittman/convex-encryption");
+      decryptFn = async (v: string) => {
+        const result = await decryptIfEncrypted(v);
+        return result ?? v;
+      };
+    } catch {
+      // Encryption package not available
+    }
+
+    // Config sync
+    const configRunner = new ConfigSyncRunner({
+      fetchSnapshot: async () => {
+        return await client.query(api.configSync.getSnapshot, { clerkId });
+      },
+      decrypt: decryptFn,
+    });
+    await configRunner.tick({ force: true, dryRun: false });
+
+    // Content sync
+    const contentRunner = new ContentSyncRunner({
+      fetchSnapshot: async () => {
+        return await client.query(api.contentSync.getSnapshot, { clerkId });
+      },
+    });
+    await contentRunner.tick({ force: true, dryRun: false });
+  }
+}

package/src/cli/commands/logout.ts

@@ -0,0 +1,45 @@
+/**
+ * abbie logout — clear stored credentials from this device.
+ */
+
+import { clearClerkId, getStoredClerkId, getDeviceInfo } from "@abbie/sdk/config";
+import { BaseCommand } from "../base-command.js";
+
+type LogoutResult = {
+  status: "logged-out" | "not-authenticated";
+  deviceId: string;
+};
+
+export default class LogoutCommand extends BaseCommand {
+  static override summary = "Clear authentication from this device";
+
+  static override description = `Removes stored credentials from ~/.abbie/config.json.
+Does not revoke tokens server-side — just clears local state.`;
+
+  static override examples = [
+    "$ abbie logout",
+    "$ abbie logout --json --quiet",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+  };
+
+  async execute(): Promise<LogoutResult> {
+    const { flags } = await this.parse(LogoutCommand);
+    this.parsedFlags = flags;
+
+    const device = getDeviceInfo();
+    const existing = getStoredClerkId();
+
+    if (!existing) {
+      this.logInfo("not authenticated.");
+      return { status: "not-authenticated", deviceId: device.deviceId };
+    }
+
+    clearClerkId();
+    this.logInfo(`logged out (was ${existing.slice(0, 12)}...)`);
+
+    return { status: "logged-out", deviceId: device.deviceId };
+  }
+}

package/src/cli/commands/panes/broker.ts

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Flags } from "@oclif/core";
+import { startPanesBroker } from "../../../lib/panes/server.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class PanesBrokerCommand extends BaseCommand {
+  static override summary = "Run local panes broker (event-driven tmux streaming)";
+  static override hidden = false;
+
+  static override examples = [
+    "$ abbie panes broker",
+    "$ abbie panes broker --socket ~/.abbie/run/panes-broker.sock",
+    "$ abbie panes broker --fps 30",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    socket: Flags.string({
+      description: "Unix socket path for the broker",
+      required: false,
+    }),
+    fps: Flags.integer({
+      description: "Max snapshots per second (throttled)",
+      default: 30,
+    }),
+    force: Flags.boolean({
+      description: "Override any existing tmux pipe-pane for a pane",
+      default: false,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { flags } = await this.parse(PanesBrokerCommand);
+    this.parsedFlags = flags;
+
+    const devBin = join(this.config.root, "bin", "dev.js");
+    const runBin = join(this.config.root, "bin", "run.js");
+    const agentsBinPath = existsSync(devBin) ? devBin : runBin;
+
+    const broker = await startPanesBroker(
+      {
+        socketPath: flags.socket,
+        fps: flags.fps,
+        forcePipe: flags.force,
+      },
+      {
+        agentsBinPath,
+        logInfo: (m) => this.logInfo(m),
+        logWarn: (m) => this.logWarn(m),
+      },
+    );
+
+    // Block forever until killed.
+    await new Promise<void>((resolve) => {
+      const onStop = async () => {
+        process.off("SIGINT", onStop);
+        process.off("SIGTERM", onStop);
+        await broker.stop();
+        resolve();
+      };
+      process.on("SIGINT", onStop);
+      process.on("SIGTERM", onStop);
+    });
+
+    return { socketPath: broker.socketPath };
+  }
+}

package/src/cli/commands/panes/pipe-sink.ts

@@ -0,0 +1,101 @@
+import { createConnection } from "node:net";
+import { Args, Flags } from "@oclif/core";
+import {
+  createNdjsonLineParser,
+  getDefaultPanesBrokerSocketPath,
+} from "../../../lib/panes/broker.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class PanesPipeSinkCommand extends BaseCommand {
+  static override summary = "Internal: tmux pipe-pane sink (stdin <-> broker)";
+  static override hidden = true;
+
+  static override args = {
+    pane: Args.string({
+      description: "tmux pane id (e.g. %3)",
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    sock: Flags.string({
+      description: "Broker socket path",
+      required: false,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(PanesPipeSinkCommand);
+    this.parsedFlags = flags;
+
+    const paneId = args.pane;
+    const socketPath = flags.sock ?? getDefaultPanesBrokerSocketPath();
+
+    // Connect to broker. If broker isn't running, exit quietly so tmux isn't spammed.
+    const socket = createConnection({ path: socketPath });
+
+    const parser = createNdjsonLineParser<Record<string, unknown>>();
+    socket.on("data", (chunk) => parser.pushChunk(chunk));
+
+    const send = (msg: unknown) => {
+      socket.write(`${JSON.stringify(msg)}\n`);
+    };
+
+    const done = new Promise<void>((resolve) => {
+      const finish = () => resolve();
+      socket.on("error", finish);
+      socket.on("close", finish);
+    });
+
+    // Identify as a pipe client for this pane.
+    send({
+      type: "client.hello",
+      at: new Date().toISOString(),
+      clientId: `pipe:${paneId}`,
+      version: 1,
+      pid: process.pid,
+    });
+    send({ type: "panes.pipe.hello", at: new Date().toISOString(), paneId });
+
+    parser.onMessage((msg) => {
+      if (msg.type !== "panes.pipe.input") return;
+      if (msg.paneId !== paneId) return;
+      const data = typeof msg.data === "string" ? msg.data : null;
+      if (!data) return;
+      try {
+        const bytes = Buffer.from(data, "base64");
+        process.stdout.write(bytes);
+      } catch {
+        // ignore
+      }
+    });
+
+    // Forward raw pane output to broker as base64 chunks.
+    process.stdin.on("data", (chunk) => {
+      try {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        send({
+          type: "panes.pipe.chunk",
+          at: new Date().toISOString(),
+          paneId,
+          data: buf.toString("base64"),
+        });
+      } catch {
+        // ignore
+      }
+    });
+
+    // If stdin ends, exit.
+    process.stdin.on("end", () => {
+      try {
+        socket.end();
+      } catch {
+        // ignore
+      }
+    });
+
+    await done;
+    return { ok: true };
+  }
+}

package/src/cli/commands/panes/snapshot.ts

@@ -0,0 +1,156 @@
+import { Args, Flags } from "@oclif/core";
+import { capturePane, capturePaneWithAnsi } from "../../../lib/tmux/bridge.js";
+import { isRunning } from "../../../lib/tmux/index.js";
+import { redactContent } from "../../../lib/tmux/redaction.js";
+import * as windows from "../../../lib/windows/index.js";
+import { BaseCommand } from "../../base-command.js";
+
+type SnapshotEncoding = "text" | "ansi";
+
+type SnapshotResult = {
+  tmuxRunning: boolean;
+  window: windows.WindowInfo | null;
+  ref: string | null;
+  paneId: string | null;
+  encoding: SnapshotEncoding;
+  lines: number;
+  content: string;
+  redacted: boolean;
+  wasRedacted: boolean;
+};
+
+function paneRef(window: windows.WindowInfo): string {
+  return `${window.session}:${window.window}.${window.pane}`;
+}
+
+export default class PanesSnapshotCommand extends BaseCommand {
+  static override summary = "Capture tmux pane scrollback snapshot";
+  static hidden = false;
+
+  static override examples = [
+    "$ abbie panes snapshot",
+    "$ abbie panes snapshot %3 --lines 200",
+    "$ abbie panes snapshot work:0.0 --lines 500 --ansi",
+    "$ abbie panes snapshot --json",
+  ];
+
+  static override args = {
+    ref: Args.string({
+      description: "Pane ID (e.g. %3) or session:window.pane (e.g. work:0.0)",
+      required: false,
+    }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    lines: Flags.integer({
+      description: "Number of lines to capture from the bottom",
+      default: 200,
+    }),
+    ansi: Flags.boolean({
+      description: "Preserve ANSI escape codes",
+      default: false,
+    }),
+    redact: Flags.boolean({
+      description: "Enable redaction",
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(PanesSnapshotCommand);
+    this.parsedFlags = flags;
+
+    const tmuxRunning = await isRunning();
+    if (!tmuxRunning) {
+      const result: SnapshotResult = {
+        tmuxRunning: false,
+        window: null,
+        ref: null,
+        paneId: null,
+        encoding: flags.ansi ? "ansi" : "text",
+        lines: Math.max(1, flags.lines),
+        content: "",
+        redacted: flags.redact,
+        wasRedacted: false,
+      };
+      if (!this.jsonEnabled?.()) {
+        this.log("tmux is not running");
+      }
+      return result;
+    }
+
+    const maxLines = Math.max(1, flags.lines);
+    const state = args.ref
+      ? await windows.getWindowState(args.ref, {
+          includeNvim: false,
+          includeAgent: false,
+          includeBuffers: false,
+        })
+      : await windows.getFocusedWindow({
+          includeNvim: false,
+          includeAgent: false,
+          includeBuffers: false,
+        });
+
+    if (!state) {
+      const result: SnapshotResult = {
+        tmuxRunning: true,
+        window: null,
+        ref: null,
+        paneId: null,
+        encoding: flags.ansi ? "ansi" : "text",
+        lines: maxLines,
+        content: "",
+        redacted: flags.redact,
+        wasRedacted: false,
+      };
+      if (!this.jsonEnabled?.()) {
+        this.log("Pane not found");
+      }
+      return result;
+    }
+
+    const encoding: SnapshotEncoding = flags.ansi ? "ansi" : "text";
+    const paneId =
+      state.window.paneId || `${state.window.session}:${state.window.window}.${state.window.pane}`;
+
+    const raw =
+      encoding === "ansi"
+        ? await capturePaneWithAnsi(state.window.window, state.window.pane, {
+            session: state.window.session,
+            lines: maxLines,
+          })
+        : await capturePane(state.window.window, state.window.pane, {
+            session: state.window.session,
+            lines: maxLines,
+          });
+
+    let content = raw;
+    let wasRedacted = false;
+    if (flags.redact) {
+      const redaction = redactContent(raw, "balanced");
+      content = redaction.content;
+      wasRedacted = redaction.wasRedacted;
+    }
+
+    const result: SnapshotResult = {
+      tmuxRunning: true,
+      window: state.window,
+      ref: paneRef(state.window),
+      paneId,
+      encoding,
+      lines: maxLines,
+      content,
+      redacted: flags.redact,
+      wasRedacted,
+    };
+
+    if (!this.jsonEnabled?.()) {
+      this.log(content);
+    }
+
+    return result;
+  }
+}

package/src/cli/commands/plan.e2e.test.ts

@@ -0,0 +1,90 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * E2E tests for abbie plan command.
+ * Tests session creation with actual CLI binary.
+ */
+
+describe("abbie plan (E2E)", () => {
+  let testPlansDir: string;
+
+  beforeAll(() => {
+    testPlansDir = mkdtempSync(join(tmpdir(), "agents-plan-test-"));
+  });
+
+  afterAll(() => {
+    rmSync(testPlansDir, { recursive: true, force: true });
+  });
+
+  async function runCLI(
+    args: string[],
+    env: Record<string, string> = {},
+  ): Promise<{ stdout: string; stderr: string; exitCode: number | null }> {
+    const proc = Bun.spawn(["bun", "bin/run.js", "plan", ...args], {
+      cwd: `${import.meta.dir}/../../..`,
+      env: {
+        ...process.env,
+        HOME: testPlansDir, // Override HOME to use test directory
+        ...env,
+      },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    await proc.exited;
+
+    return { stdout, stderr, exitCode: proc.exitCode };
+  }
+
+  it("creates a new planning session", async () => {
+    const { stdout, exitCode } = await runCLI(["--project", "test", "--title", "E2E Test Session"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Created planning session");
+    expect(stdout).toContain("test");
+
+    // Verify session directory was created in ~/.abbie/plans/
+    const sessionDir = join(testPlansDir, ".abbie", "plans", "test");
+    expect(existsSync(sessionDir)).toBe(true);
+  });
+
+  it("creates session with custom slug", async () => {
+    const { stdout, exitCode } = await runCLI([
+      "--project",
+      "test2",
+      "--slug",
+      "2025-12-01-custom",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("2025-12-01-custom");
+
+    const sessionPath = join(testPlansDir, ".abbie", "plans", "test2", "2025-12-01-custom");
+    expect(existsSync(sessionPath)).toBe(true);
+  });
+
+  it("outputs JSON format", async () => {
+    const { stdout, exitCode } = await runCLI([
+      "--project",
+      "test3",
+      "--title",
+      "JSON Test",
+      "--json",
+    ]);
+    expect(exitCode).toBe(0);
+    const data = JSON.parse(stdout);
+    expect(data).toHaveProperty("project", "test3");
+    expect(data).toHaveProperty("slug");
+    expect(data).toHaveProperty("path");
+    expect(data).toHaveProperty("files");
+  });
+
+  it("errors when no title or slug provided", async () => {
+    const { stderr, exitCode } = await runCLI(["--project", "test"]);
+    expect(exitCode).toBe(2); // oclif uses exit code 2 for validation errors
+    expect(stderr).toContain("Provide --title or --slug");
+  });
+});