@coasys/ad4m-connect 0.12.0 → 0.13.0-postmessage-ws-proxy.0

package/dist/services/hostIndex.d.ts

@@ -2,9 +2,9 @@ import type { RemoteHost, UserInfo } from '../types';
 import type { Ad4mClient } from '@coasys/ad4m';
 /** Fetch available hosts from the central index API */
 export declare function fetchHosts(indexUrl?: string): Promise<RemoteHost[]>;
-/** Fetch current user info from the executor via GraphQL */
+/** Fetch current user info from the executor */
 export declare function fetchUserInfo(ad4mClient: Ad4mClient): Promise<UserInfo>;
-/** Trigger a payment request via the executor's GraphQL API */
+/** Trigger a payment request via the executor */
 export declare function requestPayment(ad4mClient: Ad4mClient, amountHOT: number): Promise<{
     success: boolean;
     message: string;

package/dist/state/ConnectState.d.ts

@@ -0,0 +1,101 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * UI View States
+ */
+export type UIView = 'connection_overview' | 'remote_connection' | 'settings' | 'start' | 'qr' | 'requestcap' | 'verifycode' | 'disconnected' | 'hosting' | 'agentlocked' | 'multiuser_auth';
+/**
+ * Multi-user authentication steps
+ */
+export type MultiUserStep = 'email' | 'password' | 'code';
+export type MultiUserVerificationType = 'signup' | 'login';
+/**
+ * Form state for different auth methods
+ */
+interface FormState {
+    email: string;
+    password: string;
+    hostingStep: number;
+    multiUserEmail: string;
+    multiUserPassword: string;
+    multiUserVerificationCode: string;
+    multiUserStep: MultiUserStep;
+    multiUserVerificationType: MultiUserVerificationType;
+    remoteUrl: string;
+    code: string | null;
+}
+/**
+ * Error state for different operations
+ */
+interface ErrorState {
+    password: string | null;
+    hostingNotRunning: string | null;
+    verifyCode: string | null;
+    multiUser: string | null;
+    remote: string | null;
+}
+/**
+ * Loading state for async operations
+ */
+interface LoadingState {
+    hosting: boolean;
+    multiUser: boolean;
+    remoteDetecting: boolean;
+}
+/**
+ * Detection state
+ */
+interface DetectionState {
+    localDetected: boolean;
+    remoteMultiUserDetected: boolean | null;
+}
+/**
+ * Reactive state controller for Ad4m Connect
+ * Manages all UI and form state in a centralized, reactive way
+ */
+export declare class ConnectState implements ReactiveController {
+    private host;
+    currentView: UIView;
+    isOpen: boolean;
+    isMobile: boolean;
+    isRemote: boolean;
+    hasClickedDownload: boolean;
+    forms: FormState;
+    errors: ErrorState;
+    loading: LoadingState;
+    detection: DetectionState;
+    constructor(host: ReactiveControllerHost);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    get canSubmitMultiUser(): boolean;
+    get canSubmitVerificationCode(): boolean;
+    get hasAnyError(): boolean;
+    get isAnyLoading(): boolean;
+    get showLocalOption(): boolean;
+    get showRemoteOption(): boolean;
+    get showQROption(): boolean;
+    get showDownload(): boolean;
+    setView(view: UIView): void;
+    toggleOpen(): void;
+    open(): void;
+    close(): void;
+    setMobile(isMobile: boolean): void;
+    setRemote(isRemote: boolean): void;
+    setHasClickedDownload(clicked: boolean): void;
+    updateForm<K extends keyof FormState>(field: K, value: FormState[K]): void;
+    resetMultiUserForm(): void;
+    nextMultiUserStep(): void;
+    previousMultiUserStep(): void;
+    toggleMultiUserVerificationType(): void;
+    setError<K extends keyof ErrorState>(field: K, message: string | null): void;
+    clearError<K extends keyof ErrorState>(field: K): void;
+    clearAllErrors(): void;
+    setLoading<K extends keyof LoadingState>(field: K, isLoading: boolean): void;
+    setLocalDetected(detected: boolean): void;
+    setRemoteMultiUserDetected(detected: boolean | null): void;
+    private requestUpdate;
+    /**
+     * Reset all state to initial values
+     */
+    reset(): void;
+}
+export {};

package/dist/state/index.d.ts

@@ -0,0 +1,2 @@
+export { ConnectState } from './ConnectState';
+export type { UIView, MultiUserStep, MultiUserVerificationType } from './ConnectState';

package/dist/types.d.ts

@@ -18,7 +18,45 @@ export type Ad4mConnectOptions = {
     userEmail?: string;
     userPassword?: string;
     allowedOrigins?: string[];
+    hostIndexUrl?: string;
+    lowCreditThreshold?: number;
+    onCreditsDepleted?: () => void;
+    onUseApp?: () => void;
 };
 export type ConfigStates = "port" | "url" | "token";
 export type AuthStates = "authenticated" | "locked" | "unauthenticated";
 export type ConnectionStates = "connecting" | "connected" | "error" | "port-not-found" | "not-connected" | "disconnected" | "checking-local";
+/** Host as returned by the central index API */
+export type RemoteHost = {
+    id: string;
+    name: string;
+    description?: string;
+    profilePicUrl: string;
+    location: string;
+    url: string;
+    rates: PricingItem[];
+    aiModels: string[];
+    computeSpecs?: string | null;
+};
+/** Flexible pricing item — avoids locking the interface to a specific pricing model */
+export type PricingItem = {
+    description: string;
+    priceInHOT: number;
+};
+/** User account data returned by the host after auth */
+export type UserInfo = {
+    email: string;
+    remainingCredits: number;
+    hotWalletAddress: string | null;
+    freeAccess: boolean;
+};
+/** A single compute activity log entry */
+export type ComputeLogEntryData = {
+    id: number;
+    userEmail: string;
+    timestamp: string;
+    operation: string;
+    summary: string | null;
+    cost: number;
+    creditsAfter: number;
+};

package/dist/utils.d.ts

@@ -2,4 +2,11 @@ export declare function isEmbedded(): boolean;
 export declare function setLocal(key: string, value: string): void;
 export declare function getLocal(key: string): string | null;
 export declare function removeLocal(key: string): void;
-export declare function connectWebSocket(url: any, timeout?: number): Promise<unknown>;
+/** Convert a WebSocket URL to an HTTP base URL. */
+export declare function wsUrlToHttpBase(wsUrl: string): string;
+/** Check that the AD4M executor is reachable at the given HTTP base URL. */
+export declare function checkConnection(baseUrl: string, timeout?: number): Promise<void>;
+/** Extract up to 2 initials from a name (first letter of first two words) */
+export declare function getInitials(name: string): string;
+/** Deterministic hue (0-359) from a string — same input always yields same color */
+export declare function getHue(str: string): number;

package/dist/utils.js

@@ -1 +1,99 @@
-var l=(o,s,t)=>new Promise((c,e)=>{var r=n=>{try{u(t.next(n))}catch(d){e(d)}},p=n=>{try{u(t.throw(n))}catch(d){e(d)}},u=n=>n.done?c(n.value):Promise.resolve(n.value).then(r,p);u((t=t.apply(o,s)).next())});var a="0.12.0";function f(){return typeof window!="undefined"&&window.self!==window.top}function i(){try{localStorage.setItem("test",""),localStorage.removeItem("test")}catch(o){return!1}return!0}function w(o,s){i()&&localStorage.setItem(`${a}/${o}`,s)}function k(o){return i()?localStorage.getItem(`${a}/${o}`):null}function y(o){i()&&localStorage.removeItem(`${a}/${o}`)}function v(o,s=1e4){return l(this,null,function*(){return Promise.race([new Promise((t,c)=>{let e;try{e=new WebSocket(o,"graphql-transport-ws"),e.onopen=()=>{e.close(),t(e)},e.onerror=r=>{c(r)},e.onclose=r=>{r.code!==1e3&&c(new Error(`WebSocket closed with code ${r.code}: ${r.reason}`))}}catch(r){e&&e.close(),c(r)}}),new Promise((t,c)=>{setTimeout(()=>{c(new Error("WebSocket connection timed out"))},s)})])})}export{v as connectWebSocket,k as getLocal,f as isEmbedded,y as removeLocal,w as setLocal};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// ../package.json
+var version = "0.13.0-test-6";
+
+// src/utils.ts
+function isEmbedded() {
+  return typeof window !== "undefined" && window.self !== window.top;
+}
+function localStorageSupported() {
+  try {
+    localStorage.setItem("test", "");
+    localStorage.removeItem("test");
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+function setLocal(key, value) {
+  if (localStorageSupported())
+    localStorage.setItem(`${version}/${key}`, value);
+}
+function getLocal(key) {
+  if (localStorageSupported())
+    return localStorage.getItem(`${version}/${key}`);
+  return null;
+}
+function removeLocal(key) {
+  if (localStorageSupported())
+    localStorage.removeItem(`${version}/${key}`);
+}
+function wsUrlToHttpBase(wsUrl) {
+  return wsUrl.replace(/^ws(s?):\/\//, (_, s) => `http${s}://`);
+}
+function checkConnection(baseUrl, timeout = 1e4) {
+  return __async(this, null, function* () {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const res = yield fetch(`${baseUrl}/health`, { signal: controller.signal });
+      if (!res.ok)
+        throw new Error(`Health check returned ${res.status}`);
+      const body = yield res.json();
+      if ((body == null ? void 0 : body.status) !== "ok")
+        throw new Error("Not an AD4M executor");
+    } catch (e) {
+      if (e.name === "AbortError")
+        throw new Error("Connection timed out");
+      throw e;
+    } finally {
+      clearTimeout(timer);
+    }
+  });
+}
+function getInitials(name) {
+  const clean = name.trim();
+  if (!clean)
+    return "";
+  const words = clean.split(/\s+/);
+  if (words.length >= 2)
+    return (words[0][0] + words[1][0]).toUpperCase();
+  return clean.slice(0, 2).toUpperCase();
+}
+function getHue(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++)
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+  return (hash % 360 + 360) % 360;
+}
+export {
+  checkConnection,
+  getHue,
+  getInitials,
+  getLocal,
+  isEmbedded,
+  removeLocal,
+  setLocal,
+  wsUrlToHttpBase
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/utils.ts"],
+  "sourcesContent": ["//@ts-ignore\nimport { version } from \"../../package.json\";\n\nexport function isEmbedded(): boolean {\n  return typeof window !== 'undefined' && window.self !== window.top;\n}\n\nfunction localStorageSupported(): boolean {\n  try {\n    localStorage.setItem(\"test\", \"\");\n    localStorage.removeItem(\"test\");\n  } catch (e) {\n    return false;\n  }\n  return true;\n}\n\nexport function setLocal(key: string, value: string): void {\n  if (localStorageSupported()) localStorage.setItem(`${version}/${key}`, value);\n}\n\nexport function getLocal(key: string): string | null {\n  if (localStorageSupported()) return localStorage.getItem(`${version}/${key}`);\n  return null;\n}\n\nexport function removeLocal(key: string): void {\n  if (localStorageSupported()) localStorage.removeItem(`${version}/${key}`);\n}\n\n/** Convert a WebSocket URL to an HTTP base URL. */\nexport function wsUrlToHttpBase(wsUrl: string): string {\n  return wsUrl.replace(/^ws(s?):\\/\\//, (_, s) => `http${s}://`);\n}\n\n/** Check that the AD4M executor is reachable at the given HTTP base URL. */\nexport async function checkConnection(baseUrl: string, timeout = 10000): Promise<void> {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeout);\n  try {\n    const res = await fetch(`${baseUrl}/health`, { signal: controller.signal });\n    if (!res.ok) throw new Error(`Health check returned ${res.status}`);\n    const body = await res.json();\n    if (body?.status !== 'ok') throw new Error('Not an AD4M executor');\n  } catch (e: any) {\n    if (e.name === 'AbortError') throw new Error('Connection timed out');\n    throw e;\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n/** Extract up to 2 initials from a name (first letter of first two words) */\nexport function getInitials(name: string): string {\n  const clean = name.trim();\n  if (!clean) return \"\";\n  const words = clean.split(/\\s+/);\n  if (words.length >= 2) return (words[0][0] + words[1][0]).toUpperCase();\n  return clean.slice(0, 2).toUpperCase();\n}\n\n/** Deterministic hue (0-359) from a string \u2014 same input always yields same color */\nexport function getHue(str: string): number {\n  let hash = 0;\n  for (let i = 0; i < str.length; i++) hash = str.charCodeAt(i) + ((hash << 5) - hash);\n  return ((hash % 360) + 360) % 360;\n}\n\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAGO,SAAS,aAAsB;AACpC,SAAO,OAAO,WAAW,eAAe,OAAO,SAAS,OAAO;AACjE;AAEA,SAAS,wBAAiC;AACxC,MAAI;AACF,iBAAa,QAAQ,QAAQ,EAAE;AAC/B,iBAAa,WAAW,MAAM;AAAA,EAChC,SAAS,GAAP;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEO,SAAS,SAAS,KAAa,OAAqB;AACzD,MAAI,sBAAsB;AAAG,iBAAa,QAAQ,GAAG,WAAW,OAAO,KAAK;AAC9E;AAEO,SAAS,SAAS,KAA4B;AACnD,MAAI,sBAAsB;AAAG,WAAO,aAAa,QAAQ,GAAG,WAAW,KAAK;AAC5E,SAAO;AACT;AAEO,SAAS,YAAY,KAAmB;AAC7C,MAAI,sBAAsB;AAAG,iBAAa,WAAW,GAAG,WAAW,KAAK;AAC1E;AAGO,SAAS,gBAAgB,OAAuB;AACrD,SAAO,MAAM,QAAQ,gBAAgB,CAAC,GAAG,MAAM,OAAO,MAAM;AAC9D;AAGA,SAAsB,gBAAgB,SAAiB,UAAU,KAAsB;AAAA;AACrF,UAAM,aAAa,IAAI,gBAAgB;AACvC,UAAM,QAAQ,WAAW,MAAM,WAAW,MAAM,GAAG,OAAO;AAC1D,QAAI;AACF,YAAM,MAAM,MAAM,MAAM,GAAG,kBAAkB,EAAE,QAAQ,WAAW,OAAO,CAAC;AAC1E,UAAI,CAAC,IAAI;AAAI,cAAM,IAAI,MAAM,yBAAyB,IAAI,QAAQ;AAClE,YAAM,OAAO,MAAM,IAAI,KAAK;AAC5B,WAAI,6BAAM,YAAW;AAAM,cAAM,IAAI,MAAM,sBAAsB;AAAA,IACnE,SAAS,GAAP;AACA,UAAI,EAAE,SAAS;AAAc,cAAM,IAAI,MAAM,sBAAsB;AACnE,YAAM;AAAA,IACR,UAAE;AACA,mBAAa,KAAK;AAAA,IACpB;AAAA,EACF;AAAA;AAGO,SAAS,YAAY,MAAsB;AAChD,QAAM,QAAQ,KAAK,KAAK;AACxB,MAAI,CAAC;AAAO,WAAO;AACnB,QAAM,QAAQ,MAAM,MAAM,KAAK;AAC/B,MAAI,MAAM,UAAU;AAAG,YAAQ,MAAM,GAAG,KAAK,MAAM,GAAG,IAAI,YAAY;AACtE,SAAO,MAAM,MAAM,GAAG,CAAC,EAAE,YAAY;AACvC;AAGO,SAAS,OAAO,KAAqB;AAC1C,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ;AAAK,WAAO,IAAI,WAAW,CAAC,MAAM,QAAQ,KAAK;AAC/E,UAAS,OAAO,MAAO,OAAO;AAChC;",
+  "names": []
+}

package/dist/web.d.ts

@@ -4,29 +4,49 @@ import "./components/views/ConnectionOptions";
 import "./components/views/LocalAuthentication";
 import "./components/views/RemoteAuthentication";
 import "./components/views/CurrentState";
+import "./components/views/HostBrowser";
+import "./components/views/HostDetail";
+import "./components/views/LoggedInDashboard";
 export declare class Ad4mConnectElement extends LitElement {
     static styles: import("lit").CSSResult[];
     core: Ad4mConnect;
     modalOpen: boolean;
     private currentView;
-    private connectingToRemoteNode;
-    private remoteNodeError;
     private verificationError;
     private remoteAuthLoading;
     private remoteAuthState;
     private emailCodeError;
     private passwordError;
     private accountCreationError;
+    private hosts;
+    private hostsLoading;
+    private hostsError;
+    private selectedHost;
+    private userInfo;
+    private lowCredit;
+    private requestingPayment;
+    private paymentError;
+    private openedDueToCreditDepletion;
     connectedCallback(): void;
     private changePort;
     private connectLocalNode;
     private verifyLocalAd4mCode;
+    private browseHosts;
+    private retryFetchHosts;
+    private selectHost;
+    private proceedToAuth;
+    private handleAuthSuccess;
+    private handleRequestTopUp;
+    private handleSetWalletAddress;
     private connectRemoteNode;
     private emailLogin;
     private verifyEmailCode;
     private passwordLogin;
     private createAccount;
     private disconnect;
+    private get backTarget();
+    private handleBack;
+    private resetRemoteAuthState;
     renderViews(): import("lit").TemplateResult<1>;
     render(): import("lit").TemplateResult<1>;
 }