@ouro.bot/cli 0.1.0-alpha.343 → 0.1.0-alpha.344

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.344",
+      "changes": [
+        "Provider readiness groundwork now has stable machine identity stored at `~/.ouro-cli/machine.json`, preserving random machine IDs across hostname changes while recording aliases for diagnostics.",
+        "Per-agent provider bindings and readiness can now be read, validated, written, and bootstrapped in `<agent>.ouro/state/providers.json` using explicit `outward` and `inner` lanes without storing credentials in bundle state."
+      ]
+    },
     {
       "version": "0.1.0-alpha.343",
       "changes": [

package/dist/heart/machine-identity.js

@@ -0,0 +1,161 @@
+"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.getMachineIdentityPath = getMachineIdentityPath;
+exports.loadOrCreateMachineIdentity = loadOrCreateMachineIdentity;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function nowIso(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+function currentHostname(deps) {
+    return (deps.hostname?.() ?? os.hostname()).trim();
+}
+function defaultRandomId() {
+    return `machine_${crypto.randomUUID()}`;
+}
+function normalizeAliases(value) {
+    if (!Array.isArray(value))
+        return [];
+    const aliases = [];
+    for (const alias of value) {
+        if (typeof alias !== "string")
+            continue;
+        const trimmed = alias.trim();
+        if (trimmed && !aliases.includes(trimmed))
+            aliases.push(trimmed);
+    }
+    return aliases;
+}
+function parseMachineIdentity(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const aliases = normalizeAliases(record.hostnameAliases);
+    if (record.schemaVersion !== 1 ||
+        typeof record.machineId !== "string" ||
+        record.machineId.trim().length === 0 ||
+        typeof record.createdAt !== "string" ||
+        record.createdAt.trim().length === 0 ||
+        typeof record.updatedAt !== "string" ||
+        record.updatedAt.trim().length === 0) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        machineId: record.machineId,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        hostnameAliases: aliases,
+    };
+}
+function writeMachineIdentity(machinePath, identity) {
+    fs.mkdirSync(path.dirname(machinePath), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(machinePath, `${JSON.stringify(identity, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+}
+function getMachineIdentityPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".ouro-cli", "machine.json");
+}
+function loadOrCreateMachineIdentity(deps = {}) {
+    const homeDir = deps.homeDir ?? os.homedir();
+    const machinePath = getMachineIdentityPath(homeDir);
+    const hostname = currentHostname(deps);
+    let existing = null;
+    let hadInvalidFile = false;
+    try {
+        existing = parseMachineIdentity(JSON.parse(fs.readFileSync(machinePath, "utf-8")));
+        if (!existing)
+            hadInvalidFile = true;
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+            ? error.code
+            : undefined;
+        if (code !== "ENOENT")
+            hadInvalidFile = true;
+    }
+    if (hadInvalidFile) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "config/identity",
+            event: "config.machine_identity_invalid",
+            message: "machine identity file is invalid; replacing it",
+            meta: { path: machinePath },
+        });
+    }
+    if (existing) {
+        if (hostname && !existing.hostnameAliases.includes(hostname)) {
+            const updated = {
+                ...existing,
+                updatedAt: nowIso(deps),
+                hostnameAliases: [...existing.hostnameAliases, hostname],
+            };
+            writeMachineIdentity(machinePath, updated);
+            (0, runtime_1.emitNervesEvent)({
+                component: "config/identity",
+                event: "config.machine_identity_alias_added",
+                message: "recorded hostname alias for stable machine identity",
+                meta: { machineId: updated.machineId, hostname },
+            });
+            return updated;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config.machine_identity_loaded",
+            message: "loaded stable machine identity",
+            meta: { machineId: existing.machineId },
+        });
+        return existing;
+    }
+    const timestamp = nowIso(deps);
+    const identity = {
+        schemaVersion: 1,
+        machineId: (deps.randomId?.() ?? defaultRandomId()).trim() || defaultRandomId(),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        hostnameAliases: hostname ? [hostname] : [],
+    };
+    writeMachineIdentity(machinePath, identity);
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.machine_identity_created",
+        message: "created stable machine identity",
+        meta: { machineId: identity.machineId },
+    });
+    return identity;
+}

package/dist/heart/provider-state.js

@@ -0,0 +1,208 @@
+"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.validateProviderState = validateProviderState;
+exports.getProviderStatePath = getProviderStatePath;
+exports.readProviderState = readProviderState;
+exports.writeProviderState = writeProviderState;
+exports.bootstrapProviderStateFromAgentConfig = bootstrapProviderStateFromAgentConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const LANES = ["outward", "inner"];
+const VALID_SOURCES = new Set(["bootstrap", "local"]);
+const VALID_READINESS = new Set(["ready", "failed", "stale", "unknown"]);
+function isProvider(value) {
+    return typeof value === "string" && Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function validateBinding(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    const record = value;
+    if (!isProvider(record.provider))
+        throw new Error(`${label}.provider must be a valid provider`);
+    if (!isNonEmptyString(record.model))
+        throw new Error(`${label}.model must be a non-empty string`);
+    if (!VALID_SOURCES.has(record.source)) {
+        throw new Error(`${label}.source must be bootstrap or local`);
+    }
+    if (!isNonEmptyString(record.updatedAt))
+        throw new Error(`${label}.updatedAt must be a non-empty string`);
+    return {
+        provider: record.provider,
+        model: record.model,
+        source: record.source,
+        updatedAt: record.updatedAt,
+    };
+}
+function validateReadiness(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    const record = value;
+    if (!VALID_READINESS.has(record.status)) {
+        throw new Error(`${label}.status must be ready, failed, stale, or unknown`);
+    }
+    if (!isProvider(record.provider))
+        throw new Error(`${label}.provider must be a valid provider`);
+    if (!isNonEmptyString(record.model))
+        throw new Error(`${label}.model must be a non-empty string`);
+    if (record.checkedAt !== undefined && typeof record.checkedAt !== "string") {
+        throw new Error(`${label}.checkedAt must be a string when present`);
+    }
+    if (record.credentialRevision !== undefined && typeof record.credentialRevision !== "string") {
+        throw new Error(`${label}.credentialRevision must be a string when present`);
+    }
+    if (record.error !== undefined && typeof record.error !== "string") {
+        throw new Error(`${label}.error must be a string when present`);
+    }
+    if (record.attempts !== undefined && typeof record.attempts !== "number") {
+        throw new Error(`${label}.attempts must be a number when present`);
+    }
+    return {
+        status: record.status,
+        provider: record.provider,
+        model: record.model,
+        ...(record.checkedAt !== undefined ? { checkedAt: record.checkedAt } : {}),
+        ...(record.credentialRevision !== undefined ? { credentialRevision: record.credentialRevision } : {}),
+        ...(record.error !== undefined ? { error: record.error } : {}),
+        ...(record.attempts !== undefined ? { attempts: record.attempts } : {}),
+    };
+}
+function validateProviderState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("provider state must be an object");
+    }
+    const record = value;
+    if (record.schemaVersion !== 1)
+        throw new Error("schemaVersion must be 1");
+    if (!isNonEmptyString(record.machineId))
+        throw new Error("machineId must be a non-empty string");
+    if (!isNonEmptyString(record.updatedAt))
+        throw new Error("updatedAt must be a non-empty string");
+    if (!record.lanes || typeof record.lanes !== "object" || Array.isArray(record.lanes)) {
+        throw new Error("lanes must be an object");
+    }
+    const rawLanes = record.lanes;
+    const lanes = {
+        outward: validateBinding(rawLanes.outward, "outward"),
+        inner: validateBinding(rawLanes.inner, "inner"),
+    };
+    if (!record.readiness || typeof record.readiness !== "object" || Array.isArray(record.readiness)) {
+        throw new Error("readiness must be an object");
+    }
+    const rawReadiness = record.readiness;
+    const readiness = {};
+    for (const lane of LANES) {
+        if (rawReadiness[lane] !== undefined) {
+            readiness[lane] = validateReadiness(rawReadiness[lane], `${lane}.readiness`);
+        }
+    }
+    return {
+        schemaVersion: 1,
+        machineId: record.machineId,
+        updatedAt: record.updatedAt,
+        lanes,
+        readiness,
+    };
+}
+function getProviderStatePath(agentRoot) {
+    return path.join(agentRoot, "state", "providers.json");
+}
+function readProviderState(agentRoot) {
+    const statePath = getProviderStatePath(agentRoot);
+    let raw;
+    try {
+        raw = fs.readFileSync(statePath, "utf-8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return { ok: false, reason: "missing", statePath, error: "provider state not found" };
+        }
+        return { ok: false, reason: "invalid", statePath, error: String(error) };
+    }
+    try {
+        const state = validateProviderState(JSON.parse(raw));
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config.provider_state_read",
+            message: "read provider state",
+            meta: { statePath, machineId: state.machineId },
+        });
+        return { ok: true, statePath, state };
+    }
+    catch (error) {
+        return { ok: false, reason: "invalid", statePath, error: String(error) };
+    }
+}
+function writeProviderState(agentRoot, state) {
+    const statePath = getProviderStatePath(agentRoot);
+    const validated = validateProviderState(state);
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, `${JSON.stringify(validated, null, 2)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.provider_state_written",
+        message: "wrote provider state",
+        meta: { statePath, machineId: validated.machineId },
+    });
+}
+function binding(provider, model, updatedAt) {
+    return {
+        provider,
+        model,
+        source: "bootstrap",
+        updatedAt,
+    };
+}
+function bootstrapProviderStateFromAgentConfig(input) {
+    const updatedAt = input.now.toISOString();
+    return {
+        schemaVersion: 1,
+        machineId: input.machineId,
+        updatedAt,
+        lanes: {
+            outward: binding(input.agentConfig.humanFacing.provider, input.agentConfig.humanFacing.model, updatedAt),
+            inner: binding(input.agentConfig.agentFacing.provider, input.agentConfig.agentFacing.model, updatedAt),
+        },
+        readiness: {},
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.343",
+  "version": "0.1.0-alpha.344",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",