@camstack/agent 1.0.8 → 1.1.1

package/dist/cli.js

@@ -24,7 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
+var import_node_fs = require("fs");
+var import_node_module = require("module");
 var os3 = __toESM(require("os"));
+var path7 = __toESM(require("path"));
 
 // src/agent-bootstrap.ts
 var fs6 = __toESM(require("fs"));
@@ -369,6 +372,37 @@ async function applyDeployedBundle(input) {
   return { addonDir: liveDir };
 }
 
+// src/fetch-bundle-from-hub.ts
+var import_node_crypto2 = require("crypto");
+var import_undici = require("undici");
+async function fetchBundleFromHub(opts) {
+  const authHeader = { Authorization: `Bearer ${opts.token}`, "accept-encoding": "identity" };
+  const res = opts.fetchImpl ? await opts.fetchImpl(opts.url, { headers: authHeader }) : await (0, import_undici.fetch)(opts.url, {
+    headers: authHeader,
+    dispatcher: new import_undici.Agent({ connect: { rejectUnauthorized: false } })
+  });
+  if (!res.ok) {
+    throw new Error(`bundle fetch failed: HTTP ${res.status}`);
+  }
+  const buffer = Buffer.from(await res.arrayBuffer());
+  if (buffer.length !== opts.bytes) {
+    throw new Error(`bundle bytes mismatch: expected ${opts.bytes}, got ${buffer.length}`);
+  }
+  const sha = (0, import_node_crypto2.createHash)("sha256").update(buffer).digest("hex");
+  if (sha !== opts.sha256) {
+    throw new Error(`bundle sha256 mismatch: expected ${opts.sha256}, got ${sha}`);
+  }
+  return buffer;
+}
+
+// src/apply-model-distribution.ts
+async function applyModelDistribution(seam, params) {
+  seam.mkdirp(seam.modelsDir);
+  const buffer = await seam.fetchBundle(params.source);
+  await seam.extract(buffer, seam.modelsDir);
+  return { success: true, modelId: params.modelId, format: params.format, path: seam.modelsDir };
+}
+
 // src/agent-service.ts
 var deploySwapLogger = {
   info: (msg) => console.log(`[Agent] ${msg}`),
@@ -392,8 +426,8 @@ function getLocalIps() {
 }
 async function withTimeout(p, ms, fallback) {
   let timer;
-  const timeout = new Promise((resolve5) => {
-    timer = setTimeout(() => resolve5(fallback), ms);
+  const timeout = new Promise((resolve6) => {
+    timer = setTimeout(() => resolve6(fallback), ms);
   });
   try {
     return await Promise.race([p, timeout]);
@@ -402,6 +436,28 @@ async function withTimeout(p, ms, fallback) {
   }
 }
 var METRICS_SNAPSHOT_TIMEOUT_MS = 2e3;
+function resolveDeployAction(seam) {
+  return async (params) => {
+    const { addonId, source, bundle } = params;
+    if (source && (0, import_system.isAddonDeploySource)(source)) {
+      if (source.kind === "npm") {
+        await seam.installFromNpm(addonId, source.version);
+        return { success: true, addonId };
+      }
+      const buf2 = await seam.fetchBundle(source);
+      const { addonDir: addonDir2 } = await seam.applyBundle(buf2);
+      seam.onApplied(addonDir2);
+      return { success: true, addonId, path: addonDir2 };
+    }
+    if (bundle === void 0) {
+      throw new Error("$agent.deploy: no source descriptor and no legacy bundle provided");
+    }
+    const buf = typeof bundle === "string" ? Buffer.from(bundle, "base64") : bundle;
+    const { addonDir } = await seam.applyBundle(buf);
+    seam.onApplied(addonDir);
+    return { success: true, addonId, path: addonDir };
+  };
+}
 function readHubAddressFromConfig(configPath) {
   if (!configPath) return null;
   try {
@@ -574,8 +630,7 @@ function createAgentService(deps) {
       deploy: {
         handler: async (ctx) => {
           const { params } = ctx;
-          const { addonId, bundle } = params;
-          const bufferData = typeof bundle === "string" ? Buffer.from(bundle, "base64") : bundle;
+          const { addonId, source, bundle } = params;
           const { execFile } = await import("child_process");
           const { promisify } = await import("util");
           const execFileAsync = promisify(execFile);
@@ -593,17 +648,74 @@ function createAgentService(deps) {
               }
             }
           };
-          const { addonDir } = await applyDeployedBundle({
-            addonsDir: deps.addonsDir,
-            addonId,
-            bundle: bufferData,
-            extract,
-            logger: deploySwapLogger
-          });
-          for (const declId of readDeployedAddonIds(addonDir)) {
-            deps.loadedAddons.delete(declId);
-          }
-          return { success: true, addonId, path: addonDir };
+          const seam = {
+            installFromNpm: (pkg, v) => {
+              if (!deps.installFromNpm) {
+                throw new Error("npm deploy source unsupported on this agent");
+              }
+              return deps.installFromNpm(pkg, v);
+            },
+            applyBundle: (buf) => applyDeployedBundle({
+              addonsDir: deps.addonsDir,
+              addonId,
+              bundle: buf,
+              extract,
+              logger: deploySwapLogger
+            }),
+            fetchBundle: (s) => fetchBundleFromHub(s),
+            // Evict every addon DECLARATION id this package contributes
+            // from `loadedAddons` so the follow-up `$agent.reload` actually
+            // re-instantiates it. `loadDeployedAddons` skips any addon
+            // still present in `loadedAddons`; without this eviction a
+            // redeploy would leave the agent pinned to the pre-update
+            // version. The `deploy` param `addonId` is the PACKAGE name
+            // (used only as the on-disk dir), whereas `loadedAddons` is
+            // keyed by the addon DECLARATION id — they differ for scoped
+            // packages, so we read the extracted manifest to bridge them.
+            onApplied: (addonDir) => {
+              for (const declId of readDeployedAddonIds(addonDir)) {
+                deps.loadedAddons.delete(declId);
+              }
+            }
+          };
+          return resolveDeployAction(seam)({ addonId, source, bundle });
+        }
+      },
+      /**
+       * Pull a staged model tarball from the hub and untar it into this node's
+       * `<dataDir>/models` (Model Studio P2). Reuses the agent-pull machinery:
+       * `fetchBundleFromHub` verifies bytes + sha256 before extraction. The
+       * existing `isModelDownloaded` then reports the model present, so the
+       * detection-pipeline can load it locally.
+       */
+      distributeModel: {
+        handler: async (ctx) => {
+          const { params } = ctx;
+          const { execFile } = await import("child_process");
+          const { promisify } = await import("util");
+          const execFileAsync = promisify(execFile);
+          const modelsDir = path4.join(deps.dataDir, "models");
+          const seam = {
+            modelsDir,
+            fetchBundle: (s) => fetchBundleFromHub(s),
+            extract: async (tgz, destDir) => {
+              const tmp = path4.join(
+                destDir,
+                `.dist-${Date.now()}-${Math.random().toString(36).slice(2)}.tgz`
+              );
+              fs4.writeFileSync(tmp, tgz);
+              try {
+                await execFileAsync("tar", ["-xzf", tmp, "-C", destDir], { timeout: 6e4 });
+              } finally {
+                try {
+                  fs4.unlinkSync(tmp);
+                } catch {
+                }
+              }
+            },
+            mkdirp: (dir) => fs4.mkdirSync(dir, { recursive: true })
+          };
+          return applyModelDistribution(seam, params);
         }
       },
       /**
@@ -1070,7 +1182,10 @@ async function startAgent(configPath) {
       subtree.registerNode(params);
       triggerUpwardRegistration();
     },
-    expectedClusterSecretHash: config.secret ? (0, import_system3.hashClusterSecret)(config.secret) : void 0
+    expectedClusterSecretHash: config.secret ? (0, import_system3.hashClusterSecret)(config.secret) : void 0,
+    installFromNpm: async (pkg, version) => {
+      await installer.install(pkg, version);
+    }
   });
   broker.createService(agentServiceSchema);
   const agentTcpPort = (0, import_system3.deriveAgentListenPort)(broker.nodeID);
@@ -1649,6 +1764,28 @@ if (args.secret && !process.env["CAMSTACK_CLUSTER_SECRET"]) {
 if (args.statusPort && !process.env["CAMSTACK_STATUS_PORT"]) {
   process.env["CAMSTACK_STATUS_PORT"] = args.statusPort;
 }
+if (!process.env["CAMSTACK_FRAMEWORK_DIR"]) {
+  const scriptPath = process.argv[1];
+  if (scriptPath) {
+    const frameworkDir = path7.resolve(path7.dirname(scriptPath), "..", "..");
+    const frameworkModules = path7.join(frameworkDir, "node_modules");
+    if ((0, import_node_fs.existsSync)(path7.join(frameworkModules, "@camstack", "shm-ring"))) {
+      process.env["CAMSTACK_FRAMEWORK_DIR"] = frameworkDir;
+      const existingNodePath = process.env["NODE_PATH"];
+      process.env["NODE_PATH"] = existingNodePath ? `${frameworkModules}${path7.delimiter}${existingNodePath}` : frameworkModules;
+      import_node_module.Module._initPaths();
+      console.log(
+        `[Agent] Self-contained framework detected \u2014 CAMSTACK_FRAMEWORK_DIR=${frameworkDir}`
+      );
+      if (!process.env["CAMSTACK_BUNDLED_ADDONS_DIR"]) {
+        const bundledAddons = path7.join(frameworkDir, "addons");
+        if ((0, import_node_fs.existsSync)(bundledAddons)) {
+          process.env["CAMSTACK_BUNDLED_ADDONS_DIR"] = bundledAddons;
+        }
+      }
+    }
+  }
+}
 if (!process.env["CAMSTACK_NODE_ID"]) {
   process.env["CAMSTACK_NODE_ID"] = os3.hostname();
 }