@le-space/ui 0.1.54 → 0.1.56

package/shared/index.js

@@ -17,6 +17,16 @@ var RELAY_PING_IDLE_STATE = {
   lastReceivedAt: null,
   error: null
 };
+var IDLE_DEPLOYMENT_PROGRESS = {
+  stage: "idle",
+  label: "Ready",
+  progress: 0,
+  status: "info",
+  itemHash: null,
+  detail: null,
+  error: null,
+  timestamp: Date.now()
+};
 var REFRESH_INTERVAL_MS = 3e4;
 var RELAY_PING_INTERVAL_MS = 2e4;
 
@@ -696,18 +706,34 @@ function resolveManifestSource(args) {
 }
 
 // src/shared/wallet-controller.ts
+import { keccak_256 } from "@noble/hashes/sha3";
 function getEthereumProvider() {
   return globalThis.window?.ethereum ?? null;
 }
+function toChecksumAddress(address) {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+    throw new Error("Invalid EVM address.");
+  }
+  const normalized = address.slice(2).toLowerCase();
+  const hash = Array.from(keccak_256(new TextEncoder().encode(normalized))).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  let result = "0x";
+  for (let index = 0; index < normalized.length; index += 1) {
+    result += Number.parseInt(hash[index], 16) >= 8 ? normalized[index].toUpperCase() : normalized[index];
+  }
+  return result;
+}
 async function connectWallet(provider = getEthereumProvider()) {
   if (!provider) {
     throw new Error("MetaMask provider not found.");
   }
-  const accounts = await provider.request({ method: "eth_requestAccounts" });
+  const accounts = await provider.request({
+    method: "eth_requestAccounts"
+  });
   const chainId = await provider.request({ method: "eth_chainId" });
+  const address = accounts[0] ? toChecksumAddress(accounts[0]) : null;
   return {
-    connected: Boolean(accounts[0]),
-    address: accounts[0] ?? null,
+    connected: Boolean(address),
+    address,
     chainId,
     isMetaMask: Boolean(provider.isMetaMask)
   };
@@ -963,6 +989,16 @@ async function createUnsignedForgetMessage(args) {
   };
 }
 async function forgetAlephMessages(args) {
+  args.onProgress?.({
+    stage: "building-delete-message",
+    label: "Building delete message",
+    progress: 18,
+    status: "info",
+    itemHash: null,
+    detail: [...new Set((args.hashes ?? []).filter(Boolean))].join(", ") || null,
+    error: null,
+    timestamp: Date.now()
+  });
   const unsignedMessage = await createUnsignedForgetMessage({
     sender: args.sender,
     hashes: args.hashes,
@@ -972,18 +1008,49 @@ async function forgetAlephMessages(args) {
     channel: args.channel,
     now: args.now
   });
+  args.onProgress?.({
+    stage: "signing-delete-message",
+    label: "Waiting for delete signature",
+    progress: 42,
+    status: "info",
+    itemHash: unsignedMessage.item_hash,
+    detail: unsignedMessage.item_hash,
+    error: null,
+    timestamp: Date.now()
+  });
   const message = await signAlephMessage(unsignedMessage, args.signer);
+  args.onProgress?.({
+    stage: "broadcasting-delete",
+    label: "Broadcasting delete to Aleph",
+    progress: 68,
+    status: "warning",
+    itemHash: message.item_hash,
+    detail: message.item_hash,
+    error: null,
+    timestamp: Date.now()
+  });
   const { response, httpStatus } = await broadcastAlephMessage2(message, {
     apiHost: args.apiHost,
     sync: args.sync,
     fetch: args.fetch
   });
+  const status = normalizeBroadcastStatus(httpStatus, response?.message_status);
+  args.onProgress?.({
+    stage: status === "rejected" ? "error" : "delete-completed",
+    label: status === "rejected" ? "Delete rejected by Aleph" : "Delete submitted to Aleph",
+    progress: 100,
+    status: status === "rejected" ? "error" : "success",
+    itemHash: message.item_hash,
+    detail: status === "rejected" ? String(response?.details ?? "Aleph rejected this delete request.") : null,
+    error: status === "rejected" ? String(response?.details ?? "Aleph rejected this delete request.") : null,
+    timestamp: Date.now()
+  });
   return {
     sender: args.sender,
     itemHash: message.item_hash,
     response,
     httpStatus,
-    status: normalizeBroadcastStatus(httpStatus, response?.message_status)
+    status
   };
 }
 
@@ -1090,6 +1157,16 @@ async function createUnsignedInstanceMessage(args) {
   };
 }
 async function deployInstance(args) {
+  args.onProgress?.({
+    stage: "building-message",
+    label: "Building deployment message",
+    progress: 32,
+    status: "info",
+    detail: args.content.metadata?.name ?? null,
+    itemHash: null,
+    error: null,
+    timestamp: Date.now()
+  });
   const unsignedMessage = await createUnsignedInstanceMessage({
     sender: args.sender,
     content: args.content,
@@ -1097,17 +1174,47 @@ async function deployInstance(args) {
     channel: args.channel,
     now: args.now
   });
+  args.onProgress?.({
+    stage: "signing-message",
+    label: "Waiting for MetaMask signature",
+    progress: 48,
+    status: "info",
+    detail: unsignedMessage.item_hash,
+    itemHash: unsignedMessage.item_hash,
+    error: null,
+    timestamp: Date.now()
+  });
   const signature = await args.signer(unsignedMessage.sender, [unsignedMessage.chain, unsignedMessage.sender, unsignedMessage.type, unsignedMessage.item_hash].join("\n"));
   const message = {
     ...unsignedMessage,
     signature: signature.startsWith("0x") ? signature : `0x${signature}`
   };
+  args.onProgress?.({
+    stage: "broadcasting",
+    label: "Broadcasting to Aleph",
+    progress: 64,
+    status: "info",
+    detail: message.item_hash,
+    itemHash: message.item_hash,
+    error: null,
+    timestamp: Date.now()
+  });
   const { response, httpStatus } = await broadcastAlephMessage2(message, {
     apiHost: args.apiHost,
     sync: args.sync,
     fetch: args.fetch
   });
   const status = httpStatus === 202 ? "pending" : typeof response.message_status === "string" ? response.message_status : "unknown";
+  args.onProgress?.({
+    stage: status === "processed" ? "deployment-confirmed" : status === "rejected" ? "deployment-rejected" : "waiting-for-aleph",
+    label: status === "processed" ? "Deployment accepted by Aleph" : status === "rejected" ? "Deployment rejected by Aleph" : "Deployment submitted to Aleph",
+    progress: status === "processed" ? 88 : status === "rejected" ? 100 : 78,
+    status: status === "processed" ? "success" : status === "rejected" ? "error" : "warning",
+    detail: status === "rejected" ? String(response.details ?? "Aleph rejected this deployment.") : null,
+    itemHash: message.item_hash,
+    error: status === "rejected" ? String(response.details ?? "Aleph rejected this deployment.") : null,
+    timestamp: Date.now()
+  });
   return {
     itemHash: message.item_hash,
     httpStatus,
@@ -1118,6 +1225,107 @@ async function deployInstance(args) {
   };
 }
 
+// ../core/src/guest.ts
+async function notifyCrnAllocation2(args) {
+  const normalizedCrnUrl = typeof args.crnUrl === "string" ? args.crnUrl.trim().replace(/\/+$/, "") : "";
+  if (!normalizedCrnUrl) {
+    return {
+      status: "skipped",
+      reason: "No CRN URL available for allocation notification."
+    };
+  }
+  try {
+    const response = await args.fetch(
+      `${normalizedCrnUrl}/control/allocation/notify`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ instance: args.itemHash })
+      }
+    );
+    const payload = await response.json().catch(() => null);
+    const responseText = payload == null ? "" : typeof payload === "string" ? payload : JSON.stringify(payload);
+    if (!response.ok) {
+      return {
+        status: "unconfirmed",
+        reason: `CRN allocation notify returned ${response.status}${responseText ? ` ${responseText}` : ""}.`,
+        payload
+      };
+    }
+    return {
+      status: "confirmed",
+      payload
+    };
+  } catch (error) {
+    return {
+      status: "unconfirmed",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isRetryableAllocationNotifyReason(reason) {
+  const normalized = String(reason ?? "").toLowerCase();
+  return normalized.includes("503") && (normalized.includes("node hash not yet discovered") || normalized.includes("cannot accept targeted allocations"));
+}
+async function notifyCrnAllocationWithRetry(args) {
+  const attempts = Math.max(1, Number(args.attempts ?? 6));
+  const delayMs = Math.max(0, Number(args.delayMs ?? 2e3));
+  const sleep = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let lastResult = null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    args.onProgress?.({
+      stage: "notifying-crn",
+      label: "Notifying selected CRN",
+      progress: 84,
+      status: "info",
+      itemHash: args.itemHash,
+      detail: `${attempt + 1}/${attempts} ${String(args.crnUrl ?? "").trim() || "selected CRN"}`,
+      error: null,
+      timestamp: Date.now()
+    });
+    const result = await notifyCrnAllocation2({
+      crnUrl: args.crnUrl,
+      itemHash: args.itemHash,
+      fetch: args.fetch
+    });
+    if (result.status === "confirmed" || result.status === "skipped") {
+      return result;
+    }
+    lastResult = result;
+    if (!isRetryableAllocationNotifyReason(result.reason)) {
+      return result;
+    }
+    if (attempt < attempts - 1) {
+      await sleep(delayMs);
+    }
+  }
+  return lastResult ?? {
+    status: "unconfirmed",
+    reason: "CRN allocation notify was not confirmed."
+  };
+}
+
+// src/shared/events.ts
+function createDeploymentProgressEmitter() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    emit(event) {
+      listeners.forEach((listener) => listener(event));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+
 // src/shared/controller.ts
 function defaultState(props = {}) {
   return {
@@ -1167,18 +1375,24 @@ function defaultState(props = {}) {
     selectedCrn: null,
     instances: [],
     relayPing: RELAY_PING_IDLE_STATE,
-    lastDeploymentHash: null
+    lastDeploymentHash: null,
+    deploymentProgress: IDLE_DEPLOYMENT_PROGRESS
   };
 }
 async function sha256Hex(payload) {
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
+  const digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(payload)
+  );
   return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function mappedPorts(execution) {
-  return Object.entries(execution?.networking?.mapped_ports ?? {}).map(([port, mapping]) => ({
-    label: `${port}/${mapping.udp ? "udp" : "tcp"}`,
-    hostPort: mapping.host ?? null
-  }));
+  return Object.entries(execution?.networking?.mapped_ports ?? {}).map(
+    ([port, mapping]) => ({
+      label: `${port}/${mapping.udp ? "udp" : "tcp"}`,
+      hostPort: mapping.host ?? null
+    })
+  );
 }
 function rootfsHealth(args) {
   if (!args.manifestState.valid || !args.manifestState.manifest) {
@@ -1236,7 +1450,9 @@ async function resolveManifest(args) {
 }
 async function inspectInstanceRuntime(args) {
   const details = {
-    messageStatus: String(args.instance.status ?? (args.instance.confirmed ? "processed" : "unknown")).toLowerCase(),
+    messageStatus: String(
+      args.instance.status ?? (args.instance.confirmed ? "processed" : "unknown")
+    ).toLowerCase(),
     allocationSource: null,
     crnUrl: null,
     hostIpv4: null,
@@ -1267,11 +1483,15 @@ async function inspectInstanceRuntime(args) {
     details.allocationSource = allocation?.source ?? null;
     details.crnUrl = allocation?.crnUrl ?? null;
     details.ipv6 = allocation?.vmIpv6 ?? null;
-    details.webUrl = await args.client.fetch2n6WebAccessUrl(args.instance.item_hash);
+    details.webUrl = await args.client.fetch2n6WebAccessUrl(
+      args.instance.item_hash
+    );
     if (!allocation?.crnUrl) {
       return details;
     }
-    const executionLookup = await args.client.fetchCrnExecutionMap(allocation.crnUrl);
+    const executionLookup = await args.client.fetchCrnExecutionMap(
+      allocation.crnUrl
+    );
     const executionPayload = executionLookup.payload?.[args.instance.item_hash];
     if (!executionPayload) {
       return details;
@@ -1299,7 +1519,10 @@ function compatibleCrnsForTier(crns, state) {
   if (!state.pricingSummary.pricing || !state.pricingSummary.tier) {
     return [];
   }
-  const spec = tierSpec(state.pricingSummary.pricing, state.pricingSummary.tier);
+  const spec = tierSpec(
+    state.pricingSummary.pricing,
+    state.pricingSummary.tier
+  );
   return filterDeployableCrns(crns, { spec });
 }
 async function pingPeer(libp2p) {
@@ -1361,6 +1584,7 @@ var SponsorRelayController = class {
   pingTimer = null;
   stopWalletWatch = null;
   props;
+  progressEmitter = createDeploymentProgressEmitter();
   constructor(props = {}) {
     this.props = props;
     this.state = defaultState(props);
@@ -1371,6 +1595,9 @@ var SponsorRelayController = class {
       twoN6ApiHost: props.twoN6ApiHost
     });
   }
+  subscribeToDeploymentProgress(listener) {
+    return this.progressEmitter.subscribe(listener);
+  }
   subscribe(subscriber) {
     this.subscribers.add(subscriber);
     return () => {
@@ -1395,6 +1622,18 @@ var SponsorRelayController = class {
     };
     this.emit();
   }
+  emitProgress(event) {
+    const nextEvent = {
+      ...event,
+      timestamp: Date.now()
+    };
+    this.patch({
+      deploymentProgress: nextEvent,
+      statusText: event.error ?? event.detail ?? event.label,
+      errorText: event.status === "error" ? event.error ?? event.detail ?? event.label : this.state.errorText
+    });
+    this.progressEmitter.emit(nextEvent);
+  }
   async init() {
     this.stopWalletWatch = watchWallet(() => {
       void this.refreshWalletDerivedState();
@@ -1514,11 +1753,25 @@ var SponsorRelayController = class {
       statusText: "Refreshing relay sponsor data"
     });
     try {
+      this.emitProgress({
+        stage: "loading-manifest",
+        label: "Loading manifest",
+        progress: 8,
+        status: "info",
+        detail: this.state.manifestUrl
+      });
       const manifestState = await resolveManifest({
         manifestUrl: this.state.manifestUrl,
         manifestJson: this.state.manifestJson
       });
       const manifest = manifestState.manifest;
+      this.emitProgress({
+        stage: "loading-pricing",
+        label: "Loading pricing and CRNs",
+        progress: 18,
+        status: "info",
+        detail: "Fetching live Aleph pricing and compatible CRNs."
+      });
       const [pricingSummary, crns] = await Promise.all([
         fetchInstancePricing(this.client.apiHost),
         this.client.fetchCrns()
@@ -1526,6 +1779,13 @@ var SponsorRelayController = class {
       let balance = this.state.balance;
       let instances = [];
       if (this.state.wallet.address) {
+        this.emitProgress({
+          stage: "loading-balance",
+          label: "Loading wallet balance",
+          progress: 28,
+          status: "info",
+          detail: this.state.wallet.address
+        });
         const [nextBalance, rawInstances] = await Promise.all([
           this.client.fetchBalance(this.state.wallet.address),
           this.state.showInstances ? this.client.fetchInstances(this.state.wallet.address) : Promise.resolve([])
@@ -1545,8 +1805,21 @@ var SponsorRelayController = class {
       let rootfsVerified = false;
       let rootfsResolution = null;
       if (manifestState.valid && manifest) {
-        rootfsVerified = await verifyRootfsExists(manifest.rootfsItemHash, this.client.apiHost);
-        rootfsResolution = await resolveRootfsReference(manifest.rootfsItemHash, this.client.apiHost);
+        this.emitProgress({
+          stage: "verifying-rootfs",
+          label: "Verifying rootfs",
+          progress: 38,
+          status: "info",
+          detail: manifest.rootfsItemHash
+        });
+        rootfsVerified = await verifyRootfsExists(
+          manifest.rootfsItemHash,
+          this.client.apiHost
+        );
+        rootfsResolution = await resolveRootfsReference(
+          manifest.rootfsItemHash,
+          this.client.apiHost
+        );
       }
       this.patch({
         manifestState,
@@ -1569,12 +1842,26 @@ var SponsorRelayController = class {
         statusText: "Relay sponsor data ready"
       });
       this.recomputePricingSummary();
+      this.emitProgress({
+        stage: "completed",
+        label: "Data ready",
+        progress: 100,
+        status: "success",
+        detail: "Manifest, pricing, and wallet state are ready."
+      });
     } catch (error) {
       this.patch({
         busy: { refreshing: false },
         errorText: error instanceof Error ? error.message : String(error),
         statusText: "Refresh failed"
       });
+      this.emitProgress({
+        stage: "error",
+        label: "Refresh failed",
+        progress: 100,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
   async refreshRelayPing() {
@@ -1587,7 +1874,9 @@ var SponsorRelayController = class {
       return;
     }
     if (!this.state.manifest || !this.state.rootfsVerified || !this.state.pricingSummary.pricing || !this.state.pricingSummary.tier) {
-      this.patch({ errorText: "Manifest, rootfs, and pricing must be ready before deploying." });
+      this.patch({
+        errorText: "Manifest, rootfs, and pricing must be ready before deploying."
+      });
       return;
     }
     this.patch({
@@ -1596,13 +1885,33 @@ var SponsorRelayController = class {
       statusText: "Broadcasting deployment"
     });
     try {
-      const spec = tierSpec(this.state.pricingSummary.pricing, this.state.pricingSummary.tier);
+      this.emitProgress({
+        stage: "validating",
+        label: "Validating deployment",
+        progress: 5,
+        status: "info",
+        detail: "Checking wallet, manifest, rootfs, pricing, and SSH key."
+      });
+      const spec = tierSpec(
+        this.state.pricingSummary.pricing,
+        this.state.pricingSummary.tier
+      );
+      this.emitProgress({
+        stage: "selecting-crn",
+        label: "Selecting CRN",
+        progress: 18,
+        status: "info",
+        detail: this.state.selectedCrn?.name ?? this.state.selectedCrn?.hash ?? "Auto-selected compatible CRN"
+      });
       const content = createInstanceContent({
         address: this.state.wallet.address,
         name: this.state.instanceName.trim(),
         sshPublicKey: this.state.sshPublicKey.trim(),
         rootfsItemHash: this.state.manifest.rootfsItemHash,
-        rootfsSizeMiB: Math.max(this.state.manifest.rootfsSizeMiB, spec.diskMiB),
+        rootfsSizeMiB: Math.max(
+          this.state.manifest.rootfsSizeMiB,
+          spec.diskMiB
+        ),
         vcpus: spec.vcpus,
         memoryMiB: spec.memoryMiB,
         rootfsVersion: this.state.manifest.version,
@@ -1615,20 +1924,57 @@ var SponsorRelayController = class {
         signer: personalSign,
         fetch: (url, init) => fetch(url, init),
         apiHost: this.client.apiHost,
-        sync: false
+        sync: false,
+        onProgress: (event) => {
+          this.emitProgress(event);
+        }
       });
       this.patch({
         busy: { deploying: false },
         statusText: `Deployment submitted: ${result.itemHash}`,
         lastDeploymentHash: result.itemHash
       });
+      if (result.status === "processed" && this.state.selectedCrn?.address) {
+        await notifyCrnAllocationWithRetry({
+          crnUrl: this.state.selectedCrn.address,
+          itemHash: result.itemHash,
+          fetch: (url, init) => fetch(url, init),
+          onProgress: (event) => {
+            this.emitProgress(event);
+          }
+        });
+      }
+      this.emitProgress({
+        stage: "refreshing-instances",
+        label: "Refreshing instances",
+        progress: 92,
+        status: "info",
+        itemHash: result.itemHash,
+        detail: "Reloading deployments and runtime state."
+      });
       await this.refresh();
+      this.emitProgress({
+        stage: "completed",
+        label: "Deployment completed",
+        progress: 100,
+        status: result.status === "rejected" ? "error" : "success",
+        itemHash: result.itemHash,
+        detail: result.status === "rejected" ? result.rejectionReason ?? "Aleph rejected the deployment." : "Deployment submitted and synced back into the panel.",
+        error: result.status === "rejected" ? result.rejectionReason ?? "Aleph rejected the deployment." : null
+      });
     } catch (error) {
       this.patch({
         busy: { deploying: false },
         errorText: error instanceof Error ? error.message : String(error),
         statusText: "Deployment failed"
       });
+      this.emitProgress({
+        stage: "error",
+        label: "Deployment failed",
+        progress: 100,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
   async deleteInstance(instanceHash) {
@@ -1642,6 +1988,14 @@ var SponsorRelayController = class {
       statusText: `Deleting ${instanceHash}`
     });
     try {
+      this.emitProgress({
+        stage: "validating",
+        label: "Validating delete request",
+        progress: 6,
+        status: "warning",
+        itemHash: instanceHash,
+        detail: "Preparing Aleph FORGET message."
+      });
       await forgetAlephMessages({
         sender: this.state.wallet.address,
         hashes: [instanceHash],
@@ -1653,13 +2007,33 @@ var SponsorRelayController = class {
           status: response.status,
           json: async () => await response.json()
         })),
-        apiHost: this.client.apiHost
+        apiHost: this.client.apiHost,
+        onProgress: (event) => {
+          this.emitProgress(event);
+        }
       });
       this.patch({
         busy: { deletingInstanceHash: null },
         statusText: `Deletion submitted for ${instanceHash}`
       });
+      this.emitProgress({
+        stage: "refreshing-instances",
+        label: "Refreshing instances after delete",
+        progress: 92,
+        status: "info",
+        itemHash: instanceHash,
+        detail: "Reloading current deployments."
+      });
       await this.refresh();
+      this.emitProgress({
+        stage: "completed",
+        label: "Delete completed",
+        progress: 100,
+        status: "success",
+        itemHash: instanceHash,
+        detail: "Delete request submitted and deployments refreshed.",
+        error: null
+      });
     } catch (error) {
       this.patch({
         busy: { deletingInstanceHash: null },
@@ -1676,6 +2050,7 @@ export {
   DEFAULT_INSTANCE_NAME,
   DEFAULT_MANIFEST_URL,
   DEFAULT_TIER_ID,
+  IDLE_DEPLOYMENT_PROGRESS,
   REFRESH_INTERVAL_MS,
   RELAY_PING_IDLE_STATE,
   RELAY_PING_INTERVAL_MS,
@@ -1683,6 +2058,7 @@ export {
   SponsorRelayController,
   buildSshCommand,
   connectWallet,
+  createDeploymentProgressEmitter,
   createSponsorRelayController,
   formatDateTime,
   formatNumber,
@@ -1691,5 +2067,6 @@ export {
   personalSign,
   resolveManifestSource,
   shortHash,
+  toChecksumAddress,
   watchWallet
 };