@ricsam/r5d-worker 0.0.165 → 0.0.167

package/dist/cjs/package.json

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

package/dist/mjs/internal-r5dctl.cjs

@@ -20605,7 +20605,7 @@ function resolveEntrypointPath(entrypoint) {
   }
 }
 function getR5dctlVersion() {
-  if (true) return "0.0.165";
+  if (true) return "0.0.167";
   const entrypoint = process.argv[1] ? resolveEntrypointPath(process.argv[1]) : null;
   let current = entrypoint ? import_node_path2.default.dirname(entrypoint) : process.cwd();
   for (let index = 0; index < 12; index += 1) {

package/dist/mjs/main.mjs

@@ -7,7 +7,7 @@ import { startManagerRpc } from "./runtime/releases/rpc-main.mjs";
 import { ManagerRpcConfig } from "./runtime/releases/rpc-protocol.mjs";
 const args = process.argv.slice(2);
 if (args.includes("--version")) {
-  console.log(`r5d-worker ${true ? "0.0.165" : "development"}`);
+  console.log(`r5d-worker ${true ? "0.0.167" : "development"}`);
 } else if (!args.length || args.includes("--help")) {
   console.log(
     "Usage: r5d-worker start --label <label> [--root <dir>] [--base-url <url>] [--token <worker-token>]\n       r5d-worker executor /absolute/private/config.json\n       r5d-worker manager /absolute/private/config.json\n\nRun independently supervised durable runtime services. Provision configuration with r5dinfra."
@@ -15,7 +15,7 @@ if (args.includes("--version")) {
 } else if (args[0] === "start") {
   const runtime = await startPersonalWorker(
     parsePersonalWorkerOptions(args.slice(1)),
-    true ? "0.0.165" : "development"
+    true ? "0.0.167" : "development"
   );
   console.log(`Worker connected: ${runtime.resourceId}`);
   let closing = false;

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.165",
+  "version": "0.0.167",
   "type": "module"
 }

package/dist/mjs/personal/client.mjs

@@ -103,7 +103,7 @@ async function startPersonalWorker(options, version) {
     platform: process.platform,
     arch: process.arch,
     hostname: os.hostname(),
-    capabilities: { updateClis: true, durableWorkspace: true, outerWorkspace: true, fileWalk: true }
+    capabilities: { updateClis: true, durableWorkspace: true, outerWorkspace: true, fileWalk: true, fileSearch: true }
   });
   const grant = PersonalWorkerGrant.parse(
     await request("/api/personal/resources/register", { kind: "worker", ...identity, label: options.label, metadata: metadata() })

package/dist/mjs/personal/runtime.mjs

@@ -13,6 +13,7 @@ import { privateDirectory, readPrivateJson } from "../runtime/storage.mjs";
 import { WorkspaceAuthority } from "../runtime/workspace/authority.mjs";
 import { ApprovedWorkbench, WorkspaceError } from "../runtime/workspace/contracts.mjs";
 import { OuterSnapshotRefusal } from "../runtime/workspace/outer.mjs";
+import { WorkspaceSearch } from "../runtime/workspace/search.mjs";
 import { WorkspaceStorageClient } from "../runtime/workspace/storage-client.mjs";
 import { BranchName, GitOid, StorageId } from "../runtime/workspace/storage-wire.mjs";
 const PersonalWorkerGrant = z.object({
@@ -371,6 +372,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         if (command.method === "fileHistoryDates") return authority.fileHistoryDates(identity, command.path);
         if (command.method === "directory" || command.method === "raw") return authority.inspectFiles(identity, command);
         if (command.method === "walk") return authority.walkFiles(identity, command);
+        if (command.method === "search") return authority.searchFiles(identity, WorkspaceSearch.parse(command));
       }
       if (request.kind === "terminal") {
         await authority.ensureHydrated(identity);

package/dist/mjs/runtime/workspace/authority.mjs

@@ -15,6 +15,7 @@ import { OuterRepository, OuterSnapshotRefusal, OUTER_BRANCH, OUTER_CONFLICT_COD
 import { SessionArtifactStore, SessionArtifactChunk, RESERVED_ARTIFACT_ENV } from "./artifacts.mjs";
 import { WorkspaceFileWrite, WorkspaceFileWriteLookup } from "./file-write.mjs";
 import { walkDirectoryTree } from "./walk.mjs";
+import { searchDirectoryTree } from "./search.mjs";
 import { WorkspaceStorageClient } from "./storage-client.mjs";
 import {
   durableJson,
@@ -338,6 +339,25 @@ class WorkspaceAuthority {
     const walked = await walkDirectoryTree(target);
     return { directory: display, ...walked };
   }
+  /** Searches a tree (or one file) locally in one operation: the walk, every
+   * bounded file read and the thread-isolated match all happen here, so a
+   * search costs one round-trip however many files it touches. */
+  async searchFiles(identity, command) {
+    const b = await this.bench(identity);
+    const relative = command.hostPath ? "" : command.path.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!command.hostPath && relative) safeTreePath(relative);
+    const target = command.hostPath ? this.resolveHostPath(command.path) : path.join(b.config.cwd, relative);
+    const display = command.hostPath ? target : `/${relative}`;
+    const inspect = command.hostPath ? fs.lstat(target).then((stat) => {
+      if (stat.isSymbolicLink()) throw new WorkspaceError("unsafe_path", "Final symlink paths are not inspected");
+    }) : noSymlinkAncestors(target);
+    await inspect.catch((error) => {
+      if (error.code === "ENOENT" || error.code === "ENOTDIR") throw new WorkspaceError("not_found", "File or directory not found");
+      throw error;
+    });
+    const searched = await searchDirectoryTree(target, { pattern: command.pattern, caseSensitive: command.caseSensitive, glob: command.glob, limit: command.limit, hostPath: command.hostPath });
+    return { directory: display, ...searched };
+  }
   async inspectGit(identity, command) {
     const b = await this.bench(identity);
     return this.serial(b, async () => {

package/dist/mjs/runtime/workspace/outer.mjs

@@ -146,24 +146,22 @@ class OuterRepository {
   async snapshot(inners, options = {}) {
     const limit = options.limitBytes ?? OUTER_SNAPSHOT_LIMIT_BYTES;
     await this.seed(inners);
-    const dependencies = nulSplit(
-      await this.run(["ls-files", "--others", "--exclude-standard", "--directory", "-z", "--", ":(glob)**/node_modules/**"])
-    );
-    if (dependencies.length && !options.allowLargeDiff)
-      throw new OuterSnapshotRefusal("too_large", "An unignored dependency tree exceeds the automatic publication limit", dependencies.slice(0, MAX_REPORTED_PATHS));
     const others = nulSplit(await this.run(["ls-files", "--others", "--exclude-standard", "-z"]));
     const foreign = others.filter((file) => file.endsWith("/")).map((file) => file.slice(0, -1));
+    const collapsed = nulSplit(await this.run(["ls-files", "--others", "--exclude-standard", "--directory", "-z"])).filter((entry) => entry.endsWith("/") && !foreign.includes(entry.slice(0, -1)));
+    const attribute = (paths) => [...new Set(paths.map((file) => collapsed.find((directory) => file.startsWith(directory)) ?? file))].slice(0, MAX_REPORTED_PATHS);
     const tracked = /* @__PURE__ */ new Map();
+    const trackedOf = async (inner) => {
+      let set = tracked.get(inner.root);
+      if (!set) tracked.set(inner.root, set = await inner.tracked());
+      return set;
+    };
     let unexplainedBytes = 0;
     const unexplainedPaths = [];
     for (const file of others) {
       if (file.endsWith("/")) continue;
       const inner = inners.find((candidate) => withinRoot(file, candidate.root));
-      if (inner) {
-        let set = tracked.get(inner.root);
-        if (!set) tracked.set(inner.root, set = await inner.tracked());
-        if (set.has(file.slice(inner.root.length + 1))) continue;
-      }
+      if (inner && (await trackedOf(inner)).has(file.slice(inner.root.length + 1))) continue;
       const stat = await fs.lstat(path.join(this.workTree, file)).catch((error) => {
         if (error.code === "ENOENT" || error.code === "ENOTDIR") return null;
         throw error;
@@ -175,7 +173,7 @@ class OuterRepository {
         throw new OuterSnapshotRefusal(
           "too_large",
           `Unexplained workspace content exceeds the ${limit}-byte automatic publication limit`,
-          unexplainedPaths.slice(0, MAX_REPORTED_PATHS)
+          attribute(unexplainedPaths)
         );
     }
     for (const file of unexplainedPaths) {
@@ -192,9 +190,40 @@ class OuterRepository {
     }
     await this.run(["add", "-A", "--", ".", ...foreign.map((directory) => `:(exclude,literal)${directory}`)]);
     await this.stripUnsupported();
+    await this.evictIgnored(inners, trackedOf);
     const tree = GitOid.parse((await this.run(["write-tree"])).toString("utf8").trim());
     return { tree, unexplainedBytes, unexplainedPaths };
   }
+  /** Under a checkout the outer tree holds exactly what the checkout tracks plus
+   * what it shows as untracked-and-not-ignored. Staging never drops a tracked
+   * file that has since become ignored — npm's cache, published by a cycle that
+   * raced `npm install` while it was still under the limit, then excluded by a
+   * restored `.gitignore` — so such files are removed from the index here. The
+   * working tree is untouched; a fixed ignore file simply cleans what was
+   * published. The seeding invariant holds: a checkout never loses its last
+   * outer entry. */
+  async evictIgnored(inners, trackedOf) {
+    const cached = nulSplit(await this.run(["ls-files", "--cached", "-z"]));
+    const tracked = /* @__PURE__ */ new Map(), untracked = /* @__PURE__ */ new Map();
+    for (const file of cached) {
+      const inner = inners.find((candidate) => withinRoot(file, candidate.root));
+      if (!inner) continue;
+      if ((await trackedOf(inner)).has(file.slice(inner.root.length + 1))) tracked.set(inner.root, (tracked.get(inner.root) ?? 0) + 1);
+      else untracked.set(inner.root, [...untracked.get(inner.root) ?? [], file]);
+    }
+    const paths = [...untracked.values()].flat();
+    if (!paths.length) return;
+    const { code, stdout } = await this.result(["check-ignore", "--no-index", "-z", "--stdin"], `${paths.join("\0")}\0`);
+    if (code !== 0 && code !== 1) throw new WorkspaceError("git_failed", "Outer repository ignore rules are unreadable");
+    const ignored = new Set(nulSplit(stdout));
+    const removals = [];
+    for (const [root, files] of untracked) {
+      const drop = files.filter((file) => ignored.has(file));
+      const survivors = (tracked.get(root) ?? 0) + files.length - drop.length;
+      removals.push(...survivors ? drop : drop.sort().slice(1));
+    }
+    if (removals.length) await this.run(["update-index", "--force-remove", "-z", "--stdin"], `${removals.join("\0")}\0`);
+  }
   /** Staging records a symlink as a link entry, and a nested repository that
    * appeared between the walk and the add as a gitlink. Neither can be
    * materialized on another host; both are dropped from the index without

package/dist/mjs/runtime/workspace/search.mjs

@@ -0,0 +1,120 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Worker } from "node:worker_threads";
+import picomatch from "picomatch";
+import { z } from "zod";
+import { WorkspaceError } from "./contracts.mjs";
+import { readHostRegular, readRegular } from "./files.mjs";
+import { walkDirectoryTree, WORKSPACE_WALK_IGNORED, WORKSPACE_WALK_LIMITS } from "./walk.mjs";
+const WORKSPACE_SEARCH_LIMITS = Object.freeze({
+  bytes: 8 * 1024 * 1024,
+  matches: 1e3,
+  outputBytes: 5e4,
+  lineChars: 2e3,
+  matchTimeoutMs: 1e3
+});
+const WorkspaceSearch = z.object({
+  method: z.literal("search"),
+  path: z.string().max(4096),
+  pattern: z.string().min(1).max(1e3),
+  caseSensitive: z.boolean().optional(),
+  glob: z.string().max(1e3).optional(),
+  limit: z.number().int().min(1).optional(),
+  hostPath: z.boolean().optional()
+}).strict();
+function globMatcher(glob) {
+  return glob.includes("/") ? picomatch(glob, { dot: true }) : picomatch(glob, { basename: true, dot: true });
+}
+function compileSearchPattern(pattern, caseSensitive) {
+  let source = pattern;
+  if (source.startsWith("(?i)")) {
+    source = source.slice(4);
+    caseSensitive = false;
+  }
+  if (!source) throw new WorkspaceError("invalid_pattern", "Invalid regular expression", true);
+  try {
+    new RegExp(source, caseSensitive ? "" : "i");
+  } catch {
+    throw new WorkspaceError("invalid_pattern", "Invalid regular expression", true);
+  }
+  return { source, caseSensitive };
+}
+function decodeSearchText(bytes) {
+  if (bytes.includes(0)) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function matchTextFiles(files, pattern, caseSensitive, maximum, timeoutMs = WORKSPACE_SEARCH_LIMITS.matchTimeoutMs) {
+  const compiled = compileSearchPattern(pattern, caseSensitive);
+  const limits = { maximum: Math.max(1, Math.min(maximum, WORKSPACE_SEARCH_LIMITS.matches)), outputBytes: WORKSPACE_SEARCH_LIMITS.outputBytes, lineChars: WORKSPACE_SEARCH_LIMITS.lineChars };
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(
+      "const {parentPort,workerData}=require('node:worker_threads');const r=new RegExp(workerData.source,workerData.caseSensitive?'':'i');const matches=[];let truncated=false,bytes=0;outer:for(const file of workerData.files){let n=0;for(const line of file.text.split('\\n')){n++;if(!r.test(line))continue;const text=line.slice(0,workerData.lineChars),size=file.path.length+text.length+8;if(matches.length>=workerData.maximum||bytes+size>workerData.outputBytes){truncated=true;break outer}matches.push({path:file.path,line:n,text});bytes+=size}}parentPort.postMessage({matches,truncated})",
+      { eval: true, workerData: { files, source: compiled.source, caseSensitive: compiled.caseSensitive, ...limits } }
+    );
+    const timer = setTimeout(() => {
+      void worker.terminate();
+      reject(new WorkspaceError("pattern_budget", "Search pattern exceeded its execution budget; narrow the pattern", true));
+    }, timeoutMs);
+    worker.once("message", (value) => {
+      clearTimeout(timer);
+      void worker.terminate();
+      resolve(value);
+    });
+    worker.once("error", (error) => {
+      clearTimeout(timer);
+      void worker.terminate();
+      reject(error);
+    });
+  });
+}
+async function searchDirectoryTree(root, options) {
+  const compiled = compileSearchPattern(options.pattern, options.caseSensitive ?? true);
+  const limits = options.limits ?? WORKSPACE_SEARCH_LIMITS, read = options.hostPath ? readHostRegular : readRegular;
+  const stat = await fs.stat(root);
+  let candidates, truncated = false;
+  if (stat.isFile()) candidates = [{ path: "", size: stat.size }];
+  else {
+    const matches = options.glob ? globMatcher(options.glob) : () => true;
+    const walked = await walkDirectoryTree(root, { ignored: options.ignored ?? WORKSPACE_WALK_IGNORED, limits: WORKSPACE_WALK_LIMITS });
+    truncated = walked.truncated;
+    candidates = walked.entries.filter((entry) => entry.type === "file" && matches(entry.path));
+  }
+  const files = [];
+  let budget = limits.bytes;
+  for (const candidate of candidates) {
+    if ((candidate.size ?? 0) > budget) {
+      truncated = true;
+      continue;
+    }
+    let bytes;
+    try {
+      bytes = await read(candidate.path ? path.join(root, candidate.path) : root, budget);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") continue;
+      if (error instanceof WorkspaceError) {
+        truncated = true;
+        continue;
+      }
+      throw error;
+    }
+    budget -= bytes.length;
+    const text = decodeSearchText(bytes);
+    if (text !== null) files.push({ path: candidate.path, text });
+  }
+  const matched = await matchTextFiles(files, compiled.source, compiled.caseSensitive, options.limit ?? limits.matches, limits.matchTimeoutMs);
+  return { matches: matched.matches, truncated: truncated || matched.truncated };
+}
+export {
+  WORKSPACE_SEARCH_LIMITS,
+  WorkspaceSearch,
+  compileSearchPattern,
+  decodeSearchText,
+  globMatcher,
+  matchTextFiles,
+  searchDirectoryTree
+};

package/dist/types/runtime/workspace/authority.d.ts

@@ -4,6 +4,7 @@ import { WorkspaceConfig, type ExecutorRoute, type WorkspaceIdentity, type Outer
 import { SessionArtifactChunk } from "./artifacts";
 import { WorkspaceFileWrite } from "./file-write";
 import { type WorkspaceWalk, type WorkspaceWalkResult } from "./walk";
+import { type WorkspaceSearch, type WorkspaceSearchResult } from "./search";
 import { WorkspaceStorageClient } from "./storage-client";
 export interface WorkspaceAuthorityOptions {
     config: WorkspaceConfig;
@@ -112,6 +113,10 @@ export declare class WorkspaceAuthority {
      * relative to the walked directory; the shared ignore list and bounds live
      * in `./walk` so the server's fallback agrees with them. */
     walkFiles(identity: WorkspaceIdentity, command: WorkspaceWalk): Promise<WorkspaceWalkResult>;
+    /** Searches a tree (or one file) locally in one operation: the walk, every
+     * bounded file read and the thread-isolated match all happen here, so a
+     * search costs one round-trip however many files it touches. */
+    searchFiles(identity: WorkspaceIdentity, command: WorkspaceSearch): Promise<WorkspaceSearchResult>;
     inspectGit(identity: WorkspaceIdentity, command: {
         method: "status" | "diff" | "history" | "fileDiff";
         path?: string;

package/dist/types/runtime/workspace/outer.d.ts

@@ -75,6 +75,15 @@ export declare class OuterRepository {
         allowLargeDiff?: boolean;
         limitBytes?: number;
     }): Promise<OuterSnapshot>;
+    /** Under a checkout the outer tree holds exactly what the checkout tracks plus
+     * what it shows as untracked-and-not-ignored. Staging never drops a tracked
+     * file that has since become ignored — npm's cache, published by a cycle that
+     * raced `npm install` while it was still under the limit, then excluded by a
+     * restored `.gitignore` — so such files are removed from the index here. The
+     * working tree is untouched; a fixed ignore file simply cleans what was
+     * published. The seeding invariant holds: a checkout never loses its last
+     * outer entry. */
+    private evictIgnored;
     /** Staging records a symlink as a link entry, and a nested repository that
      * appeared between the walk and the add as a gitlink. Neither can be
      * materialized on another host; both are dropped from the index without

package/dist/types/runtime/workspace/search.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+export type WorkspaceSearchLimits = {
+    /** Bytes of file content one search may read in total. */
+    readonly bytes: number;
+    /** Match lines reported before the result is marked truncated. */
+    readonly matches: number;
+    /** Bytes of reported match text. */
+    readonly outputBytes: number;
+    /** Characters kept from a matching line. */
+    readonly lineChars: number;
+    /** Wall-clock budget for regular-expression execution. */
+    readonly matchTimeoutMs: number;
+};
+/** Bounds one text search regardless of what a checkout contains. */
+export declare const WORKSPACE_SEARCH_LIMITS: WorkspaceSearchLimits;
+/** Inspect command: search text files under a path in one worker operation.
+ * `glob` matches paths relative to `path` (a glob without a slash matches
+ * base names). `limit` is clamped to the shared match bound. */
+export declare const WorkspaceSearch: z.ZodObject<{
+    method: z.ZodLiteral<"search">;
+    path: z.ZodString;
+    pattern: z.ZodString;
+    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+    glob: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    hostPath: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type WorkspaceSearch = z.infer<typeof WorkspaceSearch>;
+/** A match's `path` is relative to the searched directory, or empty when the
+ * searched path was itself a file. */
+export type WorkspaceSearchMatch = {
+    path: string;
+    line: number;
+    text: string;
+};
+export type WorkspaceSearchResult = {
+    directory: string;
+    matches: WorkspaceSearchMatch[];
+    truncated: boolean;
+};
+/** A glob without a slash matches base names anywhere under the searched
+ * directory; one with a slash matches the whole relative path. picomatch's
+ * `basename` option silently fails slash patterns, so it is applied only to
+ * slash-free globs. */
+export declare function globMatcher(glob: string): (relative: string) => boolean;
+/** Validates a search pattern before any file is touched. A leading `(?i)`,
+ * the inline flag models trained on ripgrep and PCRE emit, is folded into
+ * case-insensitivity because JavaScript has no inline flag syntax. */
+export declare function compileSearchPattern(pattern: string, caseSensitive: boolean): {
+    source: string;
+    caseSensitive: boolean;
+};
+/** Decodes a file as UTF-8 text, or returns null for binary or non-UTF-8 content. */
+export declare function decodeSearchText(bytes: Buffer): string | null;
+/** Runs the regular expression in a disposable thread so a hostile pattern
+ * cannot stall the process's event loop; the thread is terminated at the
+ * budget. `maximum` bounds reported matches. */
+export declare function matchTextFiles(files: Array<{
+    path: string;
+    text: string;
+}>, pattern: string, caseSensitive: boolean, maximum: number, timeoutMs?: number): Promise<{
+    matches: WorkspaceSearchMatch[];
+    truncated: boolean;
+}>;
+/** Searches the tree under `root` (or `root` itself when it is a file) in
+ * process: one walk with the shared ignore list, bounded reads of the files
+ * the glob selects, and one thread-isolated match. Files that vanish, exceed
+ * the remaining byte budget, or are not UTF-8 text are skipped; the first two
+ * mark the result truncated. */
+export declare function searchDirectoryTree(root: string, options: {
+    pattern: string;
+    caseSensitive?: boolean;
+    glob?: string;
+    limit?: number;
+    hostPath?: boolean;
+    ignored?: ReadonlySet<string>;
+    limits?: WorkspaceSearchLimits;
+}): Promise<{
+    matches: WorkspaceSearchMatch[];
+    truncated: boolean;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.165",
+  "version": "0.0.167",
   "type": "module",
   "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,7 @@
     "r5d-worker": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.165",
+    "@ricsam/r5d-api": "^0.0.167",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"