nemoris 0.1.0

package/src/runtime/delivery-store.js

@@ -0,0 +1,168 @@
+import path from "node:path";
+import { ensureDir, listFilesRecursive, readJson, writeJson } from "../utils/fs.js";
+import { buildRetentionPolicy, pruneJsonBuckets } from "./retention.js";
+import { createRuntimeId } from "../utils/ids.js";
+
+function stamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function deliveryKey(mode, notificationFilePath, dedupeKey = null) {
+  return dedupeKey ? `${mode}:dedupe:${dedupeKey}` : `${mode}:file:${notificationFilePath}`;
+}
+
+export class DeliveryStore {
+  constructor({ rootDir, retention = {} }) {
+    this.rootDir = rootDir;
+    this.indexPath = path.join(rootDir, "index.json");
+    this.setRetentionPolicy(retention);
+  }
+
+  setRetentionPolicy(retention = {}) {
+    this.retentionPolicy = buildRetentionPolicy(retention, {
+      ttlDays: 14,
+      maxFilesPerBucket: 1000
+    });
+  }
+
+  async loadIndex() {
+    await ensureDir(this.rootDir);
+    return readJson(this.indexPath, { delivered: {} });
+  }
+
+  async saveIndex(index) {
+    await ensureDir(this.rootDir);
+    await writeJson(this.indexPath, index);
+    return index;
+  }
+
+  async isDelivered(mode, notificationFilePath, dedupeKey = null) {
+    const record = await this.getDeliveryRecord(mode, notificationFilePath, dedupeKey);
+    return Boolean(record && ["delivered", "uncertain"].includes(record.status || "delivered"));
+  }
+
+  async getDeliveryRecord(mode, notificationFilePath, dedupeKey = null) {
+    const index = await this.loadIndex();
+    return (
+      index.delivered[deliveryKey(mode, notificationFilePath, dedupeKey)] ||
+      index.delivered[deliveryKey(mode, notificationFilePath)] ||
+      null
+    );
+  }
+
+  async markDelivered(mode, notificationFilePath, receiptFilePath, options = {}) {
+    const index = await this.loadIndex();
+    const current = await this.getDeliveryRecord(mode, notificationFilePath, options.dedupeKey);
+    const record = {
+      id: current?.id || createRuntimeId("delivery-record"),
+      receiptFilePath,
+      deliveredAt: new Date().toISOString(),
+      status: "delivered",
+      dedupeKey: options.dedupeKey || null,
+      retryEligible: false,
+      uncertain: false,
+      attempts: (current?.attempts || 0) + 1,
+      lastError: null
+    };
+    index.delivered[deliveryKey(mode, notificationFilePath)] = record;
+    if (options.dedupeKey) {
+      index.delivered[deliveryKey(mode, notificationFilePath, options.dedupeKey)] = record;
+    }
+    await this.saveIndex(index);
+    return record;
+  }
+
+  async markUncertain(mode, notificationFilePath, receiptFilePath, options = {}) {
+    const index = await this.loadIndex();
+    const current = await this.getDeliveryRecord(mode, notificationFilePath, options.dedupeKey);
+    const record = {
+      id: current?.id || createRuntimeId("delivery-record"),
+      receiptFilePath,
+      deliveredAt: null,
+      status: "uncertain",
+      dedupeKey: options.dedupeKey || null,
+      retryEligible: false,
+      uncertain: true,
+      attempts: (current?.attempts || 0) + 1,
+      lastError: options.error || null,
+      updatedAt: new Date().toISOString()
+    };
+    index.delivered[deliveryKey(mode, notificationFilePath)] = record;
+    if (options.dedupeKey) {
+      index.delivered[deliveryKey(mode, notificationFilePath, options.dedupeKey)] = record;
+    }
+    await this.saveIndex(index);
+    return record;
+  }
+
+  async markFailed(mode, notificationFilePath, receiptFilePath, options = {}) {
+    const index = await this.loadIndex();
+    const current = await this.getDeliveryRecord(mode, notificationFilePath, options.dedupeKey);
+    const record = {
+      id: current?.id || createRuntimeId("delivery-record"),
+      receiptFilePath,
+      deliveredAt: null,
+      status: "failed",
+      dedupeKey: options.dedupeKey || null,
+      retryEligible: options.retryEligible ?? false,
+      uncertain: false,
+      attempts: (current?.attempts || 0) + 1,
+      lastError: options.error || null,
+      updatedAt: new Date().toISOString()
+    };
+    index.delivered[deliveryKey(mode, notificationFilePath)] = record;
+    if (options.dedupeKey) {
+      index.delivered[deliveryKey(mode, notificationFilePath, options.dedupeKey)] = record;
+    }
+    await this.saveIndex(index);
+    return record;
+  }
+
+  async saveReceipt(jobId, receipt) {
+    const receiptDir = path.join(this.rootDir, jobId);
+    await ensureDir(receiptDir);
+    const filePath = path.join(receiptDir, `${stamp()}.json`);
+    await writeJson(filePath, {
+      id: receipt.id || createRuntimeId("delivery-attempt"),
+      ...receipt
+    });
+    await pruneJsonBuckets(this.rootDir, this.retentionPolicy, {
+      excludePaths: [this.indexPath]
+    });
+    return filePath;
+  }
+
+  async listAll() {
+    const files = (await listFilesRecursive(this.rootDir)).filter(
+      (filePath) => filePath.endsWith(".json") && filePath !== this.indexPath
+    );
+    const receipts = [];
+
+    for (const filePath of files) {
+      const data = await readJson(filePath, null);
+      if (!data) continue;
+      receipts.push({
+        filePath,
+        ...data
+      });
+    }
+
+    return receipts.sort((a, b) => String(b.timestamp || "").localeCompare(String(a.timestamp || "")));
+  }
+
+  async listRecent(limit = 10) {
+    const receipts = await this.listAll();
+    return receipts.slice(0, limit);
+  }
+
+  async prune(options = {}) {
+    const result = await pruneJsonBuckets(this.rootDir, this.retentionPolicy, {
+      ...options,
+      excludePaths: [...(options.excludePaths || []), this.indexPath]
+    });
+    return {
+      ...result,
+      indexFilePath: this.indexPath
+    };
+  }
+}

package/src/runtime/dependency-health.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { ConfigLoader } from "../config/loader.js";
+import { ProviderRegistry } from "../providers/registry.js";
+import { PeerReadinessProbe } from "./peer-readiness.js";
+import { Scheduler } from "./scheduler.js";
+
+const execFileAsync = promisify(execFile);
+
+function resolveNamedProfile(profiles, profileName) {
+  if (!profileName) return null;
+  return profiles[profileName] || profiles[String(profileName).replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())] || null;
+}
+
+export class DependencyHealth {
+  constructor({ projectRoot, liveRoot, fetchImpl, execFileImpl } = {}) {
+    this.loader = new ConfigLoader({ rootDir: path.join(projectRoot, "config") });
+    this.registry = new ProviderRegistry({ fetchImpl });
+    this.scheduler = new Scheduler({ projectRoot, liveRoot, stateRoot: path.join(projectRoot, "state") });
+    this.peerProbe = new PeerReadinessProbe({ liveRoot });
+    this.execFileImpl = execFileImpl || execFileAsync;
+  }
+
+  async provider(providerId, runtime = null) {
+    const loaded = runtime || (await this.loader.loadAll());
+    const providerConfig = loaded.providers?.[providerId];
+    if (!providerConfig) {
+      return { providerId, configured: false, reachable: false, failureClass: "provider_missing" };
+    }
+    try {
+      const adapter = this.registry.create(providerConfig);
+      const health = typeof adapter.healthCheck === "function" ? await adapter.healthCheck() : { ok: true, status: null };
+      return {
+        providerId,
+        configured: true,
+        reachable: Boolean(health.ok),
+        status: health.status ?? null,
+        failureClass: health.ok ? null : "provider_unhealthy"
+      };
+    } catch (error) {
+      return {
+        providerId,
+        configured: true,
+        reachable: false,
+        status: null,
+        failureClass: error.failureClass || error.networkClass || "provider_unreachable",
+        error: error.message
+      };
+    }
+  }
+
+  async probeGatewayHealth() {
+    try {
+      await this.execFileImpl("openclaw", ["--version"], { timeout: 5000, maxBuffer: 64 * 1024 });
+      return { ok: true };
+    } catch (error) {
+      const code = error.code || "";
+      if (code === "ENOENT") {
+        return { ok: false, reason: "openclaw CLI binary not found on PATH." };
+      }
+      if (code === "ETIMEDOUT" || error.killed) {
+        return { ok: false, reason: "openclaw CLI timed out; the gateway may be stalled." };
+      }
+      return { ok: false, reason: `openclaw CLI probe failed: ${error.message || code}` };
+    }
+  }
+
+  async delivery(profileName, runtime = null) {
+    const loaded = runtime || (await this.loader.loadAll());
+    const profile = resolveNamedProfile(loaded.delivery?.profiles || {}, profileName);
+    if (!profile) {
+      return { profileName, configured: false, reachable: false, failureClass: "delivery_profile_missing" };
+    }
+    const adapter = profile.adapter || null;
+    let reachable = true;
+    let failureClass = null;
+    const findings = [];
+    if (adapter === "openclaw_cli" || adapter === "openclaw_peer") {
+      const probeResult = await this.probeGatewayHealth();
+      reachable = probeResult.ok;
+      if (!reachable) {
+        failureClass = "delivery_gateway_unreachable";
+        findings.push(probeResult.reason || "OpenClaw gateway is not reachable for delivery.");
+      }
+    }
+    return {
+      profileName,
+      configured: true,
+      adapter,
+      reachable,
+      failureClass: reachable ? null : (failureClass || "delivery_not_ready"),
+      findings
+    };
+  }
+
+  async peer(peerId, runtime = null) {
+    const loaded = runtime || (await this.loader.loadAll());
+    return this.peerProbe.probe(loaded, peerId);
+  }
+
+  async forJob(jobId) {
+    const runtime = await this.loader.loadAll();
+    const plan = await this.scheduler.hydrateJob(jobId, { shadowImport: false });
+    const primaryProviderId = String(plan.routing.selectedLane || "").startsWith("openrouter")
+      ? "openrouter"
+      : null;
+    const providerId = plan.routing.selectedLane === "local_report" || plan.routing.selectedLane === "local_cheap"
+      ? "ollama"
+      : primaryProviderId || "anthropic";
+
+    const fallbackProfile = plan.agent.deliveryProfile || runtime.delivery?.defaultInteractiveProfile || null;
+    return {
+      provider: await this.provider(providerId, runtime),
+      delivery: await this.delivery(fallbackProfile, runtime)
+    };
+  }
+}

package/src/runtime/envelope.js

@@ -0,0 +1,114 @@
+import { ulid } from "./ulid.js";
+
+export class EnvelopeStore {
+  constructor(db, stateStore = null) {
+    this.db = db;
+    this.stateStore = stateStore;
+    this._ensureSchema();
+  }
+
+  _ensureSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS envelopes (
+        id              TEXT PRIMARY KEY,
+        correlation_id  TEXT,
+        source_agent    TEXT,
+        criticality     TEXT NOT NULL,
+        created_at      TEXT NOT NULL,
+        ack_status      TEXT NOT NULL DEFAULT 'pending',
+        ack_updated_at  TEXT,
+        payload_type    TEXT NOT NULL,
+        payload         TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_envelopes_correlation ON envelopes(correlation_id);
+      CREATE INDEX IF NOT EXISTS idx_envelopes_ack_status ON envelopes(ack_status);
+      CREATE INDEX IF NOT EXISTS idx_envelopes_source_agent ON envelopes(source_agent);
+    `);
+  }
+
+  create({ sourceAgent, criticality, payloadType, payload, correlationId = null }) {
+    const id = ulid();
+    const now = new Date().toISOString();
+    const payloadJson = JSON.stringify(payload);
+    this.db.prepare(`
+      INSERT INTO envelopes (id, correlation_id, source_agent, criticality, created_at, ack_status, payload_type, payload)
+      VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)
+    `).run(id, correlationId, sourceAgent, criticality, now, payloadType, payloadJson);
+    return this.get(id);
+  }
+
+  get(id) {
+    return this.db.prepare("SELECT * FROM envelopes WHERE id = ?").get(id) || null;
+  }
+
+  list({ limit = 50, ackStatus = null } = {}) {
+    if (ackStatus) {
+      return this.db.prepare("SELECT * FROM envelopes WHERE ack_status = ? ORDER BY created_at DESC LIMIT ?").all(ackStatus, limit);
+    }
+    return this.db.prepare("SELECT * FROM envelopes ORDER BY created_at DESC LIMIT ?").all(limit);
+  }
+
+  updateAck(id, newStatus) {
+    const now = new Date().toISOString();
+    const result = this.db.prepare(`
+      UPDATE envelopes SET ack_status = ?, ack_updated_at = ?
+      WHERE id = ? AND ack_status != 'dead_letter'
+    `).run(newStatus, now, id);
+    return result.changes > 0;
+  }
+
+  prune(retentionDays = 30) {
+    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+    const result = this.db.prepare(`
+      DELETE FROM envelopes
+      WHERE created_at < ? AND ack_status IN ('delivered', 'responded')
+    `).run(cutoff);
+    return result.changes;
+  }
+
+  getSchemaVersion() {
+    if (!this.stateStore) return 1;
+    const row = this.stateStore.db.prepare(
+      "SELECT value_json FROM scheduler_meta WHERE key = ?"
+    ).get("schema_version");
+    return row ? parseInt(JSON.parse(row.value_json), 10) : 1;
+  }
+
+  setSchemaVersion(version) {
+    if (!this.stateStore) return;
+    this.stateStore.db.prepare(`
+      INSERT INTO scheduler_meta(key, value_json) VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json
+    `).run("schema_version", JSON.stringify(version));
+  }
+
+  runBackfill(stateStore, taskContract) {
+    const version = this.getSchemaVersion();
+    if (version >= 2) return { backfilled: 0, skipped: true };
+
+    let backfilled = 0;
+    try {
+      const inFlight = stateStore.db.prepare(`
+        SELECT * FROM interactive_jobs
+        WHERE triggered_by IS NOT NULL AND status IN ('queued', 'running')
+      `).all();
+
+      for (const job of inFlight) {
+        if (taskContract) {
+          try {
+            taskContract.createTask({
+              ownerAgent: job.triggered_by,
+              assignedAgent: job.agent_id,
+              objective: (job.input || "migrated task").slice(0, 500),
+              deadlineMinutes: 30,
+            });
+            backfilled++;
+          } catch { /* skip if creation fails */ }
+        }
+      }
+    } catch { /* table may not have these columns */ }
+
+    this.setSchemaVersion(2);
+    return { backfilled, skipped: false };
+  }
+}