@ai-switch/tauri-plugin-runtime 0.1.0

package/dist/chunk-WT62GTMC.js

@@ -0,0 +1,18 @@
+// src/protocol/limits.ts
+var protocolVersion = "aplg/1";
+var apiVersion = "1.0.0";
+var limits = Object.freeze({
+  controlBytes: 1048576,
+  fileChunkBytes: 262144,
+  fileBytes: 8388608,
+  fileTransfers: 2,
+  archiveBytes: 134217728,
+  archiveExtractedBytes: 536870912,
+  archiveEntries: 1e4
+});
+
+export {
+  protocolVersion,
+  apiVersion,
+  limits
+};

package/dist/chunk-YI6NQ6WR.js

@@ -0,0 +1,513 @@
+import {
+  aplg
+} from "./chunk-K5YWIJN6.js";
+import {
+  validatePublicSessionInfo
+} from "./chunk-PW7XHHWG.js";
+import {
+  AplgError,
+  errorCodes,
+  validateCapabilityRequest,
+  validateCapabilityResult,
+  validateJson,
+  validateVirtualPath
+} from "./chunk-RKQEK7DY.js";
+import {
+  limits
+} from "./chunk-WT62GTMC.js";
+import {
+  import_buffer
+} from "./chunk-CFQSUF5W.js";
+
+// src/node/fs/lifecycle.ts
+function checkSignal(signal) {
+  if (signal.aborted) throw signal.reason;
+}
+function boundedOperation(action, signal, timeoutMs = 3e4, onLate) {
+  return new Promise((resolve, reject) => {
+    const controller = new AbortController();
+    let settled = false;
+    const finish = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+    };
+    const stop = (error) => {
+      if (!settled) {
+        settled = true;
+        finish();
+        controller.abort(error);
+        reject(error);
+      }
+    };
+    const abort = () => stop(signal.reason);
+    const timer = setTimeout(() => stop(new AplgError("E_TIMEOUT", "The filesystem operation timed out.")), timeoutMs);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) {
+      abort();
+      return;
+    }
+    void Promise.resolve().then(() => {
+      checkSignal(controller.signal);
+      return action(controller.signal);
+    }).then((value) => {
+      if (settled) {
+        try {
+          onLate?.(value);
+        } catch {
+        }
+        return;
+      }
+      settled = true;
+      finish();
+      resolve(value);
+    }, (error) => {
+      if (!settled) {
+        settled = true;
+        finish();
+        reject(error);
+      }
+    });
+  });
+}
+function createLifecycle(session, options) {
+  const active = /* @__PURE__ */ new Set();
+  let remove;
+  let closed = false;
+  return {
+    async run(action) {
+      if (closed) throw new AplgError("E_SESSION_CLOSED", "The filesystem session is closed.");
+      if (active.size >= 64) throw new AplgError("E_LIMIT_EXCEEDED", "Too many queued filesystem operations.");
+      const controller = new AbortController();
+      active.add(controller);
+      try {
+        const info = validatePublicSessionInfo(await boundedOperation(() => session(), controller.signal));
+        if (!Object.hasOwn(info.capabilities, "aplg.fs")) throw new AplgError("E_CAPABILITY_UNAVAILABLE", "The host does not provide filesystem access.");
+        if (!remove && options.onConnectionChange) remove = options.onConnectionChange((state) => {
+          if (state === "connected") return;
+          if (state === "closed") closed = true;
+          for (const pending of [...active]) pending.abort(new AplgError(state === "closed" ? "E_SESSION_CLOSED" : "E_HOST_UNAVAILABLE", "The filesystem connection is unavailable."));
+        });
+        checkSignal(controller.signal);
+        return await action({ info, signal: controller.signal });
+      } finally {
+        active.delete(controller);
+        if (!active.size) {
+          const unsubscribe = remove;
+          remove = void 0;
+          try {
+            unsubscribe?.();
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/node/fs/backend.ts
+function createBackend(call) {
+  return {
+    async invoke(context, method, params, observe) {
+      if (!context.info.capabilities["aplg.fs"].methods.includes(method)) throw new AplgError("E_CAPABILITY_UNAVAILABLE", "The filesystem method is unavailable.");
+      const checked = validateCapabilityRequest("aplg.fs", method, params);
+      if (!checked.ok) throw Object.assign(new Error("Invalid filesystem request."), { code: checked.diagnostics[0]?.code ?? "E_INVALID_ARGUMENT" });
+      const raw = await boundedOperation(
+        (signal) => call("aplg.fs", method, params, { signal, timeoutMs: 3e4 }),
+        context.signal,
+        3e4,
+        (result2) => observe?.(result2, true)
+      );
+      observe?.(raw, false);
+      const result = validateCapabilityResult("aplg.fs", method, raw);
+      if (!result.ok) throw new AplgError("E_INVALID_MESSAGE", "The filesystem backend returned an invalid result.");
+      return raw;
+    },
+    async abort(handle) {
+      try {
+        const result = await boundedOperation((signal) => call("aplg.fs", "transfer.abort", { handle }, { signal, timeoutMs: 1e3 }), void 0, 1e3);
+        return result === null;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function responseHandle(value) {
+  if (!validateJson(value).ok || value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const handle = value.handle;
+  return typeof handle === "string" && /^[\x21-\x7e]{1,128}$/.test(handle) ? handle : void 0;
+}
+
+// src/node/fs/transfer.ts
+function createTransferClient(backend) {
+  let active = 0;
+  let unsafe = false;
+  const waiters = [];
+  const handles = /* @__PURE__ */ new Set();
+  function acquire(context) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = () => {
+        clearTimeout(timer);
+        context.signal.removeEventListener("abort", abort);
+        const index = waiters.indexOf(wake);
+        if (index >= 0) waiters.splice(index, 1);
+      };
+      const abort = () => {
+        if (!settled) {
+          settled = true;
+          finish();
+          reject(context.signal.reason);
+        }
+      };
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          finish();
+          reject(new AplgError("E_TIMEOUT", "The filesystem transfer queue timed out."));
+        }
+      }, 3e4);
+      const wake = () => {
+        if (settled) return;
+        if (unsafe) {
+          settled = true;
+          finish();
+          reject(new AplgError("E_SESSION_CLOSED", "File transfer cleanup could not be confirmed."));
+          return;
+        }
+        if (active >= context.info.limits.fileTransfers) return;
+        if (context.signal.aborted) {
+          abort();
+          return;
+        }
+        settled = true;
+        finish();
+        active++;
+        let released = false;
+        resolve(() => {
+          if (released) return;
+          released = true;
+          active--;
+          for (const pending of [...waiters]) pending();
+        });
+      };
+      waiters.push(wake);
+      context.signal.addEventListener("abort", abort, { once: true });
+      if (context.signal.aborted) abort();
+      else wake();
+    });
+  }
+  function chunkLimit(context) {
+    const envelopeBudget = context.info.limits.controlBytes - 768;
+    const limit = Math.min(context.info.limits.fileChunkBytes, Math.floor(envelopeBudget / 4) * 3);
+    if (limit < 1) throw new AplgError("E_LIMIT_EXCEEDED", "The negotiated message budget is too small for file transfers.");
+    return limit;
+  }
+  async function usingHandle(context, open, perform) {
+    const chunk = chunkLimit(context);
+    const release = await acquire(context);
+    let handle;
+    let committed = false;
+    const observe = (raw, late) => {
+      const candidate = responseHandle(raw);
+      if (!candidate) return;
+      if (late) {
+        if (!handles.has(candidate)) void backend.abort(candidate).then((confirmed) => {
+          if (!confirmed) {
+            unsafe = true;
+            for (const pending of [...waiters]) pending();
+          }
+        });
+        return;
+      }
+      if (handles.has(candidate)) throw new AplgError("E_INVALID_MESSAGE", "The host reused an active file transfer handle.");
+      handles.add(candidate);
+      handle = candidate;
+    };
+    try {
+      checkSignal(context.signal);
+      const opened = await open(observe);
+      if (!handle) throw new AplgError("E_INVALID_MESSAGE", "The host did not return a file transfer handle.");
+      checkSignal(context.signal);
+      const result = await perform(handle, opened, chunk);
+      await backend.invoke(context, "transfer.finish", { handle });
+      committed = true;
+      return result;
+    } finally {
+      if (handle) {
+        if (!committed && !await backend.abort(handle) && !context.signal.aborted) unsafe = true;
+        handles.delete(handle);
+      }
+      release();
+    }
+  }
+  return {
+    read(context, path) {
+      return usingHandle(context, (observe) => backend.invoke(context, "transfer.openRead", { path }, observe), async (handle, opened, chunk) => {
+        const size = opened.size;
+        if (size > context.info.limits.fileBytes) throw new AplgError("E_LIMIT_EXCEEDED", "The file exceeds the negotiated size limit.");
+        const output = import_buffer.Buffer.alloc(size);
+        for (let offset = 0; offset < size; ) {
+          checkSignal(context.signal);
+          const length = Math.min(chunk, size - offset);
+          const result = await backend.invoke(context, "transfer.pull", { handle, offset, length });
+          const bytes = import_buffer.Buffer.from(result.dataBase64, "base64");
+          if (result.offset !== offset || bytes.length !== length || bytes.toString("base64") !== result.dataBase64) {
+            throw new AplgError("E_INVALID_MESSAGE", "The host returned an incomplete or uncorrelated file chunk.");
+          }
+          output.set(bytes, offset);
+          offset += bytes.length;
+        }
+        return output;
+      });
+    },
+    async write(context, path, data, mode) {
+      if (data.length > context.info.limits.fileBytes) throw new AplgError("E_LIMIT_EXCEEDED", "The file exceeds the negotiated size limit.");
+      await usingHandle(context, (observe) => backend.invoke(context, "transfer.openWrite", { path, size: data.length, mode }, observe), async (handle, _opened, chunk) => {
+        for (let offset = 0; offset < data.length; ) {
+          checkSignal(context.signal);
+          const length = Math.min(chunk, data.length - offset);
+          const result = await backend.invoke(context, "transfer.push", { handle, offset, dataBase64: data.subarray(offset, offset + length).toString("base64") });
+          if (result.written !== length) throw new AplgError("E_INVALID_MESSAGE", "The host did not acknowledge the complete file chunk.");
+          offset += length;
+        }
+      });
+    }
+  };
+}
+
+// src/node/fs/errors.ts
+var known = /* @__PURE__ */ new Set([...errorCodes, "ENOENT", "EACCES", "EPERM", "EEXIST", "ENOTDIR", "EISDIR", "ENOTEMPTY", "EXDEV", "EINVAL", "ENOSPC", "EIO", "EBUSY", "EROFS", "EBADF", "ENAMETOOLONG", "EMFILE", "ELOOP", "ERR_APLG_SYNC_IO_UNSUPPORTED"]);
+function invalidArgument() {
+  throw new AplgError("E_INVALID_ARGUMENT", "Unsupported filesystem argument or option.");
+}
+function checkArity(count, min, max) {
+  if (count < min || count > max) invalidArgument();
+}
+function toFsError(error, syscall, path, dest) {
+  let code = "EIO";
+  try {
+    if (error && typeof error === "object") {
+      const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+      if (descriptor && "value" in descriptor && typeof descriptor.value === "string" && known.has(descriptor.value)) code = descriptor.value;
+    }
+  } catch {
+  }
+  const result = Object.assign(new Error(`Filesystem operation failed: ${syscall} (${code}).`), { name: "FileSystemError", code, syscall });
+  try {
+    if (typeof path === "string") result.path = validateVirtualPath(path);
+  } catch {
+  }
+  try {
+    if (typeof dest === "string") result.dest = validateVirtualPath(dest);
+  } catch {
+  }
+  return result;
+}
+function unsupportedSync() {
+  throw toFsError({ code: "ERR_APLG_SYNC_IO_UNSUPPORTED" }, "sync");
+}
+
+// src/node/fs/options.ts
+function filePath(value) {
+  if (typeof value !== "string") invalidArgument();
+  return validateVirtualPath(value);
+}
+function objectOptions(value, allowed) {
+  if (value === void 0 || value === null) return {};
+  if (typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) invalidArgument();
+  const result = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string" || !allowed.includes(key)) invalidArgument();
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor) || !descriptor.enumerable) invalidArgument();
+    if (descriptor.value !== void 0) result[key] = descriptor.value;
+  }
+  if (!validateJson(result, 4096).ok) invalidArgument();
+  return result;
+}
+function readEncoding(value) {
+  if (value === "utf8") return "utf8";
+  const options = objectOptions(value, ["encoding"]);
+  if (options.encoding !== void 0 && options.encoding !== null && options.encoding !== "utf8") invalidArgument();
+  return options.encoding === "utf8" ? "utf8" : null;
+}
+function writeMode(value, append) {
+  const options = value === "utf8" ? {} : objectOptions(value, ["encoding", "flag"]);
+  if (options.encoding !== void 0 && options.encoding !== "utf8") invalidArgument();
+  const mode = options.flag ?? (append ? "a" : "w");
+  if (!(append ? ["a", "ax"] : ["w", "wx"]).includes(mode)) invalidArgument();
+  return mode;
+}
+function boolOptions(value, allowed) {
+  const options = objectOptions(value, allowed);
+  const result = {};
+  for (const key of allowed) {
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") invalidArgument();
+    result[key] = options[key] === true;
+  }
+  return result;
+}
+function snapshotData(data) {
+  if (typeof data === "string") {
+    if (data.length > limits.fileBytes || import_buffer.Buffer.byteLength(data, "utf8") > limits.fileBytes) throw new AplgError("E_LIMIT_EXCEEDED", "File data exceeds the supported size.");
+    return import_buffer.Buffer.from(data, "utf8");
+  }
+  if (!(data instanceof Uint8Array)) invalidArgument();
+  if (data.byteLength > limits.fileBytes) throw new AplgError("E_LIMIT_EXCEEDED", "File data exceeds the supported size.");
+  return import_buffer.Buffer.from(data);
+}
+function virtualRoot(path) {
+  return path.startsWith("/mounts/") ? path.split("/").slice(0, 3).join("/") : path.split("/").slice(0, 2).join("/");
+}
+
+// src/node/fs/client.ts
+function createFsClient(call, session, options = {}) {
+  const lifecycle = createLifecycle(session, options);
+  const backend = createBackend(call);
+  const transfers = createTransferClient(backend);
+  const api = {
+    async readFile(path, options2) {
+      try {
+        checkArity(arguments.length, 1, 2);
+        const normalized = filePath(path);
+        const encoding = readEncoding(options2);
+        const data = await lifecycle.run((context) => transfers.read(context, normalized));
+        return encoding === "utf8" ? data.toString("utf8") : data;
+      } catch (error) {
+        throw toFsError(error, "readFile", path);
+      }
+    },
+    async writeFile(path, data, options2) {
+      try {
+        checkArity(arguments.length, 2, 3);
+        const normalized = filePath(path);
+        const mode = writeMode(options2, false);
+        const copy = snapshotData(data);
+        await lifecycle.run((context) => transfers.write(context, normalized, copy, mode));
+      } catch (error) {
+        throw toFsError(error, "writeFile", path);
+      }
+    },
+    async appendFile(path, data, options2) {
+      try {
+        checkArity(arguments.length, 2, 3);
+        const normalized = filePath(path);
+        const mode = writeMode(options2, true);
+        const copy = snapshotData(data);
+        await lifecycle.run((context) => transfers.write(context, normalized, copy, mode));
+      } catch (error) {
+        throw toFsError(error, "appendFile", path);
+      }
+    },
+    async readdir(path, options2) {
+      try {
+        checkArity(arguments.length, 1, 2);
+        const normalized = filePath(path);
+        const parsed = boolOptions(options2, ["withFileTypes"]);
+        const entries = await lifecycle.run((context) => backend.invoke(context, "readdir", { path: normalized }));
+        return parsed.withFileTypes ? entries.map(({ name, kind }) => Object.freeze({ name, isFile: () => kind === "file", isDirectory: () => kind === "directory" })) : entries.map((entry) => entry.name);
+      } catch (error) {
+        throw toFsError(error, "readdir", path);
+      }
+    },
+    async stat(path) {
+      try {
+        checkArity(arguments.length, 1, 1);
+        const normalized = filePath(path);
+        const entry = await lifecycle.run((context) => backend.invoke(context, "stat", { path: normalized }));
+        const { kind, size, mtimeMs } = entry;
+        return Object.freeze({ size, mtimeMs, isFile: () => kind === "file", isDirectory: () => kind === "directory" });
+      } catch (error) {
+        throw toFsError(error, "stat", path);
+      }
+    },
+    async mkdir(path, options2) {
+      try {
+        checkArity(arguments.length, 1, 2);
+        const normalized = filePath(path);
+        const parsed = boolOptions(options2, ["recursive"]);
+        const result = await lifecycle.run((context) => backend.invoke(context, "mkdir", { path: normalized, recursive: parsed.recursive }));
+        if (result.createdPath !== null) {
+          const created = filePath(result.createdPath);
+          if (virtualRoot(created) !== virtualRoot(normalized) || !(created === normalized || normalized.startsWith(created + "/"))) {
+            throw new AplgError("E_INVALID_MESSAGE", "The created directory path does not match the request.");
+          }
+        }
+        return parsed.recursive ? result.createdPath ?? void 0 : void 0;
+      } catch (error) {
+        throw toFsError(error, "mkdir", path);
+      }
+    },
+    async rename(from, to) {
+      try {
+        checkArity(arguments.length, 2, 2);
+        const source = filePath(from);
+        const destination = filePath(to);
+        if (virtualRoot(source) !== virtualRoot(destination)) throw Object.assign(new Error("Cross-grant rename is unsupported."), { code: "EXDEV" });
+        await lifecycle.run((context) => backend.invoke(context, "rename", { from: source, to: destination }));
+      } catch (error) {
+        throw toFsError(error, "rename", from, to);
+      }
+    },
+    async copyFile(from, to) {
+      try {
+        checkArity(arguments.length, 2, 2);
+        const source = filePath(from);
+        const destination = filePath(to);
+        await lifecycle.run((context) => backend.invoke(context, "copyFile", { from: source, to: destination }));
+      } catch (error) {
+        throw toFsError(error, "copyFile", from, to);
+      }
+    },
+    async rm(path, options2) {
+      try {
+        checkArity(arguments.length, 1, 2);
+        const normalized = filePath(path);
+        const parsed = boolOptions(options2, ["recursive", "force"]);
+        await lifecycle.run((context) => backend.invoke(context, "rm", { path: normalized, recursive: parsed.recursive, force: parsed.force }));
+      } catch (error) {
+        throw toFsError(error, "rm", path);
+      }
+    }
+  };
+  return Object.freeze(api);
+}
+
+// src/node/fs/promises.ts
+var client;
+function getClient() {
+  client ??= createFsClient(aplg.call, aplg.ready, { onConnectionChange: aplg.onConnectionChange });
+  return client;
+}
+function lazy(method) {
+  return ((...args) => {
+    const current = getClient();
+    return Reflect.apply(current[method], current, args);
+  });
+}
+var readFile = lazy("readFile");
+var writeFile = lazy("writeFile");
+var appendFile = lazy("appendFile");
+var readdir = lazy("readdir");
+var stat = lazy("stat");
+var mkdir = lazy("mkdir");
+var rename = lazy("rename");
+var copyFile = lazy("copyFile");
+var rm = lazy("rm");
+var promises = Object.freeze({ readFile, writeFile, appendFile, readdir, stat, mkdir, rename, copyFile, rm });
+var promises_default = promises;
+
+export {
+  unsupportedSync,
+  readFile,
+  writeFile,
+  appendFile,
+  readdir,
+  stat,
+  mkdir,
+  rename,
+  copyFile,
+  rm,
+  promises_default
+};

package/dist/host/event-router.d.ts

@@ -0,0 +1,19 @@
+import type { HostEvent } from "../protocol/generated/types.generated.js";
+import type { HostTransport } from "../protocol/wire.js";
+import type { PortEvent } from "../bridge/rpc-types.js";
+import type { SessionRequests } from "./requests.js";
+export interface EventRouter {
+    open(capability: string, topic: string, signal?: AbortSignal): Promise<string>;
+    close(id: string): Promise<void>;
+    accept(event: HostEvent): void;
+    isConnected(): boolean;
+    setConnected(connected: boolean): Promise<void>;
+    dispose(): Promise<void>;
+}
+export declare function createEventRouter(options: {
+    transport: HostTransport;
+    requests: SessionRequests;
+    sessionId: string;
+    timeoutMs: number;
+    send(event: PortEvent): void;
+}): EventRouter;

package/dist/host/file-handles.d.ts

@@ -0,0 +1,15 @@
+import type { JsonValue } from "../protocol/types.js";
+import type { HostTransport } from "../protocol/wire.js";
+import type { SessionRequests } from "./requests.js";
+/** Owns file handles at the host boundary, including replies the plugin no longer sees. */
+export declare function createFileHandleGuard(options: {
+    transport: HostTransport;
+    requests: SessionRequests;
+    sessionId: string;
+    timeoutMs: number;
+    maxTransfers: number;
+}): {
+    call(method: string, params: JsonValue, signal: AbortSignal): Promise<JsonValue>;
+    restore(): Promise<void>;
+    dispose(): Promise<void>;
+};

package/dist/host/host.d.ts

@@ -0,0 +1,2 @@
+import type { PluginHost, PluginHostOptions } from "./types.js";
+export declare function createPluginHost(options: PluginHostOptions): PluginHost;

package/dist/host/index.d.ts

@@ -0,0 +1,4 @@
+export { createPluginHost } from "./host.js";
+export type { PluginHost, PluginHostOptions, PluginView } from "./types.js";
+export type { HostTransport, HostOperation, Unsubscribe } from "../protocol/wire.js";
+export type { HostEvent } from "../protocol/generated/types.generated.js";