@nyte-ai/host 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,134 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  localFiles2
+} from "./canvas-preview-ymgz0937.js";
+import {
+  localGit2
+} from "./canvas-preview-xn10d4f8.js";
+import {
+  localGitHub2
+} from "./canvas-preview-75db60xy.js";
+import {
+  folderIdentity2
+} from "./canvas-preview-1sq7z9jq.js";
+import {
+  localExec2
+} from "./canvas-preview-ehf3vp31.js";
+import {
+  localSnapshots2
+} from "./canvas-preview-senpjwep.js";
+import {
+  localWorktrees2
+} from "./canvas-preview-rp6fz0w5.js";
+
+// src/local/provider.ts
+import { constants, realpathSync } from "node:fs";
+import { access, readdir, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { asId, SdkError } from "@nyte-ai/schema";
+var PLUGIN_FILE = /\.(?:ts|mts|js|mjs)$/;
+var ROOT_SOURCES = [".nyte/SYSTEM.md", ".nyte/APPEND_SYSTEM.md", ".nyte/mcp.json"];
+function localProvider2(options) {
+  const home = options?.home ?? homedir();
+  const store = join(home, ".nyte", "snapshots");
+  let state;
+  const github = localGitHub2({ gh: options?.gh, git: options?.git });
+  return {
+    kind: "local",
+    async inspect(target) {
+      const path = readTargetPath(target);
+      if (path === null)
+        return {
+          identity: asId(sha2562(JSON.stringify(target))),
+          availability: { kind: "unavailable", reason: "unsupported" },
+          projectSources: []
+        };
+      const identity = await folderIdentity2(path);
+      if (!await readableDirectory(path))
+        return {
+          identity,
+          availability: { kind: "unavailable", reason: "unreachable" },
+          projectSources: []
+        };
+      return {
+        identity,
+        availability: { kind: "available" },
+        projectSources: await projectSources(path)
+      };
+    },
+    async attach(target) {
+      const path = readTargetPath(target);
+      if (path === null)
+        throw new SdkError("unavailable", "A local workspace needs a path.");
+      const real = await realpath(path).catch(() => null);
+      if (real === null || !await readableDirectory(real))
+        throw new SdkError("unavailable", `${path} is not a readable directory.`);
+      const detached = new AbortController;
+      const env = {
+        identity: await folderIdentity2(real),
+        cwd: real,
+        files: localFiles2(real, {
+          ripgrep: options?.ripgrep,
+          formatter: options?.formatter,
+          signal: detached.signal
+        }),
+        exec: localExec2(real, { shell: options?.shell, signal: detached.signal }),
+        close: async () => detached.abort()
+      };
+      return env;
+    },
+    git: (env) => localGit2(env, { git: options?.git }),
+    github,
+    snapshots(env) {
+      state ??= join(realpathOrSelf(home), ".nyte");
+      return nests(env.cwd, state) || nests(state, env.cwd) && !nests(join(state, "worktrees"), env.cwd) ? undefined : localSnapshots2(env, { store, git: options?.git });
+    },
+    worktrees: localWorktrees2({ home, git: options?.git }),
+    async destroy() {
+      throw new SdkError("unavailable", "A local folder is never torn down.");
+    }
+  };
+}
+function realpathOrSelf(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function nests(outer, inner) {
+  const path = relative(outer, inner);
+  return path === "" || path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+function readTargetPath(target) {
+  return "path" in target && typeof target.path === "string" ? target.path : null;
+}
+async function readableDirectory(path) {
+  const stats = await stat(path).catch(() => null);
+  return stats !== null && stats.isDirectory() && await access(path, constants.R_OK | constants.X_OK).then(() => true, () => false);
+}
+async function projectSources(root) {
+  const names = async (directory) => (await readdir(join(root, directory)).catch(() => [])).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  const fileExists = async (path) => (await stat(join(root, path)).catch(() => null))?.isFile() === true;
+  const plugins = (await Promise.all((await names(".nyte/plugins")).map(async (name) => {
+    const path = `.nyte/plugins/${name}`;
+    if (PLUGIN_FILE.test(name) && await fileExists(path))
+      return [path];
+    for (const index of ["index.ts", "index.mts", "index.js", "index.mjs"])
+      if (await fileExists(`${path}/${index}`))
+        return [`${path}/${index}`];
+    return [];
+  }))).flat();
+  const skills = (await Promise.all([".nyte/skills", ".agents/skills"].map(async (directory) => (await Promise.all((await names(directory)).map(async (name) => {
+    const path = `${directory}/${name}/SKILL.md`;
+    return await fileExists(path) ? [path] : [];
+  }))).flat()))).flat();
+  const prompts = (await names(".nyte/prompts")).filter((name) => name.endsWith(".md")).map((name) => `.nyte/prompts/${name}`);
+  const present = await Promise.all(ROOT_SOURCES.map(async (path) => await fileExists(path) ? [path] : []));
+  return [...plugins, ...skills, ...prompts, ...present.flat()];
+}
+
+export { localProvider2 };

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

@@ -0,0 +1,244 @@
+// src/sqlite-workers.ts
+import { Worker } from "node:worker_threads";
+import { dev } from "@nyte-ai/core";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var rowSchema = Type.Record(Type.String(), Type.Union([Type.Null(), Type.String(), Type.Number(), Type.BigInt()]));
+var replySchema = Type.Union([
+  Type.Object({ ready: Type.Literal(true) }),
+  Type.Object({ id: Type.Integer(), rows: Type.Array(rowSchema), executionMs: Type.Number() }),
+  Type.Object({
+    id: Type.Integer(),
+    error: Type.String(),
+    code: Type.Optional(Type.String()),
+    errcode: Type.Optional(Type.Number()),
+    errstr: Type.Optional(Type.String())
+  })
+]);
+var source = String.raw`
+const { parentPort, workerData } = require("node:worker_threads");
+const { DatabaseSync } = require("node:sqlite");
+const db = new DatabaseSync(workerData.path, {
+  readOnly: workerData.role === "reader",
+  timeout: 5000,
+});
+if (String(db.prepare("PRAGMA journal_mode").get().journal_mode).toLowerCase() !== "wal")
+  throw new Error("SQLite workers require WAL mode");
+if (workerData.role === "checkpoint") {
+  const version = db.prepare("SELECT sqlite_version() AS version").get().version;
+  const [major, minor] = version.split(".").map(Number);
+  if (major < 3 || (major === 3 && minor < 51))
+    throw new Error("SQLite " + version + " has no NOOP checkpoint");
+  db.exec("PRAGMA synchronous = NORMAL; PRAGMA checkpoint_fullfsync = ON");
+}
+const statements = new Map();
+const frames = workerData.role === "checkpoint" ? db.prepare("PRAGMA wal_checkpoint(NOOP)") : null;
+const checkpoint = workerData.role === "checkpoint" ? db.prepare("PRAGMA wal_checkpoint(PASSIVE)") : null;
+let idle;
+parentPort.on("message", ({ id, sql, params }) => {
+  const started = performance.now();
+  try {
+    let rows = [];
+    if (workerData.role === "checkpoint") {
+      const { log, checkpointed } = frames.get();
+      if (log - checkpointed >= 1000) checkpoint.get();
+      clearTimeout(idle);
+      idle = setTimeout(() => {
+        const { log, checkpointed } = frames.get();
+        if (log >= 1000 && checkpointed < log) checkpoint.get();
+      }, 100);
+    } else {
+      const size = params.reduce((total, value) => total + (typeof value === "string" ? value.length : ArrayBuffer.isView(value) ? value.byteLength : 0), 0);
+      let statement = size > 65536 ? undefined : statements.get(sql);
+      if (statement === undefined) {
+        statement = db.prepare(sql);
+        if (size <= 65536) {
+          if (statements.size >= 16) statements.delete(statements.keys().next().value);
+          statements.set(sql, statement);
+        }
+      }
+      rows = statement.all(...params);
+    }
+    parentPort.postMessage({ id, rows, executionMs: performance.now() - started });
+  } catch (error) {
+    parentPort.postMessage({ id, error: String(error.message), code: error.code, errcode: error.errcode, errstr: error.errstr });
+  }
+});
+parentPort.postMessage({ ready: true });
+`;
+
+class SqliteWorker {
+  ready;
+  worker;
+  nextId = 0;
+  pending = new Map;
+  stop;
+  constructor(path, role, unavailable) {
+    const worker = new Worker(source, { eval: true, workerData: { path, role } });
+    this.worker = worker;
+    let started = false;
+    let announce = () => {
+      return;
+    };
+    this.ready = new Promise((resolve) => {
+      announce = resolve;
+    });
+    const timeout = setTimeout(() => {
+      this.stop(new Error("SQLite worker did not start within 10 seconds"), true);
+    }, 1e4);
+    timeout.unref();
+    this.stop = (cause, notify) => {
+      if (this.worker === null)
+        return;
+      this.worker = null;
+      clearTimeout(timeout);
+      announce(false);
+      for (const request of this.pending.values())
+        request.reject(cause);
+      this.pending.clear();
+      if (notify)
+        unavailable(cause, started);
+      return worker.terminate();
+    };
+    worker.on("message", (reply) => {
+      if (!Value.Check(replySchema, reply)) {
+        this.stop(new Error("Malformed SQLite worker reply"), true);
+        return;
+      }
+      if ("ready" in reply) {
+        clearTimeout(timeout);
+        started = true;
+        announce(true);
+        if (this.pending.size === 0)
+          worker.unref();
+        return;
+      }
+      const request = this.pending.get(reply.id);
+      if (request === undefined)
+        return;
+      this.pending.delete(reply.id);
+      if (this.pending.size === 0)
+        worker.unref();
+      if ("error" in reply) {
+        request.reject(Object.assign(new Error(reply.error), reply));
+      } else {
+        dev("sqlite", "query", {
+          connection: role,
+          durationMs: performance.now() - request.at,
+          executionMs: reply.executionMs
+        });
+        request.resolve(reply.rows);
+      }
+    });
+    worker.on("error", (cause) => {
+      this.stop(cause instanceof Error ? cause : new Error(String(cause)), true);
+    });
+    worker.on("exit", (code) => {
+      this.stop(new Error(`SQLite ${role} worker exited with code ${code}`), true);
+    });
+    if (role === "checkpoint")
+      worker.unref();
+  }
+  async query(sql, params) {
+    if (!await this.ready)
+      return;
+    const worker = this.worker;
+    if (worker === null)
+      throw new Error("SQLite worker stopped");
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, at: performance.now() });
+      worker.ref();
+      try {
+        worker.postMessage({ id, sql, params });
+      } catch (cause) {
+        this.pending.delete(id);
+        if (this.pending.size === 0)
+          worker.unref();
+        reject(cause);
+      }
+    });
+  }
+  async close() {
+    await this.stop(new Error("SQLite worker closed"), false);
+  }
+}
+function sqliteWorkers2(database, path) {
+  let reader = null;
+  let readerUnavailable = false;
+  let closed = false;
+  let checking = false;
+  let checkAgain = false;
+  let checkpoint = null;
+  const warn = (role, cause) => {
+    process.emitWarning(`SQLite ${role} worker unavailable; using the main connection: ${cause.message}`, {
+      code: "NYTE_SQLITE_WORKER_UNAVAILABLE"
+    });
+  };
+  const handBack = (cause) => {
+    const stopped = checkpoint;
+    checkpoint = null;
+    stopped?.close();
+    if (closed)
+      return;
+    database.exec("PRAGMA wal_autocheckpoint = 1000");
+    warn("checkpoint", cause);
+  };
+  try {
+    checkpoint = new SqliteWorker(path, "checkpoint", handBack);
+    checkpoint.ready.then((ready) => {
+      if (ready && !closed)
+        database.exec("PRAGMA wal_autocheckpoint = 10000");
+    });
+  } catch (cause) {
+    warn("checkpoint", cause instanceof Error ? cause : new Error(String(cause)));
+  }
+  const check = () => {
+    if (checkpoint === null || closed)
+      return;
+    if (checking) {
+      checkAgain = true;
+      return;
+    }
+    checking = true;
+    checkpoint.query("", []).catch((cause) => {
+      if (checkpoint !== null)
+        handBack(cause instanceof Error ? cause : new Error(String(cause)));
+    }).finally(() => {
+      checking = false;
+      if (checkAgain) {
+        checkAgain = false;
+        check();
+      }
+    });
+  };
+  return {
+    check,
+    async read(sql, params) {
+      if (closed)
+        throw new Error("SQLite store closed");
+      if (readerUnavailable)
+        return;
+      if (reader === null) {
+        try {
+          reader = new SqliteWorker(path, "reader", (cause, started) => {
+            reader = null;
+            readerUnavailable = !started;
+            warn("reader", cause);
+          });
+        } catch (cause) {
+          readerUnavailable = true;
+          warn("reader", cause instanceof Error ? cause : new Error(String(cause)));
+          return;
+        }
+      }
+      return reader.query(sql, params);
+    },
+    async close() {
+      closed = true;
+      await Promise.all([reader?.close(), checkpoint?.close()]);
+    }
+  };
+}
+
+export { sqliteWorkers2 };

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

@@ -0,0 +1,133 @@
+import {
+  createIgnores2,
+  watchTree2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/local/git-watch.ts
+import { isAbsolute, relative, sep } from "node:path";
+var WATCH_DELAY_MS = 250;
+var POLL_MS = 2000;
+var GIT_STATE = new Set([
+  "HEAD",
+  "index",
+  "packed-refs",
+  "config",
+  "MERGE_HEAD",
+  "CHERRY_PICK_HEAD",
+  "REVERT_HEAD",
+  "rebase-merge",
+  "rebase-apply"
+]);
+function createWatcher2(cwd, read, repository, forget) {
+  const listeners = new Set;
+  let stop = null;
+  let checking = false;
+  let again = false;
+  const check = async () => {
+    if (checking) {
+      again = true;
+      return;
+    }
+    checking = true;
+    do {
+      again = false;
+      const current = await read().catch(() => null);
+      if (current !== null)
+        for (const listener of listeners)
+          listener(current);
+    } while (again && listeners.size > 0);
+    checking = false;
+  };
+  const restart = () => {
+    forget();
+    stop?.();
+    stop = start();
+    check();
+  };
+  const start = () => {
+    const disposers = [];
+    let polling = null;
+    let stopped = false;
+    const unwatched = () => {
+      polling ??= setInterval(() => void check(), POLL_MS);
+    };
+    const watchGitDir = (dir) => {
+      disposers.push(watchTree2(dir, { delay: WATCH_DELAY_MS, poll: null, unwatched }, (paths) => {
+        if ([...paths].some(movesStatus))
+          check();
+      }));
+    };
+    repository().then((repo) => {
+      if (stopped)
+        return;
+      const insideGitDir = repo === null ? null : pathInside(cwd, repo.gitDir);
+      const ignores = repo === null ? null : createIgnores2(repo.root);
+      const moved = async (paths) => {
+        let found = "none";
+        for (const path of paths) {
+          if (path === ".git")
+            return "repository";
+          if (repo === null || ignores === null)
+            continue;
+          if (insideGitDir !== null && (path === insideGitDir || path.startsWith(`${insideGitDir}/`))) {
+            if (movesStatus(path.slice(insideGitDir.length + 1)))
+              found = "status";
+            continue;
+          }
+          if (path.endsWith(".gitignore"))
+            ignores.forget(`${repo.prefix}${path}`.split("/").slice(0, -1).join("/"));
+          if (found === "none" && !await ignores.ignored(`${repo.prefix}${path}`, false))
+            found = "status";
+        }
+        return found;
+      };
+      disposers.push(watchTree2(cwd, { delay: WATCH_DELAY_MS, poll: null, unwatched }, (paths) => {
+        moved(paths).then((outcome) => {
+          if (stopped)
+            return;
+          if (outcome === "repository")
+            restart();
+          else if (outcome === "status")
+            check();
+        });
+      }));
+      if (repo === null)
+        return;
+      if (insideGitDir === null)
+        watchGitDir(repo.gitDir);
+      if (repo.commonDir !== repo.gitDir && pathInside(cwd, repo.commonDir) === null)
+        watchGitDir(repo.commonDir);
+    });
+    return () => {
+      stopped = true;
+      if (polling !== null)
+        clearInterval(polling);
+      for (const dispose of disposers)
+        dispose();
+    };
+  };
+  return {
+    subscribe(listener, fail) {
+      listeners.add(listener);
+      stop ??= start();
+      read().then(listener, fail);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          stop?.();
+          stop = null;
+        }
+      };
+    }
+  };
+}
+function movesStatus(path) {
+  const [top = ""] = path.split("/");
+  return path === "" || GIT_STATE.has(top) || path === "refs" || path.startsWith("refs/heads/") || path.startsWith("refs/remotes/");
+}
+function pathInside(cwd, dir) {
+  const inside = relative(cwd, dir);
+  return inside.startsWith("..") || isAbsolute(inside) ? null : inside.split(sep).join("/");
+}
+
+export { createWatcher2 };

package/dist/src/canvas-preview.d.ts

@@ -0,0 +1,29 @@
+import type { CanvasPreviewer } from "@nyte-ai/plugin/core/canvas-preview";
+/**
+ * Returns the shell a previewer serves: every file of the canvas package's
+ * `dist/shell`, base64 by its path from it (`index.html`,
+ * `libraries/three.js`), as `@nyte-ai/canvas/shell-files` exports them.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export type CanvasShellFiles = Readonly<Record<string, string>>;
+/**
+ * Finds a Chromium to preview with: `NYTE_CANVAS_CHROMIUM`, then
+ * Playwright's headless shell or Chromium, then an installed Chrome or
+ * Chromium. Undefined when there is none.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export declare function findChromium(): string | undefined;
+/**
+ * Returns a previewer over a headless Chromium on this machine
+ * (`findChromium`), serving `shell`; it answers `unavailable` when there is
+ * no Chromium or it fails to start, and stops the browser when the
+ * preview's signal aborts.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export declare function chromiumCanvasPreview(shell: CanvasShellFiles, executable?: () => string | undefined): CanvasPreviewer;