@ricsam/r5d-worker 0.0.29 → 0.0.31

package/dist/cjs/main.cjs

@@ -31,11 +31,17 @@ var main_exports = {};
 __export(main_exports, {
   ensureVisibleGitCheckout: () => ensureVisibleGitCheckout,
   findRepositorySyncBlockers: () => findRepositorySyncBlockers,
+  findWorkerFiles: () => findWorkerFiles,
+  grepWorkerFiles: () => grepWorkerFiles,
   isArtifactEnvPath: () => isArtifactEnvPath,
+  listWorkerDirectory: () => listWorkerDirectory,
   prepareArtifactEnvForShell: () => prepareArtifactEnvForShell,
   preparePlanEnvForShell: () => preparePlanEnvForShell,
+  readWorkerImageFile: () => readWorkerImageFile,
+  readWorkerTextFile: () => readWorkerTextFile,
   resolveHostShell: () => resolveHostShell,
   resolveProjectFilePath: () => resolveProjectFilePath,
+  resolveWorkerFilePath: () => resolveWorkerFilePath,
   syncManifestProjectsFromInternal: () => syncManifestProjectsFromInternal,
   syncProjectPlans: () => syncProjectPlans,
   syncSessionArtifacts: () => syncSessionArtifacts
@@ -49,6 +55,7 @@ var import_node_child_process = require("node:child_process");
 var import_cli_update = require("./cli-update.cjs");
 var import_git_identity = require("./git-identity.cjs");
 var import_heartbeat = require("./heartbeat.cjs");
+var import_process_tree = require("./process-tree.cjs");
 var import_supervisor = require("./supervisor.cjs");
 const import_meta = {};
 const DEFAULT_BASE_URL = "https://r5d.dev";
@@ -705,36 +712,69 @@ function isInsideBranchPath(branchPath, filePath) {
   const relative = import_node_path.default.relative(import_node_path.default.resolve(branchPath), import_node_path.default.resolve(filePath));
   return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative);
 }
-function assertInsideBranch(branchPath, filePath) {
-  if (!isInsideBranchPath(branchPath, filePath)) {
-    throw new Error("File path escapes the project branch");
+function toProjectDisplayPath(branchPath, absolutePath) {
+  const relative = import_node_path.default.relative(import_node_path.default.resolve(branchPath), import_node_path.default.resolve(absolutePath)).split(import_node_path.default.sep).join(import_node_path.default.posix.sep);
+  return relative || ".";
+}
+function assertAllowedProjectPath(repoRelativePath, inputPath) {
+  if (repoRelativePath === ".git" || repoRelativePath.startsWith(".git/")) {
+    throw new Error("Refusing to access .git through worker file tools");
+  }
+  if (repoRelativePath.split("/").includes("..")) {
+    throw new Error(`Invalid project file path: ${inputPath}`);
   }
 }
-function resolveProjectFilePath(branchPath, virtualPath) {
-  if (typeof virtualPath !== "string" || !virtualPath.startsWith("/") || virtualPath.includes("\0")) {
-    throw new Error(`File path must be an absolute project path starting with /. Got: ${JSON.stringify(virtualPath)}`);
+function resolveWorkerFilePath(branchPath, inputPath) {
+  if (typeof inputPath !== "string" || inputPath.length === 0 || inputPath.includes("\0")) {
+    throw new Error(`File path must be a non-empty string. Got: ${JSON.stringify(inputPath)}`);
   }
-  const checkoutAbsolutePath = import_node_path.default.resolve(virtualPath);
-  if (isInsideBranchPath(branchPath, checkoutAbsolutePath)) {
-    const checkoutVirtualPath = toVirtualPath(import_node_path.default.resolve(branchPath), checkoutAbsolutePath);
-    if (checkoutVirtualPath !== virtualPath) {
-      return resolveProjectFilePath(branchPath, checkoutVirtualPath);
+  const resolvedBranchPath = import_node_path.default.resolve(branchPath);
+  if (import_node_path.default.isAbsolute(inputPath)) {
+    const absolutePath2 = import_node_path.default.resolve(inputPath);
+    if (!isInsideBranchPath(resolvedBranchPath, absolutePath2)) {
+      return {
+        absolutePath: absolutePath2,
+        displayPath: absolutePath2,
+        repoRelativePath: null,
+        scope: "host"
+      };
     }
+    const displayPath = toProjectDisplayPath(resolvedBranchPath, absolutePath2);
+    const repoRelativePath2 = displayPath === "." ? "" : displayPath;
+    assertAllowedProjectPath(repoRelativePath2, inputPath);
+    return {
+      absolutePath: absolutePath2,
+      displayPath,
+      repoRelativePath: repoRelativePath2,
+      scope: "project"
+    };
   }
-  if (virtualPath.split("/").includes("..")) {
-    throw new Error(`Invalid project file path: ${virtualPath}`);
+  const normalizedInputPath = inputPath.replace(/\\/g, "/");
+  if (normalizedInputPath.split("/").includes("..")) {
+    throw new Error(`Invalid project file path: ${inputPath}`);
   }
-  const normalized = import_node_path.default.posix.normalize(virtualPath);
-  if (normalized.startsWith("/../")) {
-    throw new Error(`Invalid project file path: ${virtualPath}`);
+  const normalized = import_node_path.default.posix.normalize(normalizedInputPath);
+  const repoRelativePath = normalized === "." ? "" : normalized.replace(/^\.\/+/, "");
+  assertAllowedProjectPath(repoRelativePath, inputPath);
+  const absolutePath = repoRelativePath ? import_node_path.default.resolve(resolvedBranchPath, ...repoRelativePath.split("/")) : resolvedBranchPath;
+  if (!isInsideBranchPath(resolvedBranchPath, absolutePath)) {
+    throw new Error(`Invalid project file path: ${inputPath}`);
   }
-  const repoRelativePath = normalized === "/" ? "" : normalized.slice(1);
-  if (repoRelativePath === ".git" || repoRelativePath.startsWith(".git/")) {
-    throw new Error("Refusing to access .git through worker file tools");
+  return {
+    absolutePath,
+    displayPath: repoRelativePath || ".",
+    repoRelativePath,
+    scope: "project"
+  };
+}
+function resolveProjectFilePath(branchPath, inputPath) {
+  const resolved = resolveWorkerFilePath(branchPath, inputPath);
+  if (resolved.scope === "host") {
+    throw new Error(
+      `Project file writes must use a checkout-relative path. Absolute host paths are read-only in file tools: ${inputPath}`
+    );
   }
-  const absolutePath = repoRelativePath ? import_node_path.default.resolve(branchPath, ...repoRelativePath.split("/")) : import_node_path.default.resolve(branchPath);
-  assertInsideBranch(branchPath, absolutePath);
-  return { absolutePath, virtualPath: repoRelativePath ? `/${repoRelativePath}` : "/", repoRelativePath };
+  return resolved;
 }
 function resolveRemoteUrl(baseUrl, remoteUrl) {
   if (/^https?:\/\//i.test(remoteUrl)) {
@@ -1348,6 +1388,21 @@ async function withFileMutationQueue(key, operation) {
 function mutationQueueKey(projectId, branchName, filePath) {
   return `${projectId}:${branchName}:${import_node_path.default.posix.normalize(filePath)}`;
 }
+function readWorkerTextFile(branchPath, filePath, offset, limit) {
+  const resolved = resolveWorkerFilePath(branchPath, filePath);
+  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
+    throw new Error(`File not found: ${resolved.displayPath}`);
+  }
+  const buffer = import_node_fs.default.readFileSync(resolved.absolutePath);
+  const formatted = formatLineNumberedContent(buffer.toString("utf8"), offset, limit);
+  return {
+    type: "read",
+    kind: "text",
+    file: resolved.displayPath,
+    gitBlobHash: getGitBlobHashForContent(buffer),
+    ...formatted
+  };
+}
 async function executeReadFileOperation(input) {
   const artifact = await resolveArtifactEnvFilePath({
     filePath: input.message.filePath,
@@ -1362,55 +1417,43 @@ async function executeReadFileOperation(input) {
     if (!import_node_fs.default.existsSync(artifact.absolutePath) || !import_node_fs.default.statSync(artifact.absolutePath).isFile()) {
       throw new Error(`File not found: ${artifact.virtualPath}`);
     }
-    const buffer2 = import_node_fs.default.readFileSync(artifact.absolutePath);
-    const formatted2 = formatLineNumberedContent(buffer2.toString("utf8"), input.message.offset, input.message.limit);
+    const buffer = import_node_fs.default.readFileSync(artifact.absolutePath);
+    const formatted = formatLineNumberedContent(buffer.toString("utf8"), input.message.offset, input.message.limit);
     return {
       type: "read",
       kind: "text",
       file: artifact.virtualPath,
-      gitBlobHash: getGitBlobHashForContent(buffer2),
-      ...formatted2
+      gitBlobHash: getGitBlobHashForContent(buffer),
+      ...formatted
     };
   }
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
-  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
-    throw new Error(`File not found: ${resolved.virtualPath}`);
-  }
-  const buffer = import_node_fs.default.readFileSync(resolved.absolutePath);
-  const formatted = formatLineNumberedContent(buffer.toString("utf8"), input.message.offset, input.message.limit);
-  return {
-    type: "read",
-    kind: "text",
-    file: resolved.virtualPath,
-    gitBlobHash: getGitBlobHashForContent(buffer),
-    ...formatted
-  };
+  return readWorkerTextFile(workspace.branchPath, input.message.filePath, input.message.offset, input.message.limit);
 }
 async function executeWriteFileOperation(input) {
   rejectArtifactWritePath(input.message.filePath);
-  return withFileMutationQueue(mutationQueueKey(input.projectId, input.message.branchName, input.message.filePath), async () => {
-    const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-    const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
+  return withFileMutationQueue(mutationQueueKey(input.projectId, input.message.branchName, resolved.repoRelativePath), async () => {
     import_node_fs.default.mkdirSync(import_node_path.default.dirname(resolved.absolutePath), { recursive: true });
     import_node_fs.default.writeFileSync(resolved.absolutePath, input.message.content, "utf8");
     return {
       type: "write",
-      file: resolved.virtualPath,
+      file: resolved.displayPath,
       gitBlobHash: getGitBlobHashForContent(input.message.content)
     };
   });
 }
 async function executeEditFileOperation(input) {
   rejectArtifactWritePath(input.message.filePath);
-  return withFileMutationQueue(mutationQueueKey(input.projectId, input.message.branchName, input.message.filePath), async () => {
-    const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-    const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
+  return withFileMutationQueue(mutationQueueKey(input.projectId, input.message.branchName, resolved.repoRelativePath), async () => {
     if (!Array.isArray(input.message.edits) || input.message.edits.length === 0) {
       throw new Error("edit requires at least one replacement");
     }
     if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
-      throw new Error(`File not found: ${resolved.virtualPath}`);
+      throw new Error(`File not found: ${resolved.displayPath}`);
     }
     const originalContent = import_node_fs.default.readFileSync(resolved.absolutePath, "utf8");
     const ranges = input.message.edits.map((edit, index) => {
@@ -1445,7 +1488,7 @@ async function executeEditFileOperation(input) {
     import_node_fs.default.writeFileSync(resolved.absolutePath, nextContent, "utf8");
     return {
       type: "edit",
-      file: resolved.virtualPath,
+      file: resolved.displayPath,
       edits: input.message.edits.length
     };
   });
@@ -1465,47 +1508,70 @@ function wildcardToRegex(pattern) {
 function normalizeFindPattern(pattern) {
   return /[*?]/.test(pattern) ? pattern : `*${pattern}*`;
 }
-function toVirtualPath(branchPath, absolutePath) {
-  const relative = import_node_path.default.relative(branchPath, absolutePath).split(import_node_path.default.sep).join(import_node_path.default.posix.sep);
-  return relative ? `/${relative}` : "/";
-}
-function walkProjectEntries(branchPath, startPath) {
+function walkWorkerEntries(branchPath, start) {
   const entries = [];
-  const visit = (absolutePath) => {
-    const stat = import_node_fs.default.statSync(absolutePath);
-    const virtualPath = toVirtualPath(branchPath, absolutePath);
-    entries.push({ absolutePath, virtualPath, stat });
+  const visitedDirectories = /* @__PURE__ */ new Set();
+  const visit = (absolutePath, isRoot) => {
+    let stat;
+    try {
+      stat = import_node_fs.default.statSync(absolutePath);
+    } catch (error) {
+      if (isRoot) throw error;
+      return;
+    }
+    const displayPath = start.scope === "project" ? toProjectDisplayPath(branchPath, absolutePath) : import_node_path.default.resolve(absolutePath);
+    const hostRelativePath = import_node_path.default.relative(start.absolutePath, absolutePath).split(import_node_path.default.sep).join(import_node_path.default.posix.sep);
+    const matchPath = start.scope === "project" ? displayPath : hostRelativePath || import_node_path.default.basename(start.absolutePath);
+    entries.push({ absolutePath, displayPath, matchPath, stat });
     if (!stat.isDirectory()) return;
-    const children = import_node_fs.default.readdirSync(absolutePath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    let realDirectoryPath;
+    try {
+      realDirectoryPath = import_node_fs.default.realpathSync(absolutePath);
+    } catch (error) {
+      if (isRoot) throw error;
+      return;
+    }
+    if (visitedDirectories.has(realDirectoryPath)) return;
+    visitedDirectories.add(realDirectoryPath);
+    let children;
+    try {
+      children = import_node_fs.default.readdirSync(absolutePath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      if (isRoot) throw error;
+      return;
+    }
     for (const child of children) {
       if (IGNORED_ENTRY_NAMES.has(child.name)) continue;
-      visit(import_node_path.default.join(absolutePath, child.name));
+      visit(import_node_path.default.join(absolutePath, child.name), false);
     }
   };
-  visit(startPath);
+  visit(start.absolutePath, true);
   return entries;
 }
 function isProbablyText(bytes) {
   return !bytes.subarray(0, Math.min(bytes.length, 4096)).includes(0);
 }
-async function executeGrepOperation(input) {
-  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const start = resolveProjectFilePath(workspace.branchPath, input.message.path ?? "/");
+function grepWorkerFiles(branchPath, input) {
+  const start = resolveWorkerFilePath(branchPath, input.path ?? ".");
   if (!import_node_fs.default.existsSync(start.absolutePath)) {
-    throw new Error(`Path not found: ${start.virtualPath}`);
+    throw new Error(`Path not found: ${start.displayPath}`);
   }
-  const limit = normalizeToolLimit(input.message.limit, 100, 1e3);
-  const flags = input.message.caseSensitive === false ? "i" : "";
-  const regex = new RegExp(input.message.pattern, flags);
-  const globRegex = input.message.glob ? wildcardToRegex(input.message.glob) : null;
+  const limit = normalizeToolLimit(input.limit, 100, 1e3);
+  const flags = input.caseSensitive === false ? "i" : "";
+  const regex = new RegExp(input.pattern, flags);
+  const globRegex = input.glob ? wildcardToRegex(input.glob) : null;
   const lines = [];
   let matchCount = 0;
   let truncated = false;
-  for (const entry of walkProjectEntries(workspace.branchPath, start.absolutePath)) {
+  for (const entry of walkWorkerEntries(branchPath, start)) {
     if (!entry.stat.isFile()) continue;
-    const repoRelative = entry.virtualPath.slice(1);
-    if (globRegex && !globRegex.test(repoRelative)) continue;
-    const bytes = import_node_fs.default.readFileSync(entry.absolutePath);
+    if (globRegex && !globRegex.test(entry.matchPath)) continue;
+    let bytes;
+    try {
+      bytes = import_node_fs.default.readFileSync(entry.absolutePath);
+    } catch {
+      continue;
+    }
     if (!isProbablyText(bytes)) continue;
     const fileLines = bytes.toString("utf8").split(/\r?\n/);
     for (let index = 0; index < fileLines.length; index += 1) {
@@ -1516,7 +1582,7 @@ async function executeGrepOperation(input) {
       matchCount += 1;
       if (lines.length < limit) {
         const column = Math.max(1, (match.index ?? 0) + 1);
-        lines.push(`${entry.virtualPath}:${index + 1}:${column}: ${line.slice(0, MAX_LINE_LENGTH)}`);
+        lines.push(`${entry.displayPath}:${index + 1}:${column}: ${line.slice(0, MAX_LINE_LENGTH)}`);
       } else {
         truncated = true;
       }
@@ -1531,26 +1597,35 @@ async function executeGrepOperation(input) {
     truncated
   };
 }
-async function executeFindOperation(input) {
+async function executeGrepOperation(input) {
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const start = resolveProjectFilePath(workspace.branchPath, input.message.path ?? "/");
+  return grepWorkerFiles(workspace.branchPath, {
+    pattern: input.message.pattern,
+    path: input.message.path,
+    glob: input.message.glob,
+    caseSensitive: input.message.caseSensitive,
+    limit: input.message.limit
+  });
+}
+function findWorkerFiles(branchPath, input) {
+  const start = resolveWorkerFilePath(branchPath, input.path ?? ".");
   if (!import_node_fs.default.existsSync(start.absolutePath) || !import_node_fs.default.statSync(start.absolutePath).isDirectory()) {
-    throw new Error(`Directory not found: ${start.virtualPath}`);
+    throw new Error(`Directory not found: ${start.displayPath}`);
   }
-  const pattern = normalizeFindPattern(input.message.pattern ?? "*");
+  const pattern = normalizeFindPattern(input.pattern ?? "*");
   const matcher = wildcardToRegex(pattern);
-  const entryType = input.message.entryType ?? "file";
-  const limit = normalizeToolLimit(input.message.limit, 200, 1e3);
+  const entryType = input.entryType ?? "file";
+  const limit = normalizeToolLimit(input.limit, 200, 1e3);
   const matches = [];
   let count = 0;
   let truncated = false;
-  for (const entry of walkProjectEntries(workspace.branchPath, start.absolutePath)) {
-    if (entry.virtualPath === start.virtualPath) continue;
+  for (const entry of walkWorkerEntries(branchPath, start)) {
+    if (entry.absolutePath === start.absolutePath) continue;
     const isDirectory = entry.stat.isDirectory();
     if (entryType === "file" && !entry.stat.isFile()) continue;
     if (entryType === "directory" && !isDirectory) continue;
-    const label = isDirectory ? `${entry.virtualPath}/` : entry.virtualPath;
-    if (!matcher.test(import_node_path.default.posix.basename(entry.virtualPath)) && !matcher.test(entry.virtualPath.slice(1))) continue;
+    const label = isDirectory ? `${entry.displayPath}${start.scope === "host" ? import_node_path.default.sep : "/"}` : entry.displayPath;
+    if (!matcher.test(import_node_path.default.basename(entry.absolutePath)) && !matcher.test(entry.matchPath)) continue;
     count += 1;
     if (matches.length < limit) {
       matches.push(label);
@@ -1566,25 +1641,59 @@ async function executeFindOperation(input) {
     truncated
   };
 }
-async function executeLsOperation(input) {
+async function executeFindOperation(input) {
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.path ?? "/");
+  return findWorkerFiles(workspace.branchPath, {
+    pattern: input.message.pattern,
+    path: input.message.path,
+    entryType: input.message.entryType,
+    limit: input.message.limit
+  });
+}
+function listWorkerDirectory(branchPath, inputPath = ".", inputLimit) {
+  const resolved = resolveWorkerFilePath(branchPath, inputPath);
   if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isDirectory()) {
-    throw new Error(`Directory not found: ${resolved.virtualPath}`);
+    throw new Error(`Directory not found: ${resolved.displayPath}`);
   }
-  const limit = normalizeToolLimit(input.message.limit, 200, 1e3);
+  const limit = normalizeToolLimit(inputLimit, 200, 1e3);
   const entries = import_node_fs.default.readdirSync(resolved.absolutePath, { withFileTypes: true }).filter((entry) => !IGNORED_ENTRY_NAMES.has(entry.name)).sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
   const displayed = entries.slice(0, limit).map((entry) => `${entry.name}${entry.isDirectory() ? "/" : ""}`);
   const truncated = entries.length > displayed.length;
   const hint = truncated ? "\n... truncated. Increase limit to continue." : "";
   return {
     type: "ls",
-    path: resolved.virtualPath,
+    path: resolved.displayPath,
     content: displayed.length > 0 ? `${displayed.join("\n")}${hint}` : "(empty directory)",
     count: entries.length,
     truncated
   };
 }
+async function executeLsOperation(input) {
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  return listWorkerDirectory(workspace.branchPath, input.message.path, input.message.limit);
+}
+function readWorkerImageFile(branchPath, filePath) {
+  const resolved = resolveWorkerFilePath(branchPath, filePath);
+  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
+    throw new Error(`File not found: ${resolved.displayPath}`);
+  }
+  const extension = import_node_path.default.extname(resolved.absolutePath).toLowerCase();
+  const mediaType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : null;
+  if (!mediaType) {
+    throw new Error("read supports PNG and JPEG image inputs only");
+  }
+  const bytes = import_node_fs.default.readFileSync(resolved.absolutePath);
+  const dimensions = readImageDimensions(bytes, mediaType);
+  return {
+    type: "view_file_bytes",
+    filePath: resolved.displayPath,
+    mediaType,
+    base64: bytes.toString("base64"),
+    fileSizeBytes: bytes.length,
+    width: dimensions.width,
+    height: dimensions.height
+  };
+}
 async function executeViewFileBytesOperation(input) {
   const artifact = await resolveArtifactEnvFilePath({
     filePath: input.message.filePath,
@@ -1599,44 +1708,25 @@ async function executeViewFileBytesOperation(input) {
     if (!import_node_fs.default.existsSync(artifact.absolutePath) || !import_node_fs.default.statSync(artifact.absolutePath).isFile()) {
       throw new Error(`File not found: ${artifact.virtualPath}`);
     }
-    const extension2 = import_node_path.default.extname(artifact.absolutePath).toLowerCase();
-    const mediaType2 = extension2 === ".jpg" || extension2 === ".jpeg" ? "image/jpeg" : extension2 === ".png" ? "image/png" : null;
-    if (!mediaType2) {
+    const extension = import_node_path.default.extname(artifact.absolutePath).toLowerCase();
+    const mediaType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : null;
+    if (!mediaType) {
       throw new Error("read supports PNG and JPEG image inputs only");
     }
-    const bytes2 = import_node_fs.default.readFileSync(artifact.absolutePath);
-    const dimensions2 = readImageDimensions(bytes2, mediaType2);
+    const bytes = import_node_fs.default.readFileSync(artifact.absolutePath);
+    const dimensions = readImageDimensions(bytes, mediaType);
     return {
       type: "view_file_bytes",
       filePath: artifact.virtualPath,
-      mediaType: mediaType2,
-      base64: bytes2.toString("base64"),
-      fileSizeBytes: bytes2.length,
-      width: dimensions2.width,
-      height: dimensions2.height
+      mediaType,
+      base64: bytes.toString("base64"),
+      fileSizeBytes: bytes.length,
+      width: dimensions.width,
+      height: dimensions.height
     };
   }
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
-  if (!import_node_fs.default.existsSync(resolved.absolutePath) || !import_node_fs.default.statSync(resolved.absolutePath).isFile()) {
-    throw new Error(`File not found: ${resolved.virtualPath}`);
-  }
-  const extension = import_node_path.default.extname(resolved.absolutePath).toLowerCase();
-  const mediaType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : null;
-  if (!mediaType) {
-    throw new Error("read supports PNG and JPEG image inputs only");
-  }
-  const bytes = import_node_fs.default.readFileSync(resolved.absolutePath);
-  const dimensions = readImageDimensions(bytes, mediaType);
-  return {
-    type: "view_file_bytes",
-    filePath: resolved.virtualPath,
-    mediaType,
-    base64: bytes.toString("base64"),
-    fileSizeBytes: bytes.length,
-    width: dimensions.width,
-    height: dimensions.height
-  };
+  return readWorkerImageFile(workspace.branchPath, input.message.filePath);
 }
 function stagedBlobSizeBytes(context) {
   const names = runInternalGit(context, ["diff", "--cached", "--name-only", "-z", "--", ".", ":(exclude).git"]).split("\0").filter(Boolean);
@@ -1817,6 +1907,7 @@ async function executeCommand(input) {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      detached: true,
       env: {
         ...process.env,
         ...containerRegistryEnv(),
@@ -1838,7 +1929,12 @@ async function executeCommand(input) {
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
-        subprocess.kill("SIGTERM");
+        void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] failed to terminate timed-out command ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+        });
       }, input.message.timeoutMs);
     }
     const [stdout, stderr, exitCode] = await Promise.all([
@@ -1874,6 +1970,8 @@ async function executeCommand(input) {
 async function executeStreamingCommand(input) {
   const startedAt = Date.now();
   let started = false;
+  let timedOut = false;
+  let timeout;
   try {
     if (cancelledProcessRuns.delete(input.message.runId)) {
       sendWorkerMessage(input.ws, {
@@ -1914,6 +2012,7 @@ async function executeStreamingCommand(input) {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      detached: true,
       env: {
         ...process.env,
         ...containerRegistryEnv(),
@@ -1940,6 +2039,17 @@ async function executeStreamingCommand(input) {
       requestId: input.message.requestId,
       runId: input.message.runId
     });
+    if (input.message.timeoutMs) {
+      timeout = setTimeout(() => {
+        timedOut = true;
+        void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] failed to terminate timed-out process ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+        });
+      }, input.message.timeoutMs);
+    }
     const [exitCode] = await Promise.all([
       subprocess.exited,
       streamCommandOutput(subprocess.stdout, (data) => {
@@ -1963,7 +2073,8 @@ async function executeStreamingCommand(input) {
       type: "exec_exit",
       runId: input.message.runId,
       exitCode,
-      durationMs: Date.now() - startedAt
+      durationMs: Date.now() - startedAt,
+      ...timedOut ? { timedOut: true } : {}
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1983,6 +2094,9 @@ async function executeStreamingCommand(input) {
       });
     }
   } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
@@ -2545,18 +2659,27 @@ async function startWorker(options) {
       }
       if (message.type === "cancel") {
         const active = activeProcesses.get(message.runId);
+        let cancelled = true;
+        let cancelMessage;
         if (active) {
-          active.process.kill("SIGTERM");
+          try {
+            await (0, import_process_tree.terminateProcessTree)(active.process);
+            cancelMessage = `Stopped ${active.command}`;
+          } catch (error) {
+            cancelled = false;
+            cancelMessage = `Failed to stop ${active.command}: ${error instanceof Error ? error.message : String(error)}`;
+          }
         } else {
           cancelledProcessRuns.add(message.runId);
+          cancelMessage = "Cancellation queued before command start";
         }
         ws.send(
           JSON.stringify({
             type: "cancel_result",
             requestId: message.requestId,
             runId: message.runId,
-            cancelled: true,
-            message: active ? `Sent SIGTERM to ${active.command}` : "Cancellation queued before command start"
+            cancelled,
+            message: cancelMessage
           })
         );
         return;
@@ -2796,11 +2919,17 @@ if (isCliEntrypoint()) {
 0 && (module.exports = {
   ensureVisibleGitCheckout,
   findRepositorySyncBlockers,
+  findWorkerFiles,
+  grepWorkerFiles,
   isArtifactEnvPath,
+  listWorkerDirectory,
   prepareArtifactEnvForShell,
   preparePlanEnvForShell,
+  readWorkerImageFile,
+  readWorkerTextFile,
   resolveHostShell,
   resolveProjectFilePath,
+  resolveWorkerFilePath,
   syncManifestProjectsFromInternal,
   syncProjectPlans,
   syncSessionArtifacts

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "type": "commonjs"
 }