@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.636

package/dist/heart/daemon/os-cron-deps.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRealOsCronDeps = createRealOsCronDeps;
+exports.createRealCrontabDeps = createRealCrontabDeps;
+exports.resolveOuroBinaryPath = resolveOuroBinaryPath;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function createRealOsCronDeps() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.os_cron_deps_created",
+        message: "created real OS cron deps",
+        meta: { platform: process.platform },
+    });
+    return {
+        exec: (cmd) => {
+            try {
+                (0, child_process_1.execSync)(cmd, { stdio: "ignore" });
+            }
+            catch {
+                /* best effort */
+            }
+        },
+        writeFile: (p, c) => fs.writeFileSync(p, c, "utf-8"),
+        removeFile: (p) => {
+            try {
+                fs.unlinkSync(p);
+            }
+            catch {
+                /* best effort — file may already be gone */
+            }
+        },
+        existsFile: (p) => fs.existsSync(p),
+        listDir: (dir) => {
+            try {
+                return fs.readdirSync(dir);
+            }
+            catch {
+                return [];
+            }
+        },
+        mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
+        homeDir: os.homedir(),
+        envPath: process.env.PATH ?? "",
+    };
+}
+function createRealCrontabDeps() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.crontab_deps_created",
+        message: "created real crontab deps",
+        meta: {},
+    });
+    /* v8 ignore start -- crontab exec closures: calling these in tests would modify the real system crontab @preserve */
+    return {
+        execOutput: (cmd) => (0, child_process_1.execSync)(cmd, { encoding: "utf-8" }),
+        execWrite: (cmd, stdin) => {
+            (0, child_process_1.execSync)(cmd, { input: stdin, stdio: ["pipe", "ignore", "ignore"] });
+        },
+    };
+    /* v8 ignore stop */
+}
+/* v8 ignore start -- ouro path resolution: probes process.argv, filesystem layout, and PATH; branches depend on install method and runtime environment @preserve */
+function resolveOuroBinaryPath() {
+    // Try to resolve from process.argv[1] — the script being run
+    const scriptPath = process.argv[1];
+    if (scriptPath) {
+        // If running via node dist/heart/daemon/daemon-entry.js, resolve the ouro wrapper
+        // The ouro binary is typically at the package root's bin
+        const distDir = path.resolve(path.dirname(scriptPath));
+        const packageBin = path.resolve(distDir, "..", "..", "..", "node_modules", ".bin", "ouro");
+        if (fs.existsSync(packageBin)) {
+            return packageBin;
+        }
+        // Try the repo-local scripts/ouro.sh
+        const repoOuro = path.resolve(distDir, "..", "..", "..", "scripts", "ouro.sh");
+        if (fs.existsSync(repoOuro)) {
+            return repoOuro;
+        }
+    }
+    // Try which ouro
+    try {
+        const result = (0, child_process_1.execSync)("which ouro", { encoding: "utf-8" }).trim();
+        if (result.length > 0)
+            return result;
+    }
+    catch {
+        /* not on PATH */
+    }
+    // Fallback: use "ouro" and rely on PATH
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_fallback",
+        message: "could not resolve full ouro binary path, falling back to 'ouro'",
+        meta: {},
+    });
+    return "ouro";
+}
+/* v8 ignore stop */

package/dist/heart/daemon/os-cron.js

@@ -43,6 +43,7 @@ exports.crontabLine = crontabLine;
 const os = __importStar(require("os"));
 const runtime_1 = require("../../nerves/runtime");
 const PLIST_PREFIX = "bot.ouro.";
+const DAEMON_PLIST_FILENAME = "bot.ouro.daemon.plist";
 function plistLabel(job) {
     return `${PLIST_PREFIX}${job.agent}.${job.taskId}`;
 }
@@ -80,7 +81,7 @@ function scheduleToCalendarInterval(schedule) {
         result.Month = parseInt(month, 10);
     return Object.keys(result).length > 0 ? result : null;
 }
-function generatePlistXml(job) {
+function generatePlistXml(job, envPath) {
     const label = plistLabel(job);
     const seconds = cadenceToSeconds(job.schedule);
     const calendar = seconds === null ? scheduleToCalendarInterval(job.schedule) : null;
@@ -97,7 +98,7 @@ function generatePlistXml(job) {
     else {
         triggerXml = `  <key>StartInterval</key>\n  <integer>1800</integer>`;
     }
-    return [
+    const lines = [
         `<?xml version="1.0" encoding="UTF-8"?>`,
         `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
         `<plist version="1.0">`,
@@ -110,14 +111,12 @@ function generatePlistXml(job) {
         ...job.command.split(" ").slice(1).map((arg) => `    <string>${arg}</string>`),
         `  </array>`,
         triggerXml,
-        `  <key>StandardOutPath</key>`,
-        `  <string>/tmp/${label}.stdout.log</string>`,
-        `  <key>StandardErrorPath</key>`,
-        `  <string>/tmp/${label}.stderr.log</string>`,
-        `</dict>`,
-        `</plist>`,
-        ``,
-    ].join("\n");
+    ];
+    if (envPath) {
+        lines.push(`  <key>EnvironmentVariables</key>`, `  <dict>`, `    <key>PATH</key>`, `    <string>${envPath}</string>`, `  </dict>`);
+    }
+    lines.push(`  <key>StandardOutPath</key>`, `  <string>/tmp/${label}.stdout.log</string>`, `  <key>StandardErrorPath</key>`, `  <string>/tmp/${label}.stderr.log</string>`, `</dict>`, `</plist>`, ``);
+    return lines.join("\n");
 }
 class LaunchdCronManager {
     deps;
@@ -148,7 +147,7 @@ class LaunchdCronManager {
             const label = plistLabel(job);
             const filename = `${label}.plist`;
             const fullPath = `${this.launchAgentsDir}/${filename}`;
-            const xml = generatePlistXml(job);
+            const xml = generatePlistXml(job, this.deps.envPath);
             try {
                 this.deps.exec(`launchctl unload "${fullPath}"`);
             }
@@ -178,7 +177,9 @@ class LaunchdCronManager {
     listPlistFiles() {
         if (!this.deps.existsFile(this.launchAgentsDir))
             return [];
-        return this.deps.listDir(this.launchAgentsDir).filter((f) => f.startsWith(PLIST_PREFIX) && f.endsWith(".plist"));
+        return this.deps.listDir(this.launchAgentsDir).filter((f) => f.startsWith(PLIST_PREFIX) &&
+            f.endsWith(".plist") &&
+            f !== DAEMON_PLIST_FILENAME);
     }
 }
 exports.LaunchdCronManager = LaunchdCronManager;
@@ -248,6 +249,7 @@ function createOsCronManager(options = {}) {
             listDir: () => [],
             mkdirp: () => { },
             homeDir: os.homedir(),
+            envPath: process.env.PATH ?? "",
         };
         /* v8 ignore stop */
         return new LaunchdCronManager(deps);

package/dist/heart/daemon/ouro-bot-entry.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_1 = require("../../nerves/runtime");
 const runtime_logging_1 = require("./runtime-logging");
-const ouro_bot_wrapper_1 = require("./ouro-bot-wrapper");
+const ouro_bot_wrapper_1 = require("../versioning/ouro-bot-wrapper");
 (0, runtime_logging_1.configureDaemonRuntimeLogger)("ouro-bot");
 (0, runtime_1.emitNervesEvent)({
     component: "daemon",
@@ -12,12 +12,14 @@ const ouro_bot_wrapper_1 = require("./ouro-bot-wrapper");
     meta: { args: process.argv.slice(2) },
 });
 void (0, ouro_bot_wrapper_1.runOuroBotWrapper)(process.argv.slice(2)).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "daemon",
         event: "daemon.ouro_bot_entry_error",
         message: "ouro.bot wrapper entrypoint failed",
-        meta: { error: error instanceof Error ? error.message : String(error) },
+        meta: { error: message },
     });
     process.exit(1);
 });

package/dist/heart/daemon/ouro-entry.js

@@ -12,12 +12,14 @@ const runtime_logging_1 = require("./runtime-logging");
     meta: { args: process.argv.slice(2) },
 });
 void (0, daemon_cli_1.runOuroCli)(process.argv.slice(2)).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "daemon",
         event: "daemon.cli_entry_error",
         message: "ouro CLI entrypoint failed",
-        meta: { error: error instanceof Error ? error.message : String(error) },
+        meta: { error: message },
     });
     process.exit(1);
 });

package/dist/heart/daemon/plugin-cli.js

@@ -0,0 +1,432 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivePluginIdFromSource = derivePluginIdFromSource;
+exports.executePluginInstall = executePluginInstall;
+exports.executePluginList = executePluginList;
+exports.executePluginRemove = executePluginRemove;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
+function getPluginsRootDir() {
+    return path.join((0, ouro_version_manager_1.getOuroCliHome)(), "plugins");
+}
+// ── agent.json plugin-list helpers ───────────────────────────────────────────
+//
+// Each agent's bundle (~/AgentBundles/<name>.ouro/agent.json) declares a
+// `plugins[]` array of PluginConfig entries. `--agent <name>` flags on
+// `ouro plugin install / list / remove` operate on that array. This is the
+// ouro-side per-agent enable mechanism; it lives in the consuming agent's
+// bundle, NOT in the plugin's manifest, which stays portable across the
+// universal Claude Code / Copilot CLI spec.
+//
+// Atomic-write note: codebase pattern is plain `fs.writeFileSync(file, JSON
+// + "\n")`. Daemon writes to agent.json are already racy with other handlers,
+// so we match the existing pattern. A future `writeAgentConfig` atomic helper
+// would benefit ~3 callsites; deferred.
+function getAgentJsonPath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "agent.json");
+}
+function readAgentJsonOrThrow(agentName) {
+    const jsonPath = getAgentJsonPath(agentName);
+    if (!fs.existsSync(jsonPath)) {
+        throw new Error(`Agent '${agentName}' bundle not found at ${path.dirname(jsonPath)}. Bundle must exist before installing a plugin for it.`);
+    }
+    const raw = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+    return { raw, path: jsonPath };
+}
+function writeAgentJson(jsonPath, raw) {
+    fs.writeFileSync(jsonPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+}
+function readAgentPluginsList(agentName) {
+    try {
+        const { raw } = readAgentJsonOrThrow(agentName);
+        return Array.isArray(raw.plugins) ? raw.plugins : [];
+    }
+    catch {
+        return [];
+    }
+}
+function addPluginToAgent(agentName, entry) {
+    const { raw, path: jsonPath } = readAgentJsonOrThrow(agentName);
+    const existing = Array.isArray(raw.plugins) ? raw.plugins : [];
+    if (existing.some((p) => p.id === entry.id)) {
+        return { added: false, agentJsonPath: jsonPath };
+    }
+    raw.plugins = [...existing, entry];
+    writeAgentJson(jsonPath, raw);
+    return { added: true, agentJsonPath: jsonPath };
+}
+function removePluginFromAgent(agentName, pluginId) {
+    const { raw, path: jsonPath } = readAgentJsonOrThrow(agentName);
+    const existing = Array.isArray(raw.plugins) ? raw.plugins : [];
+    const next = existing.filter((p) => p.id !== pluginId);
+    if (next.length === existing.length) {
+        return { removed: false, agentJsonPath: jsonPath };
+    }
+    raw.plugins = next;
+    writeAgentJson(jsonPath, raw);
+    return { removed: true, agentJsonPath: jsonPath };
+}
+function listAgentsReferencingPlugin(pluginId) {
+    const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+    if (!fs.existsSync(bundlesRoot))
+        return [];
+    const agents = [];
+    for (const entry of fs.readdirSync(bundlesRoot)) {
+        if (!entry.endsWith(".ouro"))
+            continue;
+        const agentName = entry.slice(0, -".ouro".length);
+        if (readAgentPluginsList(agentName).some((p) => p.id === pluginId)) {
+            agents.push(agentName);
+        }
+    }
+    return agents.sort();
+}
+function derivePluginIdFromSource(source) {
+    // Accepts:
+    //   github:org/repo:plugins/<id>
+    //   github:org/repo:path/to/<id>
+    //   https://github.com/org/repo[.git]
+    //   local:/abs/path/to/<id>
+    //   /abs/path/to/<id>
+    // Returns the trailing path segment as the plugin id.
+    const cleaned = source
+        .replace(/^github:[^:]+:/, "")
+        .replace(/^https?:\/\/[^/]+\//, "")
+        .replace(/^local:/, "")
+        .replace(/\.git$/, "")
+        .replace(/\/$/, "");
+    const segments = cleaned.split("/").filter(Boolean);
+    const last = segments[segments.length - 1];
+    if (!last) {
+        throw new Error(`Could not derive plugin id from source: ${source}`);
+    }
+    if (!/^[a-z0-9][a-z0-9-]*$/i.test(last)) {
+        throw new Error(`Derived plugin id '${last}' is not a valid name (alphanumeric + dashes only)`);
+    }
+    return last;
+}
+function buildPluginCloneUrl(source) {
+    if (source.startsWith("github:")) {
+        const match = source.match(/^github:([^/]+)\/([^:]+)(?::(.*))?$/);
+        if (!match) {
+            throw new Error(`Invalid github: source: ${source}`);
+        }
+        const [, org, repo] = match;
+        return `https://github.com/${org}/${repo}.git`;
+    }
+    if (source.startsWith("local:")) {
+        return source.replace(/^local:/, "");
+    }
+    return source;
+}
+function buildPluginSubpath(source) {
+    const match = source.match(/^github:[^/]+\/[^:]+:(.+)$/);
+    if (match)
+        return match[1];
+    return null;
+}
+async function executePluginInstall(command, deps) {
+    const { source } = command;
+    const pluginsRoot = getPluginsRootDir();
+    const pluginId = derivePluginIdFromSource(source);
+    const installDir = path.join(pluginsRoot, pluginId);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.plugin_install_start",
+        message: "installing plugin",
+        meta: { source, pluginId, installDir },
+    });
+    if (fs.existsSync(installDir)) {
+        const message = `Plugin '${pluginId}' is already installed at ${installDir}. Run 'ouro plugin remove ${pluginId}' first to reinstall.`;
+        deps.writeStdout(message);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.plugin_install_error",
+            message: "plugin already installed",
+            meta: { source, pluginId, installDir },
+        });
+        return message;
+    }
+    fs.mkdirSync(pluginsRoot, { recursive: true });
+    const cloneUrl = buildPluginCloneUrl(source);
+    const subpath = buildPluginSubpath(source);
+    try {
+        if (subpath) {
+            const tmpClone = path.join(pluginsRoot, `.${pluginId}.clone-${Date.now()}`);
+            (0, child_process_1.execFileSync)("git", ["clone", "--depth", "1", cloneUrl, tmpClone], { stdio: "pipe" });
+            const subpathInClone = path.join(tmpClone, subpath);
+            if (!fs.existsSync(subpathInClone)) {
+                fs.rmSync(tmpClone, { recursive: true, force: true });
+                throw new Error(`Subpath '${subpath}' not found in cloned repo`);
+            }
+            fs.renameSync(subpathInClone, installDir);
+            fs.rmSync(tmpClone, { recursive: true, force: true });
+        }
+        else {
+            (0, child_process_1.execFileSync)("git", ["clone", "--depth", "1", cloneUrl, installDir], { stdio: "pipe" });
+        }
+    }
+    catch (e) {
+        const errMessage = e instanceof Error ? e.message : String(e);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.plugin_install_error",
+            message: "plugin clone failed",
+            meta: { source, pluginId, error: errMessage },
+        });
+        if (fs.existsSync(installDir)) {
+            fs.rmSync(installDir, { recursive: true, force: true });
+        }
+        const message = `Plugin install failed: ${errMessage}`;
+        deps.writeStdout(message);
+        return message;
+    }
+    const pluginJson = path.join(installDir, ".claude-plugin", "plugin.json");
+    if (!fs.existsSync(pluginJson)) {
+        fs.rmSync(installDir, { recursive: true, force: true });
+        const message = `Plugin install failed: .claude-plugin/plugin.json missing in ${installDir}. Rolled back.`;
+        deps.writeStdout(message);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.plugin_install_error",
+            message: "plugin manifest missing",
+            meta: { source, pluginId, expectedManifest: pluginJson },
+        });
+        return message;
+    }
+    // Wire the plugin entry into the agent's agent.json plugins[] when
+    // --agent was passed.
+    let agentEnableMessage = null;
+    if (command.agent) {
+        try {
+            const entry = {
+                id: pluginId,
+                enabled: true,
+                /* v8 ignore next -- command.source is a required field; falsy branch unreachable */
+                ...(command.source ? { source: command.source } : {}),
+                ...(command.version ? { version: command.version } : {}),
+            };
+            const result = addPluginToAgent(command.agent, entry);
+            agentEnableMessage = result.added
+                ? `Enabled plugin '${pluginId}' for agent '${command.agent}' (updated ${result.agentJsonPath}).`
+                : `Plugin '${pluginId}' was already enabled for agent '${command.agent}'.`;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: result.added
+                    ? "daemon.plugin_agent_enable_end"
+                    : "daemon.plugin_agent_enable_noop",
+                message: result.added
+                    ? "plugin enabled for agent"
+                    : "plugin already enabled for agent",
+                meta: { pluginId, agent: command.agent, agentJsonPath: result.agentJsonPath },
+            });
+        }
+        catch (e) {
+            /* v8 ignore start -- defensive: readAgentJsonOrThrow only throws Error */
+            const errMessage = e instanceof Error ? e.message : String(e);
+            /* v8 ignore stop */
+            agentEnableMessage = `Plugin installed on disk, but enabling for agent '${command.agent}' failed: ${errMessage}`;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.plugin_agent_enable_error",
+                message: "agent enable failed; plugin still installed on disk",
+                meta: { pluginId, agent: command.agent, error: errMessage },
+            });
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.plugin_install_end",
+        message: "plugin installed",
+        meta: { source, pluginId, installDir, agent: command.agent },
+    });
+    const baseMessage = `Plugin '${pluginId}' installed at ${installDir}. Run 'ouro up' to activate.`;
+    const message = agentEnableMessage ? `${baseMessage}\n${agentEnableMessage}` : baseMessage;
+    deps.writeStdout(message);
+    return message;
+}
+async function executePluginList(command, deps) {
+    const pluginsRoot = getPluginsRootDir();
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.plugin_list_start",
+        message: "listing plugins",
+        meta: { pluginsRoot, agent: command.agent },
+    });
+    if (!fs.existsSync(pluginsRoot)) {
+        const message = "No plugins installed.";
+        deps.writeStdout(message);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.plugin_list_end",
+            message: "no plugins root",
+            meta: { count: 0 },
+        });
+        return message;
+    }
+    let entries = fs
+        .readdirSync(pluginsRoot)
+        .filter((name) => {
+        try {
+            return (fs.statSync(path.join(pluginsRoot, name)).isDirectory() &&
+                !name.startsWith("."));
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+    // With --agent X, filter to plugins enabled for X (intersect installed-on-disk
+    // with X's agent.json plugins[]). Without --agent, list all installed.
+    if (command.agent) {
+        const agentPlugins = readAgentPluginsList(command.agent);
+        const enabledIds = new Set(agentPlugins.filter((p) => p.enabled).map((p) => p.id));
+        entries = entries.filter((id) => enabledIds.has(id));
+        if (entries.length === 0) {
+            const message = `No plugins enabled for agent '${command.agent}'.`;
+            deps.writeStdout(message);
+            return message;
+        }
+        const message = `Plugins enabled for agent '${command.agent}' (${entries.length}):\n` +
+            entries.map((id) => `  - ${id}`).join("\n");
+        deps.writeStdout(message);
+        return message;
+    }
+    if (entries.length === 0) {
+        const message = "No plugins installed.";
+        deps.writeStdout(message);
+        return message;
+    }
+    const message = `Installed plugins (${entries.length}):\n` +
+        entries.map((id) => `  - ${id}`).join("\n");
+    deps.writeStdout(message);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.plugin_list_end",
+        message: "listed plugins",
+        meta: { count: entries.length },
+    });
+    return message;
+}
+async function executePluginRemove(command, deps) {
+    const { pluginId, agent } = command;
+    const installDir = path.join(getPluginsRootDir(), pluginId);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.plugin_remove_start",
+        message: "removing plugin",
+        meta: { pluginId, installDir, agent },
+    });
+    // With --agent X: scoped to that agent's plugins[] only; never touches disk.
+    if (agent) {
+        try {
+            const { removed, agentJsonPath } = removePluginFromAgent(agent, pluginId);
+            const message = removed
+                ? `Plugin '${pluginId}' disabled for agent '${agent}' (updated ${agentJsonPath}). Run 'ouro up' to apply.`
+                : `Plugin '${pluginId}' was not enabled for agent '${agent}'.`;
+            deps.writeStdout(message);
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.plugin_remove_end",
+                message: removed ? "plugin disabled for agent" : "plugin was not enabled for agent",
+                meta: { pluginId, agent, agentJsonPath, removed },
+            });
+            return message;
+        }
+        catch (e) {
+            /* v8 ignore start -- defensive: removePluginFromAgent only throws Error */
+            const errMessage = e instanceof Error ? e.message : String(e);
+            /* v8 ignore stop */
+            const message = `Plugin remove failed for agent '${agent}': ${errMessage}`;
+            deps.writeStdout(message);
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.plugin_remove_error",
+                message: "agent remove failed",
+                meta: { pluginId, agent, error: errMessage },
+            });
+            return message;
+        }
+    }
+    // Without --agent: machine-wide remove. Refuse if any agent's plugins[]
+    // still references this plugin (silent removal would break those agents
+    // on next `ouro up`).
+    const refs = listAgentsReferencingPlugin(pluginId);
+    if (refs.length > 0) {
+        const message = `Cannot remove plugin '${pluginId}': still enabled for: ${refs.join(", ")}.\n` +
+            `Disable per-agent first with 'ouro plugin remove ${pluginId} --agent <name>', then re-run.`;
+        deps.writeStdout(message);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.plugin_remove_error",
+            message: "plugin still referenced by agents",
+            meta: { pluginId, refs },
+        });
+        return message;
+    }
+    if (!fs.existsSync(installDir)) {
+        const message = `Plugin '${pluginId}' is not installed at ${installDir}.`;
+        deps.writeStdout(message);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.plugin_remove_error",
+            message: "plugin not installed",
+            meta: { pluginId, installDir },
+        });
+        return message;
+    }
+    fs.rmSync(installDir, { recursive: true, force: true });
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.plugin_remove_end",
+        message: "plugin removed",
+        meta: { pluginId, installDir },
+    });
+    const message = `Plugin '${pluginId}' removed from ${installDir}. Run 'ouro up' to deactivate.`;
+    deps.writeStdout(message);
+    return message;
+}