@honeybee-ai/waggle-cli 1.0.21 → 1.0.23

package/dist/commands/funnel.js

@@ -0,0 +1,1031 @@
+/**
+ * wgl funnel — connect local tools to a Colony hive.
+ *
+ * Opens an outbound WebSocket to Colony, registers available tools,
+ * and dispatches incoming tool_call messages to local handlers.
+ *
+ * Uses Node 22 native WebSocket — no npm dependency.
+ */
+import { c, error, success, heading, label } from '../lib/format.js';
+import { hostname, loadavg, homedir } from 'node:os';
+import { resolve, relative, join } from 'node:path';
+// --- HMAC verification (mirrors colony/src/durable-objects/funnel-hmac.ts) ---
+const HMAC_ALGO = { name: 'HMAC', hash: 'SHA-256' };
+async function importSigningKey(rawBase64) {
+    const binaryStr = atob(rawBase64);
+    const bytes = new Uint8Array(binaryStr.length);
+    for (let i = 0; i < binaryStr.length; i++) {
+        bytes[i] = binaryStr.charCodeAt(i);
+    }
+    return crypto.subtle.importKey('raw', bytes, HMAC_ALGO, false, ['verify']);
+}
+async function verifyHmac(key, payload, sig) {
+    const enc = new TextEncoder();
+    const sigBytes = new Uint8Array(sig.length / 2);
+    for (let i = 0; i < sig.length; i += 2) {
+        sigBytes[i / 2] = parseInt(sig.slice(i, i + 2), 16);
+    }
+    return crypto.subtle.verify('HMAC', key, sigBytes, enc.encode(payload));
+}
+function buildSignPayload(callId, tool, args, nonce) {
+    return JSON.stringify({ callId, tool, args, nonce });
+}
+// --- Main ---
+export async function funnel(args) {
+    const sub = args[0];
+    if (sub === '--help' || sub === '-h') {
+        showHelp();
+        return;
+    }
+    if (sub === 'status') {
+        await showStatus();
+        return;
+    }
+    if (sub === 'install') {
+        await installDaemon(args.slice(1));
+        return;
+    }
+    if (sub === 'uninstall') {
+        await uninstallDaemon();
+        return;
+    }
+    // Default: start funnel
+    await startFunnel(args);
+}
+function showHelp() {
+    console.log(`
+${c('bold', 'wgl funnel')} — connect local tools to a Colony hive
+
+${c('cyan', 'USAGE:')}
+  wgl funnel [options]           Start funnel (connects to Colony)
+  wgl funnel status              Show connection state
+  wgl funnel install [options]   Install as system daemon (systemd/launchd)
+  wgl funnel uninstall           Remove daemon and stop service
+
+${c('cyan', 'OPTIONS:')}
+  --hive <id>           Hive ID to connect to
+  --key <key>           Colony API key (or set COLONY_KEY env var)
+  --name <name>         Funnel name (default: hostname)
+  --verbose             Detailed logging
+  --colony <url>        Colony URL (default: colony.honeyb.dev)
+  --dances <path>       Load custom tools from dance file (repeatable)
+                        Whitelist: --dances=file.js:tool1,tool2
+  --tool <name=cmd>     One-off shell tool (repeatable)
+  --scope <path>        Restrict file/shell ops to this directory (default: cwd)
+  --no-scope            Disable scope restriction (dangerous!)
+  --acl <tool:roles>    Restrict tool to roles (repeatable)
+                        Example: --acl="deploy:deployer,admin"
+  --label <key:value>   Tag this funnel with a label (repeatable)
+                        Agents can route to funnels by label.
+                        Example: --label=region:us-east --label=gpu:a100
+
+${c('cyan', 'API LOADERS:')}
+  --api <path>          Load OpenAPI 3.x spec as tools (repeatable)
+  --api-url <url>       Base URL for OpenAPI requests (overrides spec servers)
+  --graphql <src>       Load GraphQL tools — URL (introspect) or file (repeatable)
+  --graphql-url <url>   Query endpoint (required when --graphql is a file)
+  --api-header <h>      Header for API requests (repeatable)
+                        Supports \${VAR} env interpolation:
+                        --api-header="Authorization: Bearer \${API_KEY}"
+
+${c('cyan', 'SECURITY:')}
+  Tool calls from Colony are HMAC-SHA256 signed. The signing key is
+  exchanged per session over the TLS+API-key-authenticated channel.
+  Calls with invalid or missing signatures are rejected.
+
+${c('cyan', 'DESCRIPTION:')}
+  Connects your machine as a tool endpoint for a Colony hive. Agents
+  running in Colony can call tools that execute on your local machine.
+
+  By default, registers propolis tools (shell, git, file ops) if
+  @honeybee-ai/propolis is installed. Falls back to a built-in shell
+  tool if propolis is not available.
+
+  API loaders let you expose REST (OpenAPI) and GraphQL endpoints as
+  funnel tools. Each operation becomes a tool that proxies requests.
+  Headers with \${VAR} syntax resolve from environment variables, so
+  secrets never appear in CLI args or process lists.
+
+  All tools are scope-restricted to the current directory by default.
+  Use --scope to change the restriction path, or --no-scope to disable
+  (not recommended for production).
+
+${c('cyan', 'EXAMPLES:')}
+  wgl funnel --hive abc123 --key col_...
+  wgl funnel --hive abc123 --dances=game.js --tool="deploy=./deploy.sh"
+  wgl funnel --hive abc123 --dances="game.js:roll,attack"
+  wgl funnel --hive abc123 --scope=/home/user/project
+  wgl funnel --hive abc123 --label=region:us-east --label=gpu:a100
+  wgl funnel --hive abc123 --acl="shell:developer" --acl="deploy:deployer"
+  wgl funnel install --hive abc123    Install as daemon (auto-start on boot)
+
+  ${c('dim', '# OpenAPI: expose a REST API to Colony agents')}
+  wgl funnel --hive abc123 --api=petstore.yaml --api-header="Authorization: Bearer \${PET_KEY}"
+
+  ${c('dim', '# GraphQL: expose endpoint via introspection')}
+  wgl funnel --hive abc123 --graphql=https://api.example.com/graphql
+
+  ${c('dim', '# GraphQL from local schema file')}
+  wgl funnel --hive abc123 --graphql=schema.graphql --graphql-url=http://localhost:4000/graphql
+
+  ${c('dim', '# Combine all sources')}
+  wgl funnel --hive abc123 --api=api.yaml --graphql=https://hasura.example.com/v1/graphql --dances=tools.js
+`);
+}
+function parseArgs(args) {
+    let hiveId = '';
+    let apiKey = '';
+    let name = '';
+    let verbose = false;
+    let colonyUrl = '';
+    const dancePaths = [];
+    const toolDefs = [];
+    let scope = process.cwd(); // default: cwd
+    let noScope = false;
+    const acls = new Map();
+    const apiSpecs = [];
+    let apiUrl = '';
+    const graphqlSources = [];
+    let graphqlUrl = '';
+    const apiHeaders = [];
+    const labels = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--hive' && args[i + 1]) {
+            hiveId = args[++i];
+            continue;
+        }
+        if (arg.startsWith('--hive=')) {
+            hiveId = arg.slice(7);
+            continue;
+        }
+        if (arg === '--key' && args[i + 1]) {
+            apiKey = args[++i];
+            continue;
+        }
+        if (arg.startsWith('--key=')) {
+            apiKey = arg.slice(6);
+            continue;
+        }
+        if (arg === '--name' && args[i + 1]) {
+            name = args[++i];
+            continue;
+        }
+        if (arg.startsWith('--name=')) {
+            name = arg.slice(7);
+            continue;
+        }
+        if (arg === '--colony' && args[i + 1]) {
+            colonyUrl = args[++i];
+            continue;
+        }
+        if (arg.startsWith('--colony=')) {
+            colonyUrl = arg.slice(9);
+            continue;
+        }
+        if (arg === '--verbose' || arg === '-v') {
+            verbose = true;
+            continue;
+        }
+        // Dance files: --dances=file.js or --dances="file.js:tool1,tool2"
+        if (arg === '--dances' && args[i + 1]) {
+            parseDancePath(args[++i], dancePaths);
+            continue;
+        }
+        if (arg.startsWith('--dances=')) {
+            parseDancePath(arg.slice(9), dancePaths);
+            continue;
+        }
+        // Custom shell tools: --tool="name=command"
+        if (arg === '--tool' && args[i + 1]) {
+            toolDefs.push(args[++i]);
+            continue;
+        }
+        if (arg.startsWith('--tool=')) {
+            toolDefs.push(arg.slice(7));
+            continue;
+        }
+        // Scope: --scope=<path> or --no-scope
+        if (arg === '--scope' && args[i + 1]) {
+            scope = resolve(args[++i]);
+            continue;
+        }
+        if (arg.startsWith('--scope=')) {
+            scope = resolve(arg.slice(8));
+            continue;
+        }
+        if (arg === '--no-scope') {
+            noScope = true;
+            continue;
+        }
+        // ACLs: --acl="tool:role1,role2"
+        if (arg === '--acl' && args[i + 1]) {
+            parseAcl(args[++i], acls);
+            continue;
+        }
+        if (arg.startsWith('--acl=')) {
+            parseAcl(arg.slice(6), acls);
+            continue;
+        }
+        // OpenAPI specs: --api=<path> (repeatable)
+        if (arg === '--api' && args[i + 1]) {
+            apiSpecs.push(args[++i]);
+            continue;
+        }
+        if (arg.startsWith('--api=')) {
+            apiSpecs.push(arg.slice(6));
+            continue;
+        }
+        // OpenAPI base URL: --api-url=<url>
+        if (arg === '--api-url' && args[i + 1]) {
+            apiUrl = args[++i];
+            continue;
+        }
+        if (arg.startsWith('--api-url=')) {
+            apiUrl = arg.slice(10);
+            continue;
+        }
+        // GraphQL sources: --graphql=<url-or-file> (repeatable)
+        if (arg === '--graphql' && args[i + 1]) {
+            graphqlSources.push(args[++i]);
+            continue;
+        }
+        if (arg.startsWith('--graphql=')) {
+            graphqlSources.push(arg.slice(10));
+            continue;
+        }
+        // GraphQL endpoint URL: --graphql-url=<url>
+        if (arg === '--graphql-url' && args[i + 1]) {
+            graphqlUrl = args[++i];
+            continue;
+        }
+        if (arg.startsWith('--graphql-url=')) {
+            graphqlUrl = arg.slice(14);
+            continue;
+        }
+        // API headers: --api-header="Name: ${VAR}" (repeatable)
+        if (arg === '--api-header' && args[i + 1]) {
+            apiHeaders.push(args[++i]);
+            continue;
+        }
+        if (arg.startsWith('--api-header=')) {
+            apiHeaders.push(arg.slice(13));
+            continue;
+        }
+        // Labels: --label=key:value (repeatable)
+        if (arg === '--label' && args[i + 1]) {
+            parseLabel(args[++i], labels);
+            continue;
+        }
+        if (arg.startsWith('--label=')) {
+            parseLabel(arg.slice(8), labels);
+            continue;
+        }
+    }
+    if (noScope)
+        scope = null;
+    // Resolve from env / config
+    if (!apiKey)
+        apiKey = process.env.COLONY_KEY || '';
+    if (!colonyUrl)
+        colonyUrl = process.env.COLONY_URL || 'https://colony.honeyb.dev';
+    if (!name)
+        name = hostname() || 'funnel';
+    // Normalize to wss:// for WebSocket
+    if (colonyUrl.startsWith('http://'))
+        colonyUrl = colonyUrl.replace('http://', 'ws://');
+    else if (colonyUrl.startsWith('https://'))
+        colonyUrl = colonyUrl.replace('https://', 'wss://');
+    else if (!colonyUrl.startsWith('ws://') && !colonyUrl.startsWith('wss://'))
+        colonyUrl = `wss://${colonyUrl}`;
+    return { hiveId, apiKey, name, verbose, colonyUrl, dancePaths, toolDefs, scope, acls, apiSpecs, apiUrl, graphqlSources, graphqlUrl, apiHeaders, labels };
+}
+function parseDancePath(value, out) {
+    const colonIdx = value.indexOf(':');
+    // Check if the colon is part of a Windows drive letter (e.g. C:\) or not present
+    const isWindowsDrive = colonIdx === 1 && /^[a-zA-Z]$/.test(value[0]);
+    if (colonIdx > 0 && !isWindowsDrive) {
+        const path = value.slice(0, colonIdx);
+        const names = value.slice(colonIdx + 1).split(',').map(s => s.trim()).filter(Boolean);
+        out.push({ path, whitelist: new Set(names) });
+    }
+    else {
+        out.push({ path: value });
+    }
+}
+function parseAcl(value, out) {
+    const colonIdx = value.indexOf(':');
+    if (colonIdx <= 0)
+        return;
+    const tool = value.slice(0, colonIdx).trim();
+    const roles = value.slice(colonIdx + 1).split(',').map(s => s.trim()).filter(Boolean);
+    if (tool && roles.length > 0) {
+        out.set(tool, roles);
+    }
+}
+function parseLabel(value, out) {
+    const colonIdx = value.indexOf(':');
+    if (colonIdx <= 0)
+        return;
+    const key = value.slice(0, colonIdx).trim();
+    const val = value.slice(colonIdx + 1).trim();
+    if (key && val)
+        out[key] = val;
+}
+// --- Scope validation ---
+/**
+ * Validate that a path or command doesn't escape the scope directory.
+ * Returns null if ok, error string if violation detected.
+ */
+function validateScope(scope, tool, args) {
+    // File operations: check path arg
+    if (tool === 'read_file' || tool === 'write_file' || tool === 'patch_file') {
+        const filePath = args.path;
+        if (typeof filePath !== 'string')
+            return null;
+        const resolved = resolve(filePath);
+        if (!resolved.startsWith(scope + '/') && resolved !== scope) {
+            return `Path ${relative(scope, resolved) || resolved} escapes scope ${scope}`;
+        }
+    }
+    // List/glob: check path/dir arg
+    if (tool === 'list_files' || tool === 'glob') {
+        const dir = args.path || args.dir || args.directory;
+        if (typeof dir === 'string') {
+            const resolved = resolve(dir);
+            if (!resolved.startsWith(scope + '/') && resolved !== scope) {
+                return `Directory ${relative(scope, resolved) || resolved} escapes scope ${scope}`;
+            }
+        }
+    }
+    // Shell: check cwd arg
+    if (tool === 'shell') {
+        const cwd = args.cwd;
+        if (typeof cwd === 'string') {
+            const resolved = resolve(cwd);
+            if (!resolved.startsWith(scope + '/') && resolved !== scope) {
+                return `Working directory ${relative(scope, resolved) || resolved} escapes scope ${scope}`;
+            }
+        }
+    }
+    // Git operations: check cwd
+    if (tool.startsWith('git_')) {
+        const cwd = args.cwd;
+        if (typeof cwd === 'string') {
+            const resolved = resolve(cwd);
+            if (!resolved.startsWith(scope + '/') && resolved !== scope) {
+                return `Git cwd ${relative(scope, resolved) || resolved} escapes scope ${scope}`;
+            }
+        }
+    }
+    // Grep: check path arg
+    if (tool === 'grep') {
+        const grepPath = args.path || args.dir;
+        if (typeof grepPath === 'string') {
+            const resolved = resolve(grepPath);
+            if (!resolved.startsWith(scope + '/') && resolved !== scope) {
+                return `Search path ${relative(scope, resolved) || resolved} escapes scope ${scope}`;
+            }
+        }
+    }
+    return null;
+}
+// --- Custom shell tool execution ---
+async function execShellTool(command, args) {
+    const { execFileSync } = await import('node:child_process');
+    try {
+        const stdout = execFileSync(command, [JSON.stringify(args)], {
+            encoding: 'utf8',
+            timeout: 30_000,
+            maxBuffer: 1_048_576,
+        });
+        return { ok: true, data: { stdout: stdout.trim() } };
+    }
+    catch (err) {
+        return { ok: false, error: err.stderr || err.message || 'Shell tool failed' };
+    }
+}
+// --- Tool discovery ---
+async function discoverTools(opts, danceHandlers, customHandlers) {
+    const tools = [];
+    // 1. Dance files
+    if (opts.dancePaths.length > 0) {
+        const { loadDanceTools } = await import('../lib/dance-loader.js');
+        for (const { path, whitelist } of opts.dancePaths) {
+            try {
+                const danceTools = await loadDanceTools(path, whitelist);
+                for (const dt of danceTools) {
+                    const acl = opts.acls.get(dt.name);
+                    tools.push({
+                        name: dt.name,
+                        description: dt.description,
+                        parameters: dt.params,
+                        source: 'dance',
+                        allowedRoles: acl,
+                    });
+                    danceHandlers.set(dt.name, dt.handler);
+                }
+                if (opts.verbose)
+                    console.log(c('dim', `  Loaded ${danceTools.length} tools from ${path}`));
+            }
+            catch (err) {
+                console.log(c('red', `  Failed to load dance file ${path}: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+    }
+    // 2. OpenAPI specs
+    if (opts.apiSpecs.length > 0) {
+        const { resolveHeaders } = await import('../lib/header-resolver.js');
+        const { loadOpenAPITools } = await import('../lib/openapi-loader.js');
+        const headers = opts.apiHeaders.length > 0 ? resolveHeaders(opts.apiHeaders) : undefined;
+        for (const specPath of opts.apiSpecs) {
+            try {
+                const apiTools = await loadOpenAPITools(specPath, opts.apiUrl || undefined, headers);
+                for (const at of apiTools) {
+                    const acl = opts.acls.get(at.name);
+                    tools.push({
+                        name: at.name,
+                        description: at.description,
+                        parameters: at.params,
+                        source: 'openapi',
+                        allowedRoles: acl,
+                    });
+                    customHandlers.set(at.name, at.handler);
+                }
+                if (opts.verbose)
+                    console.log(c('dim', `  Loaded ${apiTools.length} tools from OpenAPI: ${specPath}`));
+            }
+            catch (err) {
+                console.log(c('red', `  Failed to load OpenAPI spec ${specPath}: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+    }
+    // 3. GraphQL sources
+    if (opts.graphqlSources.length > 0) {
+        const { resolveHeaders } = await import('../lib/header-resolver.js');
+        const { loadGraphQLTools } = await import('../lib/graphql-loader.js');
+        const headers = opts.apiHeaders.length > 0 ? resolveHeaders(opts.apiHeaders) : undefined;
+        for (const source of opts.graphqlSources) {
+            try {
+                const gqlTools = await loadGraphQLTools(source, opts.graphqlUrl || undefined, headers);
+                for (const gt of gqlTools) {
+                    const acl = opts.acls.get(gt.name);
+                    tools.push({
+                        name: gt.name,
+                        description: gt.description,
+                        parameters: gt.params,
+                        source: 'graphql',
+                        allowedRoles: acl,
+                    });
+                    customHandlers.set(gt.name, gt.handler);
+                }
+                if (opts.verbose)
+                    console.log(c('dim', `  Loaded ${gqlTools.length} tools from GraphQL: ${source}`));
+            }
+            catch (err) {
+                console.log(c('red', `  Failed to load GraphQL source ${source}: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
+    }
+    // 4. Custom --tool definitions
+    for (const def of opts.toolDefs) {
+        const eqIdx = def.indexOf('=');
+        if (eqIdx === -1) {
+            console.log(c('yellow', `  Skipping malformed --tool (expected name=command): ${def}`));
+            continue;
+        }
+        const toolName = def.slice(0, eqIdx);
+        if (!/^[a-zA-Z0-9_-]+$/.test(toolName)) {
+            console.log(c('yellow', `  Skipping invalid tool name: ${toolName}`));
+            continue;
+        }
+        const command = resolve(def.slice(eqIdx + 1));
+        const acl = opts.acls.get(toolName);
+        tools.push({
+            name: toolName,
+            description: `Custom: ${command}`,
+            parameters: { args: { type: 'object', description: 'Arguments passed as JSON' } },
+            source: 'shell',
+            allowedRoles: acl,
+        });
+        customHandlers.set(toolName, (args) => execShellTool(command, args));
+        if (opts.verbose)
+            console.log(c('dim', `  Registered custom tool: ${toolName} -> ${command}`));
+    }
+    // 5. Propolis tools (auto-discovered)
+    try {
+        // @ts-expect-error — optional dependency, may not be installed
+        const propolis = await import('@honeybee-ai/propolis');
+        if (propolis.createPlugin) {
+            const plugin = propolis.createPlugin();
+            if (plugin.getToolEntries) {
+                const entries = plugin.getToolEntries({});
+                for (const [toolName, entry] of Object.entries(entries)) {
+                    const acl = opts.acls.get(toolName);
+                    tools.push({
+                        name: toolName,
+                        description: entry.description || `Propolis: ${toolName}`,
+                        source: 'propolis',
+                        allowedRoles: acl,
+                    });
+                }
+            }
+        }
+        if (opts.verbose)
+            console.log(c('dim', `  Discovered propolis tools`));
+    }
+    catch {
+        // Propolis not installed — provide basic shell tool if no other tools found
+        if (tools.length === 0) {
+            if (opts.verbose)
+                console.log(c('dim', '  Propolis not installed, using built-in shell tool'));
+            const acl = opts.acls.get('shell');
+            tools.push({
+                name: 'shell',
+                description: 'Execute a shell command on this machine',
+                parameters: { command: { type: 'string', description: 'Command to execute' } },
+                source: 'custom',
+                allowedRoles: acl,
+            });
+        }
+    }
+    return tools;
+}
+// --- Built-in tool handler ---
+async function handleToolCall(tool, args, scope, danceHandlers, customHandlers) {
+    // Scope check (applies to all tools)
+    if (scope) {
+        const violation = validateScope(scope, tool, args);
+        if (violation) {
+            return { ok: false, error: `Scope violation: ${violation}` };
+        }
+    }
+    // Check dance handlers first
+    const danceHandler = danceHandlers.get(tool);
+    if (danceHandler)
+        return danceHandler(args);
+    // Check custom shell tool handlers
+    const customHandler = customHandlers.get(tool);
+    if (customHandler)
+        return customHandler(args);
+    // Try propolis
+    try {
+        // @ts-expect-error — optional dependency, may not be installed
+        const propolis = await import('@honeybee-ai/propolis');
+        if (propolis.createPlugin) {
+            const plugin = propolis.createPlugin();
+            const entries = plugin.getToolEntries ? plugin.getToolEntries({}) : {};
+            const handler = entries[tool];
+            if (handler && handler.handler) {
+                const result = await handler.handler(args);
+                return { ok: true, data: result };
+            }
+        }
+    }
+    catch {
+        // Fall through to built-in handlers
+    }
+    // Built-in shell handler
+    if (tool === 'shell' && typeof args.command === 'string') {
+        const { execFileSync } = await import('node:child_process');
+        try {
+            const cwd = typeof args.cwd === 'string' ? args.cwd : (scope || process.cwd());
+            const stdout = execFileSync('/bin/sh', ['-c', args.command], {
+                encoding: 'utf8',
+                timeout: 30_000,
+                maxBuffer: 1_048_576,
+                cwd,
+            });
+            return { ok: true, data: { stdout } };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err.stderr || err.message || 'Shell command failed',
+            };
+        }
+    }
+    return { ok: false, error: `Unknown tool: ${tool}` };
+}
+// --- WebSocket connection ---
+async function startFunnel(args) {
+    const opts = parseArgs(args);
+    if (!opts.hiveId) {
+        console.log(error('Missing --hive <id>. Specify the hive to connect to.'));
+        process.exit(1);
+    }
+    if (!opts.apiKey) {
+        console.log(error('Missing API key. Use --key <key> or set COLONY_KEY env var.'));
+        process.exit(1);
+    }
+    console.log(heading('Funnel'));
+    console.log(label('Hive', opts.hiveId));
+    console.log(label('Name', opts.name));
+    console.log(label('Colony', opts.colonyUrl));
+    if (opts.scope) {
+        console.log(label('Scope', opts.scope));
+    }
+    else {
+        console.log(label('Scope', c('yellow', 'DISABLED (--no-scope)')));
+        console.log(c('yellow', '  WARNING: All tools have unrestricted filesystem access'));
+    }
+    // Handler registries for dance + custom tools
+    const danceHandlers = new Map();
+    const customHandlers = new Map();
+    // Discover tools
+    console.log(c('dim', '\nDiscovering tools...'));
+    const tools = await discoverTools(opts, danceHandlers, customHandlers);
+    if (tools.length === 0) {
+        console.log(error('No tools discovered. Install @honeybee-ai/propolis, use --dances, or --tool.'));
+        process.exit(1);
+    }
+    console.log(success(`Found ${tools.length} tools: ${tools.map(t => t.name).join(', ')}`));
+    if (opts.acls.size > 0) {
+        for (const [toolName, roles] of opts.acls) {
+            console.log(c('dim', `  ACL: ${toolName} -> ${roles.join(', ')}`));
+        }
+    }
+    // Connect with reconnection
+    let reconnectDelay = 1000;
+    let funnelId = '';
+    let signingKey = null;
+    let callCount = 0;
+    let shuttingDown = false;
+    function connect() {
+        // Native WebSocket can't set custom headers — pass API key as query param
+        const wsUrl = `${opts.colonyUrl}/f/${encodeURIComponent(opts.hiveId)}/ws?key=${encodeURIComponent(opts.apiKey)}`;
+        if (opts.verbose)
+            console.log(c('dim', `\nConnecting to ${opts.colonyUrl}/f/${opts.hiveId}/ws ...`));
+        let ws;
+        try {
+            ws = new WebSocket(wsUrl);
+        }
+        catch {
+            console.log(c('yellow', 'Failed to create WebSocket connection'));
+            scheduleReconnect();
+            return;
+        }
+        ws.addEventListener('open', () => {
+            reconnectDelay = 1000; // Reset backoff
+            // Send registration with ACL info and labels
+            ws.send(JSON.stringify({
+                type: 'funnel_register',
+                name: opts.name,
+                tools: tools.map(t => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                    source: t.source,
+                    ...(t.allowedRoles ? { allowedRoles: t.allowedRoles } : {}),
+                })),
+                ...(Object.keys(opts.labels).length > 0 ? { labels: opts.labels } : {}),
+            }));
+        });
+        ws.addEventListener('message', (ev) => {
+            const text = typeof ev.data === 'string' ? ev.data : String(ev.data);
+            let msg;
+            try {
+                msg = JSON.parse(text);
+            }
+            catch {
+                return;
+            }
+            switch (msg.type) {
+                case 'funnel_welcome': {
+                    funnelId = msg.funnelId;
+                    // Import HMAC signing key if provided
+                    if (typeof msg.signingKey === 'string') {
+                        importSigningKey(msg.signingKey).then(key => {
+                            signingKey = key;
+                            if (opts.verbose)
+                                console.log(c('dim', '  HMAC signing key imported'));
+                        }).catch(() => {
+                            console.log(c('yellow', '  Warning: failed to import signing key'));
+                        });
+                    }
+                    console.log(success(`Connected as ${funnelId}`));
+                    console.log(c('dim', 'Waiting for tool calls... (Ctrl+C to disconnect)\n'));
+                    break;
+                }
+                case 'tool_ack': {
+                    if (opts.verbose) {
+                        const accepted = msg.accepted || [];
+                        const rejected = msg.rejected || [];
+                        if (accepted.length > 0)
+                            console.log(c('dim', `  Accepted: ${accepted.join(', ')}`));
+                        if (rejected.length > 0)
+                            console.log(c('yellow', `  Rejected: ${rejected.join(', ')}`));
+                    }
+                    break;
+                }
+                case 'tool_call': {
+                    const call = msg;
+                    callCount++;
+                    const ts = new Date().toLocaleTimeString();
+                    console.log(`${c('dim', ts)} ${c('cyan', call.tool)} from ${c('bold', call.agentId)} ${c('dim', `(${call.role})`)}`);
+                    if (opts.verbose) {
+                        console.log(c('dim', `  args: ${JSON.stringify(call.args)}`));
+                    }
+                    // Verify HMAC signature if signing key is available
+                    const verifySig = (signingKey && call.sig)
+                        ? verifyHmac(signingKey, buildSignPayload(call.callId, call.tool, call.args, call.nonce), call.sig)
+                        : Promise.resolve(true);
+                    verifySig.then(valid => {
+                        if (!valid) {
+                            console.log(c('red', '  -> REJECTED: invalid HMAC signature'));
+                            ws.send(JSON.stringify({
+                                type: 'tool_result',
+                                callId: call.callId,
+                                result: { ok: false, error: 'HMAC signature verification failed' },
+                                nonce: call.nonce,
+                            }));
+                            return;
+                        }
+                        return handleToolCall(call.tool, call.args, opts.scope, danceHandlers, customHandlers);
+                    }).then(result => {
+                        if (!result)
+                            return; // Already handled (sig rejection)
+                        ws.send(JSON.stringify({
+                            type: 'tool_result',
+                            callId: call.callId,
+                            result,
+                            nonce: call.nonce,
+                        }));
+                        if (result.ok) {
+                            console.log(c('green', '  -> ok'));
+                        }
+                        else {
+                            console.log(c('red', `  -> error: ${result.error}`));
+                        }
+                    }).catch((err) => {
+                        ws.send(JSON.stringify({
+                            type: 'tool_result',
+                            callId: call.callId,
+                            result: { ok: false, error: err.message || 'Handler threw' },
+                            nonce: call.nonce,
+                        }));
+                        console.log(c('red', `  -> exception: ${err.message}`));
+                    });
+                    break;
+                }
+                case 'ping': {
+                    const mem = process.memoryUsage?.();
+                    ws.send(JSON.stringify({
+                        type: 'pong',
+                        ts: Date.now(),
+                        cpuLoad: loadavg()[0],
+                        memoryMb: mem ? Math.round(mem.rss / 1048576) : 0,
+                        queueDepth: 0,
+                        uptime: Math.round(process.uptime()),
+                    }));
+                    break;
+                }
+                case 'error': {
+                    console.log(c('red', `Server error: ${msg.message || 'Unknown'}`));
+                    break;
+                }
+            }
+        });
+        ws.addEventListener('close', () => {
+            if (shuttingDown)
+                return;
+            console.log(c('yellow', `\nDisconnected. Reconnecting in ${reconnectDelay / 1000}s...`));
+            scheduleReconnect();
+        });
+        ws.addEventListener('error', () => {
+            // error fires before close — close handler will reconnect
+        });
+        // Graceful shutdown
+        const shutdown = () => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            console.log(c('dim', `\nDisconnecting... (${callCount} calls handled)`));
+            try {
+                ws.close(1000);
+            }
+            catch {
+                // Already closed
+            }
+            setTimeout(() => process.exit(0), 500);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        function scheduleReconnect() {
+            setTimeout(() => {
+                reconnectDelay = Math.min(reconnectDelay * 2, 30_000);
+                connect();
+            }, reconnectDelay);
+        }
+    }
+    connect();
+    // Keep process alive
+    await new Promise(() => { });
+}
+// --- Status ---
+async function showStatus() {
+    console.log(heading('Funnel Status'));
+    // Check for propolis
+    let propolisAvailable = false;
+    try {
+        // @ts-expect-error — optional dependency, may not be installed
+        await import('@honeybee-ai/propolis');
+        propolisAvailable = true;
+    }
+    catch {
+        // Not installed
+    }
+    console.log(label('Propolis', propolisAvailable ? c('green', 'installed') : c('yellow', 'not installed')));
+    const dummyHandlers = new Map();
+    const dummyOpts = {
+        hiveId: '', apiKey: '', name: '', verbose: false, colonyUrl: '',
+        dancePaths: [], toolDefs: [], scope: process.cwd(), acls: new Map(),
+        apiSpecs: [], apiUrl: '', graphqlSources: [], graphqlUrl: '', apiHeaders: [],
+        labels: {},
+    };
+    const tools = await discoverTools(dummyOpts, dummyHandlers, dummyHandlers);
+    console.log(label('Available tools', tools.length > 0 ? tools.map(t => t.name).join(', ') : c('yellow', 'none')));
+    const colonyKey = process.env.COLONY_KEY;
+    console.log(label('COLONY_KEY', colonyKey ? c('green', 'set') : c('yellow', 'not set')));
+    console.log(c('dim', '\nUse `wgl funnel --hive <id> --key <key>` to connect'));
+}
+// --- Daemon install/uninstall ---
+const FUNNEL_CONFIG_DIR = join(homedir(), '.honeyb');
+const FUNNEL_CONFIG_FILE = join(FUNNEL_CONFIG_DIR, 'funnel.json');
+async function installDaemon(args) {
+    const opts = parseArgs(args);
+    if (!opts.hiveId) {
+        console.log(error('Missing --hive <id>. Specify the hive to connect to.'));
+        process.exit(1);
+    }
+    if (!opts.apiKey) {
+        console.log(error('Missing API key. Use --key <key> or set COLONY_KEY env var.'));
+        process.exit(1);
+    }
+    const { existsSync, mkdirSync, writeFileSync } = await import('node:fs');
+    const { execFileSync } = await import('node:child_process');
+    const nodePath = process.execPath;
+    const wglPath = process.argv[1];
+    const isMac = process.platform === 'darwin';
+    // Build the funnel args string
+    const funnelArgs = ['funnel', '--hive', opts.hiveId];
+    if (opts.colonyUrl && opts.colonyUrl !== 'wss://colony.honeyb.dev') {
+        funnelArgs.push('--colony', opts.colonyUrl);
+    }
+    if (opts.scope === null) {
+        funnelArgs.push('--no-scope');
+    }
+    else if (opts.scope !== process.cwd()) {
+        funnelArgs.push('--scope', opts.scope);
+    }
+    for (const dp of opts.dancePaths) {
+        const danceArg = dp.whitelist ? `${dp.path}:${[...dp.whitelist].join(',')}` : dp.path;
+        funnelArgs.push(`--dances=${danceArg}`);
+    }
+    for (const td of opts.toolDefs)
+        funnelArgs.push(`--tool=${td}`);
+    for (const [tool, roles] of opts.acls)
+        funnelArgs.push(`--acl=${tool}:${roles.join(',')}`);
+    for (const [k, v] of Object.entries(opts.labels))
+        funnelArgs.push(`--label=${k}:${v}`);
+    if (opts.verbose)
+        funnelArgs.push('--verbose');
+    if (opts.name && opts.name !== (hostname() || 'funnel'))
+        funnelArgs.push('--name', opts.name);
+    const argsString = funnelArgs.map(a => a.includes(' ') ? `"${a}"` : a).join(' ');
+    console.log(heading('Funnel Daemon Install'));
+    if (isMac) {
+        // --- launchd ---
+        const plistDir = join(homedir(), 'Library', 'LaunchAgents');
+        const plistPath = join(plistDir, 'dev.honeyb.wgl-funnel.plist');
+        const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>dev.honeyb.wgl-funnel</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${wglPath}</string>
+${funnelArgs.map(a => `    <string>${a}</string>`).join('\n')}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>COLONY_KEY</key>
+    <string>${opts.apiKey}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(FUNNEL_CONFIG_DIR, 'funnel.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(FUNNEL_CONFIG_DIR, 'funnel.err')}</string>
+</dict>
+</plist>`;
+        if (!existsSync(plistDir))
+            mkdirSync(plistDir, { recursive: true });
+        writeFileSync(plistPath, plistContent);
+        console.log(label('Plist', plistPath));
+        try {
+            execFileSync('launchctl', ['load', plistPath], { encoding: 'utf8' });
+            console.log(success('Daemon installed and started'));
+        }
+        catch (err) {
+            console.log(error(`launchctl load failed: ${err.message}`));
+        }
+    }
+    else {
+        // --- systemd (user-level) ---
+        const unitDir = join(homedir(), '.config', 'systemd', 'user');
+        const unitPath = join(unitDir, 'wgl-funnel.service');
+        const unitContent = `[Unit]
+Description=Honeybee Funnel (${opts.name})
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${wglPath} ${argsString}
+Restart=always
+RestartSec=5
+Environment=COLONY_KEY=${opts.apiKey}
+
+[Install]
+WantedBy=default.target
+`;
+        if (!existsSync(unitDir))
+            mkdirSync(unitDir, { recursive: true });
+        writeFileSync(unitPath, unitContent);
+        console.log(label('Unit file', unitPath));
+        try {
+            execFileSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf8' });
+            execFileSync('systemctl', ['--user', 'enable', '--now', 'wgl-funnel'], { encoding: 'utf8' });
+            console.log(success('Daemon installed and started'));
+            console.log(c('dim', '  Check status: systemctl --user status wgl-funnel'));
+            console.log(c('dim', '  View logs:    journalctl --user -u wgl-funnel -f'));
+        }
+        catch (err) {
+            console.log(error(`systemctl failed: ${err.message}`));
+            console.log(c('dim', '  You may need to enable lingering: loginctl enable-linger $USER'));
+        }
+    }
+    // Save config for reference / uninstall
+    if (!existsSync(FUNNEL_CONFIG_DIR))
+        mkdirSync(FUNNEL_CONFIG_DIR, { recursive: true });
+    writeFileSync(FUNNEL_CONFIG_FILE, JSON.stringify({
+        hiveId: opts.hiveId,
+        name: opts.name,
+        args: funnelArgs,
+        installedAt: new Date().toISOString(),
+        platform: isMac ? 'launchd' : 'systemd',
+    }, null, 2));
+    console.log(label('Config', FUNNEL_CONFIG_FILE));
+}
+async function uninstallDaemon() {
+    const { existsSync, unlinkSync } = await import('node:fs');
+    const { execFileSync } = await import('node:child_process');
+    const isMac = process.platform === 'darwin';
+    console.log(heading('Funnel Daemon Uninstall'));
+    if (isMac) {
+        const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'dev.honeyb.wgl-funnel.plist');
+        if (existsSync(plistPath)) {
+            try {
+                execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf8' });
+            }
+            catch { /* already unloaded */ }
+            unlinkSync(plistPath);
+            console.log(success('Daemon stopped and plist removed'));
+        }
+        else {
+            console.log(c('yellow', 'No funnel daemon installed (plist not found)'));
+        }
+    }
+    else {
+        const unitPath = join(homedir(), '.config', 'systemd', 'user', 'wgl-funnel.service');
+        if (existsSync(unitPath)) {
+            try {
+                execFileSync('systemctl', ['--user', 'disable', '--now', 'wgl-funnel'], { encoding: 'utf8' });
+            }
+            catch { /* already stopped */ }
+            try {
+                execFileSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf8' });
+            }
+            catch { /* non-fatal */ }
+            unlinkSync(unitPath);
+            console.log(success('Daemon stopped and unit file removed'));
+        }
+        else {
+            console.log(c('yellow', 'No funnel daemon installed (unit file not found)'));
+        }
+    }
+    // Remove config file
+    if (existsSync(FUNNEL_CONFIG_FILE)) {
+        unlinkSync(FUNNEL_CONFIG_FILE);
+        console.log(c('dim', '  Removed config: ' + FUNNEL_CONFIG_FILE));
+    }
+}
+// Exported for testing
+export { parseArgs, discoverTools, validateScope, parseDancePath, parseAcl, parseLabel, importSigningKey, verifyHmac, buildSignPayload };
+//# sourceMappingURL=funnel.js.map