farming-code 2.2.30 → 2.2.32

package/backend/{workspace-file-router.js → workspace-file-router.cjs}

@@ -1,50 +1,73 @@
-const express = require('express');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { inspectGitWorktree } = require('./git-worktree-info');
-const { WorkspaceFileError } = require('./workspace-file-service');
-const { PreviewSessionManager } = require('./preview-session-manager');
-const {
-  GLOBAL_WORKSPACE_FILES_AGENT_ID,
-  GLOBAL_WORKSPACE_FILES_ROOT,
-  GLOBAL_WORKSPACE_ROOT_ID,
-  PROJECT_FILES_WORKSPACE_PREFIX,
-  WorkspaceRootRegistry,
-  projectWorkspaceFromLegacyRef,
-} = require('./workspace-root-registry');
-
-const ROOT_REGISTRIES = new WeakMap();
-
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_file_router_exports = {};
+__export(workspace_file_router_exports, {
+  GLOBAL_WORKSPACE_FILES_AGENT_ID: () => import_workspace_root_registry.GLOBAL_WORKSPACE_FILES_AGENT_ID,
+  GLOBAL_WORKSPACE_FILES_ROOT: () => import_workspace_root_registry.GLOBAL_WORKSPACE_FILES_ROOT,
+  PROJECT_FILES_WORKSPACE_PREFIX: () => import_workspace_root_registry.PROJECT_FILES_WORKSPACE_PREFIX,
+  assertExactExternalFileReadable: () => assertExactExternalFileReadable,
+  assertGlobalWorkspacePathAllowed: () => assertGlobalWorkspacePathAllowed,
+  createWorkspaceFileRouter: () => createWorkspaceFileRouter,
+  globalWorkspaceAllowedRoots: () => globalWorkspaceAllowedRoots,
+  isGlobalWorkspaceFilesAgentId: () => isGlobalWorkspaceFilesAgentId,
+  projectWorkspaceFromFilesId: () => projectWorkspaceFromFilesId,
+  resolveWorkspaceRoot: () => resolveWorkspaceRoot,
+  sendWorkspaceFileError: () => sendWorkspaceFileError
+});
+module.exports = __toCommonJS(workspace_file_router_exports);
+var import_git_worktree_info = require("./git-worktree-info.cjs");
+var import_workspace_file_service = require("./workspace-file-service.cjs");
+var import_preview_session_manager = require("./preview-session-manager.cjs");
+var import_workspace_root_registry = require("./workspace-root-registry.cjs");
+const express = require("express");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const expressFactory = express;
+const ROOT_REGISTRIES = /* @__PURE__ */ new WeakMap();
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 function isGlobalWorkspaceFilesAgentId(agentId) {
-  return agentId === GLOBAL_WORKSPACE_FILES_AGENT_ID || agentId === GLOBAL_WORKSPACE_ROOT_ID;
+  return agentId === import_workspace_root_registry.GLOBAL_WORKSPACE_FILES_AGENT_ID || agentId === import_workspace_root_registry.GLOBAL_WORKSPACE_ROOT_ID;
 }
-
 function projectWorkspaceFromFilesId(filesId) {
-  return projectWorkspaceFromLegacyRef(filesId);
+  return (0, import_workspace_root_registry.projectWorkspaceFromLegacyRef)(filesId);
 }
-
 function workspaceRootRegistryFor(agentManager) {
   let registry = ROOT_REGISTRIES.get(agentManager);
   if (!registry) {
-    registry = new WorkspaceRootRegistry(agentManager);
+    registry = new import_workspace_root_registry.WorkspaceRootRegistry(agentManager);
     ROOT_REGISTRIES.set(agentManager, registry);
   }
   return registry;
 }
-
 function workspaceRef(source) {
-  return source && typeof source.rootId === 'string' && source.rootId.trim()
-    ? source.rootId
-    : source?.agentId;
+  if (!isRecord(source)) return void 0;
+  return typeof source.rootId === "string" && source.rootId.trim() ? source.rootId : source.agentId;
 }
-
 function normalizeAbsolutePath(value) {
-  const raw = String(value || '').trim();
-  if (!raw) return '';
+  const raw = String(value || "").trim();
+  if (!raw) return "";
   return path.resolve(raw.replace(/^~(?=$|[\\/])/, os.homedir()));
 }
-
 function realPathIfPresent(value) {
   try {
     return fs.realpathSync(value);
@@ -52,27 +75,21 @@ function realPathIfPresent(value) {
     return value;
   }
 }
-
 function isSameOrDescendantPath(root, target) {
   const relative = path.relative(root, target);
-  return relative === '' || Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
+  return relative === "" || Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
 }
-
 function previewAuthorizedRootForTarget(allowedRoots, target) {
-  return allowedRoots
-    .filter(root => isSameOrDescendantPath(root, target))
-    .sort((left, right) => right.length - left.length)[0] || '';
+  return allowedRoots.filter((root) => isSameOrDescendantPath(root, target)).sort((left, right) => right.length - left.length)[0] || "";
 }
-
 function normalizePreviewAssetPath(value) {
-  const normalized = path.posix.normalize(String(value || '').replace(/\\/g, '/').replace(/^\/+/, ''));
-  if (!normalized || normalized === '.') return '';
-  if (normalized === '..' || normalized.startsWith('../') || path.posix.isAbsolute(normalized)) {
-    throw new WorkspaceFileError('preview path must stay inside the authorized root', 403);
+  const normalized = path.posix.normalize(String(value || "").replace(/\\/g, "/").replace(/^\/+/, ""));
+  if (!normalized || normalized === ".") return "";
+  if (normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+    throw new import_workspace_file_service.WorkspaceFileError("preview path must stay inside the authorized root", 403);
   }
   return normalized;
 }
-
 function previewContentSecurityPolicy() {
   return [
     "default-src 'none'",
@@ -86,91 +103,65 @@ function previewContentSecurityPolicy() {
     "object-src 'none'",
     "base-uri 'none'",
     "form-action 'none'",
-    "frame-ancestors 'self'",
-  ].join('; ');
+    "frame-ancestors 'self'"
+  ].join("; ");
 }
-
 function escapeHtmlAttribute(value) {
-  return String(value || '')
-    .replace(/&/g, '&')
-    .replace(/"/g, '"')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
+  return String(value || "").replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-
 function rewritePreviewHtmlRootReferences(source, rootUrl) {
   const safeRootUrl = escapeHtmlAttribute(rootUrl);
-  return String(source || '')
-    .replace(/(\b(?:href|src|poster)\s*=\s*["'])\/(?!\/)/gi, `$1${safeRootUrl}`)
-    .replace(/(url\(\s*["']?)\/(?!\/)/gi, `$1${safeRootUrl}`);
+  return String(source || "").replace(/(\b(?:href|src|poster)\s*=\s*["'])\/(?!\/)/gi, `$1${safeRootUrl}`).replace(/(url\(\s*["']?)\/(?!\/)/gi, `$1${safeRootUrl}`);
 }
-
-function globalUserPathToAbsolute(userPath = '') {
-  const normalized = String(userPath || '')
-    .trim()
-    .replace(/\\/g, '/')
-    .replace(/^\/+/, '');
-  return path.resolve(GLOBAL_WORKSPACE_FILES_ROOT, normalized || '.');
+function globalUserPathToAbsolute(userPath = "") {
+  const normalized = String(userPath || "").trim().replace(/\\/g, "/").replace(/^\/+/, "");
+  return path.resolve(import_workspace_root_registry.GLOBAL_WORKSPACE_FILES_ROOT, normalized || ".");
 }
-
 function relativeGlobalPath(absolutePath) {
-  const relative = path.relative(GLOBAL_WORKSPACE_FILES_ROOT, absolutePath);
-  return relative === '' ? '' : relative.replace(/\\/g, '/');
+  const relative = path.relative(import_workspace_root_registry.GLOBAL_WORKSPACE_FILES_ROOT, absolutePath);
+  return relative === "" ? "" : relative.replace(/\\/g, "/");
 }
-
 function collectCandidateAllowedRoots(agentManager) {
   const roots = [os.homedir()];
-  const state = agentManager && typeof agentManager.getState === 'function'
-    ? agentManager.getState()
-    : {};
+  const state = agentManager && typeof agentManager.getState === "function" ? agentManager.getState() : {};
   for (const agent of state.agents || []) {
+    const worktree = isRecord(agent.gitWorktree) ? agent.gitWorktree : {};
     roots.push(agent && agent.projectWorkspace);
     roots.push(agent && agent.cwd);
-    roots.push(agent && agent.gitWorktree && agent.gitWorktree.workspace);
+    roots.push(worktree.workspace);
   }
   for (const entry of state.taskHistory || []) {
     roots.push(entry && entry.projectWorkspace);
     roots.push(entry && entry.cwd);
   }
-
   const configManager = agentManager && agentManager.configManager;
-  const settings = configManager && typeof configManager.getSettings === 'function'
-    ? configManager.getSettings()
-    : null;
+  const settings = configManager && typeof configManager.getSettings === "function" ? configManager.getSettings() : null;
   if (settings) {
-    roots.push(...(Array.isArray(settings.workspaceHistory) ? settings.workspaceHistory : []));
-    roots.push(...(Array.isArray(settings.projectWorkspaces) ? settings.projectWorkspaces : []));
+    roots.push(...Array.isArray(settings.workspaceHistory) ? settings.workspaceHistory : []);
+    roots.push(...Array.isArray(settings.projectWorkspaces) ? settings.projectWorkspaces : []);
   }
   return roots;
 }
-
 function globalWorkspaceAllowedRoots(agentManager) {
-  const seen = new Set();
-  return collectCandidateAllowedRoots(agentManager)
-    .map(normalizeAbsolutePath)
-    .filter(Boolean)
-    .map(realPathIfPresent)
-    .filter(root => {
-      if (root === path.parse(root).root) return false;
-      if (seen.has(root)) return false;
-      seen.add(root);
-      return true;
-    });
+  const seen = /* @__PURE__ */ new Set();
+  return collectCandidateAllowedRoots(agentManager).map(normalizeAbsolutePath).filter(Boolean).map(realPathIfPresent).filter((root) => {
+    if (root === path.parse(root).root) return false;
+    if (seen.has(root)) return false;
+    seen.add(root);
+    return true;
+  });
 }
-
 function assertGlobalWorkspacePathAllowed(agentManager, userPath, options = {}) {
   const allowedRoots = globalWorkspaceAllowedRoots(agentManager);
   const requestedTarget = globalUserPathToAbsolute(userPath);
   if (!allowedRoots.length) {
-    throw new WorkspaceFileError('global files have no allowed roots', 403);
+    throw new import_workspace_file_service.WorkspaceFileError("global files have no allowed roots", 403);
   }
-
   if (options.allowAllowedRootAncestor === true) {
-    const isAllowedRootAncestor = allowedRoots.some(root => isSameOrDescendantPath(requestedTarget, root));
+    const isAllowedRootAncestor = allowedRoots.some((root) => isSameOrDescendantPath(requestedTarget, root));
     if (isAllowedRootAncestor) return { target: requestedTarget, allowedRoots };
   }
-
-  const allowed = allowedRoots.some(root => {
+  const allowed = allowedRoots.some((root) => {
     if (options.allowMissing === true) {
       const realParent = realPathIfPresent(path.dirname(requestedTarget));
       return isSameOrDescendantPath(root, requestedTarget) && isSameOrDescendantPath(root, realParent);
@@ -179,11 +170,10 @@ function assertGlobalWorkspacePathAllowed(agentManager, userPath, options = {})
     return isSameOrDescendantPath(root, realTarget);
   });
   if (!allowed) {
-    throw new WorkspaceFileError('global file path is outside allowed workspaces', 403);
+    throw new import_workspace_file_service.WorkspaceFileError("global file path is outside allowed workspaces", 403);
   }
   return { target: requestedTarget, allowedRoots };
 }
-
 function assertExactExternalFileReadable(userPath) {
   const requestedTarget = globalUserPathToAbsolute(userPath);
   let target;
@@ -193,19 +183,18 @@ function assertExactExternalFileReadable(userPath) {
     stat = fs.statSync(target);
     fs.accessSync(target, fs.constants.R_OK);
   } catch {
-    throw new WorkspaceFileError('external file is not readable', 403);
+    throw new import_workspace_file_service.WorkspaceFileError("external file is not readable", 403);
   }
   if (!stat.isFile()) {
-    throw new WorkspaceFileError('external path must be a file', 400);
+    throw new import_workspace_file_service.WorkspaceFileError("external path must be a file", 400);
   }
   return relativeGlobalPath(target);
 }
-
-function globalSyntheticTree(agentManager, userPath = '') {
+function globalSyntheticTree(agentManager, userPath = "") {
   const { target, allowedRoots } = assertGlobalWorkspacePathAllowed(agentManager, userPath, {
-    allowAllowedRootAncestor: true,
+    allowAllowedRootAncestor: true
   });
-  const children = new Map();
+  const children = /* @__PURE__ */ new Map();
   for (const root of allowedRoots) {
     if (!isSameOrDescendantPath(target, root) || target === root) continue;
     const relative = path.relative(target, root);
@@ -215,94 +204,80 @@ function globalSyntheticTree(agentManager, userPath = '') {
     children.set(first, {
       name: first,
       path: relativeGlobalPath(childAbsolute),
-      type: 'directory',
+      type: "directory",
       size: 0,
-      mtimeMs: 0,
+      mtimeMs: 0
     });
   }
   return {
     path: relativeGlobalPath(target),
     items: Array.from(children.values()).sort((a, b) => a.name.localeCompare(b.name)),
-    gitStatusPending: false,
+    gitStatusPending: false
   };
 }
-
-async function listGlobalWorkspaceTree(agentManager, fileService, userPath = '') {
+async function listGlobalWorkspaceTree(agentManager, fileService, userPath = "") {
   const { target, allowedRoots } = assertGlobalWorkspacePathAllowed(agentManager, userPath, {
-    allowAllowedRootAncestor: true,
+    allowAllowedRootAncestor: true
   });
-  const insideAllowedRoot = allowedRoots.some(root => isSameOrDescendantPath(root, realPathIfPresent(target)));
+  const insideAllowedRoot = allowedRoots.some((root) => isSameOrDescendantPath(root, realPathIfPresent(target)));
   if (!insideAllowedRoot) {
     return globalSyntheticTree(agentManager, userPath);
   }
-  return fileService.listTree(GLOBAL_WORKSPACE_FILES_ROOT, userPath || '');
+  return fileService.listTree(import_workspace_root_registry.GLOBAL_WORKSPACE_FILES_ROOT, userPath || "");
 }
-
 function sendWorkspaceFileError(res, error) {
-  if (error instanceof WorkspaceFileError) {
+  if (error instanceof import_workspace_file_service.WorkspaceFileError) {
     res.status(error.statusCode).json({
       error: error.message,
-      ...(Object.keys(error.details || {}).length > 0 ? { details: error.details } : {}),
+      ...Object.keys(error.details || {}).length > 0 ? { details: error.details } : {}
     });
     return;
   }
-
-  console.error('Workspace file API error:', error);
-  res.status(500).json({ error: 'workspace file operation failed' });
+  console.error("Workspace file API error:", error);
+  res.status(500).json({ error: "workspace file operation failed" });
 }
-
 function resolveWorkspaceRoot(agentManager, rootRef) {
   return workspaceRootRegistryFor(agentManager).resolve(rootRef).canonicalPath;
 }
-
 function assertWritableWorkspaceAgent(agentId) {
   if (isGlobalWorkspaceFilesAgentId(agentId)) {
-    throw new WorkspaceFileError('global files are read-only', 403);
+    throw new import_workspace_file_service.WorkspaceFileError("global files are read-only", 403);
   }
 }
-
 function readOptionsForAgent(agentManager, agentId) {
-  return isGlobalWorkspaceFilesAgentId(agentId)
-    ? {}
-    : { allowedExternalRoots: globalWorkspaceAllowedRoots(agentManager) };
+  return isGlobalWorkspaceFilesAgentId(agentId) ? {} : { allowedExternalRoots: globalWorkspaceAllowedRoots(agentManager) };
 }
-
 function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
-  const router = express.Router();
+  const router = expressFactory.Router();
   const rootRegistry = options.rootRegistry || workspaceRootRegistryFor(agentManager);
-  const previewSessions = options.previewSessionManager || new PreviewSessionManager();
-
-  router.use(express.json({ limit: '3mb' }));
-
-  router.get('/roots', (_req, res) => {
+  const previewSessions = options.previewSessionManager || new import_preview_session_manager.PreviewSessionManager();
+  router.use(expressFactory.json({ limit: "3mb" }));
+  router.get("/roots", (_req, res) => {
     res.json({ roots: rootRegistry.list() });
   });
-
-  const resolveRequestRoot = source => {
+  const resolveRequestRoot = (source) => {
     const workspaceRoot = rootRegistry.resolve(workspaceRef(source));
-    return { root: workspaceRoot.canonicalPath, rootId: workspaceRoot.rootId };
+    return {
+      kind: String(workspaceRoot.kind || ""),
+      root: workspaceRoot.canonicalPath,
+      rootId: workspaceRoot.rootId
+    };
   };
-
-  router.get('/tree', async (req, res) => {
+  router.get("/tree", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       const { root, rootId } = resolveRequestRoot(req.query);
-      const tree = isGlobalWorkspaceFilesAgentId(rootRef)
-        ? await listGlobalWorkspaceTree(agentManager, fileService, req.query.path || '')
-        : await fileService.listTree(root, req.query.path || '', readOptionsForAgent(agentManager, rootRef));
+      const tree = isGlobalWorkspaceFilesAgentId(rootRef) ? await listGlobalWorkspaceTree(agentManager, fileService, req.query.path || "") : await fileService.listTree(root, req.query.path || "", readOptionsForAgent(agentManager, rootRef));
       res.json({ rootId, root, tree });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/file', async (req, res) => {
+  router.get("/file", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
-      const requestPath = isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact === '1'
-        ? assertExactExternalFileReadable(req.query.path || '')
-        : req.query.path || '';
-      if (isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact !== '1') {
+      const requestPath = isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact === "1" ? assertExactExternalFileReadable(req.query.path || "") : req.query.path || "";
+      if (isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact !== "1") {
         assertGlobalWorkspacePathAllowed(agentManager, requestPath);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
@@ -312,54 +287,42 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/raw', async (req, res) => {
+  router.get("/raw", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
-      const requestPath = isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact === '1'
-        ? assertExactExternalFileReadable(req.query.path || '')
-        : req.query.path || '';
-      if (isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact !== '1') {
+      const requestPath = isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact === "1" ? assertExactExternalFileReadable(req.query.path || "") : req.query.path || "";
+      if (isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact !== "1") {
         assertGlobalWorkspacePathAllowed(agentManager, requestPath);
       }
       const { root } = resolveRequestRoot(req.query);
       const file = await fileService.readPreviewFile(root, requestPath, readOptionsForAgent(agentManager, rootRef));
-      res
-        .status(200)
-        .type(file.preview.mediaType)
-        .set('Cache-Control', 'no-store')
-        .set('X-Content-Type-Options', 'nosniff')
-        .set('Content-Length', String(file.size))
-        .send(file.buffer);
+      res.status(200).type(file.preview.mediaType).set("Cache-Control", "no-store").set("X-Content-Type-Options", "nosniff").set("Content-Length", String(file.size)).send(file.buffer);
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.post('/previews', async (req, res) => {
+  router.post("/previews", async (req, res) => {
     try {
       const body = req.body || {};
       const rootRef = workspaceRef(body);
-      let entryPath = String(body.path || '').trim();
+      let entryPath = String(body.path || "").trim();
       if (!/\.html?$/i.test(entryPath)) {
-        throw new WorkspaceFileError('HTML preview requires an .html or .htm file', 415);
+        throw new import_workspace_file_service.WorkspaceFileError("HTML preview requires an .html or .htm file", 415);
       }
-
       let authorizedRoot;
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
         if (body.exact === true) {
           entryPath = assertExactExternalFileReadable(entryPath);
           authorizedRoot = path.dirname(realPathIfPresent(globalUserPathToAbsolute(entryPath)));
           if (authorizedRoot === path.parse(authorizedRoot).root) {
-            throw new WorkspaceFileError('external HTML preview directory cannot be the filesystem root', 403);
+            throw new import_workspace_file_service.WorkspaceFileError("external HTML preview directory cannot be the filesystem root", 403);
           }
         } else {
           const authorization = assertGlobalWorkspacePathAllowed(agentManager, entryPath);
           authorizedRoot = previewAuthorizedRootForTarget(authorization.allowedRoots, realPathIfPresent(authorization.target));
-          if (!authorizedRoot) throw new WorkspaceFileError('global file path is outside allowed workspaces', 403);
+          if (!authorizedRoot) throw new import_workspace_file_service.WorkspaceFileError("global file path is outside allowed workspaces", 403);
         }
       }
-
       const { root, rootId } = resolveRequestRoot(body);
       await fileService.readFile(root, entryPath, { allowedExternalRoots: [] });
       const session = previewSessions.createStatic({
@@ -367,198 +330,177 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
         workspaceRoot: root,
         authorizedRoot: realPathIfPresent(authorizedRoot || root),
         entryPath,
-        baseDirectory: path.posix.dirname(entryPath) === '.' ? '' : path.posix.dirname(entryPath),
+        baseDirectory: path.posix.dirname(entryPath) === "." ? "" : path.posix.dirname(entryPath)
       });
       res.status(201).json({
         preview: {
           id: session.id,
           kind: session.kind,
-          expiresAt: session.expiresAt,
-        },
+          expiresAt: session.expiresAt
+        }
       });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/previews/:sessionId/:scope/*', async (req, res) => {
+  router.get("/previews/:sessionId/:scope/*", async (req, res) => {
     try {
       const session = previewSessions.get(req.params.sessionId);
-      if (!session) throw new WorkspaceFileError('preview session not found or expired', 404);
+      if (!session) throw new import_workspace_file_service.WorkspaceFileError("preview session not found or expired", 404);
       const scope = req.params.scope;
-      if (scope !== 'base' && scope !== 'root') {
-        throw new WorkspaceFileError('preview scope is invalid', 400);
+      if (scope !== "base" && scope !== "root") {
+        throw new import_workspace_file_service.WorkspaceFileError("preview scope is invalid", 400);
       }
-      const assetPath = normalizePreviewAssetPath(req.params[0] || '');
-      const resourcePath = scope === 'base'
-        ? path.posix.join(session.baseDirectory, assetPath)
-        : assetPath;
-      if (!resourcePath) throw new WorkspaceFileError('preview resource path is required', 400);
-
+      const assetPath = normalizePreviewAssetPath(req.params[0] || "");
+      const resourcePath = scope === "base" ? path.posix.join(session.baseDirectory, assetPath) : assetPath;
+      if (!resourcePath) throw new import_workspace_file_service.WorkspaceFileError("preview resource path is required", 400);
       const absoluteTarget = realPathIfPresent(path.resolve(session.workspaceRoot, resourcePath));
       if (!isSameOrDescendantPath(session.authorizedRoot, absoluteTarget)) {
-        throw new WorkspaceFileError('preview path must stay inside the authorized root', 403);
+        throw new import_workspace_file_service.WorkspaceFileError("preview path must stay inside the authorized root", 403);
       }
-
       const file = await fileService.readResourceFile(session.workspaceRoot, resourcePath, {
-        allowedExternalRoots: [],
+        allowedExternalRoots: []
       });
       const isHtml = /\.html?$/i.test(file.path);
-      const body = isHtml
-        ? Buffer.from(rewritePreviewHtmlRootReferences(
-          file.buffer.toString('utf8'),
-          `${req.baseUrl}/previews/${encodeURIComponent(session.id)}/root/`,
-        ))
-        : file.buffer;
-      res
-        .status(200)
-        .type(path.extname(file.path) || 'application/octet-stream')
-        .set('Cache-Control', 'no-store')
-        .set('X-Content-Type-Options', 'nosniff')
-        .set('Content-Length', String(body.length));
-      if (isHtml) res.set('Content-Security-Policy', previewContentSecurityPolicy());
+      const body = isHtml ? Buffer.from(rewritePreviewHtmlRootReferences(
+        file.buffer.toString("utf8"),
+        `${req.baseUrl}/previews/${encodeURIComponent(session.id)}/root/`
+      )) : file.buffer;
+      res.status(200).type(path.extname(file.path) || "application/octet-stream").set("Cache-Control", "no-store").set("X-Content-Type-Options", "nosniff").set("Content-Length", String(body.length));
+      if (isHtml) res.set("Content-Security-Policy", previewContentSecurityPolicy());
       res.send(body);
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.delete('/previews/:sessionId', (req, res) => {
+  router.delete("/previews/:sessionId", (req, res) => {
     const deleted = previewSessions.delete(req.params.sessionId);
     res.status(deleted ? 204 : 404).end();
   });
-
-  router.put('/file', async (req, res) => {
+  router.put("/file", async (req, res) => {
     try {
       const body = req.body || {};
       const rootRef = workspaceRef(body);
       assertWritableWorkspaceAgent(rootRef);
-      const { root, rootId } = resolveRequestRoot(body);
-      const file = await fileService.writeFile(root, body.path || '', body.content, {
+      const { kind, root, rootId } = resolveRequestRoot(body);
+      if (kind === "agent-home") await fs.promises.mkdir(root, { recursive: true });
+      const file = await fileService.writeFile(root, body.path || "", body.content, {
         baseSha1: body.baseSha1,
-        overwrite: body.overwrite === true,
+        overwrite: body.overwrite === true
       });
       res.json({ rootId, root, file });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.post('/move', async (req, res) => {
+  router.post("/move", async (req, res) => {
     try {
       const body = req.body || {};
       const rootRef = workspaceRef(body);
       assertWritableWorkspaceAgent(rootRef);
       const { root, rootId } = resolveRequestRoot(body);
-      const move = await fileService.moveEntry(root, body.sourcePath || '', body.targetDirectory || '', {
-        expectedVersion: body.expectedVersion,
+      const move = await fileService.moveEntry(root, body.sourcePath || "", body.targetDirectory || "", {
+        expectedVersion: body.expectedVersion
       });
       res.json({ rootId, root, move });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.post('/entry', async (req, res) => {
+  router.post("/entry", async (req, res) => {
     try {
       const body = req.body || {};
       const rootRef = workspaceRef(body);
       assertWritableWorkspaceAgent(rootRef);
       const { root, rootId } = resolveRequestRoot(body);
-      const created = await fileService.createEntry(root, body.parentPath || '', body.name || '', body.entryType || 'file', body.content || '');
+      const created = await fileService.createEntry(root, body.parentPath || "", body.name || "", body.entryType || "file", body.content || "");
       res.status(201).json({ rootId, root, ...created });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.patch('/entry', async (req, res) => {
+  router.patch("/entry", async (req, res) => {
     try {
       const body = req.body || {};
       const rootRef = workspaceRef(body);
       assertWritableWorkspaceAgent(rootRef);
       const { root, rootId } = resolveRequestRoot(body);
-      const move = await fileService.renameEntry(root, body.path || '', body.name || '', {
-        expectedVersion: body.expectedVersion,
+      const move = await fileService.renameEntry(root, body.path || "", body.name || "", {
+        expectedVersion: body.expectedVersion
       });
       res.json({ rootId, root, move });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.delete('/entry', async (req, res) => {
+  router.delete("/entry", async (req, res) => {
     try {
       const body = req.body || {};
       const rootRef = workspaceRef(body) || workspaceRef(req.query);
-      const targetPath = body.path || req.query.path || '';
+      const targetPath = body.path || req.query.path || "";
       assertWritableWorkspaceAgent(rootRef);
       const workspaceRoot = rootRegistry.resolve(rootRef);
       const { canonicalPath: root, rootId } = workspaceRoot;
       const deleted = await fileService.deleteEntry(root, targetPath, {
-        expectedVersion: body.expectedVersion || req.query.expectedVersion,
+        expectedVersion: body.expectedVersion || req.query.expectedVersion
       });
       res.json({ rootId, root, deleted });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/search', async (req, res) => {
+  router.get("/search", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '');
+        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || "");
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const settings = agentManager?.configManager?.getSettings?.() || {};
-      const results = await fileService.search(root, req.query.q || '', {
-        includeIgnored: req.query.includeIgnored === 'true',
-        path: req.query.path || '',
+      const results = await fileService.search(root, req.query.q || "", {
+        includeIgnored: req.query.includeIgnored === "true",
+        path: req.query.path || "",
         limit: req.query.limit,
-        timeoutMs: settings.searchTimeoutMs,
+        timeoutMs: settings.searchTimeoutMs
       });
       res.json({ rootId, root, results });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/diff', async (req, res) => {
+  router.get("/diff", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '', { allowMissing: true });
+        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || "", { allowMissing: true });
       }
       const { root, rootId } = resolveRequestRoot(req.query);
-      const diff = await fileService.diff(root, req.query.path || '');
+      const diff = await fileService.diff(root, req.query.path || "");
       res.json({ rootId, root, diff });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/changes', async (req, res) => {
+  router.get("/changes", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        throw new WorkspaceFileError('global files do not support workspace changes', 403);
+        throw new import_workspace_file_service.WorkspaceFileError("global files do not support workspace changes", 403);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const changes = await fileService.changes(root, {
-        limit: req.query.limit,
+        limit: req.query.limit
       });
       res.json({ rootId, root, changes });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/branch', async (req, res) => {
+  router.get("/branch", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        throw new WorkspaceFileError('global files do not support git branches', 403);
+        throw new import_workspace_file_service.WorkspaceFileError("global files do not support git branches", 403);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const branch = await fileService.gitBranch(root);
@@ -567,62 +509,57 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/worktrees', async (req, res) => {
+  router.get("/worktrees", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        throw new WorkspaceFileError('global files do not support git worktrees', 403);
+        throw new import_workspace_file_service.WorkspaceFileError("global files do not support git worktrees", 403);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
-      const info = await inspectGitWorktree(root, { cacheMs: 0 });
+      const info = await (0, import_git_worktree_info.inspectGitWorktree)(root, { cacheMs: 0 });
       res.json({
         rootId,
         root,
-        worktrees: info
-          ? {
-            isGitRepo: true,
-            commonDir: info.commonDir,
-            currentWorkspace: info.workspace,
-            mainWorkspace: info.mainWorkspace,
-            items: info.worktrees,
-          }
-          : {
-            isGitRepo: false,
-            commonDir: '',
-            currentWorkspace: root,
-            mainWorkspace: '',
-            items: [],
-          },
+        worktrees: info ? {
+          isGitRepo: true,
+          commonDir: info.commonDir,
+          currentWorkspace: info.workspace,
+          mainWorkspace: info.mainWorkspace,
+          items: info.worktrees
+        } : {
+          isGitRepo: false,
+          commonDir: "",
+          currentWorkspace: root,
+          mainWorkspace: "",
+          items: []
+        }
       });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/history', async (req, res) => {
+  router.get("/history", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        throw new WorkspaceFileError('global files do not support git history', 403);
+        throw new import_workspace_file_service.WorkspaceFileError("global files do not support git history", 403);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const history = await fileService.gitHistory(root, {
         limit: req.query.limit,
         skip: req.query.skip,
-        scope: req.query.scope,
+        scope: req.query.scope
       });
       res.json({ rootId, root, history });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/history/changes', async (req, res) => {
+  router.get("/history/changes", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        throw new WorkspaceFileError('global files do not support git history', 403);
+        throw new import_workspace_file_service.WorkspaceFileError("global files do not support git history", 403);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const changes = await fileService.gitHistoryChanges(
@@ -636,50 +573,47 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/line-changes', async (req, res) => {
+  router.get("/line-changes", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '');
+        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || "");
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const changes = await fileService.lineChanges(
         root,
-        req.query.path || '',
+        req.query.path || "",
         req.query.lineNumber,
-        req.query.mode || 'working'
+        req.query.mode || "working"
       );
       res.json({ rootId, root, changes });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/blame', async (req, res) => {
+  router.get("/blame", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '');
+        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || "");
       }
       const { root, rootId } = resolveRequestRoot(req.query);
-      const blame = await fileService.blame(root, req.query.path || '');
+      const blame = await fileService.blame(root, req.query.path || "");
       res.json({ rootId, root, blame });
     } catch (error) {
       sendWorkspaceFileError(res, error);
     }
   });
-
-  router.get('/blame-capability', async (req, res) => {
+  router.get("/blame-capability", async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
       if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '');
+        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || "");
       }
       const { root, rootId } = resolveRequestRoot(req.query);
       const capability = await fileService.blameCapability(
         root,
-        req.query.path || '',
+        req.query.path || "",
         readOptionsForAgent(agentManager, rootRef)
       );
       res.json({ rootId, root, capability });
@@ -687,22 +621,19 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
       sendWorkspaceFileError(res, error);
     }
   });
-
   return router;
 }
-
-module.exports = {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   GLOBAL_WORKSPACE_FILES_AGENT_ID,
   GLOBAL_WORKSPACE_FILES_ROOT,
   PROJECT_FILES_WORKSPACE_PREFIX,
-  PROJECT_FILES_AGENT_PREFIX: PROJECT_FILES_WORKSPACE_PREFIX,
-  assertGlobalWorkspacePathAllowed,
   assertExactExternalFileReadable,
+  assertGlobalWorkspacePathAllowed,
   createWorkspaceFileRouter,
   globalWorkspaceAllowedRoots,
   isGlobalWorkspaceFilesAgentId,
   projectWorkspaceFromFilesId,
-  projectWorkspaceFromFilesAgentId: projectWorkspaceFromFilesId,
   resolveWorkspaceRoot,
-  sendWorkspaceFileError,
-};
+  sendWorkspaceFileError
+});