@hachej/boring-agent 0.1.61 → 0.1.63

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/server/index.d.ts

@@ -444,6 +444,62 @@ 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;
+    }>;
+    rejectMutation(operation: string, descriptor: {
+        filesystem: string;
+        path: string;
+    }): never;
+}
+interface RuntimeFilesystemBinding {
+    readonly filesystem: string;
+    readonly access: 'readonly';
+    readonly operations: RuntimeFilesystemBindingOperations;
+}
 interface RuntimeBundle {
     runtimeContext?: WorkspaceRuntimeContext;
     /**
@@ -461,6 +517,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 +666,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 {

package/dist/server/index.js

@@ -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,49 @@ 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);
+  }
+  async function rejectUnsupportedFilesystemMutation(request, reply, filesystem) {
+    const binding = await resolveFilesystemBinding(request, filesystem);
+    if (!binding) return sendNotFoundOrDenied(reply);
+    if (binding.access === "readonly") return sendFilesystemBindingMutationDenied(reply, filesystem, binding.access);
+    return reply.code(501).send({
+      error: { code: ERROR_CODE_INTERNAL, message: `${filesystem} binding access is not supported by this route` }
+    });
+  }
   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 || binding.access !== "readonly") 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 +2949,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 || binding.access !== "readonly") return sendNotFoundOrDenied(reply);
+        const result = await binding.operations.read({ filesystem, path: path4 });
+        return { content: result.content };
+      } catch {
+        return sendNotFoundOrDenied(reply);
+      }
+    }
     try {
       if (isReadonlySkillFilePath(path4)) {
         const { content: content2, stat: stat13 } = await readReadonlySkillFile(path4);
@@ -2936,6 +2991,8 @@ function fileRoutes(app, opts, done) {
         error: { code: ERROR_CODE_VALIDATION_ERROR, message: "content is required", field: "content" }
       });
     }
+    const filesystem = requestedFilesystem(body.filesystem);
+    if (filesystem !== USER_FILESYSTEM_ID) return await rejectUnsupportedFilesystemMutation(request, reply, filesystem);
     const expectedMtimeMs = typeof body.expectedMtimeMs === "number" ? body.expectedMtimeMs : null;
     const shouldReturnMtimeMs = body.returnMtimeMs !== false || expectedMtimeMs !== null;
     try {
@@ -3069,6 +3126,8 @@ 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) return await rejectUnsupportedFilesystemMutation(request, reply, filesystem);
     try {
       const workspace = await resolveWorkspace(request);
       await workspace.unlink(path4);
@@ -3083,6 +3142,8 @@ 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) return await rejectUnsupportedFilesystemMutation(request, reply, filesystem);
     try {
       const workspace = await resolveWorkspace(request);
       await workspace.rename(from, to);
@@ -3096,6 +3157,8 @@ 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) return await rejectUnsupportedFilesystemMutation(request, reply, filesystem);
     try {
       const workspace = await resolveWorkspace(request);
       await workspace.mkdir(path4, { recursive });
@@ -3108,6 +3171,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 || binding.access !== "readonly") 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 +8401,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 +8553,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 +8564,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "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.61"
+    "@hachej/boring-ui-kit": "0.1.63"
   },
   "devDependencies": {
     "@antithesishq/bombadil": "0.5.0",