pragma-so 0.1.14 → 0.1.16

package/dist/server/db.js

@@ -24,13 +24,12 @@ const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const pglite_1 = require("@electric-sql/pglite");
+const pglite_socket_1 = require("@electric-sql/pglite-socket");
+const pg_1 = require("pg");
 const gitWorkflow_1 = require("./conversation/gitWorkflow");
 const store_1 = require("./conversation/store");
 const bundledSkills_1 = require("./bundledSkills");
-const CONFIGURED_PRAGMA_DIR = process.env.PRAGMA_DIR?.trim();
-exports.PRAGMA_DIR = CONFIGURED_PRAGMA_DIR
-    ? (0, node_path_1.resolve)(CONFIGURED_PRAGMA_DIR)
-    : (0, node_path_1.join)((0, node_os_1.homedir)(), ".pragma");
+exports.PRAGMA_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".pragma");
 const ACTIVE_WORKSPACE_FILE = (0, node_path_1.join)(exports.PRAGMA_DIR, "active_workspace");
 const RESERVED_ROOT_NAMES = new Set(["db", "workspace", "worktrees"]);
 exports.DEFAULT_AGENT_ID = "pragma-orchestrator";
@@ -43,6 +42,9 @@ function getDefaultModelForHarness(harness) {
     return DEFAULT_HARNESS_MODELS[harness] ?? DEFAULT_HARNESS_MODELS.claude_code;
 }
 const REAL_CLOSE = new WeakMap();
+const DB_SOCKET_HOST = "127.0.0.1";
+const DB_SOCKET_WAIT_MS = 5000;
+const DB_SOCKET_POLL_MS = 100;
 exports.DEFAULT_AGENT_FILE = `# Orchestrator
 
 You are the orchestrator agent for Pragma.
@@ -354,7 +356,7 @@ async function openDatabase(workspaceName) {
     if (existing) {
         return existing;
     }
-    const pending = createWorkspaceDatabase(paths.dbDir).catch((error) => {
+    const pending = openWorkspaceDatabase(paths).catch((error) => {
         OPEN_DATABASES.delete(workspaceName);
         throw error;
     });
@@ -394,7 +396,46 @@ function validateWorkspaceName(name) {
         throw new PragmaError("INVALID_WORKSPACE_NAME", 400, "Workspace name is reserved.");
     }
 }
-async function createWorkspaceDatabase(dbDir) {
+async function openWorkspaceDatabase(paths) {
+    const remote = await tryConnectToWorkspaceDatabase(paths);
+    if (remote) {
+        return remote;
+    }
+    if (await acquireWorkspaceOwnerLock(paths)) {
+        try {
+            return await createOwnedWorkspaceDatabase(paths);
+        }
+        catch (error) {
+            await cleanupWorkspaceSocketFiles(paths);
+            throw error;
+        }
+    }
+    const waited = await waitForWorkspaceDatabase(paths);
+    if (waited) {
+        return waited;
+    }
+    throw new Error(`Timed out waiting for shared workspace database: ${paths.name}`);
+}
+async function createOwnedWorkspaceDatabase(paths) {
+    const db = await initializeWorkspaceDatabase(paths.dbDir);
+    const rawClose = db.close.bind(db);
+    const socketServer = new pglite_socket_1.PGLiteSocketServer({
+        db,
+        host: DB_SOCKET_HOST,
+        port: 0,
+        maxConnections: 25,
+    });
+    await socketServer.start();
+    const socketInfo = createSocketInfo(paths.name, socketServer.getServerConn());
+    await writeSocketInfo(paths, socketInfo);
+    const realClose = async () => {
+        await socketServer.stop().catch(() => { });
+        await cleanupWorkspaceSocketFiles(paths);
+        await rawClose();
+    };
+    return patchDatabaseClose(db, realClose);
+}
+async function initializeWorkspaceDatabase(dbDir) {
     const db = new pglite_1.PGlite(dbDir);
     await db.waitReady;
     await ensureRequiredSchema(db);
@@ -402,17 +443,209 @@ async function createWorkspaceDatabase(dbDir) {
     await ensureDefaultHuman(db);
     await ensureDefaultSkills(db);
     await (0, store_1.ensureConversationSchema)(db);
-    return patchDatabaseClose(db);
+    return db;
 }
-function patchDatabaseClose(db) {
+function patchDatabaseClose(db, realClose) {
     if (REAL_CLOSE.has(db)) {
         return db;
     }
-    const realClose = db.close.bind(db);
     REAL_CLOSE.set(db, realClose);
     db.close = async () => { };
     return db;
 }
+async function tryConnectToWorkspaceDatabase(paths) {
+    const socketInfo = await readSocketInfo(paths);
+    if (!socketInfo) {
+        return null;
+    }
+    try {
+        return await connectToSharedDatabase(socketInfo);
+    }
+    catch {
+        if (!isProcessAlive(socketInfo.ownerPid)) {
+            await cleanupWorkspaceSocketFiles(paths);
+        }
+        return null;
+    }
+}
+async function waitForWorkspaceDatabase(paths) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < DB_SOCKET_WAIT_MS) {
+        const remote = await tryConnectToWorkspaceDatabase(paths);
+        if (remote) {
+            return remote;
+        }
+        const ownerLock = await readOwnerLock(paths);
+        if (!ownerLock) {
+            if (await acquireWorkspaceOwnerLock(paths)) {
+                try {
+                    return await createOwnedWorkspaceDatabase(paths);
+                }
+                catch (error) {
+                    await cleanupWorkspaceSocketFiles(paths);
+                    throw error;
+                }
+            }
+        }
+        else if (!isProcessAlive(ownerLock.ownerPid)) {
+            await cleanupWorkspaceSocketFiles(paths);
+            if (await acquireWorkspaceOwnerLock(paths)) {
+                try {
+                    return await createOwnedWorkspaceDatabase(paths);
+                }
+                catch (error) {
+                    await cleanupWorkspaceSocketFiles(paths);
+                    throw error;
+                }
+            }
+        }
+        await sleep(DB_SOCKET_POLL_MS);
+    }
+    return null;
+}
+async function connectToSharedDatabase(socketInfo) {
+    const client = new pg_1.Client({
+        host: socketInfo.host,
+        port: socketInfo.port,
+        database: "template1",
+        ssl: false,
+    });
+    client.on("error", () => { });
+    await client.connect();
+    await client.query("SELECT 1");
+    const remote = patchDatabaseClose(new RemotePGliteClient(client), async () => {
+        await client.end().catch(() => { });
+    });
+    return remote;
+}
+async function acquireWorkspaceOwnerLock(paths) {
+    const lockPath = getSocketLockPath(paths);
+    for (;;) {
+        try {
+            const payload = {
+                ownerPid: process.pid,
+                createdAt: new Date().toISOString(),
+            };
+            await (0, promises_1.writeFile)(lockPath, JSON.stringify(payload), { flag: "wx" });
+            return true;
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "EEXIST") {
+                throw error;
+            }
+            const lock = await readOwnerLock(paths);
+            if (!lock || !isProcessAlive(lock.ownerPid)) {
+                await (0, promises_1.rm)(lockPath, { force: true });
+                continue;
+            }
+            return false;
+        }
+    }
+}
+async function readSocketInfo(paths) {
+    try {
+        const raw = await (0, promises_1.readFile)(getSocketInfoPath(paths), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.workspaceName !== paths.name ||
+            typeof parsed.host !== "string" ||
+            !Number.isInteger(parsed.port) ||
+            parsed.port <= 0 ||
+            typeof parsed.ownerPid !== "number") {
+            return null;
+        }
+        return {
+            workspaceName: parsed.workspaceName,
+            host: parsed.host,
+            port: Number(parsed.port),
+            ownerPid: parsed.ownerPid,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeSocketInfo(paths, socketInfo) {
+    await (0, promises_1.writeFile)(getSocketInfoPath(paths), JSON.stringify(socketInfo));
+}
+async function readOwnerLock(paths) {
+    try {
+        const raw = await (0, promises_1.readFile)(getSocketLockPath(paths), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.ownerPid !== "number") {
+            return null;
+        }
+        return {
+            ownerPid: parsed.ownerPid,
+            createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function cleanupWorkspaceSocketFiles(paths) {
+    await (0, promises_1.rm)(getSocketInfoPath(paths), { force: true });
+    await (0, promises_1.rm)(getSocketLockPath(paths), { force: true });
+}
+function getSocketInfoPath(paths) {
+    return (0, node_path_1.join)(paths.rootDir, ".db-socket.json");
+}
+function getSocketLockPath(paths) {
+    return (0, node_path_1.join)(paths.rootDir, ".db-socket.lock");
+}
+function createSocketInfo(workspaceName, serverConn) {
+    const [host, portValue] = serverConn.split(":");
+    const port = Number.parseInt(portValue ?? "", 10);
+    if (!host || !Number.isInteger(port) || port <= 0) {
+        throw new Error(`Invalid PGlite socket server address: ${serverConn}`);
+    }
+    return {
+        workspaceName,
+        host,
+        port,
+        ownerPid: process.pid,
+        startedAt: new Date().toISOString(),
+    };
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class RemotePGliteClient {
+    constructor(client) {
+        this.client = client;
+    }
+    async query(sql, params) {
+        const result = await this.client.query(sql, params);
+        return {
+            rows: result.rows,
+            fields: result.fields,
+            rowCount: result.rowCount ?? 0,
+            affectedRows: result.rowCount ?? 0,
+        };
+    }
+    async exec(sql) {
+        await this.client.query(sql);
+    }
+    async close() {
+        await this.client.end();
+    }
+}
 async function ensureRequiredSchema(db) {
     await ensureTaskStatusEnumType(db);
     await db.exec(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pragma-so",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Very minimal pragma-so CLI",
   "main": "dist/cli/index.js",
   "bin": {
@@ -8,7 +8,6 @@
   },
   "scripts": {
     "build": "tsc && npm run ui:build",
-    "dev": "node scripts/dev-start.mjs",
     "prepack": "npm run build",
     "start": "node dist/cli/index.js",
     "ui:dev": "vite --config ui/vite.config.mjs ui",
@@ -29,6 +28,7 @@
   "type": "commonjs",
   "dependencies": {
     "@electric-sql/pglite": "^0.3.16",
+    "@electric-sql/pglite-socket": "^0.0.22",
     "@emoji-mart/data": "^1.2.1",
     "@emoji-mart/react": "^1.1.1",
     "@hono/node-server": "^1.19.11",
@@ -44,6 +44,7 @@
     "mime-types": "^3.0.2",
     "open": "^8.4.2",
     "papaparse": "^5.5.3",
+    "pg": "^8.20.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-markdown": "^10.1.0",
@@ -52,6 +53,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.4.0",
+    "@types/pg": "^8.18.0",
     "@vitejs/plugin-react": "^4.3.1",
     "typescript": "^5.9.3",
     "vite": "^5.4.11"