@ricsam/r5d-worker 0.0.10 → 0.0.12

package/dist/mjs/main.mjs

@@ -1,9 +1,8 @@
 #!/usr/bin/env bun
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import { hostname } from "node:os";
+import { createHash } from "node:crypto";
+import os, { hostname } from "node:os";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { configureVisibleGitIdentity } from "./git-identity.mjs";
 const DEFAULT_BASE_URL = "https://r5d.dev";
@@ -11,6 +10,7 @@ const WORKER_PACKAGE_NAME = "@ricsam/r5d-worker";
 const LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
 const BRANCH_RE = /^[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9]$|^[A-Za-z0-9]$/;
 const DEFAULT_READ_LIMIT = 2e3;
+const DEFAULT_READ_MAX_BYTES = 5e4;
 const MAX_LINE_LENGTH = 2e3;
 const MAX_SYNC_DIFF_BYTES = 5 * 1024 * 1024;
 const R5D_REMOTE_NAME = "r5d";
@@ -30,6 +30,9 @@ function defaultProjectsRoot() {
 function defaultSyncRoot() {
   return path.join(os.homedir(), ".r5d", "sync");
 }
+function defaultArtifactRoot() {
+  return path.join(os.homedir(), ".r5d", "artifacts");
+}
 function printHelp() {
   process.stdout.write(`Usage:
   r5d-worker start --label <label> [--base-url <url>] [--token <token>] [--api-key <key>]
@@ -43,6 +46,7 @@ Options:
   --config <path>       Config path (default ~/.config/r5d/r5dctl/config.json)
   --project-root <dir>  Override projects checkout root (default ~/.r5d/projects)
   --sync-root <dir>     Override r5d internal sync git root (default ~/.r5d/sync)
+  --artifact-root <dir> Override session artifact root (default from R5D_ARTIFACTS_ROOT or ~/.r5d/artifacts)
   -v, --version         Show r5d-worker version
   -h, --help            Show this help
 `);
@@ -159,6 +163,11 @@ function parseArgs(argv) {
       options.syncRoot = syncRoot;
       continue;
     }
+    const artifactRoot = readOption("--artifact-root");
+    if (artifactRoot !== void 0) {
+      options.artifactRoot = artifactRoot;
+      continue;
+    }
     rest.push(arg);
   }
   if (options.version) {
@@ -201,6 +210,170 @@ async function readResponseText(response) {
     return "";
   }
 }
+const R5D_ARTIFACTS_DIR_REF = "$R5D_ARTIFACTS_DIR";
+function validateArtifactSessionId(sessionId) {
+  if (!/^(migration-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) {
+    throw new Error(`Invalid artifact session id: ${sessionId}`);
+  }
+}
+function assertInsideRoot(rootPath, candidatePath, label) {
+  const relative = path.relative(rootPath, candidatePath);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`${label} escapes the artifact directory`);
+  }
+}
+function sessionArtifactDir(artifactRoot, sessionId) {
+  validateArtifactSessionId(sessionId);
+  return path.join(artifactRoot, sessionId);
+}
+function artifactEnv(artifactRoot, sessionId) {
+  if (!sessionId) {
+    return {};
+  }
+  return {
+    R5D_ARTIFACTS_DIR: sessionArtifactDir(artifactRoot, sessionId)
+  };
+}
+function isArtifactEnvPath(filePath) {
+  return filePath === R5D_ARTIFACTS_DIR_REF || filePath.startsWith(`${R5D_ARTIFACTS_DIR_REF}/`);
+}
+function artifactApiBasePath(projectId, branchName, sessionId) {
+  return `/preview-api/${encodeURIComponent(projectId)}/${encodeURIComponent(branchName)}/artifacts/${encodeURIComponent(sessionId)}`;
+}
+function artifactManifestUrl(baseUrl, projectId, branchName, sessionId) {
+  return new URL(artifactApiBasePath(projectId, branchName, sessionId), baseUrl);
+}
+function artifactDownloadUrl(baseUrl, projectId, branchName, sessionId, filename) {
+  return new URL(`${artifactApiBasePath(projectId, branchName, sessionId)}/${encodeURIComponent(filename)}`, baseUrl);
+}
+function sha256Path(filePath) {
+  return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+function parseSessionArtifactManifest(value) {
+  if (!value || typeof value !== "object" || !Array.isArray(value.artifacts)) {
+    throw new Error("Artifact manifest response is invalid");
+  }
+  return value.artifacts.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      throw new Error("Artifact manifest entry is invalid");
+    }
+    const artifact = entry;
+    if (typeof artifact.filename !== "string" || artifact.filename.includes("/") || artifact.filename.includes("\\")) {
+      throw new Error("Artifact manifest entry has an invalid filename");
+    }
+    if (typeof artifact.size !== "number" || !Number.isFinite(artifact.size) || artifact.size < 0) {
+      throw new Error(`Artifact manifest entry has an invalid size: ${artifact.filename}`);
+    }
+    if (typeof artifact.sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(artifact.sha256)) {
+      throw new Error(`Artifact manifest entry has an invalid sha256: ${artifact.filename}`);
+    }
+    return {
+      filename: artifact.filename,
+      size: artifact.size,
+      sha256: artifact.sha256.toLowerCase()
+    };
+  });
+}
+async function fetchSessionArtifactManifest(input) {
+  const response = await fetch(artifactManifestUrl(input.baseUrl, input.projectId, input.branchName, input.sessionId), {
+    headers: {
+      Authorization: `Bearer ${input.token}`
+    }
+  });
+  if (!response.ok) {
+    const detail = (await readResponseText(response)).trim();
+    throw new Error(`Failed to fetch artifact manifest (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+  return parseSessionArtifactManifest(await response.json());
+}
+async function downloadSessionArtifact(input) {
+  const targetDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
+  const targetPath = path.join(targetDir, input.artifact.filename);
+  assertInsideRoot(targetDir, targetPath, "Artifact path");
+  const response = await fetch(
+    artifactDownloadUrl(input.baseUrl, input.projectId, input.branchName, input.sessionId, input.artifact.filename),
+    {
+      headers: {
+        Authorization: `Bearer ${input.token}`
+      }
+    }
+  );
+  if (!response.ok) {
+    const detail = (await readResponseText(response)).trim();
+    throw new Error(`Failed to download artifact ${input.artifact.filename} (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const receivedHash = createHash("sha256").update(buffer).digest("hex");
+  if (receivedHash !== input.artifact.sha256) {
+    throw new Error(`Downloaded artifact ${input.artifact.filename} failed sha256 verification`);
+  }
+  if (buffer.length !== input.artifact.size) {
+    throw new Error(`Downloaded artifact ${input.artifact.filename} has unexpected size`);
+  }
+  const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, buffer);
+  fs.renameSync(tempPath, targetPath);
+}
+async function syncSessionArtifacts(input) {
+  const targetDir = sessionArtifactDir(input.artifactRoot, input.sessionId);
+  fs.mkdirSync(targetDir, { recursive: true });
+  const artifacts = await fetchSessionArtifactManifest(input);
+  const manifestNames = new Set(artifacts.map((artifact) => artifact.filename));
+  for (const artifact of artifacts) {
+    const localPath = path.join(targetDir, artifact.filename);
+    assertInsideRoot(targetDir, localPath, "Artifact path");
+    if (fs.existsSync(localPath)) {
+      const stats = fs.statSync(localPath);
+      if (stats.isFile() && stats.size === artifact.size && sha256Path(localPath) === artifact.sha256) {
+        continue;
+      }
+      fs.rmSync(localPath, { recursive: true, force: true });
+    }
+    await downloadSessionArtifact({ ...input, artifact });
+  }
+  for (const localName of fs.readdirSync(targetDir)) {
+    if (!manifestNames.has(localName)) {
+      const localPath = path.join(targetDir, localName);
+      assertInsideRoot(targetDir, localPath, "Artifact path");
+      fs.rmSync(localPath, { recursive: true, force: true });
+    }
+  }
+  return targetDir;
+}
+async function resolveArtifactEnvFilePath(input) {
+  if (!isArtifactEnvPath(input.filePath)) {
+    return null;
+  }
+  if (!input.sessionId) {
+    throw new Error(`${R5D_ARTIFACTS_DIR_REF} paths require an active chat session`);
+  }
+  if (!input.filePath.startsWith(`${R5D_ARTIFACTS_DIR_REF}/`)) {
+    throw new Error(`Artifact path must reference a file under ${R5D_ARTIFACTS_DIR_REF}/`);
+  }
+  const targetDir = await syncSessionArtifacts({
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.branchName,
+    sessionId: input.sessionId,
+    artifactRoot: input.artifactRoot
+  });
+  const relativePath = path.posix.normalize(input.filePath.slice(`${R5D_ARTIFACTS_DIR_REF}/`.length));
+  if (!relativePath || relativePath === "." || relativePath.startsWith("../") || relativePath.includes("\0")) {
+    throw new Error(`Invalid artifact path: ${input.filePath}`);
+  }
+  const absolutePath = path.resolve(targetDir, ...relativePath.split("/"));
+  assertInsideRoot(targetDir, absolutePath, "Artifact path");
+  return {
+    absolutePath,
+    virtualPath: `${R5D_ARTIFACTS_DIR_REF}/${relativePath}`
+  };
+}
+function rejectArtifactWritePath(filePath) {
+  if (isArtifactEnvPath(filePath)) {
+    throw new Error(`${R5D_ARTIFACTS_DIR_REF} attachments are read-only. Copy them into a project path before editing or creating files.`);
+  }
+}
 async function verifyR5dctlAuth(baseUrl, token) {
   const statusUrl = new URL("/api/r5dctl/auth/status", baseUrl);
   let response;
@@ -712,16 +885,36 @@ function formatLineNumberedContent(content, offset, limit) {
   const endLine = Math.min(startLine + readLimit - 1, totalLines);
   const selectedLines = allLines.slice(startLine - 1, endLine);
   const padWidth = String(endLine).length;
-  const formattedLines = selectedLines.map((line, index) => {
+  const formattedLines = [];
+  let actualEndLine = endLine;
+  let budgetTruncated = false;
+  for (let index = 0; index < selectedLines.length; index += 1) {
+    const line = selectedLines[index] ?? "";
     const lineNumber = startLine + index;
     const truncatedLine = line.length > MAX_LINE_LENGTH ? `${line.slice(0, MAX_LINE_LENGTH)}...` : line;
-    return `${String(lineNumber).padStart(padWidth, " ")}\u2192${truncatedLine}`;
-  });
+    const formattedLine = `${String(lineNumber).padStart(padWidth, " ")}\u2192${truncatedLine}`;
+    const candidateLength = formattedLines.length === 0 ? formattedLine.length : formattedLine.length + 1;
+    const currentLength = formattedLines.join("\n").length;
+    if (currentLength + candidateLength > DEFAULT_READ_MAX_BYTES) {
+      budgetTruncated = true;
+      break;
+    }
+    formattedLines.push(formattedLine);
+    actualEndLine = lineNumber;
+  }
+  let formattedContent = formattedLines.join("\n");
+  if (budgetTruncated) {
+    formattedContent = `${formattedContent}
+... (truncated by byte budget)`;
+  }
+  const truncated = budgetTruncated || actualEndLine < totalLines;
   return {
-    content: formattedLines.join("\n"),
+    content: formattedContent,
     totalLines,
     startLine,
-    endLine
+    endLine: actualEndLine,
+    truncated,
+    continuation: truncated ? `Call read with offset ${actualEndLine + 1} to continue.` : void 0
   };
 }
 function readPngDimensions(bytes) {
@@ -788,7 +981,51 @@ function readImageDimensions(bytes, mediaType) {
   }
   return dimensions;
 }
+const fileMutationQueues = /* @__PURE__ */ new Map();
+async function withFileMutationQueue(key, operation) {
+  const previous = fileMutationQueues.get(key) ?? Promise.resolve();
+  let release;
+  const current = previous.catch(() => void 0).then(() => new Promise((resolve) => {
+    release = resolve;
+  }));
+  fileMutationQueues.set(key, current);
+  await previous.catch(() => void 0);
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (fileMutationQueues.get(key) === current) {
+      fileMutationQueues.delete(key);
+    }
+  }
+}
+function mutationQueueKey(projectId, branchName, filePath) {
+  return `${projectId}:${branchName}:${path.posix.normalize(filePath)}`;
+}
 async function executeReadFileOperation(input) {
+  const artifact = await resolveArtifactEnvFilePath({
+    filePath: input.message.filePath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    artifactRoot: input.artifactRoot
+  });
+  if (artifact) {
+    if (!fs.existsSync(artifact.absolutePath) || !fs.statSync(artifact.absolutePath).isFile()) {
+      throw new Error(`File not found: ${artifact.virtualPath}`);
+    }
+    const buffer2 = fs.readFileSync(artifact.absolutePath);
+    const formatted2 = formatLineNumberedContent(buffer2.toString("utf8"), input.message.offset, input.message.limit);
+    return {
+      type: "read",
+      kind: "text",
+      file: artifact.virtualPath,
+      gitBlobHash: getGitBlobHashForContent(buffer2),
+      ...formatted2
+    };
+  }
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
   const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
   if (!fs.existsSync(resolved.absolutePath) || !fs.statSync(resolved.absolutePath).isFile()) {
@@ -797,222 +1034,242 @@ async function executeReadFileOperation(input) {
   const buffer = fs.readFileSync(resolved.absolutePath);
   const formatted = formatLineNumberedContent(buffer.toString("utf8"), input.message.offset, input.message.limit);
   return {
-    type: "read_file",
+    type: "read",
+    kind: "text",
     file: resolved.virtualPath,
     gitBlobHash: getGitBlobHashForContent(buffer),
     ...formatted
   };
 }
-async function executeCreateFileOperation(input) {
-  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
-  if (fs.existsSync(resolved.absolutePath)) {
-    throw new Error(`File "${resolved.virtualPath}" already exists. Use edit_file to modify existing files.`);
-  }
-  fs.mkdirSync(path.dirname(resolved.absolutePath), { recursive: true });
-  fs.writeFileSync(resolved.absolutePath, input.message.content, "utf8");
-  return {
-    type: "create_file",
-    file: resolved.virtualPath,
-    gitBlobHash: getGitBlobHashForContent(input.message.content)
-  };
+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);
+    fs.mkdirSync(path.dirname(resolved.absolutePath), { recursive: true });
+    fs.writeFileSync(resolved.absolutePath, input.message.content, "utf8");
+    return {
+      type: "write",
+      file: resolved.virtualPath,
+      gitBlobHash: getGitBlobHashForContent(input.message.content)
+    };
+  });
 }
 async function executeEditFileOperation(input) {
-  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
-  if (input.message.oldString === input.message.newString) {
-    throw new Error("old_string and new_string must be different");
-  }
-  if (!fs.existsSync(resolved.absolutePath) || !fs.statSync(resolved.absolutePath).isFile()) {
-    throw new Error(`File not found: ${resolved.virtualPath}`);
-  }
-  const content = fs.readFileSync(resolved.absolutePath, "utf8");
-  if (!content.includes(input.message.oldString)) {
-    throw new Error(
-      `Could not find old_string: "${input.message.oldString.slice(0, 100)}${input.message.oldString.length > 100 ? "..." : ""}"`
-    );
-  }
-  if (!input.message.replaceAll) {
-    const occurrences = content.split(input.message.oldString).length - 1;
-    if (occurrences > 1) {
-      throw new Error(
-        `old_string is not unique in the file (found ${occurrences} occurrences). Provide more context or use replace_all: true.`
-      );
+  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);
+    if (!Array.isArray(input.message.edits) || input.message.edits.length === 0) {
+      throw new Error("edit requires at least one replacement");
+    }
+    if (!fs.existsSync(resolved.absolutePath) || !fs.statSync(resolved.absolutePath).isFile()) {
+      throw new Error(`File not found: ${resolved.virtualPath}`);
+    }
+    const originalContent = fs.readFileSync(resolved.absolutePath, "utf8");
+    const ranges = input.message.edits.map((edit, index) => {
+      if (edit.oldText === edit.newText) {
+        throw new Error(`edits[${index}].oldText and edits[${index}].newText must be different`);
+      }
+      if (edit.oldText.length === 0) {
+        throw new Error(`edits[${index}].oldText cannot be empty`);
+      }
+      const occurrences = originalContent.split(edit.oldText).length - 1;
+      if (occurrences === 0) {
+        throw new Error(`Could not find edits[${index}].oldText: "${edit.oldText.slice(0, 100)}${edit.oldText.length > 100 ? "..." : ""}"`);
+      }
+      if (occurrences > 1) {
+        throw new Error(`edits[${index}].oldText is not unique in the file (found ${occurrences} occurrences). Include more surrounding context.`);
+      }
+      const start = originalContent.indexOf(edit.oldText);
+      return { index, start, end: start + edit.oldText.length, edit };
+    });
+    const sortedRanges = [...ranges].sort((a, b) => a.start - b.start);
+    for (let index = 1; index < sortedRanges.length; index += 1) {
+      const previous = sortedRanges[index - 1];
+      const current = sortedRanges[index];
+      if (current.start < previous.end) {
+        throw new Error(`edits[${current.index}] overlaps edits[${previous.index}]. Merge nearby changes into one replacement.`);
+      }
     }
-  }
-  const nextContent = input.message.replaceAll ? content.split(input.message.oldString).join(input.message.newString) : content.replace(input.message.oldString, input.message.newString);
-  fs.writeFileSync(resolved.absolutePath, nextContent, "utf8");
-  return {
-    type: "edit_file",
-    file: resolved.virtualPath
-  };
+    let nextContent = originalContent;
+    for (const range of [...sortedRanges].reverse()) {
+      nextContent = nextContent.slice(0, range.start) + range.edit.newText + nextContent.slice(range.end);
+    }
+    fs.writeFileSync(resolved.absolutePath, nextContent, "utf8");
+    return {
+      type: "edit",
+      file: resolved.virtualPath,
+      edits: input.message.edits.length
+    };
+  });
 }
-function decodePatchPath(rawPath) {
-  const trimmed = rawPath.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      return trimmed.slice(1, -1);
+const IGNORED_ENTRY_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".cache", "coverage", "target"]);
+function normalizeToolLimit(value, fallback, max) {
+  if (!Number.isFinite(value) || value === void 0) return fallback;
+  return Math.max(1, Math.min(max, Math.floor(value)));
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function wildcardToRegex(pattern) {
+  const escaped = escapeRegex(pattern).replace(/\\\*/g, ".*").replace(/\\\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+function normalizeFindPattern(pattern) {
+  return /[*?]/.test(pattern) ? pattern : `*${pattern}*`;
+}
+function toVirtualPath(branchPath, absolutePath) {
+  const relative = path.relative(branchPath, absolutePath).split(path.sep).join(path.posix.sep);
+  return relative ? `/${relative}` : "/";
+}
+function walkProjectEntries(branchPath, startPath) {
+  const entries = [];
+  const visit = (absolutePath) => {
+    const stat = fs.statSync(absolutePath);
+    const virtualPath = toVirtualPath(branchPath, absolutePath);
+    entries.push({ absolutePath, virtualPath, stat });
+    if (!stat.isDirectory()) return;
+    const children = fs.readdirSync(absolutePath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const child of children) {
+      if (IGNORED_ENTRY_NAMES.has(child.name)) continue;
+      visit(path.join(absolutePath, child.name));
     }
-  }
-  return trimmed;
+  };
+  visit(startPath);
+  return entries;
 }
-function normalizePatchPath(rawPath) {
-  const withoutMetadata = rawPath.split("	")[0] ?? rawPath;
-  let patchPath = decodePatchPath(withoutMetadata);
-  if (patchPath === "/dev/null") {
-    return null;
-  }
-  if (patchPath.startsWith("a/") || patchPath.startsWith("b/")) {
-    patchPath = patchPath.slice(2);
-  }
-  if (!patchPath || path.isAbsolute(patchPath)) {
-    throw new Error(`Invalid patch path: ${rawPath}`);
-  }
-  const normalized = path.posix.normalize(patchPath);
-  if (normalized === "." || normalized.startsWith("../") || normalized === "..") {
-    throw new Error(`Invalid patch path: ${rawPath}`);
-  }
-  return normalized;
+function isProbablyText(bytes) {
+  return !bytes.subarray(0, Math.min(bytes.length, 4096)).includes(0);
 }
-function readDiffPathToken(value, startIndex) {
-  let index = startIndex;
-  while (index < value.length && /\s/.test(value[index] ?? "")) {
-    index += 1;
-  }
-  if (index >= value.length) {
-    throw new Error("Missing path in patch header");
-  }
-  if (value[index] !== '"') {
-    const tokenStart2 = index;
-    while (index < value.length && !/\s/.test(value[index] ?? "")) {
-      index += 1;
-    }
-    return { token: value.slice(tokenStart2, index), nextIndex: index };
-  }
-  const tokenStart = index;
-  index += 1;
-  let escaped = false;
-  while (index < value.length) {
-    const character = value[index];
-    if (escaped) {
-      escaped = false;
-    } else if (character === "\\") {
-      escaped = true;
-    } else if (character === '"') {
-      index += 1;
-      return { token: value.slice(tokenStart, index), nextIndex: index };
+async function executeGrepOperation(input) {
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const start = resolveProjectFilePath(workspace.branchPath, input.message.path ?? "/");
+  if (!fs.existsSync(start.absolutePath)) {
+    throw new Error(`Path not found: ${start.virtualPath}`);
+  }
+  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 lines = [];
+  let matchCount = 0;
+  let truncated = false;
+  for (const entry of walkProjectEntries(workspace.branchPath, start.absolutePath)) {
+    if (!entry.stat.isFile()) continue;
+    const repoRelative = entry.virtualPath.slice(1);
+    if (globRegex && !globRegex.test(repoRelative)) continue;
+    const bytes = fs.readFileSync(entry.absolutePath);
+    if (!isProbablyText(bytes)) continue;
+    const fileLines = bytes.toString("utf8").split(/\r?\n/);
+    for (let index = 0; index < fileLines.length; index += 1) {
+      const line = fileLines[index] ?? "";
+      regex.lastIndex = 0;
+      const match = regex.exec(line);
+      if (!match) continue;
+      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)}`);
+      } else {
+        truncated = true;
+      }
     }
-    index += 1;
-  }
-  throw new Error("Unterminated quoted path in patch header");
-}
-function parseDiffGitPaths(line) {
-  if (!line.startsWith("diff --git ")) {
-    throw new Error(`Invalid patch header: ${line}`);
-  }
-  const rest = line.slice("diff --git ".length);
-  const first = readDiffPathToken(rest, 0);
-  const second = readDiffPathToken(rest, first.nextIndex);
-  if (rest.slice(second.nextIndex).trim()) {
-    throw new Error(`Invalid patch header: ${line}`);
   }
+  const hint = truncated ? `
+... truncated. Narrow path/glob or increase limit to continue.` : "";
   return {
-    oldPath: normalizePatchPath(first.token),
-    newPath: normalizePatchPath(second.token)
+    type: "grep",
+    content: lines.length > 0 ? `${lines.join("\n")}${hint}` : "No matches.",
+    matchCount,
+    truncated
   };
 }
-function summarizePatch(patch) {
-  if (!patch.trim()) {
-    throw new Error("Patch cannot be empty");
-  }
-  const files = [];
-  let current;
-  for (const line of patch.split(/\r?\n/)) {
-    if (line.startsWith("diff --git ")) {
-      const { oldPath, newPath } = parseDiffGitPaths(line);
-      if (!oldPath && !newPath) {
-        throw new Error(`Invalid patch header: ${line}`);
-      }
-      current = {
-        path: newPath ?? oldPath,
-        ...oldPath && newPath && oldPath !== newPath ? { oldPath } : {},
-        operation: oldPath && newPath && oldPath !== newPath ? "move" : "update",
-        additions: 0,
-        deletions: 0,
-        hunks: 0
-      };
-      files.push(current);
-      continue;
-    }
-    if (!current) {
-      continue;
-    }
-    if (line.startsWith("new file mode ")) {
-      current.operation = "add";
-      continue;
-    }
-    if (line.startsWith("deleted file mode ")) {
-      current.operation = "delete";
-      if (current.oldPath) {
-        current.path = current.oldPath;
-        delete current.oldPath;
-      }
-      continue;
-    }
-    if (line.startsWith("rename from ")) {
-      current.operation = "move";
-      current.oldPath = normalizePatchPath(line.slice("rename from ".length)) ?? void 0;
-      continue;
-    }
-    if (line.startsWith("rename to ")) {
-      current.operation = "move";
-      current.path = normalizePatchPath(line.slice("rename to ".length)) ?? current.path;
-      continue;
-    }
-    if (line.startsWith("@@")) {
-      current.hunks += 1;
-      continue;
-    }
-    if (line.startsWith("+") && !line.startsWith("+++")) {
-      current.additions += 1;
-      continue;
-    }
-    if (line.startsWith("-") && !line.startsWith("---")) {
-      current.deletions += 1;
+async function executeFindOperation(input) {
+  const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
+  const start = resolveProjectFilePath(workspace.branchPath, input.message.path ?? "/");
+  if (!fs.existsSync(start.absolutePath) || !fs.statSync(start.absolutePath).isDirectory()) {
+    throw new Error(`Directory not found: ${start.virtualPath}`);
+  }
+  const pattern = normalizeFindPattern(input.message.pattern ?? "*");
+  const matcher = wildcardToRegex(pattern);
+  const entryType = input.message.entryType ?? "file";
+  const limit = normalizeToolLimit(input.message.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;
+    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(path.posix.basename(entry.virtualPath)) && !matcher.test(entry.virtualPath.slice(1))) continue;
+    count += 1;
+    if (matches.length < limit) {
+      matches.push(label);
+    } else {
+      truncated = true;
     }
   }
-  if (files.length === 0) {
-    throw new Error("Patch must contain at least one diff --git file header");
-  }
-  return files;
+  const hint = truncated ? "\n... truncated. Narrow path/pattern or increase limit to continue." : "";
+  return {
+    type: "find",
+    content: matches.length > 0 ? `${matches.join("\n")}${hint}` : "No paths found.",
+    count,
+    truncated
+  };
 }
-async function executeApplyPatchOperation(input) {
+async function executeLsOperation(input) {
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
-  const files = summarizePatch(input.message.patch);
-  const patchPath = path.join(os.tmpdir(), `r5d-apply-patch-${randomUUID()}.patch`);
-  try {
-    fs.writeFileSync(patchPath, input.message.patch, "utf8");
-    runInternalGit(workspace.internalGit, ["apply", "--check", "--whitespace=nowarn", patchPath]);
-    runInternalGit(workspace.internalGit, ["apply", "--whitespace=nowarn", patchPath]);
-  } catch (error) {
-    throw new Error(`Patch did not apply: ${error instanceof Error ? error.message : String(error)}`);
-  } finally {
-    fs.rmSync(patchPath, { force: true });
-  }
+  const resolved = resolveProjectFilePath(workspace.branchPath, input.message.path ?? "/");
+  if (!fs.existsSync(resolved.absolutePath) || !fs.statSync(resolved.absolutePath).isDirectory()) {
+    throw new Error(`Directory not found: ${resolved.virtualPath}`);
+  }
+  const limit = normalizeToolLimit(input.message.limit, 200, 1e3);
+  const entries = fs.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: "apply_patch",
-    files,
-    summary: {
-      filesChanged: files.length,
-      additions: files.reduce((sum, file) => sum + file.additions, 0),
-      deletions: files.reduce((sum, file) => sum + file.deletions, 0),
-      hunks: files.reduce((sum, file) => sum + file.hunks, 0)
-    }
+    type: "ls",
+    path: resolved.virtualPath,
+    content: displayed.length > 0 ? `${displayed.join("\n")}${hint}` : "(empty directory)",
+    count: entries.length,
+    truncated
   };
 }
 async function executeViewFileBytesOperation(input) {
+  const artifact = await resolveArtifactEnvFilePath({
+    filePath: input.message.filePath,
+    baseUrl: input.baseUrl,
+    token: input.token,
+    projectId: input.projectId,
+    branchName: input.message.branchName,
+    sessionId: input.message.sessionId,
+    artifactRoot: input.artifactRoot
+  });
+  if (artifact) {
+    if (!fs.existsSync(artifact.absolutePath) || !fs.statSync(artifact.absolutePath).isFile()) {
+      throw new Error(`File not found: ${artifact.virtualPath}`);
+    }
+    const extension2 = path.extname(artifact.absolutePath).toLowerCase();
+    const mediaType2 = extension2 === ".jpg" || extension2 === ".jpeg" ? "image/jpeg" : extension2 === ".png" ? "image/png" : null;
+    if (!mediaType2) {
+      throw new Error("read supports PNG and JPEG image inputs only");
+    }
+    const bytes2 = fs.readFileSync(artifact.absolutePath);
+    const dimensions2 = readImageDimensions(bytes2, mediaType2);
+    return {
+      type: "view_file_bytes",
+      filePath: artifact.virtualPath,
+      mediaType: mediaType2,
+      base64: bytes2.toString("base64"),
+      fileSizeBytes: bytes2.length,
+      width: dimensions2.width,
+      height: dimensions2.height
+    };
+  }
   const workspace = ensureOperationBranch({ ...input, branchName: input.message.branchName });
   const resolved = resolveProjectFilePath(workspace.branchPath, input.message.filePath);
   if (!fs.existsSync(resolved.absolutePath) || !fs.statSync(resolved.absolutePath).isFile()) {
@@ -1021,7 +1278,7 @@ async function executeViewFileBytesOperation(input) {
   const extension = path.extname(resolved.absolutePath).toLowerCase();
   const mediaType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : null;
   if (!mediaType) {
-    throw new Error("view_image supports PNG and JPEG files only");
+    throw new Error("read supports PNG and JPEG image inputs only");
   }
   const bytes = fs.readFileSync(resolved.absolutePath);
   const dimensions = readImageDimensions(bytes, mediaType);
@@ -1127,14 +1384,18 @@ function pullBranch(input) {
 }
 async function executeOperation(input) {
   switch (input.message.type) {
-    case "read_file":
+    case "read":
       return executeReadFileOperation({ ...input, message: input.message });
-    case "create_file":
-      return executeCreateFileOperation({ ...input, message: input.message });
-    case "edit_file":
+    case "write":
+      return executeWriteFileOperation({ ...input, message: input.message });
+    case "edit":
       return executeEditFileOperation({ ...input, message: input.message });
-    case "apply_patch":
-      return executeApplyPatchOperation({ ...input, message: input.message });
+    case "grep":
+      return executeGrepOperation({ ...input, message: input.message });
+    case "find":
+      return executeFindOperation({ ...input, message: input.message });
+    case "ls":
+      return executeLsOperation({ ...input, message: input.message });
     case "view_file_bytes":
       return executeViewFileBytesOperation({ ...input, message: input.message });
     case "sync":
@@ -1189,6 +1450,18 @@ async function executeCommand(input) {
       branchName: input.message.branchName,
       manifest: input.manifest
     });
+    let artifactProcessEnv = {};
+    if (input.message.sessionId) {
+      await syncSessionArtifacts({
+        baseUrl: input.baseUrl,
+        token: input.token,
+        projectId: input.projectId,
+        branchName: input.message.branchName,
+        sessionId: input.message.sessionId,
+        artifactRoot: input.artifactRoot
+      });
+      artifactProcessEnv = artifactEnv(input.artifactRoot, input.message.sessionId);
+    }
     const cwd = resolveCommandCwd(workspace.branchPath, input.message.cwd);
     const subprocess = Bun.spawn(input.message.argv, {
       cwd,
@@ -1198,7 +1471,8 @@ async function executeCommand(input) {
         ...process.env,
         ...containerRegistryEnv(),
         ...input.message.env ?? {},
-        ...internalGitProcessEnv(workspace, input.message.env)
+        ...internalGitProcessEnv(workspace, input.message.env),
+        ...artifactProcessEnv
       }
     });
     activeProcesses.set(input.message.runId, { process: subprocess, command: input.message.argv });
@@ -1261,6 +1535,15 @@ async function executeStreamingCommand(input) {
       branchName: input.message.branchName,
       manifest: input.manifest
     });
+    await syncSessionArtifacts({
+      baseUrl: input.baseUrl,
+      token: input.token,
+      projectId: input.projectId,
+      branchName: input.message.branchName,
+      sessionId: input.message.sessionId,
+      artifactRoot: input.artifactRoot
+    });
+    const artifactProcessEnv = artifactEnv(input.artifactRoot, input.message.sessionId);
     const cwd = resolveCommandCwd(workspace.branchPath, input.message.cwd);
     const subprocess = Bun.spawn(input.message.argv, {
       cwd,
@@ -1270,7 +1553,8 @@ async function executeStreamingCommand(input) {
         ...process.env,
         ...containerRegistryEnv(),
         ...input.message.env ?? {},
-        ...internalGitProcessEnv(workspace, input.message.env)
+        ...internalGitProcessEnv(workspace, input.message.env),
+        ...artifactProcessEnv
       }
     });
     activeProcesses.set(input.message.runId, { process: subprocess, command: input.message.argv });
@@ -1645,11 +1929,14 @@ async function startWorker(options) {
   validateLabel(label);
   const projectsRoot = path.resolve(options.projectRoot ?? defaultProjectsRoot());
   const syncRoot = path.resolve(options.syncRoot ?? process.env.R5D_SYNC_ROOT ?? defaultSyncRoot());
+  const artifactRoot = path.resolve(options.artifactRoot ?? process.env.R5D_ARTIFACTS_ROOT ?? defaultArtifactRoot());
   process.stdout.write(`[r5d-worker] label: ${label}
 `);
   process.stdout.write(`[r5d-worker] projects root: ${projectsRoot}
 `);
   process.stdout.write(`[r5d-worker] sync root: ${syncRoot}
+`);
+  process.stdout.write(`[r5d-worker] artifact root: ${artifactRoot}
 `);
   process.stdout.write(`[r5d-worker] server: ${baseUrl}
 `);
@@ -1657,6 +1944,7 @@ async function startWorker(options) {
   await verifyR5dctlAuth(baseUrl, token);
   fs.mkdirSync(projectsRoot, { recursive: true });
   fs.mkdirSync(syncRoot, { recursive: true });
+  fs.mkdirSync(artifactRoot, { recursive: true });
   const manifestByProjectId = /* @__PURE__ */ new Map();
   const ws = new WebSocket(websocketUrl(baseUrl, label), {
     headers: {
@@ -1672,7 +1960,8 @@ async function startWorker(options) {
         arch: process.arch,
         pid: process.pid,
         version: getWorkerVersion(),
-        projectRoot: projectsRoot
+        projectRoot: projectsRoot,
+        artifactRoot
       }
     };
     ws.send(JSON.stringify(hello));
@@ -1769,7 +2058,7 @@ async function startWorker(options) {
         const result = await withBranchLock(
           message.projectId,
           message.branchName,
-          () => executeCommand({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest })
+          () => executeCommand({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, artifactRoot, manifest })
         );
         ws.send(JSON.stringify(result));
         return;
@@ -1788,7 +2077,7 @@ async function startWorker(options) {
           void withBranchLock(
             message.projectId,
             message.branchName,
-            () => executeStreamingCommand({ ws, message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest })
+            () => executeStreamingCommand({ ws, message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, artifactRoot, manifest })
           ).catch((error) => {
             sendWorkerMessage(ws, {
               type: "exec_start_error",
@@ -1807,14 +2096,14 @@ async function startWorker(options) {
         }
         return;
       }
-      if (message.type === "read_file" || message.type === "create_file" || message.type === "edit_file" || message.type === "apply_patch" || message.type === "view_file_bytes" || message.type === "sync" || message.type === "confirm_large_diff" || message.type === "pull_branch") {
+      if (message.type === "read" || message.type === "write" || message.type === "edit" || message.type === "grep" || message.type === "find" || message.type === "ls" || message.type === "view_file_bytes" || message.type === "sync" || message.type === "confirm_large_diff" || message.type === "pull_branch") {
         try {
           const manifest = manifestByProjectId.get(message.projectId);
           const projectRoot = projectRootFor(projectsRoot, message.projectId, manifestByProjectId);
           const result = await withBranchLock(
             message.projectId,
             message.branchName,
-            () => executeOperation({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, manifest })
+            () => executeOperation({ message, projectId: message.projectId, baseUrl, token, projectRoot, syncRoot, artifactRoot, manifest })
           );
           ws.send(
             JSON.stringify({
@@ -1890,5 +2179,7 @@ if (isCliEntrypoint()) {
   });
 }
 export {
-  ensureVisibleGitCheckout
+  ensureVisibleGitCheckout,
+  isArtifactEnvPath,
+  syncSessionArtifacts
 };