@camstack/agent 1.1.42 → 1.1.44

package/dist/index.mjs

@@ -5,8 +5,8 @@ import {
   loadAgentConfig,
   startAgent,
   startAgentHttpServer
-} from "./chunk-MMKRM4RT.mjs";
-import "./chunk-L34OOQI3.mjs";
+} from "./chunk-Z7VZQCFX.mjs";
+import "./chunk-Y6BUFOWG.mjs";
 export {
   createAgentHttpServer,
   createAgentService,

package/dist/starter.js

@@ -59,6 +59,9 @@ var require_dist = __commonJS({
     var src_exports = {};
     __export(src_exports, {
       AGENT_ROOT_SPEC: () => AGENT_ROOT_SPEC2,
+      DEV_UPLOADS_DIRNAME: () => DEV_UPLOADS_DIRNAME,
+      DEV_UPLOADS_KEEP_COUNT: () => DEV_UPLOADS_KEEP_COUNT,
+      DEV_UPLOAD_MANIFEST_FILE: () => DEV_UPLOAD_MANIFEST_FILE,
       HOST_EXTERNAL_SPECIFIERS: () => HOST_EXTERNAL_SPECIFIERS,
       HUB_ROOT_SPEC: () => HUB_ROOT_SPEC,
       RESTART_INTENT_FILE: () => RESTART_INTENT_FILE,
@@ -68,11 +71,17 @@ var require_dist = __commonJS({
       clearRestartIntentMarker: () => clearRestartIntentMarker,
       compareSemver: () => compareSemver,
       detectWorkspaceRoot: () => detectWorkspaceRoot,
+      devChannelEpoch: () => devChannelEpoch,
+      devUploadManifestPath: () => devUploadManifestPath,
+      devUploadVersionDir: () => devUploadVersionDir,
+      devUploadsDir: () => devUploadsDir,
       emptyServerRootState: () => emptyServerRootState,
+      isDevChannelVersion: () => isDevChannelVersion,
       isHostExternal: () => isHostExternal,
       isServerRootState: () => isServerRootState,
       minNodeMajorOf: () => minNodeMajorOf,
       planBoot: () => planBoot,
+      readDevUploadManifest: () => readDevUploadManifest,
       readRestartIntentMarker: () => readRestartIntentMarker,
       readServerRootState: () => readServerRootState,
       registerActiveRootResolver: () => registerActiveRootResolver,
@@ -85,10 +94,58 @@ var require_dist = __commonJS({
       validateVersionDir: () => validateVersionDir,
       versionDir: () => versionDir,
       versionsDir: () => versionsDir,
+      writeDevUploadManifest: () => writeDevUploadManifest,
       writeRestartIntentMarker: () => writeRestartIntentMarker,
       writeServerRootState: () => writeServerRootState
     });
     module2.exports = __toCommonJS(src_exports);
+    var fs = __toESM2(require("fs"));
+    var path2 = __toESM2(require("path"));
+    var DEV_UPLOADS_DIRNAME = "dev-uploads";
+    var DEV_UPLOAD_MANIFEST_FILE = "manifest.json";
+    var DEV_UPLOADS_KEEP_COUNT = 3;
+    var DEV_CHANNEL_VERSION_RE = /-dev\.\d+$/;
+    function isDevChannelVersion(version) {
+      return DEV_CHANNEL_VERSION_RE.test(version);
+    }
+    function devChannelEpoch(version) {
+      const match = /-dev\.(\d+)$/.exec(version);
+      if (match === null) return null;
+      const epoch = Number.parseInt(match[1] ?? "", 10);
+      return Number.isNaN(epoch) ? null : epoch;
+    }
+    function devUploadsDir(rootDir) {
+      return path2.join(rootDir, DEV_UPLOADS_DIRNAME);
+    }
+    function devUploadVersionDir(rootDir, version) {
+      return path2.join(devUploadsDir(rootDir), version);
+    }
+    function devUploadManifestPath(versionDirPath) {
+      return path2.join(versionDirPath, DEV_UPLOAD_MANIFEST_FILE);
+    }
+    function isDevUploadManifest(v) {
+      if (typeof v !== "object" || v === null) return false;
+      const m = v;
+      if (typeof m["version"] !== "string") return false;
+      const packages = m["packages"];
+      if (typeof packages !== "object" || packages === null || Array.isArray(packages)) return false;
+      return Object.values(packages).every((filename) => typeof filename === "string");
+    }
+    function readDevUploadManifest(versionDirPath) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(devUploadManifestPath(versionDirPath), "utf-8"));
+        return isDevUploadManifest(raw) ? raw : null;
+      } catch {
+        return null;
+      }
+    }
+    function writeDevUploadManifest(versionDirPath, manifest) {
+      fs.mkdirSync(versionDirPath, { recursive: true });
+      const target = devUploadManifestPath(versionDirPath);
+      const tmp = `${target}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(manifest, null, 2), "utf-8");
+      fs.renameSync(tmp, target);
+    }
     var HUB_ROOT_SPEC = {
       packageName: "@camstack/server",
       entryRelPath: ["dist", "launcher.js"]
@@ -97,8 +154,8 @@ var require_dist = __commonJS({
       packageName: "@camstack/agent",
       entryRelPath: ["dist", "cli.js"]
     };
-    var fs = __toESM2(require("fs"));
-    var path2 = __toESM2(require("path"));
+    var fs2 = __toESM2(require("fs"));
+    var path22 = __toESM2(require("path"));
     var SERVER_ROOT_DIRNAME = "server-root";
     var SERVER_ROOT_STATE_FILE = "state.json";
     var RESTART_INTENT_FILE = ".restart-intent";
@@ -112,22 +169,22 @@ var require_dist = __commonJS({
       };
     }
     function serverRootDir(dataDir) {
-      return path2.join(dataDir, SERVER_ROOT_DIRNAME);
+      return path22.join(dataDir, SERVER_ROOT_DIRNAME);
     }
     function versionsDir(rootDir) {
-      return path2.join(rootDir, "versions");
+      return path22.join(rootDir, "versions");
     }
     function versionDir(rootDir, version) {
-      return path2.join(versionsDir(rootDir), version);
+      return path22.join(versionsDir(rootDir), version);
     }
     function rootPackageDir(versionDirPath, spec) {
-      return path2.join(versionDirPath, "node_modules", ...spec.packageName.split("/"));
+      return path22.join(versionDirPath, "node_modules", ...spec.packageName.split("/"));
     }
     function rootEntryPath(versionDirPath, spec) {
-      return path2.join(rootPackageDir(versionDirPath, spec), ...spec.entryRelPath);
+      return path22.join(rootPackageDir(versionDirPath, spec), ...spec.entryRelPath);
     }
     function stateFilePath(rootDir) {
-      return path2.join(rootDir, SERVER_ROOT_STATE_FILE);
+      return path22.join(rootDir, SERVER_ROOT_STATE_FILE);
     }
     function isNullableString(v) {
       return v === null || typeof v === "string";
@@ -154,21 +211,21 @@ var require_dist = __commonJS({
     }
     function readServerRootState(rootDir) {
       try {
-        const raw = JSON.parse(fs.readFileSync(stateFilePath(rootDir), "utf-8"));
+        const raw = JSON.parse(fs2.readFileSync(stateFilePath(rootDir), "utf-8"));
         return isServerRootState(raw) ? raw : null;
       } catch {
         return null;
       }
     }
     function writeServerRootState(rootDir, state) {
-      fs.mkdirSync(rootDir, { recursive: true });
+      fs2.mkdirSync(rootDir, { recursive: true });
       const target = stateFilePath(rootDir);
       const tmp = `${target}.tmp`;
-      fs.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
-      fs.renameSync(tmp, target);
+      fs2.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+      fs2.renameSync(tmp, target);
     }
     function restartIntentMarkerPath(rootDir) {
-      return path2.join(rootDir, RESTART_INTENT_FILE);
+      return path22.join(rootDir, RESTART_INTENT_FILE);
     }
     function isRestartIntentMarker(v) {
       if (typeof v !== "object" || v === null) return false;
@@ -176,15 +233,15 @@ var require_dist = __commonJS({
       return typeof m["requestedAtMs"] === "number" && typeof m["reason"] === "string";
     }
     function writeRestartIntentMarker(rootDir, marker) {
-      fs.mkdirSync(rootDir, { recursive: true });
+      fs2.mkdirSync(rootDir, { recursive: true });
       const target = restartIntentMarkerPath(rootDir);
       const tmp = `${target}.tmp`;
-      fs.writeFileSync(tmp, JSON.stringify(marker, null, 2), "utf-8");
-      fs.renameSync(tmp, target);
+      fs2.writeFileSync(tmp, JSON.stringify(marker, null, 2), "utf-8");
+      fs2.renameSync(tmp, target);
     }
     function readRestartIntentMarker(rootDir) {
       try {
-        const raw = JSON.parse(fs.readFileSync(restartIntentMarkerPath(rootDir), "utf-8"));
+        const raw = JSON.parse(fs2.readFileSync(restartIntentMarkerPath(rootDir), "utf-8"));
         return isRestartIntentMarker(raw) ? raw : null;
       } catch {
         return null;
@@ -192,7 +249,7 @@ var require_dist = __commonJS({
     }
     function clearRestartIntentMarker(rootDir) {
       try {
-        fs.rmSync(restartIntentMarkerPath(rootDir), { force: true });
+        fs2.rmSync(restartIntentMarkerPath(rootDir), { force: true });
       } catch {
       }
     }
@@ -205,13 +262,13 @@ var require_dist = __commonJS({
     function validateVersionDir(rootDir, version, nodeMajor, spec) {
       const vDir = versionDir(rootDir, version);
       const entry = rootEntryPath(vDir, spec);
-      if (!fs.existsSync(entry)) {
+      if (!fs2.existsSync(entry)) {
         return `root entry missing: ${entry}`;
       }
-      const pkgJsonPath = path2.join(rootPackageDir(vDir, spec), "package.json");
+      const pkgJsonPath = path22.join(rootPackageDir(vDir, spec), "package.json");
       let pkg;
       try {
-        const raw = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+        const raw = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
         if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
           return `package.json malformed: ${pkgJsonPath}`;
         }
@@ -358,25 +415,25 @@ var require_dist = __commonJS({
       if (pa.prerelease > pb.prerelease) return 1;
       return 0;
     }
-    var fs2 = __toESM2(require("fs"));
-    var path22 = __toESM2(require("path"));
+    var fs3 = __toESM2(require("fs"));
+    var path3 = __toESM2(require("path"));
     function detectWorkspaceRoot(fromDir) {
-      let dir = path22.resolve(fromDir);
+      let dir = path3.resolve(fromDir);
       for (; ; ) {
-        const pkgPath = path22.join(dir, "package.json");
+        const pkgPath = path3.join(dir, "package.json");
         try {
-          const raw = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+          const raw = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
           if (typeof raw === "object" && raw !== null && raw["workspaces"] !== void 0) {
             return dir;
           }
         } catch {
         }
-        const parent = path22.dirname(dir);
+        const parent = path3.dirname(dir);
         if (parent === dir) return null;
         dir = parent;
       }
     }
-    var path3 = __toESM2(require("path"));
+    var path4 = __toESM2(require("path"));
     var import_node_url = require("url");
     var HOST_EXTERNAL_SPECIFIERS = [
       "@camstack/system",
@@ -404,7 +461,7 @@ var require_dist = __commonJS({
         return;
       }
       const anchorURL = (0, import_node_url.pathToFileURL)(
-        path3.join(activeRootDir, "node_modules", "__camstack_starter_anchor__.js")
+        path4.join(activeRootDir, "node_modules", "__camstack_starter_anchor__.js")
       ).href;
       const hooks = {
         resolve: (specifier, context, nextResolve) => {
@@ -482,8 +539,8 @@ var require_dist = __commonJS({
       options.loadEntry(options.seedEntry);
     }
     var import_node_child_process = require("child_process");
-    var fs3 = __toESM2(require("fs"));
-    var path4 = __toESM2(require("path"));
+    var fs4 = __toESM2(require("fs"));
+    var path5 = __toESM2(require("path"));
     var import_node_util = require("util");
     var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
     function buildNpmRegistryArgs(registry) {
@@ -495,7 +552,7 @@ var require_dist = __commonJS({
     var RESTART_REASON_PREFIX = "server-update";
     function readPackageVersion(pkgJsonPath) {
       try {
-        const raw = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+        const raw = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
         if (typeof raw === "object" && raw !== null) {
           const version = raw["version"];
           if (typeof version === "string") return version;
@@ -522,7 +579,7 @@ var require_dist = __commonJS({
         this.envNames = options.envNames;
         this.logger = options.logger;
         this.restartServerFn = options.restartServer;
-        this.dataDir = path4.resolve(options.dataDir);
+        this.dataDir = path5.resolve(options.dataDir);
         this.execNpm = options.execNpm ?? (async (args, opts) => {
           const { stdout } = await execFileAsync("npm", [...args], {
             cwd: opts.cwd,
@@ -551,7 +608,7 @@ var require_dist = __commonJS({
       seedVersion() {
         const seedDir = this.env[this.envNames.seedDir];
         if (seedDir === void 0 || seedDir.length === 0) return null;
-        return readPackageVersion(path4.join(seedDir, "package.json"));
+        return readPackageVersion(path5.join(seedDir, "package.json"));
       }
       rootDir() {
         return serverRootDir(this.dataDir);
@@ -569,7 +626,7 @@ var require_dist = __commonJS({
         const rootDir = this.rootDir();
         const raw = readServerRootState(rootDir);
         if (raw !== null) return { state: raw, corrupt: false };
-        return { state: emptyServerRootState(), corrupt: fs3.existsSync(stateFilePath(rootDir)) };
+        return { state: emptyServerRootState(), corrupt: fs4.existsSync(stateFilePath(rootDir)) };
       }
       updateState(state) {
         if (this.inFlight === "checking") return "checking";
@@ -709,6 +766,17 @@ var require_dist = __commonJS({
             message: `Refused: ${this.spec.packageName}@${target} is already running.`
           };
         }
+        if (isDevChannelVersion(target)) {
+          const uploadsDir = devUploadVersionDir(this.rootDir(), target);
+          if (!fs4.existsSync(uploadsDir)) {
+            return {
+              accepted: false,
+              targetVersion: target,
+              restarting: false,
+              message: `Refused: dev-channel version ${target} has no uploaded tarballs on this node (${uploadsDir} is missing). Dev server deploys are hub-only in this phase \u2014 upload via \`camstack deploy-server\` against this node first.`
+            };
+          }
+        }
         this.inFlight = "staging";
         try {
           await this.stageAndActivate(target);
@@ -755,34 +823,40 @@ var require_dist = __commonJS({
       async stageAndActivate(target) {
         const rootDir = this.rootDir();
         const vDir = versionsDir(rootDir);
-        fs3.mkdirSync(vDir, { recursive: true });
-        const stagingDir = path4.join(vDir, `.staging-${target}-${process.pid}-${this.now()}`);
-        fs3.mkdirSync(stagingDir, { recursive: true });
+        fs4.mkdirSync(vDir, { recursive: true });
+        const stagingDir = path5.join(vDir, `.staging-${target}-${process.pid}-${this.now()}`);
+        fs4.mkdirSync(stagingDir, { recursive: true });
         try {
-          fs3.writeFileSync(
-            path4.join(stagingDir, "package.json"),
-            JSON.stringify({ name: "camstack-node-root", private: true }, null, 2),
-            "utf-8"
-          );
+          const devDir = devUploadVersionDir(rootDir, target);
           const registry = this.env["CAMSTACK_NPM_REGISTRY"];
-          await this.execNpm(
-            [
-              "install",
-              "--omit=dev",
-              "--no-audit",
-              "--no-fund",
-              "--loglevel=error",
-              `${this.spec.packageName}@${target}`,
-              ...buildNpmRegistryArgs(registry)
-            ],
-            { cwd: stagingDir, timeoutMs: NPM_INSTALL_TIMEOUT_MS }
-          );
+          const installArgs = ["install", "--omit=dev", "--no-audit", "--no-fund", "--loglevel=error"];
+          if (fs4.existsSync(devDir)) {
+            fs4.writeFileSync(
+              path5.join(stagingDir, "package.json"),
+              JSON.stringify(this.buildDevUploadsPackageJson(devDir, target), null, 2),
+              "utf-8"
+            );
+            await this.execNpm([...installArgs, ...buildNpmRegistryArgs(registry)], {
+              cwd: stagingDir,
+              timeoutMs: NPM_INSTALL_TIMEOUT_MS
+            });
+          } else {
+            fs4.writeFileSync(
+              path5.join(stagingDir, "package.json"),
+              JSON.stringify({ name: "camstack-node-root", private: true }, null, 2),
+              "utf-8"
+            );
+            await this.execNpm(
+              [...installArgs, `${this.spec.packageName}@${target}`, ...buildNpmRegistryArgs(registry)],
+              { cwd: stagingDir, timeoutMs: NPM_INSTALL_TIMEOUT_MS }
+            );
+          }
           const entry = rootEntryPath(stagingDir, this.spec);
-          if (!fs3.existsSync(entry)) {
+          if (!fs4.existsSync(entry)) {
             throw new Error(`staged closure is missing the root entry (${entry})`);
           }
           const stagedVersion = readPackageVersion(
-            path4.join(rootPackageDir(stagingDir, this.spec), "package.json")
+            path5.join(rootPackageDir(stagingDir, this.spec), "package.json")
           );
           if (stagedVersion !== target) {
             throw new Error(
@@ -790,17 +864,61 @@ var require_dist = __commonJS({
             );
           }
           const dest = versionDir(rootDir, target);
-          if (fs3.existsSync(dest)) {
+          if (fs4.existsSync(dest)) {
             const aside = `${dest}.evicted-${this.now()}`;
-            await fs3.promises.rename(dest, aside);
-            await fs3.promises.rm(aside, { recursive: true, force: true }).catch(() => void 0);
+            await fs4.promises.rename(dest, aside);
+            await fs4.promises.rm(aside, { recursive: true, force: true }).catch(() => void 0);
           }
-          await fs3.promises.rename(stagingDir, dest);
+          await fs4.promises.rename(stagingDir, dest);
         } catch (err) {
-          await fs3.promises.rm(stagingDir, { recursive: true, force: true }).catch(() => void 0);
+          await fs4.promises.rm(stagingDir, { recursive: true, force: true }).catch(() => void 0);
           throw err;
         }
       }
+      /**
+       * Synthetic staging package.json for the dev server-deploy channel:
+       * `dependencies` carries the root package as a `file:` ref to its uploaded
+       * tgz; `overrides` maps EVERY OTHER uploaded `@camstack/<name>` to its tgz
+       * so any transitive occurrence resolves to the uploaded copy, never npm.
+       * Fail-closed: a missing/invalid manifest, a manifest for a different
+       * version, a missing root package, or a listed-but-absent tgz all throw
+       * (surfaced by `applyServerUpdate` as a staging failure).
+       */
+      buildDevUploadsPackageJson(devDir, target) {
+        const manifest = readDevUploadManifest(devDir);
+        if (manifest === null) {
+          throw new Error(`dev-uploads manifest missing or invalid in ${devDir}`);
+        }
+        if (manifest.version !== target) {
+          throw new Error(
+            `dev-uploads manifest version mismatch: dir is for ${target}, manifest says ${manifest.version}`
+          );
+        }
+        const rootTgz = manifest.packages[this.spec.packageName];
+        if (rootTgz === void 0) {
+          throw new Error(
+            `dev-uploads for ${target} do not include the root package ${this.spec.packageName}`
+          );
+        }
+        const fileRef = (filename) => {
+          const abs = path5.join(devDir, filename);
+          if (!fs4.existsSync(abs)) {
+            throw new Error(`dev-uploads tarball listed in the manifest is missing: ${abs}`);
+          }
+          return `file:${abs}`;
+        };
+        const overrides = {};
+        for (const [pkgName, filename] of Object.entries(manifest.packages)) {
+          if (pkgName === this.spec.packageName) continue;
+          overrides[pkgName] = fileRef(filename);
+        }
+        return {
+          name: "camstack-node-root",
+          private: true,
+          dependencies: { [this.spec.packageName]: fileRef(rootTgz) },
+          ...Object.keys(overrides).length > 0 ? { overrides } : {}
+        };
+      }
       // ── Rollback ──────────────────────────────────────────────────────────
       async rollbackServerUpdate() {
         if (this.inFlight !== "idle") {
@@ -930,6 +1048,7 @@ var require_dist = __commonJS({
             (v) => typeof v === "string"
           )
         );
+        this.sweepDevUploads(DEV_UPLOADS_KEEP_COUNT);
         this.logger.info("root package update confirmed healthy", {
           meta: {
             version: promoted.currentVersion,
@@ -953,23 +1072,23 @@ var require_dist = __commonJS({
         const vDir = versionsDir(this.rootDir());
         let entries;
         try {
-          entries = fs3.readdirSync(vDir);
+          entries = fs4.readdirSync(vDir);
         } catch {
           return;
         }
         for (const entry of entries) {
           if (keep.includes(entry)) continue;
-          const full = path4.join(vDir, entry);
+          const full = path5.join(vDir, entry);
           if (entry.startsWith(".")) {
             try {
-              const ageMs = this.now() - fs3.statSync(full).mtimeMs;
+              const ageMs = this.now() - fs4.statSync(full).mtimeMs;
               if (ageMs < _RootUpdateService.STALE_TRANSIENT_MS) continue;
             } catch {
               continue;
             }
           }
           try {
-            fs3.rmSync(full, { recursive: true, force: true });
+            fs4.rmSync(full, { recursive: true, force: true });
             this.logger.debug("pruned server-root version dir", { meta: { entry } });
           } catch (err) {
             this.logger.warn("failed to prune server-root version dir", {
@@ -978,6 +1097,56 @@ var require_dist = __commonJS({
           }
         }
       }
+      /**
+       * Promote-time sweep of `server-root/dev-uploads/`: keep only the
+       * `keepCount` most recent entries (ordered by the self-describing
+       * `-dev.<epochSeconds>` suffix; non-dev-shaped residue counts as oldest).
+       * Uses the same rename-aside graveyard pattern as the addon installer —
+       * a rename is a metadata op that succeeds even when a tarball is held
+       * open, and residue in the graveyard is re-swept on the next promote.
+       */
+      sweepDevUploads(keepCount) {
+        const dir = devUploadsDir(this.rootDir());
+        let entries;
+        try {
+          entries = fs4.readdirSync(dir);
+        } catch {
+          return;
+        }
+        const graveyard = path5.join(dir, ".sweeping");
+        try {
+          for (const residue of fs4.readdirSync(graveyard)) {
+            try {
+              fs4.rmSync(path5.join(graveyard, residue), { recursive: true, force: true });
+            } catch {
+            }
+          }
+        } catch {
+        }
+        const versions = entries.filter((name) => !name.startsWith("."));
+        const byNewestFirst = [...versions].sort(
+          (a, b) => (devChannelEpoch(b) ?? -1) - (devChannelEpoch(a) ?? -1)
+        );
+        const doomed = byNewestFirst.slice(keepCount);
+        if (doomed.length === 0) return;
+        fs4.mkdirSync(graveyard, { recursive: true });
+        for (const entry of doomed) {
+          const aside = path5.join(graveyard, `${entry}-${this.now()}`);
+          try {
+            fs4.renameSync(path5.join(dir, entry), aside);
+          } catch (err) {
+            this.logger.warn("failed to move dev-uploads entry aside for sweep", {
+              meta: { entry, error: err instanceof Error ? err.message : String(err) }
+            });
+            continue;
+          }
+          try {
+            fs4.rmSync(aside, { recursive: true, force: true });
+            this.logger.debug("swept dev-uploads entry", { meta: { entry } });
+          } catch {
+          }
+        }
+      }
       /** Transient (.staging- / .evicted-) dirs younger than this are never pruned. */
       static STALE_TRANSIENT_MS = 24 * 60 * 60 * 1e3;
     };