@abot-ai/runtime 1.7.0 → 1.8.1

package/plugins/filesystem/source/windows/read-script.ts

@@ -0,0 +1,63 @@
+export const WINDOWS_FILESYSTEM_READ = String.raw`
+public static partial class AbotFilesystem {
+  static object ReadSlices(Dictionary<string,object> request) {
+    int headLimit=Limit(request, "headBytes", 1048576), tailLimit=Limit(request, "tailBytes", 1048576);
+    int maximum=Limit(request, "maximumFileBytes", 1048576);
+    string[] parts=Components(request);
+    if (parts.Length == 0) throw new FsFault("not_a_file");
+    using (var chain=new DirectoryChain(request)) {
+      chain.Walk(parts, parts.Length-1, false);
+      using (var file=OpenHandle(chain.Current, parts[parts.Length-1], false, 1, 0x80000000, 1)) {
+        var before=Metadata(file);
+        long size=Convert.ToInt64(before["size"]);
+        if (maximum > 0 && size > maximum) throw new FsFault("file_too_large");
+        bool complete=size <= (long)headLimit+tailLimit;
+        var head=ReadBytes(file, 0, complete ? (int)size : headLimit);
+        var tail=complete ? new byte[0] : ReadBytes(file, size-tailLimit, tailLimit);
+        if (!SameMetadata(before, Metadata(file))) throw new FsFault("filesystem_read_changed");
+        return Record("metadata", before, "head", Convert.ToBase64String(head), "tail", Convert.ToBase64String(tail));
+      }
+    }
+  }
+  static object SampleDirectory(Dictionary<string,object> request) {
+    int maximum=Limit(request, "maxEntries", 160);
+    string[] parts=Components(request);
+    using (var chain=new DirectoryChain(request)) {
+      chain.Walk(parts, parts.Length, false);
+      var before=Basic(chain.Current);
+      var entries=new List<string>();
+      bool truncated=false, complete=false;
+      IntPtr buffer=Marshal.AllocHGlobal(16384);
+      try {
+        int kind=11;
+        while (!complete) {
+          if (!GetFileInformationByHandleEx(chain.Current, kind, buffer, 16384)) {
+            uint error=(uint)Marshal.GetLastWin32Error();
+            if (error == 18) break;
+            NativeFailure(error);
+          }
+          kind=10;
+          int offset=0;
+          for (;;) {
+            int next=Marshal.ReadInt32(buffer, offset), attributes=Marshal.ReadInt32(buffer, offset+56);
+            int nameLength=Marshal.ReadInt32(buffer, offset+60);
+            if (nameLength < 0 || nameLength % 2 != 0 || offset+104+nameLength > 16384)
+              throw new FsFault("filesystem_native_operation_failed");
+            string name=Marshal.PtrToStringUni(IntPtr.Add(buffer, offset+104), nameLength/2);
+            if (name != "." && name != "..") {
+              if (entries.Count == maximum) { truncated=true; complete=true; break; }
+              entries.Add(name + ((attributes & 0x410) == 0x10 ? "/" : ""));
+            }
+            if (next == 0) break;
+            if (next < 104 || offset+next >= 16384) throw new FsFault("filesystem_native_operation_failed");
+            offset+=next;
+          }
+        }
+      } finally { Marshal.FreeHGlobal(buffer); }
+      var after=Basic(chain.Current);
+      if (before.Modified != after.Modified || before.Changed != after.Changed) throw new FsFault("filesystem_read_changed");
+      return Record("entries", entries, "truncated", truncated);
+    }
+  }
+}
+`;

package/plugins/filesystem/source/windows/request-availability.ts

@@ -0,0 +1,67 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import {
+  failureResult,
+  type ToolModuleRequestPreparation,
+  type ToolModuleDeclaration,
+} from "../../../../src/plugin-sdk/index.js";
+import type { FilesystemToolError } from "../errors.js";
+import { isWindowsHelperBlocked, runWindowsFilesystem } from "./process.js";
+
+type RequestAvailability = { blocked?: FilesystemToolError };
+const currentRequest = new AsyncLocalStorage<{
+  availability: RequestAvailability;
+  signal?: AbortSignal;
+}>();
+
+/** A detected helper block applies only to this request, never to another installation/request. */
+export async function executeWindowsFilesystem(
+  request: Readonly<Record<string, unknown>>,
+): Promise<unknown> {
+  const scope = currentRequest.getStore();
+  if (scope?.availability.blocked) throw scope.availability.blocked;
+  try {
+    return await runWindowsFilesystem(request, scope?.signal);
+  } catch (error) {
+    if (scope && isWindowsHelperBlocked(error))
+      scope.availability.blocked = error;
+    throw error;
+  }
+}
+
+export const prepareFilesystemRequest: ToolModuleRequestPreparation = async (
+  modules,
+) => {
+  if (process.platform !== "win32" || modules.length === 0) return modules;
+  try {
+    const result = await runWindowsFilesystem({ operation: "probe" });
+    if (
+      !result ||
+      typeof result !== "object" ||
+      !("available" in result) ||
+      result.available !== true
+    )
+      return Object.freeze([]);
+  } catch {
+    return Object.freeze([]);
+  }
+  const availability: RequestAvailability = {};
+  return Object.freeze(
+    modules.map<ToolModuleDeclaration>((module) => ({
+      ...module,
+      implementation: (params, context) => {
+        if (availability.blocked)
+          return Promise.resolve(
+            failureResult({
+              errorCode: availability.blocked.code,
+              message: availability.blocked.message,
+              data: availability.blocked.data,
+            }),
+          );
+        return currentRequest.run(
+          { availability, signal: context?.abortSignal },
+          () => module.implementation(params, context),
+        );
+      },
+    })),
+  );
+};

package/plugins/filesystem/source/windows/source.ts

@@ -0,0 +1,42 @@
+import { WINDOWS_FILE_READ_BYTES } from "../../../../src/shared/windows-file-io/read-bytes-script.js";
+import { WINDOWS_FILESYSTEM_NATIVE } from "./native-script.js";
+import { WINDOWS_FILESYSTEM_AUTHORITY } from "./authority-script.js";
+import { WINDOWS_FILESYSTEM_READ } from "./read-script.js";
+import { WINDOWS_FILESYSTEM_STREAMS } from "./streams-script.js";
+import { WINDOWS_FILESYSTEM_STORAGE } from "./storage-script.js";
+import { WINDOWS_FILESYSTEM_PUBLICATION } from "./publication-script.js";
+import { WINDOWS_FILESYSTEM_WRITE } from "./write-script.js";
+
+const ENTRYPOINT = String.raw`
+public static partial class AbotFilesystem {
+  public static string Run(string input) {
+    var json=new JavaScriptSerializer { MaxJsonLength=2097152 };
+    try {
+      var request=json.Deserialize<Dictionary<string,object>>(input);
+      string operation=Text(request, "operation");
+      object result;
+      switch (operation) {
+        case "probe": result=Record("available", true); break;
+        case "read": result=ReadSlices(request); break;
+        case "sample": result=SampleDirectory(request); break;
+        case "write": result=CommitWrite(request); break;
+        default: throw new FsFault("filesystem_invalid_request");
+      }
+      return json.Serialize(Record("ok", true, "result", result));
+    } catch (FsFault error) { return json.Serialize(Record("ok", false, "code", error.Code)); }
+      catch { return json.Serialize(Record("ok", false, "code", "filesystem_native_operation_failed")); }
+  }
+}
+`;
+
+export const WINDOWS_FILESYSTEM_SOURCE = [
+  WINDOWS_FILESYSTEM_NATIVE,
+  WINDOWS_FILESYSTEM_AUTHORITY,
+  WINDOWS_FILE_READ_BYTES,
+  WINDOWS_FILESYSTEM_READ,
+  WINDOWS_FILESYSTEM_STREAMS,
+  WINDOWS_FILESYSTEM_STORAGE,
+  WINDOWS_FILESYSTEM_PUBLICATION,
+  WINDOWS_FILESYSTEM_WRITE,
+  ENTRYPOINT,
+].join("\n");

package/plugins/filesystem/source/windows/storage-script.ts

@@ -0,0 +1,11 @@
+/** Replacement must not silently remove per-file Windows storage properties. */
+export const WINDOWS_FILESYSTEM_STORAGE = String.raw`
+public static partial class AbotFilesystem {
+  static void RequireReplaceableStorage(SafeFileHandle file) {
+    const uint encrypted=0x4000, compressed=0x800;
+    if ((Basic(file).Attributes & (encrypted | compressed)) != 0)
+      throw new FsFault("filesystem_storage_attributes_unsupported");
+    RequireUnnamedDataStreamOnly(file);
+  }
+}
+`;

package/plugins/filesystem/source/windows/streams-script.ts

@@ -0,0 +1,24 @@
+/** Inspect the held file's stream names without reading their contents. */
+export const WINDOWS_FILESYSTEM_STREAMS = String.raw`
+public static partial class AbotFilesystem {
+  static void RequireUnnamedDataStreamOnly(SafeFileHandle file) {
+    // One unnamed data stream fits in 40 bytes. Extra entries/names must not
+    // be silently discarded by replacement; only a bounded header is needed.
+    const int capacity=64;
+    IntPtr buffer=Marshal.AllocHGlobal(capacity);
+    try {
+      if (!GetFileInformationByHandleEx(file, 7, buffer, capacity)) {
+        uint error=(uint)Marshal.GetLastWin32Error();
+        if (error == 122 || error == 234)
+          throw new FsFault("filesystem_named_streams_unsupported");
+        NativeFailure(error);
+      }
+      int next=Marshal.ReadInt32(buffer, 0), length=Marshal.ReadInt32(buffer, 4);
+      if (next != 0 || length != 14)
+        throw new FsFault("filesystem_named_streams_unsupported");
+      string name=Marshal.PtrToStringUni(IntPtr.Add(buffer, 24), length/2);
+      if (name != "::$DATA") throw new FsFault("filesystem_named_streams_unsupported");
+    } finally { Marshal.FreeHGlobal(buffer); }
+  }
+}
+`;

package/plugins/filesystem/source/windows/write-script.ts

@@ -0,0 +1,86 @@
+export const WINDOWS_FILESYSTEM_WRITE = String.raw`
+public static partial class AbotFilesystem {
+  static string Digest(byte[] bytes) {
+    using (var hash=System.Security.Cryptography.SHA256.Create())
+      return BitConverter.ToString(hash.ComputeHash(bytes)).Replace("-", "").ToLowerInvariant();
+  }
+  static SafeFileHandle ObserveExisting(SafeFileHandle parent, string name, Dictionary<string,object> expected) {
+    SafeFileHandle file=null;
+    try {
+      try { file=OpenHandle(parent, name, false, 1, 0x80020000, 7); }
+      catch (FsFault error) {
+        if (error.Code != "file_not_found") throw;
+        if (Text(expected, "kind") != "absent") throw new FsFault("filesystem_target_changed");
+        return null;
+      }
+      if (Text(expected, "kind") != "file") throw new FsFault("filesystem_target_changed");
+      var before=Metadata(file);
+      if (!SameMetadata(before, expected)) throw new FsFault("filesystem_target_changed");
+      long size=Convert.ToInt64(before["size"]);
+      if (size > 1048576) throw new FsFault("filesystem_target_changed");
+      byte[] bytes=ReadBytes(file, 0, (int)size);
+      if (!SameMetadata(before, Metadata(file)) || Digest(bytes) != Text(expected, "digest"))
+        throw new FsFault("filesystem_target_changed");
+      RequireReplaceableStorage(file);
+      return file;
+    } catch { if (file != null) file.Dispose(); throw; }
+  }
+  static byte[] PrivateFileSecurityDescriptor() {
+    var acl=new FileSecurity();
+    acl.SetAccessRuleProtection(true, false);
+    acl.AddAccessRule(new FileSystemAccessRule(WindowsIdentity.GetCurrent().User,
+      FileSystemRights.FullControl, AccessControlType.Allow));
+    return acl.GetSecurityDescriptorBinaryForm();
+  }
+  static void PreserveAccess(SafeFileHandle original, SafeFileHandle replacement) {
+    IntPtr owner, group, dacl, sacl, descriptor;
+    uint error=GetSecurityInfo(original, 1, 4, out owner, out group, out dacl, out sacl, out descriptor);
+    if (error != 0) NativeFailure(error);
+    try {
+      ushort control; uint revision;
+      Check(GetSecurityDescriptorControl(descriptor, out control, out revision));
+      uint protection=(control & 0x1000) != 0 ? 0x80000000u : 0x20000000u;
+      error=SetSecurityInfo(replacement, 1, 4 | protection, IntPtr.Zero, IntPtr.Zero, dacl, IntPtr.Zero);
+      if (error != 0) NativeFailure(error);
+      var basic=new BasicInfo { Attributes=Basic(original).Attributes & 0x27u };
+      if (basic.Attributes == 0) basic.Attributes=0x80;
+      Check(SetFileInformationByHandle(replacement, 0, ref basic, 40));
+    } finally { LocalFree(descriptor); }
+  }
+  static void WritePreparedContent(SafeFileHandle file, byte[] bytes) {
+    int offset=0;
+    while (offset < bytes.Length) {
+      var chunk=new byte[Math.Min(65536, bytes.Length-offset)];
+      Buffer.BlockCopy(bytes, offset, chunk, 0, chunk.Length);
+      uint written;
+      Check(WriteFile(file, chunk, (uint)chunk.Length, out written, IntPtr.Zero));
+      if (written == 0 || written > chunk.Length) throw new FsFault("filesystem_native_operation_failed");
+      offset+=(int)written;
+    }
+    Check(FlushFileBuffers(file));
+  }
+  static object CommitWrite(Dictionary<string,object> request) {
+    string[] parts=Components(request);
+    if (parts.Length == 0) throw new FsFault("not_a_file");
+    byte[] bytes=Convert.FromBase64String(Text(request, "content"));
+    if (bytes.Length > 1048576) throw new FsFault("file_too_large");
+    var expected=request["expected"] as Dictionary<string,object>;
+    if (expected == null) throw new FsFault("filesystem_invalid_request");
+    string name=parts[parts.Length-1];
+    using (var chain=new DirectoryChain(request)) {
+      chain.Walk(parts, parts.Length-1, true);
+      using (var previous=ObserveExisting(chain.Current, name, expected)) {
+        string temporary=".abot-"+Guid.NewGuid().ToString("N")+".tmp";
+        using (var file=OpenHandle(chain.Current, temporary, false, 2, 0xC0070000, 0, PrivateFileSecurityDescriptor(), true)) {
+          WritePreparedContent(file, bytes);
+          using (var current=ObserveExisting(chain.Current, name, expected)) {
+            if (current != null) PreserveAccess(current, file);
+            PublishLinkRelative(file, chain.Current, name, current != null);
+          }
+          return Record("committed", true);
+        }
+      }
+    }
+  }
+}
+`;