whale-code 6.4.0

package/dist/cli/services/background-processes.js

@@ -0,0 +1,318 @@
+/**
+ * Background Process Management — Claude Code-style async shell execution
+ *
+ * Enables running long-running processes (dev servers, watchers, builds)
+ * without blocking the agent loop.
+ *
+ * Tools:
+ * - run_command with run_in_background: true
+ * - bash_output: Read output from running/completed process
+ * - kill_shell: Terminate a background process
+ */
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+// ============================================================================
+// PROCESS REGISTRY — in-memory store of running/completed processes
+// ============================================================================
+const processes = new Map();
+const MAX_BUFFER_LINES = 10000;
+const MAX_PROCESSES = 20;
+// ============================================================================
+// HELPERS
+// ============================================================================
+function generateProcessId() {
+    return `shell-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function cleanOldProcesses() {
+    // Remove oldest completed/failed processes if we're at capacity
+    const procs = Array.from(processes.values());
+    const completed = procs
+        .filter((p) => p.status !== "running")
+        .sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
+    while (processes.size >= MAX_PROCESSES && completed.length > 0) {
+        const oldest = completed.shift();
+        processes.delete(oldest.id);
+    }
+}
+// ============================================================================
+// SPAWN BACKGROUND PROCESS
+// ============================================================================
+export async function spawnBackground(command, options = {}) {
+    cleanOldProcesses();
+    const id = generateProcessId();
+    const cwd = options.cwd || process.cwd();
+    const timeout = options.timeout || 600_000; // 10 minutes default
+    const proc = {
+        id,
+        command,
+        cwd,
+        startedAt: new Date(),
+        status: "running",
+        outputBuffer: [],
+        errorBuffer: [],
+        process: null,
+        lastReadIndex: 0,
+        lastErrorReadIndex: 0,
+    };
+    // Spawn with shell
+    let child;
+    try {
+        child = spawn(command, [], {
+            shell: true,
+            cwd,
+            env: { ...process.env, FORCE_COLOR: "0" },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        return { id, message: `Failed to spawn: ${err.message}`, status: "failed" };
+    }
+    proc.process = child;
+    // Capture stdout
+    child.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+            if (line.trim()) {
+                proc.outputBuffer.push(line);
+                if (proc.outputBuffer.length > MAX_BUFFER_LINES) {
+                    proc.outputBuffer.splice(0, proc.outputBuffer.length - MAX_BUFFER_LINES);
+                }
+            }
+        }
+    });
+    // Capture stderr
+    child.stderr?.on("data", (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+            if (line.trim()) {
+                proc.errorBuffer.push(line);
+                if (proc.errorBuffer.length > MAX_BUFFER_LINES) {
+                    proc.errorBuffer.splice(0, proc.errorBuffer.length - MAX_BUFFER_LINES);
+                }
+            }
+        }
+    });
+    // Handle exit
+    child.on("exit", (code) => {
+        proc.status = code === 0 ? "completed" : "failed";
+        proc.exitCode = code ?? undefined;
+        proc.process = null;
+    });
+    child.on("error", (err) => {
+        proc.status = "failed";
+        proc.errorBuffer.push(`Process error: ${err.message}`);
+        proc.process = null;
+    });
+    // Timeout kill
+    setTimeout(() => {
+        if (proc.status === "running" && proc.process) {
+            proc.process.kill("SIGTERM");
+            proc.status = "killed";
+            proc.errorBuffer.push(`Process killed after ${timeout}ms timeout`);
+        }
+    }, timeout);
+    processes.set(id, proc);
+    // ── Validation wait — give process 1.5s to start or fail ──
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    // Build result with validation
+    const lines = [];
+    if (proc.status === "failed") {
+        lines.push(`✕ Process failed immediately`);
+        lines.push(`  Command: ${command}`);
+        if (proc.errorBuffer.length > 0)
+            lines.push(`  Error: ${proc.errorBuffer.join("\n  ")}`);
+        if (proc.exitCode !== undefined)
+            lines.push(`  Exit code: ${proc.exitCode}`);
+        return { id, message: lines.join("\n"), status: "failed" };
+    }
+    lines.push(`✓ Background process running`);
+    lines.push(`  PID: ${child.pid || "?"}`);
+    lines.push(`  ID: ${id}`);
+    lines.push(`  Command: ${command}`);
+    if (proc.outputBuffer.length > 0) {
+        lines.push(`  Initial output (${proc.outputBuffer.length} lines):`);
+        for (const l of proc.outputBuffer.slice(0, 8)) {
+            lines.push(`    ${l}`);
+        }
+        if (proc.outputBuffer.length > 8)
+            lines.push(`    ... +${proc.outputBuffer.length - 8} more lines`);
+    }
+    if (proc.errorBuffer.length > 0) {
+        lines.push(`  Stderr (${proc.errorBuffer.length} lines):`);
+        for (const l of proc.errorBuffer.slice(0, 4)) {
+            lines.push(`    ${l}`);
+        }
+    }
+    lines.push(`  Use bash_output("${id}") to check output, kill_shell("${id}") to stop.`);
+    return { id, message: lines.join("\n"), status: "running" };
+}
+// ============================================================================
+// READ OUTPUT
+// ============================================================================
+export function readProcessOutput(id, options = {}) {
+    const proc = processes.get(id);
+    if (!proc) {
+        // Try partial match
+        const match = Array.from(processes.keys()).find(k => k.includes(id));
+        if (match)
+            return readProcessOutput(match, options);
+        return { error: `Process not found: ${id}. Use list_shells to see available processes.` };
+    }
+    // Get new output since last read (separate indices for stdout/stderr)
+    const newStdout = proc.outputBuffer.slice(proc.lastReadIndex);
+    const newStderr = proc.errorBuffer.slice(proc.lastErrorReadIndex);
+    // Update read indices
+    proc.lastReadIndex = proc.outputBuffer.length;
+    proc.lastErrorReadIndex = proc.errorBuffer.length;
+    // Apply filter if provided
+    let filteredOutput = newStdout;
+    let filteredErrors = newStderr;
+    if (options.filter) {
+        try {
+            const regex = new RegExp(options.filter, "i");
+            filteredOutput = newStdout.filter((line) => regex.test(line));
+            filteredErrors = newStderr.filter((line) => regex.test(line));
+        }
+        catch {
+            // Invalid regex, return unfiltered
+        }
+    }
+    return {
+        id,
+        status: proc.status,
+        newOutput: filteredOutput.join("\n"),
+        newErrors: filteredErrors.join("\n"),
+        exitCode: proc.exitCode,
+    };
+}
+// ============================================================================
+// KILL PROCESS
+// ============================================================================
+export function killProcess(id) {
+    const proc = processes.get(id);
+    if (!proc) {
+        return { success: false, message: `Process not found: ${id}` };
+    }
+    if (proc.status !== "running") {
+        return { success: false, message: `Process already ${proc.status}` };
+    }
+    if (proc.process) {
+        proc.process.kill("SIGTERM");
+        // Force kill after 5 seconds if still running
+        setTimeout(() => {
+            if (proc.process) {
+                proc.process.kill("SIGKILL");
+            }
+        }, 5000);
+    }
+    proc.status = "killed";
+    return { success: true, message: `Process ${id} killed` };
+}
+// ============================================================================
+// LIST PROCESSES
+// ============================================================================
+export function listProcesses() {
+    const now = Date.now();
+    return Array.from(processes.values()).map((p) => {
+        const runtimeMs = now - p.startedAt.getTime();
+        const runtimeSec = Math.floor(runtimeMs / 1000);
+        const runtime = runtimeSec < 60
+            ? `${runtimeSec}s`
+            : runtimeSec < 3600
+                ? `${Math.floor(runtimeSec / 60)}m ${runtimeSec % 60}s`
+                : `${Math.floor(runtimeSec / 3600)}h ${Math.floor((runtimeSec % 3600) / 60)}m`;
+        return {
+            id: p.id,
+            pid: p.process?.pid,
+            command: p.command.length > 50 ? p.command.slice(0, 47) + "..." : p.command,
+            status: p.status,
+            startedAt: p.startedAt.toISOString(),
+            runtime,
+            outputLines: p.outputBuffer.length,
+            errorLines: p.errorBuffer.length,
+        };
+    });
+}
+const bgAgents = new Map();
+export function registerBackgroundAgent(id, type, outputFile) {
+    bgAgents.set(id, { id, type, outputFile, startTime: Date.now(), status: "running" });
+}
+export function getAgentStatus(id) {
+    return bgAgents.get(id) || null;
+}
+export function markAgentDone(id, success) {
+    const agent = bgAgents.get(id);
+    if (agent)
+        agent.status = success ? "completed" : "failed";
+}
+export function readAgentOutput(id) {
+    const agent = bgAgents.get(id);
+    if (!agent)
+        return null;
+    try {
+        const content = existsSync(agent.outputFile) ? readFileSync(agent.outputFile, "utf-8") : "(no output yet)";
+        return { status: agent.status, output: content };
+    }
+    catch {
+        return { status: agent.status, output: "(failed to read output file)" };
+    }
+}
+export function listBackgroundAgents() {
+    return Array.from(bgAgents.values());
+}
+export function stopBackgroundAgent(id) {
+    const agent = bgAgents.get(id);
+    if (!agent)
+        return { success: false, message: `Agent not found: ${id}` };
+    if (agent.status !== "running")
+        return { success: false, message: `Agent already ${agent.status}` };
+    // We can't kill the async promise, but we mark it as failed so it won't be waited on
+    agent.status = "failed";
+    return { success: true, message: `Agent ${id} marked as stopped` };
+}
+// ============================================================================
+// TOOL DEFINITIONS
+// ============================================================================
+export const BACKGROUND_TOOL_DEFINITIONS = [
+    {
+        name: "bash_output",
+        description: "Read output from a running or completed background shell process. Returns only NEW output since the last read.",
+        input_schema: {
+            type: "object",
+            properties: {
+                bash_id: {
+                    type: "string",
+                    description: "The process ID returned when starting the background process",
+                },
+                filter: {
+                    type: "string",
+                    description: "Optional regex to filter output lines (only matching lines returned)",
+                },
+            },
+            required: ["bash_id"],
+        },
+    },
+    {
+        name: "kill_shell",
+        description: "Terminate a running background shell process",
+        input_schema: {
+            type: "object",
+            properties: {
+                shell_id: {
+                    type: "string",
+                    description: "The process ID to kill",
+                },
+            },
+            required: ["shell_id"],
+        },
+    },
+    {
+        name: "list_shells",
+        description: "List all background shell processes (running and recent completed)",
+        input_schema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+];

package/dist/cli/services/browser-auth.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browser-based OAuth login for CLI and MCP
+ *
+ * Opens the user's browser to whaletools.dev/auth/cli, which handles
+ * email/password (and future SSO), then redirects back to a localhost
+ * callback with a one-time code. The CLI exchanges that code for tokens.
+ *
+ * Same pattern as: `gh auth login`, `vercel login`, `claude login`
+ */
+import { type SwagManagerConfig } from "./config-store.js";
+import type { StoreInfo } from "./auth-service.js";
+export interface BrowserAuthCallbacks {
+    onBrowserOpening?: (url: string) => void;
+    onWaitingForCallback?: () => void;
+    onExchangingCode?: () => void;
+}
+export interface BrowserAuthResult {
+    success: boolean;
+    error?: string;
+    config?: SwagManagerConfig;
+    stores?: StoreInfo[];
+}
+export declare function openBrowser(url: string): void;
+export declare function signInWithBrowser(platformUrl?: string, callbacks?: BrowserAuthCallbacks, timeoutMs?: number): Promise<BrowserAuthResult>;

package/dist/cli/services/browser-auth.js

@@ -0,0 +1,180 @@
+/**
+ * Browser-based OAuth login for CLI and MCP
+ *
+ * Opens the user's browser to whaletools.dev/auth/cli, which handles
+ * email/password (and future SSO), then redirects back to a localhost
+ * callback with a one-time code. The CLI exchanges that code for tokens.
+ *
+ * Same pattern as: `gh auth login`, `vercel login`, `claude login`
+ */
+import http from "node:http";
+import { exec } from "node:child_process";
+import { loadConfig, saveConfig } from "./config-store.js";
+const DEFAULT_PLATFORM_URL = "https://whaletools.dev";
+const DEFAULT_TIMEOUT_MS = 120_000; // 2 minutes
+// ============================================================================
+// OPEN BROWSER (cross-platform)
+// ============================================================================
+export function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === "darwin" ? "open" :
+        platform === "win32" ? "start" :
+            "xdg-open";
+    exec(`${cmd} "${url}"`, (err) => {
+        if (err) {
+            // Non-fatal — user can manually open the URL
+            console.error(`[browser-auth] Failed to open browser: ${err.message}`);
+        }
+    });
+}
+// ============================================================================
+// BROWSER AUTH FLOW
+// ============================================================================
+export async function signInWithBrowser(platformUrl, callbacks, timeoutMs) {
+    const platform = platformUrl || process.env.WHALETOOLS_PLATFORM_URL || loadConfig().platform_url || DEFAULT_PLATFORM_URL;
+    const timeout = timeoutMs || DEFAULT_TIMEOUT_MS;
+    const state = crypto.randomUUID();
+    return new Promise((resolve) => {
+        let settled = false;
+        let timeoutId;
+        let httpServer;
+        function finish(result) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            try {
+                httpServer?.close();
+            }
+            catch { }
+            resolve(result);
+        }
+        // Start localhost callback server on random port
+        httpServer = http.createServer(async (req, res) => {
+            const url = new URL(req.url || "/", `http://localhost`);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const returnedState = url.searchParams.get("state");
+            // CSRF check
+            if (returnedState !== state) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(errorPage("Security error: state mismatch. Please try again."));
+                finish({ success: false, error: "State mismatch — possible CSRF attack" });
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(errorPage("Missing auth code. Please try again."));
+                finish({ success: false, error: "No auth code received" });
+                return;
+            }
+            // Show success page immediately (before exchange — reduces perceived latency)
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(successPage());
+            callbacks?.onExchangingCode?.();
+            // Exchange the one-time code for tokens
+            try {
+                const exchangeRes = await fetch(`${platform}/api/auth/cli/exchange`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ code }),
+                });
+                const data = await exchangeRes.json();
+                if (!exchangeRes.ok || data.error) {
+                    finish({ success: false, error: data.error || "Failed to exchange auth code" });
+                    return;
+                }
+                // data = { access_token, refresh_token, user_id, email, expires_at, stores }
+                const config = {
+                    ...loadConfig(),
+                    access_token: data.access_token,
+                    refresh_token: data.refresh_token,
+                    user_id: data.user_id,
+                    email: data.email,
+                    expires_at: data.expires_at,
+                    platform_url: platform !== DEFAULT_PLATFORM_URL ? platform : undefined,
+                };
+                const stores = data.stores || [];
+                // Auto-select store if user has exactly one
+                if (stores.length === 1) {
+                    config.store_id = stores[0].id;
+                    config.store_name = stores[0].name;
+                }
+                saveConfig(config);
+                finish({
+                    success: true,
+                    config,
+                    stores: stores.length > 1 ? stores : undefined,
+                });
+            }
+            catch (err) {
+                finish({
+                    success: false,
+                    error: `Code exchange failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        });
+        httpServer.listen(0, "127.0.0.1", () => {
+            const addr = httpServer.address();
+            if (!addr || typeof addr === "string") {
+                finish({ success: false, error: "Failed to bind callback server" });
+                return;
+            }
+            const port = addr.port;
+            const loginUrl = `${platform}/auth/cli?port=${port}&state=${state}`;
+            callbacks?.onBrowserOpening?.(loginUrl);
+            openBrowser(loginUrl);
+            callbacks?.onWaitingForCallback?.();
+        });
+        // Timeout
+        timeoutId = setTimeout(() => {
+            finish({
+                success: false,
+                error: "Login timed out. Please try again with `whale login`.",
+            });
+        }, timeout);
+        // Handle server errors
+        httpServer.on("error", (err) => {
+            finish({ success: false, error: `Callback server error: ${err.message}` });
+        });
+    });
+}
+// ============================================================================
+// HTML PAGES (served by localhost callback)
+// ============================================================================
+function successPage() {
+    return `<!DOCTYPE html>
+<html><head><title>Whale Code — Signed In</title>
+<style>
+  body { background: #0a0a0a; color: #f5f5f7; font-family: -apple-system, BlinkMacSystemFont, sans-serif;
+    display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; }
+  .box { text-align: center; max-width: 400px; }
+  h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+  p { color: #a1a1a6; font-size: 0.9rem; }
+  .check { font-size: 3rem; margin-bottom: 1rem; color: #30d158; }
+</style></head>
+<body><div class="box">
+  <div class="check">&#10003;</div>
+  <h1>Signed in!</h1>
+  <p>You can close this window and return to your terminal.</p>
+</div></body></html>`;
+}
+function errorPage(message) {
+    return `<!DOCTYPE html>
+<html><head><title>Whale Code — Error</title>
+<style>
+  body { background: #0a0a0a; color: #f5f5f7; font-family: -apple-system, BlinkMacSystemFont, sans-serif;
+    display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; }
+  .box { text-align: center; max-width: 400px; }
+  h1 { font-size: 1.5rem; margin-bottom: 0.5rem; color: #ff453a; }
+  p { color: #a1a1a6; font-size: 0.9rem; }
+</style></head>
+<body><div class="box">
+  <h1>Authentication Error</h1>
+  <p>${message}</p>
+</div></body></html>`;
+}

package/dist/cli/services/claude-md-loader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CLAUDE.md Loader — auto-load project instructions from cwd + parents
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+export declare function loadClaudeMd(): {
+    content: string;
+    path: string;
+} | null;
+export declare function reloadClaudeMd(): {
+    content: string;
+    path: string;
+} | null;
+/** Reset CLAUDE.md cache (called by resetSessionState) */
+export declare function resetClaudeMdCache(): void;

package/dist/cli/services/claude-md-loader.js

@@ -0,0 +1,58 @@
+/**
+ * CLAUDE.md Loader — auto-load project instructions from cwd + parents
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import { readFileSync, existsSync } from "fs";
+import { join, resolve, dirname } from "path";
+/** CLI-only: cached CLAUDE.md content (cleared by reloadClaudeMd/resetClaudeMdCache) */
+let cachedClaudeMd = null;
+/** CLI-only: cached CLAUDE.md path */
+let cachedClaudeMdPath = null;
+function findClaudeMd(startDir) {
+    const cwd = startDir || process.cwd();
+    const checked = new Set();
+    // Walk up from cwd looking for CLAUDE.md
+    let dir = resolve(cwd);
+    while (dir && !checked.has(dir)) {
+        checked.add(dir);
+        const candidates = [
+            join(dir, "CLAUDE.md"),
+            join(dir, ".claude", "CLAUDE.md"),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                try {
+                    const content = readFileSync(candidate, "utf-8");
+                    if (content.trim())
+                        return { content: content.trim(), path: candidate };
+                }
+                catch { /* skip unreadable */ }
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function loadClaudeMd() {
+    if (cachedClaudeMd !== null)
+        return cachedClaudeMd ? { content: cachedClaudeMd, path: cachedClaudeMdPath } : null;
+    const result = findClaudeMd();
+    cachedClaudeMd = result?.content || "";
+    cachedClaudeMdPath = result?.path || null;
+    return result;
+}
+export function reloadClaudeMd() {
+    cachedClaudeMd = null;
+    cachedClaudeMdPath = null;
+    return loadClaudeMd();
+}
+/** Reset CLAUDE.md cache (called by resetSessionState) */
+export function resetClaudeMdCache() {
+    cachedClaudeMd = null;
+    cachedClaudeMdPath = null;
+}

package/dist/cli/services/config-store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Config Store
+ *
+ * Persistent configuration at ~/.swagmanager/config.json
+ *
+ * v2.0: Raw Supabase/Anthropic keys (for MCP server env vars)
+ * v2.1: Auth tokens from login flow (for CLI chat/status)
+ *
+ * Environment variables always override file-based config for MCP server mode.
+ */
+export interface SwagManagerConfig {
+    supabase_url?: string;
+    supabase_key?: string;
+    anthropic_api_key?: string;
+    default_agent_id?: string;
+    access_token?: string;
+    refresh_token?: string;
+    user_id?: string;
+    email?: string;
+    store_id?: string;
+    store_name?: string;
+    expires_at?: number;
+    default_model?: string;
+    thinking_enabled?: boolean;
+    permission_mode?: string;
+    agent_api_key?: string;
+    platform_url?: string;
+}
+export declare function loadConfig(): SwagManagerConfig;
+export declare function saveConfig(config: SwagManagerConfig): void;
+export declare function updateConfig(partial: Partial<SwagManagerConfig>): void;
+export declare function clearConfig(): void;
+export interface ResolvedConfig {
+    supabaseUrl: string;
+    supabaseKey: string;
+    storeId: string;
+    anthropicApiKey: string;
+    defaultAgentId: string;
+    serverUrl: string;
+    platformUrl: string;
+}
+/** Default Fly.io agent server URL */
+export declare const WHALE_SERVER_URL = "https://whale-agent.fly.dev";
+export declare function resolveConfig(): ResolvedConfig;
+export declare function getConfigPath(): string;
+/** Lazy proxy URL — avoids reading config at import time */
+export declare function getProxyUrl(): string;