@hydra-acp/cli 0.1.23 → 0.1.24

package/dist/index.d.ts

@@ -1203,10 +1203,14 @@ declare const RegistryDocument: z.ZodObject<{
     extensions?: unknown[] | undefined;
 }>;
 type RegistryDocument = z.infer<typeof RegistryDocument>;
+interface RegistryOptions {
+    onFetched?: (doc: RegistryDocument) => void | Promise<void>;
+}
 declare class Registry {
     private config;
+    private options;
     private cache;
-    constructor(config: HydraConfig);
+    constructor(config: HydraConfig, options?: RegistryOptions);
     load(): Promise<RegistryDocument>;
     refresh(): Promise<RegistryDocument>;
     getAgent(id: string): Promise<RegistryAgent | undefined>;
@@ -1219,6 +1223,7 @@ interface SpawnPlan {
     command: string;
     args: string[];
     env: Record<string, string>;
+    version: string;
 }
 declare function planSpawn(agent: RegistryAgent, callerArgs?: string[], options?: {
     npmRegistry?: string;
@@ -1618,6 +1623,7 @@ interface AgentLogger {
 }
 declare class AgentInstance {
     readonly agentId: string;
+    readonly version: string;
     readonly cwd: string;
     readonly connection: JsonRpcConnection;
     private child;
@@ -2263,6 +2269,7 @@ declare class SessionManager {
     loadFromDisk(sessionId: string): Promise<ResurrectParams | undefined>;
     private deriveTitleFromHistory;
     get(sessionId: string): Session | undefined;
+    activeAgentVersions(): Map<string, Set<string>>;
     resolveCanonicalId(input: string): Promise<string | undefined>;
     require(sessionId: string): Session;
     list(filter?: {

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/daemon/server.ts
 import * as fs14 from "fs";
-import * as fsp4 from "fs/promises";
+import * as fsp5 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 import pino from "pino";
@@ -693,10 +693,12 @@ var RegistryDocument = z2.object({
   extensions: z2.array(z2.unknown()).optional()
 });
 var Registry = class {
-  constructor(config) {
+  constructor(config, options = {}) {
     this.config = config;
+    this.options = options;
   }
   config;
+  options;
   cache;
   async load() {
     if (this.cache && this.isFresh(this.cache.fetchedAt)) {
@@ -746,7 +748,12 @@ var Registry = class {
     }
     const raw = await response.json();
     const data = RegistryDocument.parse(raw);
-    return { fetchedAt: Date.now(), raw, data };
+    const cached = { fetchedAt: Date.now(), raw, data };
+    const hook = this.options.onFetched;
+    if (hook) {
+      void Promise.resolve().then(() => hook(data)).catch(() => void 0);
+    }
+    return cached;
   }
   async readDiskCache() {
     let text;
@@ -808,6 +815,7 @@ function npxPackageBasename(agent) {
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
 async function planSpawn(agent, callerArgs = [], options = {}) {
+  const version = agent.version ?? "current";
   if (agent.distribution.npx) {
     const npx = agent.distribution.npx;
     const tail = callerArgs.length > 0 ? callerArgs : npx.args ?? [];
@@ -815,13 +823,14 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
       return {
         command: "npx",
         args: ["-y", npx.package, ...tail],
-        env: npx.env ?? {}
+        env: npx.env ?? {},
+        version
       };
     }
     const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
     const binPath = await ensureNpmPackage({
       agentId: agent.id,
-      version: agent.version ?? "current",
+      version,
       packageSpec: npx.package,
       bin,
       registry: options.npmRegistry
@@ -829,7 +838,8 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     return {
       command: binPath,
       args: tail,
-      env: npx.env ?? {}
+      env: npx.env ?? {},
+      version
     };
   }
   if (agent.distribution.binary) {
@@ -841,14 +851,15 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     }
     const cmdPath = await ensureBinary({
       agentId: agent.id,
-      version: agent.version ?? "current",
+      version,
       target
     });
     const tail = callerArgs.length > 0 ? callerArgs : target.args ?? [];
     return {
       command: cmdPath,
       args: tail,
-      env: target.env ?? {}
+      env: target.env ?? {},
+      version
     };
   }
   if (agent.distribution.uvx) {
@@ -857,7 +868,8 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     return {
       command: "uvx",
       args: [uvx.package, ...tail],
-      env: uvx.env ?? {}
+      env: uvx.env ?? {},
+      version
     };
   }
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
@@ -1443,6 +1455,9 @@ var JsonRpcConnection = class _JsonRpcConnection {
 var DEFAULT_STDERR_TAIL_BYTES = 4096;
 var AgentInstance = class _AgentInstance {
   agentId;
+  // Version this process was spawned from — used by the registry-fetch
+  // prune sweep to skip install dirs belonging to a live agent.
+  version;
   cwd;
   connection;
   child;
@@ -1454,6 +1469,7 @@ var AgentInstance = class _AgentInstance {
   exitHandlers = [];
   constructor(opts, child) {
     this.agentId = opts.agentId;
+    this.version = opts.plan.version;
     this.cwd = opts.cwd;
     this.child = child;
     this.stderrTailBytes = opts.stderrTailBytes ?? DEFAULT_STDERR_TAIL_BYTES;
@@ -4257,6 +4273,23 @@ var SessionManager = class {
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  // Snapshot of which agent versions are currently in use by live
+  // sessions, keyed by agentId. Read by the registry-fetch prune sweep
+  // so it can skip install dirs that still back a running process.
+  activeAgentVersions() {
+    const out = /* @__PURE__ */ new Map();
+    for (const session of this.sessions.values()) {
+      const id = session.agent.agentId;
+      const version = session.agent.version;
+      let set = out.get(id);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        out.set(id, set);
+      }
+      set.add(version);
+    }
+    return out;
+  }
   // Resolve a user-typed session id (which may have the hydra_session_
   // prefix stripped — that's what `sessions list` and the picker show) to
   // the canonical form that actually exists. Tries the input as-given
@@ -5230,9 +5263,85 @@ function withCode2(err, code) {
   return err;
 }
 
+// src/core/agent-prune.ts
+import * as fsp4 from "fs/promises";
+import * as path8 from "path";
+var logSink3 = (msg) => {
+  process.stderr.write(msg + "\n");
+};
+function setAgentPruneLogger(log) {
+  logSink3 = log ?? ((msg) => process.stderr.write(msg + "\n"));
+}
+async function pruneStaleAgentVersions(registry, sessionManager) {
+  const platformKey = currentPlatformKey();
+  if (!platformKey) {
+    return;
+  }
+  const doc = await registry.load();
+  const desiredByAgent = /* @__PURE__ */ new Map();
+  for (const a of doc.agents) {
+    desiredByAgent.set(a.id, a.version ?? "current");
+  }
+  const activeByAgent = sessionManager.activeAgentVersions();
+  const platformDir = path8.join(paths.agentsDir(), platformKey);
+  let agentEntries;
+  try {
+    agentEntries = await fsp4.readdir(platformDir, { withFileTypes: true });
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return;
+    }
+    logSink3(`hydra-acp: prune: failed to read ${platformDir}: ${e.message}`);
+    return;
+  }
+  for (const agentEntry of agentEntries) {
+    if (!agentEntry.isDirectory()) {
+      continue;
+    }
+    const agentId = agentEntry.name;
+    const desired = desiredByAgent.get(agentId);
+    if (desired === void 0) {
+      continue;
+    }
+    const activeVersions = activeByAgent.get(agentId) ?? /* @__PURE__ */ new Set();
+    const agentDir = path8.join(platformDir, agentId);
+    let versionEntries;
+    try {
+      versionEntries = await fsp4.readdir(agentDir, { withFileTypes: true });
+    } catch (err) {
+      logSink3(
+        `hydra-acp: prune: failed to read ${agentDir}: ${err.message}`
+      );
+      continue;
+    }
+    for (const versionEntry of versionEntries) {
+      if (!versionEntry.isDirectory()) {
+        continue;
+      }
+      const version = versionEntry.name;
+      if (version === desired) {
+        continue;
+      }
+      if (activeVersions.has(version)) {
+        continue;
+      }
+      const versionDir = path8.join(agentDir, version);
+      try {
+        await fsp4.rm(versionDir, { recursive: true, force: true });
+        logSink3(`hydra-acp: pruned stale ${agentId} ${version} (${versionDir})`);
+      } catch (err) {
+        logSink3(
+          `hydra-acp: prune: failed to remove ${versionDir}: ${err.message}`
+        );
+      }
+    }
+  }
+}
+
 // src/core/session-tokens.ts
 import * as fs12 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
 var TOKEN_PREFIX = "hydra_session_";
 var DEFAULT_TTL_SEC = 60 * 60 * 24 * 30;
@@ -5240,7 +5349,7 @@ var ID_LENGTH = 12;
 var TOKEN_BYTES = 32;
 var WRITE_DEBOUNCE_MS = 50;
 function tokensFilePath() {
-  return path8.join(paths.home(), "session-tokens.json");
+  return path9.join(paths.home(), "session-tokens.json");
 }
 function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -6536,12 +6645,12 @@ import { z as z6 } from "zod";
 
 // src/core/password.ts
 import * as fs13 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 import { randomBytes as randomBytes2, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { promisify } from "util";
 var scryptAsync = promisify(scrypt);
 function passwordHashPath() {
-  return path9.join(paths.home(), "password-hash");
+  return path10.join(paths.home(), "password-hash");
 }
 var DEFAULT_N = 1 << 15;
 var MAX_MEM = 128 * 1024 * 1024;
@@ -7174,10 +7283,10 @@ function bindClientToSession(connection, session, state, clientInfo, callerClien
 async function startDaemon(config, serviceToken) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
-    key: await fsp4.readFile(config.daemon.tls.key),
-    cert: await fsp4.readFile(config.daemon.tls.cert)
+    key: await fsp5.readFile(config.daemon.tls.key),
+    cert: await fsp5.readFile(config.daemon.tls.cert)
   } : void 0;
-  await fsp4.mkdir(paths.home(), { recursive: true });
+  await fsp5.mkdir(paths.home(), { recursive: true });
   const { stream: logStream, fileStream } = await buildLogStream(
     config.daemon.logLevel
   );
@@ -7221,7 +7330,12 @@ async function startDaemon(config, serviceToken) {
     5 * 60 * 1e3
   );
   sweepInterval.unref();
-  const registry = new Registry(config);
+  const registry = new Registry(config, {
+    onFetched: () => {
+      void pruneStaleAgentVersions(registry, manager);
+    }
+  });
+  setAgentPruneLogger((msg) => app.log.info(msg));
   const agentLogger = {
     info: (msg) => app.log.info(msg),
     warn: (msg) => app.log.warn(msg)
@@ -7262,8 +7376,8 @@ async function startDaemon(config, serviceToken) {
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
   const boundPort = address && typeof address === "object" ? address.port : config.daemon.port;
-  await fsp4.mkdir(paths.home(), { recursive: true });
-  await fsp4.writeFile(
+  await fsp5.mkdir(paths.home(), { recursive: true });
+  await fsp5.writeFile(
     paths.pidFile(),
     JSON.stringify({
       pid: process.pid,
@@ -7297,6 +7411,7 @@ async function startDaemon(config, serviceToken) {
     await manager.flushMetaWrites();
     setBinaryInstallLogger(null);
     setNpmInstallLogger(null);
+    setAgentPruneLogger(null);
     await app.close();
     try {
       fs14.unlinkSync(paths.pidFile());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydra-acp/cli",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Multi-client ACP session daemon: spawn agents, attach over WSS, multiplex sessions across editors.",
   "license": "MIT",
   "type": "module",