chainlesschain 0.165.8 → 0.165.9

package/src/lib/external-agent-adapters.js

@@ -0,0 +1,269 @@
+/**
+ * Provider-specific contracts for non-interactive coding-agent CLIs.
+ *
+ * Keep argv construction and JSONL parsing here instead of assuming that two
+ * CLIs with similar product goals expose the same wire protocol.
+ */
+
+export const EXTERNAL_AGENT_PROTOCOL = Object.freeze({
+  CLAUDE_STREAM_JSON: "claude-stream-json-v1",
+  CODEX_EXEC_JSONL: "codex-exec-jsonl-v1",
+});
+
+export const EXTERNAL_AGENT_ERROR = Object.freeze({
+  CANCELLED: "EXTERNAL_AGENT_CANCELLED",
+  TIMEOUT: "EXTERNAL_AGENT_TIMEOUT",
+  EXIT_NONZERO: "EXTERNAL_AGENT_EXIT_NONZERO",
+  SPAWN_FAILED: "EXTERNAL_AGENT_SPAWN_FAILED",
+  PROTOCOL_FAILED: "EXTERNAL_AGENT_PROTOCOL_FAILED",
+  UNSUPPORTED_OPTION: "EXTERNAL_AGENT_UNSUPPORTED_OPTION",
+});
+
+const KNOWN_CODEX_ITEM_TYPES = new Set([
+  "agent_message",
+  "reasoning",
+  "command_execution",
+  "file_change",
+  "mcp_tool_call",
+  "web_search",
+  "plan_update",
+]);
+
+function stringifyValue(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+function errorMessage(value, fallback) {
+  if (typeof value === "string" && value) return value;
+  if (value && typeof value.message === "string" && value.message) {
+    return value.message;
+  }
+  return fallback;
+}
+
+/**
+ * Common adapter surface. Subclasses provide buildArgs() and parseEvent().
+ */
+export class ExternalAgentAdapter {
+  constructor(options = {}) {
+    this.command = options.command;
+    this.model = options.model || null;
+  }
+
+  capabilities() {
+    return Object.freeze({
+      protocol: "unknown",
+      jsonl: false,
+      modelOverride: false,
+      allowedTools: false,
+      requiresTerminalEvent: false,
+    });
+  }
+
+  buildArgs() {
+    throw new Error("ExternalAgentAdapter.buildArgs() must be implemented");
+  }
+
+  parseEvent() {
+    throw new Error("ExternalAgentAdapter.parseEvent() must be implemented");
+  }
+
+  /**
+   * Reduce a JSONL transcript into a provider-neutral terminal projection.
+   * Unknown additive events are retained for diagnostics but do not make a
+   * successful run fail.
+   */
+  parseTranscript(raw) {
+    const lines = String(raw || "")
+      .split(/\r?\n/)
+      .filter((line) => line.trim().length > 0);
+    const projection = {
+      output: "",
+      terminal: null,
+      error: null,
+      parsedEventCount: 0,
+      malformedLineCount: 0,
+      unknownEventTypes: [],
+      unknownItemTypes: [],
+      usage: null,
+    };
+    const unknownEvents = new Set();
+    const unknownItems = new Set();
+
+    for (const line of lines) {
+      let event;
+      try {
+        event = JSON.parse(line);
+        projection.parsedEventCount += 1;
+      } catch (_err) {
+        projection.malformedLineCount += 1;
+        continue;
+      }
+
+      const normalized = this.parseEvent(event);
+      if (normalized.output) projection.output = normalized.output;
+      if (normalized.terminal) projection.terminal = normalized.terminal;
+      if (normalized.error) projection.error = normalized.error;
+      if (normalized.usage) projection.usage = normalized.usage;
+      if (normalized.unknownEventType) {
+        unknownEvents.add(normalized.unknownEventType);
+      }
+      if (normalized.unknownItemType) {
+        unknownItems.add(normalized.unknownItemType);
+      }
+    }
+
+    projection.unknownEventTypes = [...unknownEvents];
+    projection.unknownItemTypes = [...unknownItems];
+    return projection;
+  }
+}
+
+export class ClaudeAdapter extends ExternalAgentAdapter {
+  constructor(options = {}) {
+    super({ ...options, command: options.command || "claude" });
+  }
+
+  capabilities() {
+    return Object.freeze({
+      protocol: EXTERNAL_AGENT_PROTOCOL.CLAUDE_STREAM_JSON,
+      jsonl: true,
+      modelOverride: true,
+      allowedTools: true,
+      requiresTerminalEvent: true,
+    });
+  }
+
+  buildArgs({ prompt, allowedTools = null } = {}) {
+    const args = ["-p", String(prompt || ""), "--output-format", "stream-json"];
+    if (this.model) args.push("--model", this.model);
+    if (allowedTools) args.push("--allowedTools", allowedTools);
+    return args;
+  }
+
+  parseEvent(event) {
+    if (!event || typeof event !== "object") {
+      return { unknownEventType: "<non-object>" };
+    }
+
+    if (event.type === "result") {
+      const failed = event.is_error === true || event.subtype === "error";
+      return {
+        output: event.result ? stringifyValue(event.result) : "",
+        terminal: failed ? "failed" : "completed",
+        error: failed
+          ? errorMessage(event.error || event.result, "Claude Code turn failed")
+          : null,
+        usage: event.usage || null,
+      };
+    }
+
+    if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+      const output = event.message.content
+        .filter((block) => block?.type === "text")
+        .map((block) => block.text)
+        .filter(Boolean)
+        .join("\n");
+      return { output };
+    }
+
+    // These are progress/input events in Claude Code stream-json.
+    if (["system", "user", "rate_limit_event"].includes(event.type)) {
+      return {};
+    }
+    return { unknownEventType: String(event.type || "<missing>") };
+  }
+}
+
+export class CodexAdapter extends ExternalAgentAdapter {
+  constructor(options = {}) {
+    super({ ...options, command: options.command || "codex" });
+    this.sandbox = options.sandbox || null;
+  }
+
+  capabilities() {
+    return Object.freeze({
+      protocol: EXTERNAL_AGENT_PROTOCOL.CODEX_EXEC_JSONL,
+      jsonl: true,
+      modelOverride: true,
+      allowedTools: false,
+      requiresTerminalEvent: true,
+      sandboxModes: ["read-only", "workspace-write", "danger-full-access"],
+    });
+  }
+
+  buildArgs({ prompt, allowedTools = null } = {}) {
+    if (allowedTools) {
+      const err = new Error(
+        "Codex CLI does not expose Claude Code's --allowedTools option",
+      );
+      err.code = EXTERNAL_AGENT_ERROR.UNSUPPORTED_OPTION;
+      throw err;
+    }
+
+    const args = ["exec", "--json"];
+    if (this.model) args.push("--model", this.model);
+    if (this.sandbox) args.push("--sandbox", this.sandbox);
+    args.push(String(prompt || ""));
+    return args;
+  }
+
+  parseEvent(event) {
+    if (!event || typeof event !== "object") {
+      return { unknownEventType: "<non-object>" };
+    }
+
+    switch (event.type) {
+      case "thread.started":
+      case "turn.started":
+        return {};
+      case "turn.completed":
+        return {
+          terminal: "completed",
+          usage: event.usage || null,
+        };
+      case "turn.failed":
+        return {
+          terminal: "failed",
+          error: errorMessage(event.error, "Codex turn failed"),
+        };
+      case "error":
+        return {
+          terminal: "failed",
+          error: errorMessage(event.error || event, "Codex emitted an error"),
+        };
+      case "item.started":
+      case "item.updated":
+      case "item.completed": {
+        const itemType = event.item?.type;
+        const unknownItemType =
+          itemType && !KNOWN_CODEX_ITEM_TYPES.has(itemType)
+            ? String(itemType)
+            : null;
+        const output =
+          event.type === "item.completed" &&
+          itemType === "agent_message" &&
+          typeof event.item?.text === "string"
+            ? event.item.text
+            : "";
+        return { output, unknownItemType };
+      }
+      default:
+        return { unknownEventType: String(event.type || "<missing>") };
+    }
+  }
+}
+
+export function createExternalAgentAdapter(options = {}) {
+  const command = options.command || options.cliCommand || "claude";
+  if (command === "codex" || /(^|[\\/])codex(?:\.cmd|\.exe)?$/i.test(command)) {
+    return new CodexAdapter({ ...options, command });
+  }
+  if (
+    command === "claude" ||
+    /(^|[\\/])claude(?:\.cmd|\.exe)?$/i.test(command)
+  ) {
+    return new ClaudeAdapter({ ...options, command });
+  }
+  throw new Error(`Unsupported external agent CLI: ${command}`);
+}

package/src/lib/ipfs-storage.js

@@ -21,6 +21,35 @@
  */
 
 import crypto from "crypto";
+import { createSecretStore } from "./secret-store.js";
+
+let configuredIpfsSecretStore = null;
+
+export function setIpfsSecretStore(secretStore) {
+  if (
+    !secretStore ||
+    typeof secretStore.set !== "function" ||
+    typeof secretStore.get !== "function" ||
+    typeof secretStore.delete !== "function"
+  ) {
+    throw new TypeError("IPFS storage requires a SecretStore");
+  }
+  configuredIpfsSecretStore = secretStore;
+}
+
+function getIpfsSecretStore() {
+  if (!configuredIpfsSecretStore) {
+    configuredIpfsSecretStore = createSecretStore({
+      service: "chainlesschain-ipfs-dek",
+    });
+  }
+  return configuredIpfsSecretStore;
+}
+
+function _encryptionKeyRef(cid) {
+  const digest = crypto.createHash("sha256").update(cid).digest("hex");
+  return `ipfs/dek/${digest}`;
+}
 
 /* ── Constants ──────────────────────────────────────────── */
 
@@ -91,7 +120,8 @@ export function ensureIpfsTables(db) {
     mime_type TEXT,
     pinned INTEGER DEFAULT 0,
     encrypted INTEGER DEFAULT 0,
-    encryption_key TEXT,
+    encryption_key TEXT DEFAULT '',
+    encryption_key_ref TEXT,
     knowledge_id TEXT,
     metadata TEXT,
     payload TEXT,
@@ -105,9 +135,63 @@ export function ensureIpfsTables(db) {
     updated_at INTEGER NOT NULL
   )`);
 
+  const columns = db.prepare("PRAGMA table_info(ipfs_content)").all();
+  if (
+    columns.length > 0 &&
+    !columns.some((entry) => entry.name === "encryption_key_ref")
+  ) {
+    db.exec("ALTER TABLE ipfs_content ADD COLUMN encryption_key_ref TEXT");
+  }
+
+  migrateIpfsEncryptionKeys(db);
+
   _loadAll(db);
 }
 
+export function migrateIpfsEncryptionKeys(db, { dryRun = false } = {}) {
+  db.exec("PRAGMA secure_delete = ON");
+  const rows = db
+    .prepare("SELECT cid, encryption_key, encryption_key_ref FROM ipfs_content")
+    .all()
+    .filter((row) => row.encryption_key && !row.encryption_key_ref);
+  if (dryRun) {
+    return { pending: rows.length, migrated: 0, dryRun: true };
+  }
+
+  if (rows.length > 0 && typeof db.transaction !== "function") {
+    throw new Error(
+      "IPFS data-key migration requires transactional database support",
+    );
+  }
+
+  const secretStore = rows.length > 0 ? getIpfsSecretStore() : null;
+  const stagedKeyRefs = [];
+  try {
+    for (const row of rows) {
+      const keyRef = _encryptionKeyRef(row.cid);
+      secretStore.set(keyRef, row.encryption_key);
+      stagedKeyRefs.push(keyRef);
+    }
+    const applyMigration = db.transaction(() => {
+      for (const row of rows) {
+        const keyRef = _encryptionKeyRef(row.cid);
+        db.prepare(
+          "UPDATE ipfs_content SET encryption_key = ?, encryption_key_ref = ? WHERE cid = ?",
+        ).run("", keyRef, row.cid);
+      }
+    });
+    applyMigration();
+  } catch (error) {
+    for (const keyRef of stagedKeyRefs) secretStore.delete(keyRef);
+    throw error;
+  }
+  return {
+    pending: rows.length,
+    migrated: rows.length,
+    dryRun: false,
+  };
+}
+
 function _loadAll(db) {
   _content.clear();
   _knowledgeLinks.clear();
@@ -263,6 +347,7 @@ export function addContent(
   }
 
   const cid = _computeCid(payload);
+  const encryptionKeyRef = encryptionKey ? _encryptionKeyRef(cid) : null;
 
   // Idempotent: if CID exists, just update flags
   const existing = _content.get(cid);
@@ -301,7 +386,8 @@ export function addContent(
     mime_type: mimeType || null,
     pinned: pin ? 1 : 0,
     encrypted: encrypt ? 1 : 0,
-    encryption_key: encryptionKey,
+    encryption_key: "",
+    encryption_key_ref: encryptionKeyRef,
     knowledge_id: knowledgeId || null,
     metadata: metadataJson,
     payload: payloadBase64,
@@ -309,24 +395,33 @@ export function addContent(
     updated_at: now,
   };
 
-  db.prepare(
-    `INSERT INTO ipfs_content (id, cid, filename, size, mime_type, pinned, encrypted, encryption_key, knowledge_id, metadata, payload, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  ).run(
-    id,
-    cid,
-    entry.filename,
-    size,
-    entry.mime_type,
-    entry.pinned,
-    entry.encrypted,
-    entry.encryption_key,
-    entry.knowledge_id,
-    entry.metadata,
-    entry.payload,
-    now,
-    now,
-  );
+  if (encryptionKeyRef) {
+    getIpfsSecretStore().set(encryptionKeyRef, encryptionKey);
+  }
+  try {
+    db.prepare(
+      `INSERT INTO ipfs_content (id, cid, filename, size, mime_type, pinned, encrypted, encryption_key, encryption_key_ref, knowledge_id, metadata, payload, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id,
+      cid,
+      entry.filename,
+      size,
+      entry.mime_type,
+      entry.pinned,
+      entry.encrypted,
+      entry.encryption_key,
+      entry.encryption_key_ref,
+      entry.knowledge_id,
+      entry.metadata,
+      entry.payload,
+      now,
+      now,
+    );
+  } catch (error) {
+    if (encryptionKeyRef) getIpfsSecretStore().delete(encryptionKeyRef);
+    throw error;
+  }
 
   _content.set(cid, entry);
   if (knowledgeId) {
@@ -350,9 +445,12 @@ export function getContent(db, cid, { asString } = {}) {
   if (!entry) return null;
 
   let buffer = Buffer.from(entry.payload, "base64");
-  if (entry.encrypted && entry.encryption_key) {
+  if (entry.encrypted) {
     try {
-      buffer = _decrypt(buffer, entry.encryption_key);
+      if (!entry.encryption_key_ref) return null;
+      const encryptionKey = getIpfsSecretStore().get(entry.encryption_key_ref);
+      if (!encryptionKey) return null;
+      buffer = _decrypt(buffer, encryptionKey);
     } catch (_e) {
       return null;
     }
@@ -395,7 +493,7 @@ export function listContent(db, { pinned, knowledgeId, limit = 50 } = {}) {
     .sort((a, b) => b.created_at - a.created_at)
     .slice(0, limit)
     .map((c) => {
-      const { payload, encryption_key, ...rest } = c;
+      const { payload, encryption_key, encryption_key_ref, ...rest } = c;
       return rest;
     });
 }
@@ -446,7 +544,7 @@ export function listPins(db, { limit = 50, sortBy = "created_at" } = {}) {
     .sort(sorter)
     .slice(0, limit)
     .map((c) => {
-      const { payload, encryption_key, ...rest } = c;
+      const { payload, encryption_key, encryption_key_ref, ...rest } = c;
       return rest;
     });
 }
@@ -501,8 +599,12 @@ export function garbageCollect(db) {
     }
   }
   for (const cid of toRemove) {
+    const entry = _content.get(cid);
     _content.delete(cid);
     db.prepare("DELETE FROM ipfs_content WHERE cid = ?").run(cid);
+    if (entry?.encryption_key_ref) {
+      getIpfsSecretStore().delete(entry.encryption_key_ref);
+    }
   }
   // Clean up knowledge links pointing to removed CIDs
   for (const [kid, set] of _knowledgeLinks) {
@@ -555,7 +657,7 @@ export function getKnowledgeAttachments(db, knowledgeId) {
     .map((cid) => _content.get(cid))
     .filter(Boolean)
     .map((c) => {
-      const { payload, encryption_key, ...rest } = c;
+      const { payload, encryption_key, encryption_key_ref, ...rest } = c;
       return rest;
     });
 }

package/src/lib/orchestrator.js

@@ -28,6 +28,17 @@ import { NotificationManager } from "./notifiers/index.js";
 import { createChatFn } from "./cowork-adapter.js";
 import { firstBalancedJson } from "./json-schema-output.js";
 import executionBroker from "./process-execution-broker/index.js";
+import runtimeClaimsContract from "@chainlesschain/session-core/runtime-claims";
+
+const { RUNTIME_MODE, createRuntimeClaims, hasTerminalSuccessEvidence } =
+  runtimeClaimsContract;
+
+const ORCHESTRATOR_RUNTIME_CLAIMS = createRuntimeClaims({
+  mode: RUNTIME_MODE.REAL_EXECUTION,
+  durable: false,
+  crashSafe: false,
+  isolatedWrites: false,
+});
 
 /* ---------- _deps injection (Vitest CJS mock pattern) ---------- */
 export const _deps = {
@@ -160,6 +171,8 @@ export class Orchestrator extends EventEmitter {
       ciErrors: [],
       createdAt: new Date().toISOString(),
       completedAt: null,
+      runtimeClaims: ORCHESTRATOR_RUNTIME_CLAIMS,
+      terminalEvidence: [],
     };
 
     this._tasks.set(task.id, task);
@@ -192,6 +205,8 @@ export class Orchestrator extends EventEmitter {
       source: t.source,
       retries: t.retries,
       createdAt: t.createdAt,
+      runtimeClaims: t.runtimeClaims,
+      terminalEvidence: t.terminalEvidence,
     }));
     return {
       tasks,
@@ -228,6 +243,7 @@ export class Orchestrator extends EventEmitter {
 
       // Step 2: Dispatch to Claude Code agents
       task.agentResults = await this._dispatch(task);
+      this._assertSuccessfulAgentResults(task);
 
       // Step 3: CI/CD check
       if (task.runCI) {
@@ -368,6 +384,7 @@ export class Orchestrator extends EventEmitter {
       task.agentResults = await this._router.dispatch(fixSubtasks, {
         cwd: task.cwd,
       });
+      this._assertSuccessfulAgentResults(task);
       this.emit("agents:complete", { task, results: task.agentResults });
     }
 
@@ -409,6 +426,36 @@ export class Orchestrator extends EventEmitter {
     }
   }
 
+  _assertSuccessfulAgentResults(task) {
+    if (!Array.isArray(task.agentResults) || task.agentResults.length === 0) {
+      throw new Error("Agent dispatch produced no terminal results");
+    }
+
+    const failed = [];
+    const evidence = [];
+    for (let index = 0; index < task.agentResults.length; index += 1) {
+      const result = task.agentResults[index];
+      const valid =
+        result?.success === true &&
+        hasTerminalSuccessEvidence(
+          result.runtimeClaims,
+          result.terminalEvidence,
+        );
+      if (!valid) {
+        failed.push(
+          `${result?.taskId || `result-${index}`}: ${result?.error || result?.status || "missing terminal evidence"}`,
+        );
+      } else {
+        evidence.push(...result.terminalEvidence);
+      }
+    }
+
+    if (failed.length > 0) {
+      throw new Error(`Agent execution did not succeed: ${failed.join("; ")}`);
+    }
+    task.terminalEvidence = evidence;
+  }
+
   /**
    * Bound retained task history to maxTasks. Evicts the oldest TERMINAL tasks
    * first (Map preserves insertion order = FIFO); an in-flight task is never

package/src/lib/shell-approval.js

@@ -238,13 +238,15 @@ export async function evaluateShellCommandWithApproval({
     };
   }
 
-  // No ApprovalGate wired? Preserve legacy behavior (shell policy decides).
+  // A missing gate is an unavailable security boundary, not an implicit
+  // authorization. Explicit bypass modes must provide their own auditable
+  // gate implementation instead of omitting the gate.
   if (!approvalGate || typeof approvalGate.decide !== "function") {
     return {
-      allowed: true,
-      decision: DECISION.ALLOW,
-      via: "shell-policy",
-      reason: shellPolicy.reason,
+      allowed: false,
+      decision: DECISION.DENY,
+      via: "approval-gate-unavailable",
+      reason: "Approval gate is unavailable",
       shellPolicy,
       riskLevel,
       policy: null,