@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/heart/migrate-config.js

@@ -0,0 +1,100 @@
+"use strict";
+// v1 → v2 agent.json migration.
+// Creates explicit humanFacing/agentFacing blocks from the legacy provider.
+// Uses raw fs and provider-model defaults — NO import from config.ts.
+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.migrateAgentConfigV1ToV2 = migrateAgentConfigV1ToV2;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const provider_models_1 = require("./provider-models");
+function isAgentProvider(value) {
+    return value === "azure" ||
+        value === "minimax" ||
+        value === "anthropic" ||
+        value === "openai-codex" ||
+        value === "github-copilot";
+}
+function migrateAgentConfigV1ToV2(agentRoot) {
+    const configPath = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return; // No agent.json — nothing to migrate
+    }
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Cannot parse agent.json at ${configPath} — invalid JSON`);
+    }
+    const version = typeof config.version === "number" ? config.version : 1;
+    if (version >= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config_identity.migrate_skip",
+            message: "agent config already v2, skipping migration",
+            meta: { agentRoot },
+        });
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_start",
+        message: "migrating agent config v1 → v2",
+        meta: { agentRoot },
+    });
+    const provider = isAgentProvider(config.provider) ? config.provider : "anthropic";
+    const model = (0, provider_models_1.getDefaultModelForProvider)(provider);
+    // Write v2 config
+    const { provider: _removed, ...rest } = config;
+    const v2Config = {
+        ...rest,
+        version: 2,
+        humanFacing: { provider, model },
+        agentFacing: { provider, model },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(v2Config, null, 2) + "\n", "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_end",
+        message: "agent config migration complete",
+        meta: { agentRoot, provider, model },
+    });
+}

package/dist/heart/model-capabilities.js

@@ -8,22 +8,41 @@ exports.MODEL_CAPABILITIES = {
         reasoningEffort: ["low", "medium", "high", "max"],
         thinkingFormat: "anthropic",
         maxOutputTokens: 128000,
+        vision: true,
     },
     "claude-sonnet-4-6": {
         reasoningEffort: ["low", "medium", "high"],
         thinkingFormat: "anthropic",
         maxOutputTokens: 64000,
+        vision: true,
+    },
+    "claude-opus-4.6": {
+        reasoningEffort: ["low", "medium", "high", "max"],
+        maxOutputTokens: 128000,
+        vision: true,
+    },
+    "claude-sonnet-4.6": {
+        reasoningEffort: ["low", "medium", "high"],
+        maxOutputTokens: 64000,
+        vision: true,
     },
     "gpt-5.4": {
         reasoningEffort: ["low", "medium", "high"],
         phase: true,
         maxOutputTokens: 100000,
+        vision: true,
     },
     "gpt-5.3-codex": {
         reasoningEffort: ["low", "medium", "high"],
         phase: true,
         maxOutputTokens: 100000,
     },
+    "MiniMax-Text-01": {
+        vision: true,
+    },
+    "MiniMax-VL-01": {
+        vision: true,
+    },
 };
 const EMPTY_CAPABILITIES = Object.freeze({});
 function getModelCapabilities(modelId) {

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

package/dist/heart/provider-binding-resolver.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProviderLane = normalizeProviderLane;
+exports.resolveEffectiveProviderBinding = resolveEffectiveProviderBinding;
+const runtime_1 = require("../nerves/runtime");
+const provider_credentials_1 = require("./provider-credentials");
+const provider_state_1 = require("./provider-state");
+function legacyLaneWarning(selector, lane) {
+    return {
+        code: "legacy-lane-selector",
+        message: `${selector} is legacy provider wording; using ${lane} lane`,
+    };
+}
+function normalizeProviderLane(selector) {
+    switch (selector) {
+        case "outward":
+            return { lane: "outward", warnings: [] };
+        case "inner":
+            return { lane: "inner", warnings: [] };
+        case "human":
+        case "humanFacing":
+            return { lane: "outward", warnings: [legacyLaneWarning(selector, "outward")] };
+        case "agent":
+        case "agentFacing":
+            return { lane: "inner", warnings: [legacyLaneWarning(selector, "inner")] };
+    }
+}
+function buildUseRepair(agentName, lane, force = false) {
+    return {
+        command: `ouro use --agent ${agentName} --lane ${lane} --provider <provider> --model <model>${force ? " --force" : ""}`,
+        message: force
+            ? `Rewrite this machine's ${lane} provider binding for ${agentName}.`
+            : `Choose the provider/model this machine should use for ${agentName}'s ${lane} lane.`,
+    };
+}
+function buildAuthRepair(agentName, provider) {
+    return {
+        command: `ouro auth --agent ${agentName} --provider ${provider}`,
+        message: `Store ${provider} credentials in ${agentName}'s vault.`,
+    };
+}
+function missingProviderStateWarning(agentName) {
+    return {
+        code: "provider-state-missing",
+        message: `No local provider binding exists for ${agentName} on this machine.`,
+    };
+}
+function invalidProviderStateWarning(agentName) {
+    return {
+        code: "provider-state-invalid",
+        message: `Local provider binding state for ${agentName} is invalid.`,
+    };
+}
+function missingCredentialWarning(provider) {
+    return {
+        code: "credential-missing",
+        message: `${provider} has no credential record in the agent vault.`,
+    };
+}
+function invalidCredentialPoolWarning(provider) {
+    return {
+        code: "credential-pool-invalid",
+        message: `${provider} cannot read credentials from the agent vault.`,
+    };
+}
+function presentCredential(record) {
+    return {
+        status: "present",
+        provider: record.provider,
+        revision: record.revision,
+        source: record.provenance.source,
+        updatedAt: record.updatedAt,
+        credentialFields: Object.keys(record.credentials).sort(),
+        configFields: Object.keys(record.config).sort(),
+    };
+}
+function resolveCredential(poolResult, provider, agentName) {
+    if (poolResult.ok) {
+        const record = poolResult.pool.providers[provider];
+        if (record)
+            return { credential: presentCredential(record), warnings: [] };
+        return {
+            credential: {
+                status: "missing",
+                provider,
+                poolPath: poolResult.poolPath,
+                repair: buildAuthRepair(agentName, provider),
+            },
+            warnings: [missingCredentialWarning(provider)],
+        };
+    }
+    if ((0, provider_credentials_1.isProviderCredentialPoolNotLoaded)(poolResult)) {
+        return {
+            credential: {
+                status: "not-loaded",
+                provider,
+                poolPath: poolResult.poolPath,
+            },
+            warnings: [],
+        };
+    }
+    if (poolResult.reason === "invalid" || poolResult.reason === "unavailable") {
+        return {
+            credential: {
+                status: "invalid-pool",
+                provider,
+                poolPath: poolResult.poolPath,
+                error: poolResult.error,
+                repair: buildAuthRepair(agentName, provider),
+            },
+            warnings: [invalidCredentialPoolWarning(provider)],
+        };
+    }
+    return {
+        credential: {
+            status: "missing",
+            provider,
+            poolPath: poolResult.poolPath,
+            repair: buildAuthRepair(agentName, provider),
+        },
+        warnings: [missingCredentialWarning(provider)],
+    };
+}
+function readinessFromState(readiness) {
+    return {
+        status: readiness.status,
+        checkedAt: readiness.checkedAt,
+        credentialRevision: readiness.credentialRevision,
+        error: readiness.error,
+        attempts: readiness.attempts,
+    };
+}
+function staleReadiness(readiness, reason) {
+    return {
+        ...readinessFromState(readiness),
+        status: "stale",
+        previousStatus: readiness.status,
+        reason,
+    };
+}
+function resolveReadiness(input) {
+    if (!input.readiness) {
+        if (input.credential.status === "not-loaded") {
+            return { readiness: { status: "unknown" }, warnings: [] };
+        }
+        if (input.credential.status === "missing") {
+            return { readiness: { status: "unknown", reason: "credential-missing" }, warnings: [] };
+        }
+        if (input.credential.status === "invalid-pool") {
+            return { readiness: { status: "unknown", reason: "credential-pool-invalid" }, warnings: [] };
+        }
+        return { readiness: { status: "unknown" }, warnings: [] };
+    }
+    if (input.readiness.provider !== input.provider || input.readiness.model !== input.model) {
+        return {
+            readiness: staleReadiness(input.readiness, "provider-model-changed"),
+            warnings: [{
+                    code: "readiness-stale",
+                    message: `${input.provider}/${input.model} readiness is stale because the last check was for ${input.readiness.provider}/${input.readiness.model}.`,
+                }],
+        };
+    }
+    if (input.credential.status === "present"
+        && input.readiness.credentialRevision !== undefined
+        && input.readiness.credentialRevision !== input.credential.revision) {
+        return {
+            readiness: staleReadiness(input.readiness, "credential-revision-changed"),
+            warnings: [{
+                    code: "readiness-stale",
+                    message: `${input.provider}/${input.model} readiness is stale because credential revision changed from ${input.readiness.credentialRevision} to ${input.credential.revision}.`,
+                }],
+        };
+    }
+    if (input.credential.status === "missing") {
+        return {
+            readiness: staleReadiness(input.readiness, "credential-missing"),
+            warnings: [],
+        };
+    }
+    if (input.credential.status === "invalid-pool") {
+        return {
+            readiness: staleReadiness(input.readiness, "credential-pool-invalid"),
+            warnings: [],
+        };
+    }
+    if (input.credential.status === "not-loaded") {
+        return { readiness: readinessFromState(input.readiness), warnings: [] };
+    }
+    return { readiness: readinessFromState(input.readiness), warnings: [] };
+}
+function resolveEffectiveProviderBinding(input) {
+    const laneResolution = normalizeProviderLane(input.lane);
+    const stateResult = (0, provider_state_1.readProviderState)(input.agentRoot);
+    if (!stateResult.ok) {
+        const reason = stateResult.reason === "missing" ? "provider-state-missing" : "provider-state-invalid";
+        const stateWarning = stateResult.reason === "missing"
+            ? missingProviderStateWarning(input.agentName)
+            : invalidProviderStateWarning(input.agentName);
+        const result = {
+            ok: false,
+            lane: laneResolution.lane,
+            reason,
+            statePath: stateResult.statePath,
+            warnings: [...laneResolution.warnings, stateWarning],
+            repair: buildUseRepair(input.agentName, laneResolution.lane, stateResult.reason === "invalid"),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config.provider_binding_resolution_failed",
+            message: "provider binding resolution failed",
+            meta: { agentName: input.agentName, lane: laneResolution.lane, reason },
+        });
+        return result;
+    }
+    const laneBinding = stateResult.state.lanes[laneResolution.lane];
+    const poolResult = (0, provider_credentials_1.readProviderCredentialPool)(input.agentName);
+    const credentialResult = resolveCredential(poolResult, laneBinding.provider, input.agentName);
+    const readinessResult = resolveReadiness({
+        provider: laneBinding.provider,
+        model: laneBinding.model,
+        readiness: stateResult.state.readiness[laneResolution.lane],
+        credential: credentialResult.credential,
+    });
+    const warnings = [
+        ...laneResolution.warnings,
+        ...credentialResult.warnings,
+        ...readinessResult.warnings,
+    ];
+    const binding = {
+        lane: laneResolution.lane,
+        provider: laneBinding.provider,
+        model: laneBinding.model,
+        source: laneBinding.source,
+        machineId: stateResult.state.machineId,
+        statePath: stateResult.statePath,
+        credential: credentialResult.credential,
+        readiness: readinessResult.readiness,
+        warnings,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.provider_binding_resolved",
+        message: "resolved effective provider binding",
+        meta: {
+            agentName: input.agentName,
+            lane: binding.lane,
+            provider: binding.provider,
+            model: binding.model,
+            credentialStatus: binding.credential.status,
+            readinessStatus: binding.readiness.status,
+            warningCount: warnings.length,
+        },
+    });
+    return { ok: true, binding };
+}