@inetafrica/open-claudia 3.5.0 → 3.5.4

package/channels/kazee/state.js

@@ -4,19 +4,29 @@
 // "messages since I last engaged" delta and advances it on every engage, so
 // group chatter the gate stayed silent through is caught up exactly once.
 // Parent-process only; small, atomic writes.
+//
+// Chat threads ("reply in thread") keep their own small record, keyed by the
+// thread's root message id: whether the bot has replied in it (a group thread
+// the bot is part of engages it without an @-mention), who posted the root
+// (fetched once, so the gate never asks twice), and the thread's own context
+// watermark. Bounded: the least recently touched threads are dropped first.
 
 const path = require("path");
 const { CONFIG_DIR } = require("../../core/config");
 const { atomicWriteFileSync, readJsonWithFallback } = require("../../core/fsutil");
 
 const STATE_FILE = path.join(CONFIG_DIR, "kazee-state.json");
+const MAX_THREADS = 2000;
 
 let store = null;
 
 function load() {
   if (store) return store;
   const raw = readJsonWithFallback(STATE_FILE, null) || {};
-  store = { chats: raw.chats && typeof raw.chats === "object" ? raw.chats : {} };
+  store = {
+    chats: raw.chats && typeof raw.chats === "object" ? raw.chats : {},
+    threads: raw.threads && typeof raw.threads === "object" && !Array.isArray(raw.threads) ? raw.threads : {},
+  };
   return store;
 }
 
@@ -39,4 +49,70 @@ function getContextWatermark(chatId) {
   return (c && c.contextAt) || null;
 }
 
-module.exports = { setContextWatermark, getContextWatermark, STATE_FILE };
+function getThread(rootId) {
+  const s = load();
+  const t = s.threads[String(rootId || "")];
+  return t && typeof t === "object" ? t : null;
+}
+
+// Merge `patch` into the thread's record. Writes only when something changed,
+// so the per-send "the bot replied here" mark costs one write per thread.
+function updateThread(rootId, patch = {}) {
+  const id = String(rootId || "");
+  if (!id) return null;
+  const s = load();
+  const prev = s.threads[id] || {};
+  const changed = Object.keys(patch).some((k) => patch[k] !== undefined && prev[k] !== patch[k]);
+  if (!changed) return prev;
+  const next = { ...prev };
+  for (const [k, v] of Object.entries(patch)) if (v !== undefined) next[k] = v;
+  next.at = Date.now();
+  s.threads[id] = next;
+  const ids = Object.keys(s.threads);
+  if (ids.length > MAX_THREADS) {
+    ids.sort((a, b) => (Number(s.threads[a].at) || 0) - (Number(s.threads[b].at) || 0));
+    for (const old of ids.slice(0, ids.length - MAX_THREADS)) delete s.threads[old];
+  }
+  save();
+  return next;
+}
+
+function markBotRepliedInThread(chatId, rootId) {
+  return updateThread(rootId, { chatId: String(chatId || ""), botReplied: true });
+}
+
+function botRepliedInThread(rootId) {
+  return getThread(rootId)?.botReplied === true;
+}
+
+function setThreadRootAuthor(chatId, rootId, authorId) {
+  if (!authorId) return null;
+  return updateThread(rootId, { chatId: String(chatId || ""), rootAuthor: String(authorId) });
+}
+
+function getThreadRootAuthor(rootId) {
+  return getThread(rootId)?.rootAuthor || null;
+}
+
+function setThreadWatermark(chatId, rootId, iso) {
+  if (!iso) return null;
+  return updateThread(rootId, { chatId: String(chatId || ""), contextAt: String(iso) });
+}
+
+function getThreadWatermark(rootId) {
+  return getThread(rootId)?.contextAt || null;
+}
+
+module.exports = {
+  setContextWatermark,
+  getContextWatermark,
+  getThread,
+  markBotRepliedInThread,
+  botRepliedInThread,
+  setThreadRootAuthor,
+  getThreadRootAuthor,
+  setThreadWatermark,
+  getThreadWatermark,
+  STATE_FILE,
+  MAX_THREADS,
+};

package/channels/types.js

@@ -19,7 +19,10 @@
  * @property {string} type            // "text" | "voice" | "audio" | "photo" | "document" | "action"
  * @property {string} [text]          // command text or message body
  * @property {string} [messageId]     // outer-channel message id
- * @property {string} [replyToId]     // id of message being replied to
+ * @property {string} [replyToId]     // id of message being replied to (a quote, not a thread)
+ * @property {string} [threadId]      // chat thread root id when the message was posted IN a thread
+ *                                    // (Kazee "reply in thread"); null/absent = the main timeline.
+ *                                    // A thread is its own conversation: own session, queue and lane.
  * @property {Object} [reply]         // {text, media?: MediaRef[], document, photo} for reply context
  * @property {Array<MediaRef>} [media]
  * @property {Object} [from]          // {id, name, username}
@@ -38,6 +41,8 @@
  *                                    // (telegram-native, accepted by both adapters)
  *                                    // or {buttons:[PortableButton]} (portable)
  * @property {string|number} [replyTo]
+ * @property {string} [threadId]      // post into this chat thread (Kazee threadRootId); core/io
+ *                                    // fills it from the turn's thread unless set explicitly
  *
  * @typedef {Object} CommandSpec
  * @property {string} name            // no leading slash
@@ -53,10 +58,11 @@
  *   send(channelId, text, opts): Promise<messageId|null>
  *   edit(channelId, messageId, text, opts): Promise<void>
  *   delete(channelId, messageId): Promise<void>
- *   sendVoice(channelId, oggPath): Promise<boolean>
- *   sendFile(channelId, filePath, caption?): Promise<boolean>
- *   typing(channelId, state?): Promise<void>  // state: "thinking" | "typing" (default). Non-socket channels ignore state.
- *   typingStop?(channelId): Promise<void>     // optional — socket channels only
+ *   sendVoice(channelId, oggPath, opts?): Promise<boolean>          // opts.threadId: post into that thread
+ *   sendFile(channelId, filePath, caption?, opts?): Promise<boolean> // opts.threadId: post into that thread
+ *   typing(channelId, state?, opts?): Promise<void>  // state: "thinking" | "typing" (default). Non-socket channels ignore state.
+ *                                             // opts.threadId: show the indicator inside that thread
+ *   typingStop?(channelId, opts?): Promise<void>     // optional — socket channels only
  *   downloadMedia(mediaRef): Promise<localPath|null>
  *   buildThreadContext?(envelope): Promise<{contextBlock: string, media?: MediaRef[]}|null>
  *   registerCommands(commands: CommandSpec[]): Promise<void>

package/core/actions.js

@@ -622,6 +622,7 @@ async function handleAction(envelope) {
           adapter: "",
           adapterType: rec.adapter,
           channelId: String(rec.channelId),
+          threadId: rec.threadId || null,
           canonicalUserId: rec.canonicalUserId,
           userId: rec.userId || null,
           provider: rec.provider,
@@ -692,6 +693,9 @@ async function handleAction(envelope) {
           adapter: isExternalAction ? "" : (rec.adapter || (adapter && adapter.id) || ""),
           adapterType: isExternalAction ? (rec.adapter || (adapter && adapter.type)) : (adapter && adapter.type),
           channelId: String(rec.channelId || envelope.channelId),
+          // Back into the thread the held run was in (the press itself may
+          // come from another room: the owner's approver channel).
+          threadId: rec.threadId || (rec.channelId ? null : envelope.threadId || null),
           canonicalUserId: rec.canonicalUserId,
           userId: rec.userId || null,
           provider: rec.provider,
@@ -991,6 +995,8 @@ async function handleAction(envelope) {
       adapter: envelope.adapter.id,
       adapterType: envelope.adapter.type,
       channelId: String(envelope.channelId),
+      // A preset picked in a thread fires in that thread.
+      threadId: envelope.threadId || null,
       canonicalUserId: envelope.canonicalUserId,
       project: cronProject,
       prompt: p.prompt,

package/core/approvals.js

@@ -19,6 +19,7 @@ const path = require("path");
 const crypto = require("crypto");
 const CONFIG_DIR = require("../config-dir");
 const { atomicWriteFileSync } = require("./fsutil");
+const { currentChannelId, currentThreadId } = require("./context");
 
 const APPROVALS_DIR = process.env.APPROVALS_DIR || path.join(CONFIG_DIR, "approvals");
 const MAX_AGE_MS = 24 * 60 * 60 * 1000;
@@ -124,17 +125,25 @@ function create({
   // room holds many people they are different values, so recording only the
   // room would hand one member's grant to everyone in it.
   speakerId = "", room = "",
+  // The chat thread of the ORIGIN turn (null = main timeline), so a re-run
+  // this approval wakes lands back in that thread. Unset: taken from the
+  // current turn when it is in the origin channel.
+  threadId = undefined,
 } = {}) {
   fs.mkdirSync(APPROVALS_DIR, { recursive: true, mode: 0o700 });
   prune();
   const id = `apr_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
   const exactCommand = approvedCommand(command);
+  const originThread = threadId !== undefined
+    ? threadId
+    : (currentThreadId() && String(currentChannelId() || "") === String(channelId || "") ? currentThreadId() : null);
   const rec = {
     id, status: "pending",
     tool: String(tool || ""), verb: String(verb || ""), tier: String(tier || ""),
     command: exactCommand,
     commandHash: commandHash(exactCommand),
     channelId: String(channelId || ""), adapter: String(adapter || ""),
+    threadId: originThread ? String(originThread) : null,
     canonicalUserId: String(canonicalUserId || ""), userId: String(userId || ""),
     provider: String(provider || ""), providerSettings: providerSettings && typeof providerSettings === "object" ? structuredClone(providerSettings) : {},
     project: String(project || ""), projectDir: String(projectDir || ""),

package/core/bot-endpoint.js

@@ -0,0 +1,194 @@
+// Which loopback endpoint may a CLI believe about WHO it acts for?
+//
+// Owner-only CLI verbs and staff tool writes are decided by asking the bot
+// (whoami, tool-gate). The address to ask comes from this process's env
+// (OC_SEND_URL), and a staff turn's shell can point that at a server of its
+// own that answers "owner" (Phase 0 review, CRITICAL). So an endpoint is
+// believed for those answers only when:
+//   1. the process LISTENING on it is this process or one of its ancestors —
+//      the bot spawns every run, so the real bot is always above the CLI,
+//      while a server a turn starts is beside it at best; and
+//   2. nothing above that listener was STARTED with OC_GUARDED_RUN=1 in its
+//      environment — the listener was not itself started inside a staff turn
+//      (such a server could run the CLI as its own child, making itself an
+//      ancestor). A process's start-up environment is fixed by whoever spawned
+//      it; a turn's shell cannot rewrite its provider's.
+// Linux reads /proc; macOS asks /bin/ps and /usr/sbin/lsof by absolute path
+// (PATH belongs to the caller). Anything that cannot be established is a
+// refusal, and a refused caller is unattributed — never the owner.
+//
+// Residual, closed by Phase 2's tool-only staff turns: a staff shell that
+// detaches a server from its turn and runs the CLI beneath that server is no
+// longer below the guarded provider, so rule 2 cannot see it.
+
+const fs = require("fs");
+const { execFileSync } = require("child_process");
+
+const MAX_DEPTH = 64;
+const PS = "/bin/ps";
+const LSOF = "/usr/sbin/lsof";
+const EXEC_TIMEOUT_MS = 5000;
+
+function parsePort(url) {
+  let parsed;
+  try { parsed = new URL(String(url)); } catch (_) { return null; }
+  if (parsed.protocol !== "http:") return null;
+  if (parsed.hostname !== "127.0.0.1" && parsed.hostname !== "localhost") return null;
+  const port = Number(parsed.port);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
+
+// ── Linux: /proc ─────────────────────────────────────────────────────────────
+// The loopback binds 127.0.0.1 itself, never a wildcard, and nothing else can
+// bind that exact address and port while it listens (no SO_REUSEPORT), so the
+// only listener that counts is an IPv4 127.0.0.1 socket. /proc/net/tcp shows
+// the address as little-endian hex.
+const LINUX_LOOPBACK_HEX = "0100007F";
+
+function linuxSystem(procRoot = "/proc") {
+  return {
+    parentOf(pid) {
+      const stat = fs.readFileSync(`${procRoot}/${pid}/stat`, "utf8");
+      // "pid (comm) state ppid ..." — comm may hold spaces and parentheses.
+      const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+      const ppid = Number(fields[1]);
+      return Number.isInteger(ppid) ? ppid : null;
+    },
+    // The pid in `pids` that owns the 127.0.0.1:port listening socket, else null.
+    listenerAmong(port, pids) {
+      const inodes = new Set();
+      const text = fs.readFileSync(`${procRoot}/net/tcp`, "utf8");
+      for (const line of text.split("\n").slice(1)) {
+        const cols = line.trim().split(/\s+/);
+        if (cols.length < 10 || cols[3] !== "0A") continue; // 0A = LISTEN
+        const [addr, portHex] = cols[1].split(":");
+        if (addr === LINUX_LOOPBACK_HEX && parseInt(portHex, 16) === port) inodes.add(cols[9]);
+      }
+      if (!inodes.size) return null;
+      for (const pid of pids) {
+        let fds = [];
+        try { fds = fs.readdirSync(`${procRoot}/${pid}/fd`); } catch (_) { continue; }
+        for (const fd of fds) {
+          let link = "";
+          try { link = fs.readlinkSync(`${procRoot}/${pid}/fd/${fd}`); } catch (_) { continue; }
+          const match = /^socket:\[(\d+)\]$/.exec(link);
+          if (match && inodes.has(match[1])) return pid;
+        }
+      }
+      return null;
+    },
+    startEnvHas(pid, key, value) {
+      const raw = fs.readFileSync(`${procRoot}/${pid}/environ`, "utf8");
+      return raw.split("\0").includes(`${key}=${value}`);
+    },
+  };
+}
+
+// ── macOS: /bin/ps + /usr/sbin/lsof ─────────────────────────────────────────
+function run(file, args) {
+  return execFileSync(file, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: EXEC_TIMEOUT_MS,
+    maxBuffer: 64 * 1024 * 1024,
+    env: { PATH: "/usr/bin:/bin:/usr/sbin:/sbin", LANG: "C", LC_ALL: "C" },
+  });
+}
+
+function darwinSystem() {
+  let parents = null;
+  return {
+    parentOf(pid) {
+      if (!parents) {
+        parents = new Map();
+        for (const line of run(PS, ["-Ao", "pid=,ppid="]).split("\n")) {
+          const [p, pp] = line.trim().split(/\s+/).map(Number);
+          if (Number.isInteger(p) && Number.isInteger(pp)) parents.set(p, pp);
+        }
+      }
+      return parents.has(pid) ? parents.get(pid) : null;
+    },
+    listenerAmong(port, pids) {
+      let out = "";
+      try { out = run(LSOF, ["-nP", "-a", "-p", pids.join(","), `-iTCP@127.0.0.1:${port}`, "-sTCP:LISTEN", "-Fpn"]); }
+      catch (error) {
+        // Exit 1 whenever some listed pid matched nothing (or is another
+        // user's); what did match is still on stdout.
+        if (!error || error.status !== 1) throw error;
+        out = String(error.stdout || "");
+      }
+      const owners = new Set();
+      let current = null;
+      for (const line of out.split("\n")) {
+        if (line.startsWith("p")) current = Number(line.slice(1));
+        else if (line === `n127.0.0.1:${port}` && current != null) owners.add(current);
+      }
+      for (const pid of pids) if (owners.has(pid)) return pid;
+      return null;
+    },
+    // ps -E prints the command line followed by the environment the process
+    // started with; the environment is what follows the plain command line.
+    startEnvHas(pid, key, value) {
+      const withEnv = run(PS, ["-E", "-ww", "-o", "command=", "-p", String(pid)]).replace(/\n+$/, "");
+      const bare = run(PS, ["-ww", "-o", "command=", "-p", String(pid)]).replace(/\n+$/, "");
+      if (!withEnv.startsWith(bare)) return false;
+      return withEnv.slice(bare.length).split(" ").includes(`${key}=${value}`);
+    },
+  };
+}
+
+function currentSystem() {
+  if (process.platform === "linux") return linuxSystem();
+  if (process.platform === "darwin") return darwinSystem();
+  return null;
+}
+
+function ancestry(pid, system) {
+  const chain = [pid];
+  let current = pid;
+  while (chain.length < MAX_DEPTH) {
+    const parent = system.parentOf(current);
+    if (!Number.isInteger(parent) || parent <= 0 || chain.includes(parent)) break;
+    chain.push(parent);
+    current = parent;
+  }
+  return chain;
+}
+
+function refuse(reason) {
+  return { ok: false, reason };
+}
+
+// { ok: true, url, port, listenerPid } when `url` may be believed about who
+// this process acts for; { ok: false, reason } otherwise.
+function verifyEndpoint(url, { pid = process.pid, system = currentSystem() } = {}) {
+  const port = parsePort(url);
+  if (!port) return refuse("the loopback address is not a 127.0.0.1 endpoint");
+  if (!system) return refuse(`cannot inspect processes on ${process.platform}`);
+  let chain;
+  let listener;
+  try {
+    chain = ancestry(pid, system);
+    listener = system.listenerAmong(port, chain);
+  } catch (error) {
+    return refuse(`cannot read the process tree (${error && error.message ? error.message : error})`);
+  }
+  if (listener == null) return refuse("the loopback endpoint is not served by this process or an ancestor");
+  for (const above of chain.slice(chain.indexOf(listener) + 1)) {
+    let guarded = false;
+    // Unreadable = another user's process, never a guarded provider (the bot
+    // starts providers as its own user).
+    try { guarded = system.startEnvHas(above, "OC_GUARDED_RUN", "1") === true; } catch (_) { guarded = false; }
+    if (guarded) return refuse("the loopback endpoint was started inside a guarded (non-owner) run");
+  }
+  return { ok: true, url: `http://127.0.0.1:${port}`, port, listenerPid: listener };
+}
+
+const verified = new Map();
+function verifyEndpointCached(url) {
+  const key = String(url || "");
+  if (!verified.has(key)) verified.set(key, verifyEndpoint(url));
+  return verified.get(key);
+}
+
+module.exports = { verifyEndpoint, verifyEndpointCached, parsePort, linuxSystem, darwinSystem, ancestry };

package/core/context.js

@@ -6,8 +6,8 @@ const { AsyncLocalStorage } = require("node:async_hooks");
 
 const chatContext = new AsyncLocalStorage();
 
-function runInChat({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup }, fn) {
-  return chatContext.run({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup: !!isGroup }, fn);
+function runInChat({ adapter, channelId, threadId, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup }, fn) {
+  return chatContext.run({ adapter, channelId, threadId: threadId ? String(threadId) : null, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup: !!isGroup }, fn);
 }
 
 function currentStore() {
@@ -24,6 +24,14 @@ function currentChannelId() {
   return s ? s.channelId : null;
 }
 
+// The chat thread this turn belongs to (a Kazee thread's root message id), or
+// null for the channel's main timeline. A thread is its own conversation: its
+// own session, transcript, queue and run lane, and every reply goes back into it.
+function currentThreadId() {
+  const s = currentStore();
+  return s && s.threadId ? s.threadId : null;
+}
+
 function currentCanonicalUserId() {
   const s = currentStore();
   return s ? s.canonicalUserId : null;
@@ -114,6 +122,7 @@ module.exports = {
   runInChat,
   currentAdapter,
   currentChannelId,
+  currentThreadId,
   currentCanonicalUserId,
   currentUserId,
   currentTransport,