@celilo/cli 5.1.0 → 5.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {

package/src/services/module-validator/bundled-deps.test.ts

@@ -1,4 +1,7 @@
 import { describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { findStaleBundledDeps, refreshAndVerifyBundledDeps } from './bundled-deps';
 
 describe('findStaleBundledDeps (ISS-0104)', () => {
@@ -52,4 +55,45 @@ describe('refreshAndVerifyBundledDeps (ISS-0104)', () => {
     expect(result).toEqual({ refreshed: false, mismatches: [] });
     expect(installs).toBe(0);
   });
+
+  // celilo#1447: the release run's sweep installs seconds after the same run
+  // published the packages it resolves, so bun's cached packument 404s them.
+  describe('just-published dep (celilo#1447)', () => {
+    function moduleWithScripts(): string {
+      const dir = mkdtempSync(join(tmpdir(), 'bundled-deps-'));
+      mkdirSync(join(dir, 'scripts'), { recursive: true });
+      writeFileSync(join(dir, 'scripts', 'package.json'), '{"name":"m"}');
+      return dir;
+    }
+
+    test('retries with --no-cache when the first install cannot resolve it', () => {
+      const cmds: string[] = [];
+      const slept: number[] = [];
+      refreshAndVerifyBundledDeps(
+        moduleWithScripts(),
+        (cmd) => {
+          cmds.push(cmd);
+          if (cmds.length === 1) throw new Error('failed to resolve (but package exists)');
+        },
+        (ms) => void slept.push(ms),
+      );
+      expect(cmds).toEqual(['bun install', 'bun install --no-cache']);
+      expect(slept).toEqual([2_000]);
+    });
+
+    test('rethrows once the retries are exhausted', () => {
+      const cmds: string[] = [];
+      expect(() =>
+        refreshAndVerifyBundledDeps(
+          moduleWithScripts(),
+          (cmd) => {
+            cmds.push(cmd);
+            throw new Error('still unresolvable');
+          },
+          () => {},
+        ),
+      ).toThrow('still unresolvable');
+      expect(cmds).toHaveLength(3);
+    });
+  });
 });

package/src/services/module-validator/bundled-deps.ts

@@ -65,6 +65,44 @@ function findWorkspaceRoot(start: string): string | undefined {
   return undefined;
 }
 
+/**
+ * celilo#1447: in a release run this install happens SECONDS after the same
+ * run published the workspace packages it must resolve. bun has already cached
+ * the pre-publish packument (the workspace install at the top of the job), so
+ * it fails with "@celilo/capabilities@^6.1.0 failed to resolve ... but package
+ * exists" — and the whole module sweep aborts AFTER npm and the CLI shipped,
+ * which is exactly the half-shipped release #1369 reordered the steps to
+ * prevent. `--no-cache` re-reads the registry; the backoff covers the case
+ * where npm's own metadata has not propagated yet.
+ *
+ * ponytail: fixed 3 attempts, no jitter. If propagation ever needs longer,
+ * raise RETRY_DELAYS_MS rather than adding a scheduler.
+ */
+const RETRY_DELAYS_MS = [2_000, 8_000];
+
+function installWithRetry(
+  run: (cmd: string, cwd: string) => void,
+  sleep: (ms: number) => void,
+  scriptsDir: string,
+): void {
+  try {
+    run('bun install', scriptsDir);
+    return;
+  } catch (err) {
+    let lastErr = err;
+    for (const delay of RETRY_DELAYS_MS) {
+      sleep(delay);
+      try {
+        run('bun install --no-cache', scriptsDir);
+        return;
+      } catch (retryErr) {
+        lastErr = retryErr;
+      }
+    }
+    throw lastErr;
+  }
+}
+
 export interface RefreshResult {
   /** Whether the module had a scripts/ package to refresh. */
   refreshed: boolean;
@@ -84,6 +122,7 @@ export function refreshAndVerifyBundledDeps(
   moduleDir: string,
   run: (cmd: string, cwd: string) => void = (cmd, cwd) =>
     void execSync(cmd, { cwd, stdio: 'pipe' }),
+  sleep: (ms: number) => void = (ms) => Bun.sleepSync(ms),
 ): RefreshResult {
   const scriptsDir = join(moduleDir, 'scripts');
   if (!existsSync(join(scriptsDir, 'package.json'))) {
@@ -92,7 +131,7 @@ export function refreshAndVerifyBundledDeps(
 
   // Reconcile node_modules with the lockfile + package.json pins so the pack
   // bundles a CURRENT closure, not whatever the operator last installed.
-  run('bun install', scriptsDir);
+  installWithRetry(run, sleep, scriptsDir);
 
   const workspaceRoot = findWorkspaceRoot(moduleDir);
   if (!workspaceRoot) {