@le-space/node 0.1.16 → 0.1.18

package/index.d.ts

@@ -231,6 +231,20 @@ declare function retainSuccessfulDeployments(args: {
         hash: string;
         result: Awaited<ReturnType<typeof forgetAlephMessages>>;
     }[];
+    forgetStageResults: {
+        stage: "instances" | "dependents";
+        hashes: string[];
+        skipped?: boolean;
+        skippedReason?: string;
+        forgottenHashes: string[];
+        outstandingForgetHashes: string[];
+        statuses: Record<string, string>;
+        forgetResult: Awaited<ReturnType<typeof forgetAlephMessages>> | null;
+        followUpForgetResults: Array<{
+            hash: string;
+            result: Awaited<ReturnType<typeof forgetAlephMessages>>;
+        }>;
+    }[];
 }>;
 
 declare function buildScaffoldDeployResult(env?: NodeJS.ProcessEnv): DeployOutputResult;

package/index.js

@@ -896,6 +896,26 @@ function retentionRecordId(record) {
 function hashesFromRetentionRecord(record) {
   return [record.instance_item_hash, record.rootfs_item_hash, record.site_item_hash].filter(Boolean);
 }
+function uniqueHashes(hashes) {
+  return [...new Set(hashes.filter(Boolean))];
+}
+function dependentHashesFromRetentionRecord(record) {
+  return [record.rootfs_item_hash, record.site_item_hash].filter(Boolean);
+}
+function splitForgetStages(args) {
+  const instanceForgetHashes = uniqueHashes(args.prunedRecords.map((record) => record.instance_item_hash)).filter(
+    (hash) => !args.retainedHashes.has(hash)
+  );
+  const dependentForgetHashes = uniqueHashes([
+    ...args.prunedRecords.flatMap(dependentHashesFromRetentionRecord),
+    ...args.extraForgetHashes
+  ]).filter((hash) => !args.retainedHashes.has(hash) && !instanceForgetHashes.includes(hash));
+  return {
+    instanceForgetHashes,
+    dependentForgetHashes,
+    orderedForgetHashes: [...instanceForgetHashes, ...dependentForgetHashes]
+  };
+}
 async function fetchAggregateKey(args) {
   const requestUrl = new URL(`/api/v0/aggregates/${args.address}.json`, args.apiHost ?? "https://api2.aleph.im");
   requestUrl.searchParams.set("keys", args.key);
@@ -973,6 +993,73 @@ async function classifyForgetHashes(args) {
     statuses
   };
 }
+async function executeForgetStage(args) {
+  const stageHashes = uniqueHashes(args.hashes);
+  let forgetResult = null;
+  const followUpForgetResults = [];
+  if (stageHashes.length === 0) {
+    return {
+      hashes: stageHashes,
+      forgottenHashes: [],
+      outstandingForgetHashes: [],
+      statuses: {},
+      forgetResult,
+      followUpForgetResults
+    };
+  }
+  let classified = await classifyForgetHashes({
+    hashes: stageHashes,
+    fetch: args.fetch,
+    apiHost: args.apiHost
+  });
+  if (classified.outstandingForgetHashes.length > 0) {
+    forgetResult = await forgetAlephMessages({
+      sender: args.sender,
+      hashes: classified.outstandingForgetHashes,
+      reason: args.reason,
+      signer: args.signer,
+      hasher: args.hasher,
+      fetch: args.fetch,
+      channel: args.channel,
+      apiHost: args.apiHost,
+      now: args.now
+    });
+    classified = await classifyForgetHashes({
+      hashes: stageHashes,
+      fetch: args.fetch,
+      apiHost: args.apiHost
+    });
+    if (classified.outstandingForgetHashes.length > 0) {
+      for (const hash of classified.outstandingForgetHashes) {
+        const result = await forgetAlephMessages({
+          sender: args.sender,
+          hashes: [hash],
+          reason: args.reason,
+          signer: args.signer,
+          hasher: args.hasher,
+          fetch: args.fetch,
+          channel: args.channel,
+          apiHost: args.apiHost,
+          now: args.now
+        });
+        followUpForgetResults.push({ hash, result });
+      }
+      classified = await classifyForgetHashes({
+        hashes: stageHashes,
+        fetch: args.fetch,
+        apiHost: args.apiHost
+      });
+    }
+  }
+  return {
+    hashes: stageHashes,
+    forgottenHashes: classified.forgottenHashes,
+    outstandingForgetHashes: classified.outstandingForgetHashes,
+    statuses: classified.statuses,
+    forgetResult,
+    followUpForgetResults
+  };
+}
 async function retainSuccessfulDeployments(args) {
   const keepCount = Math.max(0, Number.parseInt(String(args.keepCount ?? 0), 10) || 0);
   const aggregateKey = asString3(args.aggregateKey) ?? SUCCESSFUL_DEPLOYMENTS_AGGREGATE_KEY;
@@ -999,10 +1086,13 @@ async function retainSuccessfulDeployments(args) {
   const retainedRecords = keepCount > 0 ? uniqueRecords.slice(0, keepCount) : [];
   const prunedRecords = keepCount > 0 ? uniqueRecords.slice(keepCount) : uniqueRecords;
   const retainedHashes = new Set(retainedRecords.flatMap(hashesFromRetentionRecord));
-  const extraForgetHashes = [...new Set((args.extraForgetHashes ?? []).filter(Boolean))];
-  const forgetHashes = [.../* @__PURE__ */ new Set([...prunedRecords.flatMap(hashesFromRetentionRecord), ...extraForgetHashes])].filter(
-    (hash) => !retainedHashes.has(hash)
-  );
+  const extraForgetHashes = uniqueHashes(args.extraForgetHashes ?? []);
+  const { instanceForgetHashes, dependentForgetHashes, orderedForgetHashes } = splitForgetStages({
+    prunedRecords,
+    extraForgetHashes,
+    retainedHashes
+  });
+  const forgetHashes = orderedForgetHashes;
   const aggregateContent = {
     keep: keepCount,
     updated_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1019,25 +1109,40 @@ async function retainSuccessfulDeployments(args) {
     apiHost: args.apiHost,
     now: args.now
   });
-  let forgetResult = null;
-  let followUpForgetResults = [];
+  const forgetReason = args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`;
+  const forgetStageResults = [];
   let forgottenHashes = [];
   let outstandingForgetHashes = [];
   let forgetStatuses = {};
-  if (forgetHashes.length > 0) {
-    const initiallyOutstanding = await classifyForgetHashes({
-      hashes: forgetHashes,
+  let forgetResult = null;
+  const followUpForgetResults = [];
+  if (instanceForgetHashes.length > 0) {
+    const instanceStage = await executeForgetStage({
+      sender: args.sender,
+      hashes: instanceForgetHashes,
+      reason: forgetReason,
+      signer: args.signer,
+      hasher: args.hasher,
       fetch: args.fetch,
-      apiHost: args.apiHost
+      channel: args.channel,
+      apiHost: args.apiHost,
+      now: args.now
     });
-    forgottenHashes = initiallyOutstanding.forgottenHashes;
-    outstandingForgetHashes = initiallyOutstanding.outstandingForgetHashes;
-    forgetStatuses = initiallyOutstanding.statuses;
-    if (outstandingForgetHashes.length > 0) {
-      forgetResult = await forgetAlephMessages({
+    forgetStageResults.push({ stage: "instances", ...instanceStage });
+    forgottenHashes.push(...instanceStage.forgottenHashes);
+    outstandingForgetHashes.push(...instanceStage.outstandingForgetHashes);
+    forgetStatuses = { ...forgetStatuses, ...instanceStage.statuses };
+    if (!forgetResult && instanceStage.forgetResult) {
+      forgetResult = instanceStage.forgetResult;
+    }
+    followUpForgetResults.push(...instanceStage.followUpForgetResults);
+  }
+  if (dependentForgetHashes.length > 0) {
+    if (outstandingForgetHashes.length === 0) {
+      const dependentStage = await executeForgetStage({
         sender: args.sender,
-        hashes: outstandingForgetHashes,
-        reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
+        hashes: dependentForgetHashes,
+        reason: forgetReason,
         signer: args.signer,
         hasher: args.hasher,
         fetch: args.fetch,
@@ -1045,40 +1150,38 @@ async function retainSuccessfulDeployments(args) {
         apiHost: args.apiHost,
         now: args.now
       });
-      let postBatch = await classifyForgetHashes({
-        hashes: forgetHashes,
+      forgetStageResults.push({ stage: "dependents", ...dependentStage });
+      forgottenHashes.push(...dependentStage.forgottenHashes);
+      outstandingForgetHashes.push(...dependentStage.outstandingForgetHashes);
+      forgetStatuses = { ...forgetStatuses, ...dependentStage.statuses };
+      if (!forgetResult && dependentStage.forgetResult) {
+        forgetResult = dependentStage.forgetResult;
+      }
+      followUpForgetResults.push(...dependentStage.followUpForgetResults);
+    } else {
+      const dependentStageStatus = await classifyForgetHashes({
+        hashes: dependentForgetHashes,
         fetch: args.fetch,
         apiHost: args.apiHost
       });
-      forgottenHashes = postBatch.forgottenHashes;
-      outstandingForgetHashes = postBatch.outstandingForgetHashes;
-      forgetStatuses = postBatch.statuses;
-      if (outstandingForgetHashes.length > 0) {
-        for (const hash of outstandingForgetHashes) {
-          const result = await forgetAlephMessages({
-            sender: args.sender,
-            hashes: [hash],
-            reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
-            signer: args.signer,
-            hasher: args.hasher,
-            fetch: args.fetch,
-            channel: args.channel,
-            apiHost: args.apiHost,
-            now: args.now
-          });
-          followUpForgetResults.push({ hash, result });
-        }
-        postBatch = await classifyForgetHashes({
-          hashes: forgetHashes,
-          fetch: args.fetch,
-          apiHost: args.apiHost
-        });
-        forgottenHashes = postBatch.forgottenHashes;
-        outstandingForgetHashes = postBatch.outstandingForgetHashes;
-        forgetStatuses = postBatch.statuses;
-      }
+      forgetStageResults.push({
+        stage: "dependents",
+        hashes: dependentForgetHashes,
+        skipped: true,
+        skippedReason: "Waiting for instance forget stage to complete before pruning dependent store items.",
+        forgottenHashes: dependentStageStatus.forgottenHashes,
+        outstandingForgetHashes: dependentStageStatus.outstandingForgetHashes,
+        statuses: dependentStageStatus.statuses,
+        forgetResult: null,
+        followUpForgetResults: []
+      });
+      forgottenHashes.push(...dependentStageStatus.forgottenHashes);
+      outstandingForgetHashes.push(...dependentStageStatus.outstandingForgetHashes);
+      forgetStatuses = { ...forgetStatuses, ...dependentStageStatus.statuses };
     }
   }
+  forgottenHashes = uniqueHashes(forgottenHashes);
+  outstandingForgetHashes = uniqueHashes(outstandingForgetHashes);
   return {
     sender: args.sender,
     aggregateKey,
@@ -1091,7 +1194,8 @@ async function retainSuccessfulDeployments(args) {
     outstandingForgetHashes,
     forgetStatuses,
     forgetResult,
-    followUpForgetResults
+    followUpForgetResults,
+    forgetStageResults
   };
 }
 
@@ -2905,6 +3009,7 @@ if (import.meta.url === pathToFileURL2(process.argv[1] ?? "").href) {
 // src/site-runner.ts
 import process2 from "process";
 import { spawn as spawn2 } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
 async function runCapture(command, args, options = {}) {
   return await new Promise((resolve, reject) => {
     const child = spawn2(command, args, {
@@ -2957,6 +3062,9 @@ async function waitForAlephMessage(itemHash, env = process2.env) {
   }
   throw new Error(`Aleph STORE message ${itemHash} did not become processed in time.`);
 }
+function defaultSitePublishScriptPath() {
+  return fileURLToPath2(new URL("../reference/publish-static-site.py", import.meta.url));
+}
 function mergedAddrs(env = process2.env) {
   const combined = [];
   for (const key of ["PROBE_MULTIADDRS_JSON", "BROWSER_BOOTSTRAP_MULTIADDRS_JSON"]) {
@@ -2972,7 +3080,7 @@ function mergedAddrs(env = process2.env) {
 }
 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 publishScript = optionalEnv("ALEPH_SITE_PUBLISH_SCRIPT", defaultSitePublishScriptPath(), env);
   const siteDirectory = requiredEnv("ALEPH_SITE_DIRECTORY", env);
   const pythonBin = optionalEnv("ALEPH_SITE_PYTHON", "python3", env);
   const alephBin = optionalEnv("ALEPH_SITE_ALEPH_BIN", "aleph", env);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/node",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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.16",
-    "@le-space/shared-types": "0.1.16",
-    "@le-space/rootfs": "0.1.16",
+    "@le-space/core": "0.1.18",
+    "@le-space/shared-types": "0.1.18",
+    "@le-space/rootfs": "0.1.18",
     "ethers": "^6.15.0"
   }
 }

package/reference/publish-static-site.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+import json
+import sys
+from pathlib import Path
+
+import requests
+from cid import make_cid
+
+
+def upload_directory(folder: Path, gateway: str) -> dict[str, str]:
+    url = f"{gateway.rstrip('/')}/api/v0/add"
+    params = {
+        "recursive": "true",
+        "wrap-with-directory": "true",
+    }
+
+    handles = []
+    files = []
+    try:
+        for path in sorted(folder.rglob("*")):
+            if not path.is_file():
+                continue
+            relative_path = path.relative_to(folder)
+            handle = path.open("rb")
+            handles.append(handle)
+            files.append(("file", (str(relative_path), handle)))
+
+        if not files:
+            raise RuntimeError(f"No files found under {folder}")
+
+        response = requests.post(url, params=params, files=files, timeout=300)
+        response.raise_for_status()
+
+        cid_v0 = None
+        for line in response.text.strip().splitlines():
+            entry = json.loads(line)
+            cid_v0 = entry.get("Hash") or cid_v0
+
+        if not cid_v0:
+            raise RuntimeError("CID not found in IPFS response")
+
+        cid_v1 = make_cid(cid_v0).to_v1().encode("base32").decode()
+        return {"cid_v0": cid_v0, "cid_v1": cid_v1}
+    finally:
+        for handle in handles:
+            handle.close()
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print("usage: publish-static-site.py <directory>", file=sys.stderr)
+        return 2
+
+    directory = Path(sys.argv[1]).resolve()
+    if not directory.is_dir():
+        print(f"Error: path must be a directory: {directory}", file=sys.stderr)
+        return 1
+
+    result = upload_directory(directory, "https://ipfs-2.aleph.im")
+    print(json.dumps(result))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())