chainlesschain 0.165.9 → 0.166.0

package/src/lib/app-server/sqlite-rollout-store.js

@@ -0,0 +1,315 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+
+import {
+  ROLLOUT_STORE_SCHEMA,
+  ROLLOUT_STORE_VERSION,
+  _rolloutStoreInternals,
+} from "./rollout-store.js";
+
+const { buildRecord, canonicalJson, projectThread, verifyRecords } =
+  _rolloutStoreInternals;
+
+let DatabaseSync = null;
+try {
+  ({ DatabaseSync } = createRequire(import.meta.url)("node:sqlite"));
+} catch {
+  // node:sqlite is optional on the minimum supported Node 22.12 runtime.
+}
+
+function sqliteError(code, message, cause = null) {
+  const error = new Error(message);
+  error.name = "SqliteRolloutStoreError";
+  error.code = code;
+  if (cause) error.cause = cause;
+  return error;
+}
+
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function recordThreadId(input) {
+  return buildRecord(
+    { threadId: input, eventType: "validation", payload: null },
+    null,
+    Date.now,
+  ).thread_id;
+}
+
+export function sqliteRolloutStoreAvailable() {
+  return typeof DatabaseSync === "function";
+}
+
+export class SqliteRolloutStore {
+  constructor({ filename = ":memory:", now = Date.now, database = null } = {}) {
+    this.filename = filename === ":memory:" ? filename : path.resolve(filename);
+    this.now = now;
+    if (this.filename !== ":memory:") {
+      fs.mkdirSync(path.dirname(this.filename), { recursive: true });
+    }
+    if (!database && !sqliteRolloutStoreAvailable()) {
+      throw sqliteError(
+        "CC_ROLLOUT_SQLITE_UNAVAILABLE",
+        "SQLite rollout storage requires a Node runtime with node:sqlite",
+      );
+    }
+    this.db = database || new DatabaseSync(this.filename);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA synchronous = FULL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cc_rollout_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS cc_rollout_events (
+        thread_id TEXT NOT NULL,
+        event_seq INTEGER NOT NULL,
+        idempotency_key TEXT,
+        event_json TEXT NOT NULL,
+        PRIMARY KEY (thread_id, event_seq),
+        UNIQUE (thread_id, idempotency_key)
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS cc_rollout_events_thread
+        ON cc_rollout_events(thread_id, event_seq);
+    `);
+    this.db
+      .prepare(
+        "INSERT OR IGNORE INTO cc_rollout_meta(key, value) VALUES ('schema_version', ?)",
+      )
+      .run(String(ROLLOUT_STORE_VERSION));
+    const version = Number(
+      this.db
+        .prepare(
+          "SELECT value FROM cc_rollout_meta WHERE key = 'schema_version'",
+        )
+        .get()?.value,
+    );
+    if (version !== ROLLOUT_STORE_VERSION) {
+      throw sqliteError(
+        "CC_ROLLOUT_VERSION_UNSUPPORTED",
+        `SQLite rollout schema version ${version} is unsupported`,
+      );
+    }
+  }
+
+  _read(threadId, { allowMissing = false } = {}) {
+    const id = recordThreadId(threadId);
+    const rows = this.db
+      .prepare(
+        "SELECT event_json FROM cc_rollout_events WHERE thread_id = ? ORDER BY event_seq",
+      )
+      .all(id);
+    if (!rows.length && !allowMissing) {
+      throw sqliteError(
+        "CC_ROLLOUT_THREAD_NOT_FOUND",
+        `thread does not exist: ${id}`,
+      );
+    }
+    const records = rows.map((row) => {
+      try {
+        return JSON.parse(row.event_json);
+      } catch (cause) {
+        throw sqliteError(
+          "CC_ROLLOUT_CORRUPT",
+          `rollout contains invalid JSON: ${id}`,
+          cause,
+        );
+      }
+    });
+    try {
+      return verifyRecords(records, id);
+    } catch (cause) {
+      throw sqliteError("CC_ROLLOUT_CORRUPT", cause.message, cause);
+    }
+  }
+
+  _transaction(operation) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = operation();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+        // Preserve the operation error; rollback failure is secondary.
+      }
+      throw error;
+    }
+  }
+
+  start({
+    threadId = randomUUID(),
+    title = null,
+    parentThreadId = null,
+    metadata = {},
+  } = {}) {
+    const id = recordThreadId(threadId);
+    return this._transaction(() => {
+      const existing = this._read(id, { allowMissing: true });
+      if (existing.length) return projectThread(existing);
+      const record = buildRecord(
+        {
+          threadId: id,
+          eventType: "thread.started",
+          idempotencyKey: `thread:${id}`,
+          payload: { title, parentThreadId, metadata },
+        },
+        null,
+        this.now,
+      );
+      this.db
+        .prepare(
+          "INSERT INTO cc_rollout_events(thread_id, event_seq, idempotency_key, event_json) VALUES (?, ?, ?, ?)",
+        )
+        .run(
+          id,
+          record.event_seq,
+          record.idempotency_key,
+          JSON.stringify(record),
+        );
+      return projectThread([record]);
+    });
+  }
+
+  append(input) {
+    const id = recordThreadId(input?.threadId);
+    return this._transaction(() => {
+      const records = this._read(id);
+      const duplicate = input.idempotencyKey
+        ? records.find(
+            (record) => record.idempotency_key === input.idempotencyKey,
+          )
+        : null;
+      if (duplicate) {
+        if (
+          duplicate.event_type !== input.eventType ||
+          canonicalJson(duplicate.payload) !==
+            canonicalJson(input.payload ?? null)
+        ) {
+          throw sqliteError(
+            "CC_ROLLOUT_IDEMPOTENCY_CONFLICT",
+            `idempotency key was reused with different content: ${input.idempotencyKey}`,
+          );
+        }
+        return clone(duplicate);
+      }
+      const record = buildRecord(input, records.at(-1), this.now);
+      this.db
+        .prepare(
+          "INSERT INTO cc_rollout_events(thread_id, event_seq, idempotency_key, event_json) VALUES (?, ?, ?, ?)",
+        )
+        .run(
+          id,
+          record.event_seq,
+          record.idempotency_key,
+          JSON.stringify(record),
+        );
+      return clone(record);
+    });
+  }
+
+  read(threadId, { afterSeq = 0, limit = 10_000 } = {}) {
+    return clone(
+      this._read(threadId)
+        .filter((record) => record.event_seq > Number(afterSeq || 0))
+        .slice(0, Math.max(1, Math.min(100_000, Number(limit) || 10_000))),
+    );
+  }
+
+  resume(threadId) {
+    return projectThread(this._read(threadId));
+  }
+
+  list({ includeArchived = false, limit = 100 } = {}) {
+    const ids = this.db
+      .prepare(
+        "SELECT DISTINCT thread_id FROM cc_rollout_events ORDER BY thread_id",
+      )
+      .all()
+      .map((row) => row.thread_id);
+    return ids
+      .map((threadId) => this.resume(threadId))
+      .filter((thread) => includeArchived || thread.status !== "archived")
+      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+      .slice(0, Math.max(1, Number(limit) || 100));
+  }
+
+  forkThread(sourceThreadId, { threadId = randomUUID(), title = null } = {}) {
+    const source = this.resume(sourceThreadId);
+    const target = this.start({
+      threadId,
+      title: title ?? source.title,
+      parentThreadId: source.id,
+      metadata: source.metadata,
+    });
+    this.append({
+      threadId: target.id,
+      eventType: "thread.forked",
+      idempotencyKey: `fork:${source.id}:${source.headHash}`,
+      payload: {
+        sourceThreadId: source.id,
+        sourceEventSeq: source.revision,
+        sourceHeadHash: source.headHash,
+      },
+    });
+    return this.resume(target.id);
+  }
+
+  checkpoint(threadId, payload = {}) {
+    return this.append({
+      threadId,
+      eventType: "rollout.checkpoint",
+      idempotencyKey: payload.idempotencyKey || null,
+      payload: { ...payload, idempotencyKey: undefined },
+    });
+  }
+
+  compact(threadId, options = {}) {
+    return this.append({
+      threadId,
+      eventType: "rollout.compacted",
+      idempotencyKey: options.idempotencyKey || null,
+      payload: {
+        summary: String(options.summary || ""),
+        retainedState: options.retainedState || {},
+      },
+    });
+  }
+
+  archive(threadId) {
+    this.append({
+      threadId,
+      eventType: "thread.archived",
+      idempotencyKey: `archive:${threadId}`,
+      payload: {},
+    });
+    return this.resume(threadId);
+  }
+
+  migrate({ fromVersion = 1, toVersion = 1, dryRun = true } = {}) {
+    if (Number(fromVersion) !== 1 || Number(toVersion) !== 1) {
+      throw sqliteError(
+        "CC_ROLLOUT_VERSION_UNSUPPORTED",
+        "SQLite rollout adapter currently supports schema v1 only",
+      );
+    }
+    return Object.freeze({
+      schema: ROLLOUT_STORE_SCHEMA,
+      fromVersion: 1,
+      toVersion: 1,
+      dryRun: dryRun !== false,
+      changes: 0,
+      backupRequired: false,
+    });
+  }
+
+  close() {
+    this.db.close();
+  }
+}

package/src/lib/app-server/stdio-transport.js

@@ -0,0 +1,118 @@
+import { createInterface } from "node:readline";
+import { once } from "node:events";
+import { BoundedAsyncQueue, QueueOverloadedError } from "./bounded-queue.js";
+import { CcAppServer } from "./server.js";
+import { JSON_RPC_ERROR, JsonRpcError, rpcError } from "./protocol.js";
+
+export class StdioAppServerTransport {
+  constructor({
+    input = process.stdin,
+    output = process.stdout,
+    maxLineBytes = 1024 * 1024,
+    maxQueuedMessages = 512,
+    maxQueuedBytes = 8 * 1024 * 1024,
+  } = {}) {
+    this.input = input;
+    this.output = output;
+    this.maxLineBytes = maxLineBytes;
+    this.queue = new BoundedAsyncQueue({
+      maxItems: maxQueuedMessages,
+      maxBytes: maxQueuedBytes,
+      sizeOf: (line) => Buffer.byteLength(line, "utf8"),
+    });
+    this.closed = false;
+    this.failure = null;
+    this.pump = this._pump();
+  }
+
+  async _pump() {
+    try {
+      for await (const line of this.queue) {
+        if (!this.output.write(line)) await once(this.output, "drain");
+      }
+    } catch (error) {
+      this.failure = error;
+      this.queue.close(error);
+      throw error;
+    }
+  }
+
+  send(message) {
+    if (this.failure) return Promise.reject(this.failure);
+    if (this.closed)
+      return Promise.reject(new Error("stdio transport is closed"));
+    const line = `${JSON.stringify(message)}\n`;
+    try {
+      this.queue.push(line);
+      return Promise.resolve();
+    } catch (error) {
+      if (error instanceof QueueOverloadedError) {
+        this.failure = error;
+      }
+      return Promise.reject(error);
+    }
+  }
+
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.queue.close();
+    await this.pump;
+  }
+}
+
+export async function runStdioAppServer(options = {}) {
+  const input = options.input || process.stdin;
+  const transport = options.transport || new StdioAppServerTransport(options);
+  const server =
+    options.server ||
+    new CcAppServer({
+      ...options,
+      send: (message) => transport.send(message),
+    });
+  const readline = createInterface({ input, crlfDelay: Infinity });
+  const pending = new Set();
+  let fatal = null;
+  try {
+    for await (const line of readline) {
+      if (Buffer.byteLength(line, "utf8") > transport.maxLineBytes) {
+        await transport.send(
+          rpcError(
+            null,
+            new JsonRpcError(
+              JSON_RPC_ERROR.INVALID_REQUEST,
+              "JSON-RPC line exceeds the transport limit",
+            ),
+          ),
+        );
+        continue;
+      }
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        await transport.send(
+          rpcError(
+            null,
+            new JsonRpcError(JSON_RPC_ERROR.PARSE_ERROR, "Invalid JSON"),
+          ),
+        );
+        continue;
+      }
+      const request = Promise.resolve(server.receive(message)).catch(
+        (error) => {
+          fatal ||= error;
+        },
+      );
+      pending.add(request);
+      request.finally(() => pending.delete(request));
+    }
+    await Promise.all(pending);
+  } finally {
+    readline.close();
+    await server.close();
+    await transport.close();
+  }
+  if (fatal) throw fatal;
+  return server.status();
+}

package/src/lib/codex-app-server-adapter.js

@@ -0,0 +1,249 @@
+import { EventEmitter } from "node:events";
+
+export const CODEX_APP_SERVER_PROTOCOL = "codex-app-server-experimental-v1";
+export const CODEX_APP_SERVER_FEATURE_FLAG = "CC_EXPERIMENTAL_CODEX_APP_SERVER";
+
+function adapterError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "CodexAppServerAdapterError";
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+}
+
+function parseVersion(value) {
+  const match = String(value || "").match(/(\d+)\.(\d+)\.(\d+)/u);
+  return match ? match.slice(1).map(Number) : null;
+}
+
+function compareVersion(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] - right[index];
+  }
+  return 0;
+}
+
+export function isCodexAppServerVersionCompatible(version, matrix = []) {
+  const parsed = parseVersion(version);
+  if (!parsed || !Array.isArray(matrix) || matrix.length === 0) return false;
+  return matrix.some((range) => {
+    const minimum = parseVersion(range.min);
+    const maximum = parseVersion(range.maxExclusive);
+    return (
+      minimum &&
+      maximum &&
+      compareVersion(parsed, minimum) >= 0 &&
+      compareVersion(parsed, maximum) < 0
+    );
+  });
+}
+
+function projectNotification(notification) {
+  const method = notification?.method;
+  const params = notification?.params || {};
+  if (method === "thread/started") {
+    return { method: "thread/updated", params: { thread: params.thread } };
+  }
+  if (method === "turn/started") {
+    return { method: "turn/started", params: { turn: params.turn } };
+  }
+  if (["item/started", "item/updated", "item/completed"].includes(method)) {
+    const item = params.item || {};
+    const status = method === "item/completed" ? "completed" : "streaming";
+    return {
+      method: method === "item/updated" ? "item/delta" : method,
+      params: {
+        item: {
+          id: item.id,
+          kind:
+            item.type === "agent_message"
+              ? "assistant_message"
+              : item.type === "reasoning"
+                ? "reasoning"
+                : item.type === "command_execution" ||
+                    item.type === "file_change"
+                  ? "tool"
+                  : "artifact",
+          status,
+          content: item.text ?? item.content ?? item,
+        },
+      },
+      output:
+        method === "item/completed" && item.type === "agent_message"
+          ? String(item.text || "")
+          : "",
+    };
+  }
+  if (method === "turn/completed" || method === "turn/failed") {
+    const failed = method === "turn/failed";
+    return {
+      method: "turn/completed",
+      params: {
+        turn: {
+          ...params.turn,
+          status: failed ? "failed" : "completed",
+        },
+      },
+      terminal: failed ? "failed" : "completed",
+      error: failed ? params.error || "Codex App Server turn failed" : null,
+      usage: params.usage || null,
+    };
+  }
+  return { unknownMethod: String(method || "<missing>") };
+}
+
+/**
+ * Feature-gated bridge for the experimental upstream Codex App Server.
+ * It is deliberately non-authoritative and falls back to the stable
+ * `codex exec --json` adapter before admission. Once a persistent turn is
+ * admitted it never starts a duplicate fallback execution.
+ */
+export class CodexAppServerAdapter extends EventEmitter {
+  constructor({
+    client,
+    fallback,
+    upstreamVersion,
+    compatibilityMatrix = [],
+    enabled = process.env[CODEX_APP_SERVER_FEATURE_FLAG] === "1",
+    timeoutMs = 120_000,
+  } = {}) {
+    super();
+    this.client = client;
+    this.fallback = fallback;
+    this.upstreamVersion = upstreamVersion;
+    this.compatibilityMatrix = compatibilityMatrix;
+    this.enabled = enabled === true;
+    this.timeoutMs = timeoutMs;
+  }
+
+  runtimeClaims() {
+    return Object.freeze({
+      protocol: CODEX_APP_SERVER_PROTOCOL,
+      execution: "real",
+      persistence: "provider_managed",
+      stability: "experimental",
+      authoritative: false,
+      productionCritical: false,
+      featureFlag: CODEX_APP_SERVER_FEATURE_FLAG,
+      enabled: this.enabled,
+      versionCompatible: isCodexAppServerVersionCompatible(
+        this.upstreamVersion,
+        this.compatibilityMatrix,
+      ),
+      fallback: "codex-exec-jsonl-v1",
+    });
+  }
+
+  async execute({ prompt, threadId = null, ...options } = {}) {
+    const claims = this.runtimeClaims();
+    if (!claims.enabled)
+      return this._fallback(prompt, options, "feature_disabled");
+    if (!claims.versionCompatible) {
+      return this._fallback(prompt, options, "version_incompatible");
+    }
+    if (!this.client || typeof this.client.request !== "function") {
+      return this._fallback(prompt, options, "app_server_unavailable");
+    }
+    const notifications = [];
+    const unknownMethods = new Set();
+    let output = "";
+    let terminalResolve;
+    let terminalReject;
+    const terminal = new Promise((resolve, reject) => {
+      terminalResolve = resolve;
+      terminalReject = reject;
+    });
+    const timer = setTimeout(
+      () =>
+        terminalReject(
+          adapterError(
+            "CC_CODEX_APP_SERVER_TIMEOUT",
+            "Codex App Server turn timed out after admission",
+          ),
+        ),
+      this.timeoutMs,
+    );
+    timer.unref?.();
+    const onNotification = (notification) => {
+      const projected = projectNotification(notification);
+      if (projected.unknownMethod) unknownMethods.add(projected.unknownMethod);
+      else {
+        notifications.push(projected);
+        this.emit("notification", projected);
+      }
+      if (projected.output) output = projected.output;
+      if (projected.terminal) terminalResolve(projected);
+    };
+    this.client.on?.("notification", onNotification);
+    let admitted = false;
+    try {
+      if (!this.client.running && typeof this.client.start === "function") {
+        await this.client.start();
+      }
+      let activeThreadId = threadId;
+      if (!activeThreadId) {
+        const started = await this.client.request("thread/start", {
+          ephemeral: false,
+          provider: "codex",
+        });
+        activeThreadId = started?.thread?.id;
+      }
+      if (!activeThreadId) {
+        throw adapterError(
+          "CC_CODEX_APP_SERVER_PROTOCOL_FAILED",
+          "Codex App Server did not return a thread identity",
+        );
+      }
+      const started = await this.client.request("turn/start", {
+        threadId: activeThreadId,
+        input: [{ type: "text", text: String(prompt || "") }],
+      });
+      admitted = true;
+      const terminalEvent =
+        started?.turn?.status === "completed"
+          ? { terminal: "completed", usage: started.turn.usage || null }
+          : await terminal;
+      return Object.freeze({
+        protocol: CODEX_APP_SERVER_PROTOCOL,
+        threadId: activeThreadId,
+        terminal: terminalEvent.terminal,
+        output,
+        error: terminalEvent.error || null,
+        usage: terminalEvent.usage || null,
+        notifications: Object.freeze(notifications),
+        unknownMethods: Object.freeze([...unknownMethods].sort()),
+        fallback: false,
+        authoritative: false,
+      });
+    } catch (error) {
+      if (!admitted) {
+        return this._fallback(prompt, options, error?.code || "startup_failed");
+      }
+      throw adapterError(
+        "CC_CODEX_APP_SERVER_FAILED_AFTER_ADMISSION",
+        "Codex App Server failed after the turn was admitted; fallback was suppressed to prevent duplicate effects",
+        { cause: error },
+      );
+    } finally {
+      clearTimeout(timer);
+      this.client.off?.("notification", onNotification);
+    }
+  }
+
+  async _fallback(prompt, options, reason) {
+    if (typeof this.fallback !== "function") {
+      throw adapterError(
+        "CC_CODEX_APP_SERVER_FALLBACK_UNAVAILABLE",
+        `Codex App Server is unavailable and no exec fallback was provided (${reason})`,
+      );
+    }
+    const result = await this.fallback({ prompt, ...options });
+    return Object.freeze({
+      ...result,
+      protocol: "codex-exec-jsonl-v1",
+      fallback: true,
+      fallbackReason: reason,
+      authoritative: false,
+    });
+  }
+}