@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/login.ts

@@ -1,236 +0,0 @@
-/**
- * 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 "@creativeintelligence/sdk/config";
-import { api, getHttpClient, isConvexConfigured } from "@creativeintelligence/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

@@ -1,45 +0,0 @@
-/**
- * abbie logout — clear stored credentials from this device.
- */
-
-import { clearClerkId, getStoredClerkId, getDeviceInfo } from "@creativeintelligence/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

@@ -1,68 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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");
-  });
-});