@inetafrica/open-claudia 2.15.0 → 3.0.1

package/core/side-chat.js

@@ -0,0 +1,346 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { deepFreeze } = require("./run-context");
+const { redactSensitive } = require("./redact");
+
+const ACTIVE_TASK_DESCRIPTION_MAX = 320;
+const SIDE_QUESTION_MAX = 8000;
+const SIDE_RESPONSE_MAX = 3500;
+const SIDE_TIMEOUT_MS = 90 * 1000;
+const DEFAULT_PENDING_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_PENDING_LIMIT = 20;
+
+function boundedText(value, maxLength) {
+  const clean = redactSensitive(String(value || "")).replace(/\s+/g, " ").trim();
+  if (clean.length <= maxLength) return clean;
+  return `${clean.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+function readRuntimeMode(configDir) {
+  try {
+    const mode = fs.readFileSync(path.join(configDir, ".bot-mode"), "utf8").trim().toLowerCase();
+    if (mode === "agent") return "agent";
+  } catch (_) {}
+  return "direct";
+}
+
+function randomToken() {
+  return crypto.randomBytes(9).toString("base64url");
+}
+
+function sideRunId(originalRunId, token) {
+  const base = String(originalRunId || "run").slice(0, 40);
+  return `side-${base}-${token}`;
+}
+
+function createSideChatRequest({
+  runContext,
+  activeRunContext = null,
+  token = randomToken(),
+  now = Date.now(),
+} = {}) {
+  if (!runContext || typeof runContext !== "object") throw new TypeError("captured runContext is required");
+  if (!runContext.canonicalUserId) throw new TypeError("side chat requires a canonical user");
+  const activeTaskDescription = boundedText(
+    activeRunContext?.userPrompt || activeRunContext?.label || "Open Claudia is working on the active task.",
+    ACTIVE_TASK_DESCRIPTION_MAX,
+  );
+  const question = boundedText(runContext.userPrompt, SIDE_QUESTION_MAX);
+  const providerSettings = {
+    ...(runContext.providerSettings || {}),
+    budget: null,
+    permissionMode: "plan",
+    worktree: false,
+  };
+  const sideContext = deepFreeze({
+    ...runContext,
+    runId: sideRunId(runContext.runId, token),
+    admittedAt: now,
+    timeoutMs: SIDE_TIMEOUT_MS,
+    purpose: "side-chat",
+    providerSettings,
+    sessionId: null,
+    admittedSessionId: null,
+    previousSessionId: null,
+    resumeSessionId: null,
+    continueSession: false,
+    fresh: true,
+    skipAutoCompact: true,
+    requiredDelivery: false,
+    userPrompt: question,
+    activeTaskDescription,
+    maxTurns: 1,
+    toolHookSettings: null,
+    imagePaths: [],
+    attachments: [],
+    lastInputWasVoice: false,
+    voiceStream: false,
+  });
+  return deepFreeze({
+    token,
+    canonicalUserId: runContext.canonicalUserId,
+    replyToMsgId: runContext.replyToMsgId,
+    provider: runContext.provider,
+    project: runContext.project,
+    origin: runContext.origin,
+    originalMessage: runContext.userPrompt,
+    activeTaskDescription,
+    activeRunId: activeRunContext?.runId || null,
+    originalRunContext: runContext,
+    runContext: sideContext,
+  });
+}
+
+function createSideChatPromptBuilder(buildCoreInstructions) {
+  const coreBuilder = buildCoreInstructions || ((opts) => require("./system-prompt").buildCoreInstructions(opts));
+  return async function buildSideChatPrompt(userPrompt, { runContext, provider } = {}) {
+    const activeTask = boundedText(runContext?.activeTaskDescription, ACTIVE_TASK_DESCRIPTION_MAX);
+    const projectName = boundedText(runContext?.project?.name || "unknown project", 120);
+    const transport = boundedText(runContext?.origin?.transport || "chat", 40);
+    const dynamicContext = [
+      "## Isolated side chat",
+      "A main Open Claudia task is still running. Answer this one side question briefly and conversationally.",
+      `Active task: ${activeTask || "Open Claudia is working on the active task."}`,
+      `Captured context: project=${projectName}; channel=${transport}; provider=${provider?.id || runContext?.provider || "unknown"}.`,
+      "This is a fresh, read-only, ephemeral response. Do not resume the main provider session, use tools, change files or Open Claudia state, schedule work, update memory, or claim the user's message was added to the main task.",
+      "The user can explicitly choose “Add to main task” after this response if they want the original message handled by the main conversation.",
+    ].join("\n");
+    return {
+      coreInstructions: coreBuilder({ runContext }),
+      dynamicContext,
+      userPrompt: boundedText(userPrompt, SIDE_QUESTION_MAX),
+      transcriptPaths: null,
+      recallMetadata: { status: "omitted", omitted: true, reason: "isolated_side_chat" },
+    };
+  };
+}
+
+async function defaultDeliver(payload, store) {
+  const execute = async () => {
+    let text = payload.text;
+    try {
+      if (require("./relationship").isCurrentSpeakerGuarded()) {
+        const guard = await require("./enforcer").guardOutboundReply(text);
+        if (!guard.allow) text = "I need to check with the owner before I can answer that side question.";
+      }
+    } catch (error) {
+      text = "I couldn't safely classify that side response, so I held it.";
+    }
+    return require("./io").send(text, {
+      replyTo: payload.replyToMsgId,
+      keyboard: {
+        inline_keyboard: [[{
+          text: payload.action.label,
+          callback_data: payload.action.callbackData,
+        }]],
+      },
+    });
+  };
+  if (store) return require("./context").chatContext.run(store, execute);
+  return execute();
+}
+
+class SideChatCoordinator {
+  constructor(options = {}) {
+    this.runSideChat = options.runSideChat || ((request) => require("./runner").runSideChatRequest(request));
+    this.enqueueMain = options.enqueueMain || ((request, store, lineage) => require("./runner").enqueueSideChatRequest(request, store, lineage));
+    this.deliver = options.deliver || defaultDeliver;
+    this.modeReader = options.modeReader || (() => readRuntimeMode(require("./config").CONFIG_DIR));
+    this.tokenFactory = options.tokenFactory || randomToken;
+    this.now = options.now || Date.now;
+    this.pendingTtlMs = options.pendingTtlMs || DEFAULT_PENDING_TTL_MS;
+    this.pendingLimit = options.pendingLimit || DEFAULT_PENDING_LIMIT;
+    this.activeByUser = new Map();
+    this.processByUser = new Map();
+    this.cancelledRequests = new Set();
+    this.pending = new Map();
+  }
+
+  enabled() {
+    return this.modeReader() === "agent";
+  }
+
+  isActive(canonicalUserId) {
+    return this.activeByUser.has(String(canonicalUserId));
+  }
+
+  attachProcess(canonicalUserId, proc) {
+    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 });
+  }
+
+  detachProcess(canonicalUserId, proc) {
+    const key = String(canonicalUserId);
+    const entry = this.processByUser.get(key);
+    if (!proc || entry?.proc === proc) this.processByUser.delete(key);
+  }
+
+  async cancel(canonicalUserId) {
+    const key = String(canonicalUserId);
+    const active = this.activeByUser.get(key);
+    if (active) this.cancelledRequests.add(active.token);
+    const entry = this.processByUser.get(key);
+    if (!entry) return !!active;
+    const { proc, done } = entry;
+    const { killProcessTree } = require("./process-tree");
+    try { killProcessTree(proc.pid, "SIGTERM"); } catch (_) {}
+    const termClosed = await Promise.race([
+      done.then(() => true),
+      new Promise((resolve) => setTimeout(() => resolve(false), 3000)),
+    ]);
+    if (!termClosed) {
+      try { killProcessTree(proc.pid, "SIGKILL"); } catch (_) {}
+      await Promise.race([
+        done,
+        new Promise((resolve) => setTimeout(resolve, 2000)),
+      ]);
+    }
+    if (this.processByUser.get(key) === entry) this.processByUser.delete(key);
+    return true;
+  }
+
+  async cancelAll() {
+    const users = new Set([...this.activeByUser.keys(), ...this.processByUser.keys()]);
+    const outcomes = await Promise.all([...users].map((canonicalUserId) => this.cancel(canonicalUserId)));
+    return outcomes.filter(Boolean).length;
+  }
+
+  noteMainResult(runContext, result) {
+    if (!runContext?.runId || !result?.ok || !result.sessionId) return;
+    for (const entry of this.pending.values()) {
+      if (entry.request.activeRunId === runContext.runId) entry.mainSessionId = result.sessionId;
+    }
+  }
+
+  prune() {
+    const now = this.now();
+    for (const [token, entry] of this.pending) {
+      if (entry.expiresAt <= now) this.pending.delete(token);
+    }
+    while (this.pending.size >= this.pendingLimit) {
+      this.pending.delete(this.pending.keys().next().value);
+    }
+  }
+
+  makePending(input) {
+    this.prune();
+    let token = this.tokenFactory();
+    while (!token || this.pending.has(token)) token = this.tokenFactory();
+    const request = createSideChatRequest({
+      runContext: input.runContext,
+      activeRunContext: input.activeRunContext,
+      token,
+      now: this.now(),
+    });
+    this.pending.set(token, {
+      request,
+      store: input.store || null,
+      mainSessionId: null,
+      expiresAt: this.now() + this.pendingTtlMs,
+    });
+    return request;
+  }
+
+  actionFor(request) {
+    return {
+      label: "Add to main task",
+      callbackData: `sc:q:${request.token}`,
+    };
+  }
+
+  async respond(input = {}) {
+    const request = this.makePending(input);
+    const userKey = String(request.canonicalUserId);
+    if (this.activeByUser.has(userKey)) {
+      try {
+        const delivery = await this.deliver({
+          text: "A side reply is already running. Add this message to the main task if it should be handled next.",
+          replyToMsgId: request.replyToMsgId,
+          action: this.actionFor(request),
+        }, input.store || null);
+        if (delivery?.ok === false) throw new Error(delivery.error?.message || "side response delivery failed");
+        return { ok: true, status: "busy", provider: request.provider, purpose: "side-chat", enqueueToken: request.token };
+      } catch (error) {
+        return { ok: false, status: "failed", provider: request.provider, purpose: "side-chat", delivery: { ok: false, error }, enqueueToken: request.token };
+      }
+    }
+
+    this.activeByUser.set(userKey, request);
+    let result;
+    try {
+      result = await this.runSideChat(request);
+    } catch (error) {
+      result = { ok: false, status: "failed", provider: request.provider, purpose: "side-chat", diagnostic: `Side response failed: ${error.message}`, error };
+    }
+    try {
+      if (this.cancelledRequests.has(request.token)) {
+        return { ...result, ok: false, status: "cancelled", enqueueToken: request.token };
+      }
+      const text = result?.ok
+        ? boundedText(result.text || "(no response)", SIDE_RESPONSE_MAX)
+        : boundedText(result?.diagnostic || result?.error?.message || "The side response failed.", SIDE_RESPONSE_MAX);
+      const delivery = await this.deliver({
+        text,
+        replyToMsgId: request.replyToMsgId,
+        action: this.actionFor(request),
+      }, input.store || null);
+      if (delivery?.ok === false) throw new Error(delivery.error?.message || "side response delivery failed");
+      return { ...result, status: result?.status || (result?.ok ? "succeeded" : "failed"), enqueueToken: request.token };
+    } catch (deliveryError) {
+      return {
+        ...result,
+        ok: false,
+        status: "failed",
+        delivery: { ok: false, error: deliveryError },
+        enqueueToken: request.token,
+      };
+    } finally {
+      this.cancelledRequests.delete(request.token);
+      if (this.activeByUser.get(userKey) === request) this.activeByUser.delete(userKey);
+    }
+  }
+
+  async enqueue(token, canonicalUserId) {
+    this.prune();
+    const entry = this.pending.get(String(token));
+    if (!entry) return { ok: false, status: "expired" };
+    if (String(entry.request.canonicalUserId) !== String(canonicalUserId)) {
+      return { ok: false, status: "forbidden" };
+    }
+    this.pending.delete(String(token));
+    try {
+      const queued = await this.enqueueMain(entry.request, entry.store, {
+        mainRunId: entry.request.activeRunId,
+        mainSessionId: entry.mainSessionId,
+      });
+      return { ok: true, status: "queued", ...queued };
+    } catch (error) {
+      return { ok: false, status: "failed", error };
+    }
+  }
+}
+
+const sideChatCoordinator = new SideChatCoordinator();
+
+module.exports = {
+  ACTIVE_TASK_DESCRIPTION_MAX,
+  DEFAULT_PENDING_LIMIT,
+  DEFAULT_PENDING_TTL_MS,
+  SIDE_QUESTION_MAX,
+  SIDE_RESPONSE_MAX,
+  SIDE_TIMEOUT_MS,
+  SideChatCoordinator,
+  boundedText,
+  createSideChatPromptBuilder,
+  createSideChatRequest,
+  readRuntimeMode,
+  sideChatCoordinator,
+};

package/core/single-instance.js

@@ -0,0 +1,46 @@
+// Single-instance lock on the config dir. Two bot processes sharing one
+// CONFIG_DIR share one Telegram token; Telegram then 409-terminates their
+// getUpdates polls in turns and each side keeps exiting/respawning — the
+// 2026-07-12 restart storm, where a debugger-run dev checkout fought the
+// launchd service copy all morning. Whoever boots second must refuse to
+// start BEFORE touching any channel.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (e) { return e.code === "EPERM"; } // EPERM: alive, different owner
+}
+
+function acquireSingleInstanceLock({ configDir, name = "bot" }) {
+  const lockPath = path.join(configDir, `${name}.lock`);
+  try {
+    const prev = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    if (prev && prev.pid && prev.pid !== process.pid && pidAlive(prev.pid)) {
+      return { acquired: false, holder: prev, lockPath };
+    }
+    // Missing, corrupt, own-pid, or dead-pid (stale after SIGKILL): claim it.
+  } catch (e) {}
+  fs.writeFileSync(lockPath, JSON.stringify({
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    entrypoint: process.argv[1] || "",
+  }));
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    try {
+      const cur = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+      // Never delete a lock a successor already owns.
+      if (cur && cur.pid === process.pid) fs.unlinkSync(lockPath);
+    } catch (e) {}
+  };
+  process.on("exit", release);
+  return { acquired: true, lockPath, release };
+}
+
+module.exports = { acquireSingleInstanceLock, pidAlive };