@ouro.bot/cli 0.1.0-alpha.729 → 0.1.0-alpha.730

package/dist/mind/session-transaction.js

@@ -0,0 +1,379 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionTransactionError = exports.SessionTurnBusyError = void 0;
+exports.acquireSessionTurnLease = acquireSessionTurnLease;
+exports.withSessionTurnLease = withSessionTurnLease;
+exports.withImmediateSessionTurnLease = withImmediateSessionTurnLease;
+exports.currentSessionTurnLease = currentSessionTurnLease;
+exports.assertSessionTurnLease = assertSessionTurnLease;
+exports.readSessionTransaction = readSessionTransaction;
+exports.writeSessionTransaction = writeSessionTransaction;
+exports.deleteSessionTransaction = deleteSessionTransaction;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const runtime_1 = require("../nerves/runtime");
+class SessionTurnBusyError extends Error {
+    retryable = true;
+    constructor(message = "session turn is busy") {
+        super(message);
+        this.name = "SessionTurnBusyError";
+    }
+}
+exports.SessionTurnBusyError = SessionTurnBusyError;
+class SessionTransactionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SessionTransactionError";
+    }
+}
+exports.SessionTransactionError = SessionTransactionError;
+const heldLeases = new Map();
+const leaseContext = new node_async_hooks_1.AsyncLocalStorage();
+function canonicalSessionPath(sessionPath) {
+    return path.resolve(sessionPath);
+}
+function revision(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes, "utf8").digest("hex");
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isSqliteBusy(error) {
+    return error instanceof Error && "code" in error
+        && error.code === "SQLITE_BUSY";
+}
+function openLeaseDatabase(lockPath, busyTimeoutMs = 0) {
+    const database = new better_sqlite3_1.default(lockPath);
+    database.pragma(`busy_timeout = ${busyTimeoutMs}`);
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS session_turn_lease (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      pid INTEGER NOT NULL,
+      owner_id TEXT NOT NULL,
+      owner_token TEXT NOT NULL
+    )
+  `);
+    return database;
+}
+function claimLeaseRecord(lockPath, record, isProcessAlive) {
+    const database = openLeaseDatabase(lockPath);
+    try {
+        return database.transaction(() => {
+            const current = database.prepare(`
+        SELECT pid, owner_id, owner_token FROM session_turn_lease WHERE singleton = 1
+      `).get();
+            if (!current) {
+                database.prepare(`
+          INSERT INTO session_turn_lease (singleton, pid, owner_id, owner_token) VALUES (1, ?, ?, ?)
+        `).run(record.pid, record.ownerId, record.ownerToken);
+                return { acquired: true, stale: null };
+            }
+            if (!Number.isSafeInteger(current.pid) || current.pid <= 0
+                || typeof current.owner_id !== "string" || current.owner_id.length === 0
+                || typeof current.owner_token !== "string" || current.owner_token.length === 0) {
+                throw new SessionTransactionError("invalid session lease record");
+            }
+            const observed = { pid: current.pid, ownerId: current.owner_id, ownerToken: current.owner_token };
+            if (isProcessAlive(observed.pid))
+                return { acquired: false, stale: null };
+            database.prepare(`
+        UPDATE session_turn_lease SET pid = ?, owner_id = ?, owner_token = ?
+        WHERE singleton = 1 AND pid = ? AND owner_id = ? AND owner_token = ?
+      `).run(record.pid, record.ownerId, record.ownerToken, observed.pid, observed.ownerId, observed.ownerToken);
+            return { acquired: true, stale: observed };
+        })();
+    }
+    finally {
+        database.close();
+    }
+}
+function releaseLeaseRecord(lockPath, record) {
+    const database = openLeaseDatabase(lockPath, 5_000);
+    try {
+        return database.prepare(`
+      DELETE FROM session_turn_lease WHERE singleton = 1 AND pid = ? AND owner_id = ? AND owner_token = ?
+    `).run(record.pid, record.ownerId, record.ownerToken).changes === 1;
+    }
+    finally {
+        database.close();
+    }
+}
+function makeLease(held) {
+    let localReleased = false;
+    return {
+        sessionPath: held.sessionPath,
+        ownerId: held.ownerId,
+        ownerToken: held.ownerToken,
+        release: async () => {
+            if (localReleased)
+                return;
+            localReleased = true;
+            held.depth -= 1;
+            if (held.depth > 0 || held.released)
+                return;
+            held.released = true;
+            releaseLeaseRecord(held.lockPath, held);
+            heldLeases.delete(held.sessionPath);
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.session_turn_lease_released",
+                message: "released session turn lease",
+                meta: { sessionPath: held.sessionPath, ownerId: held.ownerId },
+            });
+        },
+    };
+}
+async function acquireSessionTurnLease(sessionPath, options = {}) {
+    const canonical = canonicalSessionPath(sessionPath);
+    const existing = heldLeases.get(canonical);
+    if (existing && !existing.released) {
+        if (options.ownerId === existing.ownerId && options.ownerToken === existing.ownerToken) {
+            existing.depth += 1;
+            return makeLease(existing);
+        }
+    }
+    const ownerId = options.ownerId ?? (0, node_crypto_1.randomUUID)();
+    const ownerToken = options.ownerToken ?? (0, node_crypto_1.randomUUID)();
+    const pid = options.pid ?? process.pid;
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 10;
+    const isProcessAlive = options.isProcessAlive ?? processAlive;
+    const lockPath = `${canonical}.turn.lock`;
+    const started = Date.now();
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    for (;;) {
+        let claim = null;
+        try {
+            claim = claimLeaseRecord(lockPath, { pid, ownerId, ownerToken }, isProcessAlive);
+        }
+        catch (error) {
+            if (!isSqliteBusy(error))
+                throw error;
+        }
+        if (claim?.acquired) {
+            const held = { sessionPath: canonical, lockPath, pid, ownerId, ownerToken, depth: 1, released: false };
+            heldLeases.set(canonical, held);
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.session_turn_lease_acquired",
+                message: "acquired session turn lease",
+                meta: { sessionPath: canonical, ownerId },
+            });
+            if (claim.stale) {
+                options.onStaleLease?.(claim.stale);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.session_turn_lease_stolen",
+                    message: "stole stale session turn lease",
+                    meta: { sessionPath: canonical, stalePid: claim.stale.pid, staleOwnerId: claim.stale.ownerId },
+                });
+            }
+            return makeLease(held);
+        }
+        if (Date.now() - started >= timeoutMs) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.session_turn_lease_busy",
+                message: "session turn lease acquisition timed out",
+                meta: { sessionPath: canonical, ownerId, timeoutMs },
+            });
+            throw new SessionTurnBusyError(`session turn busy: ${canonical}`);
+        }
+        await sleep(pollIntervalMs);
+    }
+}
+async function withSessionTurnLease(sessionPath, work, options = {}) {
+    const lease = await acquireSessionTurnLease(sessionPath, options);
+    try {
+        return await leaseContext.run(lease, () => work(lease));
+    }
+    finally {
+        await lease.release();
+    }
+}
+function withImmediateSessionTurnLease(sessionPath, work, options = {}) {
+    const canonical = canonicalSessionPath(sessionPath);
+    const contextual = currentSessionTurnLease(canonical);
+    if (contextual)
+        return work(contextual);
+    const ownerId = options.ownerId ?? (0, node_crypto_1.randomUUID)();
+    const ownerToken = options.ownerToken ?? (0, node_crypto_1.randomUUID)();
+    const pid = options.pid ?? process.pid;
+    const lockPath = `${canonical}.turn.lock`;
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    const tryAcquire = () => {
+        let claim;
+        try {
+            claim = claimLeaseRecord(lockPath, { pid, ownerId, ownerToken }, options.isProcessAlive ?? processAlive);
+        }
+        catch (error) {
+            if (isSqliteBusy(error))
+                return null;
+            throw error;
+        }
+        if (claim.acquired) {
+            const held = { sessionPath: canonical, lockPath, pid, ownerId, ownerToken, depth: 1, released: false };
+            heldLeases.set(canonical, held);
+            if (claim.stale) {
+                options.onStaleLease?.(claim.stale);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.session_turn_lease_stolen",
+                    message: "stole stale session turn lease",
+                    meta: { sessionPath: canonical, stalePid: claim.stale.pid, staleOwnerId: claim.stale.ownerId },
+                });
+            }
+            return held;
+        }
+        return null;
+    };
+    const held = tryAcquire();
+    if (!held)
+        throw new SessionTurnBusyError(`session turn busy: ${canonical}`);
+    const lease = makeLease(held);
+    try {
+        return leaseContext.run(lease, () => work(lease));
+    }
+    finally {
+        void lease.release();
+    }
+}
+function currentSessionTurnLease(sessionPath) {
+    const lease = leaseContext.getStore();
+    return lease && lease.sessionPath === canonicalSessionPath(sessionPath) ? lease : null;
+}
+function assertSessionTurnLease(sessionPath, lease) {
+    const canonical = canonicalSessionPath(sessionPath);
+    if (lease.sessionPath !== canonical)
+        throw new SessionTransactionError("leased session path mismatch");
+    const held = heldLeases.get(canonical);
+    if (!held || held.released || held.ownerId !== lease.ownerId || held.ownerToken !== lease.ownerToken) {
+        throw new SessionTransactionError("session lease owner token mismatch");
+    }
+}
+function readSessionTransaction(sessionPath, lease) {
+    assertSessionTurnLease(sessionPath, lease);
+    let bytes = "";
+    try {
+        bytes = fs.readFileSync(canonicalSessionPath(sessionPath), "utf8");
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.code !== "ENOENT")
+            throw error;
+    }
+    return { bytes, value: bytes ? JSON.parse(bytes) : null, revision: revision(bytes) };
+}
+function writeSessionTransaction(sessionPath, value, options) {
+    assertSessionTurnLease(sessionPath, options.lease);
+    const canonical = canonicalSessionPath(sessionPath);
+    const current = readSessionTransaction(canonical, options.lease);
+    if (current.revision !== options.expectedRevision)
+        throw new SessionTransactionError("session revision changed");
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    const bytes = JSON.stringify(value, null, 2);
+    const tempPath = path.join(path.dirname(canonical), `.${path.basename(canonical)}.tmp-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    let fd = null;
+    try {
+        fd = fs.openSync(tempPath, "wx", 0o600);
+        fs.writeFileSync(fd, bytes, "utf8");
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = null;
+        options.hooks?.beforeRename?.();
+        fs.renameSync(tempPath, canonical);
+        const directoryFd = fs.openSync(path.dirname(canonical), "r");
+        try {
+            fs.fsyncSync(directoryFd);
+        }
+        finally {
+            fs.closeSync(directoryFd);
+        }
+    }
+    catch (error) {
+        /* v8 ignore next -- fd-close failure after a prior node:fs failure is best-effort cleanup @preserve */
+        if (fd !== null)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* best effort */ }
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch { /* best effort */ }
+        throw error;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.session_transaction_written",
+        message: "durably replaced session envelope",
+        meta: { sessionPath: canonical, ownerId: options.lease.ownerId },
+    });
+    return revision(bytes);
+}
+function deleteSessionTransaction(sessionPath, lease) {
+    assertSessionTurnLease(sessionPath, lease);
+    try {
+        fs.unlinkSync(canonicalSessionPath(sessionPath));
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.code !== "ENOENT")
+            throw error;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.session_transaction_deleted",
+        message: "deleted session under turn lease",
+        meta: { sessionPath: canonicalSessionPath(sessionPath), ownerId: lease.ownerId },
+    });
+}

package/dist/repertoire/stripe-client.js

@@ -32,8 +32,8 @@ function toCardInfo(card) {
 async function createStripeClient() {
     const store = (0, credential_access_1.getCredentialStore)();
     const apiKey = await store.getRawSecret("stripe.com", "restrictedKey");
-    // StripeConstructor is a callable (not a class), cast the result
-    const stripe = (0, stripe_1.default)(apiKey);
+    const StripeFactory = stripe_1.default;
+    const stripe = new StripeFactory(apiKey);
     return {
         async createVirtualCard(opts) {
             (0, runtime_1.emitNervesEvent)({

package/dist/repertoire/tool-arguments.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestJson = digestJson;
+exports.validateAdvertisedToolArguments = validateAdvertisedToolArguments;
+const node_crypto_1 = require("node:crypto");
+const ajv_1 = __importDefault(require("ajv"));
+const runtime_1 = require("../nerves/runtime");
+const ajv = new ajv_1.default({
+    strict: true,
+    allErrors: true,
+    coerceTypes: false,
+    removeAdditional: false,
+    useDefaults: false,
+});
+const validators = new WeakMap();
+function canonicalize(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(",")}]`;
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(value[key])}`).join(",")}}`;
+}
+function digest(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+function renderErrors(errors) {
+    return errors.map((error) => `${error.instancePath || "/"} ${error.message}`).join("; ");
+}
+function digestJson(value) {
+    return digest(canonicalize(value));
+}
+function validateAdvertisedToolArguments(rawArguments, schema) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawArguments);
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.tool_arguments_invalid_json",
+            message: "tool arguments were not valid JSON",
+            meta: { rawLength: rawArguments.length },
+        });
+        return { ok: false, reason: "malformed JSON" };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.tool_arguments_non_object",
+            message: "tool arguments were not a JSON object",
+            meta: { parsedType: parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed },
+        });
+        return { ok: false, reason: "arguments must be a JSON object" };
+    }
+    let validator = validators.get(schema);
+    try {
+        validator ??= ajv.compile(schema);
+        validators.set(schema, validator);
+    }
+    catch (error) {
+        const reason = String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "repertoire",
+            event: "repertoire.tool_schema_invalid",
+            message: "advertised tool schema could not be compiled",
+            meta: { reason },
+        });
+        return { ok: false, reason: `advertised schema is invalid: ${reason}` };
+    }
+    if (!validator(parsed)) {
+        const reason = renderErrors(validator.errors);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.tool_arguments_schema_rejected",
+            message: "tool arguments failed advertised schema validation",
+            meta: { reason },
+        });
+        return { ok: false, reason };
+    }
+    const argumentsValue = structuredClone(parsed);
+    const canonicalArguments = canonicalize(argumentsValue);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.tool_arguments_validated",
+        message: "tool arguments passed advertised schema validation",
+        meta: { argumentDigest: digest(canonicalArguments) },
+    });
+    return {
+        ok: true,
+        value: {
+            arguments: argumentsValue,
+            canonicalArguments,
+            argumentDigest: digest(canonicalArguments),
+            schemaDigest: digestJson(schema),
+        },
+    };
+}

package/dist/repertoire/tools-shell.js

@@ -26,9 +26,22 @@ exports.shellToolDefinitions = [
                         },
                     },
                     required: ["command"],
+                    additionalProperties: false,
                 },
             },
         },
+        approvalPolicy: (args) => {
+            const command = typeof args.command === "string" ? args.command.trim().split(/\s+/) : [];
+            if (command[0] === "docker" && command[1] === "restart" && command.length > 2) {
+                return {
+                    kind: "required",
+                    policyId: "shell.docker-lifecycle.v1",
+                    actionClass: "service-control",
+                    requiresSoleCall: true,
+                };
+            }
+            return { kind: "not_required" };
+        },
         handler: (a) => {
             // Destructive pattern detection (friction, not a block)
             const destructivePatterns = (0, shell_sessions_1.detectDestructivePatterns)(a.command);

package/dist/repertoire/tools.js

@@ -4,6 +4,7 @@ exports.surfaceToolDef = exports.speakTool = exports.restTool = exports.ponderTo
 exports.resetMcpDefinitions = resetMcpDefinitions;
 exports.getToolsForChannel = getToolsForChannel;
 exports.resolveToolDefinition = resolveToolDefinition;
+exports.approvalPolicyForToolName = approvalPolicyForToolName;
 exports.shellRiskProfile = shellRiskProfile;
 exports.riskProfileForTool = riskProfileForTool;
 exports.riskProfileForToolName = riskProfileForToolName;
@@ -134,6 +135,9 @@ function resolveToolDefinition(toolName) {
         ?? allDefinitions.find((d) => d.tool.function.name === toolName)
         ?? mcpDefinitions.find((d) => d.tool.function.name === toolName);
 }
+function approvalPolicyForToolName(name, args) {
+    return resolveToolDefinition(name)?.approvalPolicy?.(args) ?? { kind: "not_required" };
+}
 const findDefinition = resolveToolDefinition;
 function normalizeGuardArgs(_name, args) {
     return args;