@inetafrica/open-claudia 2.14.8 → 3.0.0

package/core/subagent.js

@@ -1,129 +1,103 @@
-// Sub-agents: spawn a fresh, throwaway Claude process for focused
-// research or sub-tasks. No session resume, no shared state with the
-// caller's turn — the output is captured as text and returned. The
-// caller (a parent Claude turn invoking the CLI via Bash) decides what
-// to do with the result.
+"use strict";
 
-const { spawn } = require("child_process");
-const { CLAUDE_PATH, MAX_PROCESS_TIMEOUT, botSubprocessEnv } = require("./config");
-const { redactSensitive } = require("./redact");
-const { claudeSubprocessEnv } = require("./auth-flow");
+// Compatibility surface for existing focused-task callers. Provider
+// selection, safe prompt transport, lifecycle bounds, and process-tree cleanup
+// all live in core/utility-agent.js; this module keeps the historic
+// spawnSubagent() result shape while callers migrate purpose by purpose.
 
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-const MAX_OUTPUT_BYTES = 64 * 1024;
+const { MAX_PROCESS_TIMEOUT } = require("./config");
 
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 const concurrentByChannel = new Map();
 
 function buildSubagentSystemPrompt(role) {
   return [
-    "You are a sub-agent spawned by another Claude assistant via Open Claudia.",
+    "You are a sub-agent spawned by Open Claudia for a focused task.",
     "Your reply is captured as raw text and returned to the parent agent — there is no user reading it directly.",
     "Stay focused on the prompt. Be concise. Return findings; do not chat.",
-    "You do not have access to the parent's chat session, files in /tmp from the parent, or the loopback send tools.",
-    "You can use Read, Glob, Grep, Bash for read-only research. Do not start long-running processes.",
+    "You do not have access to the parent chat session, parent temporary files, or loopback send tools.",
+    "Work read-only: inspect with provider-native read/search tools and harmless shell queries, but do not change files or start long-running processes.",
     role ? `Role: ${role}` : "",
   ].filter(Boolean).join("\n");
 }
 
 function trackStart(channelId) {
   if (!channelId) return 0;
-  const cur = concurrentByChannel.get(channelId) || 0;
-  concurrentByChannel.set(channelId, cur + 1);
-  return cur + 1;
+  const current = concurrentByChannel.get(channelId) || 0;
+  concurrentByChannel.set(channelId, current + 1);
+  return current + 1;
 }
 
 function trackEnd(channelId) {
   if (!channelId) return;
-  const cur = concurrentByChannel.get(channelId) || 0;
-  if (cur <= 1) concurrentByChannel.delete(channelId);
-  else concurrentByChannel.set(channelId, cur - 1);
+  const current = concurrentByChannel.get(channelId) || 0;
+  if (current <= 1) concurrentByChannel.delete(channelId);
+  else concurrentByChannel.set(channelId, current - 1);
 }
 
 function concurrentCount(channelId) {
   return concurrentByChannel.get(channelId) || 0;
 }
 
-async function spawnSubagent(prompt, opts = {}) {
-  const cwd = opts.cwd || process.cwd();
-  const role = opts.role || null;
-  const channelId = opts.channelId || null;
-  const timeoutMs = Math.min(opts.timeoutMs || DEFAULT_TIMEOUT_MS, MAX_PROCESS_TIMEOUT || DEFAULT_TIMEOUT_MS);
-
-  const count = trackStart(channelId);
-  if (count > 3) {
-    console.warn(`subagent: ${count} concurrent sub-agents on channel ${channelId}`);
-  }
-
-  return new Promise((resolve, reject) => {
-    const args = ["-p"];
-    // Tool restriction. --allowedTools/--disallowedTools take variadic
-    // <tools...>, which would greedily swallow the trailing prompt arg — so we
-    // pass a single comma-joined token AND place these flags first, where the
-    // next arg (--output-format) is itself a flag, which stops the variadic.
-    // With --dangerously-skip-permissions on, a whitelist is the structural way
-    // to make a sub-agent genuinely read-only (e.g. the dream's introspection).
-    if (opts.allowedTools) args.push("--allowedTools", [].concat(opts.allowedTools).join(","));
-    if (opts.disallowedTools) args.push("--disallowedTools", [].concat(opts.disallowedTools).join(","));
-    // Sub-agents get the same tool-first deny-gate as the main agent (5b) —
-    // they also hold no keyring creds (botSubprocessEnv is cred-free).
-    try { args.push("--settings", require("./tool-guard").ensureHookSettings()); } catch (e) {}
-    args.push(
-      "--output-format", opts.json ? "json" : "text",
-      "--verbose",
-      "--append-system-prompt", opts.systemPrompt || buildSubagentSystemPrompt(role),
-    );
-    // Permissions. A genuinely read-only sub-agent (e.g. the dream's
-    // introspection) must use plan mode — verified to be the ONLY mechanism
-    // that blocks writes: --dangerously-skip-permissions OVERRIDES both
-    // --allowedTools and --disallowedTools, so a whitelist alone does NOT
-    // restrict. Default remains skip-permissions for research sub-agents that
-    // legitimately need Bash/Write.
-    if (opts.permissionMode) args.push("--permission-mode", opts.permissionMode);
-    else args.push("--dangerously-skip-permissions");
-    if (opts.model) args.push("--model", opts.model);
-    if (opts.effort) args.push("--effort", opts.effort);
-    args.push(prompt);
-    const env = { ...botSubprocessEnv(), ...claudeSubprocessEnv() };
-    const proc = spawn(CLAUDE_PATH, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+function createSubagentService(dependencies = {}) {
+  const runUtility = dependencies.spawnUtilityAgent || require("./utility-agent").spawnUtilityAgent;
 
-    let out = "";
-    let err = "";
-    let truncated = false;
+  async function spawnSubagent(prompt, opts = {}) {
+    const channelId = opts.channelId || null;
+    const count = trackStart(channelId);
+    if (count > 3) console.warn(`subagent: ${count} concurrent sub-agents on channel ${channelId}`);
 
-    proc.stdout.on("data", (d) => {
-      if (out.length + d.length > MAX_OUTPUT_BYTES) {
-        out += d.toString().slice(0, Math.max(0, MAX_OUTPUT_BYTES - out.length));
-        truncated = true;
-      } else {
-        out += d.toString();
+    try {
+      if (opts.readOnly === false || opts.permissionMode === "direct") {
+        const error = new Error("Open Claudia sub-agents are read-only until provider tool enforcement is verified");
+        error.code = "UTILITY_READ_ONLY_REQUIRED";
+        throw error;
       }
-    });
-    proc.stderr.on("data", (d) => {
-      if (err.length < MAX_OUTPUT_BYTES) err += d.toString();
-    });
-
-    const t = setTimeout(() => {
-      try { proc.kill("SIGTERM"); } catch (e) {}
-      reject(new Error(`subagent timed out after ${Math.round(timeoutMs / 1000)}s`));
-    }, timeoutMs);
-
-    proc.on("error", (e) => {
-      clearTimeout(t);
-      trackEnd(channelId);
-      reject(e);
-    });
-    proc.on("close", (code) => {
-      clearTimeout(t);
+      const timeoutMs = Math.min(
+        Number(opts.timeoutMs || DEFAULT_TIMEOUT_MS),
+        MAX_PROCESS_TIMEOUT || DEFAULT_TIMEOUT_MS,
+      );
+      const result = await runUtility(String(prompt || ""), {
+        purpose: "subagent",
+        provider: opts.provider == null ? null : opts.provider,
+        tier: opts.tier || "medium",
+        model: opts.model || null,
+        systemPrompt: opts.systemPrompt || buildSubagentSystemPrompt(opts.role || null),
+        readOnly: true,
+        ...(opts.allowedTools !== undefined ? { allowedTools: [].concat(opts.allowedTools) } : {}),
+        ...(opts.disallowedTools !== undefined ? { disallowedTools: [].concat(opts.disallowedTools) } : {}),
+        ...(opts.outputSchema ? { outputSchema: opts.outputSchema } : {}),
+        ...(opts.effort ? { effort: opts.effort } : {}),
+        timeoutMs,
+        cwd: opts.cwd || process.cwd(),
+        signal: opts.signal || null,
+      });
+      return {
+        text: result.text,
+        truncated: !!result.truncated,
+        stderr: result.stderr || "",
+        code: result.exitCode == null ? 0 : result.exitCode,
+        provider: result.provider,
+        model: result.model,
+        tier: result.tier,
+        fallbackUsed: !!result.fallbackUsed,
+        noTools: result.noTools,
+        noProductSideEffects: result.noProductSideEffects,
+      };
+    } finally {
       trackEnd(channelId);
-      const text = redactSensitive(out.trim());
-      const stderrText = redactSensitive(err.trim());
-      if (code !== 0 && !text) {
-        const msg = stderrText || `subagent exited with code ${code}`;
-        return reject(new Error(msg));
-      }
-      resolve({ text, truncated, stderr: stderrText, code });
-    });
-  });
+    }
+  }
+
+  return { spawnSubagent };
 }
 
-module.exports = { spawnSubagent, concurrentCount };
+const defaultService = createSubagentService();
+
+module.exports = {
+  DEFAULT_TIMEOUT_MS,
+  buildSubagentSystemPrompt,
+  concurrentCount,
+  createSubagentService,
+  spawnSubagent: defaultService.spawnSubagent,
+};