@aigne/doc-smith 0.8.4 → 0.8.6

package/utils/blocklet.mjs

@@ -1,3 +1,5 @@
+import { joinURL } from "ufo";
+
 /**
  * Custom error class for invalid blocklet application URLs
  */
@@ -23,17 +25,14 @@ export class ComponentNotFoundError extends Error {
   }
 }
 
-export async function getComponentMountPoint(appUrl, did) {
-  const url = new URL(appUrl);
-  const blockletJsUrl = `${url.origin}/__blocklet__.js?type=json`;
+export async function getComponentInfo(appUrl) {
+  const blockletJsUrl = joinURL(appUrl, "__blocklet__.js?type=json");
 
   let blockletJs;
   try {
     blockletJs = await fetch(blockletJsUrl, {
       method: "GET",
-      headers: {
-        Accept: "application/json",
-      },
+      headers: { Accept: "application/json" },
     });
   } catch (error) {
     throw new InvalidBlockletError(appUrl, null, error.message);
@@ -50,6 +49,12 @@ export async function getComponentMountPoint(appUrl, did) {
     throw new InvalidBlockletError(appUrl, null, "Invalid JSON response");
   }
 
+  return config;
+}
+
+export async function getComponentMountPoint(appUrl, did) {
+  const config = await getComponentInfo(appUrl);
+
   const component = config.componentMountPoints?.find((component) => component.did === did);
   if (!component) {
     throw new ComponentNotFoundError(did, appUrl);
@@ -57,3 +62,17 @@ export async function getComponentMountPoint(appUrl, did) {
 
   return component.mountPoint;
 }
+
+export async function getComponentInfoWithMountPoint(appUrl, did) {
+  const config = await getComponentInfo(appUrl);
+
+  const component = config.componentMountPoints?.find((component) => component.did === did);
+  if (!component) {
+    throw new ComponentNotFoundError(did, appUrl);
+  }
+
+  return {
+    ...config,
+    mountPoint: component.mountPoint,
+  };
+}

package/utils/constants.mjs

@@ -330,6 +330,8 @@ export const DEPTH_RECOMMENDATION_LOGIC = {
 // Component mount point ID for Discuss Kit
 export const DISCUSS_KIT_DID = "z8ia1WEiBZ7hxURf6LwH21Wpg99vophFwSJdu";
 
+export const PAYMENT_KIT_DID = "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk";
+
 // Discuss Kit related URLs
 export const DISCUSS_KIT_STORE_URL =
   "https://store.blocklet.dev/blocklets/z8ia1WEiBZ7hxURf6LwH21Wpg99vophFwSJdu";

package/utils/deploy.mjs

@@ -0,0 +1,404 @@
+import chalk from "chalk";
+import { joinURL } from "ufo";
+import { getComponentInfo, getComponentInfoWithMountPoint } from "./blocklet.mjs";
+import { PAYMENT_KIT_DID } from "./constants.mjs";
+import { saveValueToConfig } from "./utils.mjs";
+
+// ==================== URL Configuration ====================
+const BASE_URL = process.env.DOC_SMITH_BASE_URL || "";
+
+// ==================== Timeout Configuration ====================
+const INTERVAL_MS = 3000; // 3 seconds between each check
+const TIMEOUTS = {
+  paymentWait: 300, // Step 2: Payment wait timeout (5 minutes)
+  installation: 300, // Step 3: Installation timeout (5 minutes)
+  serviceStart: 300, // Step 4: Service startup timeout (5 minutes)
+};
+
+// ==================== Utility Functions ====================
+
+/**
+ * Generic polling utility with timeout and retry logic
+ * @param {Object} options - Polling configuration
+ * @param {Function} options.checkCondition - Async function that returns result if condition met, null/false if not
+ * @param {number} options.maxAttempts - Maximum number of attempts
+ * @param {number} options.intervalMs - Interval between attempts in milliseconds
+ * @param {string} options.timeoutMessage - Error message for timeout
+ * @param {string} options.stepName - Name of the step for logging (optional)
+ * @returns {Promise<any>} Result from checkCondition when successful
+ */
+async function pollWithTimeout({
+  checkCondition,
+  maxAttempts,
+  intervalMs = INTERVAL_MS,
+  timeoutMessage,
+  stepName = "Operation",
+}) {
+  let attempts = 0;
+
+  while (attempts < maxAttempts) {
+    attempts++;
+
+    try {
+      const result = await checkCondition();
+      if (result !== null && result !== false) {
+        return result;
+      }
+    } catch (_error) {
+      // Log error for debugging but continue retrying unless it's the last attempt
+      if (attempts === maxAttempts) {
+        throw new Error(`${timeoutMessage} (${stepName} failed after ${maxAttempts} attempts)`);
+      }
+      // Continue retrying for non-fatal errors
+    }
+
+    // If this is the last attempt, don't wait - just exit the loop
+    if (attempts === maxAttempts) {
+      break;
+    }
+
+    // Wait before retry
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  // If we reach here, all attempts were exhausted
+  throw new Error(`${timeoutMessage} (${stepName} timed out after ${maxAttempts} attempts)`);
+}
+
+// ==================== API Endpoints ====================
+const API_ENDPOINTS = {
+  createCheckout: `/api/checkout-sessions/start`,
+  paymentPage: `/checkout/pay/{id}`,
+  orderStatus: `/api/vendors/order/{id}/status`,
+  orderDetail: `/api/vendors/order/{id}/detail`,
+};
+
+let prefix = "";
+let paymentLinkId = "";
+/**
+ * Deploy a new Discuss Kit service and return the installation URL
+ * @returns {Promise<string>} - The URL of the deployed service
+ */
+export async function deploy(id, cachedUrl) {
+  const { mountPoint, PAYMENT_LINK_ID } = await getComponentInfoWithMountPoint(
+    BASE_URL,
+    PAYMENT_KIT_DID,
+  );
+  prefix = mountPoint;
+  paymentLinkId = PAYMENT_LINK_ID;
+
+  if (!PAYMENT_LINK_ID) {
+    const { PAYMENT_LINK_ID: id } = await getComponentInfoWithMountPoint(
+      joinURL(BASE_URL, mountPoint),
+      PAYMENT_KIT_DID,
+    );
+    paymentLinkId = id;
+  }
+
+  // Step 1: Create payment link and open
+  const cachedCheckoutId = await checkCacheCheckoutId(id);
+  let checkoutId = cachedCheckoutId;
+  let paymentUrl = cachedUrl;
+  if (!cachedCheckoutId) {
+    const { checkoutId: newCheckoutId, paymentUrl: newPaymentUrl } = await createPaymentSession();
+    checkoutId = newCheckoutId;
+    paymentUrl = newPaymentUrl;
+  }
+
+  if (!paymentUrl) {
+    paymentUrl = joinURL(BASE_URL, prefix, API_ENDPOINTS.paymentPage.replace("{id}", checkoutId));
+  }
+  if (cachedCheckoutId !== checkoutId) {
+    await openBrowser(paymentUrl);
+  }
+
+  // Step 2: Wait for payment completion
+  console.log(`${chalk.blue("⏳")} Step 1/4: Waiting for payment...`);
+  console.log(`${chalk.blue("🔗")} Payment link: ${chalk.cyan(paymentUrl)}\n`);
+  await pollPaymentStatus(checkoutId);
+  await saveValueToConfig("checkoutId", checkoutId, "Checkout ID for document deployment service");
+  await saveValueToConfig("paymentUrl", paymentUrl, "Payment URL for document deployment service");
+
+  // Step 3: Wait for service installation
+  console.log(`${chalk.blue("📦")} Step 2/4: Installing service...`);
+  const readyVendors = await waitInstallation(checkoutId);
+
+  // Step 4: Wait for service startup
+  console.log(`${chalk.blue("🚀")} Step 3/4: Starting service...`);
+  const runningVendors = await waitServiceRunning(readyVendors);
+
+  // Step 5: Get final URL
+  console.log(`${chalk.blue("🌐")} Step 4/4: Getting service URL...`);
+  const urlInfo = await getDashboardAndUrl(checkoutId, runningVendors);
+  const { appUrl, homeUrl, token } = urlInfo || {};
+
+  console.log(
+    `\n${chalk.blue("🔗")} Your website is available at: ${chalk.cyan(homeUrl || appUrl)}\n`,
+  );
+
+  return {
+    appUrl,
+    homeUrl,
+    token,
+  };
+}
+
+/**
+ * Check if there is a cached checkoutId
+ */
+async function checkCacheCheckoutId(checkoutId) {
+  try {
+    if (!checkoutId) {
+      return "";
+    }
+
+    const orderStatusUrl = joinURL(
+      BASE_URL,
+      prefix,
+      API_ENDPOINTS.orderStatus.replace("{id}", checkoutId),
+    );
+    const response = await fetch(orderStatusUrl);
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    if (data.error) {
+      throw new Error(data.error);
+    }
+
+    // Check payment status and vendors status
+    const isPaid = data.payment_status === "paid";
+
+    return isPaid ? checkoutId : "";
+  } catch (_error) {
+    await saveValueToConfig("checkoutId", "", "Checkout ID for document deployment service");
+    return "";
+  }
+}
+
+/**
+ * Create payment session - Step 1
+ */
+async function createPaymentSession() {
+  // 1. Call payment API
+  if (!paymentLinkId) {
+    throw new Error("Payment link ID not found");
+  }
+
+  const createCheckoutId = joinURL(BASE_URL, prefix, API_ENDPOINTS.createCheckout, paymentLinkId);
+  try {
+    const response = await fetch(createCheckoutId, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        needShortUrl: true,
+        metadata: {
+          page_info: {
+            has_vendor: true,
+            success_message: {
+              en: "Congratulations! Your website has been successfully installed. You can return to the command-line tool to continue the next steps.",
+              zh: "恭喜您，你的网站已安装成功！可以返回命令行工具继续后续操作！",
+            },
+          },
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const checkoutId = data.checkoutSession.id;
+    const paymentUrl = data.paymentUrl;
+
+    return { checkoutId, paymentUrl };
+  } catch (error) {
+    console.error(
+      `${chalk.red("❌")} Failed to create payment session:`,
+      error.message,
+      createCheckoutId,
+    );
+    throw new Error(`Failed to create payment session: ${error.message}`);
+  }
+}
+
+/**
+ * Open browser with payment URL
+ */
+async function openBrowser(paymentUrl) {
+  const { default: open } = await import("open");
+  try {
+    await open(paymentUrl);
+  } catch (_error) {
+    console.log(`${chalk.yellow("⚠️  Could not open browser automatically.")}`);
+    console.log(`${chalk.blue("Please manually open this URL:")} ${chalk.cyan(paymentUrl)}`);
+  }
+}
+
+/**
+ * Wait for payment completion - Step 2 (5 minute timeout)
+ */
+async function pollPaymentStatus(checkoutId) {
+  return pollWithTimeout({
+    checkCondition: async () => {
+      const orderStatusUrl = joinURL(
+        BASE_URL,
+        prefix,
+        API_ENDPOINTS.orderStatus.replace("{id}", checkoutId),
+      );
+      const response = await fetch(orderStatusUrl);
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const data = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error);
+      }
+
+      // Check payment status and vendors status
+      const isPaid = data.payment_status === "paid";
+      if (isPaid) {
+        return data.vendors;
+      }
+
+      return null; // Not ready yet, continue polling
+    },
+    maxAttempts: Math.ceil((TIMEOUTS.paymentWait * 1000) / INTERVAL_MS),
+    intervalMs: INTERVAL_MS,
+    timeoutMessage: "Payment timeout - please complete payment within 5 minutes",
+    stepName: "Payment",
+  });
+}
+
+/**
+ * Wait for installation completion - Step 3
+ */
+async function waitInstallation(checkoutId) {
+  return pollWithTimeout({
+    checkCondition: async () => {
+      const orderStatusUrl = joinURL(
+        BASE_URL,
+        prefix,
+        API_ENDPOINTS.orderStatus.replace("{id}", checkoutId),
+      );
+      const response = await fetch(orderStatusUrl);
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const data = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error);
+      }
+
+      // Check if all vendors meet conditions: progress >= 80 and appUrl exists
+      const isInstalled = data.vendors?.every((vendor) => vendor.progress >= 80 && vendor.appUrl);
+      if (isInstalled) {
+        return data.vendors;
+      }
+
+      return null; // Not ready yet, continue polling
+    },
+    maxAttempts: Math.ceil((TIMEOUTS.installation * 1000) / INTERVAL_MS),
+    intervalMs: INTERVAL_MS,
+    timeoutMessage: "Installation timeout - services failed to install within 5 minutes",
+    stepName: "Installation",
+  });
+}
+
+/**
+ * Wait for service to start running - Step 4
+ */
+async function waitServiceRunning(readyVendors) {
+  return pollWithTimeout({
+    checkCondition: async () => {
+      // Check running status of all vendors concurrently
+      const vendorChecks = readyVendors.map(async (vendor) => {
+        try {
+          const blockletInfo = await getComponentInfo(vendor.appUrl);
+
+          if (blockletInfo.status === "running") {
+            return vendor;
+          }
+          return null;
+        } catch (_error) {
+          return null;
+        }
+      });
+
+      const results = await Promise.all(vendorChecks);
+      const runningVendors = results.filter((vendor) => vendor !== null);
+
+      if (runningVendors.length === readyVendors.length) {
+        return runningVendors;
+      }
+
+      return null; // Not ready yet, continue polling
+    },
+    maxAttempts: Math.ceil((TIMEOUTS.serviceStart * 1000) / INTERVAL_MS),
+    intervalMs: INTERVAL_MS,
+    timeoutMessage: "Service start timeout - services failed to start within 5 minutes",
+    stepName: "Service Start",
+  });
+}
+
+/**
+ * Get final URL - Step 5
+ */
+async function getDashboardAndUrl(checkoutId, runningVendors) {
+  try {
+    // 5. Get order details
+    const orderDetailUrl = joinURL(
+      BASE_URL,
+      prefix,
+      API_ENDPOINTS.orderDetail.replace("{id}", checkoutId),
+    );
+    const response = await fetch(orderDetailUrl);
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    if (data.vendors.length === 0) {
+      throw new Error("No vendors found in order details");
+    }
+
+    // Wait 3 seconds
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    // Return the appUrl of the first vendor (usually only one)
+    const appUrl = runningVendors[0]?.appUrl;
+    if (!appUrl) {
+      throw new Error("No app URL found in order details");
+    }
+
+    return {
+      appUrl,
+      dashboardUrl: data.vendors[0]?.dashboardUrl,
+      homeUrl: data.vendors[0]?.homeUrl,
+      token: data.vendors[0]?.token,
+    };
+  } catch (error) {
+    console.error(`${chalk.red("❌")} Failed to get order details:`, error.message);
+    // If getting details fails, use the appUrl of running vendor
+    return {
+      appUrl: runningVendors[0]?.appUrl || null,
+      dashboardUrl: runningVendors[0]?.dashboardUrl || null,
+      homeUrl: runningVendors[0]?.homeUrl || null,
+      token: runningVendors[0]?.token || null,
+    };
+  }
+}
+
+export default deploy;