@bbigbang/runtime-acp 0.1.0

package/dist/runtime/workspaceLockManager.js

@@ -0,0 +1,141 @@
+import path from 'node:path';
+export class WorkspaceLockManager {
+    locks = new Map();
+    normalizeKey(workspaceRoot) {
+        return path.resolve(workspaceRoot);
+    }
+    async acquire(workspaceRoot, hooks) {
+        const key = this.normalizeKey(workspaceRoot);
+        const state = this.getState(key);
+        throwIfAborted(hooks?.signal);
+        let waited = false;
+        if (state.locked || state.waiters.length > 0) {
+            waited = true;
+            hooks?.onWaitStart?.();
+            await new Promise((resolve, reject) => {
+                let onAbort = () => { };
+                const cleanup = () => {
+                    hooks?.signal?.removeEventListener('abort', onAbort);
+                };
+                const waiter = {
+                    granted: false,
+                    settled: false,
+                    resolve: () => {
+                        if (waiter.settled)
+                            return;
+                        waiter.settled = true;
+                        cleanup();
+                        resolve();
+                    },
+                    reject: (error) => {
+                        if (waiter.settled)
+                            return;
+                        waiter.settled = true;
+                        cleanup();
+                        reject(error);
+                    },
+                    signal: hooks?.signal,
+                };
+                onAbort = () => {
+                    const index = state.waiters.indexOf(waiter);
+                    if (index >= 0) {
+                        state.waiters.splice(index, 1);
+                    }
+                    if (waiter.granted) {
+                        this.release(key);
+                    }
+                    waiter.reject(createWorkspaceLockAbortError());
+                };
+                hooks?.signal?.addEventListener('abort', onAbort, { once: true });
+                state.waiters.push(waiter);
+            });
+        }
+        if (hooks?.signal?.aborted) {
+            if (waited) {
+                this.release(key);
+            }
+            throw createWorkspaceLockAbortError();
+        }
+        state.locked = true;
+        hooks?.onAcquired?.({ waited });
+        let released = false;
+        return {
+            key,
+            waited,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.release(key);
+            },
+        };
+    }
+    async runExclusive(workspaceRoot, action, hooks) {
+        const lease = await this.acquire(workspaceRoot, hooks);
+        try {
+            return await action();
+        }
+        finally {
+            lease.release();
+        }
+    }
+    async runAfterPendingWrites(workspaceRoot, action, hooks) {
+        const key = this.normalizeKey(workspaceRoot);
+        const state = this.locks.get(key);
+        if (!state || (!state.locked && state.waiters.length === 0)) {
+            throwIfAborted(hooks?.signal);
+            return await action();
+        }
+        const lease = await this.acquire(workspaceRoot, hooks);
+        try {
+            return await action();
+        }
+        finally {
+            lease.release();
+        }
+    }
+    async waitForPendingWrites(workspaceRoot, hooks) {
+        await this.runAfterPendingWrites(workspaceRoot, () => { }, hooks);
+    }
+    getState(key) {
+        let state = this.locks.get(key);
+        if (!state) {
+            state = { locked: false, waiters: [] };
+            this.locks.set(key, state);
+        }
+        return state;
+    }
+    release(key) {
+        const state = this.locks.get(key);
+        if (!state)
+            return;
+        while (state.waiters.length > 0) {
+            const next = state.waiters.shift();
+            if (next.signal?.aborted || next.settled) {
+                next.reject(createWorkspaceLockAbortError());
+                continue;
+            }
+            next.granted = true;
+            state.locked = true;
+            queueMicrotask(() => {
+                if (next.signal?.aborted || next.settled) {
+                    return;
+                }
+                next.resolve();
+            });
+            return;
+        }
+        state.locked = false;
+        this.locks.delete(key);
+    }
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw createWorkspaceLockAbortError();
+}
+function createWorkspaceLockAbortError() {
+    const error = new Error('Workspace lock acquisition cancelled.');
+    error.name = 'AbortError';
+    return error;
+}

package/dist/tools/workspace.d.ts

@@ -0,0 +1 @@
+export declare function resolveWorkspacePath(workspaceRoot: string, requestedPath: string): string;

package/dist/tools/workspace.js

@@ -0,0 +1,13 @@
+import path from 'node:path';
+export function resolveWorkspacePath(workspaceRoot, requestedPath) {
+    if (!path.isAbsolute(requestedPath)) {
+        throw new Error(`ACP path must be absolute: ${requestedPath}`);
+    }
+    const resolved = path.resolve(requestedPath);
+    const root = path.resolve(workspaceRoot);
+    if (resolved === root)
+        return resolved;
+    if (resolved.startsWith(root + path.sep))
+        return resolved;
+    throw new Error(`Path escapes WORKSPACE_ROOT: ${requestedPath}`);
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@bbigbang/runtime-acp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "ACP execution engine — shared runtime for core and agent-node",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/__tests__/**",
+    "!dist/**/*.test.*",
+    "!dist/**/*.map",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.3.3",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "echo 'No lint configured'",
+    "dev": "tsc -p tsconfig.json --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}