@covro/covro 0.0.0-stage → 0.1.0-dev.1

package/dist/codex/transport.js

@@ -0,0 +1,236 @@
+import { EventEmitter } from "node:events";
+import { AppError } from "../shared/errors.js";
+const DEFAULT_MAX_LINE_BYTES = 64 * 1024 * 1024;
+class CodexError extends AppError {
+  constructor(code, message, uncertain = false, rpcCode, diagnostics) {
+    super(code, message, 503, { uncertain, rpcCode, ...diagnostics });
+    this.uncertain = uncertain;
+    this.rpcCode = rpcCode;
+    this.name = "CodexError";
+  }
+  uncertain;
+  rpcCode;
+}
+class JsonLineReader {
+  constructor(consume, maxBytes = DEFAULT_MAX_LINE_BYTES) {
+    this.consume = consume;
+    this.maxBytes = maxBytes;
+  }
+  consume;
+  maxBytes;
+  parts = [];
+  size = 0;
+  decoder = new TextDecoder("utf-8", { fatal: true });
+  push(chunk) {
+    let start = 0;
+    while (start < chunk.length) {
+      const newline = chunk.indexOf(10, start);
+      const end = newline < 0 ? chunk.length : newline;
+      const part = chunk.subarray(start, end);
+      this.size += part.length;
+      if (this.size > this.maxBytes) {
+        const receivedBytes = this.size;
+        this.parts = [];
+        this.size = 0;
+        throw new CodexError(
+          "PROTOCOL_ERROR",
+          `Codex JSONL message exceeds the configured limit (received at least ${receivedBytes} bytes; limit ${this.maxBytes} bytes)`,
+          true,
+          void 0,
+          { receivedBytes, maxLineBytes: this.maxBytes }
+        );
+      }
+      if (part.length) this.parts.push(part);
+      if (newline < 0) break;
+      this.flush();
+      start = newline + 1;
+    }
+  }
+  finish() {
+    if (this.size) this.flush();
+  }
+  flush() {
+    const bytes = Buffer.concat(this.parts, this.size);
+    this.parts = [];
+    this.size = 0;
+    try {
+      const line = this.decoder.decode(bytes).trim();
+      if (line) this.consume(JSON.parse(line));
+    } catch (error) {
+      if (error instanceof CodexError) throw error;
+      throw new CodexError("PROTOCOL_ERROR", "Invalid UTF-8 or JSON from Codex", true);
+    }
+  }
+}
+class RpcTransport extends EventEmitter {
+  constructor(input, output, options = {}) {
+    super();
+    this.input = input;
+    this.options = options;
+    this.reader = new JsonLineReader((value) => this.receive(value), options.maxLineBytes);
+    output.on("data", (chunk) => {
+      if (this.failure) return;
+      try {
+        this.reader.push(chunk);
+      } catch (error) {
+        this.fail(asCodexError(error));
+      }
+    });
+    output.on("end", () => {
+      if (this.failure) return;
+      try {
+        this.reader.finish();
+      } catch (error) {
+        this.fail(asCodexError(error));
+      }
+      this.fail(new CodexError("CODEX_UNAVAILABLE", "Codex stdout reached EOF", true));
+    });
+    output.on(
+      "close",
+      () => this.fail(new CodexError("CODEX_UNAVAILABLE", "Codex stdout closed", true))
+    );
+    output.on(
+      "error",
+      (error) => this.fail(new CodexError("CODEX_UNAVAILABLE", error.message, true))
+    );
+    input.on(
+      "error",
+      (error) => this.fail(new CodexError("CODEX_UNAVAILABLE", error.message, true))
+    );
+  }
+  input;
+  options;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 0;
+  failure;
+  reader;
+  request(method, params, id = this.nextId++) {
+    if (this.failure) return Promise.reject(this.failure);
+    if (this.pending.has(id))
+      return Promise.reject(new CodexError("PROTOCOL_ERROR", "Duplicate outgoing RPC id"));
+    if (this.pending.size >= (this.options.maxPending ?? 256))
+      return Promise.reject(new CodexError("CODEX_BUSY", "Too many pending Codex requests"));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new CodexError(
+            "RESULT_UNKNOWN",
+            `Codex ${method} acknowledgement timed out; it may have executed`,
+            true
+          )
+        );
+      }, this.options.timeoutMs ?? 3e4);
+      this.pending.set(id, { method, resolve: (result) => resolve(result), reject, timer });
+      void this.write({ id, method, params }).catch((error) => {
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+        pending.reject(asCodexError(error));
+      });
+    });
+  }
+  notify(method, params) {
+    return this.write({ method, ...params === void 0 ? {} : { params } });
+  }
+  respond(id, result) {
+    return this.write({ id, result });
+  }
+  reject(id, code, message) {
+    return this.write({ id, error: { code, message } });
+  }
+  fail(error) {
+    if (this.failure) return;
+    error = new CodexError(error.code, error.message, error.uncertain, error.rpcCode, {
+      ...isRecord(error.details) ? error.details : {},
+      pendingRequests: [...this.pending].map(([id, pending]) => ({ id, method: pending.method }))
+    });
+    this.failure = error;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    this.emit("failure", error);
+  }
+  async write(message) {
+    if (this.failure) throw this.failure;
+    const data = JSON.stringify(message) + "\n";
+    if (this.input.destroyed || !this.input.writable)
+      throw new CodexError("CODEX_UNAVAILABLE", "Codex stdin is closed", true);
+    if (this.input.writableLength + Buffer.byteLength(data) > (this.options.maxWriteBytes ?? 4 * 1024 * 1024)) {
+      throw new CodexError("CODEX_BUSY", "Codex stdin buffer limit reached");
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const error = new CodexError("RESULT_UNKNOWN", "Codex stdin write timed out", true);
+        this.fail(error);
+        reject(error);
+      }, this.options.timeoutMs ?? 3e4);
+      this.input.write(data, (error) => {
+        clearTimeout(timer);
+        if (error) reject(new CodexError("CODEX_UNAVAILABLE", error.message, true));
+        else resolve();
+      });
+    });
+  }
+  receive(value) {
+    if (!isRecord(value))
+      throw new CodexError("PROTOCOL_ERROR", "Codex sent a non-object RPC message", true);
+    const hasId = Object.hasOwn(value, "id");
+    if (hasId && !isRpcId(value.id))
+      throw new CodexError("PROTOCOL_ERROR", "Codex sent an invalid RPC id", true);
+    if (typeof value.method === "string") {
+      if (Object.hasOwn(value, "result") || Object.hasOwn(value, "error"))
+        throw new CodexError("PROTOCOL_ERROR", "Codex mixed a method and RPC result", true);
+      if (hasId) this.emit("request", value);
+      else this.emit("notification", value);
+      return;
+    }
+    if (!hasId || Object.hasOwn(value, "result") === Object.hasOwn(value, "error"))
+      throw new CodexError("PROTOCOL_ERROR", "Unrecognized Codex RPC message", true);
+    const pending = this.pending.get(value.id);
+    if (!pending) return;
+    this.pending.delete(value.id);
+    clearTimeout(pending.timer);
+    if (Object.hasOwn(value, "error")) {
+      if (!isRecord(value.error) || typeof value.error.message !== "string" || typeof value.error.code !== "number") {
+        const error = new CodexError("PROTOCOL_ERROR", "Malformed Codex RPC error", true);
+        pending.reject(error);
+        throw error;
+      }
+      pending.reject(
+        new CodexError(
+          value.error.code === -32601 ? "PROTOCOL_INCOMPATIBLE" : "CODEX_REQUEST_FAILED",
+          value.error.message,
+          false,
+          value.error.code
+        )
+      );
+    } else pending.resolve(value.result);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRpcId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function asCodexError(error) {
+  return error instanceof CodexError ? error : new CodexError(
+    "CODEX_UNAVAILABLE",
+    error instanceof Error ? error.message : String(error),
+    true
+  );
+}
+export {
+  CodexError,
+  DEFAULT_MAX_LINE_BYTES,
+  JsonLineReader,
+  RpcTransport,
+  asCodexError,
+  isRecord,
+  isRpcId
+};
+//# sourceMappingURL=transport.js.map

package/dist/codex/transport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/codex/transport.ts"],
+  "sourcesContent": ["import { EventEmitter } from 'node:events';\nimport { AppError } from '../shared/errors.js';\nimport type { Readable, Writable } from 'node:stream';\n\nexport type RpcId = string | number;\nexport type RpcNotification = { method: string; params?: unknown };\nexport type RpcServerRequest = RpcNotification & { id: RpcId };\nexport const DEFAULT_MAX_LINE_BYTES = 64 * 1024 * 1024;\nexport class CodexError extends AppError {\n  constructor(\n    code: string,\n    message: string,\n    public readonly uncertain = false,\n    public readonly rpcCode?: number,\n    diagnostics?: Record<string, unknown>,\n  ) {\n    super(code, message, 503, { uncertain, rpcCode, ...diagnostics });\n    this.name = 'CodexError';\n  }\n}\n\n/** Buffers at most one bounded line. Decoding the complete byte sequence preserves split UTF-8. */\nexport class JsonLineReader {\n  private parts: Buffer[] = [];\n  private size = 0;\n  private readonly decoder = new TextDecoder('utf-8', { fatal: true });\n  constructor(\n    private readonly consume: (value: unknown) => void,\n    private readonly maxBytes = DEFAULT_MAX_LINE_BYTES,\n  ) {}\n  push(chunk: Buffer): void {\n    let start = 0;\n    while (start < chunk.length) {\n      const newline = chunk.indexOf(10, start);\n      const end = newline < 0 ? chunk.length : newline;\n      const part = chunk.subarray(start, end);\n      this.size += part.length;\n      if (this.size > this.maxBytes) {\n        const receivedBytes = this.size;\n        this.parts = [];\n        this.size = 0;\n        throw new CodexError(\n          'PROTOCOL_ERROR',\n          `Codex JSONL message exceeds the configured limit (received at least ${receivedBytes} bytes; limit ${this.maxBytes} bytes)`,\n          true,\n          undefined,\n          { receivedBytes, maxLineBytes: this.maxBytes },\n        );\n      }\n      if (part.length) this.parts.push(part);\n      if (newline < 0) break;\n      this.flush();\n      start = newline + 1;\n    }\n  }\n  finish(): void {\n    if (this.size) this.flush();\n  }\n  private flush(): void {\n    const bytes = Buffer.concat(this.parts, this.size);\n    this.parts = [];\n    this.size = 0;\n    try {\n      const line = this.decoder.decode(bytes).trim();\n      if (line) this.consume(JSON.parse(line) as unknown);\n    } catch (error) {\n      if (error instanceof CodexError) throw error;\n      throw new CodexError('PROTOCOL_ERROR', 'Invalid UTF-8 or JSON from Codex', true);\n    }\n  }\n}\n\ntype Pending = {\n  method: string;\n  resolve: (value: unknown) => void;\n  reject: (error: Error) => void;\n  timer: NodeJS.Timeout;\n};\nexport type TransportOptions = {\n  timeoutMs?: number;\n  maxLineBytes?: number;\n  maxPending?: number;\n  maxWriteBytes?: number;\n};\n\n/** RPC receipt deadlines do not cancel upstream turns. A timeout always reports an uncertain outcome. */\nexport class RpcTransport extends EventEmitter {\n  private readonly pending = new Map<RpcId, Pending>();\n  private nextId = 0;\n  private failure?: CodexError;\n  private readonly reader: JsonLineReader;\n  constructor(\n    private readonly input: Writable,\n    output: Readable,\n    private readonly options: TransportOptions = {},\n  ) {\n    super();\n    this.reader = new JsonLineReader((value) => this.receive(value), options.maxLineBytes);\n    output.on('data', (chunk: Buffer) => {\n      if (this.failure) return;\n      try {\n        this.reader.push(chunk);\n      } catch (error) {\n        this.fail(asCodexError(error));\n      }\n    });\n    output.on('end', () => {\n      if (this.failure) return;\n      try {\n        this.reader.finish();\n      } catch (error) {\n        this.fail(asCodexError(error));\n      }\n      this.fail(new CodexError('CODEX_UNAVAILABLE', 'Codex stdout reached EOF', true));\n    });\n    output.on('close', () =>\n      this.fail(new CodexError('CODEX_UNAVAILABLE', 'Codex stdout closed', true)),\n    );\n    output.on('error', (error) =>\n      this.fail(new CodexError('CODEX_UNAVAILABLE', error.message, true)),\n    );\n    input.on('error', (error) =>\n      this.fail(new CodexError('CODEX_UNAVAILABLE', error.message, true)),\n    );\n  }\n  request<T>(method: string, params: unknown, id: RpcId = this.nextId++): Promise<T> {\n    if (this.failure) return Promise.reject(this.failure);\n    if (this.pending.has(id))\n      return Promise.reject(new CodexError('PROTOCOL_ERROR', 'Duplicate outgoing RPC id'));\n    if (this.pending.size >= (this.options.maxPending ?? 256))\n      return Promise.reject(new CodexError('CODEX_BUSY', 'Too many pending Codex requests'));\n    return new Promise<T>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        this.pending.delete(id);\n        reject(\n          new CodexError(\n            'RESULT_UNKNOWN',\n            `Codex ${method} acknowledgement timed out; it may have executed`,\n            true,\n          ),\n        );\n      }, this.options.timeoutMs ?? 30_000);\n      this.pending.set(id, { method, resolve: (result) => resolve(result as T), reject, timer });\n      void this.write({ id, method, params }).catch((error: unknown) => {\n        const pending = this.pending.get(id);\n        if (!pending) return;\n        clearTimeout(pending.timer);\n        this.pending.delete(id);\n        pending.reject(asCodexError(error));\n      });\n    });\n  }\n  notify(method: string, params?: unknown): Promise<void> {\n    return this.write({ method, ...(params === undefined ? {} : { params }) });\n  }\n  respond(id: RpcId, result: unknown): Promise<void> {\n    return this.write({ id, result });\n  }\n  reject(id: RpcId, code: number, message: string): Promise<void> {\n    return this.write({ id, error: { code, message } });\n  }\n  fail(error: CodexError): void {\n    if (this.failure) return;\n    error = new CodexError(error.code, error.message, error.uncertain, error.rpcCode, {\n      ...(isRecord(error.details) ? error.details : {}),\n      pendingRequests: [...this.pending].map(([id, pending]) => ({ id, method: pending.method })),\n    });\n    this.failure = error;\n    for (const pending of this.pending.values()) {\n      clearTimeout(pending.timer);\n      pending.reject(error);\n    }\n    this.pending.clear();\n    this.emit('failure', error);\n  }\n  private async write(message: unknown): Promise<void> {\n    if (this.failure) throw this.failure;\n    const data = JSON.stringify(message) + '\\n';\n    if (this.input.destroyed || !this.input.writable)\n      throw new CodexError('CODEX_UNAVAILABLE', 'Codex stdin is closed', true);\n    if (\n      this.input.writableLength + Buffer.byteLength(data) >\n      (this.options.maxWriteBytes ?? 4 * 1024 * 1024)\n    ) {\n      throw new CodexError('CODEX_BUSY', 'Codex stdin buffer limit reached');\n    }\n    await new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        const error = new CodexError('RESULT_UNKNOWN', 'Codex stdin write timed out', true);\n        this.fail(error);\n        reject(error);\n      }, this.options.timeoutMs ?? 30_000);\n      this.input.write(data, (error) => {\n        clearTimeout(timer);\n        if (error) reject(new CodexError('CODEX_UNAVAILABLE', error.message, true));\n        else resolve();\n      });\n    });\n  }\n  private receive(value: unknown): void {\n    if (!isRecord(value))\n      throw new CodexError('PROTOCOL_ERROR', 'Codex sent a non-object RPC message', true);\n    const hasId = Object.hasOwn(value, 'id');\n    if (hasId && !isRpcId(value.id))\n      throw new CodexError('PROTOCOL_ERROR', 'Codex sent an invalid RPC id', true);\n    if (typeof value.method === 'string') {\n      if (Object.hasOwn(value, 'result') || Object.hasOwn(value, 'error'))\n        throw new CodexError('PROTOCOL_ERROR', 'Codex mixed a method and RPC result', true);\n      if (hasId) this.emit('request', value as RpcServerRequest);\n      else this.emit('notification', value as RpcNotification);\n      return;\n    }\n    if (!hasId || Object.hasOwn(value, 'result') === Object.hasOwn(value, 'error'))\n      throw new CodexError('PROTOCOL_ERROR', 'Unrecognized Codex RPC message', true);\n    const pending = this.pending.get(value.id as RpcId);\n    if (!pending) return; // Late receipts after a timeout must never cause a prompt to be resent.\n    this.pending.delete(value.id as RpcId);\n    clearTimeout(pending.timer);\n    if (Object.hasOwn(value, 'error')) {\n      if (\n        !isRecord(value.error) ||\n        typeof value.error.message !== 'string' ||\n        typeof value.error.code !== 'number'\n      ) {\n        const error = new CodexError('PROTOCOL_ERROR', 'Malformed Codex RPC error', true);\n        pending.reject(error);\n        throw error;\n      }\n      pending.reject(\n        new CodexError(\n          value.error.code === -32601 ? 'PROTOCOL_INCOMPATIBLE' : 'CODEX_REQUEST_FAILED',\n          value.error.message,\n          false,\n          value.error.code,\n        ),\n      );\n    } else pending.resolve(value.result);\n  }\n}\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\nexport function isRpcId(value: unknown): value is RpcId {\n  return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value));\n}\nexport function asCodexError(error: unknown): CodexError {\n  return error instanceof CodexError\n    ? error\n    : new CodexError(\n        'CODEX_UNAVAILABLE',\n        error instanceof Error ? error.message : String(error),\n        true,\n      );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/codex/turn-token-usage.js

@@ -0,0 +1,46 @@
+class TurnTokenUsage {
+  threads = /* @__PURE__ */ new Map();
+  clear() {
+    this.threads.clear();
+  }
+  created(threadId) {
+    if (!this.threads.has(threadId)) this.threads.set(threadId, { total: 0 });
+  }
+  started(threadId, turnId) {
+    const state = this.threads.get(threadId) ?? {};
+    if (state.active?.id === turnId) return;
+    state.active = { id: turnId, baseline: state.total, invalid: false };
+    this.threads.set(threadId, state);
+  }
+  updated(threadId, turnId, total) {
+    const state = this.threads.get(threadId) ?? {};
+    const active = state.active;
+    if (active && active.id !== turnId) return;
+    if (!Number.isSafeInteger(total) || total < 0) {
+      if (active) active.invalid = true;
+      delete state.total;
+    } else {
+      if (active) {
+        if (state.total !== void 0 && total < state.total) active.invalid = true;
+        if (active.baseline !== void 0) active.outputTokens = total - active.baseline;
+      }
+      state.total = total;
+    }
+    this.threads.set(threadId, state);
+  }
+  compacted(threadId, turnId) {
+    const active = this.threads.get(threadId)?.active;
+    if (active?.id === turnId) active.invalid = true;
+  }
+  completed(threadId, turnId) {
+    const state = this.threads.get(threadId);
+    if (state?.active?.id !== turnId) return void 0;
+    const active = state.active;
+    delete state.active;
+    return active.invalid ? void 0 : active.outputTokens;
+  }
+}
+export {
+  TurnTokenUsage
+};
+//# sourceMappingURL=turn-token-usage.js.map

package/dist/codex/turn-token-usage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/codex/turn-token-usage.ts"],
+  "sourcesContent": ["/** Thread usage is cumulative; `last` describes one model response, not one turn. */\nexport class TurnTokenUsage {\n  private readonly threads = new Map<\n    string,\n    {\n      total?: number;\n      active?: { id: string; baseline?: number; outputTokens?: number; invalid: boolean };\n    }\n  >();\n\n  clear(): void {\n    this.threads.clear();\n  }\n\n  created(threadId: string): void {\n    if (!this.threads.has(threadId)) this.threads.set(threadId, { total: 0 });\n  }\n\n  started(threadId: string, turnId: string): void {\n    const state = this.threads.get(threadId) ?? {};\n    if (state.active?.id === turnId) return;\n    state.active = { id: turnId, baseline: state.total, invalid: false };\n    this.threads.set(threadId, state);\n  }\n\n  updated(threadId: string, turnId: string, total: number): void {\n    const state = this.threads.get(threadId) ?? {};\n    const active = state.active;\n    // A replay of another turn's usage must not become this turn's baseline or result.\n    if (active && active.id !== turnId) return;\n    if (!Number.isSafeInteger(total) || total < 0) {\n      if (active) active.invalid = true;\n      delete state.total;\n    } else {\n      if (active) {\n        if (state.total !== undefined && total < state.total) active.invalid = true;\n        if (active.baseline !== undefined) active.outputTokens = total - active.baseline;\n      }\n      state.total = total;\n    }\n    this.threads.set(threadId, state);\n  }\n\n  compacted(threadId: string, turnId: string): void {\n    const active = this.threads.get(threadId)?.active;\n    // Compaction can replace cumulative counters. Do not subtract across that reset.\n    if (active?.id === turnId) active.invalid = true;\n  }\n\n  completed(threadId: string, turnId: string): number | undefined {\n    const state = this.threads.get(threadId);\n    if (state?.active?.id !== turnId) return undefined;\n    const active = state.active;\n    delete state.active;\n    return active.invalid ? undefined : active.outputTokens;\n  }\n}\n"],
+  "mappings": "AACO,MAAM,eAAe;AAAA,EACT,UAAU,oBAAI,IAM7B;AAAA,EAEF,QAAc;AACZ,SAAK,QAAQ,MAAM;AAAA,EACrB;AAAA,EAEA,QAAQ,UAAwB;AAC9B,QAAI,CAAC,KAAK,QAAQ,IAAI,QAAQ,EAAG,MAAK,QAAQ,IAAI,UAAU,EAAE,OAAO,EAAE,CAAC;AAAA,EAC1E;AAAA,EAEA,QAAQ,UAAkB,QAAsB;AAC9C,UAAM,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,CAAC;AAC7C,QAAI,MAAM,QAAQ,OAAO,OAAQ;AACjC,UAAM,SAAS,EAAE,IAAI,QAAQ,UAAU,MAAM,OAAO,SAAS,MAAM;AACnE,SAAK,QAAQ,IAAI,UAAU,KAAK;AAAA,EAClC;AAAA,EAEA,QAAQ,UAAkB,QAAgB,OAAqB;AAC7D,UAAM,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,CAAC;AAC7C,UAAM,SAAS,MAAM;AAErB,QAAI,UAAU,OAAO,OAAO,OAAQ;AACpC,QAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAAG;AAC7C,UAAI,OAAQ,QAAO,UAAU;AAC7B,aAAO,MAAM;AAAA,IACf,OAAO;AACL,UAAI,QAAQ;AACV,YAAI,MAAM,UAAU,UAAa,QAAQ,MAAM,MAAO,QAAO,UAAU;AACvE,YAAI,OAAO,aAAa,OAAW,QAAO,eAAe,QAAQ,OAAO;AAAA,MAC1E;AACA,YAAM,QAAQ;AAAA,IAChB;AACA,SAAK,QAAQ,IAAI,UAAU,KAAK;AAAA,EAClC;AAAA,EAEA,UAAU,UAAkB,QAAsB;AAChD,UAAM,SAAS,KAAK,QAAQ,IAAI,QAAQ,GAAG;AAE3C,QAAI,QAAQ,OAAO,OAAQ,QAAO,UAAU;AAAA,EAC9C;AAAA,EAEA,UAAU,UAAkB,QAAoC;AAC9D,UAAM,QAAQ,KAAK,QAAQ,IAAI,QAAQ;AACvC,QAAI,OAAO,QAAQ,OAAO,OAAQ,QAAO;AACzC,UAAM,SAAS,MAAM;AACrB,WAAO,MAAM;AACb,WAAO,OAAO,UAAU,SAAY,OAAO;AAAA,EAC7C;AACF;",
+  "names": []
+}

package/dist/codex/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/codex/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/drizzle/0000_past_wildside.sql

@@ -0,0 +1,45 @@
+CREATE TABLE `execution_markers` (
+	`operation_id` text PRIMARY KEY NOT NULL,
+	`thread_id` text NOT NULL,
+	`turn_id` text,
+	`workspace_key` text NOT NULL,
+	`codex_epoch` text NOT NULL,
+	`state` text NOT NULL,
+	`created_at` integer NOT NULL,
+	`ended_at` integer,
+	`reconciled_at` integer,
+	`reconciliation_operation_id` text,
+	FOREIGN KEY (`operation_id`) REFERENCES `operations`(`client_operation_id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`reconciliation_operation_id`) REFERENCES `operations`(`client_operation_id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "execution_markers_state_check" CHECK("execution_markers"."state" in ('active', 'unknown', 'terminal', 'reconciled'))
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `execution_markers_active_thread` ON `execution_markers` (`thread_id`) WHERE "execution_markers"."ended_at" is null;--> statement-breakpoint
+CREATE UNIQUE INDEX `execution_markers_active_workspace` ON `execution_markers` (`workspace_key`) WHERE "execution_markers"."ended_at" is null;--> statement-breakpoint
+CREATE TABLE `operations` (
+	`client_operation_id` text PRIMARY KEY NOT NULL,
+	`kind` text NOT NULL,
+	`target` text NOT NULL,
+	`request_digest` text NOT NULL,
+	`state` text NOT NULL,
+	`result` text,
+	`error` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT "operations_state_check" CHECK("operations"."state" in ('accepted', 'dispatching', 'acknowledged', 'failed', 'unknown'))
+);
+--> statement-breakpoint
+CREATE INDEX `operations_state_idx` ON `operations` (`state`);--> statement-breakpoint
+CREATE TABLE `preferences` (
+	`key` text PRIMARY KEY NOT NULL,
+	`value` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `thread_links` (
+	`thread_id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`cwd` text NOT NULL,
+	`source` text NOT NULL,
+	`managed_epoch` text,
+	`updated_at` integer NOT NULL
+);

package/dist/drizzle/0001_shocking_ender_wiggin.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `operations` ADD `reconciled_at` integer;--> statement-breakpoint
+ALTER TABLE `operations` ADD `reconciliation_decision` text;

package/dist/drizzle/0002_allow_parallel_threads.sql

@@ -0,0 +1 @@
+DROP INDEX `execution_markers_active_workspace`;

package/dist/drizzle/0003_project_registrations.sql

@@ -0,0 +1,11 @@
+CREATE TABLE `project_registrations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`path` text NOT NULL,
+	`canonical_root` text,
+	`removed_at` integer,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE `operations` ADD `project_id` text;

package/dist/drizzle/0004_turn_usage.sql

@@ -0,0 +1,6 @@
+CREATE TABLE `turn_usage` (
+	`thread_id` text NOT NULL,
+	`turn_id` text NOT NULL,
+	`output_tokens` integer NOT NULL,
+	PRIMARY KEY(`thread_id`, `turn_id`)
+);