@hachej/boring-agent 0.1.5 → 0.1.6

package/dist/{sandbox-handle-store-OPdvRwie.d.ts → sandbox-handle-store-pNB_27Sd.d.ts}

@@ -2,6 +2,11 @@ interface Workspace {
     readonly root: string;
     readFile(relPath: string): Promise<string>;
     writeFile(relPath: string, data: string): Promise<void>;
+    /**
+     * Optional binary write operation for user-uploaded assets. Shared callers use
+     * Uint8Array so browser-safe workspace contracts do not depend on Node-only types.
+     */
+    writeBinaryFile?(relPath: string, data: Uint8Array): Promise<void>;
     /**
      * Optional optimized read+metadata operation. Remote workspaces should
      * implement this as one round trip when possible.
@@ -15,6 +20,8 @@ interface Workspace {
      * implement this as one round trip when possible.
      */
     writeFileWithStat?(relPath: string, data: string): Promise<Stat>;
+    /** Optional optimized binary write+metadata operation. */
+    writeBinaryFileWithStat?(relPath: string, data: Uint8Array): Promise<Stat>;
     unlink(relPath: string): Promise<void>;
     readdir(relPath: string): Promise<Entry[]>;
     stat(relPath: string): Promise<Stat>;

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { S as Sandbox, f as SandboxHandleStore, e as SandboxHandleRecord, W as Workspace, F as FileSearch, A as AgentTool } from '../sandbox-handle-store-OPdvRwie.js';
+import { S as Sandbox, f as SandboxHandleStore, e as SandboxHandleRecord, W as Workspace, F as FileSearch, A as AgentTool } from '../sandbox-handle-store-pNB_27Sd.js';
 import { Sandbox as Sandbox$1 } from '@vercel/sandbox';
 import { FastifyInstance, FastifyRequest, FastifyPluginAsync } from 'fastify';
 import { PackageSource } from '@mariozechner/pi-coding-agent';
@@ -289,6 +289,11 @@ interface RegisterAgentRoutesOptions {
     workspaceRoot?: string;
     sessionId?: string;
     templatePath?: string;
+    getTemplatePath?: (ctx: {
+        workspaceId: string;
+        workspaceRoot: string;
+        request?: FastifyRequest;
+    }) => string | undefined | Promise<string | undefined>;
     mode?: RuntimeModeId;
     version?: string;
     extraTools?: AgentTool[];

package/dist/server/index.js

@@ -725,6 +725,11 @@ function logSandboxStop(logger, metadata) {
     ...metadata
   });
 }
+function isSandboxAlreadyExistsError(error) {
+  const code = error?.json?.error?.code;
+  const message = error?.json?.error?.message;
+  return code === "bad_request" && typeof message === "string" && message.includes("already exists");
+}
 async function createFresh(workspaceId, snapshotId, tarballUrl, previous, store, vercel, logger) {
   let sandbox;
   let sourceType = "empty";
@@ -733,21 +738,25 @@ async function createFresh(workspaceId, snapshotId, tarballUrl, previous, store,
     persistent: true,
     snapshotExpiration: 0
   };
-  if (snapshotId) {
-    sourceType = "snapshot";
-    sandbox = await vercel.create({
-      ...base,
-      source: { type: "snapshot", snapshotId }
-    });
-  } else if (tarballUrl) {
-    sourceType = "tarball";
-    sandbox = await vercel.create({
-      ...base,
-      source: { type: "tarball", url: tarballUrl }
-    });
-  } else {
-    sandbox = await vercel.create(base);
-  }
+  const tryCreate = async () => {
+    try {
+      if (snapshotId) {
+        sourceType = "snapshot";
+        return await vercel.create({ ...base, source: { type: "snapshot", snapshotId } });
+      } else if (tarballUrl) {
+        sourceType = "tarball";
+        return await vercel.create({ ...base, source: { type: "tarball", url: tarballUrl } });
+      } else {
+        return await vercel.create(base);
+      }
+    } catch (error) {
+      if (isSandboxAlreadyExistsError(error)) {
+        return await vercel.get({ name: base.name, sandboxId: base.name, resume: true });
+      }
+      throw error;
+    }
+  };
+  sandbox = await tryCreate();
   logSandboxCreate(logger, {
     workspaceId,
     sandboxId: getSandboxIdentifier(sandbox),
@@ -1384,6 +1393,10 @@ function createNodeWorkspace(root) {
       const absPath = await ensureWritableWorkspacePath(root, relPath);
       await writeFile3(absPath, data, "utf-8");
     },
+    async writeBinaryFile(relPath, data) {
+      const absPath = await ensureWritableWorkspacePath(root, relPath);
+      await writeFile3(absPath, data);
+    },
     async readFileWithStat(relPath) {
       const absPath = await ensureExistingWorkspacePath(root, relPath);
       const [content, fileStat] = await Promise.all([
@@ -1409,6 +1422,16 @@ function createNodeWorkspace(root) {
         kind: fileStat.isDirectory() ? "dir" : "file"
       };
     },
+    async writeBinaryFileWithStat(relPath, data) {
+      const absPath = await ensureWritableWorkspacePath(root, relPath);
+      await writeFile3(absPath, data);
+      const fileStat = await stat2(absPath);
+      return {
+        size: fileStat.size,
+        mtimeMs: fileStat.mtimeMs,
+        kind: fileStat.isDirectory() ? "dir" : "file"
+      };
+    },
     async unlink(relPath) {
       const absPath = await ensureExistingWorkspacePath(root, relPath);
       const pathStat = await lstat2(absPath);
@@ -1831,6 +1854,18 @@ function createVercelSandboxWorkspace(sandbox, workspaceOpts = {}) {
       workspaceOpts.onMutation?.();
       emitChange({ op: "write", path: relPath });
     },
+    async writeBinaryFile(relPath, data) {
+      const sandboxPath = toSandboxPath(relPath);
+      await sandbox.writeFiles([
+        {
+          path: sandboxPath,
+          content: Buffer.from(data)
+        }
+      ]);
+      invalidateMetadataCache();
+      workspaceOpts.onMutation?.();
+      emitChange({ op: "write", path: relPath });
+    },
     async readFileWithStat(relPath) {
       const sandboxPath = toSandboxPath(relPath);
       const cachedStat = statCache.get(sandboxPath);
@@ -1905,6 +1940,44 @@ function createVercelSandboxWorkspace(sandbox, workspaceOpts = {}) {
       emitChange({ op: "write", path: relPath, mtimeMs: writtenStat.mtimeMs });
       return cloneStat(writtenStat);
     },
+    async writeBinaryFileWithStat(relPath, data) {
+      const sandboxPath = toSandboxPath(relPath);
+      const payload = Buffer.from(data);
+      if (payload.byteLength > MAX_INLINE_WRITE_BYTES) {
+        await sandbox.writeFiles([
+          {
+            path: sandboxPath,
+            content: payload
+          }
+        ]);
+        invalidateMetadataCache();
+        workspaceOpts.onMutation?.();
+        const writtenStat2 = remote.fs?.stat ? await (async () => {
+          const fileStat = await remote.fs.stat(sandboxPath);
+          return {
+            size: fileStat.size,
+            mtimeMs: fileStat.mtimeMs,
+            kind: fileStat.isDirectory() ? "dir" : "file"
+          };
+        })() : await runJson(
+          remote,
+          `node -e ${shellQuote2(`const fs=require('fs'); const p=process.argv[1]; const s=fs.statSync(p); process.stdout.write(JSON.stringify({size:s.size,mtimeMs:s.mtimeMs,kind:s.isDirectory()?'dir':'file'}))`)} ${shellQuote2(sandboxPath)}`
+        );
+        statCache.set(sandboxPath, writtenStat2);
+        emitChange({ op: "write", path: relPath, mtimeMs: writtenStat2.mtimeMs });
+        return cloneStat(writtenStat2);
+      }
+      const encoded = payload.toString("base64");
+      const writtenStat = await runJson(
+        remote,
+        `node -e ${shellQuote2(`const fs=require('fs'); const p=process.argv[1]; const data=Buffer.from(process.argv[2],'base64'); fs.writeFileSync(p,data); const s=fs.statSync(p); process.stdout.write(JSON.stringify({size:s.size,mtimeMs:s.mtimeMs,kind:s.isDirectory()?'dir':'file'}))`)} ${shellQuote2(sandboxPath)} ${shellQuote2(encoded)}`
+      );
+      invalidateMetadataCache();
+      statCache.set(sandboxPath, writtenStat);
+      workspaceOpts.onMutation?.();
+      emitChange({ op: "write", path: relPath, mtimeMs: writtenStat.mtimeMs });
+      return cloneStat(writtenStat);
+    },
     async unlink(relPath) {
       const sandboxPath = toSandboxPath(relPath);
       if (remote.fs?.rm) await remote.fs.rm(sandboxPath, { recursive: false, force: false });
@@ -2410,6 +2483,32 @@ async function ensureVercelWorkspaceRoot(sandbox) {
     throw new Error(`failed to initialize ${VERCEL_SANDBOX_REMOTE_ROOT} (exit ${result.exitCode ?? "unknown"})`);
   }
 }
+async function seedTemplateIntoVercelWorkspace(workspace, templatePath, logger) {
+  const files = await collectFiles(templatePath);
+  const hash = computeTemplateHash(files);
+  const markerPath = `.boring-agent/templates/${hash}.json`;
+  try {
+    await workspace.stat(markerPath);
+    logger.info("[vercel-sandbox:mode] template already seeded", {
+      hash,
+      fileCount: files.length
+    });
+    return;
+  } catch {
+  }
+  for (const file of files) {
+    if (workspace.writeBinaryFile) {
+      await workspace.writeBinaryFile(file.rel, new Uint8Array(file.content));
+    } else {
+      await workspace.writeFile(file.rel, file.content.toString("utf-8"));
+    }
+  }
+  await workspace.writeFile(markerPath, JSON.stringify({ hash, seededAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  logger.info("[vercel-sandbox:mode] template seeded into workspace", {
+    hash,
+    fileCount: files.length
+  });
+}
 var DEFAULT_MODE_LOGGER = {
   info(message, metadata) {
     process.stderr.write(`${message} ${JSON.stringify(metadata)}
@@ -2521,17 +2620,13 @@ function createVercelSandboxModeAdapter(opts = {}) {
         onMutation: markDirty
       });
       await ensureVercelWorkspaceRoot(sandboxHandle);
-      if (ctx.templatePath && !tarballUrl) {
-        logger.info("[vercel-sandbox:mode] falling back to writeFiles for template", {
-          templatePath: ctx.templatePath
-        });
-        const files = await collectFiles(ctx.templatePath);
-        for (const file of files) {
-          await workspace.writeFile(file.rel, file.content.toString("utf-8"));
+      if (ctx.templatePath) {
+        if (!tarballUrl) {
+          logger.info("[vercel-sandbox:mode] falling back to writeFiles for template", {
+            templatePath: ctx.templatePath
+          });
         }
-        logger.info("[vercel-sandbox:mode] writeFiles fallback complete", {
-          fileCount: files.length
-        });
+        await seedTemplateIntoVercelWorkspace(workspace, ctx.templatePath, logger);
       }
       const sandbox = createVercelSandboxExec(sandboxHandle, {
         onMutation: markDirty
@@ -4920,6 +5015,13 @@ function healthRoutes(app, opts, done) {
 }
 
 // src/server/http/routes/file.ts
+import { dirname as dirname7, extname as extname2, relative as relative7 } from "path/posix";
+var BORING_SETTINGS_PATH = ".boring/settings";
+var DEFAULT_MARKDOWN_IMAGE_UPLOAD_DIR = "assets/images";
+var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
+function defaultWorkspaceSettings() {
+  return { markdown: { imageUploadDir: DEFAULT_MARKDOWN_IMAGE_UPLOAD_DIR } };
+}
 function isPathValidationError(err) {
   return err instanceof Error && typeof err.reason === "string";
 }
@@ -4965,6 +5067,58 @@ function requireStringParam(value, field, reply) {
   }
   return value;
 }
+function parseWorkspaceSettings(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const dir = parsed?.markdown?.imageUploadDir;
+    return {
+      ...parsed,
+      markdown: {
+        ...parsed.markdown ?? {},
+        imageUploadDir: typeof dir === "string" && dir.trim() ? dir.trim() : DEFAULT_MARKDOWN_IMAGE_UPLOAD_DIR
+      }
+    };
+  } catch {
+    return defaultWorkspaceSettings();
+  }
+}
+async function readWorkspaceSettings(workspace) {
+  try {
+    return parseWorkspaceSettings(await workspace.readFile(BORING_SETTINGS_PATH));
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") return defaultWorkspaceSettings();
+    throw error;
+  }
+}
+function normalizeUploadDir(value) {
+  if (typeof value !== "string") return null;
+  const dir = value.trim().replace(/^\.\/+/, "").replace(/\/+/g, "/");
+  if (!dir || dir.includes("\0") || dir.startsWith("/") || dir.split("/").includes("..")) return null;
+  return dir.replace(/\/+$/, "");
+}
+function extForUpload(filename, contentType) {
+  const fromName = extname2(filename).toLowerCase().replace(/^\./, "");
+  if (/^[a-z0-9]{1,12}$/.test(fromName)) return fromName;
+  if (contentType === "image/jpeg") return "jpg";
+  if (contentType === "image/png") return "png";
+  if (contentType === "image/gif") return "gif";
+  if (contentType === "image/webp") return "webp";
+  if (contentType === "image/svg+xml") return "svg";
+  return "bin";
+}
+function basenameForUpload(filename) {
+  const base = filename.split("/").pop()?.split("\\").pop() ?? "image";
+  const withoutExt = base.replace(/\.[^.]*$/, "");
+  const safe = withoutExt.normalize("NFKD").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return safe || "image";
+}
+function markdownUrlFor(sourcePath, assetPath) {
+  if (!sourcePath) return assetPath;
+  const fromDir = dirname7(sourcePath.replace(/\\/g, "/"));
+  const rel = relative7(fromDir === "." ? "" : fromDir, assetPath);
+  return rel && !rel.startsWith(".") ? rel : rel || assetPath;
+}
 function fileRoutes(app, opts, done) {
   async function resolveWorkspace(request) {
     if (opts.getWorkspace) return await opts.getWorkspace(request);
@@ -5041,6 +5195,87 @@ function fileRoutes(app, opts, done) {
       return classifyError(err, reply, "file");
     }
   });
+  app.post("/api/v1/files/upload", async (request, reply) => {
+    const body = request.body;
+    const filename = requireStringParam(body?.filename, "filename", reply);
+    if (filename === null) return;
+    const contentBase64 = requireStringParam(body?.contentBase64, "contentBase64", reply);
+    if (contentBase64 === null) return;
+    const contentType = typeof body.contentType === "string" ? body.contentType.trim().toLowerCase() : "";
+    if (!contentType.startsWith("image/")) {
+      return reply.code(400).send({
+        error: { code: ERROR_CODE_VALIDATION_ERROR, message: "contentType must be an image/* MIME type", field: "contentType" }
+      });
+    }
+    try {
+      const workspace = await resolveWorkspace(request);
+      const settings = await readWorkspaceSettings(workspace);
+      const dir = normalizeUploadDir(body.directory) ?? normalizeUploadDir(settings.markdown?.imageUploadDir) ?? DEFAULT_MARKDOWN_IMAGE_UPLOAD_DIR;
+      const ext = extForUpload(filename, contentType);
+      const base = basenameForUpload(filename);
+      const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+      const path4 = `${dir}/${base}-${unique}.${ext}`;
+      const bytes = Buffer.from(contentBase64, "base64");
+      if (bytes.byteLength === 0 || bytes.byteLength > MAX_UPLOAD_BYTES) {
+        return reply.code(400).send({
+          error: { code: ERROR_CODE_VALIDATION_ERROR, message: `upload must be 1 byte to ${MAX_UPLOAD_BYTES} bytes`, field: "contentBase64" }
+        });
+      }
+      await workspace.mkdir(dir, { recursive: true });
+      const stat7 = workspace.writeBinaryFileWithStat ? await workspace.writeBinaryFileWithStat(path4, bytes) : await (async () => {
+        if (!workspace.writeBinaryFile) {
+          throw new Error("workspace does not support binary uploads");
+        }
+        await workspace.writeBinaryFile(path4, bytes);
+        return await workspace.stat(path4);
+      })();
+      const sourcePath = typeof body.sourcePath === "string" && !body.sourcePath.includes("\0") ? body.sourcePath : null;
+      return {
+        ok: true,
+        path: path4,
+        markdownUrl: markdownUrlFor(sourcePath, path4),
+        mtimeMs: stat7.kind === "file" ? stat7.mtimeMs : void 0
+      };
+    } catch (err) {
+      return classifyError(err, reply, "upload");
+    }
+  });
+  app.get("/api/v1/workspace-settings", async (request, reply) => {
+    try {
+      const workspace = await resolveWorkspace(request);
+      return { settings: await readWorkspaceSettings(workspace) };
+    } catch (err) {
+      return classifyError(err, reply, "settings");
+    }
+  });
+  app.put("/api/v1/workspace-settings", async (request, reply) => {
+    const body = request.body;
+    const incoming = body?.settings ?? body;
+    const markdown = incoming.markdown ?? {};
+    const imageUploadDir = normalizeUploadDir(markdown.imageUploadDir);
+    if (!imageUploadDir) {
+      return reply.code(400).send({
+        error: { code: ERROR_CODE_INVALID_PATH, message: "markdown.imageUploadDir must be a relative workspace path", field: "markdown.imageUploadDir" }
+      });
+    }
+    try {
+      const workspace = await resolveWorkspace(request);
+      const current = await readWorkspaceSettings(workspace);
+      const next = {
+        ...current,
+        markdown: {
+          ...current.markdown ?? {},
+          imageUploadDir
+        }
+      };
+      await workspace.mkdir(".boring", { recursive: true });
+      await workspace.writeFile(BORING_SETTINGS_PATH, `${JSON.stringify(next, null, 2)}
+`);
+      return { settings: next };
+    } catch (err) {
+      return classifyError(err, reply, "settings");
+    }
+  });
   app.delete("/api/v1/files", async (request, reply) => {
     const query = request.query;
     const path4 = requireStringParam(query.path, "path", reply);
@@ -5806,7 +6041,11 @@ function skillsRoutes(app, opts, done) {
       return reply.code(200).send({ skills: cached.skills });
     }
     try {
-      const result = loadSkills2({ cwd: opts.workspaceRoot, includeDefaults: true });
+      const result = loadSkills2({
+        cwd: opts.workspaceRoot,
+        skillPaths: opts.additionalSkillPaths ?? [],
+        includeDefaults: true
+      });
       const skills = result.skills.map((s) => ({
         name: s.name,
         description: s.description
@@ -6289,7 +6528,10 @@ async function createAgentApp(opts = {}) {
   });
   await app.register(systemPromptRoutes, { harness });
   await app.register(modelsRoutes);
-  await app.register(skillsRoutes, { workspaceRoot });
+  await app.register(skillsRoutes, {
+    workspaceRoot,
+    additionalSkillPaths: opts.resourceLoaderOptions?.additionalSkillPaths
+  });
   await app.register(sessionChangesRoutes, { tracker: sessionChangesTracker });
   await app.register(catalogRoutes, { tools });
   await app.register(readyStatusRoutes, { tracker: readyTracker });
@@ -6420,12 +6662,13 @@ var registerAgentRoutes = async (app, opts) => {
       key: `${resolvedMode}:${workspaceId}:${root}`
     };
   }
-  async function createRuntimeBinding(workspaceId, root) {
+  async function createRuntimeBinding(workspaceId, root, request) {
+    const scopedTemplatePath = opts.getTemplatePath ? await opts.getTemplatePath({ workspaceId, workspaceRoot: root, request }) : templatePath;
     const runtimeBundle = await modeAdapter.create({
       workspaceRoot: root,
       sessionId: workspaceId,
       workspaceId,
-      templatePath
+      templatePath: scopedTemplatePath
     });
     const standardTools = [
       ...buildHarnessAgentTools(runtimeBundle),
@@ -6494,7 +6737,7 @@ var registerAgentRoutes = async (app, opts) => {
         await existing
       );
     }
-    const created = createRuntimeBinding(workspaceId, scope.root);
+    const created = createRuntimeBinding(workspaceId, scope.root, request);
     runtimeBindings.set(scope.key, created);
     try {
       return await ensureRuntimeBindingReady(
@@ -6631,7 +6874,10 @@ var registerAgentRoutes = async (app, opts) => {
     getHarness: async (request) => (await getBindingForRequest(request)).harness
   });
   await app.register(modelsRoutes);
-  await app.register(skillsRoutes, { workspaceRoot });
+  await app.register(skillsRoutes, {
+    workspaceRoot,
+    additionalSkillPaths: opts.resourceLoaderOptions?.additionalSkillPaths
+  });
   await app.register(sessionChangesRoutes, { tracker: sessionChangesTracker });
   await app.register(
     catalogRoutes,

package/dist/shared/index.d.ts

@@ -1,6 +1,6 @@
 export { A as AgentHarness, R as RunContext, S as SendMessageInput, a as SessionCtx, b as SessionDetail, c as SessionStore, d as SessionSummary } from '../harness-CMiJ4kok.js';
-import { W as Workspace, S as Sandbox, F as FileSearch, A as AgentTool } from '../sandbox-handle-store-OPdvRwie.js';
-export { E as Entry, a as ExecOptions, b as ExecResult, I as IsolatedCodeInput, c as IsolatedCodeOutput, J as JSONSchema, d as SandboxCapability, e as SandboxHandleRecord, f as SandboxHandleStore, g as Stat, T as ToolExecContext, h as ToolResult } from '../sandbox-handle-store-OPdvRwie.js';
+import { W as Workspace, S as Sandbox, F as FileSearch, A as AgentTool } from '../sandbox-handle-store-pNB_27Sd.js';
+export { E as Entry, a as ExecOptions, b as ExecResult, I as IsolatedCodeInput, c as IsolatedCodeOutput, J as JSONSchema, d as SandboxCapability, e as SandboxHandleRecord, f as SandboxHandleStore, g as Stat, T as ToolExecContext, h as ToolResult } from '../sandbox-handle-store-pNB_27Sd.js';
 export { UIMessage, UIMessageChunk } from 'ai';
 import { z } from 'zod';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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.5"
+    "@hachej/boring-ui-kit": "0.1.6"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",