runwork 0.6.1 → 0.8.2

package/dist/utils/__tests__/sqlite.test.js

@@ -1,77 +1,89 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import path from 'path';
-// Mock better-sqlite3 for controlled tests
-vi.mock('better-sqlite3', () => {
-    const MockDatabase = vi.fn();
-    return { default: MockDatabase };
+/**
+ * Tests for the runtime SQLite adapter.
+ *
+ * The adapter picks bun:sqlite (compiled binary path) or node:sqlite
+ * (npx runwork@latest on Node >= 22.5) at module load time, and falls back
+ * to an "unavailable" path that returns empty string / null so SQLite-backed
+ * telemetry features degrade gracefully instead of breaking the CLI install.
+ *
+ * Vitest under the dev machine may run on Node 20 (no node:sqlite, no Bun
+ * global), so these tests gate fixture-database coverage on sqliteAvailable()
+ * and always assert the degradation contract.
+ */
+import { describe, it, expect } from 'vitest';
+import { fileURLToPath } from 'node:url';
+import { querySqlite, sqliteAvailable, sqliteFlavor, openWritableSqlite, } from '../sqlite.js';
+const FIXTURE_DB = fileURLToPath(new URL('../../agents/__tests__/fixtures/codex/state.sqlite', import.meta.url));
+const SQLITE_AVAILABLE = sqliteAvailable();
+describe('sqlite adapter runtime detection', () => {
+    it('exposes a boolean sqliteAvailable flag', () => {
+        expect(typeof SQLITE_AVAILABLE).toBe('boolean');
+    });
+    it('reports bun, node, or null as the flavor', () => {
+        const flavor = sqliteFlavor();
+        expect(flavor === 'bun' || flavor === 'node' || flavor === null).toBe(true);
+    });
+    it('agrees: available iff flavor is non-null', () => {
+        expect(sqliteAvailable()).toBe(sqliteFlavor() !== null);
+    });
+});
+describe('querySqlite unavailable-runtime contract', () => {
+    // These assertions must pass whether or not a SQLite runtime is available,
+    // because they only exercise the graceful-degradation path.
+    it('returns empty string for a nonexistent database path', () => {
+        expect(querySqlite('/nonexistent/path/that/does/not/exist.db', 'SELECT 1')).toBe('');
+    });
+    it('returns empty string for invalid SQL against a nonexistent path', () => {
+        expect(querySqlite('/nonexistent.db', 'INVALID SQL QUERY')).toBe('');
+    });
+    it('never throws even when asked for unreachable data', () => {
+        expect(() => querySqlite('/tmp/does-not-exist.db', 'SELECT 1')).not.toThrow();
+    });
 });
-import Database from 'better-sqlite3';
-import { querySqlite } from '../sqlite.js';
-const FIXTURE_DB = path.resolve(__dirname, '../../agents/__tests__/fixtures/codex/state.sqlite');
-beforeEach(() => {
-    vi.restoreAllMocks();
+describe.runIf(SQLITE_AVAILABLE)('querySqlite against the fixture database', () => {
+    it('returns pipe-separated values for multi-column results', () => {
+        const result = querySqlite(FIXTURE_DB, "SELECT id, tokens_used FROM threads WHERE id = 'old-session'");
+        expect(result).toBe('old-session|50000');
+    });
+    it('returns newline-separated rows for multiple rows', () => {
+        const result = querySqlite(FIXTURE_DB, 'SELECT id, tokens_used FROM threads ORDER BY created_at');
+        const lines = result.split('\n');
+        expect(lines).toHaveLength(3);
+        expect(lines[0]).toContain('old-session');
+        expect(lines[1]).toContain('recent-session');
+        expect(lines[2]).toContain('newest-session');
+    });
+    it('returns a single-column single-row result without delimiters', () => {
+        const result = querySqlite(FIXTURE_DB, 'SELECT max(tokens_used) FROM threads');
+        expect(result).toBe('120000');
+    });
+    it('returns empty string on SQL error even when runtime is available', () => {
+        const result = querySqlite(FIXTURE_DB, 'INVALID SQL QUERY');
+        expect(result).toBe('');
+    });
+    it('returns empty string when the target table does not exist', () => {
+        const result = querySqlite(FIXTURE_DB, 'SELECT * FROM nonexistent_table');
+        expect(result).toBe('');
+    });
+});
+describe('openWritableSqlite unavailable-runtime contract', () => {
+    it('returns null for a missing database path', () => {
+        expect(openWritableSqlite('/nonexistent/writable/db.sqlite')).toBeNull();
+    });
 });
-describe('querySqlite', () => {
-    // ── Tests using the real fixture database ──────────────────────────
-    describe('with real fixture database', () => {
-        beforeEach(() => {
-            // Restore the real better-sqlite3 implementation for fixture tests
-            vi.mocked(Database).mockImplementation((...args) => {
-                const RealDatabase = vi.importActual('better-sqlite3');
-                // importActual returns a promise, but we need synchronous access;
-                // however vi.importActual in the module-scope mock is async.
-                // Instead, re-require the real module.
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const Actual = require('better-sqlite3');
-                return new Actual(...args);
-            });
-        });
-        it('returns pipe-separated values for multi-column results', () => {
-            const result = querySqlite(FIXTURE_DB, "SELECT id, tokens_used FROM threads WHERE id = 'old-session'");
-            expect(result).toBe('old-session|50000');
-        });
-        it('returns newline-separated rows for multiple rows', () => {
-            const result = querySqlite(FIXTURE_DB, 'SELECT id, tokens_used FROM threads ORDER BY created_at');
-            const lines = result.split('\n');
-            expect(lines).toHaveLength(3);
-            expect(lines[0]).toContain('old-session');
-            expect(lines[1]).toContain('recent-session');
-            expect(lines[2]).toContain('newest-session');
-        });
+describe.runIf(SQLITE_AVAILABLE)('openWritableSqlite against the fixture database', () => {
+    it('opens the fixture database when it exists and can prepare SELECTs', () => {
+        const handle = openWritableSqlite(FIXTURE_DB);
+        expect(handle).not.toBeNull();
+        expect(handle?.flavor === 'bun' || handle?.flavor === 'node').toBe(true);
+        const row = handle.prepare("SELECT id FROM threads WHERE id = 'old-session'").get();
+        expect(row?.id).toBe('old-session');
+        handle.close();
     });
-    // ── Tests using mocked database ────────────────────────────────────
-    describe('error handling', () => {
-        it('returns empty string when database does not exist', () => {
-            vi.mocked(Database).mockImplementation(() => {
-                throw new Error('SQLITE_CANTOPEN: unable to open database file');
-            });
-            const result = querySqlite('/nonexistent/path.db', 'SELECT 1');
-            expect(result).toBe('');
-        });
-        it('returns empty string when SQL is invalid', () => {
-            const mockPrepare = vi.fn().mockImplementation(() => {
-                throw new Error('SQLITE_ERROR: near "INVALID": syntax error');
-            });
-            const mockClose = vi.fn();
-            vi.mocked(Database).mockImplementation(() => ({ prepare: mockPrepare, close: mockClose }));
-            const result = querySqlite('/some/db.sqlite', 'INVALID SQL QUERY');
-            expect(result).toBe('');
-        });
-        it('returns empty string when database is corrupted', () => {
-            vi.mocked(Database).mockImplementation(() => {
-                throw new Error('SQLITE_CORRUPT: database disk image is malformed');
-            });
-            const result = querySqlite('/corrupted/db.sqlite', 'SELECT 1');
-            expect(result).toBe('');
-        });
-        it('closes database even on query error', () => {
-            const mockClose = vi.fn();
-            const mockPrepare = vi.fn().mockImplementation(() => {
-                throw new Error('query failed');
-            });
-            vi.mocked(Database).mockImplementation(() => ({ prepare: mockPrepare, close: mockClose }));
-            querySqlite('/some/db.sqlite', 'SELECT 1');
-            expect(mockClose).toHaveBeenCalledTimes(1);
-        });
+    it('close() tolerates double-close without throwing', () => {
+        const handle = openWritableSqlite(FIXTURE_DB);
+        expect(handle).not.toBeNull();
+        handle.close();
+        expect(() => handle.close()).not.toThrow();
     });
 });

package/dist/utils/sqlite-adapter.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Runtime SQLite adapter.
+ *
+ * Selects a SQLite backend at module load time:
+ *   1. `bun:sqlite` when running under Bun (the compiled standalone CLI binary)
+ *   2. `node:sqlite` when running on Node >= 22.5 (the `npx runwork@latest` path)
+ *   3. null, in which case SQLite-backed telemetry features degrade gracefully
+ *      instead of breaking install
+ *
+ * This replaces the previous hard dependency on `better-sqlite3`, which
+ * required a native npm build and failed in restricted sandboxes, locked-down
+ * corporate environments, and low-privilege containers.
+ */
+type SqliteFlavor = 'bun' | 'node';
+interface StatementHandle {
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+    run(...params: unknown[]): unknown;
+}
+/**
+ * Returns true when a SQLite runtime is available.
+ * Use this to gate telemetry / agent-stats features that can degrade gracefully.
+ */
+export declare function sqliteAvailable(): boolean;
+/**
+ * Returns the name of the SQLite backend in use, or null if none is available.
+ * Intended for doctor / diagnostic output.
+ */
+export declare function sqliteFlavor(): SqliteFlavor | null;
+export declare function queryReadonlySqlite(dbPath: string, sql: string): string;
+/**
+ * Handle returned by `openWritableSqlite` for write operations.
+ * Callers are responsible for calling `close()` when done.
+ */
+export interface WritableSqlite {
+    prepare(sql: string): StatementHandle;
+    close(): void;
+    readonly flavor: SqliteFlavor;
+}
+/**
+ * Open a writable SQLite database. Returns null when no SQLite runtime is
+ * available, letting the caller degrade gracefully instead of crashing.
+ *
+ * On failure to open the database (missing file, permission denied, locked),
+ * this also returns null.
+ */
+export declare function openWritableSqlite(dbPath: string): WritableSqlite | null;
+export {};

package/dist/utils/sqlite-adapter.js

@@ -0,0 +1,147 @@
+/**
+ * Runtime SQLite adapter.
+ *
+ * Selects a SQLite backend at module load time:
+ *   1. `bun:sqlite` when running under Bun (the compiled standalone CLI binary)
+ *   2. `node:sqlite` when running on Node >= 22.5 (the `npx runwork@latest` path)
+ *   3. null, in which case SQLite-backed telemetry features degrade gracefully
+ *      instead of breaking install
+ *
+ * This replaces the previous hard dependency on `better-sqlite3`, which
+ * required a native npm build and failed in restricted sandboxes, locked-down
+ * corporate environments, and low-privilege containers.
+ */
+let adapter = null;
+async function loadAdapter() {
+    // Try bun:sqlite first. Bun defines a global `Bun` object we can sniff for.
+    const bunGlobal = globalThis.Bun;
+    if (typeof bunGlobal !== 'undefined') {
+        try {
+            const specifier = 'bun:sqlite';
+            const mod = (await import(/* @vite-ignore */ specifier));
+            if (mod?.Database) {
+                return {
+                    flavor: 'bun',
+                    Database: mod.Database,
+                    readOnlyOptionKey: 'readonly',
+                    readOnlyOptionValue: true,
+                };
+            }
+        }
+        catch {
+            // bun:sqlite unavailable despite Bun global; fall through to Node path
+        }
+    }
+    // Try node:sqlite. Available in Node >= 22.5 stable.
+    try {
+        const specifier = 'node:sqlite';
+        const mod = (await import(/* @vite-ignore */ specifier));
+        if (mod?.DatabaseSync) {
+            return {
+                flavor: 'node',
+                Database: mod.DatabaseSync,
+                readOnlyOptionKey: 'readOnly',
+                readOnlyOptionValue: true,
+            };
+        }
+    }
+    catch {
+        // node:sqlite unavailable (older Node, or flag off)
+    }
+    return null;
+}
+// Top-level await: module load blocks until an adapter is chosen.
+// The CLI is an ESM package running on Bun or modern Node, both of which
+// support top-level await.
+adapter = await loadAdapter();
+/**
+ * Returns true when a SQLite runtime is available.
+ * Use this to gate telemetry / agent-stats features that can degrade gracefully.
+ */
+export function sqliteAvailable() {
+    return adapter !== null;
+}
+/**
+ * Returns the name of the SQLite backend in use, or null if none is available.
+ * Intended for doctor / diagnostic output.
+ */
+export function sqliteFlavor() {
+    return adapter?.flavor ?? null;
+}
+/**
+ * Execute a read-only SQL query against a SQLite database and return the rows
+ * serialised as `value1|value2|value3` per row, newline separated. Matches the
+ * legacy `querySqlite` contract so existing parsers do not have to change.
+ *
+ * Returns an empty string on any failure (missing database, locked, corrupt,
+ * unavailable runtime). Callers must tolerate the empty-string path.
+ */
+const BUSY_TIMEOUT_MS = 5000;
+function setBusyTimeout(db) {
+    // bun:sqlite has no `timeout` constructor option and node:sqlite had a
+    // moving target across versions, so set busy_timeout via a PRAGMA that
+    // works on every SQLite build. PRAGMA busy_timeout is a per-connection
+    // runtime setting and does not require write permissions.
+    try {
+        db.prepare(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`).run();
+    }
+    catch {
+        /* some flavors refuse PRAGMA on readonly; best-effort */
+    }
+}
+export function queryReadonlySqlite(dbPath, sql) {
+    if (!adapter)
+        return '';
+    let db = null;
+    try {
+        const options = {
+            [adapter.readOnlyOptionKey]: adapter.readOnlyOptionValue,
+        };
+        db = new adapter.Database(dbPath, options);
+        setBusyTimeout(db);
+        const rows = db.prepare(sql).all();
+        return rows.map((row) => Object.values(row).join('|')).join('\n');
+    }
+    catch {
+        return '';
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            /* ignore close errors */
+        }
+    }
+}
+/**
+ * Open a writable SQLite database. Returns null when no SQLite runtime is
+ * available, letting the caller degrade gracefully instead of crashing.
+ *
+ * On failure to open the database (missing file, permission denied, locked),
+ * this also returns null.
+ */
+export function openWritableSqlite(dbPath) {
+    if (!adapter)
+        return null;
+    try {
+        const db = new adapter.Database(dbPath);
+        setBusyTimeout(db);
+        const flavor = adapter.flavor;
+        return {
+            prepare: (sql) => db.prepare(sql),
+            close: () => {
+                try {
+                    db.close();
+                }
+                catch {
+                    /* ignore close errors */
+                }
+            },
+            flavor,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/sqlite.d.ts

@@ -1,7 +1,14 @@
 /**
- * Query a SQLite database using better-sqlite3.
- * Cross-platform, no CLI dependency.
- * Opens database in readonly mode with a 5-second busy timeout.
- * Returns empty string on any error (missing DB, locked, corrupted).
+ * Read-only SQLite query helper used by agent stats readers.
+ *
+ * This file used to hard-depend on `better-sqlite3`, which required a native
+ * npm build and failed in low-privilege containers and corporate sandboxes.
+ * It now re-exports the runtime-aware adapter which picks `bun:sqlite` in the
+ * compiled standalone binary, `node:sqlite` when running under `npx`, and a
+ * structured "unavailable" path otherwise (returns empty string).
+ *
+ * The `querySqlite` name is preserved so existing call sites and mocks in
+ * tests keep working.
  */
-export declare function querySqlite(dbPath: string, sql: string): string;
+export { queryReadonlySqlite as querySqlite } from './sqlite-adapter.js';
+export { openWritableSqlite, sqliteAvailable, sqliteFlavor, type WritableSqlite } from './sqlite-adapter.js';

package/dist/utils/sqlite.js

@@ -1,24 +1,14 @@
-import Database from 'better-sqlite3';
 /**
- * Query a SQLite database using better-sqlite3.
- * Cross-platform, no CLI dependency.
- * Opens database in readonly mode with a 5-second busy timeout.
- * Returns empty string on any error (missing DB, locked, corrupted).
+ * Read-only SQLite query helper used by agent stats readers.
+ *
+ * This file used to hard-depend on `better-sqlite3`, which required a native
+ * npm build and failed in low-privilege containers and corporate sandboxes.
+ * It now re-exports the runtime-aware adapter which picks `bun:sqlite` in the
+ * compiled standalone binary, `node:sqlite` when running under `npx`, and a
+ * structured "unavailable" path otherwise (returns empty string).
+ *
+ * The `querySqlite` name is preserved so existing call sites and mocks in
+ * tests keep working.
  */
-export function querySqlite(dbPath, sql) {
-    let db = null;
-    try {
-        db = new Database(dbPath, { readonly: true, timeout: 5000 });
-        const rows = db.prepare(sql).all();
-        return rows.map(row => Object.values(row).join('|')).join('\n');
-    }
-    catch {
-        return '';
-    }
-    finally {
-        try {
-            db?.close();
-        }
-        catch { /* ignore close errors */ }
-    }
-}
+export { queryReadonlySqlite as querySqlite } from './sqlite-adapter.js';
+export { openWritableSqlite, sqliteAvailable, sqliteFlavor } from './sqlite-adapter.js';

package/dist/utils/zip.d.ts

@@ -1 +1,7 @@
 export declare function extractZip(zipData: ArrayBuffer, targetDir: string): void;
+/**
+ * Walk `sourceDir` recursively and write a zip file at `outputPath`.
+ * Entry paths inside the zip are forward-slash relative paths from
+ * `sourceDir`, matching the cross-platform convention that zip tools use.
+ */
+export declare function createZipFromDir(sourceDir: string, outputPath: string): void;

package/dist/utils/zip.js

@@ -1,6 +1,6 @@
-import { mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { unzipSync } from 'fflate';
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { join, dirname, relative, sep } from 'path';
+import { unzipSync, zipSync } from 'fflate';
 export function extractZip(zipData, targetDir) {
     const files = unzipSync(new Uint8Array(zipData));
     for (const [path, data] of Object.entries(files)) {
@@ -15,3 +15,28 @@ export function extractZip(zipData, targetDir) {
         writeFileSync(fullPath, data);
     }
 }
+/**
+ * Walk `sourceDir` recursively and write a zip file at `outputPath`.
+ * Entry paths inside the zip are forward-slash relative paths from
+ * `sourceDir`, matching the cross-platform convention that zip tools use.
+ */
+export function createZipFromDir(sourceDir, outputPath) {
+    const files = {};
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const absPath = join(dir, entry);
+            const stats = statSync(absPath);
+            if (stats.isDirectory()) {
+                walk(absPath);
+            }
+            else if (stats.isFile()) {
+                const relPath = relative(sourceDir, absPath).split(sep).join('/');
+                files[relPath] = readFileSync(absPath);
+            }
+        }
+    };
+    walk(sourceDir);
+    const zipped = zipSync(files);
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, zipped);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.6.1",
+  "version": "0.8.2",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",
@@ -43,7 +43,6 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.1.0",
-    "better-sqlite3": "^12.8.0",
     "chokidar": "^4.0.0",
     "commander": "^13.0.0",
     "fflate": "^0.8.2",
@@ -52,13 +51,12 @@
     "smol-toml": "^1.6.1"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0",
     "vitest": "^3.2.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22.5.0"
   },
   "files": [
     "dist/**/*.js",