0xray 2.0.0

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 strrayPkgPath = join(cwd, ".opencode", "package.json");
+    try {
+        if (existsSync(strrayPkgPath)) {
+            const pkg = JSON.parse(readFileSync(strrayPkgPath, "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: "stringray",
+        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, ".strray", "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.js

@@ -0,0 +1,219 @@
+/**
+ * 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)
+ */
+import { join } from "path";
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { createSecurityAuditSystem, runQuickSecurityAudit, runDeepSecurityAudit, } from "../../security/comprehensive-security-audit.js";
+function parseArgs(args) {
+    const options = {
+        deep: false,
+        output: null,
+        format: "markdown",
+        enableRemediation: true,
+        enableVoting: true,
+        projectPath: null,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case "--deep":
+                options.deep = true;
+                break;
+            case "--output":
+            case "-o":
+                options.output = args[++i] || null;
+                break;
+            case "--format":
+            case "-f":
+                const format = args[++i]?.toLowerCase();
+                if (format === "json" || format === "markdown") {
+                    options.format = format;
+                }
+                break;
+            case "--no-remediation":
+                options.enableRemediation = false;
+                break;
+            case "--no-voting":
+                options.enableVoting = false;
+                break;
+            case "--project":
+            case "-p":
+                options.projectPath = args[++i] || null;
+                break;
+            case "--help":
+            case "-h":
+                printHelp();
+                process.exit(0);
+                break;
+        }
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`
+0xRay Security Audit Command
+
+Comprehensive security audit with vulnerability scanning, compliance checking,
+and weighted voting for architectural decisions.
+
+Usage:
+  npx 0xray security-audit [options]
+
+Options:
+  --deep              Deep scan with all compliance standards
+  --output, -o       Output report to file
+  --format, -f       Output format: json, markdown (default: markdown)
+  --no-remediation   Skip automated remediation analysis
+  --no-voting        Disable weighted voting for architectural decisions
+  --project, -p      Project path to audit
+  --help, -h         Show this help message
+
+Examples:
+  npx 0xray security-audit
+  npx 0xray security-audit --deep
+  npx 0xray security-audit --output ./security-report.md
+  npx 0xray security-audit --format json --output ./report.json
+  `);
+}
+async function runSecurityAudit(options) {
+    const projectPath = options.projectPath || process.cwd();
+    const config = {
+        projectPath,
+        scanDepth: options.deep ? "deep" : "shallow",
+        includeDependencies: true,
+        complianceStandards: options.deep
+            ? ["owasp-top-10", "cwe", "nist", "iso-27001", "pci-dss"]
+            : ["owasp-top-10", "cwe"],
+        enableAutoRemediation: options.enableRemediation,
+        enableWeightedVoting: options.enableVoting,
+    };
+    await frameworkLogger.log("security-audit-cli", "audit-started", "info", {
+        projectPath,
+        deep: options.deep,
+        format: options.format,
+    });
+    if (options.deep) {
+        return runDeepSecurityAudit(projectPath, options.output || undefined);
+    }
+    return runQuickSecurityAudit(projectPath);
+}
+function formatReport(report, format) {
+    if (format === "json") {
+        return JSON.stringify(report, null, 2);
+    }
+    const system = createSecurityAuditSystem({
+        projectPath: report.metadata.projectPath,
+        enableWeightedVoting: false,
+    });
+    return system.generateMarkdownReport(report);
+}
+function printSummary(report) {
+    const scoreEmoji = report.summary.securityScore >= 90
+        ? "🟢"
+        : report.summary.securityScore >= 70
+            ? "🟡"
+            : report.summary.securityScore >= 50
+                ? "🟠"
+                : "🔴";
+    console.log("");
+    console.log("╔══════════════════════════════════════════════════════════╗");
+    console.log("║         0xRay Security Audit Report                 ║");
+    console.log("╚══════════════════════════════════════════════════════════╝");
+    console.log("");
+    console.log(`  📊 Security Score: ${scoreEmoji} ${report.summary.securityScore}/100`);
+    console.log(`  📁 Files Scanned: ${report.metadata.totalFilesScanned}`);
+    console.log(`  ⏱️  Duration: ${report.metadata.duration}ms`);
+    console.log("");
+    console.log("  Vulnerability Summary:");
+    console.log(`    🚨 Critical: ${report.summary.bySeverity.critical}`);
+    console.log(`    🔴 High:     ${report.summary.bySeverity.high}`);
+    console.log(`    🟡 Medium:   ${report.summary.bySeverity.medium}`);
+    console.log(`    🟢 Low:      ${report.summary.bySeverity.low}`);
+    console.log(`    ℹ️  Info:    ${report.summary.bySeverity.info}`);
+    console.log("");
+    if (report.compliance.length > 0) {
+        console.log("  Compliance Results:");
+        for (const result of report.compliance) {
+            const status = result.passed ? "✅" : "❌";
+            console.log(`    ${status} ${result.standard}: ${result.score}/100`);
+        }
+        console.log("");
+    }
+    if (report.remediation.totalIssues > 0) {
+        console.log("  Remediation Plan:");
+        console.log(`    Total Issues: ${report.remediation.totalIssues}`);
+        console.log(`    Automatable:  ${report.remediation.automatable}`);
+        console.log(`    Manual Fix:   ${report.remediation.manualRequired}`);
+        console.log(`    Est. Time:    ${report.remediation.estimatedFixTime}`);
+        console.log("");
+    }
+    if (report.agentConsensus) {
+        console.log("  Agent Consensus:");
+        console.log(`    Agreement: ${report.agentConsensus.averageAgreement}%`);
+        console.log(`    Agents: ${report.agentConsensus.participatingAgents.join(", ")}`);
+        console.log("");
+    }
+    console.log(`  Audit ID: ${report.metadata.auditId}`);
+    console.log(`  Generated: ${report.metadata.timestamp.toISOString()}`);
+    console.log("");
+}
+function saveReport(content, outputPath) {
+    const dir = join(outputPath, "..");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(outputPath, content, "utf-8");
+}
+export async function securityAuditCommand(args = process.argv.slice(2)) {
+    try {
+        const options = parseArgs(args);
+        const report = await runSecurityAudit(options);
+        printSummary(report);
+        if (options.output) {
+            const content = formatReport(report, options.format);
+            saveReport(content, options.output);
+            console.log(`  📄 Report saved to: ${options.output}`);
+            console.log("");
+        }
+        await frameworkLogger.log("security-audit-cli", "audit-completed", "info", {
+            auditId: report.metadata.auditId,
+            vulnerabilities: report.summary.totalVulnerabilities,
+            securityScore: report.summary.securityScore,
+            output: options.output,
+        });
+        process.exit(report.summary.bySeverity.critical > 0 ? 2 : 0);
+    }
+    catch (error) {
+        await frameworkLogger.log("security-audit-cli", "audit-failed", "error", {
+            error: String(error),
+        });
+        console.error("");
+        console.error("  ❌ Security audit failed:");
+        console.error(`     ${error}`);
+        console.error("");
+        process.exit(1);
+    }
+}
+export default securityAuditCommand;
+if (import.meta.url === `file://${process.argv[1]}`) {
+    securityAuditCommand();
+}