@abot-ai/runtime 1.7.0 → 1.8.1

package/plugins/filesystem/source/file-observation.ts

@@ -0,0 +1,151 @@
+import { constants } from "node:fs";
+import { open, realpath, stat, type FileHandle } from "node:fs/promises";
+import { relative, sep } from "node:path";
+import type { ResolvedRuntimeToolPath } from "../../../src/plugin-sdk/index.js";
+import { fail, rethrowFilesystemError } from "./errors.js";
+import {
+  metadataFromStat,
+  sameMetadata,
+  type MutationFileMetadata,
+} from "./file-version.js";
+import { readWindowsFileSlices } from "./windows/operations.js";
+
+type PositionalFileReader = Readonly<{
+  read(
+    buffer: Buffer,
+    offset: number,
+    length: number,
+    position: number,
+  ): Promise<Readonly<{ bytesRead: number }>>;
+}>;
+
+export async function readExactBytes(
+  reader: PositionalFileReader,
+  buffer: Buffer,
+  position: number,
+  logicalPath: string,
+): Promise<void> {
+  let offset = 0;
+  while (offset < buffer.length) {
+    const result = await reader.read(
+      buffer,
+      offset,
+      buffer.length - offset,
+      position + offset,
+    );
+    if (result.bytesRead <= 0 || result.bytesRead > buffer.length - offset) {
+      fail(
+        "filesystem_read_incomplete",
+        `File changed or ended before a complete read: ${logicalPath}`,
+      );
+    }
+    offset += result.bytesRead;
+  }
+}
+
+async function openRegularFile(target: ResolvedRuntimeToolPath): Promise<
+  Readonly<{
+    handle: FileHandle;
+    size: number;
+    metadata: MutationFileMetadata;
+  }>
+> {
+  let handle: FileHandle | undefined;
+  try {
+    if (typeof constants.O_NOFOLLOW !== "number") {
+      fail(
+        "filesystem_safe_io_unsupported",
+        "This platform does not provide the no-follow operation required for a safe read.",
+      );
+    }
+    handle = await open(
+      target.absolutePath,
+      constants.O_RDONLY | constants.O_NOFOLLOW,
+    );
+    const info = await handle.stat({ bigint: true });
+    if (!info.isFile()) {
+      fail("not_a_file", `Expected a regular file: ${target.logicalPath}`);
+    }
+    const metadata = metadataFromStat(info, target.logicalPath);
+    const [canonicalRoot, canonicalTarget] = await Promise.all([
+      realpath(target.rootPath),
+      realpath(target.absolutePath),
+    ]);
+    const rootRelative = relative(canonicalRoot, canonicalTarget);
+    if (
+      rootRelative === ".." ||
+      rootRelative.startsWith(`..${sep}`) ||
+      rootRelative.startsWith(sep)
+    ) {
+      fail(
+        "filesystem_path_changed",
+        `File changed outside its configured root: ${target.logicalPath}`,
+      );
+    }
+    const pathIdentity = await stat(canonicalTarget, { bigint: true });
+    if (
+      !pathIdentity.isFile() ||
+      pathIdentity.dev !== info.dev ||
+      pathIdentity.ino !== info.ino
+    ) {
+      fail(
+        "filesystem_path_changed",
+        `File changed while it was being opened: ${target.logicalPath}`,
+      );
+    }
+    return Object.freeze({ handle, size: metadata.size, metadata });
+  } catch (error: unknown) {
+    await handle?.close().catch(() => undefined);
+    rethrowFilesystemError(error, "inspect", target.logicalPath);
+  }
+}
+
+export async function observeFileSlices(
+  target: ResolvedRuntimeToolPath,
+  options: Readonly<{
+    headBytes: number;
+    tailBytes: number;
+    maximumFileBytes?: number;
+  }>,
+): Promise<
+  Readonly<{ metadata: MutationFileMetadata; head: Buffer; tail: Buffer }>
+> {
+  if (process.platform === "win32")
+    return readWindowsFileSlices(target, options);
+  const file = await openRegularFile(target);
+  try {
+    if (
+      options.maximumFileBytes !== undefined &&
+      file.size > options.maximumFileBytes
+    )
+      fail(
+        "file_too_large",
+        `File exceeds the mutation byte limit: ${target.logicalPath}`,
+        { byteCount: file.size, maxBytes: options.maximumFileBytes },
+      );
+    const complete = file.size <= options.headBytes + options.tailBytes;
+    const head = Buffer.alloc(complete ? file.size : options.headBytes);
+    const tail = Buffer.alloc(complete ? 0 : options.tailBytes);
+    await readExactBytes(file.handle, head, 0, target.logicalPath);
+    await readExactBytes(
+      file.handle,
+      tail,
+      file.size - tail.length,
+      target.logicalPath,
+    );
+    const after = metadataFromStat(
+      await file.handle.stat({ bigint: true }),
+      target.logicalPath,
+    );
+    if (!sameMetadata(file.metadata, after))
+      fail(
+        "filesystem_read_changed",
+        `File changed while it was being read: ${target.logicalPath}`,
+      );
+    return Object.freeze({ metadata: file.metadata, head, tail });
+  } catch (error) {
+    return rethrowFilesystemError(error, "read", target.logicalPath);
+  } finally {
+    await file.handle.close().catch(() => undefined);
+  }
+}

package/plugins/filesystem/source/file-version.ts

@@ -0,0 +1,41 @@
+import type { BigIntStats } from "node:fs";
+import { fail } from "./errors.js";
+
+export type MutationFileMetadata = Readonly<{
+  device: bigint;
+  inode: bigint;
+  size: number;
+  mode: number;
+  modifiedNs: bigint;
+  changedNs: bigint;
+}>;
+
+export function metadataFromStat(
+  info: BigIntStats,
+  logicalPath: string,
+): MutationFileMetadata {
+  if (info.size > BigInt(Number.MAX_SAFE_INTEGER))
+    fail("file_too_large", `File is too large to read safely: ${logicalPath}`);
+  return Object.freeze({
+    device: info.dev,
+    inode: info.ino,
+    size: Number(info.size),
+    mode: Number(info.mode) & 0o7777,
+    modifiedNs: info.mtimeNs,
+    changedNs: info.ctimeNs,
+  });
+}
+
+export function sameMetadata(
+  left: MutationFileMetadata,
+  right: MutationFileMetadata,
+): boolean {
+  return (
+    left.device === right.device &&
+    left.inode === right.inode &&
+    left.size === right.size &&
+    left.mode === right.mode &&
+    left.modifiedNs === right.modifiedNs &&
+    left.changedNs === right.changedNs
+  );
+}

package/plugins/filesystem/source/index.ts

@@ -1,3 +1,4 @@
+import { prepareFilesystemRequest } from "./windows/request-availability.js";
 import {
   defineRuntimePlugin,
   failureFromError,
@@ -27,6 +28,10 @@ function settle(
           errorCode: error.code,
           message: error.message,
           data: error.data,
+          ...(error.code === "filesystem_windows_interrupted" &&
+          context?.abortSignal?.aborted
+            ? { interruption: "aborted" as const }
+            : {}),
         });
       }
       return failureFromError(error, {
@@ -42,6 +47,7 @@ export default defineRuntimePlugin((context) => {
   const paths = createFilesystemPathService(context.runtimePathResolver);
   const mutations = getProcessFilesystemMutationCoordinator();
   return Object.freeze({
+    prepareRequest: prepareFilesystemRequest,
     handlers: Object.freeze({
       dev_view: settle(createDevViewHandler(paths), "dev_view"),
       edit_file: settle(createEditFileHandler(paths, mutations), "edit_file"),

package/plugins/filesystem/source/mutation-coordinator.ts

@@ -10,6 +10,7 @@ function createFilesystemMutationCoordinator(): FilesystemMutationCoordinator {
       targetKey: string,
       task: () => Promise<T>,
     ): Promise<T> {
+      if (process.platform === "win32") targetKey = targetKey.toUpperCase();
       const previous = tails.get(targetKey) ?? Promise.resolve();
       let release!: () => void;
       const current = new Promise<void>((resolve) => {

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

@@ -0,0 +1 @@
+export { WINDOWS_FILESYSTEM_AUTHORITY } from "../../../../src/shared/windows-file-io/authority-script.js";

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

@@ -0,0 +1 @@
+export { WINDOWS_FILESYSTEM_NATIVE } from "../../../../src/shared/windows-file-io/native-script.js";

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

@@ -0,0 +1,197 @@
+import { open, type FileHandle } from "node:fs/promises";
+import { win32 } from "node:path";
+import type { ResolvedRuntimeToolPath } from "../../../../src/plugin-sdk/index.js";
+import { fail, rethrowFilesystemError } from "../errors.js";
+import type { MutationFileMetadata } from "../file-version.js";
+import type { MutationTargetVersion } from "../bounded-io.js";
+import { executeWindowsFilesystem } from "./request-availability.js";
+
+type NativeMetadata = {
+  device: string;
+  inode: string;
+  size: number;
+  mode: number;
+  modifiedNs: string;
+  changedNs: string;
+};
+
+async function withTarget<Result>(
+  target: ResolvedRuntimeToolPath,
+  run: (
+    request: Readonly<Record<string, unknown>>,
+    root: FileHandle,
+  ) => Promise<Result>,
+): Promise<Result> {
+  const expectedPath = win32.resolve(target.rootPath, target.relativePath);
+  if (win32.relative(expectedPath, target.absolutePath) !== "")
+    fail(
+      "filesystem_path_changed",
+      "The resolved file target no longer matches its root.",
+    );
+  const relative = win32.relative(target.rootPath, expectedPath);
+  if (
+    win32.isAbsolute(relative) ||
+    relative === ".." ||
+    relative.startsWith("..\\")
+  )
+    fail(
+      "filesystem_path_changed",
+      "The file target is outside its configured root.",
+    );
+  let root: FileHandle | undefined;
+  try {
+    root = await open(target.rootPath, "r");
+    const identity = await root.stat({ bigint: true });
+    if (!identity.isDirectory())
+      fail("not_a_directory", "The configured root is not a directory.");
+    if (identity.ino <= 0n)
+      fail(
+        "filesystem_safe_io_unsupported",
+        "The configured filesystem does not provide a stable file identity.",
+      );
+    return await run(
+      {
+        rootPath: target.rootPath,
+        relativePath: target.relativePath,
+        rootIdentity: {
+          device: String(identity.dev),
+          inode: String(identity.ino),
+          birthtimeNs: String(identity.birthtimeNs),
+        },
+      },
+      root,
+    );
+  } catch (error) {
+    return rethrowFilesystemError(error, "inspect", target.logicalPath);
+  } finally {
+    await root?.close().catch(() => undefined);
+  }
+}
+
+function decodeMetadata(value: NativeMetadata): MutationFileMetadata {
+  const validSize = Number.isSafeInteger(value?.size) && value.size >= 0;
+  if (!validSize || !Number.isSafeInteger(value?.mode))
+    fail(
+      "filesystem_windows_response_invalid",
+      "The filesystem helper returned invalid file metadata.",
+    );
+  const fields = [value.device, value.inode, value.modifiedNs, value.changedNs];
+  if (
+    !fields.every(
+      (field) => typeof field === "string" && /^-?\d{1,30}$/u.test(field),
+    )
+  )
+    fail(
+      "filesystem_windows_response_invalid",
+      "The filesystem helper returned invalid file identity.",
+    );
+  return Object.freeze({
+    device: BigInt(value.device),
+    inode: BigInt(value.inode),
+    size: value.size,
+    mode: value.mode,
+    modifiedNs: BigInt(value.modifiedNs),
+    changedNs: BigInt(value.changedNs),
+  });
+}
+
+export async function readWindowsFileSlices(
+  target: ResolvedRuntimeToolPath,
+  options: Readonly<{
+    headBytes: number;
+    tailBytes: number;
+    maximumFileBytes?: number;
+  }>,
+): Promise<
+  Readonly<{ metadata: MutationFileMetadata; head: Buffer; tail: Buffer }>
+> {
+  return withTarget(target, async (request) => {
+    const result = (await executeWindowsFilesystem({
+      ...request,
+      operation: "read",
+      ...options,
+      maximumFileBytes: options.maximumFileBytes ?? 0,
+    })) as { metadata: NativeMetadata; head: string; tail: string };
+    const metadata = decodeMetadata(result?.metadata);
+    if (typeof result.head !== "string" || typeof result.tail !== "string")
+      fail(
+        "filesystem_windows_response_invalid",
+        "The filesystem helper returned invalid file bytes.",
+      );
+    const head = Buffer.from(result.head, "base64"),
+      tail = Buffer.from(result.tail, "base64");
+    const complete = metadata.size <= options.headBytes + options.tailBytes;
+    const expectedHead = complete ? metadata.size : options.headBytes;
+    const expectedTail = complete ? 0 : options.tailBytes;
+    if (head.length !== expectedHead || tail.length !== expectedTail)
+      fail(
+        "filesystem_read_incomplete",
+        "The filesystem helper returned incomplete file bytes.",
+      );
+    return Object.freeze({ metadata, head, tail });
+  });
+}
+
+export async function sampleWindowsDirectory(
+  target: ResolvedRuntimeToolPath,
+  maxEntries: number,
+): Promise<Readonly<{ entries: readonly string[]; truncated: boolean }>> {
+  return withTarget(target, async (request) => {
+    const result = (await executeWindowsFilesystem({
+      ...request,
+      operation: "sample",
+      maxEntries,
+    })) as {
+      entries: string[];
+      truncated: boolean;
+    };
+    if (
+      !Array.isArray(result?.entries) ||
+      result.entries.length > maxEntries ||
+      !result.entries.every((entry) => typeof entry === "string") ||
+      typeof result.truncated !== "boolean"
+    )
+      fail(
+        "filesystem_windows_response_invalid",
+        "The filesystem helper returned an invalid directory sample.",
+      );
+    return Object.freeze({
+      entries: Object.freeze(result.entries.sort((a, b) => a.localeCompare(b))),
+      truncated: result.truncated,
+    });
+  });
+}
+
+export async function writeWindowsFile(
+  input: Readonly<{
+    target: ResolvedRuntimeToolPath;
+    content: string;
+    expectedVersion: MutationTargetVersion;
+    onCommitted?: (root: FileHandle) => void;
+  }>,
+): Promise<void> {
+  await withTarget(input.target, async (request, root) => {
+    const expected = Object.fromEntries(
+      Object.entries(input.expectedVersion).map(([key, value]) => [
+        key,
+        typeof value === "bigint" ? String(value) : value,
+      ]),
+    );
+    const result = (await executeWindowsFilesystem({
+      ...request,
+      operation: "write",
+      content: Buffer.from(input.content, "utf8").toString("base64"),
+      expected,
+    })) as { committed?: unknown };
+    if (result?.committed !== true)
+      fail(
+        "filesystem_windows_response_invalid",
+        "The filesystem helper did not confirm the write; do not repeat it automatically.",
+      );
+    try {
+      input.onCommitted?.(root);
+    } catch {
+      /* Presentation cannot undo a committed write. */
+    }
+  });
+}

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

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { failNotDirectory, FilesystemToolError, isDirectoryTypeFailure } from "../errors.js";
+import { WINDOWS_FILESYSTEM_SOURCE } from "./source.js";
+
+const MAX_MESSAGE_BYTES = 2 * 1024 * 1024;
+const BOOTSTRAP = [
+  "$ErrorActionPreference='Stop'",
+  'if ($ExecutionContext.SessionState.LanguageMode -ne \'FullLanguage\') { Write-Output \'{"ok":false,"code":"filesystem_windows_policy_blocked"}\'; exit 0 }',
+  "$env:PSModulePath=[IO.Path]::Combine($PSHOME,'Modules')",
+  "[Console]::InputEncoding=[Text.UTF8Encoding]::new($false)",
+  "[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false)",
+  "$started=$false",
+  "try {",
+  "$envelope=[Console]::In.ReadToEnd() | ConvertFrom-Json",
+  "Add-Type -ReferencedAssemblies @('System.Web.Extensions') -TypeDefinition $envelope.source",
+  "$started=$true",
+  "[Console]::Write([AbotFilesystem]::Run($envelope.request))",
+  '} catch { if ($started) { [Console]::Write(\'{"ok":false,"code":"filesystem_windows_operation_unreported"}\') } else { [Console]::Write(\'{"ok":false,"code":"filesystem_windows_helper_unavailable"}\') } }',
+].join(";");
+const NATIVE_CODES = new Set([
+  "file_not_found",
+  "file_too_large",
+  "not_a_file",
+  "not_a_directory",
+  "filesystem_access_denied",
+  "filesystem_safe_io_unsupported",
+  "filesystem_storage_attributes_unsupported",
+  "filesystem_named_streams_unsupported",
+  "filesystem_windows_publication_unsupported",
+  "filesystem_path_changed",
+  "filesystem_target_changed",
+  "filesystem_invalid_path",
+  "filesystem_read_changed",
+  "filesystem_read_incomplete",
+  "filesystem_invalid_request",
+  "filesystem_native_operation_failed",
+  "filesystem_windows_policy_blocked",
+  "filesystem_windows_helper_unavailable",
+]);
+
+export function isWindowsHelperBlocked(
+  error: unknown,
+): error is FilesystemToolError {
+  if (!(error instanceof FilesystemToolError)) return false;
+  return (
+    error.code === "filesystem_windows_policy_blocked" ||
+    error.code === "filesystem_windows_helper_unavailable"
+  );
+}
+
+function helperFailure(code: string, mutation: boolean): FilesystemToolError {
+  if (code === "filesystem_windows_publication_unsupported")
+    return new FilesystemToolError(
+      code,
+      "Windows cannot safely publish this file. Writes require Windows 10 version 1809 or newer and a filesystem supporting hard links, such as NTFS. The destination was left unchanged. Do not retry this write on the same unsupported target.",
+      {
+        retryable: false,
+        blockedBy: "filesystem_publication_support",
+        targetUnchanged: true,
+      },
+    );
+  if (code === "filesystem_named_streams_unsupported")
+    return new FilesystemToolError(
+      code,
+      "This file has Windows named data streams, which may include download-origin security information. Editing it is not supported; the original file and its streams were left unchanged. Do not retry this edit or remove the streams to bypass the restriction.",
+      {
+        retryable: false,
+        blockedBy: "file_named_streams",
+        targetUnchanged: true,
+      },
+    );
+  if (code === "filesystem_storage_attributes_unsupported")
+    return new FilesystemToolError(
+      code,
+      "This file uses EFS encryption or NTFS compression. Editing it is not supported; the original file was left unchanged. Do not retry this edit or remove its storage attributes to bypass the restriction.",
+      {
+        retryable: false,
+        blockedBy: "file_storage_attributes",
+        targetUnchanged: true,
+      },
+    );
+  if (code === "filesystem_windows_policy_blocked")
+    return new FilesystemToolError(
+      code,
+      "Windows policy blocks the filesystem helper. No file operation ran. Retrying cannot resolve this restriction; ask the user to contact their administrator. Do not bypass the restriction.",
+      {
+        retryable: false,
+        blockedBy: "system_policy",
+        operationOutcome: "not_started",
+      },
+    );
+  if (code === "filesystem_windows_helper_unavailable")
+    return new FilesystemToolError(
+      code,
+      "The Windows filesystem helper is unavailable. No file operation ran. Do not retry in this request; the user must resolve helper availability first.",
+      {
+        retryable: false,
+        blockedBy: "helper_availability",
+        operationOutcome: "not_started",
+      },
+    );
+  return new FilesystemToolError(
+    code,
+    mutation
+      ? "The filesystem helper did not report a completed operation. The file state is unknown; do not repeat the write automatically."
+      : "The Windows filesystem helper did not complete the read.",
+    {
+      retryable: false,
+      operationOutcome: mutation ? "unknown" : "not_started",
+    },
+  );
+}
+
+/** One isolated operation. Never changes Windows policy, installs software or retries a write. */
+export async function runWindowsFilesystem(
+  request: Readonly<Record<string, unknown>>,
+  signal?: AbortSignal,
+  spawnProcess: typeof spawn = spawn,
+): Promise<unknown> {
+  const mutation = request.operation === "write";
+  if (signal?.aborted)
+    throw helperFailure("filesystem_windows_interrupted", false);
+  const input = JSON.stringify({
+    source: WINDOWS_FILESYSTEM_SOURCE,
+    request: JSON.stringify(request),
+  });
+  if (Buffer.byteLength(input) > MAX_MESSAGE_BYTES)
+    throw new FilesystemToolError(
+      "filesystem_invalid_request",
+      "Filesystem helper input exceeds its byte limit.",
+    );
+  const executable = join(
+    process.env.SystemRoot ?? "C:\\Windows",
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe",
+  );
+  const raw = await new Promise<string>((resolve, reject) => {
+    const child = spawnProcess(
+      executable,
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", BOOTSTRAP],
+      { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] },
+    );
+    const chunks: Buffer[] = [];
+    let bytes = 0;
+    let failure: FilesystemToolError | undefined;
+    const stop = (code: string) => {
+      failure ??= helperFailure(code, mutation);
+      child.kill("SIGKILL");
+    };
+    const abort = () => stop("filesystem_windows_interrupted");
+    const timer = setTimeout(() => stop("filesystem_windows_timeout"), 15_000);
+    timer.unref();
+    signal?.addEventListener("abort", abort, { once: true });
+    child.stdout.on("data", (chunk: Buffer) => {
+      bytes += chunk.length;
+      if (bytes > MAX_MESSAGE_BYTES) {
+        stop("filesystem_windows_output_limit");
+        return;
+      }
+      chunks.push(chunk);
+    });
+    // Native diagnostics can contain paths or file contents; never return them as tool evidence.
+    child.stderr.resume();
+    child.stdin.on("error", () => stop("filesystem_windows_transport_failed"));
+    child.once("error", () => {
+      failure ??=
+        child.pid === undefined
+          ? helperFailure("filesystem_windows_helper_unavailable", false)
+          : helperFailure("filesystem_windows_transport_failed", mutation);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      if (failure) {
+        reject(failure);
+        return;
+      }
+      if (code !== 0) {
+        reject(helperFailure("filesystem_windows_transport_failed", mutation));
+        return;
+      }
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    if (signal?.aborted) {
+      abort();
+      return;
+    }
+    child.stdin.end(input, "utf8");
+  });
+  let envelope: { ok?: unknown; result?: unknown; code?: unknown };
+  try {
+    envelope = JSON.parse(raw) as typeof envelope;
+  } catch {
+    throw helperFailure("filesystem_windows_response_invalid", mutation);
+  }
+  if (envelope?.ok === true) return envelope.result;
+  const code = typeof envelope?.code === "string" ? envelope.code : "";
+  if (!NATIVE_CODES.has(code))
+    throw helperFailure("filesystem_windows_response_invalid", mutation);
+  if (isDirectoryTypeFailure(code)) failNotDirectory();
+  if (
+    code === "filesystem_storage_attributes_unsupported" ||
+    code === "filesystem_named_streams_unsupported"
+  )
+    throw helperFailure(code, mutation);
+  if (code.startsWith("filesystem_windows_")) throw helperFailure(code, false);
+  throw new FilesystemToolError(
+    code,
+    "The filesystem operation was rejected: " + code + ".",
+  );
+}

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

@@ -0,0 +1,29 @@
+/** Publish the prepared file while its temporary name stays delete-on-close. */
+export const WINDOWS_FILESYSTEM_PUBLICATION = String.raw`
+public static partial class AbotFilesystem {
+  static void CheckLinkPublication(int status) {
+    if (status >= 0) return;
+    uint error=RtlNtStatusToDosError(status);
+    if (error == 1 || error == 50 || error == 87)
+      throw new FsFault("filesystem_windows_publication_unsupported");
+    NativeFailure(error);
+  }
+  static void PublishLinkRelative(SafeFileHandle file, SafeFileHandle parent, string name, bool replace) {
+    byte[] bytes=Encoding.Unicode.GetBytes(name);
+    int rootOffset=IntPtr.Size == 8 ? 8 : 4;
+    int lengthOffset=rootOffset+IntPtr.Size, nameOffset=lengthOffset+4;
+    IntPtr buffer=Marshal.AllocHGlobal(nameOffset+bytes.Length);
+    try {
+      for (int i=0;i<nameOffset;i++) Marshal.WriteByte(buffer, i, 0);
+      // FileLinkInformationEx: replace the destination atomically, retaining
+      // existing observations. Closing this handle deletes only its temporary name.
+      Marshal.WriteInt32(buffer, 0, replace ? 3 : 0);
+      Marshal.WriteIntPtr(buffer, rootOffset, parent.DangerousGetHandle());
+      Marshal.WriteInt32(buffer, lengthOffset, bytes.Length);
+      Marshal.Copy(bytes, 0, IntPtr.Add(buffer, nameOffset), bytes.Length);
+      IoStatus status;
+      CheckLinkPublication(NtSetInformationFile(file, out status, buffer, (uint)(nameOffset+bytes.Length), 72));
+    } finally { Marshal.FreeHGlobal(buffer); }
+  }
+}
+`;