@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/tunnel/start.ts

@@ -1,122 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { createNgrokManager, ensureAgentRunning } from "../../../lib/ngrok.js";
-import { createResourceManager } from "../../../lib/resources.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TunnelStart extends BaseCommand {
-  static override description = "Start an ngrok tunnel for a local port";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> tunnel start 3000",
-    "<%= config.bin %> tunnel start 3000 --session SESSION_ID",
-    "<%= config.bin %> tunnel start 8080 --name myapp --json",
-    "echo 3000 | <%= config.bin %> tunnel start",
-  ];
-
-  static override args = {
-    port: Args.integer({
-      description: "Local port to tunnel",
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Session ID for resource tracking",
-    }),
-    name: Flags.string({
-      char: "n",
-      description: "Tunnel name",
-    }),
-    "skip-resource": Flags.boolean({
-      description: "Skip resource semaphore acquisition",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(TunnelStart);
-    this.parsedFlags = flags;
-
-    // Support stdin for port
-    let port = args.port;
-    if (!port) {
-      // Read from stdin if available
-      const stdin = await this.tryReadStdin();
-      if (stdin) {
-        port = parseInt(stdin.trim(), 10);
-      }
-    }
-
-    if (!port || Number.isNaN(port)) {
-      this.error("Port is required. Provide as argument or via stdin.");
-    }
-
-    const sessionId = flags.session || `tunnel-${Date.now().toString(36)}`;
-
-    // Acquire ngrok resource slot (unless skipped)
-    if (!flags["skip-resource"]) {
-      const resources = createResourceManager();
-      const lease = resources.acquire("ngrok_tunnel", sessionId, "system");
-      if (!lease) {
-        if (flags.json || flags.format === "json") {
-          return { success: false, reason: "No ngrok slots available" };
-        }
-        this.error("No ngrok slots available. Use --skip-resource to bypass.");
-      }
-    }
-
-    // Ensure agent is running
-    if (!(await ensureAgentRunning())) {
-      if (flags.json || flags.format === "json") {
-        return { success: false, reason: "Failed to start ngrok agent" };
-      }
-      this.error("Failed to start ngrok agent");
-    }
-
-    const ngrok = createNgrokManager();
-    const result = await ngrok.start(port, sessionId, flags.name);
-
-    if (!result) {
-      if (flags.json || flags.format === "json") {
-        return { success: false, reason: "Failed to create tunnel" };
-      }
-      this.error("Failed to create tunnel");
-    }
-
-    if (flags.json || flags.format === "json") {
-      return {
-        success: true,
-        tunnel: {
-          name: result.tunnel.name,
-          public_url: result.public_url,
-          port,
-          session_id: sessionId,
-        },
-      };
-    }
-
-    // Unix pipe output: just the URL
-    this.log(result.public_url);
-    return { success: true, public_url: result.public_url };
-  }
-
-  private async tryReadStdin(): Promise<string | undefined> {
-    if (process.stdin.isTTY) return undefined;
-
-    return new Promise((resolve) => {
-      let data = "";
-      process.stdin.setEncoding("utf8");
-      process.stdin.on("data", (chunk) => {
-        data += chunk;
-      });
-      process.stdin.on("end", () => {
-        resolve(data || undefined);
-      });
-      // Timeout after 100ms if no stdin
-      setTimeout(() => resolve(data || undefined), 100);
-    });
-  }
-}

package/src/cli/commands/tunnel/stop.ts

@@ -1,108 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { createNgrokManager, killNgrok, listTunnels, stopTunnel } from "../../../lib/ngrok.js";
-import { createResourceManager } from "../../../lib/resources.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TunnelStop extends BaseCommand {
-  static override description = "Stop ngrok tunnels";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> tunnel stop myapp",
-    "<%= config.bin %> tunnel stop --session SESSION_ID",
-    "<%= config.bin %> tunnel stop --all",
-    "<%= config.bin %> tunnel stop --kill",
-  ];
-
-  static override args = {
-    name: Args.string({
-      description: "Tunnel name to stop",
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Stop all tunnels for a session",
-    }),
-    all: Flags.boolean({
-      description: "Stop all tunnels",
-      default: false,
-    }),
-    kill: Flags.boolean({
-      char: "k",
-      description: "Kill ngrok agent entirely",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(TunnelStop);
-    this.parsedFlags = flags;
-
-    const ngrok = createNgrokManager();
-    const resources = createResourceManager();
-
-    // Kill ngrok agent entirely
-    if (flags.kill) {
-      killNgrok();
-      if (flags.json || flags.format === "json") {
-        return { success: true, action: "killed" };
-      }
-      this.logInfo("Killed ngrok agent");
-      return { success: true };
-    }
-
-    // Stop all tunnels
-    if (flags.all) {
-      const tunnels = await listTunnels();
-      let stopped = 0;
-
-      for (const tunnel of tunnels) {
-        if (await stopTunnel(tunnel.name)) {
-          stopped++;
-        }
-      }
-
-      if (flags.json || flags.format === "json") {
-        return { success: true, stopped };
-      }
-
-      this.logInfo(`Stopped ${stopped} tunnel(s)`);
-      return { success: true, stopped };
-    }
-
-    // Stop tunnels for a session
-    if (flags.session) {
-      const stopped = await ngrok.stopSession(flags.session);
-      resources.release("ngrok_tunnel", flags.session);
-
-      if (flags.json || flags.format === "json") {
-        return { success: true, stopped };
-      }
-
-      this.logInfo(`Stopped ${stopped} tunnel(s) for session ${flags.session}`);
-      return { success: true, stopped };
-    }
-
-    // Stop specific tunnel by name
-    if (!args.name) {
-      this.error("Provide tunnel name, --session, --all, or --kill");
-    }
-
-    const stopped = await ngrok.stop(args.name);
-
-    if (flags.json || flags.format === "json") {
-      return { success: stopped };
-    }
-
-    if (stopped) {
-      this.logInfo(`Stopped tunnel: ${args.name}`);
-    } else {
-      this.error(`Tunnel not found: ${args.name}`);
-    }
-
-    return { success: stopped };
-  }
-}

package/src/cli/commands/tunnel/url.ts

@@ -1,82 +0,0 @@
-import { Args } from "@oclif/core";
-import { findTunnelByPort, getPublicUrl } from "../../../lib/ngrok.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TunnelUrl extends BaseCommand {
-  static override description = "Get public URL for a port (creates tunnel if needed)";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> tunnel url 3000",
-    "<%= config.bin %> tunnel url 3000 | xargs open",
-    "<%= config.bin %> tunnel url 3000 | pbcopy",
-    "echo 8080 | <%= config.bin %> tunnel url",
-  ];
-
-  static override args = {
-    port: Args.integer({
-      description: "Local port",
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(TunnelUrl);
-    this.parsedFlags = flags;
-
-    // Support stdin for port
-    let port = args.port;
-    if (!port) {
-      const stdin = await this.tryReadStdin();
-      if (stdin) {
-        port = parseInt(stdin.trim(), 10);
-      }
-    }
-
-    if (!port || Number.isNaN(port)) {
-      this.error("Port is required");
-    }
-
-    const url = await getPublicUrl(port);
-
-    if (!url) {
-      if (flags.json || flags.format === "json") {
-        return { success: false, port };
-      }
-      process.exit(1);
-    }
-
-    if (flags.json || flags.format === "json") {
-      const tunnel = await findTunnelByPort(port);
-      return {
-        success: true,
-        port,
-        public_url: url,
-        name: tunnel?.name,
-      };
-    }
-
-    // Unix pipe output: just the URL
-    this.log(url);
-    return { success: true, url };
-  }
-
-  private async tryReadStdin(): Promise<string | undefined> {
-    if (process.stdin.isTTY) return undefined;
-
-    return new Promise((resolve) => {
-      let data = "";
-      process.stdin.setEncoding("utf8");
-      process.stdin.on("data", (chunk) => {
-        data += chunk;
-      });
-      process.stdin.on("end", () => {
-        resolve(data || undefined);
-      });
-      setTimeout(() => resolve(data || undefined), 100);
-    });
-  }
-}

package/src/cli/commands/web/start.ts

@@ -1,125 +0,0 @@
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { Flags } from "@oclif/core";
-import { BaseCommand } from "../../base-command.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-export default class WebStartCommand extends BaseCommand {
-  static override description = "Start web UI for agent monitoring and control";
-  static override hidden = false;
-  static override aliases = ["web"];
-
-  static override examples = [
-    "<%= config.bin %> web start",
-    "<%= config.bin %> web start --port 5173",
-    "<%= config.bin %> web start --host 0.0.0.0",
-    "<%= config.bin %> web start --tunnel",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    port: Flags.integer({
-      char: "p",
-      description: "Port to listen on",
-      default: 5173,
-    }),
-    host: Flags.string({
-      char: "H",
-      description: "Host to bind to",
-      default: "localhost",
-    }),
-    tunnel: Flags.boolean({
-      description: "Enable Tailscale tunnel for remote access (not yet implemented)",
-      default: false,
-    }),
-    open: Flags.boolean({
-      char: "o",
-      description: "Open browser after starting",
-      default: false,
-    }),
-    dev: Flags.boolean({
-      description: "Development mode (expect Next.js dev server on port 5173)",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(WebStartCommand);
-    this.parsedFlags = flags;
-
-    const url = `http://${flags.host}:${flags.port}`;
-
-    if (flags.json || flags.format === "json") {
-      const packageRoot = join(__dirname, "..", "..", "..", "..");
-      const repoRoot = join(packageRoot, "..", "..");
-      const appDir = join(repoRoot, "apps", "app");
-      return {
-        url,
-        port: flags.port,
-        host: flags.host,
-        dev: flags.dev,
-        appDir,
-      };
-    }
-
-    this.log(`
-╭─────────────────────────────────────────────╮
-│                                             │
-│   abbie web                                │
-│                                             │
-│   Local:   ${url.padEnd(28)}│
-│                                             │
-${flags.dev ? "│   Mode:    Development (Next.js dev)       │\n" : ""}│   Press Ctrl+C to stop                     │
-│                                             │
-╰─────────────────────────────────────────────╯
-`);
-
-    if (flags.open) {
-      const openUrl = url;
-      // Open browser (macOS)
-      const { spawn } = await import("node:child_process");
-      spawn("open", [openUrl], { stdio: "ignore", detached: true }).unref();
-    }
-
-    if (flags.tunnel) {
-      this.logWarn("Tailscale tunnel not yet implemented");
-    }
-
-    // Start the canonical Next.js app (apps/app)
-    const packageRoot = join(__dirname, "..", "..", "..", "..");
-    const repoRoot = join(packageRoot, "..", "..");
-    const appDir = join(repoRoot, "apps", "app");
-
-    const { spawn } = await import("node:child_process");
-    const cmd = "pnpm";
-    const baseArgs = ["-C", appDir, "exec", "next"];
-    const nextArgs = flags.dev
-      ? ["dev", "-p", String(flags.port), "-H", flags.host]
-      : ["start", "-p", String(flags.port), "-H", flags.host];
-
-    const headerSizeFlag = "--max-http-header-size=131072";
-    const existingNodeOptions = process.env.NODE_OPTIONS ?? "";
-    const nextNodeOptions = existingNodeOptions.includes(headerSizeFlag)
-      ? existingNodeOptions
-      : `${existingNodeOptions} ${headerSizeFlag}`.trim();
-
-    const child = spawn(cmd, [...baseArgs, ...nextArgs], {
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        NODE_OPTIONS: nextNodeOptions,
-      },
-    });
-
-    await new Promise<void>((resolve, reject) => {
-      child.on("exit", (code) => {
-        if (code === 0) resolve();
-        reject(new Error(`Next.js exited with code ${code ?? "unknown"}`));
-      });
-      child.on("error", reject);
-    });
-
-    return;
-  }
-}