@abot-ai/runtime 1.7.0 → 1.8.0

package/plugins/local-search/README.md

@@ -0,0 +1,29 @@
+# Local Search
+
+Searches file names and file contents on Linux, macOS and native Windows using
+bundled ripgrep. Paths remain relative to the configured agent work directory;
+`workspace/...` selects configured workspace sources. Absolute paths and
+request-specific roots use the same Runtime authorization checks.
+
+The existing query modes, literal matching, 200-result ceiling, bounded streamed
+records, output budget and ten-second search deadline apply on every platform.
+Inherited ripgrep configuration is ignored. Search does not execute project
+scripts or modify files. Directory links are not followed by ripgrep.
+
+## Windows requirements
+
+Built-in Windows PowerShell and its C# helper hold the selected path and its
+ancestors open while the search runs. Their identities are checked before
+starting ripgrep. Moving or replacing that path is temporarily blocked until
+the search finishes; a selected individual file is also protected against
+writes while it is being searched.
+
+The helper uses the same Job Object mechanism as EXEC. Cancellation, timeout
+and reaching the result limit terminate its child processes. This requires no
+Companion, WSL, Docker, elevation, policy bypass or separately installed shell.
+If policy blocks the helper, `local_search_windows_unavailable` tells the model
+not to retry or bypass the restriction. Failure to retain the path authority
+returns `local_search_authority_unavailable` and no partial results.
+
+Linux retains its descriptor-based execution; macOS retains its existing
+directory-authority bridge. Windows support does not change those paths.

package/plugins/local-search/plugin.json

@@ -4,6 +4,7 @@
   "version": "0.1.0",
   "description": "Search filenames and textual content beneath configured agent data roots.",
   "extensions": {
+    "ai.abot.compatibility": { "version": 1, "runtimePlatforms": ["linux", "darwin", "win32"] },
     "ai.abot.runtime": {
       "version": 1,
       "entrypoint": "./src/index.cjs",

package/plugins/local-search/source/errors.ts

@@ -4,6 +4,8 @@ export type LocalSearchErrorCode =
   | "local_search_result_encoding_unsupported"
   | "local_search_result_invalid"
   | "local_search_path_roundtrip_unsafe"
+  | "local_search_authority_unavailable"
+  | "local_search_windows_unavailable"
   | "local_search_failed";
 
 export class LocalSearchError extends Error {

package/plugins/local-search/source/paths.ts

@@ -8,6 +8,7 @@ import type {
 } from "../../../src/plugin-sdk/index.js";
 import { resolvePluginPath } from "../../../src/plugin-sdk/index.js";
 
+import { openWindowsSearchAuthority } from "./windows-authority.js";
 import { LocalSearchError } from "./errors.js";
 import type { SearchDirectoryAuthority } from "./ripgrep-process.js";
 
@@ -164,6 +165,8 @@ export async function resolveSearchRoot(
     requirePath: true,
     allowedLocations: ["agent_work", "workspace"],
   });
+  const needsWindowsSearchAuthority = process.platform === "win32";
+  if (needsWindowsSearchAuthority) return openWindowsSearchAuthority(target);
   return openSearchAuthority(target);
 }
 

package/plugins/local-search/source/ripgrep-process.ts

@@ -5,10 +5,22 @@ import { rgPath } from "@vscode/ripgrep";
 
 import { spawnDirectoryAuthorityCommand } from "../../../src/shared/directory-authority/index.js";
 
-export type SearchDirectoryAuthority = Readonly<{
-  directoryPath: string;
-  directoryFd: number;
-}>;
+import type { WindowsSearchAuthority } from "./windows-authority.js";
+import { spawnWindowsSearch } from "./windows-search-process.js";
+import type { LocalSearchError } from "./errors.js";
+
+export type SearchDirectoryAuthority =
+  | WindowsSearchAuthority
+  | Readonly<{
+      directoryPath: string;
+      directoryFd: number;
+    }>;
+
+function isWindowsSearchAuthority(
+  authority?: SearchDirectoryAuthority,
+): authority is WindowsSearchAuthority {
+  return authority !== undefined && "platform" in authority;
+}
 
 function controlledRipgrepEnvironment(): NodeJS.ProcessEnv {
   const environment = { ...process.env };
@@ -37,14 +49,28 @@ function terminateAuthorityGroup(
   }
 }
 
+type RipgrepInvocation = Readonly<{
+  child: ChildProcessByStdio<null, Readable, Readable>;
+  terminate(): void;
+  failureForExit?: (code: number | null | undefined) => LocalSearchError;
+}>;
+
 export function spawnRipgrepProcess(
   args: readonly string[],
   cwd: string,
   stdinFd?: number,
   directoryAuthority?: SearchDirectoryAuthority,
-) {
+): RipgrepInvocation {
   const commandArgs = ["--no-config", ...args];
   const env = controlledRipgrepEnvironment();
+  if (isWindowsSearchAuthority(directoryAuthority)) {
+    return spawnWindowsSearch({
+      authority: directoryAuthority,
+      command: rgPath,
+      args: commandArgs,
+      env,
+    });
+  }
   if (directoryAuthority) {
     const child = spawnDirectoryAuthorityCommand({
       ...directoryAuthority,

package/plugins/local-search/source/ripgrep.ts

@@ -134,7 +134,7 @@ async function runRipgrepBounded<T>(
     let timedOut = false;
     let aborted = false;
     let parserError: unknown;
-    const { child, terminate } = spawnRipgrepProcess(
+    const { child, terminate, failureForExit } = spawnRipgrepProcess(
       args,
       cwd,
       stdinFd,
@@ -194,7 +194,7 @@ async function runRipgrepBounded<T>(
     });
     // Always drain stderr so the child cannot block on its diagnostic pipe.
     child.stderr.on("data", () => undefined);
-    child.on("error", (error) => settleFailure(error));
+    child.on("error", (error) => settleFailure(failureForExit?.(undefined) ?? error));
     child.on("close", (code) => {
       if (completed) return;
       if (parserError) {
@@ -214,7 +214,7 @@ async function runRipgrepBounded<T>(
         }
       }
       if (!stoppedAfterExtraResult && code !== 0 && code !== 1) {
-        settleFailure();
+        settleFailure(failureForExit?.(code));
         return;
       }
       completed = true;

package/plugins/local-search/source/windows-authority.ts

@@ -0,0 +1,99 @@
+import { open, realpath, type FileHandle } from "node:fs/promises";
+import { win32 } from "node:path";
+import type { BigIntStats } from "node:fs";
+import type { ResolvedRuntimeToolPath } from "../../../src/plugin-sdk/index.js";
+import { LocalSearchError } from "./errors.js";
+import type { SearchRoot } from "./paths.js";
+
+export type WindowsSearchIdentity = Readonly<{
+  device: string;
+  inode: string;
+  birthtimeNs: string;
+}>;
+export type WindowsSearchAuthority = Readonly<{
+  platform: "win32";
+  rootPath: string;
+  targetPath: string;
+  rootIdentity: WindowsSearchIdentity;
+  targetIdentity: WindowsSearchIdentity;
+  isFile: boolean;
+}>;
+
+function identity(stats: BigIntStats): WindowsSearchIdentity {
+  return {
+    device: String(stats.dev),
+    inode: String(stats.ino),
+    birthtimeNs: String(stats.birthtimeNs),
+  };
+}
+
+function sameWindowsPath(left: string, right: string): boolean {
+  return (
+    win32.resolve(left).toLowerCase() === win32.resolve(right).toLowerCase()
+  );
+}
+
+export function windowsSearchAuthorityUnavailable(): LocalSearchError {
+  return new LocalSearchError(
+    "local_search_authority_unavailable",
+    "Local search could not keep the selected Windows path safely bound to its authorized root. No results were returned. Do not retry or bypass this restriction with another tool; ask the user to check the path and access permissions.",
+  );
+}
+
+export async function openWindowsSearchAuthority(
+  target: ResolvedRuntimeToolPath,
+): Promise<SearchRoot> {
+  const handles: FileHandle[] = [];
+  try {
+    const root = await open(target.rootPath, "r");
+    handles.push(root);
+    const selected = await open(target.absolutePath, "r");
+    handles.push(selected);
+    const [rootStats, selectedStats, rootPath, targetPath] = await Promise.all([
+      root.stat({ bigint: true }),
+      selected.stat({ bigint: true }),
+      realpath(target.rootPath),
+      realpath(target.absolutePath),
+    ]);
+    if (!rootStats.isDirectory()) throw windowsSearchAuthorityUnavailable();
+    if (!sameWindowsPath(rootPath, target.rootPath))
+      throw windowsSearchAuthorityUnavailable();
+    if (!sameWindowsPath(targetPath, target.absolutePath))
+      throw windowsSearchAuthorityUnavailable();
+    if (!selectedStats.isFile() && !selectedStats.isDirectory()) {
+      throw new LocalSearchError(
+        "local_search_target_invalid",
+        "The selected search target must be a regular file or directory.",
+      );
+    }
+    const isFile = selectedStats.isFile();
+    return Object.freeze({
+      target,
+      isFile,
+      commandDirectory: isFile ? win32.dirname(targetPath) : targetPath,
+      commandTarget: isFile ? win32.basename(targetPath) : ".",
+      directoryAuthority: {
+        platform: "win32" as const,
+        rootPath,
+        targetPath,
+        rootIdentity: identity(rootStats),
+        targetIdentity: identity(selectedStats),
+        isFile,
+      },
+      close: async () => {
+        for (const handle of handles.splice(0)) await handle.close();
+      },
+    });
+  } catch (error) {
+    await Promise.all(handles.splice(0).map((handle) => handle.close()));
+    if (error instanceof LocalSearchError) throw error;
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      throw new LocalSearchError(
+        "local_search_root_not_found",
+        "The selected logical search root does not exist.",
+      );
+    }
+    throw windowsSearchAuthorityUnavailable();
+  }
+}

package/plugins/local-search/source/windows-search-lease.ts

@@ -0,0 +1,49 @@
+// The external search program uses paths, so pin every ancestor from the volume
+// root. The ordinary SDK reader instead reads through handles relative to its root.
+export const WINDOWS_SEARCH_LEASE = String.raw`
+public static partial class AbotFilesystem {
+  sealed class SearchPathLease : IDisposable {
+    readonly List<SafeFileHandle> held = new List<SafeFileHandle>();
+    public readonly string Target;
+    public readonly bool IsFile;
+    public SearchPathLease(Dictionary<string,object> request) {
+      try {
+        Target = Path.GetFullPath(Text(request, "targetPath"));
+        string root = Path.GetFullPath(Text(request, "rootPath")).TrimEnd('\\');
+        if (!String.Equals(Target.TrimEnd('\\'), root, StringComparison.OrdinalIgnoreCase) &&
+            !Target.StartsWith(root + "\\", StringComparison.OrdinalIgnoreCase))
+          throw new FsFault("filesystem_invalid_path");
+        IsFile = (bool)request["isFile"];
+        string current = Path.GetPathRoot(Target);
+        var handle = OpenHandle(null, NativePath(current), true, 1, 0x80000000, 3);
+        held.Add(handle);
+        bool foundRoot = VerifyRoot(current, root, handle, request);
+        string rest = Target.Substring(current.Length).TrimEnd('\\');
+        string[] parts = rest.Length == 0 ? new string[0] : rest.Split('\\');
+        for (int i = 0; i < parts.Length; i++) {
+          ValidateComponent(parts[i]);
+          bool isFile = IsFile && i == parts.Length - 1;
+          handle = OpenHandle(handle, parts[i], !isFile, 1, 0x80000000, isFile ? 1u : 3u);
+          held.Add(handle);
+          current = Path.Combine(current, parts[i]);
+          if (!String.Equals(FinalPath(handle).TrimEnd('\\'), current.TrimEnd('\\'), StringComparison.OrdinalIgnoreCase))
+            throw new FsFault("filesystem_path_changed");
+          foundRoot |= VerifyRoot(current, root, handle, request);
+        }
+        if (!foundRoot || !MatchesIdentity(Identity(handle), request["targetIdentity"] as Dictionary<string,object>))
+          throw new FsFault("filesystem_path_changed");
+      } catch { Dispose(); throw; }
+    }
+    static bool VerifyRoot(string current, string root, SafeFileHandle handle, Dictionary<string,object> request) {
+      if (!String.Equals(current.TrimEnd('\\'), root, StringComparison.OrdinalIgnoreCase)) return false;
+      var expected = request["rootIdentity"] as Dictionary<string,object>;
+      if (expected == null || !MatchesIdentity(Identity(handle), expected)) throw new FsFault("filesystem_path_changed");
+      return true;
+    }
+    public void Dispose() {
+      for (int i = held.Count - 1; i >= 0; i--) held[i].Dispose();
+      held.Clear();
+    }
+  }
+}
+`;

package/plugins/local-search/source/windows-search-process.ts

@@ -0,0 +1,91 @@
+import { spawn, type ChildProcessByStdio } from "node:child_process";
+import { join } from "node:path";
+import type { Readable } from "node:stream";
+import { WINDOWS_EXEC_JOB_SOURCE } from "../../../src/shared/windows-job-object.js";
+import { LocalSearchError } from "./errors.js";
+import {
+  windowsSearchAuthorityUnavailable,
+  type WindowsSearchAuthority,
+} from "./windows-authority.js";
+import { WINDOWS_SEARCH_SOURCE } from "./windows-search-script.js";
+
+const BOOTSTRAP = [
+  "$ErrorActionPreference='Stop'",
+  "$ProgressPreference='SilentlyContinue'",
+  "if ($ExecutionContext.SessionState.LanguageMode -ne 'FullLanguage') { exit 126 }",
+  "$env:PSModulePath=[IO.Path]::Combine($PSHOME,'Modules')",
+  "try {",
+  "[Console]::InputEncoding=[Text.UTF8Encoding]::new($false)",
+  "$envelope=[Console]::In.ReadToEnd() | ConvertFrom-Json",
+  "Add-Type -TypeDefinition $envelope.jobSource",
+  "[AbotExecJob]::Attach()",
+  "Add-Type -ReferencedAssemblies @('System.Web.Extensions') -TypeDefinition $envelope.source",
+  "$result=[AbotFilesystem]::Search($envelope.request)",
+  "exit $result",
+  "} catch { exit 126 }",
+].join(";\n");
+
+function windowsSearchUnavailable(): LocalSearchError {
+  return new LocalSearchError(
+    "local_search_windows_unavailable",
+    "The Windows local-search helper is unavailable or blocked by computer policy. No results were returned. Do not retry or bypass this restriction with another tool; ask the user to check PowerShell/C# availability or contact their administrator.",
+  );
+}
+
+function windowsSearchExitFailure(
+  code: number | null | undefined,
+): LocalSearchError {
+  if (code === 125) return windowsSearchAuthorityUnavailable();
+  const helperUnavailable = code === 126 || code === undefined;
+  if (helperUnavailable) return windowsSearchUnavailable();
+  return new LocalSearchError(
+    "local_search_failed",
+    "Local search could not complete under the selected logical root.",
+  );
+}
+
+export function spawnWindowsSearch(
+  params: Readonly<{
+    authority: WindowsSearchAuthority;
+    command: string;
+    args: readonly string[];
+    env: NodeJS.ProcessEnv;
+  }>,
+) {
+  const input = JSON.stringify({
+    source: WINDOWS_SEARCH_SOURCE,
+    jobSource: WINDOWS_EXEC_JOB_SOURCE,
+    request: JSON.stringify({
+      ...params.authority,
+      command: params.command,
+      args: params.args,
+    }),
+  });
+  if (Buffer.byteLength(input) > 2 * 1024 * 1024)
+    throw windowsSearchUnavailable();
+  const executable = join(
+    process.env.SystemRoot ?? "C:\\Windows",
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe",
+  );
+  const child = spawn(
+    executable,
+    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", BOOTSTRAP],
+    {
+      env: params.env,
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    },
+  );
+  child.stdin.on("error", () => undefined);
+  child.stdin.end(input, "utf8");
+  return {
+    child: child as unknown as ChildProcessByStdio<null, Readable, Readable>,
+    terminate: () => {
+      child.kill("SIGKILL");
+    },
+    failureForExit: windowsSearchExitFailure,
+  };
+}

package/plugins/local-search/source/windows-search-script.ts

@@ -0,0 +1,52 @@
+import { WINDOWS_FILESYSTEM_NATIVE } from "../../../src/shared/windows-file-io/native-script.js";
+import { WINDOWS_FILESYSTEM_AUTHORITY } from "../../../src/shared/windows-file-io/authority-script.js";
+
+import { WINDOWS_SEARCH_LEASE } from "./windows-search-lease.js";
+
+const SEARCH_COMMAND = String.raw`
+public static partial class AbotFilesystem {
+  static string QuoteSearchArgument(string value) {
+    var quoted = new StringBuilder("\"");
+    int slashes = 0;
+    foreach (char c in value) {
+      if (c == '\\') { slashes++; continue; }
+      if (c == '"') { quoted.Append('\\', slashes * 2 + 1); quoted.Append(c); slashes = 0; continue; }
+      quoted.Append('\\', slashes); slashes = 0; quoted.Append(c);
+    }
+    quoted.Append('\\', slashes * 2); quoted.Append('"');
+    return quoted.ToString();
+  }
+  public static int Search(string input) {
+    var json = new JavaScriptSerializer { MaxJsonLength = 2 * 1024 * 1024 };
+    try {
+      var request = json.Deserialize<Dictionary<string,object>>(input);
+      using (var lease = new SearchPathLease(request)) {
+        var args = (System.Collections.IEnumerable)request["args"];
+        var quoted = new List<string>();
+        foreach (object arg in args) quoted.Add(QuoteSearchArgument((string)arg));
+        var start = new System.Diagnostics.ProcessStartInfo {
+          FileName = Text(request, "command"), Arguments = String.Join(" ", quoted),
+          WorkingDirectory = lease.IsFile ? Path.GetDirectoryName(lease.Target) : lease.Target,
+          UseShellExecute = false, CreateNoWindow = true,
+          RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true
+        };
+        using (var process = System.Diagnostics.Process.Start(start)) {
+          process.StandardInput.Close();
+          var output = process.StandardOutput.BaseStream.CopyToAsync(Console.OpenStandardOutput());
+          var errors = process.StandardError.BaseStream.CopyToAsync(Console.OpenStandardError());
+          process.WaitForExit();
+          System.Threading.Tasks.Task.WaitAll(output, errors);
+          return process.ExitCode;
+        }
+      }
+    } catch { return 125; }
+  }
+}
+`;
+
+export const WINDOWS_SEARCH_SOURCE = [
+  WINDOWS_FILESYSTEM_NATIVE,
+  WINDOWS_FILESYSTEM_AUTHORITY,
+  WINDOWS_SEARCH_LEASE,
+  SEARCH_COMMAND,
+].join("\n");