@ouro.bot/cli 0.1.0-alpha.517 → 0.1.0-alpha.519

package/dist/heart/sync.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preTurnPull = preTurnPull;
 exports.postTurnPush = postTurnPush;
+exports.preTurnPullAsync = preTurnPullAsync;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -330,3 +331,119 @@ function postTurnPush(agentRoot, config) {
         return { ok: false, error };
     }
 }
+/**
+ * Layer 2 — async, signal-aware sibling of `preTurnPull`.
+ *
+ * Used by `runBootSyncProbe` (the `ouro up` boot orchestrator) to perform
+ * the pre-flight pull with end-to-end `AbortSignal` propagation. The
+ * underlying `child_process.execFile` accepts the signal and kills the git
+ * child process when it aborts, so a hung remote (DNS hole, slow server)
+ * can be cut by the boot timeout wrapper rather than hanging the whole
+ * boot.
+ *
+ * The legacy sync `preTurnPull` is preserved unchanged for the per-turn
+ * pipeline at `src/senses/pipeline.ts:522`. The two functions share the
+ * same `.git` and remote-availability gates — the only difference is the
+ * pull itself: `execFileSync` (no signal) vs `execFile` + `{ signal }`.
+ *
+ * Honour-the-signal contract:
+ *   - If `options.signal` is already aborted at call time, the pull is
+ *     skipped and the result is `{ ok: false, error: "aborted" }`.
+ *   - If `options.signal` aborts mid-fetch, the child receives `SIGTERM`
+ *     via Node's built-in AbortSignal handling, and the result is
+ *     `{ ok: false, error: <abort message> }`.
+ *   - With no signal supplied, behaviour matches the sync version (subject
+ *     to the small differences listed above — same git-repo / no-remote
+ *     gates and same nerves events).
+ */
+function preTurnPullAsync(agentRoot, config, options = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.sync_pull_start",
+        message: "pre-turn pull starting (async)",
+        meta: { agentRoot, remote: config.remote },
+    });
+    // Bail early when the caller has already aborted — saves a git invocation
+    // and signals failure consistently.
+    if (options.signal?.aborted) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.sync_pull_aborted",
+            message: "pre-turn pull skipped: signal already aborted",
+            meta: { agentRoot },
+        });
+        return Promise.resolve({ ok: false, error: "aborted before pull started" });
+    }
+    // Same .git presence check as the sync version.
+    const repoCheck = ensureGitRepo(agentRoot);
+    if (!repoCheck.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.sync_not_a_repo",
+            message: "pre-turn pull failed: bundle is not a git repo (async)",
+            meta: { agentRoot },
+        });
+        return Promise.resolve(repoCheck);
+    }
+    // Remote-presence check stays sync — it's a fast local op and doesn't
+    // need cancellation. The hangable op is the actual pull.
+    try {
+        const remoteOutput = (0, child_process_1.execFileSync)("git", ["remote"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 5000,
+        }).toString().trim();
+        if (remoteOutput.length === 0) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "heart",
+                event: "heart.sync_pull_end",
+                message: "pre-turn pull skipped: no remote configured (async)",
+                meta: { agentRoot },
+            });
+            return Promise.resolve({ ok: true });
+        }
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_pull_error",
+            message: "pre-turn pull failed: git remote check failed (async)",
+            meta: { agentRoot, error },
+        });
+        return Promise.resolve({ ok: false, error });
+    }
+    // The hangable op. `execFile` accepts `{ signal }` and kills the child
+    // when the signal aborts — that's the whole point of the async path.
+    const execOptions = {
+        cwd: agentRoot,
+        timeout: 30000,
+    };
+    if (options.signal) {
+        execOptions.signal = options.signal;
+    }
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)("git", ["pull", config.remote], execOptions, (err) => {
+            if (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "heart",
+                    event: "heart.sync_pull_error",
+                    message: "pre-turn pull failed (async)",
+                    meta: { agentRoot, error },
+                });
+                resolve({ ok: false, error });
+                return;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "heart",
+                event: "heart.sync_pull_end",
+                message: "pre-turn pull complete (async)",
+                meta: { agentRoot },
+            });
+            resolve({ ok: true });
+        });
+    });
+}

package/dist/heart/timeouts.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Soft/hard timeout pattern for boot-path operations — Layer 2.
+ *
+ * Soft timeout = "log a warning, keep going". The op continues; the consumer
+ * records the warning and moves on.
+ * Hard timeout = "abort the op via AbortSignal". The underlying op is
+ * expected to honour the signal (Node child_process accepts `{ signal }`,
+ * fetch accepts `{ signal }`, etc.). When the signal aborts, the op should
+ * reject with an AbortError, and the wrapper returns
+ * `{ classification: "timeout-hard" }` rather than re-throwing.
+ *
+Two optional env overrides (currently only `GIT` is consumed):
+ *   - `OURO_BOOT_TIMEOUT_GIT_SOFT` / `OURO_BOOT_TIMEOUT_GIT_HARD` — boot
+ *     git operations (fetch / pull). Used when `envKey === "GIT"`.
+ *
+ * Env values are parsed as integer milliseconds. Non-numeric or non-positive
+ * values are ignored (the explicit `softMs` / `hardMs` defaults from the
+ * caller win in that case).
+ *
+ * Pattern guarantee: timers cleared on resolve / reject so the function
+ * holds no refs after settlement. Important because `ouro up` chains
+ * many of these and a leaking timer would block process exit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithTimeouts = runWithTimeouts;
+function readEnvMs(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === null)
+        return null;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return null;
+    return parsed;
+}
+function resolveTimeouts(options) {
+    let softMs = options.softMs;
+    let hardMs = options.hardMs;
+    if (options.envKey === "GIT") {
+        const envSoft = readEnvMs("OURO_BOOT_TIMEOUT_GIT_SOFT");
+        if (envSoft !== null)
+            softMs = envSoft;
+        const envHard = readEnvMs("OURO_BOOT_TIMEOUT_GIT_HARD");
+        if (envHard !== null)
+            hardMs = envHard;
+    }
+    return { softMs, hardMs };
+}
+/**
+ * Run `fn` with soft and hard timeouts.
+ *
+ * - Returns `{ result }` on success.
+ * - Returns `{ classification: "timeout-hard", warnings }` when aborted.
+ * - Returns `{ result, warnings: [...] }` when soft tripped but op completed.
+ * - Rejects when `fn` throws a non-abort error (callers can wrap with
+ *   classifier).
+ */
+async function runWithTimeouts(fn, options) {
+    const { softMs, hardMs } = resolveTimeouts(options);
+    const controller = new AbortController();
+    const warnings = [];
+    let softTimer = setTimeout(() => {
+        softTimer = null;
+        warnings.push(`${options.label}: soft timeout exceeded (${softMs}ms) — warning, continuing until hard cut`);
+    }, softMs);
+    let hardTimer = setTimeout(() => {
+        hardTimer = null;
+        controller.abort();
+    }, hardMs);
+    const cleanup = () => {
+        if (softTimer !== null) {
+            clearTimeout(softTimer);
+            softTimer = null;
+        }
+        if (hardTimer !== null) {
+            clearTimeout(hardTimer);
+            hardTimer = null;
+        }
+    };
+    try {
+        const result = await fn(controller.signal);
+        cleanup();
+        // If the abort fired and the op resolved gracefully (e.g., the inner
+        // function caught the AbortError and returned a structured result), we
+        // still classify the outcome as timeout-hard — the op was aborted from
+        // the caller's perspective even if no exception propagated. The caller
+        // can ignore the classification and use `result` if both are present.
+        if (controller.signal.aborted) {
+            return { classification: "timeout-hard", warnings };
+        }
+        return { result, warnings };
+    }
+    catch (err) {
+        cleanup();
+        if (controller.signal.aborted) {
+            // Hard timeout fired — abort wins over whatever error the op threw.
+            return { classification: "timeout-hard", warnings };
+        }
+        throw err;
+    }
+}

package/dist/nerves/coverage/file-completeness.js

@@ -149,6 +149,15 @@ const DISPATCH_EXEMPT_PATTERNS = [
     // Diagnostics-only utility; output is human-readable summary.
     "heart/session-stats-cli-main",
     "heart/session-stats",
+    // Layer 2 sync classifier: pure pattern-matcher mapping (error, context)
+    // to a SyncClassification. The orchestrator (boot-sync-probe.ts) owns
+    // observability via daemon.boot_sync_probe_start/end events; the
+    // post-turn push path (sync.ts) emits its own classification events.
+    "heart/sync-classification",
+    // Layer 2 timeout wrapper: pure soft/hard timeout abstraction over
+    // AbortController + setTimeout. Callers (boot-sync-probe.ts and any
+    // future consumer) own observability; the wrapper itself is mechanical.
+    "heart/timeouts",
 ];
 function isDispatchExempt(filePath) {
     return DISPATCH_EXEMPT_PATTERNS.some((pattern) => filePath.includes(pattern));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.517",
+  "version": "0.1.0-alpha.519",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",