@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.700

package/dist/heart/private-runtime/ledger.js

@@ -0,0 +1,218 @@
+"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.privateTurnLedgerPath = privateTurnLedgerPath;
+exports.readPrivateTurnLedger = readPrivateTurnLedger;
+exports.recordPrivateTurnDecision = recordPrivateTurnDecision;
+const fs = __importStar(require("node:fs"));
+const crypto = __importStar(require("node:crypto"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_LEDGER_DIR = "private-runtime";
+const DEFAULT_LEDGER_FILE = "decisions.jsonl";
+function emitDecisionRecorded(deps, input) {
+    const payload = {
+        level: input.level,
+        component: "private-runtime",
+        event: "private_runtime.decision_recorded",
+        message: "private-runtime decision recorded",
+        meta: {
+            agent: input.decision.agent,
+            origin: input.decision.origin,
+            result: input.decision.result,
+            idempotencyKey: input.decision.idempotencyKey,
+            requestFingerprint: input.decision.requestFingerprint,
+        },
+    };
+    if (deps?.emitNervesEvent) {
+        deps.emitNervesEvent(payload);
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: input.level,
+        component: "private-runtime",
+        event: "private_runtime.decision_recorded",
+        message: "private-runtime decision recorded",
+        meta: payload.meta,
+    });
+}
+function emitDecisionRecordFailed(deps, input) {
+    const payload = {
+        level: "error",
+        component: "private-runtime",
+        event: "private_runtime.decision_record_failed",
+        message: "private-runtime decision ledger write failed",
+        meta: {
+            agent: input.decision.agent,
+            origin: input.decision.origin,
+            idempotencyKey: input.decision.idempotencyKey,
+            requestFingerprint: input.decision.requestFingerprint,
+            error: input.decision.error,
+        },
+    };
+    if (deps?.emitNervesEvent) {
+        deps.emitNervesEvent(payload);
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "private-runtime",
+        event: "private_runtime.decision_record_failed",
+        message: "private-runtime decision ledger write failed",
+        meta: payload.meta,
+    });
+}
+function privateTurnLedgerPath(agent, deps = {}) {
+    if (deps.ledgerPath)
+        return deps.ledgerPath;
+    return path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${agent}.ouro`, "state", DEFAULT_LEDGER_DIR, DEFAULT_LEDGER_FILE);
+}
+function readRows(ledgerPath) {
+    if (!fs.existsSync(ledgerPath))
+        return [];
+    const raw = fs.readFileSync(ledgerPath, "utf-8").trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+function writeRow(ledgerPath, row) {
+    const rowWithLocator = {
+        ...row,
+        ledgerLocator: {
+            path: ledgerPath,
+            line: readRows(ledgerPath).length + 1,
+        },
+    };
+    fs.appendFileSync(ledgerPath, `${JSON.stringify(rowWithLocator)}\n`, "utf-8");
+    return rowWithLocator;
+}
+function receiptIdFor(input) {
+    const hash = crypto
+        .createHash("sha256")
+        .update(`${input.idempotencyKey}\n${input.requestFingerprint}\n${input.result}`)
+        .digest("hex");
+    return `ptrr_${hash}`;
+}
+function mismatchDecision(candidate, existing) {
+    return {
+        ...candidate,
+        receiptId: receiptIdFor({
+            idempotencyKey: candidate.idempotencyKey,
+            requestFingerprint: candidate.requestFingerprint,
+            result: "mismatch",
+        }),
+        result: "deny",
+        executable: false,
+        deniedReason: "idempotency-key fingerprint mismatch",
+        duplicateOf: existing.receiptId,
+    };
+}
+function duplicateDecision(existing) {
+    return {
+        ...existing,
+        executable: false,
+        deniedReason: "duplicate private-turn decision already recorded",
+        duplicateOf: existing.receiptId,
+    };
+}
+function ledgerWriteFailedDecision(candidate, ledgerPath, error) {
+    return {
+        ...candidate,
+        receiptId: receiptIdFor({
+            idempotencyKey: candidate.idempotencyKey,
+            requestFingerprint: candidate.requestFingerprint,
+            result: "ledger-write-failed",
+        }),
+        result: "deny",
+        executable: false,
+        deniedReason: "ledger write failed",
+        ledgerLocator: { path: ledgerPath },
+        error: String(error),
+    };
+}
+function readPrivateTurnLedger(ledgerPath) {
+    return readRows(ledgerPath);
+}
+function recordPrivateTurnDecision(decision, deps = {}) {
+    const ledgerPath = privateTurnLedgerPath(decision.agent, deps);
+    if (!deps.ledgerPath) {
+        fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+    }
+    const candidate = {
+        ...decision,
+        receiptId: decision.receiptId || receiptIdFor(decision),
+        ledgerLocator: { path: ledgerPath },
+    };
+    try {
+        const matchingRows = readRows(ledgerPath).filter((row) => row.idempotencyKey === candidate.idempotencyKey);
+        const anchor = matchingRows[0];
+        if (anchor) {
+            if (anchor.requestFingerprint !== candidate.requestFingerprint) {
+                const mismatch = mismatchDecision(candidate, anchor);
+                const writtenMismatch = writeRow(ledgerPath, mismatch);
+                emitDecisionRecorded(deps, { level: "warn", decision: writtenMismatch });
+                return writtenMismatch;
+            }
+            const priorExecutable = matchingRows.find((row) => row.requestFingerprint === candidate.requestFingerprint && row.executable);
+            if (priorExecutable && candidate.executable) {
+                return duplicateDecision(priorExecutable);
+            }
+            const latestSameFingerprint = [...matchingRows].reverse().find((row) => row.requestFingerprint === candidate.requestFingerprint);
+            if (latestSameFingerprint
+                && latestSameFingerprint.result === candidate.result
+                && latestSameFingerprint.executable === candidate.executable
+                && latestSameFingerprint.deniedReason === candidate.deniedReason) {
+                return latestSameFingerprint;
+            }
+            if (priorExecutable && !candidate.executable) {
+                const written = writeRow(ledgerPath, candidate);
+                emitDecisionRecorded(deps, { level: "warn", decision: written });
+                return written;
+            }
+            const written = writeRow(ledgerPath, candidate);
+            emitDecisionRecorded(deps, { level: written.result === "allow" ? "info" : "warn", decision: written });
+            return written;
+        }
+        const written = writeRow(ledgerPath, candidate);
+        emitDecisionRecorded(deps, { level: written.result === "allow" ? "info" : "warn", decision: written });
+        return written;
+    }
+    catch (error) {
+        const failed = ledgerWriteFailedDecision(candidate, ledgerPath, error);
+        emitDecisionRecordFailed(deps, { decision: failed });
+        return failed;
+    }
+}

package/dist/heart/private-runtime/policy.js

@@ -0,0 +1,214 @@
+"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.createPrivateTurnRequestFingerprint = createPrivateTurnRequestFingerprint;
+exports.createPrivateTurnIdempotencyKey = createPrivateTurnIdempotencyKey;
+exports.requestPrivateTurnDecision = requestPrivateTurnDecision;
+const crypto = __importStar(require("node:crypto"));
+const identity_1 = require("../identity");
+const auth_flow_1 = require("../auth/auth-flow");
+const runtime_1 = require("../../nerves/runtime");
+const provider_credentials_1 = require("../provider-credentials");
+const ledger_1 = require("./ledger");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function normalizeOriginRefs(refs) {
+    return [...refs].sort((a, b) => stableJson(a).localeCompare(stableJson(b)));
+}
+function providerLaneSpendIdentity(providerLane) {
+    return {
+        lane: providerLane.lane,
+        provider: providerLane.provider,
+        model: providerLane.model,
+        source: providerLane.source,
+        ...(providerLane.credentialRevision ? { credentialRevision: providerLane.credentialRevision } : {}),
+    };
+}
+function spendIdentity(request, options) {
+    return {
+        agent: request.agent,
+        origin: request.origin,
+        reason: request.reason,
+        providerLane: options.providerLane ? providerLaneSpendIdentity(options.providerLane) : request.providerLane,
+        triggerSource: request.triggerSource,
+        ...(options.includeIdempotencyKey ? { idempotencyKey: request.idempotencyKey ?? "" } : {}),
+        budgetClass: request.budgetClass,
+        originRefs: normalizeOriginRefs(request.originRefs ?? []),
+    };
+}
+function sha256Prefix(prefix, value) {
+    const hash = crypto.createHash("sha256").update(stableJson(value)).digest("hex");
+    return `${prefix}_${hash}`;
+}
+function nowIso(deps) {
+    const raw = deps.now?.() ?? new Date();
+    return raw instanceof Date ? raw.toISOString() : raw;
+}
+function emitPolicyEvaluated(deps, input) {
+    const payload = {
+        level: input.result === "allow" ? "info" : "debug",
+        component: "private-runtime",
+        event: "private_runtime.policy_evaluated",
+        message: "private-runtime policy evaluated",
+        meta: {
+            agent: input.request.agent,
+            origin: input.request.origin,
+            result: input.result,
+            idempotencyKey: input.idempotencyKey,
+            requestFingerprint: input.requestFingerprint,
+        },
+    };
+    if (deps.emitNervesEvent) {
+        deps.emitNervesEvent(payload);
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: input.result === "allow" ? "info" : "debug",
+        component: "private-runtime",
+        event: "private_runtime.policy_evaluated",
+        message: "private-runtime policy evaluated",
+        meta: payload.meta,
+    });
+}
+async function defaultResolveProviderLane(agent, lane, deps) {
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const { config } = (0, auth_flow_1.readAgentConfigForAgent)(agent, bundlesRoot);
+    const facing = lane === "inner" ? config.agentFacing : config.humanFacing;
+    const credential = (0, provider_credentials_1.readCachedProviderCredentialRecord)(agent, facing.provider);
+    if (!credential.ok) {
+        throw new Error(`${lane} provider ${facing.provider} (${facing.model}) credential revision unavailable: ${credential.error}`);
+    }
+    return {
+        lane,
+        provider: facing.provider,
+        model: facing.model,
+        source: "agent.json",
+        credentialRevision: credential.record.revision,
+    };
+}
+async function resolveProviderLaneMetadata(request, deps) {
+    return deps.resolveProviderLane
+        ? await deps.resolveProviderLane(request.agent, request.providerLane)
+        : defaultResolveProviderLane(request.agent, request.providerLane, deps);
+}
+async function evaluatePolicy(request, context, deps) {
+    if (deps.evaluatePolicy)
+        return deps.evaluatePolicy(request, context);
+    const originRefs = request.originRefs ?? [];
+    if (request.triggerSource === "external-event"
+        && originRefs.some((ref) => ref.kind === "external-event" && typeof ref.id === "string" && ref.id.length > 0)
+        && originRefs.some((ref) => ref.kind === "daemon-command" && ref.id === "external.event.submit")) {
+        return {
+            result: "allow",
+            reason: "verified daemon external event",
+        };
+    }
+    return {
+        result: "deny",
+        reason: "private runtime policy denies by default",
+        deniedReason: "default policy deny",
+    };
+}
+function emptyReceiptId() {
+    return "";
+}
+function createPrivateTurnRequestFingerprint(request, providerLane) {
+    return sha256Prefix("ptr", spendIdentity(request, { includeIdempotencyKey: true, providerLane }));
+}
+function createPrivateTurnIdempotencyKey(request) {
+    return sha256Prefix("ptk", spendIdentity(request, { includeIdempotencyKey: false }));
+}
+async function requestPrivateTurnDecision(request, deps = {}) {
+    const idempotencyKey = request.idempotencyKey ?? createPrivateTurnIdempotencyKey(request);
+    const normalizedRequest = { ...request, idempotencyKey };
+    let providerLane;
+    let requestFingerprint;
+    let evaluation;
+    try {
+        providerLane = await resolveProviderLaneMetadata(normalizedRequest, deps);
+        requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
+        evaluation = await evaluatePolicy(normalizedRequest, {
+            requestFingerprint,
+            idempotencyKey,
+            providerLane,
+        }, deps);
+    }
+    catch (error) {
+        providerLane = {
+            lane: normalizedRequest.providerLane,
+            provider: "unconfigured",
+            model: "-",
+            source: "agent.json",
+        };
+        requestFingerprint = createPrivateTurnRequestFingerprint(normalizedRequest, providerLane);
+        evaluation = {
+            result: "deny",
+            reason: error instanceof Error ? error.message : String(error),
+            deniedReason: "provider lane resolution failed",
+        };
+    }
+    const result = evaluation.result;
+    emitPolicyEvaluated(deps, { request: normalizedRequest, result, requestFingerprint, idempotencyKey });
+    const reason = evaluation.reason ?? normalizedRequest.reason;
+    const decision = {
+        schemaVersion: 1,
+        receiptId: emptyReceiptId(),
+        agent: normalizedRequest.agent,
+        origin: normalizedRequest.origin,
+        requestReason: normalizedRequest.reason,
+        reason,
+        providerLane,
+        triggerSource: normalizedRequest.triggerSource,
+        idempotencyKey,
+        budgetClass: normalizedRequest.budgetClass,
+        originRefs: normalizeOriginRefs(normalizedRequest.originRefs ?? []),
+        requestFingerprint,
+        result,
+        executable: result === "allow",
+        decidedAt: nowIso(deps),
+        ledgerLocator: { path: deps.ledgerPath ?? "" },
+        ...(result === "deny" ? { deniedReason: evaluation.deniedReason ?? reason } : {}),
+    };
+    return (0, ledger_1.recordPrivateTurnDecision)(decision, deps);
+}

package/dist/heart/private-runtime/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/heart/progress-story.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProgressStory = buildProgressStory;
+exports.renderProgressStory = renderProgressStory;
+const runtime_1 = require("../nerves/runtime");
+function labelForScope(scope) {
+    return scope === "inner-delegation" ? "private-runtime work" : "shared work";
+}
+function compactDetail(text) {
+    if (typeof text !== "string")
+        return null;
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildProgressStory(input) {
+    const detailLines = [
+        compactDetail(input.objective),
+        compactDetail(input.outcomeText),
+        compactDetail(input.bridgeId ? `bridge: ${input.bridgeId}` : null),
+        compactDetail(input.taskName ? `task: ${input.taskName}` : null),
+    ].filter((line) => Boolean(line));
+    const story = {
+        statusLine: `${labelForScope(input.scope)}: ${input.phase}`,
+        detailLines,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.progress_story_build",
+        message: "built shared progress story",
+        meta: {
+            scope: input.scope,
+            phase: input.phase,
+            detailLines: detailLines.length,
+            hasBridge: Boolean(input.bridgeId),
+            hasTask: Boolean(input.taskName),
+        },
+    });
+    return story;
+}
+function renderProgressStory(story) {
+    return [story.statusLine, ...story.detailLines].join("\n");
+}

package/dist/heart/provider-attempt.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_ATTEMPT_POLICY = exports.ProviderAttemptAbortError = void 0;
+exports.runProviderAttempt = runProviderAttempt;
+const runtime_1 = require("../nerves/runtime");
+class ProviderAttemptAbortError extends Error {
+    constructor(message = "provider attempt aborted") {
+        super(message);
+        this.name = "ProviderAttemptAbortError";
+    }
+}
+exports.ProviderAttemptAbortError = ProviderAttemptAbortError;
+exports.DEFAULT_PROVIDER_ATTEMPT_POLICY = {
+    maxAttempts: 3,
+    baseDelayMs: 2_000,
+    backoffMultiplier: 2,
+};
+function sleep(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function normalizePolicy(policy) {
+    return {
+        ...exports.DEFAULT_PROVIDER_ATTEMPT_POLICY,
+        ...policy,
+    };
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function classify(error, classifyError) {
+    if (!(error instanceof Error))
+        return "unknown";
+    try {
+        return classifyError(error);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function httpStatus(error) {
+    const status = error.status;
+    return typeof status === "number" ? status : null;
+}
+function delayForAttempt(policy, attempt) {
+    return policy.baseDelayMs * Math.pow(policy.backoffMultiplier, attempt - 1);
+}
+async function runProviderAttempt(input) {
+    const policy = normalizePolicy(input.policy);
+    const maxAttempts = Math.max(1, Math.floor(policy.maxAttempts));
+    const wait = input.sleep ?? sleep;
+    const attempts = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            await input.onAttemptStart?.(attempt, maxAttempts);
+            const value = await input.run();
+            attempts.push({
+                attempt,
+                provider: input.provider,
+                model: input.model,
+                operation: input.operation,
+                ok: true,
+                willRetry: false,
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.provider_attempt_succeeded",
+                message: "provider attempt succeeded",
+                meta: { provider: input.provider, model: input.model, operation: input.operation, attempt, maxAttempts },
+            });
+            return { ok: true, value, attempts };
+        }
+        catch (caught) {
+            if (caught instanceof ProviderAttemptAbortError)
+                throw caught;
+            const error = toError(caught);
+            const classification = classify(caught, input.classifyError);
+            const willRetry = attempt < maxAttempts;
+            const delayMs = willRetry ? delayForAttempt(policy, attempt) : undefined;
+            const record = {
+                attempt,
+                provider: input.provider,
+                model: input.model,
+                operation: input.operation,
+                ok: false,
+                classification,
+                errorMessage: error.message,
+                httpStatus: httpStatus(error),
+                willRetry,
+                ...(delayMs !== undefined ? { delayMs } : {}),
+            };
+            attempts.push(record);
+            if (!willRetry) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "engine",
+                    event: "engine.provider_attempt_failed",
+                    message: "provider attempt failed",
+                    meta: {
+                        provider: input.provider,
+                        model: input.model,
+                        operation: input.operation,
+                        attempt,
+                        maxAttempts,
+                        classification,
+                        errorMessage: error.message.slice(0, 200),
+                        httpStatus: httpStatus(error),
+                    },
+                });
+                return { ok: false, error, classification, attempts };
+            }
+            const retryDelayMs = delayMs;
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.provider_attempt_retry",
+                message: "provider attempt failed; retrying",
+                meta: {
+                    provider: input.provider,
+                    model: input.model,
+                    operation: input.operation,
+                    attempt,
+                    maxAttempts,
+                    classification,
+                    errorMessage: error.message.slice(0, 200),
+                    httpStatus: httpStatus(error),
+                    delayMs: retryDelayMs,
+                },
+            });
+            await input.onRetry?.(record, maxAttempts);
+            await wait(retryDelayMs);
+        }
+    }
+    /* v8 ignore next 2 -- defensive: loop always returns on success or final failure @preserve */
+    return { ok: false, error: new Error("provider attempt loop ended unexpectedly"), classification: "unknown", attempts };
+}