@agenthippo-ai/agenthippo 0.1.0

package/out/cli/deps.js

@@ -0,0 +1,238 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDepsDir = getDepsDir;
+exports.areDepsInstalled = areDepsInstalled;
+exports.installDeps = installDeps;
+exports.isAutoInstallDisabled = isAutoInstallDisabled;
+exports.ensureDeps = ensureDeps;
+exports.getClaudeSdkCliPath = getClaudeSdkCliPath;
+exports.getCodexSdkBinaryPath = getCodexSdkBinaryPath;
+/**
+ * CLI Dependency Management
+ *
+ * On first run, installs engine SDK dependencies (which include their CLIs).
+ * This lets npm/bun handle platform-specific binaries automatically.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const utils_1 = require("./utils");
+const branding_1 = require("../branding");
+/**
+ * Resolve engine dependency versions.
+ *
+ * We prefer reading from the extension's package.json so the CLI auto-installer stays
+ * in lockstep with the extension's dependency versions (avoid drift/regressions).
+ *
+ * In compiled/bundled contexts, this require is typically inlined by the bundler.
+ * If it fails for any reason, we fall back to pinned defaults.
+ */
+function resolveEngineDeps() {
+    const pkg = (() => {
+        try {
+            // `deps.ts` lives at src/cli/, so ../../package.json resolves to extensions/agentide/package.json
+            // when run from source (and is usually bundled into the CLI binary).
+            return require('../../package.json');
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const deps = pkg?.dependencies ?? {};
+    return {
+        '@anthropic-ai/claude-agent-sdk': deps['@anthropic-ai/claude-agent-sdk'] ?? '^0.2.19',
+        '@openai/codex': deps['@openai/codex'] ?? '^0.131.0',
+        '@openai/codex-sdk': deps['@openai/codex-sdk'] ?? '^0.131.0',
+    };
+}
+// Dependencies required for the engines (resolved once at startup).
+const ENGINE_DEPS = resolveEngineDeps();
+/**
+ * Get the deps directory (next to the binary)
+ */
+function getDepsDir() {
+    const binaryDir = path.dirname(process.execPath);
+    return path.join(binaryDir, branding_1.AGENTIDE_DEPS_DIR_NAME);
+}
+/**
+ * Check if engine dependencies are installed
+ */
+function areDepsInstalled() {
+    const depsDir = getDepsDir();
+    const nodeModules = path.join(depsDir, 'node_modules');
+    const depsPackageJsonPath = path.join(depsDir, 'package.json');
+    // Ensure the installed deps match the required versions for *this* CLI build.
+    // This lets us auto-upgrade on CLI updates (long-lived ~/.agenthippo-deps dirs).
+    try {
+        if (!fs.existsSync(depsPackageJsonPath)) {
+            return false;
+        }
+        const raw = fs.readFileSync(depsPackageJsonPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        const installedSpec = parsed.dependencies ?? {};
+        for (const [name, spec] of Object.entries(ENGINE_DEPS)) {
+            if (installedSpec[name] !== spec) {
+                return false;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    // Check if key packages exist
+    const claudeSdk = path.join(nodeModules, '@anthropic-ai', 'claude-agent-sdk', 'cli.js');
+    const codexCli = path.join(nodeModules, '@openai', 'codex', 'bin', 'codex.js');
+    const codexSdk = path.join(nodeModules, '@openai', 'codex-sdk', 'package.json');
+    return fs.existsSync(claudeSdk) && fs.existsSync(codexCli) && fs.existsSync(codexSdk);
+}
+/**
+ * Install engine dependencies
+ */
+async function installDeps(verbose = false) {
+    const depsDir = getDepsDir();
+    console.log(`${utils_1.COLORS.cyan}Installing engine dependencies...${utils_1.COLORS.reset}`);
+    if (verbose) {
+        console.log(`  Directory: ${depsDir}`);
+    }
+    // Create deps directory
+    fs.mkdirSync(depsDir, { recursive: true });
+    // Write minimal package.json
+    const packageJson = {
+        name: branding_1.AGENTIDE_DEPS_PACKAGE_NAME,
+        version: '1.0.0',
+        private: true,
+        dependencies: ENGINE_DEPS,
+    };
+    fs.writeFileSync(path.join(depsDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+    // Run npm install
+    try {
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        (0, child_process_1.execSync)(`${npmCmd} install --production --no-audit --no-fund`, {
+            cwd: depsDir,
+            stdio: verbose ? 'inherit' : 'pipe',
+        });
+        console.log(`${utils_1.COLORS.green}Dependencies installed${utils_1.COLORS.reset}`);
+    }
+    catch (err) {
+        console.error(`${utils_1.COLORS.red}Error: Failed to install dependencies${utils_1.COLORS.reset}`);
+        if (err instanceof Error) {
+            console.error(`  ${err.message}`);
+        }
+        throw err;
+    }
+}
+/**
+ * Whether first-run auto-install of engine SDKs is disabled.
+ *
+ * Set `AGENTHIPPO_NO_AUTO_INSTALL=1` in a self-contained runtime image (serve-v3
+ * A2): engine deps are baked at build time, so the CLI must NOT npm-install at
+ * runtime — which would otherwise tax every cold start, break in egress-locked
+ * VPCs, and risk version drift across autoscaled instances.
+ */
+function isAutoInstallDisabled() {
+    const raw = (process.env.AGENTHIPPO_NO_AUTO_INSTALL ?? process.env.AGENTIDE_NO_AUTO_INSTALL ?? '')
+        .trim()
+        .toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+/**
+ * Ensure dependencies are installed (call on startup).
+ *
+ * When auto-install is disabled we skip silently and let engine-specific
+ * resolution fail with its own clear error if a needed SDK is genuinely absent.
+ * This keeps custom engines (e.g. cursor), which don't use these built-in SDKs,
+ * from paying any install cost at all.
+ */
+async function ensureDeps(verbose = false) {
+    if (areDepsInstalled()) {
+        return;
+    }
+    if (isAutoInstallDisabled()) {
+        if (verbose) {
+            console.error(`${utils_1.COLORS.dim}AGENTHIPPO_NO_AUTO_INSTALL set — skipping engine dependency install (expecting a self-contained image).${utils_1.COLORS.reset}`);
+        }
+        return;
+    }
+    await installDeps(verbose);
+}
+/**
+ * Get the path to Claude SDK's cli.js
+ */
+function getClaudeSdkCliPath() {
+    const depsDir = getDepsDir();
+    const cliPath = path.join(depsDir, 'node_modules', '@anthropic-ai', 'claude-agent-sdk', 'cli.js');
+    return fs.existsSync(cliPath) ? cliPath : undefined;
+}
+/**
+ * Get the path to the Codex CLI entrypoint installed alongside the CLI binary.
+ * @openai/codex@0.131+ ships bin/codex.js and pulls platform natives via optional deps.
+ */
+function getCodexSdkBinaryPath() {
+    const depsDir = getDepsDir();
+    const codexCli = path.join(depsDir, 'node_modules', '@openai', 'codex', 'bin', 'codex.js');
+    if (fs.existsSync(codexCli)) {
+        return codexCli;
+    }
+    // Legacy: codex-sdk < 0.120 bundled native binaries under vendor/
+    const codexDir = path.join(depsDir, 'node_modules', '@openai', 'codex-sdk');
+    const platform = getCodexPlatform();
+    if (!platform) {
+        return undefined;
+    }
+    const binaryName = process.platform === 'win32' ? 'codex.exe' : 'codex';
+    const legacyPath = path.join(codexDir, 'vendor', platform, 'codex', binaryName);
+    return fs.existsSync(legacyPath) ? legacyPath : undefined;
+}
+/**
+ * Get the Codex platform triple
+ */
+function getCodexPlatform() {
+    const arch = process.arch;
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+    }
+    if (platform === 'linux') {
+        return arch === 'arm64' ? 'aarch64-unknown-linux-musl' : 'x86_64-unknown-linux-musl';
+    }
+    if (platform === 'win32') {
+        return arch === 'arm64' ? 'aarch64-pc-windows-msvc' : 'x86_64-pc-windows-msvc';
+    }
+    return undefined;
+}

package/out/cli/index.js

@@ -0,0 +1,390 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Agent Hippo CLI
+ *
+ * Standalone command-line interface for running agent packs.
+ *
+ * Commands:
+ *   agenthippo chat [--agent <name>] [-e claude|codex|<custom-engine-id>] [-m <model>]  Interactive chat (flags override pack)
+ *   agenthippo ask <message> [--agent <name>] [-e ...] [-m ...]      One-shot message
+ *   agenthippo agent run --json --prompt "<message>" [--pack <name>] Gateway-friendly one-shot JSON
+ *   agenthippo serve --agent <name> [-e ...] [-m ...] [--port <n>]  HTTP API server
+ *   agenthippo pack <command>                        Pack management
+ *   agenthippo store publish engine/<id>[@version]  Publish a custom engine (fork + PR)
+ *   agenthippo store publish view/<id>[@version]     Publish a Spotlight view (--bundle full|--full)
+ *   agenthippo store install view/<id>[@version]    Install a Spotlight view from the store
+ *   agenthippo store uninstall engine/<id>           Uninstall a custom engine
+ *   agenthippo anywhere <command>                    Agent Anywhere gateway
+ *   agenthippo gateway list --outbound <path> [--agent <id>]  List session outbound routes
+ *   agenthippo gateway send --outbound <path> --agent <id> -m "..." [--media <path|url>]  Proactive outbound via gateway RPC
+ *
+ * Configuration (via environment variables):
+ *   AGENTHIPPO_LITELLM_API_KEY   API key for LiteLLM proxy (recommended)
+ *   AGENTHIPPO_LITELLM_BASE_URL  Base URL for LiteLLM proxy
+ *   ANTHROPIC_API_KEY          Direct Anthropic API key
+ *   OPENAI_API_KEY             Direct OpenAI API key
+ *   CLAUDE_CODE_PATH           Path to Claude Code CLI executable
+ *   CODEX_PATH                 Path to Codex CLI executable
+ *   AGENTHIPPO_DEFAULT_ENGINE    Default engine ('claude', 'codex', or a custom engine id)
+ *   AGENTHIPPO_DEFAULT_MODEL     Default model ID
+ *   AGENTHIPPO_HOME              Override ~/.agent-hippo directory
+ *
+ * Legacy env vars with the AGENTIDE_ prefix are still supported.
+ *
+ * Agent packs are loaded from:
+ *   1. Absolute/relative path
+ *   2. ~/.agent-hippo/agents/<name>/
+ *
+ * Permissions:
+ *   Pack's permissions.fileAccess controls filesystem scope:
+ *   - 'read-only': read/search only (no writes)
+ *   - 'workspace-write': writable inside workspace folders
+ *   - 'full': full filesystem access
+ */
+// Stub vscode before any imports that depend on it
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id) {
+    if (id === 'vscode') {
+        return {
+            window: {
+                showInformationMessage: () => undefined,
+                showErrorMessage: () => undefined,
+                showWarningMessage: () => Promise.resolve(undefined),
+            },
+            workspace: {
+                getConfiguration: () => ({
+                    get: (_key, defaultValue) => defaultValue,
+                    inspect: () => undefined,
+                }),
+            },
+            commands: {
+                executeCommand: async () => undefined,
+            },
+            Memento: class {
+            },
+        };
+    }
+    return originalRequire.apply(this, arguments);
+};
+const commander_1 = require("commander");
+const chat_1 = require("./commands/chat");
+const ask_1 = require("./commands/ask");
+const serve_1 = require("./commands/serve");
+const auth_broker_1 = require("./commands/auth-broker");
+const deploy_1 = require("./commands/deploy");
+const pack_1 = require("./commands/pack");
+const store_1 = require("./commands/store");
+const anywhere_1 = require("./commands/anywhere");
+const gateway_1 = require("./commands/gateway");
+const probe_custom_engine_1 = require("./commands/probe-custom-engine");
+const deps_1 = require("./deps");
+const branding_1 = require("../branding");
+const agentEnvFile_1 = require("../utils/agentEnvFile");
+const VERSION = '1.110.8';
+const CLI_DESCRIPTION = [
+    `${branding_1.AGENTIDE_BRAND_NAME} CLI - Run agent packs from the command line`,
+    '',
+    'Environment Variables:',
+    '  AGENTHIPPO_LITELLM_API_KEY   API key for LiteLLM proxy',
+    '  AGENTHIPPO_LITELLM_BASE_URL  Base URL for LiteLLM proxy',
+    '  ANTHROPIC_API_KEY          Direct Anthropic API key',
+    '  OPENAI_API_KEY             Direct OpenAI API key',
+    '  AGENTHIPPO_DEFAULT_ENGINE    Default engine (claude/codex/<custom-engine-id>)',
+    '  AGENTHIPPO_DEFAULT_MODEL     Default model ID',
+    '  AGENTHIPPO_HOME              Override ~/.agent-hippo directory',
+    '  AGENTHIPPO_SERVE_HOST        Listen address for serve (default 127.0.0.1; use 0.0.0.0 in containers)',
+    '  AGENTHIPPO_STORE_REPO        Override store GitHub repo (owner/repo; CLI store commands)',
+    '',
+    'Quickstart:',
+    `  AGENTHIPPO_LITELLM_BASE_URL="http://localhost:4000" AGENTHIPPO_LITELLM_API_KEY="dummy" AGENTHIPPO_DEFAULT_MODEL="litellm/gpt-5.3-codex" AGENTHIPPO_DEFAULT_ENGINE="codex" ${branding_1.AGENTIDE_CLI_NAME} ask "Reply with exactly: CLI_TEST_OK"`,
+    '',
+    'Agent Packs:',
+    `  Loaded from ~/${branding_1.AGENTIDE_DIR_NAME}/agents/<name>/ or absolute/relative paths.`,
+    '  Pack permissions control filesystem access scope.',
+].join('\n');
+const program = new commander_1.Command();
+program.hook('preAction', async () => {
+    await (0, agentEnvFile_1.mergeAgentHomeEnvIntoProcessEnv)();
+});
+program
+    .name(branding_1.AGENTIDE_CLI_NAME)
+    .description(CLI_DESCRIPTION)
+    .version(VERSION);
+// Global options
+program
+    .option('-v, --verbose', 'Enable verbose logging')
+    .option('--config <path>', 'Path to config file');
+// Chat command - interactive REPL
+program
+    .command('chat')
+    .description('Start interactive chat session')
+    .option('-a, --agent <name>', 'Agent pack to use')
+    .option('-e, --engine <id>', 'Override pack engine: claude|codex|<custom-engine-id>')
+    .option('-m, --model <id>', 'Override pack model (e.g. litellm/gpt-4.1-nano)')
+    .option('-w, --workspace <path>', 'Workspace directory', process.cwd())
+    .action(async (options) => {
+    const verbose = program.opts().verbose;
+    await (0, deps_1.ensureDeps)(verbose);
+    await (0, chat_1.chatCommand)({
+        agent: options.agent,
+        engine: options.engine,
+        model: options.model,
+        workspace: options.workspace,
+        verbose,
+    });
+});
+// Ask command - one-shot
+program
+    .command('ask <message...>')
+    .description('Send a single message and exit')
+    .option('-a, --agent <name>', 'Agent pack to use')
+    .option('-e, --engine <id>', 'Override pack engine: claude|codex|<custom-engine-id>')
+    .option('-m, --model <id>', 'Override pack model (e.g. litellm/gpt-4.1-nano)')
+    .option('-w, --workspace <path>', 'Workspace directory', process.cwd())
+    .option('-f, --file <path>', 'Include file content in context')
+    .option('--json', 'Output as JSON')
+    .option('--session-id <id>', 'Conversation session id (enables multi-turn resume across ask invocations)')
+    .action(async (messageParts, options) => {
+    const verbose = program.opts().verbose;
+    await (0, deps_1.ensureDeps)(verbose);
+    const message = messageParts.join(' ');
+    await (0, ask_1.askCommand)({
+        message,
+        agent: options.agent,
+        engine: options.engine,
+        model: options.model,
+        workspace: options.workspace,
+        file: options.file,
+        json: options.json,
+        sessionId: options.sessionId,
+        verbose,
+    });
+});
+// Agent command - gateway-friendly machine interface
+program
+    .command('agent')
+    .description('Run agent operations')
+    .command('run')
+    .description('Run a single prompt and output JSON')
+    .requiredOption('--json', 'Output JSON (required)')
+    .requiredOption('--prompt <message>', 'Prompt text')
+    .option('--pack <name>', 'Agent pack to use')
+    .option('-e, --engine <id>', 'Override pack engine: claude|codex|<custom-engine-id>')
+    .option('-m, --model <id>', 'Override pack model (e.g. litellm/gpt-4.1-nano)')
+    .option('-w, --workspace <path>', 'Workspace directory', process.cwd())
+    .option('--session-id <id>', 'Optional session id for the caller')
+    .option('--system-prompt <text>', 'Optional system prompt override')
+    .option('-f, --file <path>', 'Include file content in context')
+    .action(async (options) => {
+    const verbose = program.opts().verbose;
+    await (0, deps_1.ensureDeps)(verbose);
+    await (0, ask_1.askCommand)({
+        message: options.prompt,
+        agent: options.pack,
+        engine: options.engine,
+        model: options.model,
+        workspace: options.workspace,
+        file: options.file,
+        json: true,
+        sessionId: options.sessionId,
+        systemPrompt: options.systemPrompt,
+        outputMode: 'agent-run',
+        verbose,
+    });
+});
+// Serve command - HTTP server
+program
+    .command('serve')
+    .description('Start HTTP server')
+    .requiredOption('-a, --agent <name>', 'Agent pack to use (required)')
+    .option('-e, --engine <id>', 'Override pack engine: claude|codex|<custom-engine-id>')
+    .option('-m, --model <id>', 'Override pack model (e.g. litellm/gpt-4.1-nano)')
+    .option('-p, --port <port>', 'Port to listen on', '3000')
+    .option('--host <address>', 'Address to bind the HTTP server (default 127.0.0.1; use 0.0.0.0 in containers/behind a proxy)')
+    .option('-w, --workspace <path>', 'Default workspace directory', process.cwd())
+    .option('--bind <channels>', 'Bind agent to gateway channels (comma-separated, e.g. "telegram,whatsapp" or "*" for all)')
+    .option('--gateway-bridge', 'Keep a WebSocket to OpenClaw and register this pack so `openclaw agent --agent <id>` routes here (needs OPENCLAW_GATEWAY_TOKEN if your gateway requires it)')
+    .option('--state-dir <path>', 'Persist session state here (honors AGENTHIPPO_HOME; replaces the tmpdir default)')
+    .option('--max-turns-per-session <n>', 'Cap turns per session (abuse/runaway guard); 0 = unlimited', '0')
+    .option('--www-dir <path>', 'Serve deploy/www/index.html at GET / (static browser chat UI)')
+    .action(async (options) => {
+    const verbose = program.opts().verbose;
+    await (0, deps_1.ensureDeps)(verbose);
+    await (0, serve_1.serveCommand)({
+        agent: options.agent,
+        engine: options.engine,
+        model: options.model,
+        port: parseInt(options.port, 10),
+        host: options.host,
+        workspace: options.workspace,
+        bind: options.bind,
+        gatewayBridge: Boolean(options.gatewayBridge),
+        stateDir: options.stateDir,
+        maxTurnsPerSession: parseInt(options.maxTurnsPerSession, 10),
+        wwwDir: options.wwwDir,
+        verbose,
+    });
+});
+program
+    .command('auth-broker')
+    .description('Start the AgentHippo auth broker (OAuth + IDE bootstrap API)')
+    .action(async () => {
+    await (0, auth_broker_1.authBrokerCommand)();
+});
+// Deploy command - generate platform-native deploy artifacts
+program
+    .command('deploy <action> [pack]')
+    .description('Generate a self-contained deploy staging dir (init). Targets: vm, compose, cloudrun, databricks-app, spcs, cloudflare, all')
+    .option('-t, --target <target>', 'Deploy target', 'vm')
+    .option('-o, --out <path>', 'Staging directory (default: ./deploy-out/<pack>-<target>)')
+    .option('--packdir <path>', 'Pack directory (defaults to [pack] arg or cwd)')
+    .option('--image <ref>', 'Runtime image ref', 'ghcr.io/agenthippo/runtime:latest')
+    .option('-p, --port <port>', 'Container port', '8080')
+    .option('--gateway <channels>', 'Agent Anywhere: bind channels (e.g. "slack") + add OpenClaw gateway service (compose target)')
+    .option('--hostname <host>', 'Public hostname for SSO edge (Caddy, OAuth, tunnel)', 'auth.agenthippo.ai')
+    .option('--ingress <mode>', 'Cloud Run ingress: iap (built-in IAP), edge (per-service AgentHippo edge + Google OAuth), or edge-fed (federated: auth via auth.agenthippo.ai, no per-service OAuth)', 'iap')
+    .option('--idp-url <url>', 'edge-fed: central IdP base URL browsers redirect to for login (e.g. https://auth.agenthippo.ai)', 'https://auth.agenthippo.ai')
+    .option('--cookie-domain <domain>', 'edge-fed: parent domain the shared auth cookie is scoped to (e.g. .agenthippo.ai)', '.agenthippo.ai')
+    .option('--force', 'Overwrite existing files')
+    .action(async (action, pack, options) => {
+    const ingress = options.ingress === 'edge' ? 'edge' : options.ingress === 'edge-fed' ? 'edge-fed' : 'iap';
+    await (0, deploy_1.deployCommand)(action, pack, {
+        target: options.target,
+        out: options.out,
+        image: options.image,
+        gateway: options.gateway,
+        hostname: options.hostname,
+        port: parseInt(options.port, 10),
+        force: Boolean(options.force),
+        packdir: options.packdir,
+        ingress,
+        idpUrl: options.idpUrl,
+        cookieDomain: options.cookieDomain,
+    });
+});
+// Pack command - pack management
+program
+    .command('pack <action>')
+    .description('Manage agent packs (list, validate, install)')
+    .argument('[name]', 'Pack name or path')
+    .option('-o, --output <path>', 'Output path for export')
+    .option('-w, --workspace <path>', 'Workspace directory for local packs', process.cwd())
+    .action(async (action, name, options) => {
+    await (0, pack_1.packCommand)({
+        action,
+        name,
+        output: options.output,
+        workspace: options.workspace,
+        verbose: program.opts().verbose,
+    });
+});
+// Store command - search and install from store
+program
+    .command('store <action>')
+    .description('Search, install, and uninstall store artifacts')
+    .argument('[query]', 'Search query or artifact reference (e.g., skill/pdf-tools)')
+    .option('-t, --type <type>', 'Filter by type: pack, skill, mcp, engine, spotlight view')
+    .option('-l, --limit <n>', 'Max results for search', '20')
+    .option('--version <ver>', 'Specific version to install or publish')
+    .option('-w, --workspace <path>', 'Workspace directory', process.cwd())
+    .option('-a, --agent <id>', 'Target agent ID for skill/mcp install', 'default')
+    .option('-f, --force', 'Overwrite existing installation')
+    .option('--bundle <mode>', 'Spotlight view publish bundle: scripts-only (default) or full')
+    .option('--full', 'Publish Spotlight view full bundle: scripts, assets, charts, exports, manifest.json (same as --bundle full)')
+    .option('--json', 'Output as JSON')
+    .action(async (action, query, options) => {
+    await (0, store_1.storeCommand)({
+        action,
+        query,
+        type: options.type,
+        limit: parseInt(options.limit, 10),
+        version: options.version,
+        workspace: options.workspace,
+        agent: options.agent,
+        force: options.force,
+        bundle: options.bundle,
+        full: options.full,
+        json: options.json,
+        verbose: program.opts().verbose,
+    });
+});
+// Gateway command - proactive outbound messaging
+const gatewayCmd = program.command('gateway').description('Gateway outbound messaging');
+gatewayCmd
+    .command('send')
+    .description('Send a proactive message via the gateway (WebSocket RPC; hippoclaw CLI fallback)')
+    .requiredOption('--outbound <path>', 'Session gateway-outbound.json (see AGENTHIPPO_GATEWAY_OUTBOUND_FILE)')
+    .requiredOption('-a, --agent <id>', 'Agent pack id')
+    .requiredOption('-m, --message <text>', 'Message to send')
+    .option('--media <path-or-url>', 'Attach media (image/audio/video/document); local path or URL. Sent via gateway RPC so the bot token resolves from the gateway runtime snapshot.')
+    .option('-t, --target <target>', 'Explicit target (e.g. channel:C01234567); defaults to last inbound route')
+    .option('--thread-id <id>', 'Slack thread ts when sending to a threaded route')
+    .option('--dry-run', 'Print gateway RPC payload without sending')
+    .option('--json', 'Output handle + result as JSON')
+    .action(async (options) => {
+    await (0, gateway_1.gatewaySendCommand)({
+        outbound: options.outbound,
+        agent: options.agent,
+        message: options.message,
+        media: options.media,
+        target: options.target,
+        threadId: options.threadId,
+        dryRun: Boolean(options.dryRun),
+        json: Boolean(options.json),
+    });
+});
+gatewayCmd
+    .command('list')
+    .description('List stored gateway outbound routes from a session file')
+    .requiredOption('--outbound <path>', 'Session gateway-outbound.json (see AGENTHIPPO_GATEWAY_OUTBOUND_FILE)')
+    .option('-a, --agent <id>', 'Filter to one agent pack id')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    await (0, gateway_1.gatewayListCommand)({
+        outbound: options.outbound,
+        agent: options.agent,
+        json: Boolean(options.json),
+    });
+});
+// Anywhere command - gateway lifecycle from CLI
+program
+    .command('anywhere <action>')
+    .description('Manage Agent Anywhere gateway lifecycle')
+    .option('-s, --source <source>', 'Install source (e.g. openclaw@latest, org/repo#branch, /path/to/openclaw)')
+    .option('-p, --port <port>', 'Gateway port', '18789')
+    .option('-b, --bind <address>', 'Gateway bind address', '127.0.0.1')
+    .option('-t, --token <token>', 'Gateway auth token for starter config')
+    .option('--no-start', 'For setup: install/configure without starting')
+    .option('--config-template <path>', 'Path to openclaw.json template')
+    .action(async (action, options) => {
+    const parsedPort = parseInt(options.port, 10);
+    await (0, anywhere_1.anywhereCommand)({
+        action,
+        source: options.source,
+        port: Number.isNaN(parsedPort) ? undefined : parsedPort,
+        bind: options.bind,
+        token: options.token,
+        noStart: options.start === false,
+        configTemplate: options.configTemplate,
+    });
+});
+program
+    .command('__probe-custom-engine')
+    .description('Test custom engine load strategies (import probe)')
+    .option('-e, --engine <id>', 'Custom engine id', 'cursor')
+    .option('-w, --workspace <path>', 'Workspace directory', process.cwd())
+    .option('-s, --strategy <mode>', 'in-process|node-subprocess|all|a|c', 'all')
+    .action(async (options) => {
+    await (0, probe_custom_engine_1.probeCustomEngineCommand)({
+        engine: options.engine,
+        workspace: options.workspace,
+        strategy: options.strategy,
+    });
+});
+// Parse and run
+program.parseAsync();