@le-space/node 0.1.11 → 0.1.13

package/index.d.ts

@@ -407,4 +407,15 @@ declare function runRootfsMode(env?: NodeJS.ProcessEnv, hooks?: {
 }): Promise<void>;
 declare function rootfsMain(): Promise<void>;
 
-export { type DeployConfigurationResult, type DeployExecutorDependencies, type DeployMetadataResult, type DeployOutputResult, type DeployPlan, type ParsedRootfsRunnerInputs, type PrivateKeyIdentity, actionLog, appendGithubOutput, appendGithubSummary, booleanEnv, buildScaffoldDeployResult, createPrivateKeyIdentity, createPrivateKeySigner, emitDeployOutputs, emitGeocodedCrnOutputs, emitRootfsOutputs, executeDeployPlan, integerEnv, jsonEnv, main, optionalEnv, parseDeployPlan, parseRootfsRunnerInputs, requiredEnv, rootfsMain, runActionMode, runLocalCommand, runRootfsMode };
+interface RunResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+declare function parseLastJsonObject(text: string): Record<string, unknown>;
+declare function runSitePublishMode(env?: NodeJS.ProcessEnv): Promise<void>;
+declare function runProbeMode(env?: NodeJS.ProcessEnv): Promise<void>;
+declare function runBootstrapEnvMode(env?: NodeJS.ProcessEnv): Promise<void>;
+declare function runSiteMode(env?: NodeJS.ProcessEnv): Promise<void>;
+
+export { type DeployConfigurationResult, type DeployExecutorDependencies, type DeployMetadataResult, type DeployOutputResult, type DeployPlan, type ParsedRootfsRunnerInputs, type PrivateKeyIdentity, type RunResult, actionLog, appendGithubOutput, appendGithubSummary, booleanEnv, buildScaffoldDeployResult, createPrivateKeyIdentity, createPrivateKeySigner, emitDeployOutputs, emitGeocodedCrnOutputs, emitRootfsOutputs, executeDeployPlan, integerEnv, jsonEnv, main, optionalEnv, parseDeployPlan, parseLastJsonObject, parseRootfsRunnerInputs, requiredEnv, rootfsMain, runActionMode, runBootstrapEnvMode, runLocalCommand, runProbeMode, runRootfsMode, runSiteMode, runSitePublishMode };

package/index.js

@@ -617,6 +617,15 @@ function normalizeExecution(item, crnUrl) {
 }
 
 // ../core/src/deployment-inspection.ts
+function insufficientBalanceMessage(details) {
+  const firstError = details && Array.isArray(details.errors) && details.errors[0] && typeof details.errors[0] === "object" ? details.errors[0] : null;
+  const accountBalance = firstError?.account_balance;
+  const requiredBalance = firstError?.required_balance;
+  if (accountBalance != null && requiredBalance != null) {
+    return `insufficient Aleph balance: account has ${accountBalance}, required is ${requiredBalance}`;
+  }
+  return null;
+}
 async function fetchMessageEnvelope(itemHash, options) {
   const response = await options.fetch(`${options.apiHost ?? DEFAULT_ALEPH_API_HOST}/api/v0/messages/${itemHash}`, {
     cache: "no-cache"
@@ -625,6 +634,32 @@ async function fetchMessageEnvelope(itemHash, options) {
   if (!response.ok) throw new Error(`Message lookup failed: ${response.status}`);
   return await response.json();
 }
+async function inspectMessageResult(itemHash, options) {
+  const label = options.label ?? "Message";
+  const payload = await fetchMessageEnvelope(itemHash, options);
+  if (!payload) {
+    return {
+      status: "unknown",
+      errorCode: null,
+      details: null,
+      rejectionReason: `${label} ${itemHash} was not found on Aleph.`
+    };
+  }
+  const status = normalizeMessageStatus(payload.status);
+  const errorCode = typeof payload.error_code === "number" ? payload.error_code : null;
+  const details = payload.details && typeof payload.details === "object" ? payload.details : null;
+  let rejectionReason = null;
+  if (status === "rejected") {
+    const balanceMessage = errorCode === 5 ? insufficientBalanceMessage(details) : null;
+    rejectionReason = balanceMessage ? `${label} ${itemHash} was rejected by Aleph due to ${balanceMessage}.` : `${label} ${itemHash} was rejected by Aleph${errorCode ? ` (error ${errorCode})` : ""}.`;
+  }
+  return {
+    status,
+    errorCode,
+    details,
+    rejectionReason
+  };
+}
 async function fetchReference(itemHash, options) {
   const payload = await fetchMessageEnvelope(itemHash, options);
   if (!payload) {
@@ -1409,11 +1444,11 @@ function proxyHostnameFromUrl(value) {
     return null;
   }
 }
-async function defaultHttpProbe(fetch, url, timeoutMs = 1e4) {
+async function defaultHttpProbe(fetch2, url, timeoutMs = 1e4) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    const response = await fetch(url, {
+    const response = await fetch2(url, {
       method: "GET",
       redirect: "follow",
       signal: controller.signal
@@ -2790,6 +2825,156 @@ if (import.meta.url === pathToFileURL2(process.argv[1] ?? "").href) {
     process.exitCode = 1;
   });
 }
+
+// src/site-runner.ts
+import process2 from "process";
+import { spawn as spawn2 } from "child_process";
+async function runCapture(command, args, options = {}) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      env: { ...process2.env, ...options.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("exit", (exitCode) => resolve({ stdout, stderr, exitCode: exitCode ?? 1 }));
+  });
+}
+function parseLastJsonObject(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const candidate = lines[index]?.trimStart() ?? "";
+    if (!candidate.startsWith("{")) continue;
+    const suffix = lines.slice(index).join("\n");
+    try {
+      return JSON.parse(suffix);
+    } catch {
+    }
+  }
+  throw new Error(`Could not parse JSON object from output: ${text}`);
+}
+async function waitForAlephMessage(itemHash, env = process2.env) {
+  const apiHost = optionalEnv("ALEPH_SITE_ALEPH_API_HOST", "https://api2.aleph.im", env);
+  const attempts = Number(optionalEnv("ALEPH_SITE_ALEPH_MESSAGE_WAIT_ATTEMPTS", "60", env));
+  const delayMs = Number(optionalEnv("ALEPH_SITE_ALEPH_MESSAGE_WAIT_DELAY_MS", "5000", env));
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const result = await inspectMessageResult(itemHash, {
+      apiHost,
+      fetch,
+      label: "Aleph STORE message"
+    });
+    if (result.status === "processed") return;
+    if (result.status === "rejected") {
+      throw new Error(result.rejectionReason ?? `Aleph STORE message ${itemHash} was rejected.`);
+    }
+    if (attempt < attempts) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw new Error(`Aleph STORE message ${itemHash} did not become processed in time.`);
+}
+function mergedAddrs(env = process2.env) {
+  const combined = [];
+  for (const key of ["PROBE_MULTIADDRS_JSON", "BROWSER_BOOTSTRAP_MULTIADDRS_JSON"]) {
+    const raw = env[key] ?? "[]";
+    for (const value of JSON.parse(raw)) {
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed) combined.push(trimmed);
+      }
+    }
+  }
+  return Array.from(new Set(combined));
+}
+async function runSitePublishMode(env = process2.env) {
+  const projectDir = requiredEnv("ALEPH_SITE_PROJECT_DIR", env);
+  const publishScript = optionalEnv("ALEPH_SITE_PUBLISH_SCRIPT", "go-peer/aleph/publish-static-site.py", env);
+  const siteDirectory = requiredEnv("ALEPH_SITE_DIRECTORY", env);
+  const pythonBin = optionalEnv("ALEPH_SITE_PYTHON", "python3", env);
+  const pin = optionalEnv("ALEPH_SITE_PIN", "true", env) === "true";
+  const publish = await runCapture(pythonBin, [publishScript, siteDirectory], { cwd: projectDir });
+  process2.stdout.write(publish.stdout);
+  if (publish.stderr) process2.stderr.write(publish.stderr);
+  if (publish.exitCode !== 0) {
+    throw new Error(`${publishScript} failed with exit code ${publish.exitCode}`);
+  }
+  const payload = parseLastJsonObject(publish.stdout);
+  const cidV0 = String(payload.cid_v0 ?? "");
+  const cidV1 = String(payload.cid_v1 ?? "");
+  if (!cidV0 || !cidV1 || cidV0 === "null" || cidV1 === "null") {
+    throw new Error(`Failed to extract IPFS CIDs from publish result: ${JSON.stringify(payload)}`);
+  }
+  await appendGithubOutput("ipfs_cid_v0", cidV0, env);
+  await appendGithubOutput("ipfs_cid_v1", cidV1, env);
+  await appendGithubOutput("url", `https://${cidV1}.ipfs.aleph.sh`, env);
+  let itemHash = "";
+  if (pin) {
+    const pinResult = await runCapture("aleph", ["file", "pin", cidV0], { cwd: projectDir });
+    if (pinResult.stdout) process2.stdout.write(pinResult.stdout);
+    if (pinResult.stderr) process2.stderr.write(pinResult.stderr);
+    if (pinResult.exitCode !== 0) {
+      throw new Error(`aleph file pin ${cidV0} failed with exit code ${pinResult.exitCode}`);
+    }
+    const pinPayload = parseLastJsonObject(pinResult.stdout);
+    itemHash = String(pinPayload.item_hash ?? "");
+    if (!itemHash) {
+      throw new Error(`Aleph pin response did not include item_hash: ${JSON.stringify(pinPayload)}`);
+    }
+    await appendGithubOutput("item_hash", itemHash, env);
+    await waitForAlephMessage(itemHash, env);
+  }
+  await appendGithubSummary([
+    "## Shared Site Runner",
+    "",
+    `- Site directory: \`${siteDirectory}\``,
+    `- IPFS CID v0: \`${cidV0}\``,
+    `- IPFS CID v1: \`${cidV1}\``,
+    `- Aleph item hash: \`${itemHash}\``
+  ], env);
+}
+async function runProbeMode(env = process2.env) {
+  const addrs = mergedAddrs(env);
+  if (addrs.length === 0) throw new Error("No relay probe or browser bootstrap multiaddrs were supplied.");
+  const workdir = requiredEnv("ALEPH_SITE_PROBE_WORKDIR", env);
+  const scriptPath = requiredEnv("ALEPH_SITE_PROBE_SCRIPT", env);
+  const nodeBin = optionalEnv("ALEPH_SITE_NODE", "node", env);
+  const result = await runCapture(nodeBin, [scriptPath, ...addrs], { cwd: workdir });
+  if (result.stdout) process2.stdout.write(result.stdout);
+  if (result.stderr) process2.stderr.write(result.stderr);
+  if (result.exitCode !== 0) {
+    throw new Error(`relay probe failed with exit code ${result.exitCode}`);
+  }
+  const rows = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  if (rows.length === 0) throw new Error("Relay probe produced no JSON output.");
+  if (rows.some((row) => row.ok !== true)) throw new Error("At least one relay protocol probe failed.");
+  await appendGithubOutput("ok", "true", env);
+  await appendGithubOutput("json", result.stdout.trim(), env);
+  await appendGithubOutput("merged_multiaddrs_json", JSON.stringify(addrs), env);
+}
+async function runBootstrapEnvMode(env = process2.env) {
+  const raw = env.BROWSER_BOOTSTRAP_MULTIADDRS_JSON ?? "[]";
+  const addrs = JSON.parse(raw).filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim());
+  const csv = addrs.join(",");
+  await appendGithubOutput("json", JSON.stringify(addrs), env);
+  await appendGithubOutput("csv", csv, env);
+  await appendGithubOutput("count", String(addrs.length), env);
+  await appendGithubOutput("available", addrs.length > 0 ? "true" : "false", env);
+}
+async function runSiteMode(env = process2.env) {
+  const mode = optionalEnv("ALEPH_VM_MODE", "site-publish", env);
+  if (mode === "site-publish") return await runSitePublishMode(env);
+  if (mode === "relay-probe") return await runProbeMode(env);
+  if (mode === "bootstrap-env") return await runBootstrapEnvMode(env);
+  throw new Error(`Unsupported ALEPH_VM_MODE "${mode}" in shared site runner.`);
+}
 export {
   actionLog,
   appendGithubOutput,
@@ -2807,10 +2992,15 @@ export {
   main,
   optionalEnv,
   parseDeployPlan,
+  parseLastJsonObject,
   parseRootfsRunnerInputs,
   requiredEnv,
   rootfsMain,
   runActionMode,
+  runBootstrapEnvMode,
   runLocalCommand,
-  runRootfsMode
+  runProbeMode,
+  runRootfsMode,
+  runSiteMode,
+  runSitePublishMode
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/node",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Node and GitHub Actions adapters for shared Aleph tooling.",
   "license": "MIT",
   "type": "module",
@@ -16,9 +16,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@le-space/core": "0.1.11",
-    "@le-space/shared-types": "0.1.11",
-    "@le-space/rootfs": "0.1.11",
+    "@le-space/core": "0.1.13",
+    "@le-space/shared-types": "0.1.13",
+    "@le-space/rootfs": "0.1.13",
     "ethers": "^6.15.0"
   }
 }