@hachej/boring-agent 0.1.111 → 0.2.0

package/dist/workspaces.js

@@ -0,0 +1,212 @@
+/** The single-workspace case: every call uses `binding`. */
+export function constantWorkspace(binding) {
+    checked(binding);
+    const frozen = Object.freeze({ ...binding });
+    return () => frozen;
+}
+/** A resolver as given, or a binding wrapped as a constant resolver; nothing: the workspace of the call's env (`withWorkspace`). */
+export function asWorkspaceResolver(workspace) {
+    return workspace === undefined || typeof workspace === 'function' ? workspace : constantWorkspace(workspace);
+}
+const decorations = new WeakMap();
+/** Mark `view` as a decoration of `env` (the same workspace, for example `confinedEnv`'s): the workspace of `view` is that of `env`. Returns `view`. */
+export function decorate(env, view) { decorations.set(view, env); return view; }
+/** The env `env` decorates, or `env` itself: the env a workspace is attached to. */
+const undecorated = (env) => decorations.get(env) ?? env;
+const attached = new WeakMap();
+/**
+ * Attach `binding` to `env`: the workspace that comes with that env. The host's `HarnessOptions.env(target, context)` returns such an
+ * env, and every tool without its own `workspace` option uses its binding, so one host function resolves both. Returns `env`.
+ */
+export function withWorkspace(env, binding) {
+    checked(binding);
+    if (binding.env !== undefined && binding.env !== env)
+        throw new TypeError('A workspace binding names another env');
+    attached.set(env, Object.freeze({ ...binding, env }));
+    return env;
+}
+/** The workspace attached to `env` (`withWorkspace`, or the env of a `createWorkspaceCache` entry), if any. */
+export const workspaceOfEnv = (env) => env === undefined ? undefined : attached.get(env);
+function checked(binding) {
+    if (!binding || typeof binding !== 'object' || !binding.files || typeof binding.files.providerId !== 'string')
+        throw new TypeError('A workspace binding needs its provider');
+    if (typeof binding.root !== 'string' || !binding.root.startsWith('/'))
+        throw new TypeError('A workspace binding needs the absolute workspace root');
+    return binding;
+}
+/** The target Pi would pass to `HarnessOptions.env` for this call: its conversation, the agent's `cwd`, committed reads. */
+export async function callTarget(api, context) {
+    const cwd = (await api.agent(context)).cwd;
+    return { conversationId: api.conversationId, ...(cwd === undefined ? {} : { cwd }), read: api };
+}
+/**
+ * Resolve the workspace of a tool call, or the reason it has none: through `resolver` (or one binding), or without either from the env
+ * Pi handed the call (`withWorkspace`).
+ */
+export async function workspaceFor(resolver, api, context) {
+    // The env itself first: a binding attached to a decorated env (`withWorkspace(confinedEnv(raw), binding)`) is its own; otherwise the decoration's source.
+    const own = api.env, base = own === undefined ? undefined : undecorated(own);
+    const binding = resolver === undefined ? workspaceOfEnv(own) ?? workspaceOfEnv(base) : typeof resolver === 'function' ? await resolver(await callTarget(api, context), context) : resolver;
+    if (binding === undefined)
+        return { refused: 'This conversation has no workspace.' };
+    checked(binding);
+    if (binding.env !== undefined && binding.env !== own && binding.env !== base)
+        return { refused: 'The workspace of this conversation was reopened during the call. Try again.' };
+    return { binding };
+}
+/**
+ * The conversation whose workspace a conversation uses: itself, or for a conversation a task owns (a subagent's child), the
+ * conversation of that task, transitively. Read-only; the mapping never changes, so a host may memoise it.
+ */
+export async function rootConversation(session, id, context) {
+    return session.commit(async (tx) => {
+        let current = id;
+        for (let depth = 0; depth < 64; depth++) {
+            const record = await tx.conversation(current);
+            if (record?.owner === undefined)
+                return current;
+            current = record.owner.conversationId;
+        }
+        return current;
+    }, context);
+}
+/**
+ * One open workspace per key, opened on first use and closed when idle. The cache owns what `open` returns: a lease or a call
+ * borrows it, and only the cache closes it (idle, or `close()`), never a viewer that stops looking.
+ */
+export function createWorkspaceCache(options) {
+    const idleMs = options.idleMs ?? 10 * 60_000;
+    if (!(idleMs > 0))
+        throw new TypeError('idleMs must be positive');
+    const entries = new Map();
+    let closed = false;
+    function arm(key, entry) {
+        if (entry.timer !== undefined)
+            clearTimeout(entry.timer);
+        if (!Number.isFinite(idleMs))
+            return;
+        entry.timer = setTimeout(() => { void sweep(key, entry); }, Math.max(0, entry.lastUsed + idleMs - Date.now()));
+        entry.timer.unref?.();
+    }
+    async function sweep(key, entry) {
+        entry.timer = undefined;
+        if (entries.get(key) !== entry || entry.leases > 0)
+            return;
+        if (Date.now() - entry.lastUsed < idleMs)
+            return arm(key, entry);
+        let busy = false;
+        try {
+            busy = (await options.busy?.(key)) === true;
+        }
+        catch {
+            busy = true;
+        }
+        if (entries.get(key) !== entry || entry.leases > 0)
+            return;
+        if (Date.now() - entry.lastUsed < idleMs)
+            return arm(key, entry);
+        if (busy) {
+            entry.lastUsed = Date.now();
+            return arm(key, entry);
+        }
+        await dispose(key, entry);
+    }
+    function dispose(key, entry) {
+        if (entries.get(key) === entry)
+            entries.delete(key);
+        if (entry.timer !== undefined)
+            clearTimeout(entry.timer);
+        entry.closing ??= entry.opening.then(async (workspace) => {
+            await Promise.allSettled(entry.views.values());
+            await workspace.close?.();
+        }, () => undefined).catch(error => { options.onError?.(error, key); });
+        return entry.closing;
+    }
+    async function use(key, context, lease) {
+        if (closed)
+            throw new Error('The workspace cache is closed');
+        let entry = entries.get(key);
+        if (entry === undefined) {
+            const opening = Promise.resolve().then(() => options.open(key, context)).then(workspace => {
+                checked(workspace);
+                if (!workspace.env)
+                    throw new TypeError(`Workspace ${key} has no env`);
+                withWorkspace(workspace.env, workspace);
+                return workspace;
+            });
+            entry = { opening, views: new Map(), leases: 0, lastUsed: Date.now() };
+            entries.set(key, entry);
+            const created = entry;
+            opening.catch(() => { if (entries.get(key) === created)
+                entries.delete(key); });
+        }
+        if (lease)
+            entry.leases++;
+        entry.lastUsed = Date.now();
+        try {
+            const workspace = await entry.opening;
+            if (closed || entries.get(key) !== entry)
+                throw new Error('The workspace was closed during acquisition');
+            if (!lease)
+                arm(key, entry);
+            return { workspace, entry };
+        }
+        catch (error) {
+            if (lease)
+                entry.leases--;
+            throw error;
+        }
+    }
+    const forTarget = async (target, context) => {
+        const key = await options.key(target, context);
+        if (key === undefined)
+            return undefined;
+        const { workspace, entry } = await use(key, context, false);
+        if (closed || entries.get(key) !== entry)
+            throw new Error('The workspace was closed during acquisition');
+        const cwd = target.cwd;
+        if (cwd === undefined || cwd === workspace.env.cwd)
+            return workspace;
+        const atCwd = options.atCwd;
+        if (atCwd === undefined)
+            throw new Error(`Workspace ${key} cannot provide working directory ${cwd}`);
+        let selected = entry.views.get(cwd);
+        if (selected === undefined) {
+            selected = Promise.resolve().then(() => atCwd(workspace, cwd, context)).then(env => {
+                if (env === workspace.env || env.id !== workspace.env.id || env.cwd !== cwd)
+                    throw new Error('A cwd view must be independent and use the same namespace and requested working directory');
+                const binding = { ...workspace, env };
+                withWorkspace(env, binding);
+                return binding;
+            });
+            entry.views.set(cwd, selected);
+            void selected.catch(() => { entry.views.delete(cwd); });
+        }
+        const view = await selected;
+        if (closed || entries.get(key) !== entry)
+            throw new Error('The workspace was closed during cwd acquisition');
+        return view;
+    };
+    return {
+        env: async (target, context) => (await forTarget(target, context))?.env,
+        workspace: forTarget,
+        acquire: async (key, context) => {
+            const { workspace, entry } = await use(key, context, true);
+            let released = false;
+            return { workspace, release: () => {
+                    if (released)
+                        return;
+                    released = true;
+                    entry.leases--;
+                    entry.lastUsed = Date.now();
+                    if (entry.leases === 0 && entries.get(key) === entry)
+                        arm(key, entry);
+                } };
+        },
+        keys: () => [...entries.keys()],
+        close: async () => {
+            closed = true;
+            await Promise.all([...entries].map(([key, entry]) => dispose(key, entry)));
+        },
+    };
+}

package/package.json

@@ -1,166 +1,161 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.1.111",
-  "type": "module",
+  "version": "0.2.0",
   "license": "MIT",
-  "description": "Pane-embeddable coding agent. Ships direct/local/vercel-sandbox execution modes behind one interface.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hachej/boring-ui"
-  },
-  "homepage": "https://github.com/hachej/boring-ui",
+  "private": false,
+  "type": "module",
+  "description": "Native Pi attachment, the read/write/edit guard, durable questions, conditional document delivery and metering.",
+  "sideEffects": false,
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/front/index.d.ts",
-      "import": "./dist/front/index.js"
-    },
-    "./shared": {
-      "types": "./dist/shared/index.d.ts",
-      "import": "./dist/shared/index.js"
-    },
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core/index.js"
-    },
-    "./server": {
-      "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js",
-      "default": "./dist/server/index.js"
-    },
-    "./server/pi-session-readability": {
-      "types": "./dist/server/pi-session-readability.d.ts",
-      "import": "./dist/server/pi-session-readability.js",
-      "default": "./dist/server/pi-session-readability.js"
-    },
-    "./server/agent-host/testing/gatewayConformance": {
-      "types": "./dist/server/agent-host/testing/gatewayConformance.d.ts",
-      "import": "./dist/server/agent-host/testing/gatewayConformance.js",
-      "default": "./dist/server/agent-host/testing/gatewayConformance.js"
-    },
-    "./server/agent-host/testing/compositionRouteProof": {
-      "types": "./dist/server/agent-host/testing/compositionRouteProof.d.ts",
-      "import": "./dist/server/agent-host/testing/compositionRouteProof.js",
-      "default": "./dist/server/agent-host/testing/compositionRouteProof.js"
-    },
-    "./server/worker": {
-      "types": "./dist/server/worker/index.d.ts",
-      "import": "./dist/server/worker/index.js",
-      "default": "./dist/server/worker/index.js"
-    },
-    "./front": {
-      "types": "./dist/front/index.d.ts",
-      "import": "./dist/front/index.js"
-    },
-    "./front/styles.css": "./dist/front/styles.css",
-    "./front/artifacts": {
-      "types": "./dist/front/artifacts.d.ts",
-      "import": "./dist/front/artifacts.js"
-    },
-    "./eval": {
-      "types": "./dist/eval/index.d.ts",
-      "import": "./dist/eval/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./presentation": {
+      "types": "./dist/presentation.d.ts",
+      "import": "./dist/presentation.js"
+    },
+    "./native": {
+      "types": "./dist/native.d.ts",
+      "import": "./dist/native.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts.d.ts",
+      "import": "./dist/contracts.js"
+    },
+    "./definitions": {
+      "types": "./dist/definitions.d.ts",
+      "import": "./dist/definitions.js"
+    },
+    "./file-guard": {
+      "types": "./dist/file-guard.d.ts",
+      "import": "./dist/file-guard.js"
+    },
+    "./workspaces": {
+      "types": "./dist/workspaces.d.ts",
+      "import": "./dist/workspaces.js"
+    },
+    "./harness-pool": {
+      "types": "./dist/harness-pool.d.ts",
+      "import": "./dist/harness-pool.js"
+    },
+    "./artifacts": {
+      "types": "./dist/artifacts.d.ts",
+      "import": "./dist/artifacts.js"
+    },
+    "./file-convert": {
+      "types": "./dist/file-convert.d.ts",
+      "import": "./dist/file-convert.js"
+    },
+    "./file-types": {
+      "types": "./dist/file-types.d.ts",
+      "import": "./dist/file-types.js"
+    },
+    "./ask-user": {
+      "types": "./dist/ask-user.d.ts",
+      "import": "./dist/ask-user.js"
+    },
+    "./browser-task": {
+      "types": "./dist/browser-task.d.ts",
+      "import": "./dist/browser-task.js"
+    },
+    "./questions": {
+      "types": "./dist/questions.d.ts",
+      "import": "./dist/questions.js"
+    },
+    "./delivery": {
+      "types": "./dist/delivery.d.ts",
+      "import": "./dist/delivery.js"
+    },
+    "./question-response": {
+      "types": "./dist/question-response.d.ts",
+      "import": "./dist/question-response.js"
+    },
+    "./projection": {
+      "types": "./dist/projection.d.ts",
+      "import": "./dist/projection.js"
+    },
+    "./agents": {
+      "types": "./dist/agents.d.ts",
+      "import": "./dist/agents.js"
+    },
+    "./chat-transport": {
+      "types": "./dist/chat-transport.d.ts",
+      "import": "./dist/chat-transport.js"
+    },
+    "./conversations": {
+      "types": "./dist/conversations.d.ts",
+      "import": "./dist/conversations.js"
+    },
+    "./mentions": {
+      "types": "./dist/mentions.d.ts",
+      "import": "./dist/mentions.js"
+    },
+    "./validation": {
+      "types": "./dist/validation.d.ts",
+      "import": "./dist/validation.js"
+    },
+    "./git": {
+      "types": "./dist/git.d.ts",
+      "import": "./dist/git.js"
+    },
+    "./approval": {
+      "types": "./dist/approval.d.ts",
+      "import": "./dist/approval.js"
+    },
+    "./memory/optchat": {
+      "types": "./dist/memory/optchat.d.ts",
+      "import": "./dist/memory/optchat.js"
+    },
+    "./model-gateway": {
+      "types": "./dist/model-gateway.d.ts",
+      "import": "./dist/model-gateway.js"
+    },
+    "./gateway-provider": {
+      "types": "./dist/gateway-provider.d.ts",
+      "import": "./dist/gateway-provider.js"
+    },
+    "./metering": {
+      "types": "./dist/metering.d.ts",
+      "import": "./dist/metering.js"
     }
   },
-  "sideEffects": [
-    "**/*.css"
-  ],
-  "files": [
-    "dist",
-    "docs"
-  ],
-  "dependencies": {
-    "@mariozechner/pi-coding-agent": "npm:@earendil-works/pi-coding-agent@0.84.3",
-    "@modelcontextprotocol/sdk": "1.30.0",
-    "@radix-ui/react-use-controllable-state": "^1.2.6",
-    "@streamdown/cjk": "^1.0.3",
-    "@streamdown/code": "^1.1.1",
-    "@streamdown/math": "^1.0.2",
-    "@streamdown/mermaid": "^1.0.2",
-    "ai": "^7.0.68",
-    "clsx": "^2.1.1",
-    "diff": "^9.0.0",
-    "fastify": "^5.12.1",
-    "lucide-react": "^1.31.0",
-    "motion": "^13.1.0",
-    "nanoid": "^6.0.0",
-    "postgres": "^3.4.9",
-    "proper-lockfile": "^4.1.2",
-    "shiki": "^4.4.2",
-    "streamdown": "^2.5.0",
-    "tailwind-merge": "^3.5.0",
-    "use-stick-to-bottom": "^1.1.6",
-    "yaml": "^2.9.0",
-    "zod": "^3.25.76",
-    "@hachej/boring-sandbox": "0.1.111",
-    "@hachej/boring-ui-kit": "0.1.111",
-    "@hachej/boring-bash": "0.1.111"
-  },
-  "devDependencies": {
-    "@vercel/sandbox": "3.0.0",
-    "@antithesishq/bombadil": "0.7.2",
-    "@opentelemetry/api": "^1.9.1",
-    "@tailwindcss/postcss": "^4.3.3",
-    "@types/node": "^22.20.0",
-    "@types/proper-lockfile": "^4.1.4",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.5",
-    "@vitejs/plugin-react": "^4.7.0",
-    "ajv": "^8.20.0",
-    "esbuild": "^0.28.2",
-    "postcss": "^8.5.25",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "tsup": "^8.4.0",
-    "tsx": "^4.23.13",
-    "typescript": "^6.0.3",
-    "vite": "^8.2.1",
-    "@earendil-works/pi-ai": "0.84.3",
-    "vitest": "^4.1.11"
-  },
   "peerDependencies": {
-    "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0",
-    "tailwindcss": ">=3.4.0 || >=4.0.0",
-    "vitest": "^4.1.11"
+    "@earendil-works/pi-durable": "1.1.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/chord": "1.1.0",
+    "@hachej/boring-files": "0.2.0",
+    "@hachej/boring-ui-kit": "0.2.0"
   },
   "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    },
-    "react-dom": {
-      "optional": true
-    },
-    "tailwindcss": {
+    "@hachej/boring-files": {
       "optional": true
     },
-    "vitest": {
+    "@hachej/boring-ui-kit": {
       "optional": true
     }
   },
-  "scripts": {
-    "build": "tsup && pnpm run build:assert",
-    "build:dev": "{ [ -d '../ui/dist' ] || pnpm --filter @hachej/boring-ui-kit build; } && tsup --config tsup.dev.config.ts && node ./scripts/build-front-css.mjs",
-    "build:assert": "node ./scripts/assert-build-artifacts.mjs",
-    "dev": "tsx src/server/dev.ts",
-    "test": "vitest run",
-    "test:e2e": "playwright test -c e2e/playwright.config.ts",
-    "test:chat-baseline": "node ./scripts/run-chat-baseline.mjs",
-    "test:bombadil:chat": "node ./scripts/run-bombadil-chat.mjs",
-    "test:bombadil:chat:nightly": "BOMBADIL_TIME_LIMIT=5m node ./scripts/run-bombadil-chat.mjs",
-    "test:regression": "vitest run src/server/__tests__/system-prompt-size.regression.test.ts",
-    "test:watch": "vitest",
-    "eval": "tsx ./scripts/eval.ts",
-    "eval:provisioning": "tsx ./scripts/eval-provisioning-sdk.mts",
-    "eval:provisioning:agent": "tsx ./scripts/eval-provisioning-agent.mts",
-    "eval:provisioning:agent:vercel": "tsx ./scripts/eval-provisioning-agent-vercel.mts",
-    "check:isolation": "tsx ./scripts/check-agent-isolation.ts",
-    "pi-sdk:canary": "./scripts/pi-sdk-canary.sh",
-    "typecheck": "tsc --noEmit",
-    "lint": "pnpm run typecheck && pnpm run lint:invariants",
-    "lint:invariants": "bash ../../scripts/check-invariants.sh .",
-    "clean": "rm -rf dist .tsbuildinfo",
-    "smoke:vercel-sandbox": "tsx ./scripts/smoke-vercel-sandbox.mts",
-    "smoke:capability-readiness": "tsx ./scripts/smoke-capability-readiness.mts",
-    "smoke:capability-readiness:vercel": "tsx ./scripts/smoke-capability-readiness-vercel.mts"
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hachej/boring-ui.git",
+    "directory": "packages/agent"
+  },
+  "homepage": "https://github.com/hachej/boring-ui#readme",
+  "bugs": {
+    "url": "https://github.com/hachej/boring-ui/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
-}
+}

package/dist/DebugDrawer-JNA43SVR.js

@@ -1,8 +0,0 @@
-import {
-  DebugDrawer
-} from "./chunk-4XOW57KJ.js";
-import "./chunk-2BGLZZ7T.js";
-import "./chunk-YGRQ4Q5P.js";
-export {
-  DebugDrawer
-};