@bryanhu/codexly 0.1.0

package/dist/sqlite-state-worker.js

@@ -0,0 +1,661 @@
+import { createRequire } from 'node:module';
+import './chunk-K6J42667.js';
+import { mkdirSync } from 'fs';
+import { resolve } from 'path';
+import { workerData, parentPort } from 'worker_threads';
+import Database from 'better-sqlite3';
+
+createRequire(import.meta.url);
+
+// packages/server/src/approval-policy-persistence.js
+var GRANULAR_FIELDS = [
+  "mcp_elicitations",
+  "request_permissions",
+  "rules",
+  "sandbox_approval",
+  "skill_approval"
+];
+function parseGranularApprovalPolicy(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Stored approval policy is invalid");
+  }
+  const outerKeys = Object.keys(value);
+  const granular = value.granular;
+  if (outerKeys.length !== 1 || outerKeys[0] !== "granular" || typeof granular !== "object" || granular === null || Array.isArray(granular) || Object.keys(granular).length !== GRANULAR_FIELDS.length || GRANULAR_FIELDS.some((field) => typeof granular[field] !== "boolean")) {
+    throw new Error("Stored granular approval policy is invalid");
+  }
+  return { granular: Object.fromEntries(GRANULAR_FIELDS.map((field) => [field, granular[field]])) };
+}
+function deserializeApprovalPolicy(serialized, scope) {
+  if (serialized === "on-request" || serialized === "never") {
+    return serialized;
+  }
+  if (scope === "turn" && serialized === "untrusted") {
+    return serialized;
+  }
+  if (typeof serialized !== "string" || !serialized.startsWith("{")) {
+    throw new Error(`Stored ${scope} approval policy is invalid`);
+  }
+  try {
+    return parseGranularApprovalPolicy(JSON.parse(serialized));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Stored ${scope} approval policy JSON is invalid`, { cause: error });
+    }
+    throw error;
+  }
+}
+function serializeApprovalPolicy(policy) {
+  return typeof policy === "string" ? policy : JSON.stringify(parseGranularApprovalPolicy(policy));
+}
+
+// packages/server/src/sqlite-state-worker-bootstrap.js
+function projectFromRows(row, rootRows) {
+  if (row === void 0) {
+    return void 0;
+  }
+  const roots = rootRows.map((root) => ({ id: root.root_id, path: root.path }));
+  if (roots.length === 0) {
+    throw new Error(`Project ${row.id} has no stored roots`);
+  }
+  return {
+    createdAt: row.created_at,
+    id: row.id,
+    name: row.name,
+    roots
+  };
+}
+function projectsFromRows(projectRows, rootRows) {
+  const rootsByProject = /* @__PURE__ */ new Map();
+  for (const root of rootRows) {
+    const roots = rootsByProject.get(root.project_id) ?? [];
+    roots.push(root);
+    rootsByProject.set(root.project_id, roots);
+  }
+  return projectRows.map(
+    (project) => projectFromRows(project, rootsByProject.get(project.id) ?? [])
+  );
+}
+function projectDefaultsFromRow(row) {
+  if (row === void 0) {
+    return void 0;
+  }
+  return {
+    approvalPolicy: deserializeApprovalPolicy(row.approval_policy, "turn"),
+    approvalsReviewer: row.approvals_reviewer,
+    fastMode: row.fast_mode === 1,
+    model: row.model,
+    reasoningEffort: row.reasoning_effort,
+    sandboxMode: row.sandbox_mode
+  };
+}
+function taskSettingsFromRow(row) {
+  if (row === void 0) {
+    return void 0;
+  }
+  return {
+    approvalPolicy: deserializeApprovalPolicy(row.approval_policy, "turn"),
+    approvalsReviewer: row.approvals_reviewer,
+    model: row.model,
+    reasoningEffort: row.reasoning_effort,
+    sandboxMode: row.sandbox_mode
+  };
+}
+function globalSettingsFromRow(row) {
+  if (row === void 0) {
+    return void 0;
+  }
+  return {
+    approvalPolicy: deserializeApprovalPolicy(row.approval_policy, "global"),
+    approvalsReviewer: row.approvals_reviewer,
+    commitMessageModel: row.commit_message_model,
+    commitMessagePrompt: row.commit_message_prompt,
+    defaultOpenAppId: row.default_open_app_id,
+    fastMode: row.fast_mode === 1,
+    followUpBehavior: row.follow_up_behavior,
+    model: row.model,
+    reasoningEffort: row.reasoning_effort,
+    sandboxMode: row.sandbox_mode
+  };
+}
+function providerConnectionFromRow(row) {
+  if (row === void 0) {
+    return void 0;
+  }
+  return {
+    customBaseUrl: row.custom_base_url,
+    customModelsJson: row.custom_models_json,
+    mode: row.mode,
+    updatedAt: row.updated_at
+  };
+}
+function hasTable(database2, tableName) {
+  return database2.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName) !== void 0;
+}
+function configureDatabase(database2) {
+  database2.pragma("journal_mode = WAL");
+  database2.pragma("foreign_keys = ON");
+  database2.pragma("synchronous = NORMAL");
+  database2.pragma("busy_timeout = 5000");
+}
+function readMigrationVersion(database2) {
+  if (!hasTable(database2, "schema_migrations")) {
+    return 0;
+  }
+  return database2.prepare("SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations").get().version;
+}
+function runMigrations(database2, migrations, onMigrationApplied = () => {
+}) {
+  database2.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL
+    ) STRICT;
+  `);
+  const applied = new Set(
+    database2.prepare("SELECT version FROM schema_migrations").all().map((row) => row.version)
+  );
+  let previousVersion = 0;
+  for (const migration of migrations) {
+    if (!Number.isInteger(migration.version) || migration.version <= previousVersion || typeof migration.name !== "string" || typeof migration.sql !== "string") {
+      throw new Error("Invalid SQLite migration definition");
+    }
+    previousVersion = migration.version;
+    if (applied.has(migration.version)) {
+      continue;
+    }
+    database2.transaction(() => {
+      database2.exec(migration.sql);
+      onMigrationApplied(migration.version);
+      database2.prepare("INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.name, (/* @__PURE__ */ new Date()).toISOString());
+    })();
+  }
+}
+function initializeProjectSourceMigration(database2, previousMigrationVersion) {
+  if (!hasTable(database2, "project_source_migration")) {
+    return;
+  }
+  database2.prepare(
+    `INSERT OR IGNORE INTO project_source_migration
+       (id, completed, recover_unassigned) VALUES (1, 0, ?)`
+  ).run(previousMigrationVersion === 14 ? 1 : 0);
+}
+function ensureGlobalSettingsCompatibility(database2) {
+  if (!hasTable(database2, "global_settings")) {
+    return;
+  }
+  const columns = new Set(
+    database2.prepare("PRAGMA table_info(global_settings)").all().map((column) => column.name)
+  );
+  database2.transaction(() => {
+    if (!columns.has("fast_mode")) {
+      database2.exec(`
+        ALTER TABLE global_settings
+          ADD COLUMN fast_mode INTEGER NOT NULL DEFAULT 0
+          CHECK (fast_mode IN (0, 1));
+      `);
+    }
+    if (!columns.has("commit_message_reasoning_effort")) {
+      database2.exec(`
+        ALTER TABLE global_settings
+          ADD COLUMN commit_message_reasoning_effort TEXT NOT NULL DEFAULT '';
+        UPDATE global_settings
+        SET commit_message_reasoning_effort = reasoning_effort;
+      `);
+    }
+  })();
+}
+
+// packages/server/src/sqlite-state-worker.js
+function serializeError(error) {
+  return {
+    message: error instanceof Error ? error.message : String(error),
+    name: error instanceof Error ? error.name : "Error"
+  };
+}
+function createOperations(database2) {
+  const statements = hasTable(database2, "projects") && hasTable(database2, "project_roots") ? {
+    upsertProject: database2.prepare(
+      `INSERT INTO projects (id, name, created_at, sort_order, kind)
+           VALUES (?, ?, ?, (
+             SELECT COALESCE(MAX(sort_order) + 1, 0) FROM projects WHERE kind = 'user'
+           ), 'user')
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             created_at = excluded.created_at
+           WHERE projects.kind = 'user'`
+    ),
+    upsertProjectAtOrder: database2.prepare(
+      `INSERT INTO projects (id, name, created_at, sort_order, kind)
+           VALUES (?, ?, ?, ?, 'user')
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             created_at = excluded.created_at,
+             sort_order = excluded.sort_order
+           WHERE projects.kind = 'user'`
+    ),
+    listProjects: database2.prepare(
+      "SELECT id, name, created_at FROM projects WHERE kind = 'user' ORDER BY sort_order, created_at, id"
+    ),
+    listProjectRoots: database2.prepare(
+      `SELECT project_roots.project_id, project_roots.root_id, project_roots.path
+           FROM project_roots
+           JOIN projects ON projects.id = project_roots.project_id
+           WHERE projects.kind = 'user'
+           ORDER BY projects.sort_order, projects.created_at, projects.id, project_roots.position`
+    ),
+    listProjectIds: database2.prepare(
+      "SELECT id FROM projects WHERE kind = 'user' ORDER BY sort_order, created_at, id"
+    ),
+    readProject: database2.prepare("SELECT id, name, created_at FROM projects WHERE id = ?"),
+    readProjectWithOrder: database2.prepare(
+      "SELECT id, name, created_at, sort_order FROM projects WHERE id = ? AND kind = 'user'"
+    ),
+    readProjectRoots: database2.prepare(
+      "SELECT project_id, root_id, path FROM project_roots WHERE project_id = ? ORDER BY position"
+    ),
+    removeProjectRoots: database2.prepare("DELETE FROM project_roots WHERE project_id = ?"),
+    writeProjectRoot: database2.prepare(
+      "INSERT INTO project_roots (project_id, position, root_id, path) VALUES (?, ?, ?, ?)"
+    ),
+    removeProject: database2.prepare("DELETE FROM projects WHERE id = ? AND kind = 'user'"),
+    copyProjectDefaults: database2.prepare(
+      `INSERT INTO project_defaults
+             (project_id, model, reasoning_effort, updated_at, sandbox_mode,
+              approval_policy, approvals_reviewer, fast_mode)
+           SELECT ?, model, reasoning_effort, updated_at, sandbox_mode,
+                  approval_policy, approvals_reviewer, fast_mode
+           FROM project_defaults WHERE project_id = ?
+           ON CONFLICT(project_id) DO UPDATE SET
+             model = excluded.model,
+             reasoning_effort = excluded.reasoning_effort,
+             updated_at = excluded.updated_at,
+             sandbox_mode = excluded.sandbox_mode,
+             approval_policy = excluded.approval_policy,
+             approvals_reviewer = excluded.approvals_reviewer,
+             fast_mode = excluded.fast_mode`
+    ),
+    copyTaskSettings: database2.prepare(
+      `INSERT INTO task_settings
+             (project_id, task_id, approval_policy, model, reasoning_effort, updated_at,
+              sandbox_mode, approvals_reviewer)
+           SELECT ?, task_id, approval_policy, model, reasoning_effort, updated_at,
+                  sandbox_mode, approvals_reviewer
+           FROM task_settings WHERE project_id = ?
+           ON CONFLICT(project_id, task_id) DO UPDATE SET
+             approval_policy = excluded.approval_policy,
+             model = excluded.model,
+             reasoning_effort = excluded.reasoning_effort,
+             updated_at = excluded.updated_at,
+             sandbox_mode = excluded.sandbox_mode,
+             approvals_reviewer = excluded.approvals_reviewer`
+    ),
+    writeProjectSortOrder: database2.prepare(
+      "UPDATE projects SET sort_order = ? WHERE id = ? AND kind = 'user'"
+    ),
+    readProjectDefaults: database2.prepare(
+      `SELECT approval_policy, approvals_reviewer, fast_mode, model,
+                    reasoning_effort, sandbox_mode
+             FROM project_defaults WHERE project_id = ?`
+    ),
+    readGlobalSettings: database2.prepare(
+      `SELECT approval_policy, approvals_reviewer, commit_message_model,
+                  commit_message_prompt, model, reasoning_effort, sandbox_mode,
+                  default_open_app_id, fast_mode, follow_up_behavior
+           FROM global_settings WHERE id = 1`
+    ),
+    readProviderConnection: database2.prepare(
+      `SELECT mode, custom_base_url, custom_models_json, updated_at
+           FROM provider_connection WHERE id = 1`
+    ),
+    readTaskSettings: database2.prepare(
+      "SELECT approval_policy, approvals_reviewer, model, reasoning_effort, sandbox_mode FROM task_settings WHERE project_id = ? AND task_id = ?"
+    ),
+    writeProjectDefaults: database2.prepare(`
+      INSERT INTO project_defaults (
+        project_id, approval_policy, approvals_reviewer, fast_mode, model,
+        reasoning_effort, sandbox_mode, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id) DO UPDATE SET
+        approval_policy = excluded.approval_policy,
+        approvals_reviewer = excluded.approvals_reviewer,
+        fast_mode = excluded.fast_mode,
+        model = excluded.model,
+        reasoning_effort = excluded.reasoning_effort,
+        sandbox_mode = excluded.sandbox_mode,
+        updated_at = excluded.updated_at
+    `),
+    writeGlobalSettings: database2.prepare(`
+      INSERT INTO global_settings (
+        id, approval_policy, approvals_reviewer, commit_message_model, commit_message_prompt,
+        model, reasoning_effort, sandbox_mode, default_open_app_id, fast_mode,
+        follow_up_behavior, updated_at
+      ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        approval_policy = excluded.approval_policy,
+        approvals_reviewer = excluded.approvals_reviewer,
+        commit_message_model = excluded.commit_message_model,
+        commit_message_prompt = excluded.commit_message_prompt,
+        model = excluded.model,
+        reasoning_effort = excluded.reasoning_effort,
+        sandbox_mode = excluded.sandbox_mode,
+        default_open_app_id = excluded.default_open_app_id,
+        fast_mode = excluded.fast_mode,
+        follow_up_behavior = excluded.follow_up_behavior,
+        updated_at = excluded.updated_at
+    `),
+    writeProviderConnection: database2.prepare(`
+      INSERT INTO provider_connection (
+        id, mode, custom_base_url, custom_models_json, updated_at
+      ) VALUES (1, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        mode = excluded.mode,
+        custom_base_url = excluded.custom_base_url,
+        custom_models_json = excluded.custom_models_json,
+        updated_at = excluded.updated_at
+    `),
+    writeTaskSettings: database2.prepare(`
+      INSERT INTO task_settings (
+        project_id, task_id, approval_policy, approvals_reviewer, model, reasoning_effort, sandbox_mode, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id, task_id) DO UPDATE SET
+        approval_policy = excluded.approval_policy,
+        approvals_reviewer = excluded.approvals_reviewer,
+        model = excluded.model,
+        reasoning_effort = excluded.reasoning_effort,
+        sandbox_mode = excluded.sandbox_mode,
+        updated_at = excluded.updated_at
+        `)
+  } : void 0;
+  function requireStatements() {
+    if (statements === void 0) {
+      throw new Error("SQLite state tables are unavailable");
+    }
+    return statements;
+  }
+  function readStoredProject(projectId) {
+    const stateStatements = requireStatements();
+    return projectFromRows(
+      stateStatements.readProject.get(projectId),
+      stateStatements.readProjectRoots.all(projectId)
+    );
+  }
+  function readStoredProjects() {
+    const stateStatements = requireStatements();
+    return projectsFromRows(
+      stateStatements.listProjects.all(),
+      stateStatements.listProjectRoots.all()
+    );
+  }
+  function replaceStoredRoots(project) {
+    const stateStatements = requireStatements();
+    if (!Array.isArray(project.roots) || project.roots.length === 0) {
+      throw new Error("Project roots must contain a primary root");
+    }
+    const rootIds = project.roots.map((root) => root.id);
+    const paths = project.roots.map((root) => root.path);
+    if (rootIds.some((rootId) => typeof rootId !== "string" || rootId.length === 0)) {
+      throw new Error("Project root ids must be non-empty strings");
+    }
+    if (new Set(rootIds).size !== rootIds.length) {
+      throw new Error("Project root ids must be unique");
+    }
+    if (paths.some((path) => typeof path !== "string" || path.length === 0)) {
+      throw new Error("Project root paths must be non-empty strings");
+    }
+    if (new Set(paths).size !== paths.length) {
+      throw new Error("Project root paths must be unique");
+    }
+    stateStatements.removeProjectRoots.run(project.id);
+    paths.forEach((path, position) => {
+      stateStatements.writeProjectRoot.run(project.id, position, rootIds[position], path);
+    });
+  }
+  const reorderProjects = database2.transaction((projectIds) => {
+    const stateStatements = requireStatements();
+    const storedProjectIds = stateStatements.listProjectIds.all().map((row) => row.id);
+    const requestedProjectIds = new Set(projectIds);
+    const containsCompleteProjectSet = projectIds.length === storedProjectIds.length && requestedProjectIds.size === storedProjectIds.length && storedProjectIds.every((projectId) => requestedProjectIds.has(projectId));
+    if (!containsCompleteProjectSet) {
+      throw new Error("Project order must contain every project exactly once");
+    }
+    projectIds.forEach((projectId, sortOrder) => {
+      stateStatements.writeProjectSortOrder.run(sortOrder, projectId);
+    });
+    return readStoredProjects();
+  });
+  const replaceProjects = database2.transaction((projects) => {
+    const stateStatements = requireStatements();
+    const projectIds = new Set(projects.map((project) => project.id));
+    if (projectIds.size !== projects.length) {
+      throw new Error("Project projection must contain unique project ids");
+    }
+    for (const { id } of stateStatements.listProjectIds.all()) {
+      if (!projectIds.has(id)) {
+        stateStatements.removeProject.run(id);
+      }
+    }
+    projects.forEach((project, sortOrder) => {
+      stateStatements.upsertProjectAtOrder.run(
+        project.id,
+        project.name,
+        project.createdAt,
+        sortOrder
+      );
+      replaceStoredRoots(project);
+    });
+    return readStoredProjects();
+  });
+  const migrateProject = database2.transaction((legacyProjectId, project) => {
+    const stateStatements = requireStatements();
+    const legacy = stateStatements.readProjectWithOrder.get(legacyProjectId);
+    const sortOrder = legacy?.sort_order ?? stateStatements.listProjectIds.all().length;
+    stateStatements.upsertProjectAtOrder.run(
+      project.id,
+      project.name,
+      project.createdAt,
+      sortOrder
+    );
+    replaceStoredRoots(project);
+    if (legacyProjectId !== project.id && legacy !== void 0) {
+      stateStatements.copyProjectDefaults.run(project.id, legacyProjectId);
+      stateStatements.copyTaskSettings.run(project.id, legacyProjectId);
+      stateStatements.removeProject.run(legacyProjectId);
+    }
+    const stored = readStoredProject(project.id);
+    if (stored === void 0) {
+      throw new Error("Migrated Project projection could not be stored");
+    }
+    return stored;
+  });
+  const projectSourceMigrationStatements = hasTable(database2, "project_source_migration") ? {
+    complete: database2.prepare(
+      "UPDATE project_source_migration SET completed = 1 WHERE id = 1"
+    ),
+    read: database2.prepare(
+      "SELECT completed, recover_unassigned FROM project_source_migration WHERE id = 1"
+    )
+  } : void 0;
+  return {
+    diagnose() {
+      database2.exec("BEGIN IMMEDIATE");
+      try {
+        database2.prepare(
+          "INSERT INTO schema_migrations (version, name, applied_at) VALUES (-1, 'doctor', ?)"
+        ).run((/* @__PURE__ */ new Date()).toISOString());
+      } finally {
+        database2.exec("ROLLBACK");
+      }
+      const synchronousValue = database2.pragma("synchronous", { simple: true });
+      return {
+        busyTimeout: database2.pragma("busy_timeout", { simple: true }),
+        foreignKeys: database2.pragma("foreign_keys", { simple: true }) === 1,
+        integrityCheck: database2.pragma("integrity_check", { simple: true }),
+        journalMode: database2.pragma("journal_mode", { simple: true }),
+        migrationVersion: database2.prepare("SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations").get().version,
+        synchronous: synchronousValue === 1 ? "normal" : String(synchronousValue),
+        writable: true
+      };
+    },
+    completeProjectSourceMigration() {
+      if (projectSourceMigrationStatements === void 0) {
+        throw new Error("Project source migration state is unavailable");
+      }
+      projectSourceMigrationStatements.complete.run();
+      return null;
+    },
+    listProjects() {
+      return readStoredProjects();
+    },
+    readProject(payload) {
+      return readStoredProject(payload.projectId);
+    },
+    readProjectSourceMigration() {
+      if (projectSourceMigrationStatements === void 0) {
+        throw new Error("Project source migration state is unavailable");
+      }
+      const row = projectSourceMigrationStatements.read.get();
+      if (row === void 0) {
+        throw new Error("Project source migration state is missing");
+      }
+      return {
+        completed: row.completed === 1,
+        recoverUnassigned: row.recover_unassigned === 1
+      };
+    },
+    replaceProjects(payload) {
+      return replaceProjects(payload.projects);
+    },
+    upsertProject(payload) {
+      return database2.transaction((project) => {
+        const stateStatements = requireStatements();
+        stateStatements.upsertProject.run(project.id, project.name, project.createdAt);
+        replaceStoredRoots(project);
+        const stored = readStoredProject(project.id);
+        if (stored === void 0) {
+          throw new Error("Project projection could not be stored");
+        }
+        return stored;
+      })(payload.project);
+    },
+    migrateProject(payload) {
+      return migrateProject(payload.legacyProjectId, payload.project);
+    },
+    deleteProject(payload) {
+      return requireStatements().removeProject.run(payload.projectId).changes > 0;
+    },
+    setProjectOrder(payload) {
+      return reorderProjects(payload.projectIds);
+    },
+    readProjectDefaults(payload) {
+      return projectDefaultsFromRow(requireStatements().readProjectDefaults.get(payload.projectId));
+    },
+    readGlobalSettings() {
+      return globalSettingsFromRow(requireStatements().readGlobalSettings.get());
+    },
+    readProviderConnection() {
+      return providerConnectionFromRow(requireStatements().readProviderConnection.get());
+    },
+    readTaskSettings(payload) {
+      return taskSettingsFromRow(
+        requireStatements().readTaskSettings.get(payload.projectId, payload.taskId)
+      );
+    },
+    writeProjectDefaults(payload) {
+      const settings = payload.settings;
+      requireStatements().writeProjectDefaults.run(
+        payload.projectId,
+        serializeApprovalPolicy(settings.approvalPolicy),
+        settings.approvalsReviewer,
+        settings.fastMode ? 1 : 0,
+        settings.model,
+        settings.reasoningEffort,
+        settings.sandboxMode,
+        payload.updatedAt
+      );
+      return settings;
+    },
+    writeGlobalSettings(payload) {
+      const settings = payload.settings;
+      requireStatements().writeGlobalSettings.run(
+        serializeApprovalPolicy(settings.approvalPolicy),
+        settings.approvalsReviewer,
+        settings.commitMessageModel,
+        settings.commitMessagePrompt,
+        settings.model,
+        settings.reasoningEffort,
+        settings.sandboxMode,
+        settings.defaultOpenAppId,
+        settings.fastMode ? 1 : 0,
+        settings.followUpBehavior,
+        payload.updatedAt
+      );
+      return settings;
+    },
+    writeProviderConnection(payload) {
+      requireStatements().writeProviderConnection.run(
+        payload.mode,
+        payload.customBaseUrl,
+        payload.customModelsJson,
+        payload.updatedAt
+      );
+      return null;
+    },
+    writeTaskSettings(payload) {
+      const settings = payload.settings;
+      requireStatements().writeTaskSettings.run(
+        payload.projectId,
+        payload.taskId,
+        serializeApprovalPolicy(settings.approvalPolicy),
+        settings.approvalsReviewer,
+        settings.model,
+        settings.reasoningEffort,
+        settings.sandboxMode,
+        payload.updatedAt
+      );
+      return settings;
+    }
+  };
+}
+var database;
+try {
+  mkdirSync(resolve(workerData.databasePath, ".."), { recursive: true });
+  database = new Database(workerData.databasePath);
+  configureDatabase(database);
+  const previousMigrationVersion = readMigrationVersion(database);
+  runMigrations(database, workerData.migrations, (version) => {
+    if (version === 15) {
+      initializeProjectSourceMigration(database, previousMigrationVersion);
+    }
+  });
+  initializeProjectSourceMigration(database, previousMigrationVersion);
+  ensureGlobalSettingsCompatibility(database);
+  const operations = createOperations(database);
+  parentPort.on("message", (message) => {
+    try {
+      if (message.operation === "close") {
+        database.close();
+        parentPort.postMessage({ id: message.id, result: null, type: "response" });
+        parentPort.close();
+        return;
+      }
+      const operation = operations[message.operation];
+      if (typeof operation !== "function") {
+        throw new Error(`Unknown SQLite worker operation: ${String(message.operation)}`);
+      }
+      parentPort.postMessage({
+        id: message.id,
+        result: operation(message.payload),
+        type: "response"
+      });
+    } catch (error) {
+      parentPort.postMessage({ id: message.id, error: serializeError(error), type: "response" });
+    }
+  });
+  parentPort.postMessage({ type: "ready" });
+} catch (error) {
+  database?.close();
+  parentPort.postMessage({ error: serializeError(error), type: "fatal" });
+  parentPort.close();
+}