@deksden-com/dd-flow-cli 0.9.0-beta.124 → 0.9.0-beta.127

package/dist/storage/database.js

@@ -5,7 +5,7 @@ import { channel } from "node:diagnostics_channel";
 import { createRequire } from "node:module";
 import { ensureDir } from "./paths.js";
 import { AppError } from "../shared/errors.js";
-import { executeStoreSchema, readStoreWriterContract, registerStoreWriter } from "./writer-contract.js";
+import { executeStoreSchema, readStoreWriterContract, registerStoreWriter, STORE_WRITER_VERSION } from "./writer-contract.js";
 import { assertImportAdmission } from "./import-guard.js";
 import { withStoreCleanup, rollbackStoreTransaction } from "./native-cleanup.js";
 const workContinuationStorageSql = `
@@ -332,8 +332,9 @@ export function ensureWorkLaunchStorage(db) {
   `);
 }
 export function getDatabase(ddFlowHome, mode = "initialize", importPermitId, hookDeadlineAt) {
-    if (hookDeadlineAt !== undefined && (!Number.isSafeInteger(hookDeadlineAt) || mode !== "hook"))
-        throw new AppError("hook_deadline_invalid", "Hook deadline must be a finite absolute millisecond deadline", 1, { effect: "unknown" });
+    channel("dd-flow.sqlite.ingress").publish({ phase: "store_open", store_kind: "run" });
+    if (hookDeadlineAt !== undefined && !Number.isSafeInteger(hookDeadlineAt))
+        throw new AppError("hook_deadline_invalid", "Deadline must be a finite absolute millisecond deadline", 1, { effect: "unknown" });
     const deadline = hookDeadlineAt === undefined ? undefined : (phase) => {
         const remaining = hookDeadlineAt - Date.now();
         if (remaining <= 0)
@@ -461,18 +462,23 @@ export function withResourceReadSnapshot(resourceHome, read) {
     return withStoreCleanup(operation, () => { if (native.isOpen)
         native.close(); });
 }
-export function getResourceDatabase(resourceHome, mode = "initialize") {
+export function getResourceDatabase(resourceHome, mode = "initialize", deadlineAt) {
+    channel("dd-flow.sqlite.ingress").publish({ phase: "store_open", store_kind: "resource" });
+    const deadline = requestDeadline(deadlineAt);
+    deadline?.("resource_open");
     const dbPath = path.join(resourceHome, "runtime.sqlite");
     const cached = resourceDatabases.get(dbPath);
     if (mode === "read_existing" || mode === "read_isolated") {
         // Reuse a current transaction's view without exposing its write capability.
-        if (cached && mode === "read_existing")
-            return { ...emptyReadOnlyDatabase(dbPath), get: cached.get, all: cached.all };
+        if (cached && mode === "read_existing") {
+            const bounded = deadlineAt === undefined ? cached : cached.withDeadline(deadlineAt);
+            return { ...emptyReadOnlyDatabase(dbPath), get: bounded.get, all: bounded.all };
+        }
         if (!fs.existsSync(dbPath))
             return emptyReadOnlyDatabase(dbPath);
         const db = new DatabaseSync(dbPath, { readOnly: true });
         try {
-            db.exec("PRAGMA busy_timeout = 4000; PRAGMA query_only = ON");
+            db.exec(`PRAGMA busy_timeout = ${deadline?.("resource_open") ?? 4000}; PRAGMA query_only = ON`);
             if (!db.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' LIMIT 1").get()) {
                 db.close();
                 return emptyReadOnlyDatabase(dbPath);
@@ -481,21 +487,32 @@ export function getResourceDatabase(resourceHome, mode = "initialize") {
         catch (error) {
             return closeAfterOpenFailure(db, error);
         }
-        return databaseFacade(dbPath, false, db);
+        return databaseFacade(dbPath, false, db, undefined, deadline);
     }
-    ensureDir(resourceHome);
-    if (cached)
-        return cached;
+    if (mode === "prepared_existing" && !fs.existsSync(dbPath))
+        throw new AppError("resource_storage_unprepared", "Prepare the resource registry before maintenance", 1);
+    if (cached) {
+        const bounded = deadlineAt === undefined ? cached : cached.withDeadline(deadlineAt);
+        if (mode === "prepared_existing")
+            assertResourceStoreReady({ prepare: sql => ({ get: (...params) => bounded.get(sql, params), all: (...params) => bounded.all(sql, params), run: (...params) => bounded.run(sql, params) }) });
+        return bounded;
+    }
+    if (mode !== "prepared_existing")
+        ensureDir(resourceHome);
     const db = new DatabaseSync(dbPath);
-    db.exec("PRAGMA busy_timeout = 4000");
+    db.exec(`PRAGMA busy_timeout = ${deadline?.("resource_open") ?? 4000}`);
     try {
         registerStoreWriter(db);
     }
     catch (error) {
         return closeAfterOpenFailure(db, error);
     }
+    channel("dd-flow.sqlite.ingress").publish({ phase: "store_validation", store_kind: "resource" });
     try {
-        configureDatabase(db, "initialize");
+        if (mode === "prepared_existing")
+            assertResourceStoreReady(db);
+        else
+            configureDatabase(db, "initialize", deadline);
     }
     catch (error) {
         return closeAfterOpenFailure(db, error);
@@ -503,7 +520,8 @@ export function getResourceDatabase(resourceHome, mode = "initialize") {
     db.exec("PRAGMA foreign_keys = ON");
     const fresh = !db.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' LIMIT 1").get();
     try {
-        executeStoreSchema(db, `
+        if (mode !== "prepared_existing")
+            executeStoreSchema(db, `
     CREATE TABLE IF NOT EXISTS managed_processes (
       id TEXT PRIMARY KEY,
       kind TEXT NOT NULL,
@@ -552,7 +570,33 @@ export function getResourceDatabase(resourceHome, mode = "initialize") {
         db.close?.();
     });
     resourceDatabases.set(dbPath, database);
-    return database;
+    return deadlineAt === undefined ? database : database.withDeadline(deadlineAt);
+}
+function requestDeadline(at) {
+    if (at === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(at))
+        throw new AppError("maintenance_deadline_invalid", "Maintenance deadline must be an absolute millisecond timestamp", 1);
+    return phase => { const remaining = at - Date.now(); if (remaining <= 0)
+        throw new AppError("process_heartbeat_timeout", "Maintenance storage deadline expired", 1, { phase, deadline_at: at, effect: "unknown" }); return Math.max(1, Math.min(4000, remaining)); };
+}
+function assertResourceStoreReady(db) {
+    const version = readStoreWriterContract(db);
+    if (version === null)
+        throw new AppError("resource_storage_unprepared", "Prepare the resource registry writer contract before maintenance", 1);
+    if (version !== STORE_WRITER_VERSION)
+        throw new AppError("store_writer_incompatible", "This CLI cannot maintain the resource registry's required contract", 1, { required: version, supported: STORE_WRITER_VERSION });
+    for (const [table, columns] of Object.entries({ managed_processes: "id,kind,pid,pid_started_at,owner_id,lease_token,lease_expires_at,project_id,run_id,work_id,check_id,operation_id,stdout_path,stderr_path,state,started_at,updated_at,finished_at,termination_reason,metadata_json", managed_resources: "resource_kind,resource_key,owner_id,lease_token,lease_expires_at,process_id,metadata_json,created_at,updated_at" })) {
+        try {
+            db.prepare(`SELECT ${columns} FROM ${table} LIMIT 0`);
+        }
+        catch {
+            throw new AppError("resource_storage_unprepared", "Prepare the resource registry schema before maintenance", 1, { table });
+        }
+    }
+    for (const name of ["idx_managed_processes_lease", "idx_managed_resources_lease"])
+        if (!db.prepare("SELECT 1 FROM sqlite_schema WHERE type='index' AND name=?").get(name))
+            throw new AppError("resource_storage_unprepared", "Prepare resource registry indexes before maintenance", 1, { index: name });
 }
 function emptyReadOnlyDatabase(dbPath) {
     return {
@@ -570,6 +614,7 @@ function emptyReadOnlyDatabase(dbPath) {
     };
 }
 function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadline) {
+    let scopedDeadline = deadline;
     let reserved = false;
     let poisoned = false;
     let closed = false;
@@ -583,12 +628,13 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadli
     let readDepth = 0;
     const writerTiming = channel("dd-flow.sqlite.writer");
     const ingressPhase = channel("dd-flow.sqlite.ingress");
+    const storeKind = path.basename(dbPath) === "runtime.sqlite" ? "resource" : "run";
     const bound = (phase) => {
-        const remaining = deadline?.(phase);
+        const remaining = scopedDeadline?.(phase);
         if (remaining !== undefined)
             db.exec(`PRAGMA busy_timeout = ${remaining}`);
         if (ingressPhase.hasSubscribers)
-            ingressPhase.publish({ phase, ...(remaining !== undefined ? { remaining_ms: remaining } : {}) });
+            ingressPhase.publish({ phase, store_kind: storeKind, ...(remaining !== undefined ? { remaining_ms: remaining } : {}) });
     };
     const publishCommitted = () => {
         const pending = afterCommit;
@@ -611,7 +657,7 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadli
         db.exec("BEGIN IMMEDIATE");
         reserved = true;
         if (ingressPhase.hasSubscribers)
-            ingressPhase.publish({ phase: "writer_reserved" });
+            ingressPhase.publish({ phase: "writer_reserved", store_kind: storeKind });
     };
     const rollback = (sql, original) => {
         try {
@@ -670,8 +716,8 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadli
             else
                 db.exec("COMMIT");
             phase = "committed";
-            if (ingressPhase.hasSubscribers)
-                ingressPhase.publish({ phase: "committed" });
+            if (!nested && ingressPhase.hasSubscribers)
+                ingressPhase.publish({ phase: "committed", store_kind: storeKind });
             if (!nested && writerTiming.hasSubscribers)
                 writerTiming.publish({ operation: operationName, wall_time_ms: performance.now() - startedAt, path: dbPath });
             if (!nested)
@@ -769,7 +815,7 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadli
             }
         }
     };
-    return {
+    const facade = {
         path: dbPath,
         writable,
         close: closeOnce,
@@ -821,6 +867,19 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadli
         get: (sql, params = []) => { assertUsable(); bound("lookup"); return db.prepare(sql).get(...params); },
         all: (sql, params = []) => { assertUsable(); bound("lookup"); return db.prepare(sql).all(...params); }
     };
+    facade.withDeadline = (at) => {
+        const bounded = requestDeadline(at);
+        const scoped = (operation) => { const previous = scopedDeadline; scopedDeadline = phase => Math.min(bounded(phase), previous?.(phase) ?? 4000); try {
+            return operation();
+        }
+        finally {
+            scopedDeadline = previous;
+            if (db.isOpen)
+                db.exec("PRAGMA busy_timeout = 4000");
+        } };
+        return { ...facade, exec: sql => scoped(() => facade.exec(sql)), execSchema: sql => scoped(() => facade.execSchema(sql)), beginWriteTransaction: () => scoped(() => facade.beginWriteTransaction()), writeTransaction: (operation, name) => scoped(() => facade.writeTransaction(operation, name)), readSnapshot: operation => scoped(() => facade.readSnapshot(operation)), get: (sql, params) => scoped(() => facade.get(sql, params)), all: (sql, params) => scoped(() => facade.all(sql, params)), run: (sql, params) => scoped(() => facade.run(sql, params)) };
+    };
+    return facade;
 }
 function errorDetails(error) {
     const value = error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.124",
+  "version": "0.9.0-beta.127",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "packageManager": "pnpm@10.23.0",
@@ -28,9 +28,12 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --max-warnings=0",
     "test": "pnpm test:release && pnpm test:integration && pnpm test:runtime-sensitive",
-    "test:release": "node --test scripts/verify-release-build.test.mjs && vitest run --pool=forks --no-file-parallelism test/publish-release.test.ts",
-    "test:integration": "vitest run --pool=forks --no-file-parallelism --exclude test/publish-release.test.ts --exclude test/run-control-worker.test.ts --exclude test/native-adapter-contracts.test.ts",
-    "test:runtime-sensitive": "vitest run --pool=forks --no-file-parallelism test/run-control-worker.test.ts test/native-adapter-contracts.test.ts",
+    "test:release": "node --test scripts/verify-release-build.test.mjs && vitest run --project=release",
+    "test:integration": "vitest run --project='integration-*'",
+    "test:fast": "vitest run --project=integration-fast",
+    "test:core": "vitest run --project='integration-core-*'",
+    "test:flow": "vitest run --project=integration-flow",
+    "test:runtime-sensitive": "vitest run --project=runtime-sensitive",
     "changeset": "changeset",
     "version-packages": "changeset version",
     "release:candidate:pack": "node scripts/release-candidate.mjs pack",