0xray 4.0.13 → 4.0.15

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

@@ -0,0 +1,154 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'node:url';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { syncBuiltinSkills } from './skill-install.js';
+import { mintAfterWear, wantsCostume } from './foundry-mint-wear.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
+export function registerOpencodeCommands(opencodeCmd) {
+    opencodeCmd
+        .command('install')
+        .description('Install 0xRay OpenCode plugin (agents, skills, hooks, config)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .option('--force', 'Force reinstall even if already present')
+        .action(async (options) => {
+        await installForOpencode({ dryRun: options.dryRun, force: options.force });
+    });
+}
+const MERGE_FILES = new Set(["xray/features.json", "enforcer-config.json"]);
+const SKIP_DIRS = new Set(["node_modules", "logs"]);
+const KEEP_IF_EXISTS = new Set([".yml", ".yaml", ".md"]);
+function deepMerge(src, dest) {
+    if (typeof src !== "object" || src === null)
+        return dest !== undefined ? dest : src;
+    if (Array.isArray(src))
+        return Array.isArray(dest) ? dest : src;
+    const result = {};
+    for (const key of Object.keys(src)) {
+        result[key] = dest && typeof dest[key] !== "undefined" ? deepMerge(src[key], dest[key]) : src[key];
+    }
+    if (dest && typeof dest === "object") {
+        for (const key of Object.keys(dest)) {
+            if (!(key in src))
+                result[key] = dest[key];
+        }
+    }
+    return result;
+}
+function copyDir(src, dest, relPath = "") {
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        const rel = path.join(relPath, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, rel);
+        }
+        else if (MERGE_FILES.has(rel)) {
+            try {
+                const srcData = JSON.parse(fs.readFileSync(srcPath, "utf8"));
+                if (fs.existsSync(destPath)) {
+                    const destData = JSON.parse(fs.readFileSync(destPath, "utf8"));
+                    fs.writeFileSync(destPath, JSON.stringify(deepMerge(srcData, destData), null, 2));
+                }
+                else {
+                    fs.copyFileSync(srcPath, destPath);
+                }
+            }
+            catch {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+        else if (KEEP_IF_EXISTS.has(path.extname(srcPath)) && fs.existsSync(destPath)) {
+            return;
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+async function installForOpencode(options = {}) {
+    frameworkLogger.log('opencode-integration', 'install-start', 'info', { options });
+    const opencodeSource = path.join(__dirname, '..', '..', '..', '.opencode');
+    const opencodeDest = path.join(process.cwd(), '.opencode');
+    if (!fs.existsSync(opencodeSource)) {
+        console.error('[Opencode] Could not locate .opencode/ directory inside the package.');
+        return;
+    }
+    if (options.dryRun) {
+        console.log(`[Opencode] Dry run: Would copy ${opencodeSource} → ${opencodeDest}`);
+        return;
+    }
+    try {
+        // Auto-create package.json if missing (OpenCode requires it)
+        const consumerPkgPath = path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(consumerPkgPath)) {
+            const pkg = {
+                name: path.basename(process.cwd()),
+                version: '1.0.0',
+                private: true,
+                dependencies: {
+                    '0xray': '*',
+                },
+            };
+            fs.writeFileSync(consumerPkgPath, JSON.stringify(pkg, null, 2) + '\n');
+            console.log(`\x1b[32m✓ Created package.json with 0xray dependency\x1b[0m`);
+        }
+        const opencodeDestExists = fs.existsSync(opencodeDest);
+        if (opencodeDestExists && !options.force) {
+            console.log('[Opencode] .opencode/ directory already exists.');
+            console.log('Use --force to reinstall.');
+        }
+        else {
+            if (wantsCostume(process.cwd())) {
+                copyDir(opencodeSource, opencodeDest);
+                frameworkLogger.log('opencode-integration', 'opencode-copied', 'info', { destination: opencodeDest });
+            }
+            else {
+                fs.mkdirSync(opencodeDest, { recursive: true });
+                frameworkLogger.log('opencode-integration', 'mill-plant-plugin', 'info', { destination: opencodeDest });
+            }
+            const pluginSource = path.join(__dirname, '..', '..', '..', 'dist', 'plugin', 'xray-codex-injection.js');
+            const pluginDest = path.join(opencodeDest, 'plugin', 'xray-codex-injection.js');
+            if (fs.existsSync(pluginSource)) {
+                const pluginDestDir = path.dirname(pluginDest);
+                if (!fs.existsSync(pluginDestDir))
+                    fs.mkdirSync(pluginDestDir, { recursive: true });
+                fs.copyFileSync(pluginSource, pluginDest);
+                console.log(`\x1b[32m✓ Copied plugin to .opencode/plugin/\x1b[0m`);
+            }
+            else {
+                console.log('ℹ️  Plugin source not found (build may be needed)');
+            }
+            const opencodeSkillsDir = path.join(opencodeDest, 'skills');
+            const skillsCopied = syncBuiltinSkills(opencodeSkillsDir);
+            if (skillsCopied > 0) {
+                console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to .opencode/skills/\x1b[0m`);
+            }
+            frameworkLogger.log('opencode-integration', 'skills-synced', 'info', { count: skillsCopied });
+            console.log(`\x1b[32m✓ Copied OpenCode config to .opencode/\x1b[0m`);
+        }
+        const rootOpencode = path.join(__dirname, '..', '..', '..', 'opencode.json');
+        const userOpencode = path.join(process.cwd(), 'opencode.json');
+        if (fs.existsSync(rootOpencode) && !fs.existsSync(userOpencode)) {
+            fs.copyFileSync(rootOpencode, userOpencode);
+            console.log(`\x1b[32m✓ Seeded opencode.json from 0xRay template\x1b[0m`);
+        }
+        const mcpCount = wiring.wireOpencodeBridge(process.cwd());
+        mintAfterWear(process.cwd());
+        console.log(`\x1b[32m✓ Wired opencode.json mcp (${mcpCount} servers)\x1b[0m`);
+        console.log('\n✅ 0xRay OpenCode plugin installed!');
+        console.log('Restart OpenCode or run `opencode mcp list` to verify MCP servers.');
+    }
+    catch (err) {
+        frameworkLogger.log('opencode-integration', 'install-error', 'error', { error: err.message });
+        console.error('Failed to install OpenCode plugin:', err.message);
+    }
+    frameworkLogger.log('opencode-integration', 'install-complete', 'info', {});
+}

package/dist/cli/commands/plugin-commands.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ */
+export declare function pluginListCommand(): Promise<void>;
+export declare function pluginInstallCommand(pluginName: string): Promise<void>;
+export declare function pluginEnableCommand(pluginName: string): Promise<void>;
+export declare function pluginDisableCommand(pluginName: string): Promise<void>;
+export declare function pluginStatusCommand(pluginName: string): Promise<void>;
+export declare function pluginUninstallCommand(pluginName: string): Promise<void>;

package/dist/cli/commands/plugin-commands.js

@@ -0,0 +1,245 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { spawnSync } from "child_process";
+const PLUGINS_DIR = ".xray/plugins";
+const CONFIG_PATH = ".xray/config/plugin-config.json";
+export async function pluginListCommand() {
+    console.log("\n📦 0xRay Plugins\n");
+    console.log("═".repeat(60));
+    if (!fs.existsSync(PLUGINS_DIR)) {
+        console.log("No plugins installed.");
+        console.log("Install a plugin: npx 0xray plugin install <name>");
+        return;
+    }
+    const entries = fs.readdirSync(PLUGINS_DIR, { withFileTypes: true });
+    const plugins = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const manifestPath = path.join(PLUGINS_DIR, entry.name, "plugin.yaml");
+        if (fs.existsSync(manifestPath)) {
+            const manifest = parseYaml(fs.readFileSync(manifestPath, "utf-8"));
+            validateManifest(manifest);
+            plugins.push({
+                name: entry.name,
+                type: manifest.type || "unknown",
+                version: manifest.version || "0.0.0",
+                enabled: true,
+            });
+        }
+    }
+    if (plugins.length === 0) {
+        console.log("No plugins installed.");
+    }
+    else {
+        for (const plugin of plugins) {
+            console.log(`  ${plugin.enabled ? "✅" : "❌"} ${plugin.name}`);
+            console.log(`     Type: ${plugin.type} | Version: ${plugin.version}`);
+        }
+    }
+    console.log("\n" + "═".repeat(60));
+    console.log(`\nTotal: ${plugins.length} plugin(s)`);
+    console.log("\nInstall: npx 0xray plugin install <name>");
+    console.log("Details: npx 0xray plugin status <name>\n");
+}
+export async function pluginInstallCommand(pluginName) {
+    console.log(`\n📦 Installing plugin: ${pluginName}`);
+    const pluginPath = path.join(PLUGINS_DIR, pluginName);
+    if (fs.existsSync(pluginPath)) {
+        console.log(`❌ Plugin already installed: ${pluginName}`);
+        return;
+    }
+    if (!/^[a-zA-Z0-9@\/_.-]+$/.test(pluginName)) {
+        console.log(`❌ Invalid plugin name: ${pluginName}`);
+        return;
+    }
+    // Try npm install first
+    try {
+        console.log(`🔍 Checking npm for: ${pluginName}`);
+        // Check if package exists
+        const viewR = spawnSync('npm', ['view', pluginName, 'name'], { stdio: 'pipe' });
+        if (viewR.status !== 0)
+            throw new Error('npm view failed');
+        console.log(`📥 Installing from npm: ${pluginName}`);
+        const installR = spawnSync('npm', ['install', '--prefix', PLUGINS_DIR, pluginName], { stdio: 'inherit' });
+        if (installR.status !== 0)
+            throw new Error('npm install failed');
+        const installedPath = path.join(PLUGINS_DIR, "node_modules", pluginName);
+        if (fs.existsSync(installedPath)) {
+            // Move to plugins dir
+            fs.renameSync(installedPath, pluginPath);
+            console.log(`✅ Installed from npm: ${pluginName}`);
+        }
+        else {
+            console.log(`⚠️  Package installed but no plugin.yaml found`);
+            console.log(`   You may need to create a plugin.yaml manifest`);
+        }
+        // Clean up node_modules
+        const nodeModulesPath = path.join(PLUGINS_DIR, "node_modules");
+        if (fs.existsSync(nodeModulesPath)) {
+            fs.rmSync(nodeModulesPath, { recursive: true, force: true });
+        }
+        return;
+    }
+    catch {
+        // Not an npm package, try local installation
+    }
+    // Check if it's a local path
+    if (fs.existsSync(pluginName)) {
+        console.log(`📁 Installing from local path: ${pluginName}`);
+        fs.cpSync(pluginName, pluginPath, { recursive: true });
+        console.log(`✅ Installed from local: ${pluginName}`);
+        return;
+    }
+    // Check if it's in examples
+    const examplePath = path.join(process.cwd(), "examples", "plugins", pluginName);
+    if (fs.existsSync(examplePath)) {
+        console.log(`📁 Installing from examples: ${pluginName}`);
+        fs.cpSync(examplePath, pluginPath, { recursive: true });
+        console.log(`✅ Installed from examples: ${pluginName}`);
+        return;
+    }
+    // Manual installation
+    console.log("⚠️  Manual installation required.");
+    console.log(`   1. Clone/create plugin to: ${pluginPath}`);
+    console.log("   2. Add plugin.yaml manifest");
+    console.log("   3. Run: npx 0xray plugin enable " + pluginName + "\n");
+}
+export async function pluginEnableCommand(pluginName) {
+    console.log(`\n✅ Enabling plugin: ${pluginName}`);
+    const pluginPath = path.join(PLUGINS_DIR, pluginName);
+    const manifestPath = path.join(pluginPath, "plugin.yaml");
+    if (!fs.existsSync(manifestPath)) {
+        console.log(`❌ Plugin not found: ${pluginName}`);
+        console.log(`   Install first: npx 0xray plugin install ${pluginName}`);
+        return;
+    }
+    console.log("ℹ️  To enable, add to config:");
+    console.log(`   Edit: ${CONFIG_PATH}`);
+    console.log(`   Add: "${pluginName}": { "enabled": true }\n`);
+}
+export async function pluginDisableCommand(pluginName) {
+    console.log(`\n❌ Disabling plugin: ${pluginName}`);
+    console.log(`   Edit: ${CONFIG_PATH}`);
+    console.log(`   Set: "${pluginName}": { "enabled": false }\n`);
+}
+export async function pluginStatusCommand(pluginName) {
+    console.log(`\n📋 Plugin Status: ${pluginName}\n`);
+    console.log("═".repeat(50));
+    const pluginPath = path.join(PLUGINS_DIR, pluginName);
+    const manifestPath = path.join(pluginPath, "plugin.yaml");
+    if (!fs.existsSync(manifestPath)) {
+        console.log(`❌ Plugin not found: ${pluginName}`);
+        return;
+    }
+    const manifest = parseYaml(fs.readFileSync(manifestPath, "utf-8"));
+    validateManifest(manifest);
+    const m = manifest;
+    console.log(`  Name:        ${m.name}`);
+    console.log(`  Version:     ${m.version}`);
+    console.log(`  Type:        ${m.type}`);
+    console.log(`  Description: ${m.description}`);
+    console.log(`  License:     ${m.license || "N/A"}`);
+    if (m.capabilities) {
+        console.log("\n  Capabilities:");
+        for (const cap of m.capabilities) {
+            console.log(`    - ${cap}`);
+        }
+    }
+    if (m.tools) {
+        console.log("\n  Tools:");
+        for (const tool of m.tools) {
+            console.log(`    - ${tool.name}: ${tool.description}`);
+        }
+    }
+    if (m.runtime) {
+        const runtime = m.runtime;
+        console.log("\n  Runtime:");
+        console.log(`    Command: ${runtime.command}`);
+        if (runtime.args) {
+            console.log(`    Args:    ${runtime.args.join(" ")}`);
+        }
+    }
+    console.log("\n" + "═".repeat(50) + "\n");
+}
+export async function pluginUninstallCommand(pluginName) {
+    console.log(`\n🗑️  Uninstalling plugin: ${pluginName}`);
+    const pluginPath = path.join(PLUGINS_DIR, pluginName);
+    if (!fs.existsSync(pluginPath)) {
+        console.log(`❌ Plugin not found: ${pluginName}`);
+        return;
+    }
+    fs.rmSync(pluginPath, { recursive: true, force: true });
+    console.log(`✅ Plugin removed: ${pluginName}\n`);
+}
+function validateManifest(manifest) {
+    const runtime = manifest.runtime;
+    if (runtime?.command && typeof runtime.command === 'string') {
+        if (/[;&|`$(){}!<>]/.test(runtime.command)) {
+            throw new Error(`Invalid runtime.command: contains shell metacharacters`);
+        }
+        if (runtime.command.includes('..')) {
+            throw new Error(`Invalid runtime.command: path traversal detected`);
+        }
+    }
+}
+function parseYaml(content) {
+    const lines = content.split("\n");
+    const result = {};
+    let currentKey = "";
+    const stack = [
+        { indent: -1, obj: result },
+    ];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const indent = line.search(/\S/);
+        const isListItem = trimmed.startsWith("- ");
+        if (isListItem) {
+            const value = trimmed.slice(2).trim();
+            const top = stack[stack.length - 1];
+            if (top && currentKey && !Array.isArray(top.obj[currentKey])) {
+                top.obj[currentKey] = [];
+            }
+            if (top && currentKey) {
+                top.obj[currentKey].push(value);
+            }
+            continue;
+        }
+        const colonIndex = trimmed.indexOf(":");
+        if (colonIndex > 0) {
+            const key = trimmed.slice(0, colonIndex).trim();
+            const value = trimmed.slice(colonIndex + 1).trim();
+            const top = stack[stack.length - 1];
+            while (top && stack.length > 1 && indent <= top.indent) {
+                stack.pop();
+            }
+            const current = stack[stack.length - 1];
+            if (!current)
+                continue;
+            const parent = current.obj;
+            if (value) {
+                parent[key] = value;
+            }
+            else {
+                parent[key] = {};
+                stack.push({ indent, obj: parent[key] });
+            }
+            currentKey = key;
+        }
+    }
+    return result;
+}

package/dist/cli/commands/publish-agent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Publish Agent CLI Command
+ *
+ * Packages and publishes agents to AgentStore for sharing.
+ *
+ * Usage: npx 0xray publish-agent [options]
+ * Options:
+ *   --agent <name>    Agent name to publish (required)
+ *   --version <ver>   Version (optional, auto-detected)
+ *   --dry-run         Preview package without publishing
+ *
+ * Example: npx 0xray publish-agent --agent orchestrator --dry-run
+ */
+export declare function publishAgentCommand(): Promise<void>;
+export default publishAgentCommand;

package/dist/cli/commands/publish-agent.js

@@ -0,0 +1,184 @@
+/**
+ * Publish Agent CLI Command
+ *
+ * Packages and publishes agents to AgentStore for sharing.
+ *
+ * Usage: npx 0xray publish-agent [options]
+ * Options:
+ *   --agent <name>    Agent name to publish (required)
+ *   --version <ver>   Version (optional, auto-detected)
+ *   --dry-run         Preview package without publishing
+ *
+ * Example: npx 0xray publish-agent --agent orchestrator --dry-run
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        agent: "",
+        dryRun: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const nextArg = args[i + 1];
+        if (arg === "--agent" && nextArg && !nextArg.startsWith("--")) {
+            options.agent = nextArg;
+            i++;
+        }
+        else if (arg === "--version" && nextArg && !nextArg.startsWith("--")) {
+            options.version = nextArg;
+            i++;
+        }
+        else if (arg === "--dry-run") {
+            options.dryRun = true;
+        }
+        else if (arg && !arg.startsWith("--")) {
+            options.agent = arg;
+        }
+    }
+    return options;
+}
+function getAgentConfig(agentName, cwd) {
+    const configPaths = [
+        join(cwd, "src", "opencode", "agents", `${agentName}.yml`),
+        join(cwd, "agents", `${agentName}.yml`),
+        join(cwd, ".opencode", "agents", `${agentName}.yml`),
+        join(cwd, "agents", `${agentName}.yaml`),
+        join(cwd, ".opencode", "agents", `${agentName}.yaml`),
+    ];
+    for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+function extractYamlField(content, field) {
+    const regex = new RegExp(`^${field}:\\s*(.+)$`, "m");
+    const match = content.match(regex);
+    return match && match[1] ? match[1].trim() : null;
+}
+function getPackageVersion(cwd) {
+    try {
+        const pkgPath = join(cwd, "package.json");
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (pkg.version)
+                return pkg.version;
+        }
+    }
+    catch { /* ignore */ }
+    const xrayPkgPath = join(cwd, ".opencode", "package.json");
+    try {
+        if (existsSync(xrayPkgPath)) {
+            const pkg = JSON.parse(readFileSync(xrayPkgPath, "utf-8"));
+            if (pkg.version)
+                return pkg.version;
+        }
+    }
+    catch { /* ignore */ }
+    return "1.0.0";
+}
+function createAgentManifest(agentName, configPath, version, cwd) {
+    const content = readFileSync(configPath, "utf-8");
+    return {
+        name: agentName,
+        version: version,
+        description: extractYamlField(content, "description") || `Agent: ${agentName}`,
+        author: extractYamlField(content, "author") || extractYamlField(content, "maintainer") || "0xRay User",
+        license: extractYamlField(content, "license") || "MIT",
+        source: extractYamlField(content, "source") || "custom",
+        framework: "0xray",
+        frameworkVersion: getPackageVersion(cwd),
+        publishedAt: new Date().toISOString(),
+        skills: [],
+        permissions: extractYamlField(content, "permissions")?.split(",").map((p) => p.trim()) || [],
+        tags: extractYamlField(content, "tags")?.split(",").map((t) => t.trim()) || [],
+    };
+}
+function packageAgent(agentName, configPath, version, cwd) {
+    const outputDir = join(cwd, ".xray", "publish", agentName);
+    mkdirSync(outputDir, { recursive: true });
+    const manifest = createAgentManifest(agentName, configPath, version, cwd);
+    writeFileSync(join(outputDir, "agent.json"), JSON.stringify(manifest, null, 2));
+    writeFileSync(join(outputDir, "AGENT.md"), readFileSync(configPath, "utf-8"));
+    return outputDir;
+}
+export async function publishAgentCommand() {
+    const cwd = process.cwd();
+    const options = parseArgs();
+    console.log("");
+    console.log("╔══════════════════════════════════════════════════╗");
+    console.log("║           xray Agent Publisher             ║");
+    console.log("╚══════════════════════════════════════════════════╝");
+    console.log("");
+    if (!options.agent) {
+        console.error("❌ Error: Agent name is required");
+        console.log("");
+        console.log("Usage: npx 0xray publish-agent --agent <name> [options]");
+        console.log("");
+        console.log("Options:");
+        console.log("  --agent <name>    Agent name to publish (required)");
+        console.log("  --version <ver>   Version (optional, auto-detected)");
+        console.log("  --dry-run         Preview package without publishing");
+        console.log("");
+        console.log("Example: npx 0xray publish-agent --agent orchestrator");
+        process.exit(1);
+    }
+    const configPath = getAgentConfig(options.agent, cwd);
+    if (!configPath) {
+        console.error(`❌ Error: Agent '${options.agent}' not found`);
+        console.log("");
+        console.log("Searched locations:");
+        console.log(`  • src/opencode/agents/${options.agent}.yml`);
+        console.log(`  • agents/${options.agent}.yml`);
+        console.log(`  • .opencode/agents/${options.agent}.yml`);
+        console.log("");
+        console.log("Available agents in this project:");
+        const agentsDir = join(cwd, "agents");
+        if (existsSync(agentsDir)) {
+            const agents = readdirSync(agentsDir)
+                .filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+            if (agents.length > 0) {
+                agents.forEach((a) => console.log(`  • ${a.replace(/\.(yml|yaml)$/, "")}`));
+            }
+            else {
+                console.log("  (none found)");
+            }
+        }
+        else {
+            console.log("  (agents directory not found)");
+        }
+        process.exit(1);
+    }
+    const version = options.version || getPackageVersion(cwd);
+    console.log(`📦 Agent: ${options.agent}`);
+    console.log(`📄 Config: ${configPath}`);
+    console.log(`🏷️  Version: ${version}`);
+    console.log("");
+    if (options.dryRun) {
+        console.log("🔍 Dry run mode - showing package contents:");
+        console.log("");
+        const manifest = createAgentManifest(options.agent, configPath, version, cwd);
+        console.log("Manifest (agent.json):");
+        console.log(JSON.stringify(manifest, null, 2));
+        console.log("");
+        console.log("✅ Dry run complete - no files written");
+    }
+    else {
+        console.log("📦 Packaging agent...");
+        const outputDir = packageAgent(options.agent, configPath, version, cwd);
+        console.log("");
+        console.log(`✅ Agent packaged successfully!`);
+        console.log("");
+        console.log(`Package location: ${outputDir}`);
+        console.log("");
+        console.log("Next steps:");
+        console.log("  1. Review the generated files");
+        console.log("  2. Test the agent locally");
+        console.log("  3. Publish to AgentStore (coming soon)");
+    }
+    console.log("");
+}
+export default publishAgentCommand;

package/dist/cli/commands/security-audit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Security Audit CLI Command
+ *
+ * Comprehensive security audit with vulnerability scanning,
+ * compliance checking, and weighted voting for architectural decisions.
+ *
+ * Usage:
+ *   npx 0xray security-audit           # Quick audit
+ *   npx 0xray security-audit --deep    # Deep audit with all standards
+ *   npx 0xray security-audit --output ./reports/security.md
+ *   npx 0xray security-audit --no-remediation
+ *   npx 0xray security-audit --no-voting
+ *
+ * Options:
+ *   --deep           Deep scan with all compliance standards (OWASP, CWE, NIST, ISO, PCI)
+ *   --output <path>  Output report to file (JSON or Markdown)
+ *   --format <fmt>   Output format: json, markdown (default: markdown)
+ *   --no-remediation Skip automated remediation analysis
+ *   --no-voting      Disable weighted voting for architectural decisions
+ *   --project <path> Project path to audit (default: current directory)
+ */
+export declare function securityAuditCommand(args?: string[]): Promise<void>;
+export default securityAuditCommand;