@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/cloud/Client.mjs

@@ -0,0 +1,231 @@
+import { connectActions } from "./Decorator.mjs";
+import { iframe } from "./Dialog.mjs";
+import { connectionFromWire, connectionMatchesRequest } from "./internal.mjs";
+import { create as createRemoteProvider } from "./RemoteProvider.mjs";
+import { http } from "./Transport.mjs";
+
+let sequence = 0;
+
+export function create(parameters) {
+  if (!parameters || typeof parameters.appId !== "string" || parameters.appId.length === 0) {
+    throw new TypeError("Client.create requires appId");
+  }
+  const transport = parameters.transport ?? http();
+  const appOrigin = parameters.appOrigin ?? browserOrigin();
+  const dialog = parameters.dialog ?? iframe();
+  const transportInstance = transport.setup({ appId: parameters.appId });
+  const dialogInstance = dialog.setup({ appId: parameters.appId });
+  const principalInstance = parameters.principal?.setup({
+    appId: parameters.appId,
+    appOrigin,
+  });
+  const provider = parameters.provider ?? createRemoteProvider({
+    host: dialogInstance.host,
+    async target(options) {
+      if (!principalInstance) await dialogInstance.waitForWallet?.();
+      return dialogInstance.walletTarget(options);
+    },
+  });
+  if (!parameters.provider && !principalInstance) void provider.prepare().catch(() => undefined);
+  const uid = `${transport.key}:${parameters.appId}:${++sequence}`;
+  const sessionStorage = parameters.session === false
+    ? undefined
+    : parameters.session ?? browserSessionStorage();
+  const sessionStorageKey = `nanocodex:connect:${parameters.appId}:session`;
+  let sessionToken;
+
+  function fetchControlPlane(input, init, token = sessionToken) {
+    if (typeof transportInstance.fetch !== "function") {
+      throw new TypeError("Connect transport does not expose an HTTP fetch boundary");
+    }
+    const target = input instanceof Request
+      ? input
+      : new URL(String(input), transportInstance.baseUrl);
+    const targetUrl = new URL(input instanceof Request ? input.url : target);
+    if (targetUrl.origin !== new URL(transportInstance.baseUrl).origin) {
+      throw new TypeError("Connect client fetch is restricted to its configured API origin");
+    }
+    const headers = new Headers(
+      init?.headers ?? (input instanceof Request ? input.headers : undefined),
+    );
+    if (token) headers.set("authorization", `Bearer ${token}`);
+    return transportInstance.fetch(target, { ...init, headers });
+  }
+
+  function requestControlPlane(request, token = sessionToken) {
+    return transportInstance.request({
+      ...request,
+      headers: token
+        ? { ...request.headers, authorization: `Bearer ${token}` }
+        : request.headers,
+    });
+  }
+
+  const base = {
+    accessKey: parameters.accessKey,
+    appId: parameters.appId,
+    appOrigin,
+    auth: parameters.auth,
+    dialog: dialogInstance,
+    key: parameters.key ?? "connect",
+    name: parameters.name ?? "Nanocodex Connect",
+    principal: principalInstance,
+    provider,
+    fetch: fetchControlPlane,
+    request: requestControlPlane,
+    transport: Object.freeze({
+      key: transport.key,
+      name: transport.name,
+      type: transport.type,
+      baseUrl: transportInstance.baseUrl,
+    }),
+    type: "connect",
+    uid,
+  };
+
+  Object.defineProperty(base, "_setSessionToken", {
+    enumerable: false,
+    value(token) {
+      sessionToken = token;
+    },
+  });
+  Object.defineProperty(base, "_setSession", {
+    enumerable: false,
+    value(session) {
+      sessionToken = session.token;
+      writeSession(sessionStorage, sessionStorageKey, session);
+    },
+  });
+  Object.defineProperty(base, "_getSession", {
+    enumerable: false,
+    value() {
+      return readSession(sessionStorage, sessionStorageKey);
+    },
+  });
+  Object.defineProperty(base, "_hasSession", {
+    enumerable: false,
+    value() {
+      return readSession(sessionStorage, sessionStorageKey) !== undefined;
+    },
+  });
+  Object.defineProperty(base, "_resumeConnection", {
+    enumerable: false,
+    value(options) {
+      const session = readSession(sessionStorage, sessionStorageKey);
+      if (!session?.connection) return undefined;
+      try {
+        const connection = connectionFromWire(session.connection);
+        if (connection.principal) return undefined;
+        if (connection.grant.id.toLowerCase() !== session.grantId.toLowerCase()
+          || connection.grant.status !== "active"
+          || connection.grant.expiresAt <= Math.floor(Date.now() / 1_000)
+          || !connectionMatchesRequest(connection, options)) {
+          return undefined;
+        }
+        sessionToken = session.token;
+        return connection;
+      } catch {
+        return undefined;
+      }
+    },
+  });
+  Object.defineProperty(base, "_clearSession", {
+    enumerable: false,
+    value() {
+      sessionToken = undefined;
+      removeSession(sessionStorage, sessionStorageKey);
+    },
+  });
+  Object.defineProperty(base, "_captureSession", {
+    enumerable: false,
+    value() {
+      const token = sessionToken;
+      if (typeof token !== "string" || !token) {
+        throw new Error("The Connect grant session is unavailable.");
+      }
+      return Object.freeze({
+        token,
+        fetch: (input, init) => fetchControlPlane(input, init, token),
+        request: (request) => requestControlPlane(request, token),
+      });
+    },
+  });
+
+  function extend(decorator) {
+    if (typeof decorator !== "function") throw new TypeError("client extension must be a function");
+    const extension = decorator(client);
+    const next = Object.create(Object.getPrototypeOf(client));
+    Object.defineProperties(next, Object.getOwnPropertyDescriptors(client));
+    return Object.assign(next, extension);
+  }
+
+  let client = Object.assign(base, { extend });
+  client = client.extend(connectActions());
+  return Object.freeze(client);
+}
+
+function browserOrigin() {
+  try {
+    const origin = globalThis.location?.origin;
+    return typeof origin === "string" && origin !== "null" ? origin : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function browserSessionStorage() {
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return undefined;
+  }
+}
+
+function readSession(storage, key) {
+  if (!storage) return undefined;
+  try {
+    const value = JSON.parse(storage.getItem(key));
+    if (!value
+      || typeof value !== "object"
+      || !/^0x[0-9a-fA-F]{64}$/.test(value.grantId)
+      || typeof value.token !== "string"
+      || value.token.length === 0) {
+      removeSession(storage, key);
+      return undefined;
+    }
+    return Object.freeze({
+      grantId: value.grantId,
+      token: value.token,
+      ...(Array.isArray(value.resources)
+        && value.resources.length > 0
+        && value.resources.every((resource) => typeof resource === "string")
+        ? { resources: Object.freeze([...value.resources]) }
+        : {}),
+      ...(value.connection && typeof value.connection === "object"
+        ? { connection: value.connection }
+        : {}),
+    });
+  } catch {
+    removeSession(storage, key);
+    return undefined;
+  }
+}
+
+function writeSession(storage, key, session) {
+  if (!storage) return;
+  try {
+    storage.setItem(key, JSON.stringify(session));
+  } catch {
+    // Storage is an optional browser convenience. The in-memory grant session
+    // remains valid for the current page when persistence is unavailable.
+  }
+}
+
+function removeSession(storage, key) {
+  if (!storage) return;
+  try {
+    storage.removeItem(key);
+  } catch {
+    // A blocked storage implementation is equivalent to an ephemeral session.
+  }
+}

package/vendor/nanocodex/cloud/Decorator.d.mts

@@ -0,0 +1,31 @@
+import type { logout } from "./actions/account.mjs";
+import type { create as createAgent } from "./actions/agent.mjs";
+import type { connect, disconnect, reconnect } from "./actions/connection.mjs";
+import type { revoke } from "./actions/grant.mjs";
+import type { fund, getConfig } from "./actions/machineUsd.mjs";
+import type { transport as modelTransport } from "./actions/model.mjs";
+import type { charge, getBalance } from "./actions/mpp.mjs";
+import type { Client } from "./Client.mjs";
+import type { Connection, HostConnection } from "./types.mjs";
+
+export type ConnectActions<connection extends Connection | HostConnection = Connection> = {
+  account: { logout(): logout.ReturnType };
+  agent: { create(options: createAgent.Options): Promise<createAgent.ReturnType> };
+  connection: {
+    connect(options: connect.Options): Promise<connection>;
+    disconnect(options?: disconnect.Options | undefined): disconnect.ReturnType;
+    reconnect(options?: reconnect.Options | undefined): Promise<connection | undefined>;
+  };
+  grant: { revoke(options: revoke.Options): revoke.ReturnType };
+  machineUsd: {
+    fund(options: fund.Options): fund.ReturnType;
+    getConfig(options?: getConfig.Options | undefined): getConfig.ReturnType;
+  };
+  model: { transport(options: modelTransport.Options): modelTransport.ReturnType };
+  mpp: {
+    charge(options: charge.Options): charge.ReturnType;
+    getBalance(options: getBalance.Options): getBalance.ReturnType;
+  };
+};
+
+export function connectActions(): (client: Client) => ConnectActions;

package/vendor/nanocodex/cloud/Decorator.mjs

@@ -0,0 +1,37 @@
+import * as account from "./actions/account.mjs";
+import * as agent from "./actions/agent.mjs";
+import * as connection from "./actions/connection.mjs";
+import * as grant from "./actions/grant.mjs";
+import * as machineUsd from "./actions/machineUsd.mjs";
+import * as model from "./actions/model.mjs";
+import * as mpp from "./actions/mpp.mjs";
+
+export function connectActions() {
+  return (client) => ({
+    account: {
+      logout: () => account.logout(client),
+    },
+    agent: {
+      create: (options) => agent.create(client, options),
+    },
+    connection: {
+      connect: (options) => connection.connect(client, options),
+      disconnect: (options) => connection.disconnect(client, options),
+      reconnect: (options) => connection.reconnect(client, options),
+    },
+    grant: {
+      revoke: (options) => grant.revoke(client, options),
+    },
+    machineUsd: {
+      fund: (options) => machineUsd.fund(client, options),
+      getConfig: (options) => machineUsd.getConfig(client, options),
+    },
+    model: {
+      transport: (options) => model.transport(client, options),
+    },
+    mpp: {
+      charge: (options) => mpp.charge(client, options),
+      getBalance: (options) => mpp.getBalance(client, options),
+    },
+  });
+}

package/vendor/nanocodex/cloud/Dialog.d.mts

@@ -0,0 +1,113 @@
+export const DEFAULT_HOST: "https://nanocodex.gakonst.workers.dev/connect-dialog/";
+
+export type Request = ConnectionRequest | FundingRequest;
+
+export type ConnectionRequest = Readonly<{
+  id: string;
+  type: "connect";
+  app: Readonly<{ id: string; name: string; origin: string }>;
+  accountAddress: `0x${string}`;
+  auth: Readonly<{
+    /** EIP-4361 message whose exact bytes are bound by the access-key witness. */
+    message: string;
+    /** Connect capabilities echoed into the SIWE Resources field. */
+    resources: readonly string[];
+  }>;
+  permission: Readonly<{
+    id: string;
+    title: string;
+    description: string;
+    connectors: readonly Readonly<{ id: string; name: string; detail: string }>[];
+  }>;
+  accessKey: Readonly<{
+    address: `0x${string}`;
+    chainId: bigint;
+    keyId: `0x${string}`;
+    publicKey: `0x${string}`;
+    keyType: "secp256k1" | "p256" | "webAuthn";
+    witness: `0x${string}`;
+    expiry: number;
+    limits: readonly Readonly<{
+      token: `0x${string}`;
+      limit: bigint;
+      period?: number | undefined;
+    }>[];
+    scopes: readonly Readonly<{
+      address: `0x${string}`;
+      selector?: `0x${string}` | string | undefined;
+      recipients?: readonly `0x${string}`[] | undefined;
+    }>[];
+  }>;
+  mpp?: Readonly<{
+    token: `0x${string}`;
+    symbol: string;
+    limit: bigint;
+    period: number;
+    maxPerRequest: bigint;
+    /** Exact recipient when the delegated payment authority is recipient-bound. */
+    recipient?: `0x${string}` | undefined;
+  }> | undefined;
+}>;
+
+export type FundingRequest = Readonly<{
+  id: string;
+  type: "machineUsdFund";
+  accountAddress?: `0x${string}` | undefined;
+  grantId: `0x${string}`;
+  chainId: number;
+  apiUrl: string;
+  stripePublishableKey: string;
+  tokenAddress: `0x${string}`;
+  usdAmountCents: number;
+}>;
+
+export type Instance = Readonly<{
+  host: string;
+  open(request: Request): Promise<unknown>;
+  /** Internal WATA iframe target used by the bundled Accounts provider. */
+  walletTarget?(options: Readonly<{ host?: string | undefined }>): Window | null | undefined;
+  /** Resolves after the bundled Accounts iframe has completed navigation. */
+  waitForWallet?(): Promise<void>;
+  showWallet?(): void;
+  hideWallet?(): void;
+  /** Replaces the cached hosted wallet after account logout. */
+  resetWallet?(): Promise<void>;
+  getRequest?(): Request | undefined;
+  subscribe?(listener: () => void): () => void;
+  respond?(result: unknown): void;
+  reject?(error?: unknown): void;
+}>;
+
+export type Dialog<type extends string = string> = Readonly<{
+  key: string;
+  name: string;
+  type: type;
+  setup(options: Readonly<{ appId: string }>): Instance;
+}>;
+
+export function from<const type extends string>(parameters: Readonly<{
+  key: string;
+  name: string;
+  type: type;
+  setup(options: Readonly<{ appId: string }>): Instance;
+}>): Dialog<type>;
+
+export function iframe(options?: Readonly<{
+  host?: string | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+}>): Dialog<"iframe">;
+
+export function popup(options?: Readonly<{
+  host?: string | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+  target?: string | undefined;
+  features?: string | undefined;
+}>): Dialog<"popup">;
+
+export function memory(options?: Readonly<{
+  host?: string | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+}>): Dialog<"memory">;