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

package/dist/server/config-store.js

@@ -0,0 +1,147 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, lstat, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import lockfile from "proper-lockfile";
+import { z } from "zod";
+import { AppError } from "../shared/errors.js";
+import { configSource, parseConfig, parseFileConfig } from "./config.js";
+const saveSchema = z.object({ revision: z.string().regex(/^[a-f0-9]{64}$/), config: z.unknown() }).strict();
+const importSchema = z.object({ config: z.unknown() }).strict();
+const revision = (text) => createHash("sha256").update(text).digest("hex");
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const MAX_CONFIG_BYTES = 256 * 1024;
+class ConfigStore {
+  source;
+  running;
+  constructor(config) {
+    this.source = configSource(config);
+    const { demo: _demo, ...running } = config;
+    this.running = structuredClone(running);
+  }
+  async read() {
+    if (!this.source)
+      throw new AppError("CONFIG_UNAVAILABLE", "\u6B64\u5B9E\u4F8B\u672A\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\uFF0C\u65E0\u6CD5\u7BA1\u7406\u670D\u52A1\u914D\u7F6E\u3002", 503);
+    try {
+      const stat = await lstat(this.source.path);
+      if (stat.size > MAX_CONFIG_BYTES)
+        throw new AppError("INVALID_CONFIG", "\u914D\u7F6E\u6587\u4EF6\u4E0D\u80FD\u8D85\u8FC7 256 KiB\u3002");
+      const text = await readFile(this.source.path, "utf8");
+      if (Buffer.byteLength(text) > MAX_CONFIG_BYTES)
+        throw new AppError("INVALID_CONFIG", "\u914D\u7F6E\u6587\u4EF6\u4E0D\u80FD\u8D85\u8FC7 256 KiB\u3002");
+      let value;
+      try {
+        value = JSON.parse(text);
+      } catch {
+        throw new AppError("INVALID_CONFIG", "\u914D\u7F6E\u6587\u4EF6\u4E0D\u662F\u6709\u6548\u7684 JSON\uFF0C\u8BF7\u5148\u4FEE\u590D\u6587\u4EF6\u3002");
+      }
+      return { saved: parseFileConfig(value), revision: revision(text), stat };
+    } catch (error) {
+      if (error instanceof AppError) throw error;
+      throw new AppError(
+        "CONFIG_READ_FAILED",
+        "\u65E0\u6CD5\u8BFB\u53D6\u542F\u52A8\u65F6\u6307\u5B9A\u7684\u914D\u7F6E\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u548C\u6743\u9650\u3002",
+        503
+      );
+    }
+  }
+  async snapshot() {
+    const file = await this.read();
+    let readOnlyReason;
+    if (!file.stat.isFile())
+      readOnlyReason = "\u8F6F\u94FE\u63A5\u6216\u7279\u6B8A\u914D\u7F6E\u6587\u4EF6\u53EA\u652F\u6301\u67E5\u770B\u548C\u5BFC\u51FA\uFF0C\u8BF7\u76F4\u63A5\u7F16\u8F91\u6E90\u6587\u4EF6\u3002";
+    else {
+      try {
+        await access(this.source.path, constants.W_OK);
+        await access(dirname(this.source.path), constants.W_OK);
+      } catch {
+        readOnlyReason = "\u914D\u7F6E\u6587\u4EF6\u6216\u6240\u5728\u76EE\u5F55\u4E0D\u53EF\u5199\uFF0C\u8BF7\u8C03\u6574\u670D\u52A1\u8FDB\u7A0B\u7684\u6587\u4EF6\u6743\u9650\u3002";
+      }
+    }
+    const { demo: _demo, ...effective } = parseConfig(
+      file.saved,
+      this.source.path,
+      this.source.development
+    );
+    return {
+      path: this.source.path,
+      revision: file.revision,
+      saved: file.saved,
+      running: this.running,
+      restartRequired: !same(effective, this.running),
+      writable: !readOnlyReason,
+      ...readOnlyReason ? { readOnlyReason } : {}
+    };
+  }
+  async previewImport(input) {
+    const imported = parseFileConfig(importSchema.parse(input).config);
+    const { saved } = await this.read();
+    const preserved = ["dataDir", "projects"].filter(
+      (key) => !same(imported[key], saved[key])
+    );
+    return { config: { ...imported, dataDir: saved.dataDir, projects: saved.projects }, preserved };
+  }
+  async export() {
+    return (await this.read()).saved;
+  }
+  async save(input) {
+    const parsed = saveSchema.parse(input);
+    const config = parseFileConfig(parsed.config);
+    const initial = await this.snapshot();
+    if (!initial.writable) throw new AppError("CONFIG_READ_ONLY", initial.readOnlyReason, 409);
+    let release;
+    const temporary = join(dirname(this.source.path), `.codex-config-${randomUUID()}.tmp`);
+    try {
+      try {
+        release = await lockfile.lock(this.source.path, { realpath: false, retries: 0 });
+      } catch {
+        throw new AppError("CONFIG_BUSY", "\u914D\u7F6E\u6B63\u5728\u88AB\u5176\u4ED6\u64CD\u4F5C\u4FDD\u5B58\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", 409);
+      }
+      const current = await this.snapshot();
+      if (!current.writable) throw new AppError("CONFIG_READ_ONLY", current.readOnlyReason, 409);
+      if (current.revision !== parsed.revision)
+        throw new AppError(
+          "CONFIG_CONFLICT",
+          "\u914D\u7F6E\u6587\u4EF6\u5DF2\u88AB\u5176\u4ED6\u9875\u9762\u6216\u7A0B\u5E8F\u4FEE\u6539\u3002\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u4FDD\u5B58\u3002",
+          409
+        );
+      if (config.dataDir !== current.saved.dataDir || !same(config.projects, current.saved.projects))
+        throw new AppError(
+          "CONFIG_PROTECTED",
+          "\u6570\u636E\u76EE\u5F55\u4E0D\u53EF\u5728\u6B64\u4FEE\u6539\uFF1B\u9879\u76EE\u8BF7\u4F7F\u7528\u9879\u76EE\u7BA1\u7406\u529F\u80FD\u3002",
+          400
+        );
+      const contents = `${JSON.stringify(config, null, 2)}
+`;
+      if (Buffer.byteLength(contents) > MAX_CONFIG_BYTES)
+        throw new AppError("INVALID_CONFIG", "\u914D\u7F6E\u6587\u4EF6\u4E0D\u80FD\u8D85\u8FC7 256 KiB\u3002");
+      const file = await open(temporary, "wx", 384);
+      try {
+        await file.writeFile(contents, "utf8");
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      const latest = await this.snapshot();
+      if (latest.revision !== current.revision || !latest.writable)
+        throw new AppError("CONFIG_CONFLICT", "\u914D\u7F6E\u6587\u4EF6\u5DF2\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u4FDD\u5B58\u3002", 409);
+      await rename(temporary, this.source.path);
+      return await this.snapshot();
+    } catch (error) {
+      if (error instanceof AppError) throw error;
+      throw new AppError(
+        "CONFIG_WRITE_FAILED",
+        "\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\u548C\u78C1\u76D8\u7A7A\u95F4\u540E\u91CD\u8BD5\u3002",
+        500
+      );
+    } finally {
+      await rm(temporary, { force: true });
+      await release?.();
+    }
+  }
+}
+export {
+  ConfigStore,
+  MAX_CONFIG_BYTES
+};
+//# sourceMappingURL=config-store.js.map

package/dist/server/config-store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/server/config-store.ts"],
+  "sourcesContent": ["import { createHash, randomUUID } from 'node:crypto';\nimport { constants } from 'node:fs';\nimport { access, lstat, open, readFile, rename, rm } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\nimport lockfile from 'proper-lockfile';\nimport { z } from 'zod';\nimport { AppError } from '../shared/errors.js';\nimport type { GatewayConfig, GatewayConfigSnapshot } from '../shared/gateway-config.js';\nimport { configSource, parseConfig, parseFileConfig, type AppConfig } from './config.js';\n\nconst saveSchema = z\n  .object({ revision: z.string().regex(/^[a-f0-9]{64}$/), config: z.unknown() })\n  .strict();\nconst importSchema = z.object({ config: z.unknown() }).strict();\nconst revision = (text: string) => createHash('sha256').update(text).digest('hex');\nconst same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);\nexport const MAX_CONFIG_BYTES = 256 * 1024;\n\n/** The running configuration is immutable; this store only changes the next startup's file. */\nexport class ConfigStore {\n  private readonly source;\n  private readonly running: GatewayConfig;\n  constructor(config: AppConfig) {\n    this.source = configSource(config);\n    const { demo: _demo, ...running } = config;\n    this.running = structuredClone(running);\n  }\n\n  private async read() {\n    if (!this.source)\n      throw new AppError('CONFIG_UNAVAILABLE', '\u6B64\u5B9E\u4F8B\u672A\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\uFF0C\u65E0\u6CD5\u7BA1\u7406\u670D\u52A1\u914D\u7F6E\u3002', 503);\n    try {\n      const stat = await lstat(this.source.path);\n      if (stat.size > MAX_CONFIG_BYTES)\n        throw new AppError('INVALID_CONFIG', '\u914D\u7F6E\u6587\u4EF6\u4E0D\u80FD\u8D85\u8FC7 256 KiB\u3002');\n      const text = await readFile(this.source.path, 'utf8');\n      if (Buffer.byteLength(text) > MAX_CONFIG_BYTES)\n        throw new AppError('INVALID_CONFIG', '\u914D\u7F6E\u6587\u4EF6\u4E0D\u80FD\u8D85\u8FC7 256 KiB\u3002');\n      let value: unknown;\n      try {\n        value = JSON.parse(text);\n      } catch {\n        throw new AppError('INVALID_CONFIG', '\u914D\u7F6E\u6587\u4EF6\u4E0D\u662F\u6709\u6548\u7684 JSON\uFF0C\u8BF7\u5148\u4FEE\u590D\u6587\u4EF6\u3002');\n      }\n      return { saved: parseFileConfig(value), revision: revision(text), stat };\n    } catch (error) {\n      if (error instanceof AppError) throw error;\n      throw new AppError(\n        'CONFIG_READ_FAILED',\n        '\u65E0\u6CD5\u8BFB\u53D6\u542F\u52A8\u65F6\u6307\u5B9A\u7684\u914D\u7F6E\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u548C\u6743\u9650\u3002',\n        503,\n      );\n    }\n  }\n\n  async snapshot(): Promise<GatewayConfigSnapshot> {\n    const file = await this.read();\n    let readOnlyReason: string | undefined;\n    if (!file.stat.isFile())\n      readOnlyReason = '\u8F6F\u94FE\u63A5\u6216\u7279\u6B8A\u914D\u7F6E\u6587\u4EF6\u53EA\u652F\u6301\u67E5\u770B\u548C\u5BFC\u51FA\uFF0C\u8BF7\u76F4\u63A5\u7F16\u8F91\u6E90\u6587\u4EF6\u3002';\n    else {\n      try {\n        await access(this.source!.path, constants.W_OK);\n        await access(dirname(this.source!.path), constants.W_OK);\n      } catch {\n        readOnlyReason = '\u914D\u7F6E\u6587\u4EF6\u6216\u6240\u5728\u76EE\u5F55\u4E0D\u53EF\u5199\uFF0C\u8BF7\u8C03\u6574\u670D\u52A1\u8FDB\u7A0B\u7684\u6587\u4EF6\u6743\u9650\u3002';\n      }\n    }\n    const { demo: _demo, ...effective } = parseConfig(\n      file.saved,\n      this.source!.path,\n      this.source!.development,\n    );\n    return {\n      path: this.source!.path,\n      revision: file.revision,\n      saved: file.saved,\n      running: this.running,\n      restartRequired: !same(effective, this.running),\n      writable: !readOnlyReason,\n      ...(readOnlyReason ? { readOnlyReason } : {}),\n    };\n  }\n\n  async previewImport(input: unknown) {\n    const imported = parseFileConfig(importSchema.parse(input).config);\n    const { saved } = await this.read();\n    const preserved = (['dataDir', 'projects'] as const).filter(\n      (key) => !same(imported[key], saved[key]),\n    );\n    return { config: { ...imported, dataDir: saved.dataDir, projects: saved.projects }, preserved };\n  }\n\n  async export() {\n    return (await this.read()).saved;\n  }\n\n  async save(input: unknown): Promise<GatewayConfigSnapshot> {\n    const parsed = saveSchema.parse(input);\n    const config = parseFileConfig(parsed.config);\n    const initial = await this.snapshot();\n    if (!initial.writable) throw new AppError('CONFIG_READ_ONLY', initial.readOnlyReason!, 409);\n    let release: (() => Promise<void>) | undefined;\n    const temporary = join(dirname(this.source!.path), `.codex-config-${randomUUID()}.tmp`);\n    try {\n      try {\n        release = await lockfile.lock(this.source!.path, { realpath: false, retries: 0 });\n      } catch {\n        throw new AppError('CONFIG_BUSY', '\u914D\u7F6E\u6B63\u5728\u88AB\u5176\u4ED6\u64CD\u4F5C\u4FDD\u5B58\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002', 409);\n      }\n      const current = await this.snapshot();\n      if (!current.writable) throw new AppError('CONFIG_READ_ONLY', current.readOnlyReason!, 409);\n      if (current.revision !== parsed.revision)\n        throw new AppError(\n          'CONFIG_CONFLICT',\n          '\u914D\u7F6E\u6587\u4EF6\u5DF2\u88AB\u5176\u4ED6\u9875\u9762\u6216\u7A0B\u5E8F\u4FEE\u6539\u3002\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u4FDD\u5B58\u3002',\n          409,\n        );\n      if (\n        config.dataDir !== current.saved.dataDir ||\n        !same(config.projects, current.saved.projects)\n      )\n        throw new AppError(\n          'CONFIG_PROTECTED',\n          '\u6570\u636E\u76EE\u5F55\u4E0D\u53EF\u5728\u6B64\u4FEE\u6539\uFF1B\u9879\u76EE\u8BF7\u4F7F\u7528\u9879\u76EE\u7BA1\u7406\u529F\u80FD\u3002',\n          400,\n        );\n      const contents = `${JSON.stringify(config, null, 2)}\\n`;\n      if (Buffer.byteLength(contents) > MAX_CONFIG_BYTES)\n        throw new AppError('INVALID_CONFIG', '\u914D\u7F6E\u6587\u4EF6\u4E0D\u80FD\u8D85\u8FC7 256 KiB\u3002');\n      const file = await open(temporary, 'wx', 0o600);\n      try {\n        await file.writeFile(contents, 'utf8');\n        await file.sync();\n      } finally {\n        await file.close();\n      }\n      // Catch external editors that changed the file while the temporary file was written.\n      const latest = await this.snapshot();\n      if (latest.revision !== current.revision || !latest.writable)\n        throw new AppError('CONFIG_CONFLICT', '\u914D\u7F6E\u6587\u4EF6\u5DF2\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u4FDD\u5B58\u3002', 409);\n      await rename(temporary, this.source!.path);\n      return await this.snapshot();\n    } catch (error) {\n      if (error instanceof AppError) throw error;\n      throw new AppError(\n        'CONFIG_WRITE_FAILED',\n        '\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\u548C\u78C1\u76D8\u7A7A\u95F4\u540E\u91CD\u8BD5\u3002',\n        500,\n      );\n    } finally {\n      await rm(temporary, { force: true });\n      await release?.();\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/server/config.js

@@ -0,0 +1,124 @@
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+import { AppError } from "../shared/errors.js";
+import { DEFAULT_MAX_LINE_BYTES } from "../codex/transport.js";
+const origin = z.string().regex(/^https?:\/\/[^/?#\\\s]+\/?$/i, "Expected an exact HTTP(S) origin").pipe(z.string().url()).transform((value, context) => {
+  const url = new URL(value);
+  if (!["http:", "https:"].includes(url.protocol) || url.hostname.includes("*") || value.includes("@") || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected an exact HTTP(S) origin without wildcard, path, credentials, query or hash"
+    });
+    return z.NEVER;
+  }
+  return url.origin;
+});
+const project = z.object({
+  id: z.string().regex(/^[a-zA-Z0-9_-]+$/),
+  name: z.string().min(1),
+  path: z.string().refine(isAbsolute, "Project path must be absolute")
+}).strict();
+const configSchema = z.object({
+  host: z.string().default("127.0.0.1"),
+  port: z.number().int().min(1).max(65535).default(8787),
+  publicOrigin: z.array(origin).min(1).default(["http://127.0.0.1:8787"]).transform((values) => [...new Set(values)]),
+  developmentOrigins: z.array(origin).default([]),
+  dataDir: z.string().min(1).default("./.local/codex-web"),
+  codex: z.object({
+    binary: z.string().min(1).default("codex"),
+    home: z.string().refine(isAbsolute).optional(),
+    requestTimeoutMs: z.number().int().min(100).max(3e5).default(3e4),
+    maxLineBytes: z.number().int().min(1024).max(256 * 1024 * 1024).default(DEFAULT_MAX_LINE_BYTES)
+  }).strict().default({ binary: "codex", requestTimeoutMs: 3e4, maxLineBytes: DEFAULT_MAX_LINE_BYTES }),
+  auth: z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("local") }).strict(),
+    z.object({
+      mode: z.literal("cloudflare-access"),
+      issuer: z.string().url(),
+      audience: z.string().min(1)
+    }).strict()
+  ]).default({ mode: "local" }),
+  projects: z.array(project).default([]),
+  limits: z.object({
+    eventBytes: z.number().int().min(1024).max(64 * 1024 * 1024).default(16 * 1024 * 1024),
+    wsBytes: z.number().int().min(1024).max(16 * 1024 * 1024).default(4 * 1024 * 1024),
+    itemBytes: z.number().int().min(1024).max(8 * 1024 * 1024).default(2 * 1024 * 1024)
+  }).strict().default({
+    eventBytes: 16 * 1024 * 1024,
+    wsBytes: 4 * 1024 * 1024,
+    itemBytes: 2 * 1024 * 1024
+  })
+}).strict();
+const sources = /* @__PURE__ */ new WeakMap();
+const configSource = (config) => sources.get(config);
+function isLoopback(hostname) {
+  return ["127.0.0.1", "localhost", "::1", "[::1]"].includes(hostname);
+}
+function parseFileConfig(value) {
+  const parsed = configSchema.safeParse(value);
+  if (!parsed.success)
+    throw new AppError(
+      "INVALID_CONFIG",
+      parsed.error.issues.map((issue) => `${issue.path.join(".") || "\u914D\u7F6E"}: ${issue.message}`).join("\n")
+    );
+  const config = parsed.data;
+  if (new Set(config.projects.map((p) => p.id)).size !== config.projects.length)
+    throw new AppError("INVALID_CONFIG", "Project IDs must be unique");
+  if (config.auth.mode === "local" && !isLoopback(config.host))
+    throw new AppError("INVALID_CONFIG", "Local mode requires a loopback host");
+  if (config.developmentOrigins.some((o) => !isLoopback(new URL(o).hostname)))
+    throw new AppError("INVALID_CONFIG", "Development origins must be loopback");
+  if (config.auth.mode === "cloudflare-access") {
+    const issuer = new URL(config.auth.issuer);
+    if (issuer.protocol !== "https:" || !issuer.hostname.endsWith(".cloudflareaccess.com") || issuer.pathname !== "/" || issuer.search || issuer.hash || issuer.username || issuer.password)
+      throw new AppError(
+        "INVALID_CONFIG",
+        "Access issuer must be https://<team>.cloudflareaccess.com"
+      );
+    if (config.publicOrigin.some((value2) => new URL(value2).protocol !== "https:"))
+      throw new AppError("INVALID_CONFIG", "All Access public origins must use HTTPS");
+    config.auth.issuer = issuer.origin;
+  }
+  return config;
+}
+function parseConfig(value, filename, development = false) {
+  const config = parseFileConfig(value);
+  const result = {
+    ...config,
+    developmentOrigins: development ? config.developmentOrigins : [],
+    dataDir: resolve(dirname(filename), config.dataDir),
+    demo: false
+  };
+  sources.set(result, { path: resolve(filename), development });
+  return result;
+}
+function cliOptions(args = process.argv.slice(2)) {
+  const remaining = args.filter((arg) => arg !== "--");
+  let configPath = "config.local.json";
+  let development = false;
+  for (let i = 0; i < remaining.length; i++) {
+    const arg = remaining[i];
+    if (arg === "--dev") development = true;
+    else if (arg === "--config" && remaining[i + 1]) configPath = remaining[++i];
+    else throw new AppError("INVALID_ARGUMENT", `Unknown or incomplete argument: ${arg}`);
+  }
+  return { configPath: resolve(configPath), development };
+}
+async function loadConfig(options = cliOptions()) {
+  return parseConfig(
+    JSON.parse(await readFile(options.configPath, "utf8")),
+    options.configPath,
+    options.development
+  );
+}
+export {
+  cliOptions,
+  configSchema,
+  configSource,
+  isLoopback,
+  loadConfig,
+  parseConfig,
+  parseFileConfig
+};
+//# sourceMappingURL=config.js.map

package/dist/server/config.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/server/config.ts"],
+  "sourcesContent": ["import { readFile } from 'node:fs/promises';\nimport { dirname, isAbsolute, resolve } from 'node:path';\nimport { z } from 'zod';\nimport { AppError } from '../shared/errors.js';\nimport { DEFAULT_MAX_LINE_BYTES } from '../codex/transport.js';\nimport type { GatewayConfig } from '../shared/gateway-config.js';\nconst origin = z\n  .string()\n  .regex(/^https?:\\/\\/[^/?#\\\\\\s]+\\/?$/i, 'Expected an exact HTTP(S) origin')\n  .pipe(z.string().url())\n  .transform((value, context) => {\n    const url = new URL(value);\n    if (\n      !['http:', 'https:'].includes(url.protocol) ||\n      url.hostname.includes('*') ||\n      value.includes('@') ||\n      url.username ||\n      url.password ||\n      url.pathname !== '/' ||\n      url.search ||\n      url.hash\n    ) {\n      context.addIssue({\n        code: 'custom',\n        message:\n          'Expected an exact HTTP(S) origin without wildcard, path, credentials, query or hash',\n      });\n      return z.NEVER;\n    }\n    return url.origin;\n  });\nconst project = z\n  .object({\n    id: z.string().regex(/^[a-zA-Z0-9_-]+$/),\n    name: z.string().min(1),\n    path: z.string().refine(isAbsolute, 'Project path must be absolute'),\n  })\n  .strict();\nexport const configSchema = z\n  .object({\n    host: z.string().default('127.0.0.1'),\n    port: z.number().int().min(1).max(65535).default(8787),\n    publicOrigin: z\n      .array(origin)\n      .min(1)\n      .default(['http://127.0.0.1:8787'])\n      .transform((values) => [...new Set(values)]),\n    developmentOrigins: z.array(origin).default([]),\n    dataDir: z.string().min(1).default('./.local/codex-web'),\n    codex: z\n      .object({\n        binary: z.string().min(1).default('codex'),\n        home: z.string().refine(isAbsolute).optional(),\n        requestTimeoutMs: z.number().int().min(100).max(300_000).default(30_000),\n        maxLineBytes: z\n          .number()\n          .int()\n          .min(1024)\n          .max(256 * 1024 * 1024)\n          .default(DEFAULT_MAX_LINE_BYTES),\n      })\n      .strict()\n      .default({ binary: 'codex', requestTimeoutMs: 30_000, maxLineBytes: DEFAULT_MAX_LINE_BYTES }),\n    auth: z\n      .discriminatedUnion('mode', [\n        z.object({ mode: z.literal('local') }).strict(),\n        z\n          .object({\n            mode: z.literal('cloudflare-access'),\n            issuer: z.string().url(),\n            audience: z.string().min(1),\n          })\n          .strict(),\n      ])\n      .default({ mode: 'local' }),\n    projects: z.array(project).default([]),\n    limits: z\n      .object({\n        eventBytes: z\n          .number()\n          .int()\n          .min(1024)\n          .max(64 * 1024 * 1024)\n          .default(16 * 1024 * 1024),\n        wsBytes: z\n          .number()\n          .int()\n          .min(1024)\n          .max(16 * 1024 * 1024)\n          .default(4 * 1024 * 1024),\n        itemBytes: z\n          .number()\n          .int()\n          .min(1024)\n          .max(8 * 1024 * 1024)\n          .default(2 * 1024 * 1024),\n      })\n      .strict()\n      .default({\n        eventBytes: 16 * 1024 * 1024,\n        wsBytes: 4 * 1024 * 1024,\n        itemBytes: 2 * 1024 * 1024,\n      }),\n  })\n  .strict();\nexport type AppConfig = z.infer<typeof configSchema> & { demo: boolean };\nconst sources = new WeakMap<AppConfig, { path: string; development: boolean }>();\nexport const configSource = (config: AppConfig) => sources.get(config);\nexport function isLoopback(hostname: string): boolean {\n  return ['127.0.0.1', 'localhost', '::1', '[::1]'].includes(hostname);\n}\nexport function parseFileConfig(value: unknown): GatewayConfig {\n  const parsed = configSchema.safeParse(value);\n  if (!parsed.success)\n    throw new AppError(\n      'INVALID_CONFIG',\n      parsed.error.issues\n        .map((issue) => `${issue.path.join('.') || '\u914D\u7F6E'}: ${issue.message}`)\n        .join('\\n'),\n    );\n  const config = parsed.data;\n  if (new Set(config.projects.map((p) => p.id)).size !== config.projects.length)\n    throw new AppError('INVALID_CONFIG', 'Project IDs must be unique');\n  if (config.auth.mode === 'local' && !isLoopback(config.host))\n    throw new AppError('INVALID_CONFIG', 'Local mode requires a loopback host');\n  if (config.developmentOrigins.some((o) => !isLoopback(new URL(o).hostname)))\n    throw new AppError('INVALID_CONFIG', 'Development origins must be loopback');\n  if (config.auth.mode === 'cloudflare-access') {\n    const issuer = new URL(config.auth.issuer);\n    if (\n      issuer.protocol !== 'https:' ||\n      !issuer.hostname.endsWith('.cloudflareaccess.com') ||\n      issuer.pathname !== '/' ||\n      issuer.search ||\n      issuer.hash ||\n      issuer.username ||\n      issuer.password\n    )\n      throw new AppError(\n        'INVALID_CONFIG',\n        'Access issuer must be https://<team>.cloudflareaccess.com',\n      );\n    if (config.publicOrigin.some((value) => new URL(value).protocol !== 'https:'))\n      throw new AppError('INVALID_CONFIG', 'All Access public origins must use HTTPS');\n    config.auth.issuer = issuer.origin;\n  }\n  return config;\n}\nexport function parseConfig(value: unknown, filename: string, development = false): AppConfig {\n  const config = parseFileConfig(value);\n  const result: AppConfig = {\n    ...config,\n    developmentOrigins: development ? config.developmentOrigins : [],\n    dataDir: resolve(dirname(filename), config.dataDir),\n    demo: false,\n  };\n  sources.set(result, { path: resolve(filename), development });\n  return result;\n}\nexport function cliOptions(args = process.argv.slice(2)): {\n  configPath: string;\n  development: boolean;\n} {\n  const remaining = args.filter((arg) => arg !== '--');\n  let configPath = 'config.local.json';\n  let development = false;\n  for (let i = 0; i < remaining.length; i++) {\n    const arg = remaining[i];\n    if (arg === '--dev') development = true;\n    else if (arg === '--config' && remaining[i + 1]) configPath = remaining[++i]!;\n    else throw new AppError('INVALID_ARGUMENT', `Unknown or incomplete argument: ${arg}`);\n  }\n  return { configPath: resolve(configPath), development };\n}\nexport async function loadConfig(options = cliOptions()): Promise<AppConfig> {\n  return parseConfig(\n    JSON.parse(await readFile(options.configPath, 'utf8')),\n    options.configPath,\n    options.development,\n  );\n}\n"],
+  "mappings": "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",
+  "names": ["value"]
+}

package/dist/server/db/index.js

@@ -0,0 +1,21 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema.js";
+function openDatabase(filename) {
+  if (filename !== ":memory:") {
+    mkdirSync(dirname(filename), { recursive: true, mode: 448 });
+    chmodSync(dirname(filename), 448);
+  }
+  const sqlite = new Database(filename);
+  sqlite.pragma("foreign_keys = ON");
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("busy_timeout = 5000");
+  if (filename !== ":memory:") chmodSync(filename, 384);
+  return { database: drizzle(sqlite, { schema }), close: () => sqlite.close() };
+}
+export {
+  openDatabase
+};
+//# sourceMappingURL=index.js.map

package/dist/server/db/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/server/db/index.ts"],
+  "sourcesContent": ["import { chmodSync, mkdirSync } from 'node:fs';\nimport { dirname } from 'node:path';\nimport Database from 'better-sqlite3';\nimport { drizzle, type BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';\nimport * as schema from './schema.js';\n\nexport type AppDatabase = BetterSQLite3Database<typeof schema>;\n\n/** The caller must hold the data directory instance lock before opening/migrating. */\nexport function openDatabase(filename: string): { database: AppDatabase; close: () => void } {\n  if (filename !== ':memory:') {\n    mkdirSync(dirname(filename), { recursive: true, mode: 0o700 });\n    chmodSync(dirname(filename), 0o700);\n  }\n  const sqlite = new Database(filename);\n  sqlite.pragma('foreign_keys = ON');\n  sqlite.pragma('journal_mode = WAL');\n  sqlite.pragma('busy_timeout = 5000');\n  if (filename !== ':memory:') chmodSync(filename, 0o600);\n  return { database: drizzle(sqlite, { schema }), close: () => sqlite.close() };\n}\n"],
+  "mappings": "AAAA,SAAS,WAAW,iBAAiB;AACrC,SAAS,eAAe;AACxB,OAAO,cAAc;AACrB,SAAS,eAA2C;AACpD,YAAY,YAAY;AAKjB,SAAS,aAAa,UAAgE;AAC3F,MAAI,aAAa,YAAY;AAC3B,cAAU,QAAQ,QAAQ,GAAG,EAAE,WAAW,MAAM,MAAM,IAAM,CAAC;AAC7D,cAAU,QAAQ,QAAQ,GAAG,GAAK;AAAA,EACpC;AACA,QAAM,SAAS,IAAI,SAAS,QAAQ;AACpC,SAAO,OAAO,mBAAmB;AACjC,SAAO,OAAO,oBAAoB;AAClC,SAAO,OAAO,qBAAqB;AACnC,MAAI,aAAa,WAAY,WAAU,UAAU,GAAK;AACtD,SAAO,EAAE,UAAU,QAAQ,QAAQ,EAAE,OAAO,CAAC,GAAG,OAAO,MAAM,OAAO,MAAM,EAAE;AAC9E;",
+  "names": []
+}

package/dist/server/db/migrate.js

@@ -0,0 +1,26 @@
+import { fileURLToPath } from "node:url";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+import { sql } from "drizzle-orm";
+const defaultMigrationsFolder = fileURLToPath(new URL("../../../drizzle", import.meta.url));
+function migrateDatabase(database, migrationsFolder = defaultMigrationsFolder) {
+  const table = database.get(
+    sql`SELECT name FROM sqlite_master WHERE name = '__drizzle_migrations'`
+  );
+  if (table) {
+    const applied = database.all(
+      sql`SELECT hash FROM __drizzle_migrations ORDER BY created_at`
+    );
+    const migrations = readMigrationFiles({ migrationsFolder });
+    if (applied.some((entry, i) => entry.hash !== migrations[i]?.hash))
+      throw new Error(
+        "\u5F53\u524D\u5B89\u88C5\u4E0D\u517C\u5BB9\u6570\u636E\u5E93\u8FC1\u79FB\u5386\u53F2\uFF1B\u8BF7\u4F7F\u7528\u517C\u5BB9\u7248\u672C\u6216\u5347\u7EA7\u524D\u5907\u4EFD\uFF0C\u4E0D\u4F1A\u6539\u5199\u6216\u91CD\u5EFA\u6570\u636E\u5E93\u3002"
+      );
+  }
+  migrate(database, { migrationsFolder });
+}
+export {
+  defaultMigrationsFolder,
+  migrateDatabase
+};
+//# sourceMappingURL=migrate.js.map

package/dist/server/db/migrate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/server/db/migrate.ts"],
+  "sourcesContent": ["import { fileURLToPath } from 'node:url';\nimport { migrate } from 'drizzle-orm/better-sqlite3/migrator';\nimport { readMigrationFiles } from 'drizzle-orm/migrator';\nimport { sql } from 'drizzle-orm';\nimport type { AppDatabase } from './index.js';\n\n/** Source and unbundled dist/server/db resolve to repository/dist drizzle respectively. */\nexport const defaultMigrationsFolder = fileURLToPath(new URL('../../../drizzle', import.meta.url));\n\nexport function migrateDatabase(\n  database: AppDatabase,\n  migrationsFolder = defaultMigrationsFolder,\n): void {\n  const table = database.get(\n    sql`SELECT name FROM sqlite_master WHERE name = '__drizzle_migrations'`,\n  );\n  if (table) {\n    const applied = database.all<{ hash: string }>(\n      sql`SELECT hash FROM __drizzle_migrations ORDER BY created_at`,\n    );\n    const migrations = readMigrationFiles({ migrationsFolder });\n    if (applied.some((entry, i) => entry.hash !== migrations[i]?.hash))\n      throw new Error(\n        '\u5F53\u524D\u5B89\u88C5\u4E0D\u517C\u5BB9\u6570\u636E\u5E93\u8FC1\u79FB\u5386\u53F2\uFF1B\u8BF7\u4F7F\u7528\u517C\u5BB9\u7248\u672C\u6216\u5347\u7EA7\u524D\u5907\u4EFD\uFF0C\u4E0D\u4F1A\u6539\u5199\u6216\u91CD\u5EFA\u6570\u636E\u5E93\u3002',\n      );\n  }\n  migrate(database, { migrationsFolder });\n}\n"],
+  "mappings": "AAAA,SAAS,qBAAqB;AAC9B,SAAS,eAAe;AACxB,SAAS,0BAA0B;AACnC,SAAS,WAAW;AAIb,MAAM,0BAA0B,cAAc,IAAI,IAAI,oBAAoB,YAAY,GAAG,CAAC;AAE1F,SAAS,gBACd,UACA,mBAAmB,yBACb;AACN,QAAM,QAAQ,SAAS;AAAA,IACrB;AAAA,EACF;AACA,MAAI,OAAO;AACT,UAAM,UAAU,SAAS;AAAA,MACvB;AAAA,IACF;AACA,UAAM,aAAa,mBAAmB,EAAE,iBAAiB,CAAC;AAC1D,QAAI,QAAQ,KAAK,CAAC,OAAO,MAAM,MAAM,SAAS,WAAW,CAAC,GAAG,IAAI;AAC/D,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,EACJ;AACA,UAAQ,UAAU,EAAE,iBAAiB,CAAC;AACxC;",
+  "names": []
+}

package/dist/server/db/operations.js

@@ -0,0 +1,201 @@
+import { createHash } from "node:crypto";
+import { and, eq, isNull, or } from "drizzle-orm";
+import { executionMarkers, operations, threadLinks } from "./schema.js";
+class StoreConflict extends Error {
+  constructor(code, message, threadId) {
+    super(message);
+    this.code = code;
+    this.threadId = threadId;
+  }
+  code;
+  threadId;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function requestDigest(value) {
+  return createHash("sha256").update(canonical(value)).digest("hex");
+}
+class OperationStore {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  accept(clientOperationId, kind, target, request) {
+    const digest = requestDigest(request);
+    return this.database.transaction((tx) => {
+      const now = Date.now();
+      const inserted = tx.insert(operations).values({
+        clientOperationId,
+        kind,
+        target,
+        requestDigest: digest,
+        state: "accepted",
+        createdAt: now,
+        updatedAt: now
+      }).onConflictDoNothing({ target: operations.clientOperationId }).run().changes === 1;
+      const operation = tx.select().from(operations).where(eq(operations.clientOperationId, clientOperationId)).get();
+      if (!operation) throw new Error("Operation insert did not persist");
+      if (operation.kind !== kind || operation.target !== target || operation.requestDigest !== digest) {
+        throw new StoreConflict("OPERATION_CONFLICT", "\u540C\u4E00\u64CD\u4F5C ID \u5DF2\u7528\u4E8E\u4E0D\u540C\u7684\u8BF7\u6C42");
+      }
+      return { operation, inserted };
+    });
+  }
+  get(id) {
+    return this.database.select().from(operations).where(eq(operations.clientOperationId, id)).get();
+  }
+  associateProject(id, projectId) {
+    this.database.update(operations).set({ projectId }).where(and(eq(operations.clientOperationId, id), eq(operations.state, "accepted"))).run();
+  }
+  /** Includes older rows whose project can be recovered from their stable target/link. */
+  pendingProjectOperations(projectId) {
+    return this.database.select().from(operations).where(
+      or(
+        eq(operations.state, "accepted"),
+        eq(operations.state, "dispatching"),
+        and(eq(operations.state, "unknown"), isNull(operations.reconciledAt))
+      )
+    ).all().filter((operation) => {
+      if (![
+        "thread.create",
+        "thread.resume",
+        "thread.fork",
+        "thread.archive",
+        "thread.rename"
+      ].includes(operation.kind))
+        return false;
+      const owner = operation.projectId ?? (operation.kind === "thread.create" ? operation.target : this.getThreadLink(operation.target)?.projectId);
+      return owner === projectId;
+    });
+  }
+  dispatch(id, marker) {
+    this.database.transaction((tx) => {
+      if (marker) {
+        const occupied = tx.select().from(executionMarkers).where(
+          and(isNull(executionMarkers.endedAt), eq(executionMarkers.threadId, marker.threadId))
+        ).get();
+        if (occupied)
+          throw new StoreConflict(
+            "THREAD_BUSY",
+            "\u8BE5\u4F1A\u8BDD\u7684\u4E0A\u4E00\u8F6E\u6267\u884C\u5C1A\u672A\u7ED3\u675F\uFF0C\u8BF7\u8FFD\u52A0\u8981\u6C42\u6216\u7B49\u5F85\u7ED3\u675F",
+            occupied.threadId
+          );
+      }
+      const updated = tx.update(operations).set({ state: "dispatching", updatedAt: Date.now() }).where(and(eq(operations.clientOperationId, id), eq(operations.state, "accepted"))).run();
+      if (updated.changes !== 1)
+        throw new StoreConflict("OPERATION_CONFLICT", "\u64CD\u4F5C\u5DF2\u7ECF\u6D3E\u53D1\u6216\u7ED3\u675F");
+      if (marker)
+        tx.insert(executionMarkers).values({ operationId: id, ...marker, state: "active", createdAt: Date.now() }).run();
+    });
+  }
+  acknowledge(id, result, turnId) {
+    this.database.transaction((tx) => {
+      tx.update(operations).set({ state: "acknowledged", result, error: null, updatedAt: Date.now() }).where(and(eq(operations.clientOperationId, id), eq(operations.state, "dispatching"))).run();
+      if (turnId !== void 0)
+        tx.update(executionMarkers).set({ turnId }).where(eq(executionMarkers.operationId, id)).run();
+    });
+    return this.get(id);
+  }
+  fail(id, error, uncertain = false) {
+    this.database.transaction((tx) => {
+      const changed = tx.update(operations).set({ state: uncertain ? "unknown" : "failed", error, updatedAt: Date.now() }).where(
+        and(
+          eq(operations.clientOperationId, id),
+          or(eq(operations.state, "accepted"), eq(operations.state, "dispatching"))
+        )
+      ).run();
+      if (changed.changes === 0) return;
+      tx.update(executionMarkers).set(uncertain ? { state: "unknown" } : { state: "terminal", endedAt: Date.now() }).where(and(eq(executionMarkers.operationId, id), isNull(executionMarkers.endedAt))).run();
+    });
+    return this.get(id);
+  }
+  /** Includes acknowledged requests with unfinished turns; none of these are retried. */
+  recover() {
+    this.database.transaction((tx) => {
+      tx.update(operations).set({
+        state: "failed",
+        error: { code: "NOT_DISPATCHED", message: "\u670D\u52A1\u5728\u6D3E\u53D1\u524D\u505C\u6B62\uFF1B\u64CD\u4F5C\u6CA1\u6709\u6267\u884C" },
+        updatedAt: Date.now()
+      }).where(eq(operations.state, "accepted")).run();
+      tx.update(operations).set({
+        state: "unknown",
+        error: { code: "RESULT_UNKNOWN", message: "\u8FD0\u884C\u65F6\u5DF2\u505C\u6B62\uFF0C\u63D0\u4EA4\u7ED3\u679C\u9700\u8981\u6838\u5BF9" },
+        updatedAt: Date.now()
+      }).where(eq(operations.state, "dispatching")).run();
+      tx.update(executionMarkers).set({ state: "unknown" }).where(isNull(executionMarkers.endedAt)).run();
+    });
+  }
+  activeMarkers() {
+    return this.database.select().from(executionMarkers).where(isNull(executionMarkers.endedAt)).all();
+  }
+  unresolvedOperations() {
+    return this.database.select().from(operations).where(
+      or(
+        eq(operations.state, "accepted"),
+        eq(operations.state, "dispatching"),
+        and(eq(operations.state, "unknown"), isNull(operations.reconciledAt))
+      )
+    ).all();
+  }
+  marker(operationId) {
+    return this.database.select().from(executionMarkers).where(eq(executionMarkers.operationId, operationId)).get();
+  }
+  activeForThread(threadId) {
+    return this.database.select().from(executionMarkers).where(and(eq(executionMarkers.threadId, threadId), isNull(executionMarkers.endedAt))).get();
+  }
+  attachTurn(operationId, turnId) {
+    this.database.update(executionMarkers).set({ turnId }).where(and(eq(executionMarkers.operationId, operationId), isNull(executionMarkers.endedAt))).run();
+  }
+  finishTurn(threadId, turnId, codexEpoch) {
+    this.database.update(executionMarkers).set({ state: "terminal", endedAt: Date.now() }).where(
+      and(
+        eq(executionMarkers.threadId, threadId),
+        eq(executionMarkers.turnId, turnId),
+        eq(executionMarkers.codexEpoch, codexEpoch),
+        isNull(executionMarkers.endedAt)
+      )
+    ).run();
+  }
+  /** Keys the release to the original execution; an old decision cannot unlock a later turn. */
+  reconcile(targetOperationId, reconciliationOperationId) {
+    this.database.transaction((tx) => {
+      const now = Date.now();
+      tx.update(operations).set({ reconciledAt: now, reconciliationDecision: "confirmed-ended" }).where(
+        and(eq(operations.clientOperationId, targetOperationId), isNull(operations.reconciledAt))
+      ).run();
+      tx.update(executionMarkers).set({ state: "reconciled", endedAt: now, reconciledAt: now, reconciliationOperationId }).where(
+        and(
+          eq(executionMarkers.operationId, targetOperationId),
+          isNull(executionMarkers.endedAt)
+        )
+      ).run();
+      tx.update(operations).set({
+        state: "acknowledged",
+        result: { targetOperationId, decision: "confirmed-ended", reconciledAt: now },
+        updatedAt: now
+      }).where(
+        and(
+          eq(operations.clientOperationId, reconciliationOperationId),
+          eq(operations.state, "dispatching")
+        )
+      ).run();
+    });
+  }
+  linkThread(link) {
+    this.database.insert(threadLinks).values({ ...link, updatedAt: Date.now() }).onConflictDoUpdate({ target: threadLinks.threadId, set: { ...link, updatedAt: Date.now() } }).run();
+  }
+  getThreadLink(threadId) {
+    return this.database.select().from(threadLinks).where(eq(threadLinks.threadId, threadId)).get();
+  }
+}
+export {
+  OperationStore,
+  StoreConflict,
+  requestDigest
+};
+//# sourceMappingURL=operations.js.map