@inetafrica/open-claudia 2.14.8 → 3.0.0

package/core/lessons.js

@@ -24,6 +24,7 @@
 const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
+const { atomicWriteFileSync } = require("./fsutil");
 
 const CONFIG_DIR = require("../config-dir");
 const LESSONS_FILE = process.env.LESSONS_FILE ? path.resolve(process.env.LESSONS_FILE) : path.join(CONFIG_DIR, "lessons.md");
@@ -93,7 +94,7 @@ function readMeta() {
 
 function writeMeta(meta) {
   fs.mkdirSync(path.dirname(LESSONS_META_FILE), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(LESSONS_META_FILE, JSON.stringify(meta, null, 2) + "\n", { mode: 0o600 });
+  atomicWriteFileSync(LESSONS_META_FILE, JSON.stringify(meta, null, 2) + "\n", { mode: 0o600, backup: true });
 }
 
 // Self-heal: drop meta for lessons that no longer exist, seed defaults for
@@ -128,7 +129,7 @@ function writeLessons(lessons) {
   const body = lessons.map(lessonLine).join("\n");
   const content = FILE_HEADER + "\n" + body + (body ? "\n" : "");
   fs.mkdirSync(path.dirname(LESSONS_FILE), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(LESSONS_FILE, content, { mode: 0o600 });
+  atomicWriteFileSync(LESSONS_FILE, content, { mode: 0o600, backup: true });
   return LESSONS_FILE;
 }
 

package/core/loopback.js

@@ -1,8 +1,9 @@
 // Bot ↔ subprocess send channel. Each running bot publishes a tiny HTTP
 // server on 127.0.0.1:<random-port> and writes {port, token} to a
 // per-PID file under CONFIG_DIR/loopback. Subprocesses spawned through
-// runClaude inherit OC_SEND_URL, OC_SEND_TOKEN, OC_CHANNEL_ID, and
-// OC_CHANNEL_ADAPTER in their env; the `open-claudia send-file /
+// runAgent inherit OC_SEND_URL, OC_SEND_TOKEN, OC_CHANNEL_ID, and
+// OC_CHANNEL_ADAPTER plus immutable provider/project/session/run metadata in
+// their env; the `open-claudia send-file /
 // send-voice / send-photo` CLI subcommands POST a file back through
 // this endpoint so the active channel's adapter can deliver it.
 //
@@ -169,13 +170,24 @@ async function handleJson(req, res, url, kind) {
       adapterType: adapter.type,
       channelId,
       canonicalUserId: payload.canonicalUserId || null,
+      userId: payload.userId || null,
+      provider: payload.provider || null,
+      providerSettings: payload.providerSettings || {},
       project: payload.project || null,
+      projectDir: payload.projectDir || null,
       prompt: String(payload.prompt),
       label: String(payload.label || payload.prompt).slice(0, 60),
       source: payload.source || "agent",
       fireAt,
-      sessionKey: payload.sessionKey || null,
       sessionId: payload.sessionId || null,
+      previousSessionId: payload.previousSessionId || null,
+      originRunId: payload.originRunId || null,
+      sessionLineage: {
+        originRunId: payload.originRunId || null,
+        originSessionId: payload.sessionId || null,
+        previousSessionId: payload.previousSessionId || null,
+        originProject: payload.originProject || payload.project || null,
+      },
     });
     return reply(res, 200, { ok: true, job });
   }
@@ -188,13 +200,24 @@ async function handleJson(req, res, url, kind) {
       adapterType: adapter.type,
       channelId,
       canonicalUserId: payload.canonicalUserId || null,
+      userId: payload.userId || null,
+      provider: payload.provider || null,
+      providerSettings: payload.providerSettings || {},
       project: payload.project || null,
+      projectDir: payload.projectDir || null,
       prompt: String(payload.prompt),
       label: String(payload.label || payload.prompt).slice(0, 60),
       source: payload.source || "agent",
       schedule: String(payload.schedule),
-      sessionKey: payload.sessionKey || null,
       sessionId: payload.sessionId || null,
+      previousSessionId: payload.previousSessionId || null,
+      originRunId: payload.originRunId || null,
+      sessionLineage: {
+        originRunId: payload.originRunId || null,
+        originSessionId: payload.sessionId || null,
+        previousSessionId: payload.previousSessionId || null,
+        originProject: payload.originProject || payload.project || null,
+      },
     });
     return reply(res, 200, { ok: true, job });
   }
@@ -208,7 +231,11 @@ async function handleJson(req, res, url, kind) {
 
   if (kind === "job-list") {
     const list = jobsStore.listForChannel(adapterId, channelId);
-    return reply(res, 200, { ok: true, jobs: list });
+    // Archived legacy jobs often predate channel metadata — show the
+    // channel-less ones too rather than hiding them everywhere.
+    const archived = (jobsStore.listArchived ? jobsStore.listArchived() : [])
+      .filter((job) => !job.channelId || String(job.channelId) === String(channelId));
+    return reply(res, 200, { ok: true, jobs: list, archived });
   }
 
   if (kind === "task-add") {
@@ -496,11 +523,20 @@ async function handleJson(req, res, url, kind) {
       const rec = approvals.create({
         tool: payload.tool, verb: payload.verb || "", tier: payload.tier || "destructive",
         command: payload.command, channelId, adapter: adapterId,
+        canonicalUserId: payload.canonicalUserId || null,
+        userId: payload.userId || null,
+        provider: payload.provider || null,
+        providerSettings: payload.providerSettings || {},
+        project: payload.project || null,
+        projectDir: payload.projectDir || null,
+        sessionId: payload.sessionId || null,
+        previousSessionId: payload.previousSessionId || null,
+        originRunId: payload.originRunId || null,
       });
       const text = [
         `🔐 Destructive tool run wants approval:`,
         ``,
-        `<pre>${String(payload.command).slice(0, 800).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</pre>`,
+        `<pre>${String(rec.command).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</pre>`,
         ``,
         `Tool: ${payload.tool}${payload.verb ? ` · verb: ${payload.verb}` : ""} · tier: ${rec.tier}`,
         `This is the literal command that will execute. Decide within ~90s to run it inline; after that the agent moves on, but your Approve/Deny stays valid for 24h and wakes it back up.`,
@@ -512,8 +548,9 @@ async function handleJson(req, res, url, kind) {
       // <pre> needs Telegram's HTML parse mode to render; other adapters ignore it.
       const sendOpts = { keyboard };
       if (adapter.type === "telegram") sendOpts.parseMode = "HTML";
-      const ok = await adapter.send(channelId, text, sendOpts);
-      if (!ok) { approvals.decide(rec.id, "denied", "send-failed"); return reply(res, 500, { error: "could not deliver approval prompt" }); }
+      const { normalizeSendResult } = require("./io");
+      const sent = normalizeSendResult(await adapter.send(channelId, text, sendOpts));
+      if (!sent.ok) { approvals.decide(rec.id, "denied", "send-failed"); return reply(res, 500, { error: "could not deliver approval prompt" }); }
       audit.log("tool.approval.requested", { id: rec.id, tool: rec.tool, verb: rec.verb, channelId });
       return reply(res, 200, { ok: true, id: rec.id });
     } catch (e) { return reply(res, 400, { error: e.message }); }

package/core/memory-mutation-queue.js

@@ -0,0 +1,241 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../config-dir");
+
+const DEFAULT_MAX_PENDING = 50;
+const DEFAULT_LOCK_TIMEOUT_MS = 30 * 1000;
+const DEFAULT_LOCK_POLL_MS = 25;
+const DEFAULT_STALE_LOCK_MS = 30 * 60 * 1000;
+const DEFAULT_DRAIN_TIMEOUT_MS = 5000;
+
+class MutationQueueError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "MutationQueueError";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+
+function positiveInteger(value, fallback, label) {
+  if (value === undefined || value === null || value === "") return fallback;
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number < 1) throw new TypeError(`${label} must be a positive integer`);
+  return number;
+}
+
+function safeLabel(value) {
+  return String(value || "memory-mutation")
+    .replace(/[^a-zA-Z0-9_.:-]+/g, "-")
+    .slice(0, 80) || "memory-mutation";
+}
+
+function safeMetadata(metadata) {
+  const result = {};
+  for (const key of ["provider", "model", "purpose", "runId", "trigger"]) {
+    if (metadata?.[key] == null) continue;
+    result[key] = String(metadata[key]).slice(0, 160);
+  }
+  return result;
+}
+
+function ownerIsAlive(lockDir) {
+  let owner;
+  try { owner = JSON.parse(fs.readFileSync(path.join(lockDir, "owner.json"), "utf8")); }
+  catch (_) { return false; }
+  const pid = Number(owner?.pid);
+  if (!Number.isSafeInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+class MemoryMutationQueue {
+  constructor(options = {}) {
+    this.lockDir = options.lockDir || path.join(CONFIG_DIR, "memory-mutation.lock");
+    this.journalFile = options.journalFile || path.join(CONFIG_DIR, "memory-mutation-intents.jsonl");
+    this.maxPending = positiveInteger(options.maxPending, DEFAULT_MAX_PENDING, "maxPending");
+    this.lockTimeoutMs = positiveInteger(options.lockTimeoutMs, DEFAULT_LOCK_TIMEOUT_MS, "lockTimeoutMs");
+    this.lockPollMs = positiveInteger(options.lockPollMs, DEFAULT_LOCK_POLL_MS, "lockPollMs");
+    this.staleLockMs = positiveInteger(options.staleLockMs, DEFAULT_STALE_LOCK_MS, "staleLockMs");
+    this.accepting = true;
+    this.stopReason = null;
+    this.pending = new Map();
+    this.chain = Promise.resolve();
+  }
+
+  record(entry) {
+    const line = {
+      at: new Date().toISOString(),
+      queuePid: process.pid,
+      ...entry,
+    };
+    delete line.payload;
+    try {
+      fs.mkdirSync(path.dirname(this.journalFile), { recursive: true, mode: 0o700 });
+      fs.appendFileSync(this.journalFile, `${JSON.stringify(line)}\n`, { mode: 0o600 });
+    } catch (_) { /* intent telemetry must not break the guarded mutation */ }
+    return line;
+  }
+
+  async acquireLock(entry) {
+    const started = Date.now();
+    const token = `${process.pid}-${entry.id}-${crypto.randomBytes(6).toString("hex")}`;
+    while (true) {
+      try {
+        fs.mkdirSync(this.lockDir, { recursive: false, mode: 0o700 });
+        try {
+          fs.writeFileSync(path.join(this.lockDir, "owner.json"), `${JSON.stringify({ token, pid: process.pid, id: entry.id, at: new Date().toISOString() })}\n`, { mode: 0o600 });
+        } catch (error) {
+          try { fs.rmSync(this.lockDir, { recursive: true, force: true }); } catch (_) {}
+          throw error;
+        }
+        return token;
+      } catch (error) {
+        if (error.code !== "EEXIST") {
+          throw new MutationQueueError("MEMORY_MUTATION_LOCK_FAILED", `Unable to acquire memory mutation lock: ${error.message}`);
+        }
+      }
+
+      try {
+        const age = Date.now() - fs.statSync(this.lockDir).mtimeMs;
+        if (age > this.staleLockMs && !ownerIsAlive(this.lockDir)) {
+          fs.rmSync(this.lockDir, { recursive: true, force: true });
+        }
+      } catch (_) { /* another process may have released it */ }
+      if (Date.now() - started >= this.lockTimeoutMs) {
+        throw new MutationQueueError("MEMORY_MUTATION_LOCK_TIMEOUT", "Timed out waiting for the shared memory mutation lock", {
+          label: entry.label,
+        });
+      }
+      await delay(this.lockPollMs);
+    }
+  }
+
+  releaseLock(token) {
+    try {
+      const owner = JSON.parse(fs.readFileSync(path.join(this.lockDir, "owner.json"), "utf8"));
+      if (owner.token !== token) return;
+    } catch (_) { return; }
+    try { fs.rmSync(this.lockDir, { recursive: true, force: true }); } catch (_) {}
+  }
+
+  enqueue(label, task, metadata = {}) {
+    const normalizedLabel = safeLabel(label);
+    if (typeof task !== "function") return Promise.reject(new TypeError("memory mutation task must be a function"));
+    if (!this.accepting) {
+      const error = new MutationQueueError("MEMORY_MUTATION_QUEUE_CLOSED", "Memory mutation admission is closed", {
+        label: normalizedLabel,
+        reason: this.stopReason,
+      });
+      this.record({ id: null, label: normalizedLabel, status: "rejected_closed", reason: this.stopReason });
+      return Promise.reject(error);
+    }
+    if (this.pending.size >= this.maxPending) {
+      const error = new MutationQueueError("MEMORY_MUTATION_QUEUE_FULL", "Memory mutation queue is full", {
+        label: normalizedLabel,
+        maxPending: this.maxPending,
+      });
+      this.record({ id: null, label: normalizedLabel, status: "rejected_full" });
+      return Promise.reject(error);
+    }
+
+    const id = typeof crypto.randomUUID === "function"
+      ? crypto.randomUUID()
+      : `${Date.now()}-${crypto.randomBytes(8).toString("hex")}`;
+    const entry = {
+      id,
+      label: normalizedLabel,
+      metadata: safeMetadata(metadata),
+      admittedAt: Date.now(),
+      promise: null,
+    };
+    this.record({ id, label: normalizedLabel, status: "admitted", ...entry.metadata });
+
+    const execute = async () => {
+      let token = null;
+      try {
+        token = await this.acquireLock(entry);
+        this.record({ id, label: normalizedLabel, status: "started", ...entry.metadata });
+        const result = await task({ id, label: normalizedLabel, metadata: { ...entry.metadata } });
+        this.record({ id, label: normalizedLabel, status: "completed", ...entry.metadata });
+        return result;
+      } catch (error) {
+        this.record({
+          id,
+          label: normalizedLabel,
+          status: "failed",
+          code: String(error.code || "MEMORY_MUTATION_FAILED").slice(0, 80),
+          reason: String(error.message || "memory mutation failed").slice(0, 240),
+          ...entry.metadata,
+        });
+        throw error;
+      } finally {
+        if (token) this.releaseLock(token);
+      }
+    };
+
+    const promise = this.chain.then(execute, execute);
+    entry.promise = promise;
+    this.pending.set(id, entry);
+    this.chain = promise.then(() => undefined, () => undefined);
+    promise.then(
+      () => this.pending.delete(id),
+      () => this.pending.delete(id),
+    );
+    return promise;
+  }
+
+  stopAdmission(reason = "shutdown") {
+    if (!this.accepting) return false;
+    this.accepting = false;
+    this.stopReason = String(reason || "shutdown").slice(0, 160);
+    this.record({ id: null, label: "queue", status: "admission_stopped", reason: this.stopReason });
+    return true;
+  }
+
+  async drain(options = {}) {
+    const timeoutMs = positiveInteger(options.timeoutMs, DEFAULT_DRAIN_TIMEOUT_MS, "drain timeoutMs");
+    const snapshot = [...this.pending.values()];
+    if (!snapshot.length) return { drained: true, pending: [] };
+    let timer;
+    const completed = Promise.allSettled(snapshot.map((entry) => entry.promise)).then(() => true);
+    const timed = new Promise((resolve) => { timer = setTimeout(() => resolve(false), timeoutMs); });
+    const drained = await Promise.race([completed, timed]);
+    clearTimeout(timer);
+    if (drained) return { drained: true, pending: [] };
+    const pending = snapshot
+      .filter((entry) => this.pending.has(entry.id))
+      .map((entry) => ({ id: entry.id, label: entry.label, ...entry.metadata }));
+    for (const entry of pending) {
+      this.record({ ...entry, status: "pending_on_shutdown", reason: this.stopReason || "bounded drain timed out" });
+    }
+    return { drained: false, pending };
+  }
+
+  stats() {
+    return {
+      accepting: this.accepting,
+      pending: this.pending.size,
+      active: [...this.pending.values()].map((entry) => ({ id: entry.id, label: entry.label, ...entry.metadata })),
+    };
+  }
+}
+
+const memoryMutationQueue = new MemoryMutationQueue();
+
+module.exports = {
+  DEFAULT_DRAIN_TIMEOUT_MS,
+  DEFAULT_MAX_PENDING,
+  MemoryMutationQueue,
+  MutationQueueError,
+  memoryMutationQueue,
+};