@ouro.bot/cli 0.1.0-alpha.50 → 0.1.0-alpha.500

package/dist/heart/outlook/readers/sessions.js

@@ -0,0 +1,232 @@
+"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.readSessionInventory = readSessionInventory;
+exports.readSessionTranscript = readSessionTranscript;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const identity_1 = require("../../identity");
+const session_events_1 = require("../../session-events");
+const shared_1 = require("./shared");
+/* v8 ignore start — session envelope parsing utilities */
+function parseSessionUsage(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const record = raw;
+    const inputTokens = typeof record.input_tokens === "number" ? record.input_tokens : 0;
+    const outputTokens = typeof record.output_tokens === "number" ? record.output_tokens : 0;
+    const reasoningTokens = typeof record.reasoning_tokens === "number" ? record.reasoning_tokens : 0;
+    const totalTokens = typeof record.total_tokens === "number" ? record.total_tokens : 0;
+    if (inputTokens === 0 && outputTokens === 0 && totalTokens === 0)
+        return null;
+    return { input_tokens: inputTokens, output_tokens: outputTokens, reasoning_tokens: reasoningTokens, total_tokens: totalTokens };
+}
+function parseSessionContinuity(raw) {
+    if (!raw)
+        return null;
+    if (typeof raw !== "object")
+        return null;
+    const record = raw;
+    const continuity = {
+        mustResolveBeforeHandoff: record.mustResolveBeforeHandoff === true,
+        lastFriendActivityAt: typeof record.lastFriendActivityAt === "string" ? record.lastFriendActivityAt : null,
+    };
+    if (!continuity.mustResolveBeforeHandoff && continuity.lastFriendActivityAt === null)
+        return null;
+    return continuity;
+}
+function extractContent(event) {
+    if (!event)
+        return null;
+    const text = (0, session_events_1.extractEventText)(event);
+    return text.length > 0 ? text : null;
+}
+function extractToolCallNames(event) {
+    if (!event)
+        return [];
+    return event.toolCalls
+        .map((call) => call.function.name)
+        .filter((name) => typeof name === "string" && name.length > 0);
+}
+/* v8 ignore stop */
+function estimateTokenCount(messages) {
+    let charCount = 0;
+    for (const msg of messages) {
+        const content = extractContent(msg);
+        if (content)
+            charCount += content.length;
+        if (msg.toolCalls.length > 0)
+            charCount += JSON.stringify(msg.toolCalls).length;
+    }
+    return Math.ceil(charCount / 4);
+}
+/* v8 ignore start — filesystem traversal with defensive isDirectory checks */
+function resolveAllSessionPaths(sessionsDir) {
+    const results = [];
+    if (!(0, shared_1.safeIsDirectory)(sessionsDir))
+        return results;
+    for (const friendId of (0, shared_1.safeReaddir)(sessionsDir)) {
+        const friendDir = path.join(sessionsDir, friendId);
+        if (!(0, shared_1.safeIsDirectory)(friendDir))
+            continue;
+        for (const channel of (0, shared_1.safeReaddir)(friendDir)) {
+            const channelDir = path.join(friendDir, channel);
+            if (!(0, shared_1.safeIsDirectory)(channelDir))
+                continue;
+            for (const file of (0, shared_1.safeReaddir)(channelDir)) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const key = file.slice(0, -5);
+                results.push({
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath: path.join(channelDir, file),
+                });
+            }
+        }
+    }
+    return results;
+}
+/* v8 ignore stop */
+/* v8 ignore start — defensive parsing */
+function readSessionInventory(agentName, options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const now = options.now?.() ?? new Date();
+    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
+    const sessionsDir = path.join(agentRoot, "state", "sessions");
+    const friendsDir = path.join(agentRoot, "friends");
+    const allSessions = resolveAllSessionPaths(sessionsDir);
+    const items = [];
+    for (const { friendId, channel, key, sessionPath } of allSessions) {
+        if (friendId === "self" && channel === "inner")
+            continue;
+        const envelope = (0, shared_1.readSessionEnvelope)(sessionPath);
+        const events = envelope?.events ?? [];
+        const chronology = (0, session_events_1.deriveSessionChronology)(events);
+        const lastUsage = parseSessionUsage(envelope?.lastUsage);
+        const continuity = parseSessionContinuity(envelope?.state);
+        const hasObservedEventTiming = events.some((event) => event.time.authoredAt !== null || event.time.observedAt !== null);
+        const lastActivityAt = hasObservedEventTiming
+            ? (chronology.lastActivityAt ?? continuity?.lastFriendActivityAt ?? (0, shared_1.safeFileMtime)(sessionPath) ?? now.toISOString())
+            : (continuity?.lastFriendActivityAt ?? (0, shared_1.safeFileMtime)(sessionPath) ?? now.toISOString());
+        const activitySource = hasObservedEventTiming && chronology.lastActivityAt
+            ? "event-timeline"
+            : continuity?.lastFriendActivityAt
+                ? "friend-facing"
+                : "mtime-fallback";
+        const userMessages = events.filter((m) => m.role === "user");
+        const assistantMessages = events.filter((m) => m.role === "assistant");
+        const lastUser = userMessages.length > 0 ? userMessages[userMessages.length - 1] : null;
+        const lastAssistant = assistantMessages.length > 0 ? assistantMessages[assistantMessages.length - 1] : null;
+        const latestToolCallNames = [];
+        for (let i = events.length - 1; i >= 0; i--) {
+            const names = extractToolCallNames(events[i]);
+            if (names.length > 0) {
+                latestToolCallNames.push(...names);
+                break;
+            }
+        }
+        const friendName = (0, shared_1.resolveFriendName)(friendsDir, friendId);
+        const lastMsg = events.length > 0 ? events[events.length - 1] : null;
+        const mustResolve = continuity?.mustResolveBeforeHandoff === true;
+        let replyState = "idle";
+        if (mustResolve) {
+            replyState = "on-hold";
+        }
+        else if (lastMsg?.role === "user") {
+            replyState = "needs-reply";
+        }
+        else if (events.length > 0) {
+            replyState = "monitoring";
+        }
+        items.push({
+            friendId,
+            friendName,
+            channel,
+            key,
+            sessionPath,
+            lastActivityAt,
+            activitySource,
+            replyState,
+            messageCount: events.length,
+            lastUsage,
+            continuity,
+            latestUserExcerpt: (0, shared_1.truncateExcerpt)(extractContent(lastUser)),
+            latestAssistantExcerpt: (0, shared_1.truncateExcerpt)(extractContent(lastAssistant)),
+            latestToolCallNames,
+            estimatedTokens: events.length > 0 ? estimateTokenCount(events) : null,
+        });
+    }
+    items.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
+    const ageThreshold = now.getTime() - shared_1.STALE_THRESHOLD_MS;
+    const activeCount = items.filter((item) => Date.parse(item.lastActivityAt) >= ageThreshold).length;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_sessions_read",
+        message: "reading outlook session inventory",
+        meta: { agentName, totalCount: items.length, activeCount },
+    });
+    return {
+        totalCount: items.length,
+        activeCount,
+        staleCount: items.length - activeCount,
+        items,
+    };
+}
+function readSessionTranscript(agentName, friendId, channel, key, options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
+    const sessionPath = path.join(agentRoot, "state", "sessions", friendId, channel, `${key}.json`);
+    const envelope = (0, shared_1.readSessionEnvelope)(sessionPath);
+    if (!envelope)
+        return null;
+    // Use full event history (envelope + archive) for complete transcript
+    const rawMessages = (0, session_events_1.loadFullEventHistory)(sessionPath);
+    const friendsDir = path.join(agentRoot, "friends");
+    const friendName = (0, shared_1.resolveFriendName)(friendsDir, friendId);
+    const messages = rawMessages;
+    return {
+        friendId,
+        friendName,
+        channel,
+        key,
+        sessionPath,
+        messageCount: messages.length,
+        lastUsage: parseSessionUsage(envelope.lastUsage),
+        continuity: parseSessionContinuity(envelope.state),
+        messages,
+    };
+}

package/dist/heart/outlook/readers/shared.js

@@ -0,0 +1,111 @@
+"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.STALE_THRESHOLD_MS = exports.BLOCKED_CODING_STATUSES = exports.ACTIVE_CODING_STATUSES = void 0;
+exports.issue = issue;
+exports.safeReaddir = safeReaddir;
+exports.safeIsDirectory = safeIsDirectory;
+exports.resolveFriendName = resolveFriendName;
+exports.safeFileMtime = safeFileMtime;
+exports.truncateExcerpt = truncateExcerpt;
+exports.readSessionEnvelope = readSessionEnvelope;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const session_events_1 = require("../../session-events");
+exports.ACTIVE_CODING_STATUSES = new Set(["spawning", "running", "waiting_input", "stalled"]);
+exports.BLOCKED_CODING_STATUSES = new Set(["waiting_input", "stalled"]);
+exports.STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function issue(code, detail) {
+    return { code, detail };
+}
+function safeReaddir(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function safeIsDirectory(filePath) {
+    try {
+        return fs.statSync(filePath).isDirectory();
+        /* v8 ignore start */
+    }
+    catch {
+        return false;
+    }
+    /* v8 ignore stop */
+}
+/* v8 ignore start — defensive friend name resolution */
+function resolveFriendName(friendsDir, friendId) {
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+/* v8 ignore stop */
+/* v8 ignore start — utility helpers with defensive branches */
+function safeFileMtime(filePath) {
+    try {
+        return fs.statSync(filePath).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+function truncateExcerpt(content, maxLength = 200) {
+    if (!content)
+        return null;
+    if (content.length <= maxLength)
+        return content;
+    const truncated = content.slice(0, maxLength);
+    const lastSpace = truncated.lastIndexOf(" ");
+    return (lastSpace > maxLength * 0.6 ? truncated.slice(0, lastSpace) : truncated) + "…";
+}
+/* v8 ignore stop */
+function readSessionEnvelope(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_session_envelope_read",
+        message: "reading outlook session envelope",
+        meta: { sessionPath },
+    });
+    return (0, session_events_1.loadSessionEnvelopeFile)(sessionPath);
+}

package/dist/heart/platform.js

@@ -0,0 +1,81 @@
+"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.detectPlatform = detectPlatform;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function detectPlatform(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const readFile = deps.readFileSync ?? ((p) => fs.readFileSync(p, "utf-8"));
+    let result;
+    if (platform === "darwin") {
+        result = "macos";
+    }
+    else if (platform === "win32") {
+        result = "windows-native";
+    }
+    else if (platform === "linux") {
+        result = detectLinuxOrWsl(env, readFile);
+    }
+    else {
+        // Unknown platform — treat as linux
+        result = "linux";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.platform_detected",
+        message: "detected platform",
+        meta: { platform, result },
+    });
+    return result;
+}
+function detectLinuxOrWsl(env, readFile) {
+    // Primary: WSL_DISTRO_NAME env var
+    if (env.WSL_DISTRO_NAME && env.WSL_DISTRO_NAME.length > 0) {
+        return "wsl";
+    }
+    // Fallback: /proc/version containing "microsoft" (case-insensitive)
+    try {
+        const procVersion = readFile("/proc/version");
+        if (/microsoft/i.test(procVersion)) {
+            return "wsl";
+        }
+    }
+    catch {
+        // /proc/version not readable — not WSL
+    }
+    return "linux";
+}

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 };
+}