@hachej/boring-agent 0.1.62 → 0.1.64

package/dist/{chunk-G6YPXDHR.js → chunk-UPRDF2PB.js}

@@ -171,7 +171,8 @@ var BoringChatPartSchema = z2.discriminatedUnion("type", [
     filename: z2.string().optional(),
     mediaType: z2.string().optional(),
     url: z2.string().optional(),
-    path: z2.string().optional()
+    path: z2.string().optional(),
+    filesystem: z2.string().optional()
   }),
   z2.object({
     type: z2.literal("notice"),

package/dist/front/index.d.ts

@@ -2,7 +2,7 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ComponentProps, HTMLAttributes, FormEvent, ReactNode, ComponentType } from 'react';
 import { FileUIPart, ChatStatus, UIMessage } from 'ai';
-import { T as ToolUiMetadata, B as BoringChatPart, d as BoringChatMessage, m as PiChatStatus, r as QueuedUserMessage, C as ChatError, P as PiChatEvent, o as PromptPayload, p as PromptReceipt, F as FollowUpPayload, i as FollowUpReceipt, Q as QueueClearPayload, q as QueueClearReceipt, I as InterruptPayload, e as CommandReceipt, S as StopPayload, s as StopReceipt } from '../piChatEvent-B6GDifo2.js';
+import { T as ToolUiMetadata, B as BoringChatPart, d as BoringChatMessage, m as PiChatStatus, r as QueuedUserMessage, C as ChatError, P as PiChatEvent, o as PromptPayload, p as PromptReceipt, F as FollowUpPayload, i as FollowUpReceipt, Q as QueueClearPayload, q as QueueClearReceipt, I as InterruptPayload, e as CommandReceipt, S as StopPayload, s as StopReceipt } from '../piChatEvent-JbwYVBZj.js';
 import { e as SessionSummary } from '../chatSubmitPayload-DHqQL2wD.js';
 import { InputGroupAddon, InputGroupButton, InputGroupTextarea, Button, Collapsible, CollapsibleContent, CollapsibleTrigger } from '@hachej/boring-ui-kit';
 import { Streamdown } from 'streamdown';
@@ -650,7 +650,9 @@ interface PiChatPanelProps<TComposerBlocker extends ComposerBlocker = ComposerBl
         clientNonce: string;
     }) => void;
     onData?: (part: unknown) => void;
-    onOpenArtifact?: (path: string) => void;
+    onOpenArtifact?: (path: string, options?: {
+        filesystem?: string;
+    }) => void;
     composerBlockers?: TComposerBlocker[];
     onComposerStop?: () => void;
     onComposerBlockerAction?: (blocker: TComposerBlocker, action: string) => void;
@@ -677,7 +679,10 @@ interface DebugDrawerProps {
 }
 declare function DebugDrawer({ apiBaseUrl, fetch, sessionId, messages, requestHeaders, storageScope, width, onWidthChange }: DebugDrawerProps): react_jsx_runtime.JSX.Element;
 
-type OpenArtifactHandler = (path: string) => void;
+interface OpenArtifactOptions {
+    filesystem?: string;
+}
+type OpenArtifactHandler = (path: string, options?: OpenArtifactOptions) => void;
 interface ArtifactOpenProviderProps {
     onOpenArtifact?: OpenArtifactHandler;
     children: ReactNode;

package/dist/front/index.js

@@ -13,7 +13,7 @@ import {
   StopReceiptSchema,
   extractToolUiMetadata,
   sanitizeToolUiMetadata
-} from "../chunk-G6YPXDHR.js";
+} from "../chunk-UPRDF2PB.js";
 import {
   DebugDrawer,
   cn,
@@ -1534,7 +1534,7 @@ function toHeaderProps(part) {
     toolName: part.toolName
   };
 }
-function PathLabel({ path }) {
+function PathLabel({ path, filesystem }) {
   const onOpen = useOpenArtifact();
   if (!onOpen) {
     return /* @__PURE__ */ jsx11("span", { className: "font-mono text-[12.5px] text-foreground/85", children: path });
@@ -1542,7 +1542,8 @@ function PathLabel({ path }) {
   const open = (e) => {
     e.preventDefault();
     e.stopPropagation();
-    onOpen(path);
+    if (filesystem) onOpen(path, { filesystem });
+    else onOpen(path);
   };
   const handleKeyDown = (e) => {
     if (e.key === "Enter" || e.key === " ") open(e);
@@ -1603,11 +1604,11 @@ function renderRuntimeNotReady(part) {
 function renderReadinessBlock(part) {
   return renderWorkspaceNotReady(part) ?? renderRuntimeNotReady(part);
 }
-function pathTitle(prefix, path) {
+function pathTitle(prefix, path, filesystem) {
   return /* @__PURE__ */ jsxs10("span", { className: "flex min-w-0 items-center gap-1.5", children: [
     /* @__PURE__ */ jsx11("span", { className: "text-muted-foreground", children: prefix }),
     /* @__PURE__ */ jsx11("span", { className: "text-muted-foreground/40", "aria-hidden": "true", children: "\xB7" }),
-    /* @__PURE__ */ jsx11(PathLabel, { path })
+    /* @__PURE__ */ jsx11(PathLabel, { path, filesystem })
   ] });
 }
 function renderBash2(part) {
@@ -1649,10 +1650,11 @@ function renderRead2(part) {
   const input = asRecord2(part.input);
   const output = asRecord2(part.output);
   const path = typeof input.path === "string" ? input.path : "";
+  const filesystem = typeof input.filesystem === "string" ? input.filesystem : void 0;
   const content = extractTextContent(output);
   const lang = langFromPath(path);
   return /* @__PURE__ */ jsxs10(Tool2, { children: [
-    /* @__PURE__ */ jsx11(ToolHeader, { icon: /* @__PURE__ */ jsx11(FileTextIcon, { className: "size-4 text-muted-foreground" }), title: pathTitle("read", path), ...toHeaderProps(part) }),
+    /* @__PURE__ */ jsx11(ToolHeader, { icon: /* @__PURE__ */ jsx11(FileTextIcon, { className: "size-4 text-muted-foreground" }), title: pathTitle("read", path, filesystem), ...toHeaderProps(part) }),
     /* @__PURE__ */ jsxs10(ToolContent, { children: [
       /* @__PURE__ */ jsx11(ToolInput, { input }),
       content && /* @__PURE__ */ jsxs10("section", { className: "space-y-2", children: [
@@ -1667,11 +1669,12 @@ function renderWrite2(part) {
   if (readiness) return readiness;
   const input = asRecord2(part.input);
   const path = typeof input.path === "string" ? input.path : "";
+  const filesystem = typeof input.filesystem === "string" ? input.filesystem : void 0;
   const content = typeof input.content === "string" ? input.content : "";
   const bytes = content.length;
   const lang = langFromPath(path);
   return /* @__PURE__ */ jsxs10(Tool2, { children: [
-    /* @__PURE__ */ jsx11(ToolHeader, { icon: /* @__PURE__ */ jsx11(FilePlus2Icon, { className: "size-4 text-muted-foreground" }), title: pathTitle("write", path), ...toHeaderProps(part) }),
+    /* @__PURE__ */ jsx11(ToolHeader, { icon: /* @__PURE__ */ jsx11(FilePlus2Icon, { className: "size-4 text-muted-foreground" }), title: pathTitle("write", path, filesystem), ...toHeaderProps(part) }),
     /* @__PURE__ */ jsx11(ToolContent, { children: /* @__PURE__ */ jsxs10(Artifact, { className: "rounded-none border-0 bg-transparent shadow-none", children: [
       /* @__PURE__ */ jsxs10(ArtifactHeader, { className: "border-0 px-0 pt-0 pb-2", children: [
         /* @__PURE__ */ jsxs10("div", { children: [
@@ -1728,10 +1731,11 @@ function renderEdit2(part) {
   if (readiness) return readiness;
   const input = asRecord2(part.input);
   const path = typeof input.path === "string" ? input.path : "";
+  const filesystem = typeof input.filesystem === "string" ? input.filesystem : void 0;
   const oldString = typeof input.oldString === "string" ? input.oldString : "";
   const newString = typeof input.newString === "string" ? input.newString : "";
   return /* @__PURE__ */ jsxs10(Tool2, { children: [
-    /* @__PURE__ */ jsx11(ToolHeader, { icon: /* @__PURE__ */ jsx11(FileDiffIcon, { className: "size-4 text-muted-foreground" }), title: pathTitle("edit", path), ...toHeaderProps(part) }),
+    /* @__PURE__ */ jsx11(ToolHeader, { icon: /* @__PURE__ */ jsx11(FileDiffIcon, { className: "size-4 text-muted-foreground" }), title: pathTitle("edit", path, filesystem), ...toHeaderProps(part) }),
     /* @__PURE__ */ jsxs10(ToolContent, { children: [
       /* @__PURE__ */ jsxs10("section", { className: "space-y-2", children: [
         /* @__PURE__ */ jsx11("h4", { className: "font-medium text-muted-foreground text-xs uppercase tracking-wide", children: "Diff" }),
@@ -7046,7 +7050,8 @@ function PiTimelineMessage({ message, isLast, isStreaming, showThoughts, toolRen
                     const canOpen = Boolean(openArtifact && openPath);
                     const openAttachment = () => {
                       if (!openPath) return;
-                      openArtifact?.(openPath);
+                      if (file.filesystem) openArtifact?.(openPath, { filesystem: file.filesystem });
+                      else openArtifact?.(openPath);
                     };
                     const openAttachmentFromKeyboard = (event) => {
                       if (event.key !== "Enter" && event.key !== " ") return;

package/dist/front/styles.css

@@ -2806,6 +2806,8 @@
 @layer theme, utilities;
 @layer theme {
   :root, :host {
+    --font-sans: var(--boring-font-sans);
+    --font-mono: var(--boring-font-mono);
     --color-black: #000;
     --spacing: 0.25rem;
     --container-xs: 20rem;

package/dist/{piChatEvent-B6GDifo2.d.ts → piChatEvent-JbwYVBZj.d.ts}

@@ -112,6 +112,7 @@ type BoringChatPart = {
     mediaType?: string;
     url?: string;
     path?: string;
+    filesystem?: string;
 } | {
     type: 'notice';
     id?: string;

package/dist/server/index.d.ts

@@ -444,6 +444,91 @@ interface ModeContext {
     requestId?: string;
     telemetry?: TelemetrySink;
 }
+interface RuntimeFilesystemBindingOperations {
+    read(descriptor: {
+        filesystem: string;
+        path: string;
+    }): Promise<{
+        content: string;
+        metadata?: unknown;
+    }>;
+    list(descriptor: {
+        filesystem: string;
+        path: string;
+    }): Promise<{
+        entries: string[];
+        metadata?: unknown;
+    }>;
+    find(descriptor: {
+        filesystem: string;
+        path: string;
+    }, pattern: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        paths: string[];
+        metadata?: unknown;
+    }>;
+    grep(descriptor: {
+        filesystem: string;
+        path: string;
+    }, pattern: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        matches: Array<{
+            path: string;
+            line: number;
+            text: string;
+        }>;
+        metadata?: unknown;
+    }>;
+    stat(descriptor: {
+        filesystem: string;
+        path: string;
+    }): Promise<{
+        isDirectory: boolean;
+        metadata?: unknown;
+    }>;
+    write?(descriptor: {
+        filesystem: string;
+        path: string;
+        content: string;
+        expectedMtimeMs?: number;
+    }): Promise<{
+        mtimeMs?: number;
+        metadata?: unknown;
+    }>;
+    delete?(descriptor: {
+        filesystem: string;
+        path: string;
+    }): Promise<{
+        metadata?: unknown;
+    }>;
+    move?(descriptor: {
+        filesystem: string;
+        from: string;
+        to: string;
+    }): Promise<{
+        metadata?: unknown;
+    }>;
+    mkdir?(descriptor: {
+        filesystem: string;
+        path: string;
+        recursive?: boolean;
+    }): Promise<{
+        metadata?: unknown;
+    }>;
+    rejectMutation(operation: string, descriptor: {
+        filesystem: string;
+        path: string;
+    }): never;
+}
+interface RuntimeFilesystemBinding {
+    readonly filesystem: string;
+    readonly access: 'readonly' | 'readwrite';
+    readonly operations: RuntimeFilesystemBindingOperations;
+}
 interface RuntimeBundle {
     runtimeContext?: WorkspaceRuntimeContext;
     /**
@@ -461,6 +546,8 @@ interface RuntimeBundle {
     bash?: RuntimeBashStrategy;
     /** Runtime-owned filesystem strategy, consumed by the agent filesystem tool builder. */
     filesystem?: RuntimeFilesystemStrategy;
+    /** Optional filesystem bindings prepared for this runtime/session. */
+    filesystemBindings?: RuntimeFilesystemBinding[];
 }
 
 declare const REMOTE_WORKER_RUNTIME_CWD = "/workspace";
@@ -608,6 +695,8 @@ declare function createRemoteWorkerSandbox(client: RemoteWorkerClient): Sandbox;
 declare function fileRoutes(app: FastifyInstance, opts: {
     workspace?: Workspace;
     getWorkspace?: (request: FastifyRequest) => Workspace | Promise<Workspace>;
+    filesystemBindings?: RuntimeFilesystemBinding[];
+    getFilesystemBindings?: (request: FastifyRequest) => RuntimeFilesystemBinding[] | undefined | Promise<RuntimeFilesystemBinding[] | undefined>;
 }, done: (err?: Error) => void): void;
 
 interface RuntimeTemplateContribution {
@@ -964,6 +1053,7 @@ interface RegisterAgentRoutesOptions {
         workspaceRoot: string;
         runtimeMode: RuntimeModeId;
         workspaceFsCapability?: Workspace['fsCapability'];
+        authSubject?: string;
     }) => AgentTool[] | Promise<AgentTool[]>;
     systemPromptAppend?: string;
     /** Optional dynamic system-prompt source forwarded to the harness. */

package/dist/server/index.js

@@ -13,7 +13,7 @@ import {
   StopPayloadSchema,
   extractToolUiMetadata,
   sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "../chunk-G6YPXDHR.js";
+} from "../chunk-UPRDF2PB.js";
 
 // src/server/sandbox/direct/createDirectSandbox.ts
 import { spawn } from "child_process";
@@ -2656,6 +2656,9 @@ var BORING_SETTINGS_PATH = ".boring/settings";
 var DEFAULT_MARKDOWN_IMAGE_UPLOAD_DIR = "assets/images";
 var DEFAULT_FILE_UPLOAD_DIR = "assets/uploads";
 var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
+var USER_FILESYSTEM_ID = "user";
+var ERROR_CODE_NOT_FOUND_OR_DENIED = "not_found_or_denied";
+var ERROR_CODE_READONLY = "readonly";
 var IMAGE_UPLOAD_EXTENSIONS = /* @__PURE__ */ new Set(["avif", "gif", "jpg", "jpeg", "png", "webp"]);
 var SAFE_UNKNOWN_FILE_EXTENSIONS = /* @__PURE__ */ new Set(["csv", "doc", "docx", "json", "md", "pdf", "ppt", "pptx", "rtf", "txt", "xls", "xlsx", "zip"]);
 var MIME_UPLOAD_EXTENSIONS = {
@@ -2723,6 +2726,14 @@ function classifyError(err, reply, subject) {
     error: { code: ERROR_CODE_INTERNAL, message }
   });
 }
+function requestedFilesystem(value) {
+  return typeof value === "string" && value.length > 0 ? value : USER_FILESYSTEM_ID;
+}
+function sendNotFoundOrDenied(reply) {
+  return reply.code(404).send({
+    error: { code: ERROR_CODE_NOT_FOUND_OR_DENIED, message: "not found or denied" }
+  });
+}
 function requireStringParam(value, field, reply) {
   if (typeof value !== "string" || value.length === 0) {
     reply.code(400).send({
@@ -2842,16 +2853,41 @@ function sendValidationError(reply, message, field) {
     error: { code: ERROR_CODE_VALIDATION_ERROR, message, ...field ? { field } : {} }
   });
 }
+function sendFilesystemBindingMutationDenied(reply, filesystem, access5) {
+  return reply.code(403).send({
+    error: { code: ERROR_CODE_READONLY, message: `${filesystem} binding is ${access5}` }
+  });
+}
 function fileRoutes(app, opts, done) {
   async function resolveWorkspace(request) {
     if (opts.getWorkspace) return await opts.getWorkspace(request);
     if (opts.workspace) return opts.workspace;
     throw new Error("file route requires workspace or getWorkspace");
   }
+  async function resolveFilesystemBindings(request) {
+    if (opts.getFilesystemBindings) return await opts.getFilesystemBindings(request) ?? [];
+    if (opts.filesystemBindings) return opts.filesystemBindings;
+    return [];
+  }
+  async function resolveFilesystemBinding(request, filesystem) {
+    return (await resolveFilesystemBindings(request)).find((binding) => binding.filesystem === filesystem);
+  }
   app.get("/api/v1/files/raw", async (request, reply) => {
     const query = request.query;
     const path4 = requireStringParam(query.path, "path", reply);
     if (path4 === null) return;
+    const filesystem = requestedFilesystem(query.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        const result = await binding.operations.read({ filesystem, path: path4 });
+        const bytes = Buffer.from(result.content, "utf8");
+        return reply.header("content-type", contentTypeForPath(path4)).header("content-length", String(bytes.byteLength)).header("cache-control", "no-store").header("x-content-type-options", "nosniff").send(bytes);
+      } catch {
+        return sendNotFoundOrDenied(reply);
+      }
+    }
     try {
       const workspace = await resolveWorkspace(request);
       if (!workspace.readBinaryFile) {
@@ -2905,6 +2941,17 @@ function fileRoutes(app, opts, done) {
     const query = request.query;
     const path4 = requireStringParam(query.path, "path", reply);
     if (path4 === null) return;
+    const filesystem = requestedFilesystem(query.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        const result = await binding.operations.read({ filesystem, path: path4 });
+        return { content: result.content, access: binding.access };
+      } catch {
+        return sendNotFoundOrDenied(reply);
+      }
+    }
     try {
       if (isReadonlySkillFilePath(path4)) {
         const { content: content2, stat: stat13 } = await readReadonlySkillFile(path4);
@@ -2918,11 +2965,11 @@ function fileRoutes(app, opts, done) {
       const workspace = await resolveWorkspace(request);
       if (workspace.readFileWithStat) {
         const { content: content2, stat: stat13 } = await workspace.readFileWithStat(path4);
-        return { content: content2, mtimeMs: stat13.kind === "file" ? stat13.mtimeMs : void 0 };
+        return { content: content2, mtimeMs: stat13.kind === "file" ? stat13.mtimeMs : void 0, access: "readwrite" };
       }
       const content = await workspace.readFile(path4);
       const stat12 = await workspace.stat(path4);
-      return { content, mtimeMs: stat12.kind === "file" ? stat12.mtimeMs : void 0 };
+      return { content, mtimeMs: stat12.kind === "file" ? stat12.mtimeMs : void 0, access: "readwrite" };
     } catch (err) {
       return classifyError(err, reply, "file");
     }
@@ -2936,8 +2983,28 @@ function fileRoutes(app, opts, done) {
         error: { code: ERROR_CODE_VALIDATION_ERROR, message: "content is required", field: "content" }
       });
     }
+    const filesystem = requestedFilesystem(body.filesystem);
     const expectedMtimeMs = typeof body.expectedMtimeMs === "number" ? body.expectedMtimeMs : null;
     const shouldReturnMtimeMs = body.returnMtimeMs !== false || expectedMtimeMs !== null;
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        if (binding.access !== "readwrite") return sendFilesystemBindingMutationDenied(reply, filesystem, binding.access);
+        if (!binding.operations.write) {
+          return reply.code(501).send({ error: { code: ERROR_CODE_INTERNAL, message: `${filesystem} write operation is unavailable` } });
+        }
+        const result = await binding.operations.write({
+          filesystem,
+          path: path4,
+          content: body.content,
+          ...expectedMtimeMs !== null ? { expectedMtimeMs } : {}
+        });
+        return shouldReturnMtimeMs ? { ok: true, mtimeMs: result.mtimeMs } : { ok: true };
+      } catch (err) {
+        return classifyError(err, reply, "file");
+      }
+    }
     try {
       const workspace = await resolveWorkspace(request);
       if (expectedMtimeMs !== null) {
@@ -3069,6 +3136,21 @@ function fileRoutes(app, opts, done) {
     const query = request.query;
     const path4 = requireStringParam(query.path, "path", reply);
     if (path4 === null) return;
+    const filesystem = requestedFilesystem(query.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        if (binding.access !== "readwrite") return sendFilesystemBindingMutationDenied(reply, filesystem, binding.access);
+        if (!binding.operations.delete) {
+          return reply.code(501).send({ error: { code: ERROR_CODE_INTERNAL, message: `${filesystem} delete operation is unavailable` } });
+        }
+        await binding.operations.delete({ filesystem, path: path4 });
+        return { ok: true };
+      } catch (err) {
+        return classifyError(err, reply, "file");
+      }
+    }
     try {
       const workspace = await resolveWorkspace(request);
       await workspace.unlink(path4);
@@ -3083,6 +3165,21 @@ function fileRoutes(app, opts, done) {
     if (from === null) return;
     const to = requireStringParam(body?.to, "to", reply);
     if (to === null) return;
+    const filesystem = requestedFilesystem(body.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        if (binding.access !== "readwrite") return sendFilesystemBindingMutationDenied(reply, filesystem, binding.access);
+        if (!binding.operations.move) {
+          return reply.code(501).send({ error: { code: ERROR_CODE_INTERNAL, message: `${filesystem} move operation is unavailable` } });
+        }
+        await binding.operations.move({ filesystem, from, to });
+        return { ok: true };
+      } catch (err) {
+        return classifyError(err, reply, "file");
+      }
+    }
     try {
       const workspace = await resolveWorkspace(request);
       await workspace.rename(from, to);
@@ -3096,6 +3193,21 @@ function fileRoutes(app, opts, done) {
     const path4 = requireStringParam(body?.path, "path", reply);
     if (path4 === null) return;
     const recursive = body.recursive === true;
+    const filesystem = requestedFilesystem(body.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        if (binding.access !== "readwrite") return sendFilesystemBindingMutationDenied(reply, filesystem, binding.access);
+        if (!binding.operations.mkdir) {
+          return reply.code(501).send({ error: { code: ERROR_CODE_INTERNAL, message: `${filesystem} mkdir operation is unavailable` } });
+        }
+        await binding.operations.mkdir({ filesystem, path: path4, recursive });
+        return { ok: true };
+      } catch (err) {
+        return classifyError(err, reply, "directory");
+      }
+    }
     try {
       const workspace = await resolveWorkspace(request);
       await workspace.mkdir(path4, { recursive });
@@ -3108,6 +3220,17 @@ function fileRoutes(app, opts, done) {
     const query = request.query;
     const path4 = requireStringParam(query.path, "path", reply);
     if (path4 === null) return;
+    const filesystem = requestedFilesystem(query.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) {
+      try {
+        const binding = await resolveFilesystemBinding(request, filesystem);
+        if (!binding) return sendNotFoundOrDenied(reply);
+        const result = await binding.operations.stat({ filesystem, path: path4 });
+        return result.isDirectory ? { kind: "dir" } : { kind: "file", size: 0 };
+      } catch {
+        return sendNotFoundOrDenied(reply);
+      }
+    }
     try {
       if (isReadonlySkillFilePath(path4)) {
         return await statReadonlySkillFile(path4);
@@ -8327,17 +8450,135 @@ function buildRemoteWorkspaceFilesystemAgentTools(bundle, pathOptions) {
 function isTextContent2(content) {
   return content.type === "text" && typeof content.text === "string";
 }
+function filesystemBindings(bundle) {
+  return bundle.filesystemBindings ?? [];
+}
+function filesystemIds(bundle) {
+  return filesystemBindings(bundle).map((binding) => binding.filesystem);
+}
+function withFilesystemParameter(parameters, filesystemIds2) {
+  const schema = parameters && typeof parameters === "object" ? { ...parameters } : { type: "object" };
+  const properties = schema.properties && typeof schema.properties === "object" ? { ...schema.properties } : {};
+  return {
+    ...schema,
+    properties: {
+      ...properties,
+      filesystem: {
+        type: "string",
+        description: filesystemIds2.length > 0 ? "Logical filesystem to use. Omit or use user for workspace files; use an advertised named filesystem for bound readonly context." : "Logical filesystem to use. Omit or use user for workspace files.",
+        enum: ["user", ...filesystemIds2]
+      }
+    }
+  };
+}
+function requestedFilesystem2(params) {
+  const value = params.filesystem;
+  return typeof value === "string" && value.length > 0 ? value : "user";
+}
+function withoutFilesystem(params) {
+  const { filesystem: _filesystem, ...rest } = params;
+  return rest;
+}
+function boundFilesystemPath(params) {
+  const value = params.path;
+  return typeof value === "string" && value.length > 0 ? value : "/";
+}
+function assertNotFilesystemPathSpoof(path4, filesystemIds2) {
+  const normalized = path4.replace(/\\/g, "/");
+  if (normalized.includes(":/") || filesystemIds2.some((filesystem) => normalized === `/${filesystem}` || normalized.startsWith(`/${filesystem}/`))) {
+    throw new Error("filesystem prefixes are not valid path strings; use the filesystem parameter");
+  }
+}
+function filesystemBinding(bundle, filesystem) {
+  return filesystemBindings(bundle).find((binding) => binding.filesystem === filesystem);
+}
+function boundOperations(bundle, filesystem) {
+  const binding = filesystemBinding(bundle, filesystem);
+  if (!binding) throw new Error(`No filesystem binding is available for ${filesystem}`);
+  return binding.operations;
+}
+function formatBoundRead(content) {
+  return { content: [{ type: "text", text: content }] };
+}
+function formatBoundList(entries) {
+  return { content: [{ type: "text", text: entries.join("\n") }] };
+}
+function formatBoundFind(paths) {
+  return { content: [{ type: "text", text: paths.join("\n") }] };
+}
+function formatBoundGrep(matches) {
+  return { content: [{ type: "text", text: matches.map((match) => `${match.path}:${match.line}:${match.text}`).join("\n") }] };
+}
+async function executeBoundFilesystemTool(toolName, filesystem, params, bundle) {
+  const path4 = boundFilesystemPath(params);
+  assertNotFilesystemPathSpoof(path4, filesystemIds(bundle));
+  const operations = boundOperations(bundle, filesystem);
+  if (toolName === "read") {
+    const result = await operations.read({ filesystem, path: path4 });
+    return { ...formatBoundRead(result.content), details: { metadata: result.metadata } };
+  }
+  if (toolName === "ls") {
+    const result = await operations.list({ filesystem, path: path4 });
+    return { ...formatBoundList(result.entries), details: { metadata: result.metadata } };
+  }
+  if (toolName === "find") {
+    const pattern = typeof params.pattern === "string" ? params.pattern : "*";
+    const limit = typeof params.limit === "number" ? params.limit : void 0;
+    const result = await operations.find({ filesystem, path: path4 }, pattern, { limit });
+    return { ...formatBoundFind(result.paths), details: { metadata: result.metadata } };
+  }
+  if (toolName === "grep") {
+    const pattern = typeof params.pattern === "string" ? params.pattern : "";
+    const limit = typeof params.limit === "number" ? params.limit : void 0;
+    const result = await operations.grep({ filesystem, path: path4 }, pattern, { limit });
+    return { ...formatBoundGrep(result.matches), details: { metadata: result.metadata } };
+  }
+  if (toolName === "write" || toolName === "edit") {
+    operations.rejectMutation(toolName, { filesystem, path: path4 });
+  }
+  throw new Error(`Tool ${toolName} does not support filesystem ${filesystem}`);
+}
+function withBoundFilesystemPromptGuidance(promptSnippet, filesystemIds2) {
+  if (filesystemIds2.length === 0) return promptSnippet;
+  const guidance = [
+    "Named filesystem bindings: file tools default to the user workspace when filesystem is omitted.",
+    `Use the filesystem parameter explicitly for bound readonly context (${filesystemIds2.join(", ")}), and start browsing at / unless told otherwise.`,
+    "Readonly filesystem bindings reject writes; do not use path prefixes like filesystem:/x to switch filesystem."
+  ].join("\n");
+  return [promptSnippet, guidance].filter(Boolean).join("\n");
+}
+function withFilesystemRouting(tool, bundle) {
+  const ids = filesystemIds(bundle);
+  return {
+    ...tool,
+    promptSnippet: withBoundFilesystemPromptGuidance(tool.promptSnippet, ids),
+    parameters: withFilesystemParameter(tool.parameters, ids),
+    async execute(params, ctx) {
+      const filesystem = requestedFilesystem2(params);
+      if (filesystem !== "user") {
+        const result = await executeBoundFilesystemTool(tool.name, filesystem, params, bundle);
+        const textContent = (result.content ?? []).filter(isTextContent2).map((c) => ({ type: "text", text: c.text }));
+        return {
+          content: textContent.length > 0 ? textContent : [{ type: "text", text: "" }],
+          isError: false,
+          details: result.details
+        };
+      }
+      return await tool.execute(withoutFilesystem(params), ctx);
+    }
+  };
+}
 function adaptPiTool2(piTool) {
   return {
     name: piTool.name,
     readinessRequirements: ["workspace-fs"],
     description: piTool.description,
     promptSnippet: piTool.promptSnippet,
-    parameters: piTool.parameters,
+    parameters: piTool.parameters && typeof piTool.parameters === "object" ? { ...piTool.parameters } : { type: "object" },
     async execute(params, ctx) {
       const result = await piTool.execute(
         ctx.toolCallId,
-        params,
+        withoutFilesystem(params),
         ctx.abortSignal,
         ctx.onUpdate ? (update) => {
           const text = update.content?.filter(isTextContent2).map((c) => c.text).join("");
@@ -8361,7 +8602,7 @@ function buildFilesystemAgentTools(bundle) {
   const cwd = bundle.workspace.root;
   const strategy = bundle.filesystem ?? defaultFilesystemStrategyForBundle(bundle);
   if (strategy.kind === "remote-workspace") {
-    return buildRemoteWorkspaceFilesystemAgentTools(bundle, strategy.pathOptions);
+    return buildRemoteWorkspaceFilesystemAgentTools(bundle, strategy.pathOptions).map((tool) => withFilesystemRouting(tool, bundle));
   }
   const storageRoot = getRuntimeBundleStorageRoot(bundle);
   const ops = boundFs(storageRoot, { runtimeRoot: cwd });
@@ -8372,7 +8613,7 @@ function buildFilesystemAgentTools(bundle) {
     adaptPiTool2(createFindToolDefinition2(cwd, { operations: ops.find })),
     adaptPiTool2(createGrepToolDefinition2(cwd, { operations: ops.grep })),
     adaptPiTool2(createLsToolDefinition2(cwd, { operations: ops.ls }))
-  ];
+  ].map((tool) => withFilesystemRouting(tool, bundle));
 }
 
 // src/server/tools/harness/index.ts
@@ -9009,6 +9250,14 @@ function joinPath2(base, name) {
   if (base === ".") return name;
   return `${base}/${name}`;
 }
+function requestedFilesystem3(value) {
+  return typeof value === "string" && value.length > 0 ? value : "user";
+}
+function sendNotFoundOrDenied2(reply) {
+  return reply.code(404).send({
+    error: { code: ERROR_CODE_NOT_FOUND_OR_DENIED, message: "not found or denied" }
+  });
+}
 async function listTree(workspace, dir, recursive) {
   const entries = [];
   const initialEntries = await workspace.readdir(dir);
@@ -9033,12 +9282,44 @@ async function listTree(workspace, dir, recursive) {
   }
   return entries;
 }
+async function listBoundTree(binding, dir, recursive) {
+  const root = dir === "." ? "/" : dir;
+  const displayParentDir = dir === "." || dir === "/" ? "." : dir.replace(/\/+$/, "");
+  const entries = [];
+  const rootEntries = await binding.operations.list({ filesystem: binding.filesystem, path: root });
+  const queue = [
+    { parentDir: displayParentDir || ".", items: rootEntries.entries, depth: 0 }
+  ];
+  while (queue.length > 0) {
+    if (entries.length >= MAX_ENTRIES) break;
+    const batch = queue.shift();
+    for (const name of batch.items) {
+      if (entries.length >= MAX_ENTRIES) break;
+      const entryPath = joinPath2(batch.parentDir, name);
+      const stat12 = await binding.operations.stat({ filesystem: binding.filesystem, path: entryPath });
+      const kind = stat12.isDirectory ? "dir" : "file";
+      entries.push({ name, kind, path: entryPath });
+      if (recursive && kind === "dir" && batch.depth < MAX_DEPTH && !isIgnoredDirName(name)) {
+        try {
+          const childEntries = await binding.operations.list({ filesystem: binding.filesystem, path: entryPath });
+          queue.push({ parentDir: entryPath, items: childEntries.entries, depth: batch.depth + 1 });
+        } catch {
+        }
+      }
+    }
+  }
+  return entries;
+}
 function treeRoutes(app, opts, done) {
   async function resolveWorkspace(request) {
     if (opts.getWorkspace) return await opts.getWorkspace(request);
     if (opts.workspace) return opts.workspace;
     throw new Error("workspace route requires workspace or getWorkspace");
   }
+  async function resolveFilesystemBinding(request, filesystem) {
+    const bindings = opts.getFilesystemBindings ? await opts.getFilesystemBindings(request) ?? [] : opts.filesystemBindings ?? [];
+    return bindings.find((binding) => binding.filesystem === filesystem);
+  }
   app.get(
     "/api/v1/tree",
     async (request, reply) => {
@@ -9054,6 +9335,16 @@ function treeRoutes(app, opts, done) {
         throw err;
       }
       const recursive = request.query.recursive === "true";
+      const filesystem = requestedFilesystem3(request.query.filesystem);
+      if (filesystem !== "user") {
+        try {
+          const binding = await resolveFilesystemBinding(request, filesystem);
+          if (!binding) return sendNotFoundOrDenied2(reply);
+          return { entries: await listBoundTree(binding, dir, recursive) };
+        } catch {
+          return sendNotFoundOrDenied2(reply);
+        }
+      }
       try {
         const workspace = await resolveWorkspace(request);
         const entries = await listTree(workspace, dir, recursive);
@@ -12321,7 +12612,7 @@ async function createAgentApp(opts = {}) {
   });
   await app.register(fileRoutes, { workspace: runtimeBundle.workspace });
   await app.register(fsEventsRoutes, { workspace: runtimeBundle.workspace });
-  await app.register(treeRoutes, { workspace: runtimeBundle.workspace });
+  await app.register(treeRoutes, { workspace: runtimeBundle.workspace, filesystemBindings: runtimeBundle.filesystemBindings });
   await app.register(searchRoutes, { fileSearch: runtimeBundle.fileSearch });
   await app.register(gitRoutes, {
     getWorkspaceRoot: () => getOptionalRuntimeBundleStorageRoot(runtimeBundle)
@@ -12579,6 +12870,12 @@ function normalizeSessionNamespace(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function getRequestAuthSubject(request) {
+  const userId = request?.user?.id;
+  if (typeof userId === "string" && userId.trim()) return userId.trim();
+  const authSubject = request?.workspaceContext?.authSubject;
+  return typeof authSubject === "string" && authSubject.trim() ? authSubject.trim() : void 0;
+}
 function createHttpError(code, message, details = {}) {
   const error = new Error(message);
   error.code = code;
@@ -12637,7 +12934,7 @@ var registerAgentRoutes = async (app, opts) => {
   app.addHook("onClose", async () => {
     await modeAdapter.dispose?.();
   });
-  const requestScopedRuntime = typeof opts.getWorkspaceId === "function" || typeof opts.getWorkspaceRoot === "function" || typeof opts.getTemplatePath === "function" || typeof opts.getPi === "function" || typeof opts.getSessionNamespace === "function" || typeof opts.getSystemPromptDynamic === "function";
+  const requestScopedRuntime = typeof opts.getWorkspaceId === "function" || typeof opts.getWorkspaceRoot === "function" || typeof opts.getTemplatePath === "function" || typeof opts.getPi === "function" || typeof opts.getExtraTools === "function" || typeof opts.getSessionNamespace === "function" || typeof opts.getSystemPromptDynamic === "function";
   const sessionChangesTracker = new InMemorySessionChangesTracker();
   const externalPluginsEnabled = opts.externalPlugins !== false;
   const runtimeBindings = /* @__PURE__ */ new Map();
@@ -12657,6 +12954,7 @@ var registerAgentRoutes = async (app, opts) => {
     const scopedTemplatePath = opts.getTemplatePath ? await opts.getTemplatePath({ workspaceId, workspaceRoot: root, request }) : templatePath;
     const pi = await resolveScopePi(workspaceId, root, request);
     const sessionNamespace = normalizeSessionNamespace(opts.getSessionNamespace ? await opts.getSessionNamespace({ workspaceId, workspaceRoot: root, request }) : opts.sessionNamespace);
+    const extraToolsAuthSubject = opts.getExtraTools ? getRequestAuthSubject(request) : void 0;
     return {
       root,
       templatePath: scopedTemplatePath,
@@ -12668,7 +12966,8 @@ var registerAgentRoutes = async (app, opts) => {
         root,
         scopedTemplatePath ?? null,
         pi,
-        sessionNamespace ?? null
+        sessionNamespace ?? null,
+        extraToolsAuthSubject ?? null
       ])
     };
   }
@@ -12852,7 +13151,8 @@ var registerAgentRoutes = async (app, opts) => {
       workspaceId,
       workspaceRoot: root,
       runtimeMode: resolvedMode,
-      workspaceFsCapability: runtimeBundle.workspace.fsCapability
+      workspaceFsCapability: runtimeBundle.workspace.fsCapability,
+      authSubject: getRequestAuthSubject(request)
     }) : [];
     const tools = mergeTools({
       standardTools,
@@ -12944,7 +13244,8 @@ var registerAgentRoutes = async (app, opts) => {
         return await ensureRuntimeBindingReady(
           workspaceId,
           scope,
-          await existing.promise
+          await existing.promise,
+          request
         );
       }
     }
@@ -12958,17 +13259,18 @@ var registerAgentRoutes = async (app, opts) => {
       return await ensureRuntimeBindingReady(
         workspaceId,
         scope,
-        await created.promise
+        await created.promise,
+        request
       );
     } catch (error) {
       if (runtimeBindings.get(scope.key) === created) runtimeBindings.delete(scope.key);
       throw error;
     }
   }
-  async function recreateRuntimeBinding(workspaceId, scope) {
+  async function recreateRuntimeBinding(workspaceId, scope, request) {
     runtimeBindings.delete(scope.key);
     modeAdapter.evictCachedRuntime?.({ workspaceId });
-    const created = createRuntimeBindingEntry(workspaceId, scope);
+    const created = createRuntimeBindingEntry(workspaceId, scope, request);
     runtimeBindings.set(scope.key, created);
     evictRuntimeBindings();
     try {
@@ -12980,7 +13282,7 @@ var registerAgentRoutes = async (app, opts) => {
       throw error;
     }
   }
-  async function ensureRuntimeBindingReady(workspaceId, scope, binding) {
+  async function ensureRuntimeBindingReady(workspaceId, scope, binding, request) {
     const healthCheck = modeAdapter.cachedBindingHealthCheck;
     if (!healthCheck) return binding;
     const now = Date.now();
@@ -12997,7 +13299,7 @@ var registerAgentRoutes = async (app, opts) => {
       err: result.error,
       workspaceId
     }, result.message ?? "[runtime] cached runtime invalid; recreating");
-    return await recreateRuntimeBinding(workspaceId, scope);
+    return await recreateRuntimeBinding(workspaceId, scope, request);
   }
   const hasRuntimeProvisioningInput = opts.provisionWorkspace !== false && Boolean(opts.provisionRuntime);
   const staticBinding = requestScopedRuntime ? null : await getOrCreateRuntimeBinding(sessionId);
@@ -13090,7 +13392,8 @@ var registerAgentRoutes = async (app, opts) => {
     getWorkspace: async (request) => (await getBindingForRequest(request)).runtimeBundle.workspace
   });
   await app.register(treeRoutes, {
-    getWorkspace: async (request) => (await getBindingForRequest(request)).runtimeBundle.workspace
+    getWorkspace: async (request) => (await getBindingForRequest(request)).runtimeBundle.workspace,
+    getFilesystemBindings: async (request) => (await getBindingForRequest(request)).runtimeBundle.filesystemBindings
   });
   await app.register(searchRoutes, {
     getFileSearch: async (request) => (await getBindingForRequest(request)).runtimeBundle.fileSearch

package/dist/shared/index.d.ts

@@ -1,7 +1,7 @@
 import { W as Workspace, S as Sandbox, F as FileSearch, A as AgentTool } from '../agentPluginEvents-Ddn5DQ5E.js';
 export { a as AgentHarness, C as CommandNotifyPayload, E as Entry, b as ExecOptions, c as ExecResult, I as IsolatedCodeInput, d as IsolatedCodeOutput, J as JSONSchema, R as RunContext, e as SandboxCapability, f as SandboxHandleRecord, g as SandboxHandleStore, h as SendMessageInput, i as Stat, T as TelemetryEvent, j as TelemetrySink, k as ToolExecContext, l as ToolResult, m as WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT, n as WORKSPACE_COMMAND_NOTIFY_EVENT, o as WorkspaceRuntimeContext, p as noopTelemetry, s as safeCapture } from '../agentPluginEvents-Ddn5DQ5E.js';
-import { B as BoringChatPart, T as ToolUiMetadata } from '../piChatEvent-B6GDifo2.js';
-export { A as ApiErrorPayload, a as ApiErrorPayloadSchema, b as ApiErrorResponse, c as ApiErrorResponseSchema, d as BoringChatMessage, C as ChatError, e as CommandReceipt, E as ERROR_CODES, f as ErrorCode, g as ErrorLogFields, h as ErrorLogFieldsSchema, F as FollowUpPayload, i as FollowUpReceipt, I as InterruptPayload, j as InterruptReceipt, P as PiChatEvent, k as PiChatHeartbeatFrame, l as PiChatSnapshot, m as PiChatStatus, n as PiChatStreamFrame, o as PromptPayload, p as PromptReceipt, Q as QueueClearPayload, q as QueueClearReceipt, r as QueuedUserMessage, S as StopPayload, s as StopReceipt, t as extractToolUiMetadata, u as isToolUiMetadata } from '../piChatEvent-B6GDifo2.js';
+import { B as BoringChatPart, T as ToolUiMetadata } from '../piChatEvent-JbwYVBZj.js';
+export { A as ApiErrorPayload, a as ApiErrorPayloadSchema, b as ApiErrorResponse, c as ApiErrorResponseSchema, d as BoringChatMessage, C as ChatError, e as CommandReceipt, E as ERROR_CODES, f as ErrorCode, g as ErrorLogFields, h as ErrorLogFieldsSchema, F as FollowUpPayload, i as FollowUpReceipt, I as InterruptPayload, j as InterruptReceipt, P as PiChatEvent, k as PiChatHeartbeatFrame, l as PiChatSnapshot, m as PiChatStatus, n as PiChatStreamFrame, o as PromptPayload, p as PromptReceipt, Q as QueueClearPayload, q as QueueClearReceipt, r as QueuedUserMessage, S as StopPayload, s as StopReceipt, t as extractToolUiMetadata, u as isToolUiMetadata } from '../piChatEvent-JbwYVBZj.js';
 export { C as ChatAttachmentPayload, a as ChatModelSelection, b as ChatSubmitPayload, S as SessionCtx, c as SessionDetail, d as SessionStore, e as SessionSummary, T as ThinkingLevel } from '../chatSubmitPayload-DHqQL2wD.js';
 import { z } from 'zod';
 

package/dist/shared/index.js

@@ -39,7 +39,7 @@ import {
   extractToolUiMetadata,
   isToolUiMetadata,
   sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "../chunk-G6YPXDHR.js";
+} from "../chunk-UPRDF2PB.js";
 
 // src/shared/config-schema.ts
 import { z } from "zod";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "type": "module",
   "license": "MIT",
   "description": "Pane-embeddable coding agent. Ships direct/local/vercel-sandbox execution modes behind one interface.",
@@ -74,7 +74,7 @@
     "use-stick-to-bottom": "^1.1.3",
     "yaml": "^2.8.3",
     "zod": "^3.25.76",
-    "@hachej/boring-ui-kit": "0.1.62"
+    "@hachej/boring-ui-kit": "0.1.64"
   },
   "devDependencies": {
     "@antithesishq/bombadil": "0.5.0",