@avocadostudio-ai/orchestrator-core 0.1.0 → 0.2.0

package/dist/state/sqlite-store.js

@@ -1,6 +1,128 @@
+import { createRequire } from "node:module";
 import { mkdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import Database from "better-sqlite3";
+import { dirname, join, resolve } from "node:path";
+/*
+ * `better-sqlite3` is loaded at runtime, through a specifier no bundler can read.
+ *
+ * A static `import Database from "better-sqlite3"` is correct for the standalone
+ * Fastify server and wrong for every library-mode consumer. `createOrchestrator()`
+ * is mounted inside the integrator's own Next app, so their bundler traces this
+ * module and tries to pack a native `.node` binding. What comes out the other side
+ * is not a constructor, and the failure surfaces far from here: PBA logged
+ * `Failed to open orchestrator SQLite store { err: "Cannot read properties of
+ * undefined (reading 'indexOf')" }` once at boot and then a persist error on every
+ * single write, while `/ops` kept answering `status: "applied"`. Draft edits lived
+ * in one module instance and vanished on the next reload, silently re-seeded from
+ * the CMS.
+ *
+ * `createRequire` gives us Node's own resolver — including the native binding
+ * lookup that a bundle cannot reproduce — and the specifier is assembled at
+ * runtime so static analysis has nothing to follow. It stays synchronous, which is
+ * what lets `getStore()` keep its signature and all eight call sites stay as they
+ * are. The alternative, telling every integrator to add `better-sqlite3` to
+ * `serverExternalPackages`, pushes our dependency's shape into their config and
+ * fails closed only if they read the docs.
+ */
+const SQLITE_SPECIFIER = ["better", "sqlite3"].join("-");
+let cachedCtor = null;
+/*
+ * How the native module is reached, and why it takes three attempts.
+ *
+ * A Next server bundle is hostile to every ordinary route in:
+ *   - `require` is not defined — the emitted chunk is ESM.
+ *   - `node:module` is stubbed, so an imported `createRequire` is `undefined`.
+ *   - webpack special-cases the literal `createRequire(import.meta.url)` idiom
+ *     and swaps in its own shim, which resolves against the bundle rather than
+ *     the host and answers "Cannot find module" for a package that is installed.
+ *
+ * What survives is a dynamic `import()` whose specifier the bundler cannot read,
+ * built with `new Function` — the same technique `screenshot-actions.ts` uses to
+ * keep Playwright out of a consumer's bundle. It is async, which is why the
+ * driver is preloaded at boot (`preloadSqliteDriver`, awaited by
+ * `loadStateFromDisk`) rather than resolved lazily inside the constructor: that
+ * keeps `getStore()` synchronous and all eight of its call sites unchanged.
+ *
+ * The synchronous paths stay as fallbacks for the standalone server and for
+ * tests, which run this file as real ESM under tsx where `createRequire` is
+ * Node's own.
+ */
+const runtimeImport = new Function("specifier", "return import(specifier)");
+function asCtor(loaded) {
+    if (typeof loaded === "function")
+        return loaded;
+    const candidate = loaded?.default;
+    return typeof candidate === "function" ? candidate : null;
+}
+/**
+ * Resolve and cache the driver. Awaited once at startup; safe to call again.
+ * Throws with every attempt's failure when the module cannot be reached at all.
+ */
+export async function preloadSqliteDriver() {
+    if (cachedCtor)
+        return;
+    const failures = [];
+    try {
+        const ctor = asCtor(await runtimeImport(SQLITE_SPECIFIER));
+        if (ctor) {
+            cachedCtor = ctor;
+            return;
+        }
+        failures.push("dynamic import: resolved to a namespace with no constructor");
+    }
+    catch (err) {
+        failures.push(`dynamic import: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        loadDatabaseCtorSync();
+        return;
+    }
+    catch (err) {
+        failures.push(err instanceof Error ? err.message : String(err));
+    }
+    throw new Error(driverError(failures));
+}
+function driverError(failures) {
+    return (`Could not load better-sqlite3 (${failures.join("; ")}). The orchestrator keeps ` +
+        "draft pages, undo stacks and the version log in SQLite; without it every edit " +
+        "is in-memory only and is lost on restart. Install it in the app that mounts " +
+        "createOrchestrator(): `npm install better-sqlite3`. A workspace link to " +
+        "orchestrator-core is not enough — a native module has to be resolvable from " +
+        "the host's own node_modules.");
+}
+function loadDatabaseCtorSync() {
+    if (cachedCtor)
+        return cachedCtor;
+    const failures = [];
+    const attempts = [
+        {
+            name: "createRequire(import.meta.url)",
+            load: () => createRequire(import.meta.url)(SQLITE_SPECIFIER)
+        },
+        {
+            // A plain path, not a file URL: `node:url` is stubbed in a bundle too, so
+            // `pathToFileURL` there is `undefined`. `createRequire` takes a filename.
+            name: "createRequire(cwd)",
+            load: () => createRequire(join(process.cwd(), "noop.js"))(SQLITE_SPECIFIER)
+        }
+    ];
+    for (const attempt of attempts) {
+        try {
+            const ctor = asCtor(attempt.load());
+            if (ctor) {
+                cachedCtor = ctor;
+                return ctor;
+            }
+            failures.push(`${attempt.name}: no constructor`);
+        }
+        catch (err) {
+            failures.push(`${attempt.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    throw new Error(driverError(failures));
+}
+function loadDatabaseCtor() {
+    return cachedCtor ?? loadDatabaseCtorSync();
+}
 // ---------------------------------------------------------------------------
 // Caps (mirrors limits used by in-memory state)
 // ---------------------------------------------------------------------------
@@ -99,6 +221,7 @@ export class SqliteStore {
         if (file !== ":memory:") {
             mkdirSync(dirname(resolve(file)), { recursive: true });
         }
+        const Database = loadDatabaseCtor();
         this.db = new Database(file);
         this.db.pragma("foreign_keys = ON");
         if (useWal) {

package/dist/telemetry/chat-telemetry.js

@@ -174,7 +174,12 @@ export function createChatTelemetryStore(args) {
             "planning_exhausted",
             "planning_refusal",
             "planning_incomplete",
-            "planning_missing"
+            "planning_missing",
+            // An `edit_plan` that carried no operations. It answers 200 and reads as
+            // success to the user, which is exactly why it has to count as a failure
+            // here — otherwise the one outcome nobody can see from the UI is also
+            // invisible in the numbers.
+            "empty_edit_plan"
         ]);
         const failures = recent.filter((row) => row.phase === "result" && row.outcome && failureOutcomes.has(row.outcome));
         const success = recent.filter((row) => row.phase === "result" && row.outcome === "applied");

package/package.json

@@ -1,24 +1,18 @@
 {
   "name": "@avocadostudio-ai/orchestrator-core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./cms": {
       "types": "./dist/cms/index.d.ts",
-      "import": "./dist/cms/index.js"
-    },
-    "./*.js": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js"
-    },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js"
+      "import": "./dist/cms/index.js",
+      "default": "./dist/cms/index.js"
     }
   },
   "dependencies": {
@@ -29,15 +23,16 @@
     "openai": "^4.87.1",
     "sharp": "^0.34.5",
     "zod": "^4.3.6",
-    "@avocadostudio-ai/shared": "0.1.0",
-    "@avocadostudio-ai/migration-sdk": "0.1.0"
+    "@avocadostudio-ai/migration-sdk": "0.2.0",
+    "@avocadostudio-ai/shared": "0.2.0"
   },
   "devDependencies": {
+    "@google/genai": "^1.46.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.13.10",
-    "typescript": "^5.7.3",
     "googleapis": "^171.4.0",
-    "@google/genai": "^1.46.0"
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.3"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -73,6 +68,7 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "build": "tsc -p tsconfig.build.json && node ./scripts/copy-assets.mjs"
+    "build": "tsc -p tsconfig.build.json && node ./scripts/copy-assets.mjs",
+    "test": "NODE_ENV=test node ../../scripts/run-tests.mjs"
   }
 }