@ai-switch/tauri-plugin-runtime 0.1.0

package/dist/chunk-PW7XHHWG.js

@@ -0,0 +1,403 @@
+import {
+  AplgError,
+  errorCodes,
+  satisfiesApiRange,
+  standardCapabilities,
+  toErrorPayload,
+  validateJson,
+  validateSessionDescriptor,
+  validateWireMessage
+} from "./chunk-RKQEK7DY.js";
+import {
+  apiVersion,
+  limits,
+  protocolVersion
+} from "./chunk-WT62GTMC.js";
+
+// src/plugin/errors.ts
+function fromErrorPayload(payload) {
+  if (errorCodes.includes(payload.code)) {
+    return new AplgError(payload.code, payload.message, payload.details);
+  }
+  return Object.assign(new Error(payload.message), {
+    name: "RemoteCapabilityError",
+    code: payload.code,
+    ...payload.details === void 0 ? {} : { details: payload.details }
+  });
+}
+
+// src/bridge/json-codec.ts
+var encoder = new TextEncoder();
+function checkedByteLimit(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > limits.controlBytes) {
+    throw new AplgError("E_INVALID_ARGUMENT", "Invalid RPC message size limit.");
+  }
+  return value;
+}
+function encodeWireMessage(value, maxBytes = limits.controlBytes) {
+  checkedByteLimit(maxBytes);
+  const safe = validateJson(value, maxBytes);
+  if (!safe.ok) {
+    const sizeExceeded = safe.diagnostics.some((diagnostic) => diagnostic.message.includes("size"));
+    throw new AplgError(sizeExceeded ? "E_LIMIT_EXCEEDED" : "E_INVALID_MESSAGE", "The outgoing RPC message is invalid.");
+  }
+  if (!validateWireMessage(value).ok) throw new AplgError("E_INVALID_MESSAGE", "The outgoing RPC message does not match the protocol.");
+  return JSON.stringify(value);
+}
+function decodeWireMessage(frame, maxBytes = limits.controlBytes) {
+  checkedByteLimit(maxBytes);
+  if (typeof frame !== "string") throw new AplgError("E_INVALID_MESSAGE", "RPC frames must be JSON strings.");
+  if (frame.length > maxBytes || encoder.encode(frame).byteLength > maxBytes) {
+    throw new AplgError("E_LIMIT_EXCEEDED", "The RPC frame exceeds the negotiated byte limit.");
+  }
+  let value;
+  try {
+    value = JSON.parse(frame);
+  } catch {
+    throw new AplgError("E_INVALID_MESSAGE", "The RPC frame is not valid JSON.");
+  }
+  const result = validateWireMessage(value);
+  if (!result.ok) throw new AplgError("E_INVALID_MESSAGE", "The RPC frame does not match the protocol.");
+  return result.value;
+}
+
+// src/bridge/rpc-peer.ts
+function validTimeout(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 2147483647) {
+    throw new AplgError("E_INVALID_ARGUMENT", "RPC timeout must be a positive timer-safe integer.");
+  }
+  return value;
+}
+function requestId() {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function createRpcPeer(port, options = {}) {
+  const timeoutMs = validTimeout(options.timeoutMs ?? 3e4);
+  const maxInflight = options.maxInflight ?? 64;
+  const maxBytes = checkedByteLimit(options.maxBytes ?? limits.controlBytes);
+  if (!Number.isSafeInteger(maxInflight) || maxInflight < 1 || maxInflight > 64) {
+    throw new AplgError("E_INVALID_ARGUMENT", "RPC concurrency must be between 1 and 64.");
+  }
+  const pending = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  const recentIds = /* @__PURE__ */ new Set();
+  const events = /* @__PURE__ */ new Set();
+  let handler;
+  let closed;
+  function settle(id, action) {
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id);
+    clearTimeout(entry.timer);
+    entry.removeAbortListener();
+    action(entry);
+  }
+  function emit(event) {
+    for (const callback of [...events]) {
+      try {
+        callback(event);
+      } catch {
+      }
+    }
+  }
+  function terminate(reason, notify) {
+    if (closed) return;
+    closed = reason;
+    if (notify) {
+      try {
+        port.postMessage(encodeWireMessage({ protocol: protocolVersion, kind: "connection", state: "closed" }, maxBytes));
+      } catch {
+      }
+    }
+    port.removeEventListener("message", receive);
+    port.removeEventListener("messageerror", messageError);
+    port.removeEventListener("close", portClosed);
+    for (const id of pending.keys()) settle(id, (entry) => entry.reject(reason));
+    for (const controller of incoming.values()) controller.abort(reason);
+    incoming.clear();
+    recentIds.clear();
+    handler = void 0;
+    emit({ protocol: protocolVersion, kind: "connection", state: "closed" });
+    events.clear();
+    port.close();
+  }
+  function post(message) {
+    if (closed) throw closed;
+    const frame = encodeWireMessage(message, maxBytes);
+    try {
+      port.postMessage(frame);
+    } catch {
+      const error = new AplgError("E_SESSION_CLOSED", "The RPC port is unavailable.");
+      terminate(error, false);
+      throw error;
+    }
+  }
+  function reply(message) {
+    if (closed) return;
+    try {
+      post(message);
+    } catch (error) {
+      if (closed) return;
+      try {
+        post({ protocol: protocolVersion, kind: "error", id: "id" in message ? message.id : requestId(), error: toErrorPayload(error) });
+      } catch {
+        terminate(new AplgError("E_INVALID_MESSAGE", "The RPC reply could not be encoded."), true);
+      }
+    }
+  }
+  function cancelRemote(id) {
+    if (closed) return;
+    try {
+      post({ protocol: protocolVersion, kind: "request", id: requestId(), operation: "request.cancel", args: { requestId: id } });
+    } catch {
+    }
+  }
+  function dispatch(request) {
+    if (request.operation === "request.cancel") {
+      const controller2 = incoming.get(request.args.requestId);
+      if (controller2) {
+        incoming.delete(request.args.requestId);
+        controller2.abort(new AplgError("E_CANCELLED", "The request was cancelled."));
+      }
+      reply({ protocol: protocolVersion, kind: "result", id: request.id, value: null });
+      return;
+    }
+    if (incoming.has(request.id) || recentIds.has(request.id)) {
+      terminate(new AplgError("E_INVALID_MESSAGE", "Duplicate RPC request identifier."), true);
+      return;
+    }
+    recentIds.add(request.id);
+    if (recentIds.size > 1024) recentIds.delete(recentIds.values().next().value);
+    if (incoming.size >= maxInflight) {
+      reply({ protocol: protocolVersion, kind: "error", id: request.id, error: toErrorPayload(new AplgError("E_LIMIT_EXCEEDED", "Too many incoming RPC requests.")) });
+      return;
+    }
+    const controller = new AbortController();
+    const currentHandler = handler;
+    incoming.set(request.id, controller);
+    void Promise.resolve().then(() => {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      if (!currentHandler) throw new AplgError("E_HOST_UNAVAILABLE", "No handler is registered for this RPC peer.");
+      return currentHandler({ ...request, signal: controller.signal });
+    }).then(
+      (value) => {
+        if (!controller.signal.aborted) reply({ protocol: protocolVersion, kind: "result", id: request.id, value });
+      },
+      (error) => {
+        if (!controller.signal.aborted) reply({ protocol: protocolVersion, kind: "error", id: request.id, error: toErrorPayload(error) });
+      }
+    ).finally(() => {
+      if (incoming.get(request.id) === controller) incoming.delete(request.id);
+    });
+  }
+  function receive(event) {
+    if (closed) return;
+    let message;
+    try {
+      message = decodeWireMessage(event.data, maxBytes);
+    } catch {
+      terminate(new AplgError("E_INVALID_MESSAGE", "The remote RPC frame was invalid."), true);
+      return;
+    }
+    if (message.kind === "request") {
+      dispatch(message);
+      return;
+    }
+    if (message.kind === "result") {
+      settle(message.id, (entry) => entry.resolve(message.value));
+      return;
+    }
+    if (message.kind === "error") {
+      settle(message.id, (entry) => entry.reject(fromErrorPayload(message.error)));
+      return;
+    }
+    if (message.kind === "connection" && message.state === "closed") {
+      terminate(new AplgError("E_SESSION_CLOSED", "The remote RPC peer closed."), false);
+      return;
+    }
+    emit(message);
+  }
+  const messageError = () => terminate(new AplgError("E_INVALID_MESSAGE", "The RPC frame could not be deserialized."), true);
+  const portClosed = () => terminate(new AplgError("E_SESSION_CLOSED", "The RPC port closed."), false);
+  port.addEventListener("message", receive);
+  port.addEventListener("messageerror", messageError);
+  port.addEventListener("close", portClosed);
+  port.start();
+  return {
+    async request(operation, args, callOptions = {}) {
+      if (closed) throw closed;
+      if (callOptions.signal?.aborted) throw new AplgError("E_CANCELLED", "The request was cancelled.");
+      const deadline = validTimeout(callOptions.timeoutMs ?? timeoutMs);
+      if (pending.size >= maxInflight) throw new AplgError("E_LIMIT_EXCEEDED", "Too many pending RPC requests.");
+      const id = requestId();
+      const frame = encodeWireMessage({ protocol: protocolVersion, kind: "request", id, operation, args }, maxBytes);
+      return new Promise((resolve, reject) => {
+        const abort = () => {
+          settle(id, (entry) => entry.reject(new AplgError("E_CANCELLED", "The request was cancelled.")));
+          cancelRemote(id);
+        };
+        const timer = setTimeout(() => {
+          settle(id, (entry) => entry.reject(new AplgError("E_TIMEOUT", "The RPC request timed out.")));
+          cancelRemote(id);
+        }, deadline);
+        pending.set(id, { timer, removeAbortListener: () => callOptions.signal?.removeEventListener("abort", abort), resolve, reject });
+        callOptions.signal?.addEventListener("abort", abort, { once: true });
+        try {
+          port.postMessage(frame);
+        } catch {
+          terminate(new AplgError("E_SESSION_CLOSED", "The RPC port is unavailable."), false);
+        }
+      });
+    },
+    onRequest(callback) {
+      if (closed) throw closed;
+      if (handler) throw new AplgError("E_INVALID_ARGUMENT", "An RPC request handler is already registered.");
+      handler = callback;
+      return () => {
+        if (handler === callback) handler = void 0;
+      };
+    },
+    onEvent(callback) {
+      if (closed) {
+        try {
+          callback({ protocol: protocolVersion, kind: "connection", state: "closed" });
+        } catch {
+        }
+        return () => {
+        };
+      }
+      events.add(callback);
+      return () => {
+        events.delete(callback);
+      };
+    },
+    sendEvent(event) {
+      if (event.kind === "connection" && event.state === "closed") {
+        terminate(new AplgError("E_SESSION_CLOSED", "The RPC peer closed."), true);
+        return;
+      }
+      post(event);
+    },
+    close(reason = new AplgError("E_SESSION_CLOSED", "The RPC peer closed.")) {
+      terminate(reason, true);
+    }
+  };
+}
+
+// src/bridge/handshake.ts
+var marker = ";aplg=";
+function encodeBase64Url(value) {
+  return btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function decodeBase64Url(value) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(value)) throw new Error("Invalid base64url.");
+  const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  const result = atob(padded);
+  if (encodeBase64Url(result) !== value) throw new Error("Noncanonical base64url.");
+  return result;
+}
+function validNonce(value) {
+  if (typeof value !== "string" || value.length !== 43) return false;
+  try {
+    return decodeBase64Url(value).length === 32;
+  } catch {
+    return false;
+  }
+}
+function validOrigin(origin) {
+  if (typeof origin !== "string") return false;
+  try {
+    const url = new URL(origin);
+    return url.origin === origin && (url.protocol === "https:" || url.protocol === "http:") && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}
+function appendBootstrapHint(assetUrl, nonce, parentOrigin) {
+  if (!validNonce(nonce) || !validOrigin(parentOrigin)) throw new AplgError("E_INVALID_ARGUMENT", "Invalid bootstrap context.");
+  const url = new URL(assetUrl);
+  if (url.protocol !== "https:" && url.protocol !== "http:") throw new AplgError("E_INVALID_ARGUMENT", "Invalid plugin asset URL.");
+  const hint = encodeBase64Url(JSON.stringify({ aplgNonce: nonce, aplgParentOrigin: parentOrigin }));
+  url.hash = `${url.hash}${marker}${hint}`;
+  return url.href;
+}
+function readBootstrapHint(href) {
+  try {
+    const url = new URL(href);
+    if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error("Unsupported asset URL.");
+    const offset = url.hash.lastIndexOf(marker);
+    if (offset < 0) throw new Error("Missing bootstrap context.");
+    const encoded = url.hash.slice(offset + marker.length);
+    if (encoded.length > 4096) throw new Error("Oversized context.");
+    const value = JSON.parse(decodeBase64Url(encoded));
+    if (!validateJson(value, 4096).ok || value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid context.");
+    const hint = value;
+    if (Object.keys(hint).length !== 2 || !validNonce(hint.aplgNonce) || !validOrigin(hint.aplgParentOrigin)) throw new Error("Invalid identity.");
+    const originalHash = url.hash.slice(0, offset);
+    return { nonce: hint.aplgNonce, parentOrigin: hint.aplgParentOrigin, originalHash: originalHash === "#" ? "" : originalHash };
+  } catch {
+    throw new AplgError("E_HOST_UNAVAILABLE", "This page is not connected to an APLG host.");
+  }
+}
+function validatePublicSessionInfo(input) {
+  if (!validateJson(input).ok || input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new AplgError("E_PROTOCOL_MISMATCH", "Invalid public session information.");
+  }
+  const candidate = input;
+  if (candidate.protocol !== protocolVersion || !satisfiesApiRange(candidate.apiVersion, `^${apiVersion}`)) {
+    throw new AplgError("E_PROTOCOL_MISMATCH", "The host API version is incompatible.");
+  }
+  const required = {};
+  if (candidate.capabilities && typeof candidate.capabilities === "object") {
+    for (const [name, value] of Object.entries(candidate.capabilities)) {
+      if (!value || typeof value.version !== "string") throw new AplgError("E_PROTOCOL_MISMATCH", "Invalid capability information.");
+      required[name] = value.version;
+      if (name.startsWith("aplg.") && !Object.hasOwn(standardCapabilities, name)) throw new AplgError("E_PROTOCOL_MISMATCH", "Unknown standard capability.");
+    }
+  }
+  const descriptor = {
+    sessionId: "public-info-validation",
+    assetUrl: "https://aplg.invalid/dist/index.html",
+    info: input,
+    manifest: {
+      manifestVersion: 1,
+      id: candidate.plugin?.id,
+      name: "Public info validation",
+      version: candidate.plugin?.version,
+      description: "",
+      license: "MIT",
+      engines: { aplg: `^${apiVersion}` },
+      entry: "dist/index.html",
+      activation: "view",
+      requires: required,
+      optional: {},
+      permissions: { filesystem: [], network: [], native: false },
+      contributes: { views: [{ id: "main", title: "Main" }] }
+    }
+  };
+  if (!validateSessionDescriptor(descriptor).ok) throw new AplgError("E_PROTOCOL_MISMATCH", "Invalid public session information.");
+  return candidate;
+}
+function validateConnectMessage(value, nonce) {
+  if (!validateJson(value).ok || value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new AplgError("E_PROTOCOL_MISMATCH", "Invalid bootstrap response.");
+  }
+  const message = value;
+  const keys = ["channel", "protocol", "kind", "nonce", "info"];
+  if (Object.keys(message).length !== keys.length || !keys.every((key) => Object.hasOwn(message, key)) || message.channel !== "aplg.bootstrap" || message.protocol !== protocolVersion || message.kind !== "connect" || message.nonce !== nonce) {
+    throw new AplgError("E_PROTOCOL_MISMATCH", "Bootstrap identity or protocol mismatch.");
+  }
+  return validatePublicSessionInfo(message.info);
+}
+
+export {
+  createRpcPeer,
+  appendBootstrapHint,
+  readBootstrapHint,
+  validatePublicSessionInfo,
+  validateConnectMessage
+};