@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/lib/ngrok.ts

@@ -1,441 +0,0 @@
-import { execSync, spawn } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { createEvent, EventStore } from "./events.js";
-
-/**
- * ngrok local API base URL.
- * The agent exposes this API with no authentication.
- * @see https://ngrok.com/docs/agent/api
- */
-const NGROK_API_BASE = "http://127.0.0.1:4040/api";
-
-/**
- * Tunnel information from ngrok API.
- */
-export interface NgrokTunnel {
-  name: string;
-  public_url: string;
-  proto: string;
-  config: {
-    addr: string;
-    inspect: boolean;
-  };
-  metrics?: {
-    conns: {
-      count: number;
-      rate1: number;
-      rate5: number;
-      rate15: number;
-    };
-    http?: {
-      count: number;
-      rate1: number;
-      rate5: number;
-      rate15: number;
-    };
-  };
-}
-
-/**
- * Tunnel list response from ngrok API.
- */
-interface TunnelsResponse {
-  tunnels: NgrokTunnel[];
-  uri: string;
-}
-
-/**
- * Agent status from ngrok API.
- */
-interface AgentStatus {
-  version: string;
-  region: string;
-  status: string;
-}
-
-/**
- * Stored tunnel metadata (supplements API data).
- */
-export interface StoredTunnel {
-  name: string;
-  session_id: string;
-  port: number;
-  created_at: string;
-}
-
-/**
- * Check if ngrok agent is running.
- * Uses the status endpoint for lightweight health check.
- */
-export async function isAgentRunning(): Promise<boolean> {
-  try {
-    const response = await fetch(`${NGROK_API_BASE}/status`);
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get ngrok agent status.
- */
-export async function getAgentStatus(): Promise<AgentStatus | undefined> {
-  try {
-    const response = await fetch(`${NGROK_API_BASE}/status`);
-    if (!response.ok) return undefined;
-    return (await response.json()) as AgentStatus;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * List all active tunnels via ngrok API.
- * @see GET /api/tunnels
- */
-export async function listTunnels(): Promise<NgrokTunnel[]> {
-  try {
-    const response = await fetch(`${NGROK_API_BASE}/tunnels`);
-    if (!response.ok) return [];
-    const data = (await response.json()) as TunnelsResponse;
-    return data.tunnels || [];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Get a specific tunnel by name.
- * @see GET /api/tunnels/:name
- */
-export async function getTunnel(name: string): Promise<NgrokTunnel | undefined> {
-  try {
-    const response = await fetch(`${NGROK_API_BASE}/tunnels/${encodeURIComponent(name)}`);
-    if (!response.ok) return undefined;
-    return (await response.json()) as NgrokTunnel;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Start a new tunnel via ngrok API.
- * Requires ngrok agent to be running.
- * @see POST /api/tunnels
- */
-export async function startTunnel(port: number, name?: string): Promise<NgrokTunnel | undefined> {
-  const tunnelName = name || `port-${port}`;
-
-  try {
-    const response = await fetch(`${NGROK_API_BASE}/tunnels`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        name: tunnelName,
-        addr: port.toString(),
-        proto: "http",
-      }),
-    });
-
-    if (response.status === 201 || response.ok) {
-      return (await response.json()) as NgrokTunnel;
-    }
-
-    return undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Stop a tunnel by name.
- * @see DELETE /api/tunnels/:name
- */
-export async function stopTunnel(name: string): Promise<boolean> {
-  try {
-    const response = await fetch(`${NGROK_API_BASE}/tunnels/${encodeURIComponent(name)}`, {
-      method: "DELETE",
-    });
-    return response.status === 204 || response.ok;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Start ngrok agent in background if not running.
- * This starts the agent without any tunnels - tunnels are created via API.
- */
-export async function ensureAgentRunning(): Promise<boolean> {
-  if (await isAgentRunning()) {
-    return true;
-  }
-
-  // Start ngrok agent with no tunnels (just the API)
-  const ngrok = spawn("ngrok", ["start", "--none"], {
-    detached: true,
-    stdio: "ignore",
-  });
-  ngrok.unref();
-
-  // Wait for agent to be ready (up to 10s)
-  for (let i = 0; i < 20; i++) {
-    await new Promise((r) => setTimeout(r, 500));
-    if (await isAgentRunning()) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Find tunnel by port number.
- */
-export async function findTunnelByPort(port: number): Promise<NgrokTunnel | undefined> {
-  const tunnels = await listTunnels();
-  return tunnels.find((t) => {
-    const addr = t.config?.addr || "";
-    return addr === port.toString() || addr.endsWith(`:${port}`);
-  });
-}
-
-/**
- * Get public URL for a port, creating tunnel if needed.
- * This is the main high-level function for getting a public URL.
- */
-export async function getPublicUrl(port: number): Promise<string | undefined> {
-  // Ensure agent is running
-  if (!(await ensureAgentRunning())) {
-    return undefined;
-  }
-
-  // Check for existing tunnel
-  const existing = await findTunnelByPort(port);
-  if (existing) {
-    return existing.public_url;
-  }
-
-  // Create new tunnel
-  const tunnel = await startTunnel(port);
-  return tunnel?.public_url;
-}
-
-/**
- * Kill all ngrok processes.
- */
-export function killNgrok(): void {
-  try {
-    execSync('pkill -f "ngrok"', { stdio: "ignore" });
-  } catch {
-    // No processes to kill
-  }
-}
-
-/**
- * NgrokManager - higher-level manager with session tracking and events.
- */
-export class NgrokManager {
-  private basePath: string;
-  private eventStore: EventStore;
-
-  constructor(basePath: string = "~/.abbie/ngrok", eventStore?: EventStore) {
-    this.basePath = basePath.replace("~", process.env.HOME || "");
-    this.eventStore = eventStore || new EventStore();
-
-    if (!existsSync(this.basePath)) {
-      mkdirSync(this.basePath, { recursive: true });
-    }
-  }
-
-  /**
-   * Get stored tunnel metadata path.
-   */
-  private getMetadataPath(name: string): string {
-    return join(this.basePath, `${name}.json`);
-  }
-
-  /**
-   * Store tunnel metadata.
-   */
-  private storeMetadata(tunnel: StoredTunnel): void {
-    writeFileSync(this.getMetadataPath(tunnel.name), JSON.stringify(tunnel, null, 2));
-  }
-
-  /**
-   * Load tunnel metadata.
-   */
-  private loadMetadata(name: string): StoredTunnel | undefined {
-    const path = this.getMetadataPath(name);
-    if (!existsSync(path)) return undefined;
-    return JSON.parse(readFileSync(path, "utf-8")) as StoredTunnel;
-  }
-
-  /**
-   * Remove tunnel metadata.
-   */
-  private removeMetadata(name: string): void {
-    const path = this.getMetadataPath(name);
-    if (existsSync(path)) {
-      unlinkSync(path);
-    }
-  }
-
-  /**
-   * Start a tunnel with session tracking.
-   */
-  async start(
-    port: number,
-    sessionId: string,
-    name?: string,
-  ): Promise<{ tunnel: NgrokTunnel; public_url: string } | undefined> {
-    // Ensure agent is running
-    if (!(await ensureAgentRunning())) {
-      return undefined;
-    }
-
-    const tunnelName = name || `${sessionId.split("-")[0]}-${port}`;
-
-    // Check for existing tunnel on this port
-    const existing = await findTunnelByPort(port);
-    if (existing) {
-      return { tunnel: existing, public_url: existing.public_url };
-    }
-
-    // Create tunnel via API
-    const tunnel = await startTunnel(port, tunnelName);
-    if (!tunnel) {
-      return undefined;
-    }
-
-    // Store metadata
-    this.storeMetadata({
-      name: tunnel.name,
-      session_id: sessionId,
-      port,
-      created_at: new Date().toISOString(),
-    });
-
-    // Log event
-    this.eventStore.append(
-      createEvent.previewCreated(sessionId, "system", {
-        url: tunnel.public_url,
-        port,
-        subdomain: tunnel.name,
-      }),
-    );
-
-    return { tunnel, public_url: tunnel.public_url };
-  }
-
-  /**
-   * Stop a tunnel by name.
-   */
-  async stop(name: string): Promise<boolean> {
-    const stopped = await stopTunnel(name);
-    if (stopped) {
-      this.removeMetadata(name);
-    }
-    return stopped;
-  }
-
-  /**
-   * Stop all tunnels for a session.
-   */
-  async stopSession(sessionId: string): Promise<number> {
-    const files = existsSync(this.basePath) ? readdirSync(this.basePath) : [];
-    let stopped = 0;
-
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-
-      const name = file.replace(".json", "");
-      const metadata = this.loadMetadata(name);
-
-      if (metadata?.session_id === sessionId) {
-        if (await this.stop(name)) {
-          stopped++;
-        }
-      }
-    }
-
-    return stopped;
-  }
-
-  /**
-   * List all tunnels with metadata.
-   */
-  async list(): Promise<Array<NgrokTunnel & { metadata?: StoredTunnel }>> {
-    const tunnels = await listTunnels();
-
-    return tunnels.map((tunnel) => ({
-      ...tunnel,
-      metadata: this.loadMetadata(tunnel.name),
-    }));
-  }
-
-  /**
-   * Cleanup stale metadata (tunnels that no longer exist).
-   */
-  async cleanup(): Promise<number> {
-    if (!existsSync(this.basePath)) return 0;
-
-    const files = readdirSync(this.basePath);
-    const activeTunnels = await listTunnels();
-    const activeNames = new Set(activeTunnels.map((t) => t.name));
-    let cleaned = 0;
-
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-
-      const name = file.replace(".json", "");
-      if (!activeNames.has(name)) {
-        this.removeMetadata(name);
-        cleaned++;
-      }
-    }
-
-    return cleaned;
-  }
-}
-
-/**
- * Create an NgrokManager with default path.
- */
-export function createNgrokManager(eventStore?: EventStore): NgrokManager {
-  return new NgrokManager("~/.abbie/ngrok", eventStore);
-}
-
-// Unix pipe helpers - these output to stdout for piping
-
-/**
- * Print public URL to stdout.
- * Usage: abbie tunnel url 3000 | xargs open
- */
-export async function printPublicUrl(port: number): Promise<void> {
-  const url = await getPublicUrl(port);
-  if (url) {
-    process.stdout.write(`${url}\n`);
-  } else {
-    process.exit(1);
-  }
-}
-
-/**
- * Print all tunnel URLs to stdout.
- * Usage: abbie tunnel urls | xargs -I{} curl {}
- */
-export async function printAllUrls(): Promise<void> {
-  const tunnels = await listTunnels();
-  for (const tunnel of tunnels) {
-    process.stdout.write(`${tunnel.public_url}\n`);
-  }
-}

package/src/lib/nvim/discovery.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { ProcessInfo } from "../process/snapshot.js";
-import { buildProcessTree } from "../process/snapshot.js";
-import {
-  discoverFromArgv,
-  discoverNvimServerAddress,
-  findAllNvimInstances,
-  findNvimPidForWindow,
-} from "./discovery.js";
-
-// Mock process snapshot for testing pure functions
-function createMockSnapshot(): Map<number, ProcessInfo> {
-  const snapshot = new Map<number, ProcessInfo>();
-
-  // tmux(100) → zsh(200) → nvim(300) with --listen
-  snapshot.set(100, { pid: 100, ppid: 1, tty: "??", cmd: "tmux", args: "tmux new -s work" });
-  snapshot.set(200, {
-    pid: 200,
-    ppid: 100,
-    tty: "ttys001",
-    cmd: "zsh",
-    args: "-zsh",
-  });
-  snapshot.set(300, {
-    pid: 300,
-    ppid: 200,
-    tty: "ttys001",
-    cmd: "nvim",
-    args: "nvim --listen /tmp/nvim.300.sock src/app.ts",
-  });
-
-  // Another pane: zsh(250) → nvim(350) without --listen
-  snapshot.set(250, {
-    pid: 250,
-    ppid: 100,
-    tty: "ttys002",
-    cmd: "zsh",
-    args: "-zsh",
-  });
-  snapshot.set(350, {
-    pid: 350,
-    ppid: 250,
-    tty: "ttys002",
-    cmd: "nvim",
-    args: "nvim src/other.ts",
-  });
-
-  // Nested nvim: zsh(400) → nvim(410) → nvim(420)
-  snapshot.set(400, {
-    pid: 400,
-    ppid: 100,
-    tty: "ttys003",
-    cmd: "zsh",
-    args: "-zsh",
-  });
-  snapshot.set(410, {
-    pid: 410,
-    ppid: 400,
-    tty: "ttys003",
-    cmd: "nvim",
-    args: "nvim outer.ts",
-  });
-  snapshot.set(420, {
-    pid: 420,
-    ppid: 410,
-    tty: "ttys003",
-    cmd: "nvim",
-    args: "nvim --listen=/tmp/nested.sock inner.ts",
-  });
-
-  return snapshot;
-}
-
-describe("nvim discovery", () => {
-  describe("findNvimPidForWindow", () => {
-    it("finds nvim under pane", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-
-      const nvimPid = findNvimPidForWindow(200, snapshot, tree);
-      expect(nvimPid).toBe(300);
-    });
-
-    it("prefers deepest nested nvim", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-
-      // Starting from zsh(400), should find the nested nvim(420), not outer nvim(410)
-      const nvimPid = findNvimPidForWindow(400, snapshot, tree);
-      expect(nvimPid).toBe(420);
-    });
-
-    it("returns null when no nvim found", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-
-      // tmux(100) has no direct nvim child (nvim is under zsh)
-      // but findDeepestDescendant searches all descendants
-      const nvimPid = findNvimPidForWindow(100, snapshot, tree);
-      // Should find one of the nvims under tmux
-      expect(nvimPid).not.toBeNull();
-    });
-  });
-
-  describe("discoverFromArgv", () => {
-    it("parses --listen with space", () => {
-      const snapshot = createMockSnapshot();
-      const addr = discoverFromArgv(300, snapshot);
-      expect(addr).toBe("/tmp/nvim.300.sock");
-    });
-
-    it("parses --listen= form", () => {
-      const snapshot = createMockSnapshot();
-      const addr = discoverFromArgv(420, snapshot);
-      expect(addr).toBe("/tmp/nested.sock");
-    });
-
-    it("returns null when no --listen", () => {
-      const snapshot = createMockSnapshot();
-      const addr = discoverFromArgv(350, snapshot);
-      expect(addr).toBeNull();
-    });
-
-    it("returns null for unknown PID", () => {
-      const snapshot = createMockSnapshot();
-      const addr = discoverFromArgv(9999, snapshot);
-      expect(addr).toBeNull();
-    });
-  });
-
-  describe("discoverNvimServerAddress", () => {
-    it("uses argv when --listen present", async () => {
-      const snapshot = createMockSnapshot();
-      const result = await discoverNvimServerAddress(300, snapshot);
-
-      expect(result).toEqual({ addr: "/tmp/nvim.300.sock", method: "argv" });
-    });
-
-    // Note: lsof fallback tests require actual system state or dependency injection.
-    // These are integration tests that would need a real nvim process.
-    // For unit testing the lsof path, we'd need to refactor discovery.ts
-    // to accept an executor function as a parameter.
-  });
-
-  describe("findAllNvimInstances", () => {
-    it("finds all nvim PIDs", () => {
-      const snapshot = createMockSnapshot();
-      const nvimPids = findAllNvimInstances(snapshot);
-
-      expect(nvimPids).toContain(300);
-      expect(nvimPids).toContain(350);
-      expect(nvimPids).toContain(410);
-      expect(nvimPids).toContain(420);
-      expect(nvimPids).toHaveLength(4);
-    });
-  });
-});