0xray 4.0.13 → 4.0.14

package/dist/cli/commands/govern.js

@@ -0,0 +1,149 @@
+/**
+ * xray govern — the primary CLI command for the v3 nucleus
+ *
+ * Usage:
+ *   xray govern [options]
+ *
+ * All existing direct commands still work (backward compat with deprecation notice).
+ */
+import { resolve, join } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import { spawn } from 'child_process';
+export async function governCommand(options) {
+    if (options.status) {
+        const { statusCommand } = await import('./status.js');
+        await statusCommand();
+        return;
+    }
+    if (options.audit) {
+        const { securityAuditCommand } = await import('./security-audit.js');
+        await securityAuditCommand();
+        return;
+    }
+    if (options.mcp) {
+        const serverMap = {
+            governance: 'dist/mcps/governance.server.js',
+            skills: 'dist/mcps/knowledge-skills/skill-invocation.server.js',
+        };
+        const relPath = serverMap[options.mcp];
+        if (!relPath) {
+            console.error(`Unknown MCP server: ${options.mcp}. Use: governance, skills`);
+            process.exit(1);
+        }
+        const packageJsonPath = resolve(import.meta.url.replace(/^file:/, ''), '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        const packageRoot = resolve(packageJsonPath, '..', pkg.xray?.dist ? join('', pkg.xray.dist) : 'dist', '..');
+        const serverPath = resolve(join(packageRoot, relPath));
+        if (!existsSync(serverPath)) {
+            console.error(`MCP server not found at ${serverPath}. Is xray installed correctly?`);
+            process.exit(1);
+        }
+        const env = { ...process.env };
+        const child = spawn(process.execPath, [serverPath], { stdio: 'inherit', env });
+        child.on('exit', (code) => process.exit(code ?? 0));
+        return;
+    }
+    if (options.pluginInstall) {
+        const { pluginInstallCommand } = await import('./plugin-commands.js');
+        await pluginInstallCommand(options.pluginInstall);
+        return;
+    }
+    if (options.proposals) {
+        const { handleGovernRequest } = await import('../../nucleus/index.js');
+        let proposals;
+        try {
+            proposals = JSON.parse(options.proposals);
+        }
+        catch {
+            console.error('Invalid JSON in --proposals. Expected a JSON string with a "proposals" array.');
+            console.error('Example: xray govern --proposals \'[{"type":"fix","title":"Test","description":"A test"}]\'');
+            process.exit(1);
+        }
+        const result = await handleGovernRequest(proposals);
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (options.skillInstall !== undefined) {
+        const { skillInstallCommand } = await import('./skill-install.js');
+        await skillInstallCommand(options.skillInstall || undefined);
+        return;
+    }
+    if (options.skillRegistry !== undefined) {
+        const { skillRegistryCommand } = await import('./skill-install.js');
+        await skillRegistryCommand(options.skillRegistry || undefined);
+        return;
+    }
+    if (options.storyteller) {
+        const { storytellerCommand } = await import('./storyteller.js');
+        await storytellerCommand(options.storyteller);
+        return;
+    }
+    if (options.mcpList) {
+        const { listMCPsCommand } = await import('./mcp-install.js');
+        listMCPsCommand();
+        return;
+    }
+    if (options.mcpStatus) {
+        const { showMCPStatusCommand } = await import('./mcp-install.js');
+        showMCPStatusCommand();
+        return;
+    }
+    if (options.mcpInstall) {
+        const { installMCPCommand } = await import('./mcp-install.js');
+        await installMCPCommand(options.mcpInstall);
+        return;
+    }
+    if (options.mcpRemove) {
+        const { removeMCPCommand } = await import('./mcp-install.js');
+        removeMCPCommand(options.mcpRemove);
+        return;
+    }
+    if (options.publishAgent) {
+        const { publishAgentCommand } = await import('./publish-agent.js');
+        await publishAgentCommand();
+        return;
+    }
+    if (options.archiveLogs) {
+        const { archiveLogFiles } = await import('./archive-logs.js');
+        const result = await archiveLogFiles(undefined, `govern-${Date.now()}`);
+        console.log(`\nResults:`);
+        console.log(`  Archived: ${result.archived} files`);
+        if (result.errors.length > 0) {
+            console.log(`  Errors: ${result.errors.length}`);
+            result.errors.forEach((e) => console.log(`    - ${e}`));
+            process.exit(1);
+        }
+        return;
+    }
+    if (options.credibleInit !== undefined) {
+        const { credibleInitCommand } = await import('./credible-init.js');
+        await credibleInitCommand();
+        return;
+    }
+    if (options.antigravityStatus) {
+        const { antigravityStatusCommand } = await import('./antigravity-status.js');
+        await antigravityStatusCommand();
+        return;
+    }
+    console.log('xray govern — the governance kernel\n');
+    console.log('Usage: xray govern [options]\n');
+    console.log('Options:');
+    console.log('  --status                   Show framework status');
+    console.log('  --audit                    Run security audit');
+    console.log('  --mcp <server>             Run an MCP server (governance, skills)');
+    console.log('  --plugin-install <name>    Install a plugin');
+    console.log('  --proposals <json>         Run governance on JSON proposals');
+    console.log('  --skill-install [source]   Install skills from registry');
+    console.log('  --skill-registry [action]   Manage skill registry sources');
+    console.log('  --storyteller <type>       Write a story (reflection, saga, journey, narrative)');
+    console.log('  --mcp-list                 List available MCP servers');
+    console.log('  --mcp-status               Show installed MCP servers');
+    console.log('  --mcp-install <name>       Install an MCP server');
+    console.log('  --mcp-remove <name>        Remove an MCP server');
+    console.log('  --publish-agent            Publish an agent to AgentStore');
+    console.log('  --archive-logs             Archive log files');
+    console.log('  --credible-init [name]     Initialize Credible Pod');
+    console.log('  --antigravity-status       Show installed skills status');
+    console.log('  -h, --help                 Show this help\n');
+    console.log('All existing commands still work: xray status, xray security-audit, etc.');
+}

package/dist/cli/commands/grok-install.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI command: 0xray grok install
+ *
+ * Helps users register 0xRay MCP servers with the Grok CLI.
+ */
+import { Command } from 'commander';
+export declare function registerGrokCommands(grokCmd: Command): void;

package/dist/cli/commands/grok-install.js

@@ -0,0 +1,16 @@
+/**
+ * CLI command: 0xray grok install
+ *
+ * Helps users register 0xRay MCP servers with the Grok CLI.
+ */
+import { installForGrokCLI } from '../../integrations/grok/grok-cli.js';
+export function registerGrokCommands(grokCmd) {
+    grokCmd
+        .command('install')
+        .description('Install 0xRay as a first-class Grok CLI plugin (hooks + MCP servers)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .option('--force', 'Force reinstall even if already present')
+        .action(async (options) => {
+        await installForGrokCLI({ dryRun: options.dryRun, force: options.force });
+    });
+}

package/dist/cli/commands/hermes-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerHermesCommands(hermesCmd: Command): void;

package/dist/cli/commands/hermes-install.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { syncBuiltinSkills } from './skill-install.js';
+import { mintAfterWear } from './foundry-mint-wear.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const require = createRequire(import.meta.url);
+const packageRoot = path.join(__dirname, '..', '..', '..');
+const millSuit = require(path.join(packageRoot, 'scripts', 'foundry', 'mint-suit.cjs'));
+const wiring = require(path.join(packageRoot, 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+export function registerHermesCommands(hermesCmd) {
+    hermesCmd
+        .command('install')
+        .description('Install 0xRay as a Hermes Agent plugin (hooks + MCP servers)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .option('--force', 'Force reinstall even if already present')
+        .action(async (options) => {
+        await installForHermes({ dryRun: options.dryRun, force: options.force });
+    });
+}
+async function installForHermes(options = {}) {
+    frameworkLogger.log('hermes-integration', 'install-start', 'info', { options });
+    const isolated = millSuit.isIsolatedHome();
+    const targetPluginDir = isolated
+        ? path.join(process.cwd(), '.hermes/plugins/xray-hermes')
+        : path.join(millSuit.machineHome(), '.hermes/plugins/xray-hermes');
+    const possibleSources = [
+        path.join(__dirname, '..', '..', '..', 'dist/integrations/hermes-agent'),
+        path.join(__dirname, '..', '..', '..', 'src/integrations/hermes-agent'),
+    ];
+    let sourceDir = possibleSources.find(p => fs.existsSync(p));
+    if (!sourceDir) {
+        console.error('[Hermes] Could not locate the xray-hermes plugin inside the package.');
+        return;
+    }
+    if (options.dryRun) {
+        console.log(`[Hermes] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
+        return;
+    }
+    const targetDir = process.cwd();
+    try {
+        const pluginExists = fs.existsSync(targetPluginDir);
+        if (pluginExists && !options.force) {
+            console.log('[Hermes] xray-hermes plugin is already installed.');
+            console.log('Use --force to reinstall.');
+        }
+        else {
+            fs.mkdirSync(targetPluginDir, { recursive: true });
+            for (const entry of fs.readdirSync(sourceDir)) {
+                const src = path.join(sourceDir, entry);
+                const dst = path.join(targetPluginDir, entry);
+                if (fs.statSync(src).isDirectory()) {
+                    fs.cpSync(src, dst, { recursive: true, force: true });
+                }
+                else {
+                    fs.copyFileSync(src, dst);
+                }
+            }
+            frameworkLogger.log('hermes-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
+            console.log(`\x1b[32m✓ Copied Hermes plugin to ${targetPluginDir}\x1b[0m`);
+            const hermesSkillsDir = path.join(targetPluginDir, 'skills');
+            const skillsCopied = syncBuiltinSkills(hermesSkillsDir);
+            if (skillsCopied > 0) {
+                console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Hermes plugin\x1b[0m`);
+            }
+            frameworkLogger.log('hermes-integration', 'skills-synced', 'info', { count: skillsCopied });
+        }
+        wiring.copyHermesFindProjectRootHelper(packageRoot, targetPluginDir);
+        if (!isolated && wiring.copyHermesHookRuntimes(packageRoot)) {
+            frameworkLogger.log('hermes-integration', 'hooks-copied', 'info', {});
+        }
+        const wired = isolated ? { count: 0 } : wiring.wireHermesBridge(targetDir);
+        mintAfterWear(targetDir);
+        console.log(`\x1b[32m✓ Wired Hermes mcp_servers (${wired.count} servers)\x1b[0m`);
+        console.log(`\x1b[32m✓ Consumer root → ${targetDir}\x1b[0m`);
+        const afterInstallPath = path.join(targetPluginDir, 'after-install.md');
+        if (fs.existsSync(afterInstallPath)) {
+            console.log(`\nSee ${afterInstallPath} for post-install steps.`);
+        }
+        console.log('\n✅ 0xRay is now installed as a Hermes Agent plugin!');
+        console.log('Restart Hermes to load the plugin, MCP servers, and tools.');
+        console.log('  Run: hermes mcp list  (to verify)');
+    }
+    catch (err) {
+        frameworkLogger.log('hermes-integration', 'install-error', 'error', { error: err.message });
+        console.error('Failed to install Hermes plugin:', err.message);
+    }
+    frameworkLogger.log('hermes-integration', 'install-complete', 'info', {});
+}

package/dist/cli/commands/mcp-install.d.ts

@@ -0,0 +1,4 @@
+export declare function listMCPsCommand(): void;
+export declare function showMCPStatusCommand(): void;
+export declare function installMCPCommand(name: string): Promise<void>;
+export declare function removeMCPCommand(name: string): void;

package/dist/cli/commands/mcp-install.js

@@ -0,0 +1,253 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { getConfigDir } from "../../core/config-paths.js";
+function getMCPConfigPath() {
+    return join(process.cwd(), ".xray", "mcp-registry.json");
+}
+function getBundledMCPRegistry() {
+    const paths = [
+        join(process.cwd(), "src", "mcps", "registry.json"),
+        join(process.cwd(), "dist", "mcps", "registry.json"),
+        join(process.cwd(), "node_modules", "0xray", "dist", "mcps", "registry.json"),
+        join(process.cwd(), "node_modules", "0xray", "src", "mcps", "registry.json"),
+    ];
+    for (const p of paths) {
+        if (existsSync(p)) {
+            return JSON.parse(readFileSync(p, "utf-8"));
+        }
+    }
+    return null;
+}
+function getMCPRegistry() {
+    const bundled = getBundledMCPRegistry();
+    const localPath = getMCPConfigPath();
+    if (existsSync(localPath)) {
+        const local = JSON.parse(readFileSync(localPath, "utf-8"));
+        if (bundled) {
+            const names = new Set(bundled.sources.map((s) => s.name));
+            for (const s of local.sources) {
+                if (!names.has(s.name))
+                    bundled.sources.push(s);
+            }
+            return bundled;
+        }
+        return local;
+    }
+    return bundled ?? { sources: [] };
+}
+function findMCPSource(name) {
+    return getMCPRegistry().sources.find((s) => s.name === name || s.url.includes(name));
+}
+function getInstalledMCPsPath() {
+    const configDir = getConfigDir();
+    return join(configDir, "installed-mcps.json");
+}
+function getInstalledMCPs() {
+    const path = getInstalledMCPsPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveInstalledMCPs(mcps) {
+    const path = getInstalledMCPsPath();
+    const configDir = dirname(path);
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(path, JSON.stringify(mcps, null, 2), "utf-8");
+}
+function showHelp() {
+    console.log(`
+0xRay MCP Installer
+
+Usage:
+  npx 0xray mcp:install <name>   Install an MCP server from registry
+  npx 0xray mcp:list           List available MCP servers
+  npx 0xray mcp:status        Show installed MCPs
+  npx 0xray mcp:remove <name> Remove an installed MCP
+
+Examples:
+  npx 0xray mcp:install xmcp              # Install X (Twitter) MCP
+  npx 0xray mcp:install github-mcp      # Install GitHub MCP
+  npx 0xray mcp:list             # See all available
+  npx 0xray mcp:remove xmcp      # Remove X MCP
+
+Environment Variables:
+  Each MCP requires specific env vars. Check documentation at:
+  https://github.com/0xRay-community/<name>
+`);
+}
+function listMCPs() {
+    const registry = getMCPRegistry();
+    console.log("\n📦 Available Community MCPs:\n");
+    console.log("| Name            | Category           | Description |");
+    console.log("|----------------|-------------------|-------------|");
+    for (const mcp of registry.sources) {
+        const cat = mcp.category || "other";
+        const desc = mcp.description?.slice(0, 30) || "-";
+        console.log(`| ${mcp.name.padEnd(15)} | ${cat.padEnd(16)} | ${desc} |`);
+    }
+    console.log(`\nTotal: ${registry.sources.length} MCPs`);
+    console.log("\nInstall: npx 0xray mcp:install <name>");
+}
+function showStatus() {
+    const installed = getInstalledMCPs();
+    const keys = Object.keys(installed);
+    if (keys.length === 0) {
+        console.log("\n❌ No MCPs installed.\n");
+        console.log("Run: npx 0xray mcp:list to see available MCPs\n");
+        return;
+    }
+    console.log("\n✅ Installed MCPs:\n");
+    for (const [name, mcp] of Object.entries(installed)) {
+        console.log(`  - ${name}: ${mcp.description || mcp.url}`);
+    }
+}
+async function installMCP(name) {
+    const source = findMCPSource(name);
+    if (!source) {
+        console.error(`\n❌ MCP "${name}" not found in registry.`);
+        console.log("\nRun: npx 0xray mcp:list to see available MCPs");
+        process.exit(1);
+    }
+    const installed = getInstalledMCPs();
+    if (installed[source.name]) {
+        console.log(`\n⚠️  ${source.name} is already installed.`);
+        console.log(`Run: npx 0xray mcp:remove ${source.name} first`);
+        process.exit(1);
+    }
+    console.log(`\n📦 Installing ${source.name}...`);
+    console.log(`   Source: ${source.url}`);
+    try {
+        const installDir = join(process.cwd(), ".opencode", "mcps", source.name);
+        if (!existsSync(dirname(installDir))) {
+            mkdirSync(dirname(installDir), { recursive: true });
+        }
+        if (!existsSync(installDir)) {
+            mkdirSync(installDir, { recursive: true });
+        }
+        execSync(`git clone ${source.url} "${installDir}"`, {
+            stdio: "inherit",
+        });
+        installed[source.name] = source;
+        saveInstalledMCPs(installed);
+        console.log(`\n✅ ${source.name} installed successfully!`);
+        console.log(`\n📝 Environment variables needed:`);
+        if (source.env) {
+            for (const env of source.env) {
+                console.log(`   - ${env}`);
+            }
+        }
+        console.log(`\n📁 Location: ${installDir}`);
+        console.log(`\n─── SETUP INSTRUCTIONS ───`);
+        console.log(`\n1. Configure environment variables:`);
+        console.log(`   export ${source.env?.[0] || 'API_KEY'}=your_key_here`);
+        console.log(`\n2. Add to your MCP client:\n`);
+        if (source.name === 'xmcp') {
+            console.log(`   Claude Desktop: Add to claude_desktop_config.json`);
+            console.log(`   {"mcpServers":{"xmcp":{"command":"node","args":["${installDir}/dist/index.js"],"env":{"X_BEARER_TOKEN":"your_token"}}}`);
+        }
+        else if (source.name === 'github-mcp') {
+            console.log(`   Add: {"mcpServers":{"github-mcp":{"command":"npx","args":["-y","@divyanshvn/github-mcp-server"],"env":{"GITHUB_TOKEN":"ghp_..."}}}`);
+        }
+        else if (source.name === 'discord-mcp') {
+            console.log(`   Add: {"mcpServers":{"discord-mcp":{"command":"docker","args":["run","--rm","-i","-e","DISCORD_TOKEN=your_token","pasympa/discord-mcp"]}}`);
+        }
+        else {
+            console.log(`   Claude Desktop: Edit ~/Library/Application\\ Support/Claude/claude_desktop_config.json`);
+            console.log(`   Cursor: Edit ~/.cursor/mcp.json`);
+        }
+        console.log(`\n3. Start the MCP server:`);
+        console.log(`   cd ${installDir} && npm install && npm start`);
+        console.log(`\n4. Restart your MCP client to load the new server.`);
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to install ${source.name}:`, error);
+        process.exit(1);
+    }
+}
+function removeMCP(name) {
+    const installed = getInstalledMCPs();
+    if (!installed[name]) {
+        console.error(`\n❌ ${name} is not installed.`);
+        process.exit(1);
+    }
+    const installDir = join(process.cwd(), ".opencode", "mcps", name);
+    if (existsSync(installDir)) {
+        rmSync(installDir, { recursive: true, force: true });
+    }
+    delete installed[name];
+    saveInstalledMCPs(installed);
+    console.log(`\n✅ Removed ${name}`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    switch (command) {
+        case "list":
+            listMCPs();
+            break;
+        case "status":
+        case undefined:
+            showStatus();
+            break;
+        case "install":
+            const name = args[1];
+            if (!name) {
+                console.error("\nUsage: npx 0xray mcp:install <name>");
+                console.log("Run: npx 0xray mcp:list to see available MCPs");
+                process.exit(1);
+            }
+            await installMCP(name);
+            break;
+        case "remove":
+            const removeName = args[1];
+            if (!removeName) {
+                console.error("\nUsage: npx 0xray mcp:remove <name>");
+                process.exit(1);
+            }
+            removeMCP(removeName);
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+            showHelp();
+            break;
+        default:
+            console.error(`\nUnknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});
+// Export CLI entry points
+export function listMCPsCommand() {
+    listMCPs();
+}
+export function showMCPStatusCommand() {
+    showStatus();
+}
+export async function installMCPCommand(name) {
+    if (!name) {
+        console.error("\nUsage: npx 0xray mcp:install <name>");
+        console.log("Run: npx 0xray mcp:list to see available MCPs");
+        process.exit(1);
+    }
+    await installMCP(name);
+}
+export function removeMCPCommand(name) {
+    if (!name) {
+        console.error("\nUsage: npx 0xray mcp:remove <name>");
+        process.exit(1);
+    }
+    removeMCP(name);
+}

package/dist/cli/commands/openclaw-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpenClawCommands(openclawCmd: Command): void;

package/dist/cli/commands/openclaw-install.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { syncBuiltinSkills } from './skill-install.js';
+import { mintAfterWear } from './foundry-mint-wear.js';
+import { OpenClawConfigLoader } from '../../integrations/openclaw/config.js';
+import { writeSuitSessionBoot } from '../../nucleus/suit-temperament.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const require = createRequire(import.meta.url);
+const millSuit = require(path.join(__dirname, '..', '..', '..', 'scripts', 'foundry', 'mint-suit.cjs'));
+const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+export function registerOpenClawCommands(openclawCmd) {
+    openclawCmd
+        .command('install')
+        .description('Install 0xRay OpenClaw integration (config + API server setup)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .option('--force', 'Force reinstall even if already present')
+        .action(async (options) => {
+        await installForOpenClaw({ dryRun: options.dryRun, force: options.force });
+    });
+}
+async function installForOpenClaw(options = {}) {
+    frameworkLogger.log('openclaw-integration', 'install-start', 'info', { options });
+    const configPath = path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
+    if (options.dryRun) {
+        console.log(`[OpenClaw] Dry run: Would create config at ${configPath}`);
+        return;
+    }
+    const targetDir = process.cwd();
+    try {
+        const configExists = fs.existsSync(configPath);
+        if (configExists && !options.force) {
+            console.log(`[OpenClaw] Config already exists at ${configPath}.`);
+            console.log('Use --force to overwrite sample config.');
+        }
+        else {
+            const loader = new OpenClawConfigLoader(configPath);
+            loader.createSampleConfig();
+            const relative = path.relative(process.cwd(), configPath);
+            console.log(`\x1b[32m✓ Created OpenClaw config at ${relative}\x1b[0m`);
+        }
+        const isolated = millSuit.isIsolatedHome();
+        const openclawSkillsDir = isolated
+            ? path.join(targetDir, '.openclaw', 'skills')
+            : path.join(millSuit.machineHome(), '.openclaw', 'skills');
+        const skillsCopied = syncBuiltinSkills(openclawSkillsDir);
+        if (skillsCopied > 0) {
+            console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to ~/.openclaw/skills/\x1b[0m`);
+        }
+        frameworkLogger.log('openclaw-integration', 'skills-synced', 'info', { count: skillsCopied });
+        mintAfterWear(targetDir);
+        const wired = isolated
+            ? { count: 0, path: configPath, method: 'skipped-isolated-home' }
+            : wiring.wireOpenClawBridge(targetDir);
+        console.log(`\x1b[32m✓ Wired OpenClaw MCP servers (${wired.count} via ${wired.method}) → ${wired.path}\x1b[0m`);
+        console.log(`\x1b[32m✓ Consumer root → ${targetDir}\x1b[0m`);
+        try {
+            writeSuitSessionBoot(targetDir, 'openclaw', { source: '0xray/openclaw-install' });
+        }
+        catch {
+            /* session-boot is best-effort */
+        }
+        const packageRoot = path.resolve(__dirname, '..', '..', '..');
+        const hookInstalled = isolated ? null : wiring.installOpenClawHostWear(packageRoot);
+        const cliBackend = isolated ? false : wiring.maybeWriteOpenClawCliBackend();
+        frameworkLogger.log('openclaw-integration', 'cli-backend', 'info', { written: cliBackend });
+        if (hookInstalled) {
+            console.log(`\x1b[32m✓ OpenClaw PreToolUse hook → ${hookInstalled}\x1b[0m`);
+        }
+        console.log('\n✅ 0xRay OpenClaw integration configured!');
+        console.log('Run `openclaw mcp list` to verify MCP servers.');
+        console.log('Edit `.xray/config/openclaw.json` for gateway URL, auth token, and device ID.');
+    }
+    catch (err) {
+        frameworkLogger.log('openclaw-integration', 'install-error', 'error', { error: err.message });
+        console.error('Failed to install OpenClaw integration:', err.message);
+    }
+    frameworkLogger.log('openclaw-integration', 'install-complete', 'info', {});
+}

package/dist/cli/commands/opencode-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpencodeCommands(opencodeCmd: Command): void;