0xray 2.0.0

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(), ".opencode", "strray", "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.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { OpenClawConfigLoader } from '../../integrations/openclaw/config.js';
+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(), '.strray', 'config', 'openclaw.json');
+    if (options.dryRun) {
+        console.log(`[OpenClaw] Dry run: Would create config at ${configPath}`);
+        return;
+    }
+    try {
+        if (fs.existsSync(configPath) && !options.force) {
+            console.log(`[OpenClaw] Config already exists at ${configPath}.`);
+            console.log('Use --force to overwrite.');
+            return;
+        }
+        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`);
+        console.log('\n✅ 0xRay OpenClaw integration configured!');
+        console.log('Edit the config file to set your gateway URL, auth token, and device ID.');
+        console.log('');
+        console.log('To initialize the integration in code:');
+        console.log('  import { initializeOpenClawIntegration } from "0xray";');
+        console.log('  const integration = await initializeOpenClawIntegration();');
+    }
+    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.js

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { frameworkLogger } from '../../core/framework-logger.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+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 {
+        if (fs.existsSync(opencodeDest) && !options.force) {
+            console.log('[Opencode] .opencode/ directory already exists.');
+            console.log('Use --force to reinstall.');
+            return;
+        }
+        copyDir(opencodeSource, opencodeDest);
+        frameworkLogger.log('opencode-integration', 'opencode-copied', 'info', { destination: opencodeDest });
+        console.log(`\x1b[32m✓ Copied OpenCode config to .opencode/\x1b[0m`);
+        console.log('\n✅ 0xRay OpenCode plugin installed!');
+        console.log('Restart OpenCode or run `opencode` to load the plugin.');
+    }
+    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.js

@@ -0,0 +1,246 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ * @version 1.1.0
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { spawnSync } from "child_process";
+const PLUGINS_DIR = ".strray/plugins";
+const CONFIG_PATH = ".strray/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;
+}