@thxgg/steward 0.1.10 → 0.1.11

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward-prod",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "private": true,
   "dependencies": {

package/README.md

@@ -41,6 +41,15 @@ Add to your MCP client config:
 }
 ```
 
+Steward MCP requires a Node runtime with built-in sqlite support (`node:sqlite`) for `repos`, `prds`, and `state` APIs.
+If you see `ERR_UNKNOWN_BUILTIN_MODULE: node:sqlite`, run with sqlite enabled:
+
+```bash
+NODE_OPTIONS=--experimental-sqlite npx -y @thxgg/steward mcp
+```
+
+Note: `execute` runs in a VM sandbox by design, so globals like `process` are intentionally not exposed.
+
 ### CLI
 
 ```bash

package/bin/prd

@@ -1,11 +1,128 @@
 #!/usr/bin/env node
+import { spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
+const SQLITE_ENABLE_FLAG = '--experimental-sqlite'
+const SQLITE_DISABLE_FLAG = '--no-experimental-sqlite'
+const SQLITE_REEXEC_ENV = 'STEWARD_SQLITE_REEXEC'
+
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 const entryPath = resolve(packageRoot, 'dist', 'host', 'src', 'index.js')
 
+function requiresSqliteRuntime(command) {
+  return command === 'mcp' || command === 'ui'
+}
+
+function isSqliteRuntimeError(error) {
+  if (!(error instanceof Error)) {
+    return false
+  }
+
+  const code = error.code
+  return typeof code === 'string'
+    && code === 'ERR_UNKNOWN_BUILTIN_MODULE'
+    && error.message.includes('node:sqlite')
+}
+
+function sanitizeNodeOptions(rawNodeOptions = '') {
+  const options = rawNodeOptions
+    .split(/\s+/)
+    .filter(Boolean)
+    .filter((option) => option !== SQLITE_ENABLE_FLAG && option !== SQLITE_DISABLE_FLAG)
+
+  return options.join(' ')
+}
+
+function buildReexecEnv() {
+  const env = { ...process.env }
+  const sanitizedNodeOptions = sanitizeNodeOptions(env.NODE_OPTIONS)
+
+  if (sanitizedNodeOptions.length > 0) {
+    env.NODE_OPTIONS = sanitizedNodeOptions
+  } else {
+    delete env.NODE_OPTIONS
+  }
+
+  env[SQLITE_REEXEC_ENV] = '1'
+  return env
+}
+
+function canEnableSqliteWithFlag() {
+  const probe = spawnSync(
+    process.execPath,
+    [SQLITE_ENABLE_FLAG, '-e', "import('node:sqlite').then(() => process.exit(0)).catch(() => process.exit(1))"],
+    {
+      stdio: 'ignore',
+      env: buildReexecEnv()
+    }
+  )
+
+  return probe.status === 0
+}
+
+function reexecWithSqliteFlag() {
+  const result = spawnSync(
+    process.execPath,
+    [SQLITE_ENABLE_FLAG, fileURLToPath(import.meta.url), ...process.argv.slice(2)],
+    {
+      stdio: 'inherit',
+      env: buildReexecEnv()
+    }
+  )
+
+  if (result.error) {
+    throw result.error
+  }
+
+  process.exit(result.status ?? 1)
+}
+
+async function ensureSqliteRuntime(command) {
+  if (!requiresSqliteRuntime(command)) {
+    return
+  }
+
+  try {
+    await import('node:sqlite')
+    return
+  } catch (error) {
+    if (!isSqliteRuntimeError(error)) {
+      throw error
+    }
+
+    const alreadyReexecuted = process.env[SQLITE_REEXEC_ENV] === '1'
+    if (!alreadyReexecuted && canEnableSqliteWithFlag()) {
+      reexecWithSqliteFlag()
+      return
+    }
+
+    const message = error instanceof Error ? error.message : String(error)
+    const nodeOptions = process.env.NODE_OPTIONS || ''
+    const hasDisableFlag = process.execArgv.includes(SQLITE_DISABLE_FLAG)
+      || nodeOptions.includes(SQLITE_DISABLE_FLAG)
+
+    console.error('Steward requires SQLite runtime support for repos/prds/state APIs.')
+    console.error(`Runtime: ${process.version} (${process.execPath})`)
+    if (nodeOptions) {
+      console.error(`NODE_OPTIONS: ${nodeOptions}`)
+    }
+    console.error(`Cause: ${message}`)
+
+    if (hasDisableFlag) {
+      console.error(`Hint: remove ${SQLITE_DISABLE_FLAG} from NODE_OPTIONS or runtime args and retry.`)
+    } else {
+      console.error(`Hint: use a Node runtime with sqlite support or launch with ${SQLITE_ENABLE_FLAG}.`)
+    }
+
+    process.exit(1)
+  }
+}
+
+const command = process.argv[2] || ''
+await ensureSqliteRuntime(command)
+
 if (!existsSync(entryPath)) {
   console.error('Steward host runtime is not built.')
   console.error('Run `npm run build:host` in this package before invoking `prd`.')

package/dist/host/src/mcp.js

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { assertSqliteRuntimeSupport } from '../../server/utils/db.js';
 import { execute } from './executor.js';
 import { getExecuteToolDescription } from './help.js';
 function serializeEnvelope(envelope) {
@@ -49,6 +50,7 @@ function buildUnexpectedErrorEnvelope(error) {
     };
 }
 export async function runMcpServer() {
+    await assertSqliteRuntimeSupport();
     const server = new McpServer({
         name: 'steward',
         version: '0.1.0'

package/dist/server/utils/db.js

@@ -3,7 +3,19 @@ import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 const DEFAULT_DATA_HOME = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
 const DEFAULT_DB_PATH = join(DEFAULT_DATA_HOME, 'prd', 'state.db');
+const SQLITE_ENABLE_FLAG = '--experimental-sqlite';
+const SQLITE_DISABLE_FLAG = '--no-experimental-sqlite';
 let adapterPromise = null;
+export class SqliteRuntimeError extends Error {
+    code;
+    details;
+    constructor(message, details) {
+        super(message);
+        this.name = 'SqliteRuntimeError';
+        this.code = 'SQLITE_RUNTIME_UNSUPPORTED';
+        this.details = details;
+    }
+}
 function coerceChanges(result) {
     if (!result || typeof result !== 'object') {
         return 0;
@@ -22,11 +34,84 @@ function resolveDbPath() {
     }
     return DEFAULT_DB_PATH;
 }
+function formatNodeRuntimeHint() {
+    const nodeOptions = process.env.NODE_OPTIONS || '';
+    const hasDisableFlag = process.execArgv.includes(SQLITE_DISABLE_FLAG)
+        || nodeOptions.includes(SQLITE_DISABLE_FLAG);
+    if (hasDisableFlag) {
+        return `Remove ${SQLITE_DISABLE_FLAG} from NODE_OPTIONS or Node arguments.`;
+    }
+    return `Use Node.js with built-in sqlite support, or launch with ${SQLITE_ENABLE_FLAG}.`;
+}
+function mapSqliteImportError(error, dbPath) {
+    if (!(error instanceof Error)) {
+        return new SqliteRuntimeError('SQLite runtime support is unavailable in this process.', {
+            runtime: 'node',
+            dbPath,
+            nodeVersion: process.version,
+            execPath: process.execPath,
+            execArgv: [...process.execArgv],
+            nodeOptions: process.env.NODE_OPTIONS || '',
+            originalMessage: String(error)
+        });
+    }
+    const code = error.code;
+    const isMissingBuiltin = typeof code === 'string'
+        && code === 'ERR_UNKNOWN_BUILTIN_MODULE'
+        && error.message.includes('node:sqlite');
+    const isMissingModule = typeof code === 'string'
+        && code === 'ERR_MODULE_NOT_FOUND'
+        && error.message.includes('node:sqlite');
+    if (!isMissingBuiltin && !isMissingModule) {
+        return error;
+    }
+    return new SqliteRuntimeError(`SQLite runtime support is unavailable for Steward (${process.version}). ${formatNodeRuntimeHint()}`, {
+        runtime: 'node',
+        dbPath,
+        nodeVersion: process.version,
+        execPath: process.execPath,
+        execArgv: [...process.execArgv],
+        nodeOptions: process.env.NODE_OPTIONS || '',
+        originalCode: typeof code === 'string' ? code : undefined,
+        originalMessage: error.message
+    });
+}
+async function loadNodeSqlite(dbPath) {
+    try {
+        return await import('node:sqlite');
+    }
+    catch (error) {
+        throw mapSqliteImportError(error, dbPath);
+    }
+}
 export function getDbPath() {
     return resolveDbPath();
 }
+export async function assertSqliteRuntimeSupport() {
+    const dbPath = resolveDbPath();
+    const isBunRuntime = typeof globalThis.Bun !== 'undefined';
+    if (isBunRuntime) {
+        try {
+            const bunModuleName = 'bun:sqlite';
+            await import(bunModuleName);
+            return;
+        }
+        catch (error) {
+            const code = error instanceof Error
+                ? error.code
+                : undefined;
+            throw new SqliteRuntimeError('SQLite runtime support is unavailable in Bun runtime.', {
+                runtime: 'bun',
+                dbPath,
+                originalCode: typeof code === 'string' ? code : undefined,
+                originalMessage: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    await loadNodeSqlite(dbPath);
+}
 async function createNodeAdapter(dbPath) {
-    const sqliteModule = await import('node:sqlite');
+    const sqliteModule = await loadNodeSqlite(dbPath);
     const db = new sqliteModule.DatabaseSync(dbPath);
     return {
         exec(sql) {

package/docs/MCP.md

@@ -46,6 +46,20 @@ Example MCP client config:
 }
 ```
 
+## Runtime Requirements
+
+- `repos`, `prds`, and `state` APIs require sqlite runtime support.
+- Steward uses Node's built-in `node:sqlite` module.
+- `prd mcp` auto-retries with `--experimental-sqlite` when the runtime supports it.
+
+If you still see `ERR_UNKNOWN_BUILTIN_MODULE: node:sqlite`, launch explicitly with:
+
+```bash
+NODE_OPTIONS=--experimental-sqlite npx -y @thxgg/steward mcp
+```
+
+If that still fails, the MCP host is using an incompatible Node runtime.
+
 ## Execute Contract
 
 `execute` expects one input field:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Local-first PRD workflow steward with codemode MCP and web UI.",
   "type": "module",
   "author": "thxgg",

package/.output/public/_nuxt/builds/meta/7fda7510-94bc-443a-a338-a8d2af142ed9.json

@@ -1 +0,0 @@
-{"id":"7fda7510-94bc-443a-a338-a8d2af142ed9","timestamp":1771867324818,"prerendered":[]}