@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/chunks/canvas-preview-drctegz4.js

@@ -0,0 +1,591 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  run2,
+  findExecutable2
+} from "./canvas-preview-bxnqt8cd.js";
+import {
+  feed2
+} from "./canvas-preview-yjz0f7n4.js";
+import {
+  decodeText2
+} from "./canvas-preview-kn7kvbfj.js";
+import {
+  createIgnores2,
+  walkTree2,
+  watchTree2,
+  watchPath2,
+  readErrorCode2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/local/files.ts
+import { createHash, randomUUID } from "node:crypto";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  readdir,
+  readlink,
+  realpath,
+  rename,
+  rm,
+  stat,
+  unlink,
+  writeFile
+} from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, matchesGlob, relative, sep } from "node:path";
+import { createInterface } from "node:readline";
+import { spawn } from "node:child_process";
+import { asId, SdkError } from "@nyte-ai/schema";
+import { serial } from "@nyte-ai/schema/serial";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var TEXT_LIMIT2 = 1024 * 1024;
+var CHUNK = 64 * 1024;
+var FIND_DEFAULT = 20;
+var FIND_CAP = 50;
+var FIND_TTL_MS = 5000;
+var SEARCH_DEFAULT = 200;
+var SEARCH_LINE = 500;
+var WATCH_DELAY_MS = 100;
+var WATCH_POLL_MS = 1000;
+var FORMATTERS = ["oxfmt", "prettier", "biome"];
+function localFiles2(root, options) {
+  const absolute = (path) => isAbsolute(path) ? path : join(root, path);
+  const within = (path) => {
+    const inside = relative(root, path);
+    return inside.startsWith("..") || isAbsolute(inside) ? path : inside.split(sep).join("/");
+  };
+  let found = null;
+  const scanned = () => {
+    if (found !== null && Date.now() - found.at < FIND_TTL_MS)
+      return found.paths;
+    const paths = collectFiles(root);
+    found = { at: Date.now(), paths };
+    paths.catch(() => {
+      if (found?.paths === paths)
+        found = null;
+    });
+    return paths;
+  };
+  return {
+    async read(path) {
+      const target = absolute(path);
+      const stats = await stat(target).catch(missing);
+      if (stats === null)
+        return { kind: "missing", path };
+      if (stats.isDirectory())
+        throw new SdkError("invalid", `${path} is a directory.`);
+      if (stats.size > TEXT_LIMIT2)
+        return { kind: "large", path, size: stats.size, version: await hashFile(target) };
+      const bytes = await readFile(target).catch(missing);
+      if (bytes === null)
+        return { kind: "missing", path };
+      const version = hashVersion(bytes);
+      const text = decodeText2(bytes);
+      return text === null ? { kind: "binary", path, size: bytes.byteLength, version } : { kind: "text", path, contents: text, version };
+    },
+    async bytes(path) {
+      const target = absolute(path);
+      const stats = await stat(target).catch(missing);
+      if (stats === null || !stats.isFile())
+        throw new SdkError("unknown", `No file is at ${path}.`);
+      const version = await hashFile(target);
+      let handle = null;
+      const close = async () => {
+        const held = handle;
+        handle = null;
+        await held?.close();
+      };
+      return {
+        size: stats.size,
+        mime: null,
+        version,
+        async* chunks() {
+          handle = await open(target, "r");
+          try {
+            for (;; ) {
+              const held = handle;
+              if (held === null)
+                return;
+              const buffer = new Uint8Array(CHUNK);
+              const { bytesRead } = await held.read(buffer, 0, CHUNK, null);
+              if (bytesRead === 0)
+                return;
+              yield buffer.subarray(0, bytesRead);
+            }
+          } finally {
+            await close();
+          }
+        },
+        close,
+        [Symbol.asyncDispose]: close
+      };
+    },
+    async stat(path) {
+      const target = absolute(path);
+      const stats = await lstat(target).catch(missing);
+      if (stats === null)
+        return null;
+      if (stats.isSymbolicLink()) {
+        const link = await readLink(target);
+        return { kind: "symlink", size: stats.size, version: hashVersion(link), target: link };
+      }
+      if (stats.isDirectory())
+        return { kind: "directory", size: stats.size, version: await directoryVersion(target) };
+      return { kind: "file", size: stats.size, version: await hashFile(target) };
+    },
+    async write(path, contents, writeOptions) {
+      const target = await resolveLink(absolute(path));
+      const current = await currentVersion(target);
+      const expect = writeOptions?.expect;
+      if (expect === "absent" ? current !== null : expect !== undefined && expect !== current)
+        return { kind: "stale", current };
+      const parent = dirname(target);
+      const folder = await stat(parent).catch(missing);
+      if (folder === null) {
+        if (writeOptions?.parents !== true)
+          return { kind: "missing-parent" };
+        await mkdir(parent, { recursive: true });
+      } else if (!folder.isDirectory())
+        throw new SdkError("invalid", `${dirname(path)} is not a directory.`);
+      const bytes = typeof contents === "string" ? new TextEncoder().encode(contents) : contents;
+      const mode = (await stat(target).catch(missing))?.mode;
+      const temporary = join(parent, `.${basename(target)}.${randomUUID()}.nyte-tmp`);
+      try {
+        await writeFile(temporary, bytes);
+        if (mode !== undefined)
+          await chmod(temporary, mode & 4095);
+        await rename(temporary, target);
+      } catch (error) {
+        await unlink(temporary).catch(() => {
+          return;
+        });
+        throw error;
+      }
+      return { kind: "saved", version: hashVersion(bytes) };
+    },
+    async remove(path, removeOptions) {
+      const target = absolute(path);
+      const link = await lstat(target).catch(missing);
+      if (link === null)
+        return { kind: "stale", current: null };
+      const current = await currentVersion(target) ?? (link.isSymbolicLink() ? hashVersion(await readLink(target)) : null);
+      if (removeOptions?.expect !== undefined && removeOptions.expect !== current)
+        return { kind: "stale", current };
+      await rm(target, { recursive: link.isDirectory() });
+      return current === null ? { kind: "stale", current } : { kind: "saved", version: current };
+    },
+    batch: () => refusedBatch(),
+    async format(path, contents) {
+      return format(root, absolute(path), contents, options?.formatter);
+    },
+    async* scan(input) {
+      const directory = input?.directory ?? "";
+      const own = isAbsolute(directory);
+      const base = own ? directory : root;
+      const start = own ? "" : directory;
+      const ignores = createIgnores2(base);
+      const ignored = input?.ignored === "include" || start !== "" && await ignores.ignored(start, true) ? "include" : "exclude";
+      for await (const frame of walkTree2(base, { directory: start, ignored, ignores })) {
+        if (frame.kind !== "entries") {
+          yield frame;
+          continue;
+        }
+        yield {
+          kind: "entries",
+          entries: frame.entries.map((entry) => ({
+            path: own ? join(directory, entry.path) : entry.path,
+            kind: entry.kind,
+            size: entry.size,
+            version: null
+          }))
+        };
+      }
+    },
+    async find(input) {
+      const limit = Math.min(Math.max(1, input.limit ?? FIND_DEFAULT), FIND_CAP);
+      return rank(await scanned(), input.query, limit);
+    },
+    search(input) {
+      const drafts = new Map((input.drafts ?? []).map((draft) => [within(absolute(draft.path)), draft.contents]));
+      return search(root, input, drafts, options?.ripgrep);
+    },
+    watch(input) {
+      const paths = (input?.paths ?? []).map((path) => within(absolute(path)));
+      return watchFiles(root, paths, options?.signal);
+    },
+    upload: async () => {
+      throw new SdkError("unavailable", "Core stores uploads; the local provider does not.");
+    }
+  };
+}
+function hashVersion(data) {
+  return asId(sha2562(data));
+}
+function missing(error) {
+  const code = readErrorCode2(error);
+  if (code === "ENOENT" || code === "ENOTDIR")
+    return null;
+  throw error;
+}
+async function hashFile(path) {
+  const hash = createHash("sha256");
+  const handle = await open(path, "r");
+  try {
+    const buffer = new Uint8Array(CHUNK);
+    for (;; ) {
+      const { bytesRead } = await handle.read(buffer, 0, CHUNK, null);
+      if (bytesRead === 0)
+        break;
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+  } finally {
+    await handle.close();
+  }
+  return asId(hash.digest("hex"));
+}
+async function directoryVersion(path) {
+  return hashVersion((await readdir(path)).sort().join(`
+`));
+}
+async function currentVersion(path) {
+  const stats = await stat(path).catch(missing);
+  if (stats === null)
+    return null;
+  return stats.isDirectory() ? directoryVersion(path) : hashFile(path).catch(missing);
+}
+async function readLink(path) {
+  return (await readlink(path)).split(sep).join("/");
+}
+async function resolveLink(path) {
+  const link = await lstat(path).catch(missing);
+  return link?.isSymbolicLink() === true ? realpath(path).catch(() => path) : path;
+}
+function refusedBatch() {
+  return {
+    put: () => refusedBatch(),
+    remove: () => refusedBatch(),
+    apply: async () => {
+      throw new SdkError("unavailable", "Core applies file batches; the local provider does not.");
+    }
+  };
+}
+async function collectFiles(root) {
+  const entries = [];
+  for await (const frame of walkTree2(root, { ignored: "exclude" }))
+    if (frame.kind === "entries") {
+      for (const entry of frame.entries)
+        if (entry.kind !== "directory")
+          entries.push({ path: entry.path, kind: entry.kind, size: entry.size, version: null });
+    }
+  return entries;
+}
+function rank(entries, query, limit) {
+  const needle = query.trim().toLowerCase();
+  if (needle === "")
+    return entries.slice(0, limit);
+  const scored = entries.flatMap((entry) => {
+    const path = entry.path.toLowerCase();
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const score = name === needle ? 0 : name.startsWith(needle) ? 1 : name.includes(needle) ? 2 : path.includes(needle) ? 3 : subsequence(path, needle) ? 4 : null;
+    return score === null ? [] : [{ entry, score }];
+  });
+  return scored.sort((left, right) => left.score - right.score || left.entry.path.length - right.entry.path.length || (left.entry.path < right.entry.path ? -1 : 1)).slice(0, limit).map(({ entry }) => entry);
+}
+function subsequence(text, needle) {
+  let at = 0;
+  for (const char of text) {
+    if (char === needle[at])
+      at += 1;
+    if (at === needle.length)
+      return true;
+  }
+  return false;
+}
+async function format(root, path, contents, formatter) {
+  const binary = formatter ?? await detectFormatter(root);
+  if (binary === null)
+    return { kind: "unavailable", reason: "No formatter is installed for this workspace." };
+  const name = basename(binary).replace(/\.(cmd|exe)$/i, "");
+  const args = name === "biome" ? ["format", `--stdin-file-path=${path}`] : name === "oxfmt" ? [`--stdin-filepath=${path}`] : ["--stdin-filepath", path];
+  let ran;
+  try {
+    ran = await run2(binary, args, { cwd: root, input: contents });
+  } catch (error) {
+    return { kind: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (ran.code !== 0)
+    return {
+      kind: "unavailable",
+      reason: `${name} could not format ${basename(path)}: ${ran.stderr.trim()}`
+    };
+  const formatted = ran.stdout.toString("utf8");
+  return formatted === contents ? { kind: "unchanged" } : { kind: "formatted", contents: formatted };
+}
+async function detectFormatter(root) {
+  for (const name of FORMATTERS) {
+    const found = await findExecutable2(name, [join(root, "node_modules", ".bin")]);
+    if (found !== null)
+      return found;
+  }
+  return null;
+}
+async function* search(root, input, drafts, ripgrep) {
+  const limit = Math.max(1, input.limit ?? SEARCH_DEFAULT);
+  if (input.query === "") {
+    yield { kind: "complete" };
+    return;
+  }
+  const binary = await findExecutable2(ripgrep ?? "rg");
+  const matches = binary === null ? scanText(root, input, drafts) : grep(binary, root, input, drafts);
+  let count = 0;
+  for await (const match of matches) {
+    if (count >= limit) {
+      yield { kind: "truncated", limit };
+      return;
+    }
+    count += 1;
+    yield match;
+  }
+  yield { kind: "complete" };
+}
+function matchFlags(input) {
+  const casing = input.caseSensitive === undefined ? "--smart-case" : input.caseSensitive ? "--case-sensitive" : "--ignore-case";
+  return [
+    "--json",
+    "--no-config",
+    "--no-messages",
+    casing,
+    ...input.regex === true ? [] : ["--fixed-strings"],
+    ...input.wholeWord === true ? ["--word-regexp"] : []
+  ];
+}
+function fileFlags(input) {
+  return [
+    "--no-config",
+    "--hidden",
+    "--no-require-git",
+    "--glob=!.git",
+    ...(input.include ?? []).map((glob) => `--glob=${glob}`),
+    ...(input.exclude ?? []).map((glob) => `--glob=!${glob}`)
+  ];
+}
+function rejectFailure(code, stderr) {
+  if (code === 2 && stderr.trim() !== "")
+    throw new SdkError("invalid", stderr.trim());
+}
+function ripgrepPath(path) {
+  return path.split(sep).join("/").replace(/^\.\//, "");
+}
+async function* grep(binary, root, input, drafts) {
+  if (drafts.size > 0) {
+    const listed = await run2(binary, ["--files", ...fileFlags(input), "."], { cwd: root });
+    rejectFailure(listed.code, listed.stderr);
+    const searched = new Set(listed.stdout.toString("utf8").split(`
+`).map(ripgrepPath));
+    for (const [path, contents] of drafts) {
+      if (!searched.has(path))
+        continue;
+      const ran = await run2(binary, [...matchFlags(input), "--", input.query, "-"], {
+        cwd: root,
+        input: contents
+      });
+      rejectFailure(ran.code, ran.stderr);
+      for (const line of ran.stdout.toString("utf8").split(`
+`)) {
+        const match = ripgrepMatch(line);
+        if (match !== null)
+          yield { ...match, path };
+      }
+    }
+  }
+  const child = spawn(binary, [...matchFlags(input), ...fileFlags(input), "--", input.query, "."], {
+    cwd: root,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  let stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  const closed = new Promise((resolve) => child.on("close", resolve));
+  const lines = createInterface({ input: child.stdout, crlfDelay: Number.POSITIVE_INFINITY });
+  try {
+    for await (const line of lines) {
+      const match = ripgrepMatch(line);
+      if (match !== null && !drafts.has(match.path))
+        yield match;
+    }
+    rejectFailure(await closed, stderr);
+  } finally {
+    lines.close();
+    child.kill();
+    await closed;
+  }
+}
+var RipgrepMatchSchema = Type.Object({
+  type: Type.Literal("match"),
+  data: Type.Object({
+    path: Type.Object({ text: Type.String() }),
+    lines: Type.Object({ text: Type.String() }),
+    line_number: Type.Number(),
+    submatches: Type.Optional(Type.Array(Type.Unknown()))
+  })
+});
+var SubmatchSchema = Type.Object({ start: Type.Number(), end: Type.Number() });
+function ripgrepMatch(line) {
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!Value.Check(RipgrepMatchSchema, record))
+    return null;
+  const { path, lines, line_number: number, submatches } = record.data;
+  const first = submatches?.[0];
+  const { start, end } = Value.Check(SubmatchSchema, first) ? first : { start: 0, end: 0 };
+  const text = lines.text.replace(/\r?\n$/, "");
+  const bytes = new TextEncoder().encode(text);
+  const decoder = new TextDecoder;
+  return {
+    kind: "match",
+    path: ripgrepPath(path.text),
+    line: number,
+    column: decoder.decode(bytes.subarray(0, start)).length + 1,
+    length: decoder.decode(bytes.subarray(start, end)).length,
+    text: text.slice(0, SEARCH_LINE)
+  };
+}
+function linePattern(input) {
+  const source = input.regex === true ? input.query : RegExp.escape(input.query);
+  const sensitive = input.caseSensitive ?? input.query !== input.query.toLowerCase();
+  try {
+    return new RegExp(input.wholeWord === true ? `\\b(?:${source})\\b` : source, sensitive ? "u" : "iu");
+  } catch (error) {
+    throw new SdkError("invalid", error instanceof Error ? error.message : String(error));
+  }
+}
+function passesFilters(path, input) {
+  const parts = path.split("/");
+  const prefixes = parts.map((_, index) => parts.slice(0, index + 1).join("/"));
+  const matches = (glob, target) => matchesGlob(target, glob) || !glob.includes("/") && matchesGlob(basename(target), glob);
+  const include = input.include ?? [];
+  return (include.length === 0 || include.some((glob) => matches(glob, path))) && !(input.exclude ?? []).some((glob) => prefixes.some((prefix) => matches(glob, prefix)));
+}
+async function* scanText(root, input, drafts) {
+  const pattern = linePattern(input);
+  for await (const frame of walkTree2(root, { ignored: "exclude" })) {
+    if (frame.kind !== "entries")
+      continue;
+    for (const entry of frame.entries) {
+      if (entry.kind !== "file" || !passesFilters(entry.path, input))
+        continue;
+      const text = drafts.get(entry.path) ?? await readSearchable(join(root, entry.path), entry.size);
+      if (text === null)
+        continue;
+      for (const [index, raw] of text.split(`
+`).entries()) {
+        const line = raw.replace(/\r$/, "");
+        const found = pattern.exec(line);
+        if (found === null)
+          continue;
+        yield {
+          kind: "match",
+          path: entry.path,
+          line: index + 1,
+          column: found.index + 1,
+          length: found[0].length,
+          text: line.slice(0, SEARCH_LINE)
+        };
+      }
+    }
+  }
+}
+async function readSearchable(path, size) {
+  if ((size ?? 0) > TEXT_LIMIT2)
+    return null;
+  const bytes = await readFile(path).catch(() => null);
+  return bytes === null ? null : decodeText2(bytes);
+}
+function watchFiles(root, paths, signal) {
+  return feed2((sink) => {
+    const ignores = createIgnores2(root);
+    const known = new Map;
+    const started = Date.now();
+    const reads = serial();
+    const readEvent = async (path) => {
+      if (path.endsWith(".gitignore"))
+        ignores.forget(path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "");
+      if (await ignores.ignored(path, false))
+        return null;
+      const at = isAbsolute(path) ? path : join(root, path);
+      const stats = await lstat(at).catch(() => null);
+      if (stats?.isDirectory() === true)
+        return null;
+      const version = stats === null ? null : await currentVersion(at).catch(() => null);
+      const before = known.get(path);
+      known.set(path, version);
+      if (version === null)
+        return before === null ? null : { kind: "removed", path, version: null };
+      if (before === version)
+        return null;
+      const created = before === null || before === undefined && stats !== null && stats.birthtimeMs >= started - 1000;
+      return { kind: created ? "created" : "modified", path, version };
+    };
+    const listMoved = async (prefix, changed) => {
+      const inside = [...changed].flatMap((path) => path === "" ? [] : [`${prefix}/${path}`]);
+      if (!changed.has(""))
+        return inside;
+      const below = [...known.keys()].filter((path) => path.startsWith(`${prefix}/`));
+      for await (const frame of walkTree2(isAbsolute(prefix) ? prefix : join(root, prefix), {
+        ignored: "include"
+      }))
+        if (frame.kind === "entries") {
+          for (const entry of frame.entries)
+            if (entry.kind === "file")
+              below.push(`${prefix}/${entry.path}`);
+        }
+      return [prefix, ...below, ...inside];
+    };
+    const heard = (changed) => {
+      reads.run(async () => {
+        const events = [];
+        for (const path of await changed) {
+          if (path === "")
+            continue;
+          const event = await readEvent(path).catch(() => null);
+          if (event !== null)
+            events.push(event);
+        }
+        if (events.length > 0)
+          sink.push(events);
+      });
+    };
+    const watching = paths.length === 0 || paths.includes("") ? [watchTree2(root, { delay: WATCH_DELAY_MS, poll: WATCH_POLL_MS }, heard)] : paths.map((prefix) => watchPath2(isAbsolute(prefix) ? prefix : join(root, prefix), { delay: WATCH_DELAY_MS }, (changed) => heard(listMoved(prefix, changed))));
+    const dispose = () => {
+      for (const stop of watching)
+        stop();
+    };
+    const end = () => sink.end();
+    signal?.addEventListener("abort", end, { once: true });
+    if (signal?.aborted === true)
+      end();
+    return () => {
+      signal?.removeEventListener("abort", end);
+      dispose();
+    };
+  }, (waiting, next) => {
+    const merged = new Map(waiting.map((event) => [event.path, event]));
+    for (const event of next)
+      merged.set(event.path, event);
+    return [...merged.values()];
+  });
+}
+
+export { TEXT_LIMIT2, localFiles2 };