@ouro.bot/cli 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/heart/daemon/ouro-bot-global-installer.js

@@ -0,0 +1,128 @@
+"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.syncGlobalOuroBotWrapper = syncGlobalOuroBotWrapper;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const runtime_metadata_1 = require("./runtime-metadata");
+function normalizeOutput(output) {
+    return (typeof output === "string" ? output : output.toString("utf-8")).trim();
+}
+function resolveGlobalPrefix(execFileSyncImpl) {
+    return normalizeOutput(execFileSyncImpl("npm", ["prefix", "-g"], { encoding: "utf-8" }));
+}
+function resolveGlobalRoot(execFileSyncImpl) {
+    return normalizeOutput(execFileSyncImpl("npm", ["root", "-g"], { encoding: "utf-8" }));
+}
+function readInstalledWrapperVersion(globalRoot, existsSyncImpl, readFileSyncImpl) {
+    const packageJsonPath = path.join(globalRoot, "ouro.bot", "package.json");
+    if (!existsSyncImpl(packageJsonPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSyncImpl(packageJsonPath, "utf-8"));
+        return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveExecutableOwner(globalPrefix, platform, existsSyncImpl, realpathSyncImpl) {
+    const binName = platform === "win32" ? "ouro.bot.cmd" : "ouro.bot";
+    const binPath = platform === "win32"
+        ? path.join(globalPrefix, binName)
+        : path.join(globalPrefix, "bin", binName);
+    if (!existsSyncImpl(binPath))
+        return null;
+    try {
+        const resolved = realpathSyncImpl(binPath);
+        if (resolved.includes(`${path.sep}node_modules${path.sep}ouro.bot${path.sep}`))
+            return "wrapper";
+        if (resolved.includes(`${path.sep}node_modules${path.sep}@ouro.bot${path.sep}cli${path.sep}`))
+            return "cli";
+        return "other";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function syncGlobalOuroBotWrapper(deps = {}) {
+    /* v8 ignore start -- dependency-injection defaults are only exercised in the live runtime */
+    const execFileSyncImpl = deps.execFileSync ?? child_process_1.execFileSync;
+    const existsSyncImpl = deps.existsSync ?? fs.existsSync;
+    const readFileSyncImpl = deps.readFileSync ?? fs.readFileSync;
+    const realpathSyncImpl = deps.realpathSync ?? fs.realpathSync;
+    const runtimeVersion = deps.runtimeVersion ?? (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const platform = deps.platform ?? process.platform;
+    /* v8 ignore stop */
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_global_sync_start",
+        message: "checking global ouro.bot wrapper",
+        meta: { version: runtimeVersion },
+    });
+    const globalPrefix = resolveGlobalPrefix(execFileSyncImpl);
+    const globalRoot = resolveGlobalRoot(execFileSyncImpl);
+    const installedVersion = readInstalledWrapperVersion(globalRoot, existsSyncImpl, readFileSyncImpl);
+    const executableOwner = resolveExecutableOwner(globalPrefix, platform, existsSyncImpl, realpathSyncImpl);
+    if (executableOwner === "wrapper") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_bot_global_sync_end",
+            message: "global ouro.bot wrapper already current",
+            meta: { version: runtimeVersion, installedVersion, executableOwner, installed: false },
+        });
+        return {
+            installed: false,
+            version: runtimeVersion,
+            installedVersion,
+            executableOwner,
+        };
+    }
+    execFileSyncImpl("npm", ["install", "-g", "--force", "ouro.bot@latest"], { stdio: "pipe", encoding: "utf-8" });
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_global_sync_end",
+        message: "global ouro.bot wrapper synced",
+        meta: { version: runtimeVersion, installedVersion, executableOwner, installed: true },
+    });
+    return {
+        installed: true,
+        version: runtimeVersion,
+        installedVersion,
+        executableOwner,
+    };
+}

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

@@ -37,8 +37,9 @@ exports.runOuroBotWrapper = runOuroBotWrapper;
 const runtime_1 = require("../../nerves/runtime");
 const daemon_cli_1 = require("./daemon-cli");
 async function defaultLoadCanonicalRunner() {
-    const packageName = "@ouro.bot/cli";
-    const specifier = packageName;
+    // Use the subpath export so we get the daemon-cli module directly,
+    // NOT the root entry point which has side-effects (immediately runs the CLI).
+    const specifier = "@ouro.bot/cli/runOuroCli";
     const loaded = await Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
     const candidate = Object.prototype.hasOwnProperty.call(loaded, "runOuroCli")
         ? loaded["runOuroCli"]
@@ -46,7 +47,7 @@ async function defaultLoadCanonicalRunner() {
     if (typeof candidate === "function") {
         return candidate;
     }
-    throw new Error("@ouro.bot/cli does not export runOuroCli");
+    throw new Error("@ouro.bot/cli/runOuroCli does not export runOuroCli");
 }
 function defaultWriteStdout(_text) {
     // Wrapper is intentionally silent by default to avoid duplicate terminal output.

package/dist/heart/daemon/ouro-path-installer.js

@@ -0,0 +1,178 @@
+"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.installOuroCommand = installOuroCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const CLI_PACKAGE_SPECIFIER = "@ouro.bot/cli@alpha";
+const WRAPPER_SCRIPT = `#!/bin/sh
+exec npx --yes ${CLI_PACKAGE_SPECIFIER} "$@"
+`;
+function detectShellProfile(homeDir, shell) {
+    if (!shell)
+        return null;
+    const base = path.basename(shell);
+    if (base === "zsh")
+        return path.join(homeDir, ".zshrc");
+    if (base === "bash") {
+        // macOS uses .bash_profile, Linux uses .bashrc
+        const profilePath = path.join(homeDir, ".bash_profile");
+        return profilePath;
+    }
+    if (base === "fish")
+        return path.join(homeDir, ".config", "fish", "config.fish");
+    return null;
+}
+function isBinDirInPath(binDir, envPath) {
+    return envPath.split(path.delimiter).some((p) => p === binDir);
+}
+function buildPathExportLine(binDir, shell) {
+    const base = shell ? path.basename(shell) : /* v8 ignore next -- unreachable: only called when detectShellProfile returns non-null, which requires shell @preserve */ "";
+    if (base === "fish") {
+        return `\n# Added by ouro\nset -gx PATH ${binDir} $PATH\n`;
+    }
+    return `\n# Added by ouro\nexport PATH="${binDir}:$PATH"\n`;
+}
+function installOuroCommand(deps = {}) {
+    /* v8 ignore start -- dep defaults: only used in real runtime, tests always inject @preserve */
+    const platform = deps.platform ?? process.platform;
+    const homeDir = deps.homeDir ?? os.homedir();
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const readFileSync = deps.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    const appendFileSync = deps.appendFileSync ?? fs.appendFileSync;
+    const chmodSync = deps.chmodSync ?? fs.chmodSync;
+    const envPath = deps.envPath ?? process.env.PATH ?? "";
+    const shell = deps.shell ?? process.env.SHELL;
+    /* v8 ignore stop */
+    if (platform === "win32") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "skipped ouro PATH install on Windows",
+            meta: { platform },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows" };
+    }
+    const binDir = path.join(homeDir, ".local", "bin");
+    const scriptPath = path.join(binDir, "ouro");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_start",
+        message: "installing ouro command to PATH",
+        meta: { scriptPath, binDir },
+    });
+    // If ouro already exists, check content and repair if stale
+    if (existsSync(scriptPath)) {
+        let existingContent = "";
+        try {
+            existingContent = readFileSync(scriptPath, "utf-8");
+        }
+        catch {
+            // Can't read — treat as stale, will overwrite below
+        }
+        if (existingContent === WRAPPER_SCRIPT) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.ouro_path_install_skip",
+                message: "ouro command already installed",
+                meta: { scriptPath },
+            });
+            return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed" };
+        }
+        // Content is stale — repair by overwriting
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_repair",
+            message: "repairing stale ouro wrapper script",
+            meta: { scriptPath },
+        });
+    }
+    try {
+        mkdirSync(binDir, { recursive: true });
+        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+        chmodSync(scriptPath, 0o755);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_path_install_error",
+            message: "failed to install ouro command",
+            meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error) };
+    }
+    // Check if ~/.local/bin is already in PATH
+    let shellProfileUpdated = null;
+    const pathReady = isBinDirInPath(binDir, envPath);
+    if (!pathReady) {
+        const profilePath = detectShellProfile(homeDir, shell);
+        if (profilePath) {
+            try {
+                let existing = "";
+                try {
+                    existing = readFileSync(profilePath, "utf-8");
+                }
+                catch {
+                    // Profile doesn't exist yet — that's fine, we'll create it
+                }
+                if (!existing.includes(binDir)) {
+                    appendFileSync(profilePath, buildPathExportLine(binDir, shell));
+                    shellProfileUpdated = profilePath;
+                }
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.ouro_path_profile_error",
+                    message: "failed to update shell profile for PATH",
+                    meta: { profilePath, error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_end",
+        message: "ouro command installed",
+        meta: { scriptPath, pathReady, shellProfileUpdated },
+    });
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated };
+}

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

@@ -42,7 +42,13 @@ const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const LSREGISTER_PATH = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
 const ICON_SIZES = [16, 32, 128, 256, 512];
-function resolveIconSourcePath(repoRoot) {
+function resolveIconSourcePath(repoRoot, existsSync) {
+    // Prefer bundled asset (shipped with npm package)
+    const bundledPath = path.resolve(repoRoot, "assets", "ouroboros.png");
+    if (existsSync(bundledPath)) {
+        return bundledPath;
+    }
+    // Fall back to adjacent repo path (dev environment)
     return path.resolve(repoRoot, "..", "ouroboros-website", "public", "images", "ouroboros.png");
 }
 function buildIconAsset(iconSourcePath, icnsPath, iconsetDir, deps) {
@@ -91,6 +97,7 @@ function buildInfoPlist(iconInstalled) {
         "      <key>UTTypeConformsTo</key>",
         "      <array>",
         "        <string>public.folder</string>",
+        "        <string>com.apple.package</string>",
         "      </array>",
         "      <key>UTTypeTagSpecification</key>",
         "      <dict>",
@@ -112,6 +119,8 @@ function buildInfoPlist(iconInstalled) {
         "      </array>",
         "      <key>CFBundleTypeRole</key>",
         "      <string>Editor</string>",
+        "      <key>LSTypeIsPackage</key>",
+        "      <true/>",
         `      ${iconTag.trim()}`,
         "    </dict>",
         "  </array>",
@@ -152,7 +161,7 @@ function registerOuroBundleUti(deps = {}) {
     const plistPath = path.join(contentsDir, "Info.plist");
     const icnsPath = path.join(resourcesDir, "ouro.icns");
     const iconsetDir = path.join(supportRoot, "ouro.iconset");
-    const iconSourcePath = resolveIconSourcePath(repoRoot);
+    const iconSourcePath = resolveIconSourcePath(repoRoot, existsSync);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.ouro_uti_register_start",

package/dist/heart/daemon/process-manager.js

@@ -96,7 +96,7 @@ class DaemonProcessManager {
         state.snapshot.status = "starting";
         const runCwd = (0, identity_1.getRepoRoot)();
         const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
-        const args = [entryScript, "--agent", agent, ...(state.config.args ?? [])];
+        const args = [entryScript, "--agent", state.config.agentArg ?? agent, ...(state.config.args ?? [])];
         const child = this.spawnFn("node", args, {
             cwd: runCwd,
             env: state.config.env ? { ...process.env, ...state.config.env } : process.env,

package/dist/heart/daemon/run-hooks.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHooks = runHooks;
+const runtime_1 = require("../../nerves/runtime");
+const bundle_meta_1 = require("./hooks/bundle-meta");
+async function runHooks(deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.run_hooks_start",
+        message: "running update hooks",
+        meta: { bundlesRoot: deps.bundlesRoot },
+    });
+    try {
+        deps.registerUpdateHook(bundle_meta_1.bundleMetaHook);
+        const currentVersion = deps.getPackageVersion();
+        await deps.applyPendingUpdates(deps.bundlesRoot, currentVersion);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.run_hooks_success",
+            message: "update hooks completed successfully",
+            meta: { bundlesRoot: deps.bundlesRoot },
+        });
+        return 0;
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.run_hooks_error",
+            message: "update hooks failed",
+            meta: {
+                bundlesRoot: deps.bundlesRoot,
+                error: err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err),
+            },
+        });
+        return 1;
+    }
+}

package/dist/heart/daemon/runtime-logging.js

@@ -43,23 +43,27 @@ const DEFAULT_RUNTIME_LOGGING = {
     level: "info",
     sinks: ["terminal", "ndjson"],
 };
+function defaultLevelForProcess(processName) {
+    return processName === "daemon" ? "info" : "warn";
+}
 function isLogLevel(value) {
     return value === "debug" || value === "info" || value === "warn" || value === "error";
 }
-function resolveRuntimeLoggingConfig(configPath) {
+function resolveRuntimeLoggingConfig(configPath, processName) {
+    const defaultLevel = defaultLevelForProcess(processName);
     let parsed = null;
     try {
         const raw = fs.readFileSync(configPath, "utf-8");
         parsed = JSON.parse(raw);
     }
     catch {
-        return { ...DEFAULT_RUNTIME_LOGGING };
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
     }
     if (!parsed || typeof parsed !== "object") {
-        return { ...DEFAULT_RUNTIME_LOGGING };
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
     }
     const candidate = parsed;
-    const level = isLogLevel(candidate.level) ? candidate.level : DEFAULT_RUNTIME_LOGGING.level;
+    const level = isLogLevel(candidate.level) ? candidate.level : defaultLevel;
     const sinks = Array.isArray(candidate.sinks)
         ? candidate.sinks.filter((entry) => entry === "terminal" || entry === "ndjson")
         : DEFAULT_RUNTIME_LOGGING.sinks;
@@ -71,7 +75,7 @@ function resolveRuntimeLoggingConfig(configPath) {
 function configureDaemonRuntimeLogger(processName, options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
     const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
-    const config = resolveRuntimeLoggingConfig(configPath);
+    const config = resolveRuntimeLoggingConfig(configPath, processName);
     const sinks = config.sinks.map((sinkName) => {
         if (sinkName === "terminal") {
             return (0, nerves_1.createTerminalSink)();

package/dist/heart/daemon/runtime-metadata.js

@@ -0,0 +1,118 @@
+"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.getRuntimeMetadata = getRuntimeMetadata;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const childProcess = __importStar(require("child_process"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const UNKNOWN_METADATA = "unknown";
+function optionalFunction(target, key) {
+    try {
+        const candidate = target[key];
+        return typeof candidate === "function" ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readVersion(packageJsonPath, readFileSyncImpl) {
+    try {
+        const parsed = JSON.parse(readFileSyncImpl(packageJsonPath, "utf-8"));
+        return typeof parsed.version === "string" && parsed.version.trim().length > 0
+            ? parsed.version.trim()
+            : UNKNOWN_METADATA;
+    }
+    catch {
+        return UNKNOWN_METADATA;
+    }
+}
+function readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncImpl) {
+    try {
+        const raw = execFileSyncImpl("git", ["log", "-1", "--format=%cI"], {
+            cwd: repoRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (raw.length > 0) {
+            return { value: raw, source: "git" };
+        }
+    }
+    catch {
+        // fall through to mtime fallback
+    }
+    try {
+        const stats = statSyncImpl(packageJsonPath);
+        return {
+            value: stats.mtime.toISOString(),
+            source: "package-json-mtime",
+        };
+    }
+    catch {
+        return { value: UNKNOWN_METADATA, source: "unknown" };
+    }
+}
+function getRuntimeMetadata(deps = {}) {
+    const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const readFileSyncImpl = deps.readFileSync ?? optionalFunction(fs, "readFileSync")?.bind(fs) ?? null;
+    const statSyncImpl = deps.statSync ?? optionalFunction(fs, "statSync")?.bind(fs) ?? null;
+    const execFileSyncImpl = deps.execFileSync
+        ?? optionalFunction(childProcess, "execFileSync")?.bind(childProcess)
+        ?? null;
+    const packageJsonPath = path.join(repoRoot, "package.json");
+    const version = readFileSyncImpl
+        ? readVersion(packageJsonPath, readFileSyncImpl)
+        : UNKNOWN_METADATA;
+    const lastUpdated = statSyncImpl
+        ? readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncImpl ?? (() => {
+            throw new Error("git unavailable");
+        }))
+        : { value: UNKNOWN_METADATA, source: "unknown" };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_metadata_read",
+        message: "read runtime metadata",
+        meta: {
+            version,
+            lastUpdated: lastUpdated.value,
+            lastUpdatedSource: lastUpdated.source,
+        },
+    });
+    return {
+        version,
+        lastUpdated: lastUpdated.value,
+    };
+}