@inetafrica/open-claudia 3.5.0 → 3.5.4

package/core/scheduler.js

@@ -32,8 +32,10 @@ const {
   getProviderSession,
   getProviderSettings,
   getUserState,
+  peekLane,
+  laneBusy,
 } = require("./state");
-const { canonicalForChannel, conversationKeyFor } = require("./identity");
+const { canonicalForChannel, conversationKeyFor, parseConversationKey } = require("./identity");
 const { send: defaultSend } = require("./io");
 const { providerStatus: defaultProviderStatus } = require("./providers");
 const { redactSensitive } = require("./redact");
@@ -74,15 +76,17 @@ function uniqueId(prefix = "occ") {
 }
 
 // ── watch-check environment ────────────────────────────────────────────────
-// A watch's `check` runs a shell command. It used to inherit `env:
-// process.env` — every secret the bot process holds (provider credentials,
-// bot tokens, the loopback token), so a staff member's check could read them
-// all. Build the env explicitly instead: keep the harmless shell essentials
-// and the Open Claudia config dir (so `open-claudia ...` resolves its config),
-// then drop anything that looks like a credential (a broad denylist pattern)
-// plus the known-secret names the provider env-isolation layer already
-// strips. A short-lived, creator-scoped run is stamped on top (below) so the
-// check's reusable tools still attribute to whoever created the watch.
+// A watch's `check` runs a shell command in the bot's process tree. Whose
+// environment it gets depends on who set the watch:
+//   • a staff member's check gets an ALLOWLIST — the shell essentials and the
+//     Open Claudia config dir, nothing else — plus OC_GUARDED_RUN=1 so hooks
+//     and CLIs below it know they run for a non-owner. A denylist was not
+//     enough: any credential whose name matched no pattern (DATABASE_URL,
+//     MONGO_URI, …) reached a staff check (Phase 0 review, MEDIUM);
+//   • the owner's check keeps the bot's environment as it always had, so an
+//     owner watch that reads a credential from env keeps working.
+// Either way a short-lived, creator-scoped run is stamped on top (below) so
+// the check's reusable tools attribute to whoever created the watch.
 const WATCH_CHECK_ENV_KEEP = new Set([
   "PATH", "HOME", "USER", "LOGNAME", "SHELL",
   "LANG", "LANGUAGE", "LC_ALL", "LC_CTYPE", "TZ",
@@ -91,34 +95,29 @@ const WATCH_CHECK_ENV_KEEP = new Set([
   "OPEN_CLAUDIA_CONFIG_DIR",
   "SystemRoot", "ComSpec", "PATHEXT", "WINDIR",
 ]);
-const WATCH_CHECK_SECRET_PATTERN = /(TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|APIKEY|OAUTH|CREDENTIAL|PRIVATE[_-]?KEY|ACCESS[_-]?KEY|CLIENT[_-]?SECRET|SESSION[_-]?KEY|BEARER)/i;
-let KNOWN_SECRET_ENV_KEYS = null;
-function knownSecretEnvKeys() {
-  if (KNOWN_SECRET_ENV_KEYS) return KNOWN_SECRET_ENV_KEYS;
-  const set = new Set();
-  try { for (const key of require("./providers/env").ALWAYS_STRIPPED_KEYS) set.add(key); } catch (_) {}
-  KNOWN_SECRET_ENV_KEYS = set;
-  return set;
-}
-function isSecretCheckEnvKey(key) {
-  if (WATCH_CHECK_ENV_KEEP.has(key)) return false;
-  if (knownSecretEnvKeys().has(key)) return true;
-  return WATCH_CHECK_SECRET_PATTERN.test(key);
-}
-function buildWatchCheckEnv(source, stamp = {}) {
+function buildWatchCheckEnv(source, stamp = {}, { owner = false } = {}) {
   const env = {};
   for (const [key, value] of Object.entries(source || {})) {
     if (value == null) continue;
-    if (isSecretCheckEnvKey(key)) continue;
+    if (!owner && !WATCH_CHECK_ENV_KEEP.has(key)) continue;
     env[key] = String(value);
   }
   for (const [key, value] of Object.entries(stamp)) {
     if (value == null || value === "") continue;
     env[key] = String(value);
   }
+  if (owner) delete env.OC_GUARDED_RUN;
+  else env.OC_GUARDED_RUN = "1";
   return env;
 }
 
+// The chat thread a job answers in: stored on the job when it was created in a
+// thread, else read off its conversation key (older jobs, CLI-made jobs).
+function jobThreadId(job) {
+  if (!job) return null;
+  return job.threadId || parseConversationKey(job.project).threadId || null;
+}
+
 // The principal a watch-check's short-lived run acts for: the job's creator,
 // resolved from its stored channel/user the same way runPrincipal resolves a
 // turn's speaker. Owner → the check attributes as the owner (unchanged); a
@@ -146,6 +145,7 @@ function watchCheckPrincipal(job) {
     adapterId: job && job.adapter ? String(job.adapter) : null,
     adapterType,
     channelId,
+    threadId: jobThreadId(job),
     userId,
     room,
   };
@@ -248,7 +248,7 @@ function createSchedulerService(dependencies = {}) {
   }
   // Poll a watch's `check`: exit 0 → the watched condition is met, wake the
   // agent; non-zero → still idle, skip silently. Runs in the job's project
-  // dir with a HARDENED env — the bot's secrets are dropped (buildWatchCheckEnv)
+  // dir with its creator's env (buildWatchCheckEnv: an allowlist for staff)
   // and a short-lived run is registered for the job's creator so reusable
   // tools attribute correctly — output discarded (exit code is the contract),
   // hard-capped by WATCH_CHECK_TIMEOUT_MS. Injectable so tests stay hermetic.
@@ -256,13 +256,14 @@ function createSchedulerService(dependencies = {}) {
     const cwd = (job && projectDescriptor(job).dir) || workspace || process.cwd();
     const attest = require("./speaker-attest");
     const checkRunId = uniqueId("watch-check");
+    const principal = watchCheckPrincipal(job);
     let runAttest = "";
-    try { runAttest = attest.registerRun(checkRunId, watchCheckPrincipal(job)); } catch (_) { runAttest = ""; }
+    try { runAttest = attest.registerRun(checkRunId, principal); } catch (_) { runAttest = ""; }
     let lb = null;
     try { lb = require("./loopback").info(); } catch (_) { lb = null; }
     const stamp = { OC_RUN_ID: checkRunId, OC_RUN_ATTEST: runAttest };
     if (lb && lb.url) { stamp.OC_SEND_URL = lb.url; stamp.OC_SEND_TOKEN = lb.token; }
-    const env = buildWatchCheckEnv(process.env, stamp);
+    const env = buildWatchCheckEnv(process.env, stamp, { owner: principal.owner === true });
     let settled = false;
     const finish = (code, timedOut) => {
       if (settled) return;
@@ -308,8 +309,26 @@ function createSchedulerService(dependencies = {}) {
     return { name, dir: dir || workspace || process.cwd() };
   }
 
+  // The session of the main timeline of the room a thread job belongs to.
+  function roomMainSession(state, job) {
+    if (!jobThreadId(job)) return null;
+    const threadRoom = parseConversationKey(job.project).threadId ? parseConversationKey(job.project).roomKey : null;
+    const roomKey = threadRoom || (job.adapterType && job.channelId ? conversationKeyFor(job.adapterType, job.channelId) : null);
+    if (!roomKey || roomKey === job.project) return null;
+    return getProviderSession(state, job.provider, roomKey) || null;
+  }
+
   function resolveCompactionLineage(state, job) {
     let sessionId = job.sessionId || null;
+    // A thread job never resumes its room's MAIN session: a job made in a
+    // thread's first (forked) turn by an older build stored the main id, and
+    // resuming it would write the thread's wakeup into the main conversation,
+    // possibly beside a live main turn. Use the thread's own session instead.
+    const mainSession = sessionId ? roomMainSession(state, job) : null;
+    if (mainSession && sessionId === mainSession) {
+      const own = getProviderSession(state, job.provider, job.project);
+      sessionId = own && own !== mainSession ? own : null;
+    }
     if (!sessionId) return { sessionId: null, attachSession: true };
     const seen = new Set();
     while (sessionId && !seen.has(sessionId)) {
@@ -716,6 +735,9 @@ function createSchedulerService(dependencies = {}) {
       // shared session. Matches captured project.name (projectDescriptor(job).name)
       // so sameCapturedProject / getProjectKey resolve the right thread mid-run.
       conversationKey: projectDescriptor(job).name,
+      // A job made in a chat thread answers in that thread: its notice, its
+      // typing indicator and its reply all go back into the thread.
+      threadId: jobThreadId(job),
       // …but the thread is not the room. A job belongs to the room it was
       // created in and must answer under THAT room's provider; without this the
       // room overlay can't resolve and the run silently falls back to the
@@ -730,7 +752,15 @@ function createSchedulerService(dependencies = {}) {
     return runInChat(chat, async () => {
       noteLegacyCreatorOnce(job);
       const state = stateForUser(canonicalUserId);
-      if (state.runningProcess || state.preparingRun || state.isCompacting) {
+      // Busy means THIS job's conversation is running, compacting or has
+      // messages waiting; other conversations of the speaker may run meanwhile.
+      // The conversation it replies INTO counts too: a job whose project is not
+      // its chat's key (--project myrepo, a legacy basename) must not answer in
+      // a thread or timeline beside a live turn there.
+      const lane = peekLane(state, projectDescriptor(job).name);
+      const replyLane = peekLane(state, conversationKeyFor(adapter.type, job.channelId, jobThreadId(job)));
+      const occupied = (l) => laneBusy(l) || !!l?.messageQueue?.length;
+      if (occupied(lane) || occupied(replyLane)) {
         try { return markBusy(job); }
         catch (error) { return keepRetrying(job, error, busyDelayMs); }
       }
@@ -954,7 +984,9 @@ function createSchedulerService(dependencies = {}) {
     const sessionId = Object.prototype.hasOwnProperty.call(spec, "sessionId")
       ? spec.sessionId
       : getProviderSession(state, provider, project);
-    const originRunId = spec.originRunId || state.activeRunContext?.runId || null;
+    // Fall back to the run of the job's own conversation only: another
+    // thread's running turn is not where this job came from.
+    const originRunId = spec.originRunId || (project ? peekLane(state, project)?.activeRunContext?.runId : null) || null;
     const providerSettings = spec.providerSettings || getProviderSettings(state, provider);
     return {
       ...spec,
@@ -1080,8 +1112,8 @@ module.exports = {
   parseFallbacks,
   terminalRunSucceeded,
   buildWatchCheckEnv,
-  isSecretCheckEnvKey,
   watchCheckPrincipal,
+  jobThreadId,
   setAdapters,
   initScheduler,
   scheduleJob: service.scheduleJob,

package/core/side-chat.js

@@ -143,6 +143,23 @@ async function defaultDeliver(payload, store) {
   return execute();
 }
 
+// Side chats are per (speaker, conversation): a speaker's threads each get
+// their own side answer, and /stop in one conversation cancels only its own.
+// A bare canonical id (no lane) addresses every conversation of the speaker.
+const LANE_SEP = "\u0000";
+function sideChatKey(canonicalUserId, laneKey = null) {
+  return laneKey ? `${canonicalUserId}${LANE_SEP}${laneKey}` : String(canonicalUserId);
+}
+function keyMatches(key, canonicalUserId, laneKey = null) {
+  if (laneKey) return key === sideChatKey(canonicalUserId, laneKey);
+  const user = String(canonicalUserId);
+  return key === user || key.startsWith(`${user}${LANE_SEP}`);
+}
+function requestLaneKey(request) {
+  const runContext = request?.originalRunContext || request?.runContext || null;
+  return runContext?.laneKey || runContext?.project?.name || null;
+}
+
 class SideChatCoordinator {
   constructor(options = {}) {
     this.runSideChat = options.runSideChat || ((request) => require("./runner").runSideChatRequest(request));
@@ -163,28 +180,39 @@ class SideChatCoordinator {
     return this.modeReader() === "agent";
   }
 
-  isActive(canonicalUserId) {
-    return this.activeByUser.has(String(canonicalUserId));
+  isActive(canonicalUserId, laneKey = null) {
+    return [...this.activeByUser.keys()].some((key) => keyMatches(key, canonicalUserId, laneKey));
   }
 
-  attachProcess(canonicalUserId, proc) {
+  attachProcess(canonicalUserId, proc, laneKey = null) {
     if (!proc) return;
     let resolveDone;
     const done = new Promise((resolve) => { resolveDone = resolve; });
     const settle = () => resolveDone();
     proc.once("close", settle);
     proc.once("error", settle);
-    this.processByUser.set(String(canonicalUserId), { proc, done });
+    this.processByUser.set(sideChatKey(canonicalUserId, laneKey), { proc, done });
   }
 
-  detachProcess(canonicalUserId, proc) {
-    const key = String(canonicalUserId);
+  detachProcess(canonicalUserId, proc, laneKey = null) {
+    const key = sideChatKey(canonicalUserId, laneKey);
     const entry = this.processByUser.get(key);
     if (!proc || entry?.proc === proc) this.processByUser.delete(key);
   }
 
-  async cancel(canonicalUserId) {
-    const key = String(canonicalUserId);
+  // Cancel the side chat of one conversation (laneKey), or of every
+  // conversation of the speaker when no lane is named.
+  async cancel(canonicalUserId, laneKey = null) {
+    if (!laneKey) {
+      const keys = new Set([...this.activeByUser.keys(), ...this.processByUser.keys()]
+        .filter((key) => keyMatches(key, canonicalUserId)));
+      const outcomes = await Promise.all([...keys].map((key) => this.cancelKey(key)));
+      return outcomes.some(Boolean);
+    }
+    return this.cancelKey(sideChatKey(canonicalUserId, laneKey));
+  }
+
+  async cancelKey(key) {
     const active = this.activeByUser.get(key);
     if (active) this.cancelledRequests.add(active.token);
     const entry = this.processByUser.get(key);
@@ -208,8 +236,8 @@ class SideChatCoordinator {
   }
 
   async cancelAll() {
-    const users = new Set([...this.activeByUser.keys(), ...this.processByUser.keys()]);
-    const outcomes = await Promise.all([...users].map((canonicalUserId) => this.cancel(canonicalUserId)));
+    const keys = new Set([...this.activeByUser.keys(), ...this.processByUser.keys()]);
+    const outcomes = await Promise.all([...keys].map((key) => this.cancelKey(key)));
     return outcomes.filter(Boolean).length;
   }
 
@@ -258,7 +286,7 @@ class SideChatCoordinator {
 
   async respond(input = {}) {
     const request = this.makePending(input);
-    const userKey = String(request.canonicalUserId);
+    const userKey = sideChatKey(request.canonicalUserId, requestLaneKey(request));
     if (this.activeByUser.has(userKey)) {
       try {
         const delivery = await this.deliver({
@@ -343,4 +371,5 @@ module.exports = {
   createSideChatRequest,
   readRuntimeMode,
   sideChatCoordinator,
+  sideChatKey,
 };

package/core/speaker-attest.js

@@ -88,6 +88,8 @@ function principalOf(principal = {}) {
     adapterId: text(principal.adapterId),
     adapterType: text(principal.adapterType),
     channelId: text(principal.channelId),
+    // The chat thread the run answers in (null: the channel's main timeline).
+    threadId: text(principal.threadId),
     userId: text(principal.userId),
     room: text(principal.room),
     purpose: text(principal.purpose),