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

package/dist/repertoire/coding/workbench-manager.js

@@ -0,0 +1,346 @@
+"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.WorkbenchCodingSessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const spawner_1 = require("./spawner");
+function cloneSession(session) {
+    return {
+        ...session,
+        originSession: session.originSession ? { ...session.originSession } : undefined,
+        failure: session.failure ? { ...session.failure, args: [...session.failure.args] } : null,
+    };
+}
+function sanitizeNamePart(value, fallback) {
+    const sanitized = (value ?? fallback)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized.length > 0 ? sanitized : fallback;
+}
+function timestampPart(iso) {
+    return iso.replace(/[-:.]/g, "").replace("Z", "Z");
+}
+function sessionNameForRequest(request, nowIso) {
+    return [
+        "coding",
+        request.runner,
+        sanitizeNamePart(request.taskRef, "task"),
+        timestampPart(nowIso),
+    ].join("-");
+}
+function commandForRunner(runner) {
+    return runner === "claude" ? "claude" : "codex";
+}
+function runnerFromWorkbenchSession(session, fallback) {
+    const name = session.name.toLowerCase();
+    if (name.includes("claude"))
+        return "claude";
+    if (name.includes("codex"))
+        return "codex";
+    return fallback;
+}
+function mapWorkbenchStatus(session) {
+    switch (session.status) {
+        case "configured":
+        case "running":
+            return "running";
+        case "waitingForInput":
+            return "waiting_input";
+        case "exited":
+            return session.exitCode === 0 ? "completed" : "failed";
+        case "needsRecovery":
+        case "manualActionNeeded":
+            return "stalled";
+        default:
+            return "running";
+    }
+}
+function checkpointFor(session, status) {
+    if (session.attentionPrompt?.trim())
+        return session.attentionPrompt.trim();
+    if (session.attentionReason?.trim())
+        return session.attentionReason.trim();
+    if (session.attention?.trim())
+        return session.attention.trim();
+    if (status === "completed")
+        return "completed";
+    if (status === "failed")
+        return session.exitCode === undefined ? "exited" : `exit code ${session.exitCode}`;
+    if (status === "stalled")
+        return "needs Workbench recovery";
+    return null;
+}
+function failureFor(session, command) {
+    if (mapWorkbenchStatus(session) !== "failed")
+        return null;
+    return {
+        command,
+        args: [],
+        code: session.exitCode ?? null,
+        signal: null,
+        stdoutTail: "",
+        stderrTail: checkpointFor(session, "failed"),
+    };
+}
+function resultToActionResult(action, sessionId, result) {
+    if (result.state === "applied" || result.state === "appliedUnconfirmed") {
+        return { ok: true, message: `${action} applied for ${sessionId}` };
+    }
+    if (result.state === "queued") {
+        return { ok: false, message: `${action} queued for ${sessionId} but not confirmed` };
+    }
+    return { ok: false, message: result.result ?? `${action} ${result.state} for ${sessionId}` };
+}
+function promptDeliveryFailure(result) {
+    const sessionId = result.session.id;
+    if (result.promptAck.ok === false) {
+        return `Workbench denied initial prompt for ${sessionId}`;
+    }
+    switch (result.promptResult?.state) {
+        case "applied":
+        case "appliedUnconfirmed":
+            return null;
+        case "failed":
+            return `Workbench failed initial prompt for ${sessionId}`;
+        case "queued":
+            return `Workbench queued initial prompt for ${sessionId} but did not confirm delivery`;
+        case "unknown":
+        case undefined:
+            return `Workbench did not confirm initial prompt delivery for ${sessionId}`;
+    }
+}
+class WorkbenchCodingSessionManager {
+    records = new Map();
+    listeners = new Map();
+    client;
+    agentName;
+    nowIso;
+    existsSync;
+    readFileSync;
+    source;
+    constructor(options) {
+        this.client = options.client;
+        this.agentName = options.agentName;
+        this.nowIso = options.nowIso ?? (() => new Date().toISOString());
+        this.existsSync = options.existsSync ?? fs.existsSync;
+        this.readFileSync = options.readFileSync ?? fs.readFileSync;
+        this.source = options.source ?? "ouro-coding";
+    }
+    async spawnSession(request) {
+        const now = this.nowIso();
+        const name = sessionNameForRequest(request, now);
+        const normalizedRequest = {
+            ...request,
+            parentAgent: request.parentAgent ?? this.agentName,
+        };
+        const prompt = (0, spawner_1.buildCodingPrompt)(normalizedRequest, {
+            existsSync: this.existsSync,
+            readFileSync: this.readFileSync,
+        });
+        const result = await this.client.createCodingSession({
+            owner: normalizedRequest.parentAgent,
+            name,
+            command: commandForRunner(normalizedRequest.runner),
+            workingDirectory: normalizedRequest.workdir,
+            prompt,
+            group: path.basename(normalizedRequest.workdir),
+            trust: "trusted",
+            autoResume: normalizedRequest.autoRestartOnCrash !== false,
+            source: this.source,
+        });
+        const promptFailure = promptDeliveryFailure(result);
+        if (promptFailure) {
+            throw new Error(promptFailure);
+        }
+        const session = this.toCodingSession(result.session, normalizedRequest);
+        this.records.set(session.id, { request: normalizedRequest, session });
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.workbench_coding_session_spawned",
+            message: "Workbench coding session spawned",
+            meta: { id: session.id, runner: session.runner, workdir: session.workdir },
+        });
+        this.notifyListeners(session.id, { kind: "spawned", session: cloneSession(session) });
+        return cloneSession(session);
+    }
+    async refreshSessions() {
+        const workbenchSessions = await this.client.listSessions({ owner: this.agentName, includeArchived: true });
+        for (const workbenchSession of workbenchSessions) {
+            if (!workbenchSession.name.toLowerCase().startsWith("coding-"))
+                continue;
+            const existing = this.records.get(workbenchSession.id);
+            const fallbackRequest = existing?.request ?? this.fallbackRequest(workbenchSession);
+            const session = this.toCodingSession(workbenchSession, fallbackRequest, existing?.session);
+            this.records.set(session.id, { request: fallbackRequest, session });
+        }
+        return this.listSessions();
+    }
+    async refreshSession(sessionId) {
+        const sessions = await this.refreshSessions();
+        const session = sessions.find((item) => item.id === sessionId) ?? null;
+        if (!session)
+            return null;
+        const tail = await this.client.transcriptTail(sessionId);
+        const record = this.records.get(sessionId);
+        record.session.stdoutTail = tail;
+        record.session.lastActivityAt = this.nowIso();
+        record.session.checkpoint = tail.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? record.session.checkpoint;
+        return cloneSession(record.session);
+    }
+    listSessions() {
+        return [...this.records.values()]
+            .map((record) => cloneSession(record.session))
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    getSession(sessionId) {
+        const record = this.records.get(sessionId);
+        return record ? cloneSession(record.session) : null;
+    }
+    subscribe(sessionId, listener) {
+        const listeners = this.listeners.get(sessionId) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(sessionId, listeners);
+        return () => {
+            const current = this.listeners.get(sessionId);
+            if (!current)
+                return;
+            current.delete(listener);
+            if (current.size === 0)
+                this.listeners.delete(sessionId);
+        };
+    }
+    async sendInput(sessionId, input) {
+        return this.queueAction(sessionId, "sendInput", { text: input, appendNewline: true });
+    }
+    async killSession(sessionId) {
+        const actionResult = await this.queueAction(sessionId, "terminate", {});
+        if (actionResult.ok) {
+            const record = this.records.get(sessionId);
+            record.session.status = "killed";
+            record.session.endedAt = this.nowIso();
+            record.session.checkpoint = "terminated by parent agent";
+            this.notifyListeners(sessionId, { kind: "killed", session: cloneSession(record.session) });
+        }
+        return actionResult;
+    }
+    checkStalls() {
+        return 0;
+    }
+    shutdown() {
+        this.listeners.clear();
+    }
+    async queueAction(sessionId, action, extra) {
+        let record = this.records.get(sessionId);
+        if (!record) {
+            await this.refreshSessions();
+            record = this.records.get(sessionId);
+        }
+        if (!record) {
+            return { ok: false, message: `session not found: ${sessionId}` };
+        }
+        const ack = await this.client.requestAction({
+            source: this.source,
+            action,
+            entry: sessionId,
+            ...extra,
+        });
+        if (!ack.requestId) {
+            return { ok: ack.ok === true, message: ack.message ?? `${action} queued for ${sessionId}` };
+        }
+        const result = await this.client.waitForAction(ack.requestId);
+        const actionResult = resultToActionResult(action, sessionId, result);
+        if (actionResult.ok && action === "sendInput") {
+            record.session.status = "running";
+            record.session.lastActivityAt = this.nowIso();
+            this.notifyListeners(sessionId, { kind: "progress", session: cloneSession(record.session) });
+        }
+        return actionResult;
+    }
+    fallbackRequest(session) {
+        const runner = runnerFromWorkbenchSession(session, "codex");
+        return {
+            runner,
+            workdir: session.workingDirectory ?? "",
+            prompt: "",
+            taskRef: session.name,
+            parentAgent: this.agentName,
+            autoRestartOnCrash: session.autoResume,
+        };
+    }
+    toCodingSession(workbenchSession, request, previous) {
+        const runner = runnerFromWorkbenchSession(workbenchSession, request.runner);
+        const status = mapWorkbenchStatus(workbenchSession);
+        const workdir = workbenchSession.workingDirectory ?? request.workdir;
+        const lastActivityAt = workbenchSession.lastOutputAt ?? workbenchSession.startedAt ?? previous?.lastActivityAt ?? this.nowIso();
+        const startedAt = workbenchSession.startedAt ?? previous?.startedAt ?? this.nowIso();
+        const command = commandForRunner(runner);
+        return {
+            id: workbenchSession.id,
+            runner,
+            workdir,
+            taskRef: request.taskRef,
+            originSession: request.originSession ? { ...request.originSession } : undefined,
+            obligationId: request.obligationId,
+            evolutionCaseId: request.evolutionCaseId,
+            scopeFile: request.scopeFile,
+            stateFile: request.stateFile,
+            checkpoint: checkpointFor(workbenchSession, status),
+            artifactPath: workbenchSession.transcriptPath,
+            status,
+            stdoutTail: previous?.stdoutTail ?? "",
+            stderrTail: previous?.stderrTail ?? "",
+            pid: workbenchSession.pid ?? null,
+            startedAt,
+            lastActivityAt,
+            endedAt: status === "completed" || status === "failed" ? lastActivityAt : null,
+            restartCount: previous?.restartCount ?? 0,
+            lastExitCode: workbenchSession.exitCode ?? null,
+            lastSignal: null,
+            failure: failureFor(workbenchSession, command),
+        };
+    }
+    notifyListeners(sessionId, update) {
+        const listeners = this.listeners.get(sessionId);
+        if (!listeners || listeners.size === 0)
+            return;
+        for (const listener of listeners) {
+            void Promise.resolve(listener(update));
+        }
+    }
+}
+exports.WorkbenchCodingSessionManager = WorkbenchCodingSessionManager;

package/dist/repertoire/commerce-errors.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Commerce-specific error types and helpers.
+ *
+ * These errors carry structured `code` and `meta` fields for nerves event
+ * compatibility and provide patterns for common commerce failure modes:
+ * retry, price change detection, and partial failure reporting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileError = exports.BookingError = exports.PaymentError = exports.CommerceError = void 0;
+exports.retryOnce = retryOnce;
+exports.priceChangeGuard = priceChangeGuard;
+exports.partialFailureReport = partialFailureReport;
+// ---------------------------------------------------------------------------
+// Error types
+// ---------------------------------------------------------------------------
+class CommerceError extends Error {
+    code;
+    meta;
+    constructor(message, code, meta = {}) {
+        super(message);
+        this.name = "CommerceError";
+        this.code = code;
+        this.meta = meta;
+    }
+}
+exports.CommerceError = CommerceError;
+class PaymentError extends CommerceError {
+    constructor(message, code, meta = {}) {
+        super(message, code, meta);
+        this.name = "PaymentError";
+    }
+}
+exports.PaymentError = PaymentError;
+class BookingError extends CommerceError {
+    constructor(message, code, meta = {}) {
+        super(message, code, meta);
+        this.name = "BookingError";
+    }
+}
+exports.BookingError = BookingError;
+class ProfileError extends CommerceError {
+    constructor(message, code, meta = {}) {
+        super(message, code, meta);
+        this.name = "ProfileError";
+    }
+}
+exports.ProfileError = ProfileError;
+// ---------------------------------------------------------------------------
+// Transient error detection
+// ---------------------------------------------------------------------------
+const TRANSIENT_CODES = new Set(["COMMERCE_TRANSIENT", "COMMERCE_TIMEOUT", "COMMERCE_NETWORK"]);
+function isTransient(err) {
+    return err instanceof CommerceError && TRANSIENT_CODES.has(err.code);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Retry a function once on transient failure, then throw.
+ * Non-transient errors are thrown immediately without retry.
+ */
+async function retryOnce(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (!isTransient(err))
+            throw err;
+        // One retry
+        return fn();
+    }
+}
+/**
+ * Throw PaymentError if the actual price differs from the approved price
+ * by more than 5%. Used to protect against price changes between search
+ * and booking.
+ */
+function priceChangeGuard(approved, actual) {
+    if (approved === 0 && actual === 0)
+        return;
+    if (approved === 0) {
+        throw new PaymentError(`price changed from $0 to $${actual} — cannot verify percentage change`, "PAYMENT_PRICE_CHANGED", { approved, actual });
+    }
+    const delta = Math.abs(actual - approved) / approved;
+    if (delta > 0.05) {
+        throw new PaymentError(`price changed by ${(delta * 100).toFixed(1)}% (approved: $${approved}, actual: $${actual})`, "PAYMENT_PRICE_CHANGED", { approved, actual, deltaPercent: delta * 100 });
+    }
+}
+/**
+ * Format a human-readable status report for multi-service booking attempts.
+ * Each entry has a service name, status, and optional error message.
+ */
+function partialFailureReport(results) {
+    if (results.length === 0) {
+        return "no services attempted.";
+    }
+    const lines = results.map((r) => {
+        const status = r.status === "success" ? "success" : "failed";
+        const detail = r.error ? ` — ${r.error}` : "";
+        return `  ${r.service}: ${status}${detail}`;
+    });
+    const succeeded = results.filter((r) => r.status === "success").length;
+    const failed = results.length - succeeded;
+    return [
+        `booking status: ${succeeded} succeeded, ${failed} failed`,
+        ...lines,
+    ].join("\n");
+}

package/dist/repertoire/commerce-self-test.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Commerce self-test — per-service health checks for the agent's
+ * commerce infrastructure (Stripe, Duffel, LiteAPI).
+ *
+ * Used by the setup wizard to verify configuration and provide
+ * actionable error messages when services are misconfigured.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commerceSelfTest = commerceSelfTest;
+const stripe_client_1 = require("./stripe-client");
+const duffel_client_1 = require("./duffel-client");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Per-service tests
+// ---------------------------------------------------------------------------
+async function testStripe() {
+    try {
+        const client = await (0, stripe_client_1.createStripeClient)();
+        // Create a test card and immediately deactivate it
+        const card = await client.createVirtualCard({
+            type: "single_use",
+            spendLimit: 1,
+            currency: "usd",
+        });
+        await client.deactivateCard(card.cardId);
+        return { status: "ok", message: "Stripe Issuing working. Test card created and deactivated." };
+    }
+    catch (err) {
+        /* v8 ignore next -- reason @preserve */
+        const reason = err instanceof Error ? err.message : String(err);
+        if (reason.includes("no credential found") || reason.includes("restrictedKey")) {
+            return {
+                status: "error",
+                message: `Stripe key missing. Add your restricted key at https://dashboard.stripe.com/apikeys and store it in the vault as stripe.com/restrictedKey.`,
+            };
+        }
+        if (reason.includes("401") || reason.includes("Invalid API Key")) {
+            return {
+                status: "error",
+                message: `Stripe key returned 401. Verify it at https://dashboard.stripe.com/apikeys.`,
+            };
+        }
+        return {
+            status: "error",
+            message: `Stripe error: ${reason}`,
+        };
+    }
+}
+async function testDuffel() {
+    try {
+        const client = await (0, duffel_client_1.createDuffelClient)();
+        await client.searchFlights({
+            origin: "SFO",
+            destination: "JFK",
+            departureDate: new Date(Date.now() + 30 * 86400000).toISOString().split("T")[0],
+            passengers: [{ type: "adult" }],
+        });
+        return { status: "ok", message: "Duffel Flights working. Test search completed." };
+    }
+    catch (err) {
+        /* v8 ignore next -- reason @preserve */
+        const reason = err instanceof Error ? err.message : String(err);
+        if (reason.includes("no credential found") || reason.includes("apiKey")) {
+            return {
+                status: "error",
+                message: `Duffel key missing. Add your API key from https://app.duffel.com/tokens and store it in the vault as duffel.com/apiKey.`,
+            };
+        }
+        if (reason.includes("401") || reason.includes("Unauthorized")) {
+            return {
+                status: "error",
+                message: `Your Duffel key returned 401. Verify it at https://app.duffel.com/tokens.`,
+            };
+        }
+        return {
+            status: "error",
+            message: `Duffel error: ${reason}`,
+        };
+    }
+}
+async function testLiteApi() {
+    try {
+        const store = (0, credential_access_1.getCredentialStore)();
+        await store.getRawSecret("liteapi.travel", "apiKey");
+        // If we can retrieve the key, the config is present.
+        // LiteAPI is accessed via MCP, so we can't do a direct API call here.
+        // The actual health check happens when the MCP server starts.
+        return { status: "ok", message: "LiteAPI key found in vault. MCP server will use vault:liteapi.travel/apiKey." };
+    }
+    catch (err) {
+        /* v8 ignore next -- reason @preserve */
+        const reason = err instanceof Error ? err.message : String(err);
+        if (reason.includes("no credential found")) {
+            return {
+                status: "error",
+                message: `LiteAPI key missing. Get your API key from https://dashboard.liteapi.travel and store it in the vault as liteapi.travel/apiKey.`,
+            };
+        }
+        return {
+            status: "error",
+            message: `LiteAPI error: ${reason}`,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Main self-test
+// ---------------------------------------------------------------------------
+async function commerceSelfTest() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.commerce_self_test_start",
+        message: "starting commerce self-test",
+        meta: {},
+    });
+    const [stripe, duffel, liteapi] = await Promise.all([
+        testStripe(),
+        testDuffel(),
+        testLiteApi(),
+    ]);
+    const services = { stripe, duffel, liteapi };
+    const okCount = Object.values(services).filter((s) => s.status === "ok").length;
+    const total = Object.keys(services).length;
+    let overall;
+    if (okCount === total) {
+        overall = "healthy";
+    }
+    else if (okCount > 0) {
+        overall = "partial";
+    }
+    else {
+        overall = "unhealthy";
+    }
+    const lines = [];
+    if (stripe.status === "ok")
+        lines.push("Stripe: working");
+    else
+        lines.push(`Stripe: ${stripe.message}`);
+    if (duffel.status === "ok")
+        lines.push("Duffel: working");
+    else
+        lines.push(`Duffel: ${duffel.message}`);
+    if (liteapi.status === "ok")
+        lines.push("LiteAPI: working");
+    else
+        lines.push(`LiteAPI: ${liteapi.message}`);
+    const summary = `Commerce health: ${okCount}/${total} services ok.\n${lines.join("\n")}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.commerce_self_test_end",
+        message: "commerce self-test complete",
+        meta: { overall, okCount, total },
+    });
+    return { overall, services, summary };
+}