@hydra-acp/cli 0.1.6 → 0.1.8

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/daemon/server.ts
-import * as fs9 from "fs";
-import * as fsp3 from "fs/promises";
+import * as fs10 from "fs";
+import * as fsp4 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 import pino from "pino";
@@ -30,6 +30,9 @@ function hydraHome() {
 var paths = {
   home: hydraHome,
   config: () => path.join(hydraHome(), "config.json"),
+  // Auth token lives in its own file so config.json can be version-
+  // controlled without leaking the secret. Raw string contents, mode 0600.
+  authToken: () => path.join(hydraHome(), "auth-token"),
   pidFile: () => path.join(hydraHome(), "daemon.pid"),
   logFile: () => path.join(hydraHome(), "daemon.log"),
   currentLogFile: () => path.join(hydraHome(), "current.log"),
@@ -40,6 +43,18 @@ var paths = {
   // machine's binaries cleanly separated. `ls agents/` immediately
   // shows which platforms have ever installed anything.
   agentInstallDir: (id, platformKey, version) => path.join(hydraHome(), "agents", platformKey, id, version),
+  // npm install cache for npx-distributed agents. The trailing
+  // node<ABI> segment keys on process.versions.modules so a Node
+  // major bump (different ABI → native modules incompatible) yields
+  // a fresh install rather than failing at require() time.
+  agentNpmInstallDir: (id, platformKey, version) => path.join(
+    hydraHome(),
+    "agents",
+    platformKey,
+    id,
+    version,
+    `node${process.versions.modules}`
+  ),
   sessionsDir: () => path.join(hydraHome(), "sessions"),
   // One directory per session id under sessions/. Co-locates the
   // session record, its transcript, and any future per-session state
@@ -66,7 +81,16 @@ var DaemonConfig = z.object({
   authToken: z.string().min(16),
   logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
   tls: TlsConfig.optional(),
-  sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(3600)
+  sessionIdleTimeoutSeconds: z.number().int().nonnegative().default(3600),
+  // Cap on entries kept in a session's on-disk replay log (history.jsonl).
+  // Compaction trims to this many on a periodic basis; reads also slice
+  // to the tail at this length as a defensive measure against older
+  // daemons that may have written unbounded files.
+  sessionHistoryMaxEntries: z.number().int().positive().default(1e3),
+  // Bytes of trailing agent stderr buffered per AgentInstance so the
+  // daemon can include it in the diagnostic message when a spawn fails.
+  // Bump if your agents emit large tracebacks you want surfaced.
+  agentStderrTailBytes: z.number().int().positive().default(4096)
 });
 var RegistryConfig = z.object({
   url: z.string().url().default(REGISTRY_URL_DEFAULT),
@@ -83,7 +107,20 @@ var TuiConfig = z.object({
   // Cap on logical lines retained in the in-memory scrollback render
   // buffer. Oldest lines are dropped on overflow. The on-disk session
   // history is unaffected; this only bounds the TUI's local view buffer.
-  maxScrollbackLines: z.number().int().positive().default(1e4)
+  maxScrollbackLines: z.number().int().positive().default(1e4),
+  // When true (default), the TUI captures mouse events so the wheel can
+  // drive scrollback. The cost: terminals route clicks to the app, so
+  // text selection requires shift+drag to bypass mouse reporting. Set
+  // false to disable capture — wheel scrollback stops working, but
+  // plain click-drag selects text via the terminal emulator.
+  mouse: z.boolean().default(true),
+  // Size at which the TUI's session/update debug log (tui.log) rotates
+  // to tui.log.0 and resets. Bounds on-disk use at ~2x this value.
+  logMaxBytes: z.number().int().positive().default(5 * 1024 * 1024),
+  // Width cap on the cwd column in the `sessions list` output and the
+  // TUI picker. Set higher if you keep deeply-nested working directories
+  // and want them visible; the elastic title column shrinks to make room.
+  cwdColumnMaxWidth: z.number().int().positive().default(24)
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -116,7 +153,16 @@ var HydraConfig = z.object({
   // recency and truncated to this count. `--all` overrides in the CLI.
   sessionListColdLimit: z.number().int().nonnegative().default(20),
   extensions: z.record(ExtensionName, ExtensionBody).default({}),
-  tui: TuiConfig.default({ repaintThrottleMs: 1e3, maxScrollbackLines: 1e4 })
+  tui: TuiConfig.default({
+    repaintThrottleMs: 1e3,
+    maxScrollbackLines: 1e4,
+    mouse: true,
+    logMaxBytes: 5 * 1024 * 1024,
+    cwdColumnMaxWidth: 24
+  })
+});
+var HydraConfigReadOnly = HydraConfig.extend({
+  daemon: DaemonConfig.omit({ authToken: true })
 });
 function extensionList(config) {
   return Object.entries(config.extensions).map(([name, body]) => ({
@@ -124,56 +170,104 @@ function extensionList(config) {
     ...body
   }));
 }
-async function loadConfig() {
-  const configPath = paths.config();
+async function readConfigFile() {
   let raw;
   try {
-    raw = await fs.readFile(configPath, "utf8");
+    raw = await fs.readFile(paths.config(), "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
-      throw new Error(
-        `No config found at ${configPath}. Run \`hydra-acp init\` to create one.`
-      );
+      return {};
     }
     throw err;
   }
-  const parsed = JSON.parse(raw);
-  return HydraConfig.parse(parsed);
+  return JSON.parse(raw);
 }
-async function ensureConfig() {
+async function loadAuthToken() {
+  let tokenFile;
   try {
-    await fs.access(paths.config());
+    const text = await fs.readFile(paths.authToken(), "utf8");
+    const trimmed = text.trim();
+    if (trimmed.length > 0) {
+      tokenFile = trimmed;
+    }
   } catch (err) {
     const e = err;
     if (e.code !== "ENOENT") {
       throw err;
     }
-    const config = await writeMinimalInitConfig();
-    process.stderr.write(
-      `hydra-acp: initialized ${paths.config()} with a fresh auth token.
-`
+  }
+  const raw = await readConfigFile();
+  const daemon = raw.daemon;
+  const legacy = daemon && typeof daemon.authToken === "string" ? daemon.authToken : void 0;
+  if (tokenFile && legacy) {
+    throw new Error(
+      `Auth token present in both ${paths.authToken()} and ${paths.config()} (daemon.authToken). Remove daemon.authToken from config.json to resolve.`
     );
-    return config;
   }
-  return loadConfig();
+  if (tokenFile) {
+    return tokenFile;
+  }
+  if (legacy) {
+    await migrateLegacyAuthToken(raw, daemon, legacy);
+    return legacy;
+  }
+  return void 0;
 }
-async function writeConfig(config) {
+async function migrateLegacyAuthToken(raw, daemon, token) {
+  await writeAuthToken(token);
+  delete daemon.authToken;
+  if (Object.keys(daemon).length === 0) {
+    delete raw.daemon;
+  }
+  await fs.writeFile(paths.config(), JSON.stringify(raw, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  process.stderr.write(
+    `hydra-acp: migrated auth token from ${paths.config()} to ${paths.authToken()}.
+`
+  );
+}
+async function writeAuthToken(token) {
   await fs.mkdir(paths.home(), { recursive: true });
-  await fs.writeFile(paths.config(), JSON.stringify(config, null, 2) + "\n", {
+  await fs.writeFile(paths.authToken(), token + "\n", {
     encoding: "utf8",
     mode: 384
   });
 }
-async function writeMinimalInitConfig(authToken) {
-  const token = authToken ?? generateAuthToken();
-  const minimal = { daemon: { authToken: token } };
+async function loadConfig() {
+  const token = await loadAuthToken();
+  if (!token) {
+    throw new Error(
+      `No auth token found at ${paths.authToken()}. Run \`hydra-acp init\` to create one.`
+    );
+  }
+  const raw = await readConfigFile();
+  const daemon = raw.daemon ??= {};
+  daemon.authToken = token;
+  return HydraConfig.parse(raw);
+}
+async function ensureConfig() {
+  if (!await loadAuthToken()) {
+    const token = generateAuthToken();
+    await writeAuthToken(token);
+    process.stderr.write(
+      `hydra-acp: initialized ${paths.authToken()} with a fresh auth token.
+`
+    );
+  }
+  return loadConfig();
+}
+async function writeConfig(config) {
   await fs.mkdir(paths.home(), { recursive: true });
-  await fs.writeFile(paths.config(), JSON.stringify(minimal, null, 2) + "\n", {
+  const { daemon, ...rest } = config;
+  const { authToken: _authToken, ...daemonRest } = daemon;
+  const onDisk = { ...rest, daemon: daemonRest };
+  await fs.writeFile(paths.config(), JSON.stringify(onDisk, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
-  return HydraConfig.parse(minimal);
 }
 function generateAuthToken() {
   const bytes = new Uint8Array(32);
@@ -411,9 +505,129 @@ async function fileExists(p) {
   }
 }
 
+// src/core/npm-install.ts
+import * as fsp2 from "fs/promises";
+import * as path3 from "path";
+import { spawn as spawn2 } from "child_process";
+var logSink2 = (msg) => {
+  process.stderr.write(msg + "\n");
+};
+function setNpmInstallLogger(log) {
+  logSink2 = log ?? ((msg) => process.stderr.write(msg + "\n"));
+}
+async function ensureNpmPackage(args) {
+  const platformKey = currentPlatformKey();
+  if (!platformKey) {
+    throw new Error(
+      `Agent ${args.agentId}: cannot determine platform key for ${process.platform}/${process.arch}`
+    );
+  }
+  const installDir = paths.agentNpmInstallDir(
+    args.agentId,
+    platformKey,
+    args.version
+  );
+  const binPath = path3.join(installDir, "node_modules", ".bin", args.bin);
+  if (await fileExists2(binPath)) {
+    return binPath;
+  }
+  await installInto({
+    agentId: args.agentId,
+    packageSpec: args.packageSpec,
+    installDir
+  });
+  if (!await fileExists2(binPath)) {
+    throw new Error(
+      `Agent ${args.agentId}: npm install of ${args.packageSpec} did not produce bin ${args.bin} (looked in ${installDir}/node_modules/.bin/)`
+    );
+  }
+  return binPath;
+}
+async function installInto(args) {
+  await fsp2.mkdir(path3.dirname(args.installDir), { recursive: true });
+  const tempDir = await fsp2.mkdtemp(`${args.installDir}.partial-`);
+  try {
+    logSink2(
+      `hydra-acp: installing ${args.packageSpec} for ${args.agentId} into ${tempDir}`
+    );
+    await runNpmInstall({
+      packageSpec: args.packageSpec,
+      cwd: tempDir
+    });
+    try {
+      await fsp2.rename(tempDir, args.installDir);
+    } catch (err) {
+      const e = err;
+      if ((e.code === "EEXIST" || e.code === "ENOTEMPTY") && await fileExists2(args.installDir)) {
+        await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
+          () => void 0
+        );
+        return;
+      }
+      throw err;
+    }
+    logSink2(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+  } catch (err) {
+    await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
+      () => void 0
+    );
+    throw err;
+  }
+}
+function runNpmInstall(args) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn2(
+      "npm",
+      ["install", "--no-audit", "--no-fund", "--silent", args.packageSpec],
+      {
+        cwd: args.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let stderrTail = "";
+    child.stdout?.on("data", (chunk) => {
+      void chunk;
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderrTail = (stderrTail + chunk).slice(-4096);
+    });
+    child.on("error", (err) => {
+      const msg = err.code === "ENOENT" ? `npm not found on PATH (install Node.js / npm, or use a binary-distributed agent)` : err.message;
+      reject(new Error(msg));
+    });
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve3();
+        return;
+      }
+      const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
+      const tail = stderrTail.trim();
+      reject(
+        new Error(
+          tail ? `npm install ${args.packageSpec} failed (${reason})
+stderr: ${tail}` : `npm install ${args.packageSpec} failed (${reason})`
+        )
+      );
+    });
+  });
+}
+async function fileExists2(p) {
+  try {
+    await fsp2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/core/registry.ts
 var NpxDistribution = z2.object({
   package: z2.string(),
+  // The bin to invoke after install. Defaults to the package basename
+  // (e.g. "claude-code" for "@anthropic-ai/claude-code"). Required when
+  // the package exposes a bin name that differs from its basename.
+  bin: z2.string().optional(),
   args: z2.array(z2.string()).optional(),
   env: z2.record(z2.string()).optional()
 });
@@ -573,13 +787,27 @@ function npxPackageBasename(agent) {
   const atIdx = afterSlash.lastIndexOf("@");
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
-async function planSpawn(agent, extraArgs = []) {
+async function planSpawn(agent, callerArgs = []) {
   if (agent.distribution.npx) {
     const npx = agent.distribution.npx;
-    const args = ["-y", npx.package, ...npx.args ?? [], ...extraArgs];
+    const tail = callerArgs.length > 0 ? callerArgs : npx.args ?? [];
+    if (process.env.HYDRA_ACP_SKIP_NPM_PREFETCH) {
+      return {
+        command: "npx",
+        args: ["-y", npx.package, ...tail],
+        env: npx.env ?? {}
+      };
+    }
+    const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
+    const binPath = await ensureNpmPackage({
+      agentId: agent.id,
+      version: agent.version ?? "current",
+      packageSpec: npx.package,
+      bin
+    });
     return {
-      command: "npx",
-      args,
+      command: binPath,
+      args: tail,
       env: npx.env ?? {}
     };
   }
@@ -595,33 +823,31 @@ async function planSpawn(agent, extraArgs = []) {
       version: agent.version ?? "current",
       target
     });
+    const tail = callerArgs.length > 0 ? callerArgs : target.args ?? [];
     return {
       command: cmdPath,
-      args: [...target.args ?? [], ...extraArgs],
+      args: tail,
       env: target.env ?? {}
     };
   }
   if (agent.distribution.uvx) {
     const uvx = agent.distribution.uvx;
-    const args = [uvx.package, ...uvx.args ?? [], ...extraArgs];
+    const tail = callerArgs.length > 0 ? callerArgs : uvx.args ?? [];
     return {
       command: "uvx",
-      args,
+      args: [uvx.package, ...tail],
       env: uvx.env ?? {}
     };
   }
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
-// src/core/session-manager.ts
-import * as fs7 from "fs/promises";
-import { customAlphabet as customAlphabet3 } from "nanoid";
-
 // src/core/agent-instance.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 // src/acp/types.ts
 import { z as z3 } from "zod";
+var ACP_PROTOCOL_VERSION = 1;
 var JsonRpcErrorCodes = {
   ParseError: -32700,
   InvalidRequest: -32600,
@@ -865,7 +1091,7 @@ function ndjsonStreamFromStdio(stdout, stdin) {
 
 // src/acp/connection.ts
 import { nanoid } from "nanoid";
-var JsonRpcConnection = class {
+var JsonRpcConnection = class _JsonRpcConnection {
   constructor(stream) {
     this.stream = stream;
     this.stream.onMessage((m) => this.handleIncoming(m));
@@ -875,6 +1101,16 @@ var JsonRpcConnection = class {
   requestHandlers = /* @__PURE__ */ new Map();
   defaultRequestHandler;
   notificationHandlers = /* @__PURE__ */ new Map();
+  // Notifications received before a handler was registered. Some agents
+  // (e.g. claude-acp) advertise their command list in the same chunk as
+  // the `session/new` response, which is processed before the consumer
+  // can attach its `session/update` handler. Without this buffer those
+  // notifications would be silently dropped, so e.g. `/model` would
+  // never appear in the TUI's slash-completion palette. Capped per
+  // method to keep the buffer from growing unboundedly when nothing
+  // ever subscribes.
+  bufferedNotifications = /* @__PURE__ */ new Map();
+  static MAX_BUFFERED_PER_METHOD = 64;
   pending = /* @__PURE__ */ new Map();
   closed = false;
   closeHandlers = [];
@@ -886,6 +1122,17 @@ var JsonRpcConnection = class {
   }
   onNotification(method, handler) {
     this.notificationHandlers.set(method, handler);
+    const queued = this.bufferedNotifications.get(method);
+    if (!queued) {
+      return;
+    }
+    this.bufferedNotifications.delete(method);
+    for (const note of queued) {
+      try {
+        handler(note.params, note.method);
+      } catch {
+      }
+    }
   }
   onClose(handler) {
     this.closeHandlers.push(handler);
@@ -930,6 +1177,13 @@ var JsonRpcConnection = class {
     }
     await this.stream.close();
   }
+  // Force-close with an error. Rejects all pending requests and fires
+  // close handlers carrying `err`. Used by transports that detect a
+  // failure (e.g. child process crash, spawn ENOENT) the stream itself
+  // can't surface as a stdout/stdin error.
+  fail(err) {
+    this.handleClose(err);
+  }
   handleIncoming(message) {
     if ("method" in message) {
       if ("id" in message && message.id !== void 0) {
@@ -971,6 +1225,16 @@ var JsonRpcConnection = class {
     const handler = this.notificationHandlers.get(note.method);
     if (handler) {
       handler(note.params, note.method);
+      return;
+    }
+    let queued = this.bufferedNotifications.get(note.method);
+    if (!queued) {
+      queued = [];
+      this.bufferedNotifications.set(note.method, queued);
+    }
+    queued.push(note);
+    if (queued.length > _JsonRpcConnection.MAX_BUFFERED_PER_METHOD) {
+      queued.shift();
     }
   }
   handleResponse(res) {
@@ -1012,17 +1276,22 @@ var JsonRpcConnection = class {
 };
 
 // src/core/agent-instance.ts
+var DEFAULT_STDERR_TAIL_BYTES = 4096;
 var AgentInstance = class _AgentInstance {
   agentId;
   cwd;
   connection;
   child;
   exited = false;
+  killed = false;
+  stderrTail = "";
+  stderrTailBytes;
   exitHandlers = [];
   constructor(opts, child) {
     this.agentId = opts.agentId;
     this.cwd = opts.cwd;
     this.child = child;
+    this.stderrTailBytes = opts.stderrTailBytes ?? DEFAULT_STDERR_TAIL_BYTES;
     if (!child.stdout || !child.stdin) {
       throw new Error("agent subprocess missing stdio");
     }
@@ -1030,22 +1299,36 @@ var AgentInstance = class _AgentInstance {
     this.connection = new JsonRpcConnection(stream);
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
+      this.stderrTail = (this.stderrTail + chunk).slice(-this.stderrTailBytes);
       process.stderr.write(`[${opts.agentId}] ${chunk}`);
     });
+    child.on("error", (err) => {
+      const msg = this.formatFailure(err.message);
+      this.connection.fail(new Error(msg));
+    });
     child.on("exit", (code, signal) => {
       this.exited = true;
+      if (!this.killed) {
+        const reason = `agent ${opts.agentId} exited before responding (code=${code} signal=${signal})`;
+        this.connection.fail(new Error(this.formatFailure(reason)));
+      }
       for (const handler of this.exitHandlers) {
         handler(code, signal);
       }
     });
   }
+  formatFailure(reason) {
+    const tail = this.stderrTail.trim();
+    return tail ? `${reason}
+stderr: ${tail}` : reason;
+  }
   static spawn(opts) {
     const env = {
       ...process.env,
       ...opts.plan.env,
       ...opts.extraEnv ?? {}
     };
-    const child = spawn2(opts.plan.command, opts.plan.args, {
+    const child = spawn3(opts.plan.command, opts.plan.args, {
       cwd: opts.cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -1062,11 +1345,17 @@ var AgentInstance = class _AgentInstance {
     if (this.exited) {
       return;
     }
+    this.killed = true;
     await this.connection.close().catch(() => void 0);
     this.child.kill(signal);
   }
 };
 
+// src/core/session-manager.ts
+import * as fs8 from "fs/promises";
+import * as os2 from "os";
+import { customAlphabet as customAlphabet3 } from "nanoid";
+
 // src/core/session.ts
 import { customAlphabet } from "nanoid";
 
@@ -1074,12 +1363,12 @@ import { customAlphabet } from "nanoid";
 var HYDRA_COMMANDS = [
   {
     verb: "title",
-    name: "/hydra title",
+    name: "hydra title",
     description: "Regenerate the session title via the agent (or set manually with an arg)"
   },
   {
     verb: "agent",
-    name: "/hydra agent",
+    name: "hydra agent",
     argsHint: "<agent>",
     description: "Swap the agent backing this session, preserving context"
   }
@@ -1096,8 +1385,7 @@ function hydraCommandsAsAdvertised() {
 var HYDRA_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
 var HYDRA_SESSION_PREFIX = "hydra_session_";
-var MAX_HISTORY_ENTRIES = 1e3;
-var COMPACT_EVERY = 200;
+var DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
 var Session = class {
   sessionId;
   cwd;
@@ -1139,11 +1427,13 @@ var Session = class {
   // Bumped by broadcastPromptReceived, cleared by broadcastTurnComplete.
   // Drives the mid-turn elapsed counter delivered to fresh attachers.
   promptStartedAt;
-  // Counts appends since the last compaction. When it hits COMPACT_EVERY
+  // Counts appends since the last compaction. When it hits compactEvery
   // we ask the history store to trim the file to the most recent
-  // MAX_HISTORY_ENTRIES. Keeps file growth bounded without per-append
+  // historyMaxEntries. Keeps file growth bounded without per-append
   // file-size checks.
   appendCount = 0;
+  historyMaxEntries;
+  compactEvery;
   // Permission requests that have been broadcast to one or more
   // clients but have not yet resolved. Replayed to clients that
   // attach mid-flight so a late joiner sees the prompt instead of an
@@ -1200,6 +1490,8 @@ var Session = class {
       this.firstPromptSeeded = true;
     }
     this.historyStore = init.historyStore;
+    this.historyMaxEntries = init.historyMaxEntries ?? DEFAULT_HISTORY_MAX_ENTRIES;
+    this.compactEvery = Math.max(1, Math.floor(this.historyMaxEntries * 0.2));
     this.updatedAt = Date.now();
     this.createdAt = init.createdAt ?? this.updatedAt;
     this.lastRecordedAt = this.updatedAt;
@@ -2038,9 +2330,9 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       if (this.historyStore) {
         const store = this.historyStore;
         void store.append(this.sessionId, entry).catch(() => void 0);
-        if (this.appendCount >= COMPACT_EVERY) {
+        if (this.appendCount >= this.compactEvery) {
           this.appendCount = 0;
-          void store.compact(this.sessionId, MAX_HISTORY_ENTRIES).catch(
+          void store.compact(this.sessionId, this.historyMaxEntries).catch(
             () => void 0
           );
         }
@@ -2242,7 +2534,7 @@ function firstLine(text, max) {
 
 // src/core/session-store.ts
 import * as fs4 from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 import { customAlphabet as customAlphabet2 } from "nanoid";
 import { z as z4 } from "zod";
 var HYDRA_ID_ALPHABET2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -2414,12 +2706,16 @@ function recordFromMemorySession(args) {
 // src/core/history-store.ts
 import * as fs5 from "fs/promises";
 var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
-var MAX_ENTRIES = 1e3;
+var DEFAULT_MAX_ENTRIES = 1e3;
 var HistoryStore = class {
   // Serialize writes per session id so appends and rewrites don't
   // interleave JSONL lines on disk. The chain swallows errors so one
   // failed append doesn't poison every subsequent write.
   writeQueues = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
   async append(sessionId, entry) {
     if (!SESSION_ID_PATTERN2.test(sessionId)) {
       return;
@@ -2521,8 +2817,8 @@ var HistoryStore = class {
         recordedAt: obj.recordedAt
       });
     }
-    if (out.length > MAX_ENTRIES) {
-      return out.slice(-MAX_ENTRIES);
+    if (out.length > this.maxEntries) {
+      return out.slice(-this.maxEntries);
     }
     return out;
   }
@@ -2565,13 +2861,40 @@ var HistoryStore = class {
 
 // src/tui/history.ts
 import { promises as fs6 } from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 async function saveHistory(file, history) {
-  await fs6.mkdir(path4.dirname(file), { recursive: true });
+  await fs6.mkdir(path5.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
   await fs6.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 
+// src/core/hydra-version.ts
+import { fileURLToPath } from "url";
+import * as path6 from "path";
+import * as fs7 from "fs";
+function resolveVersion() {
+  try {
+    let dir = path6.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i += 1) {
+      const candidate = path6.join(dir, "package.json");
+      if (fs7.existsSync(candidate)) {
+        const pkg = JSON.parse(fs7.readFileSync(candidate, "utf8"));
+        if (typeof pkg.version === "string" && pkg.version.length > 0 && (typeof pkg.name !== "string" || pkg.name.includes("hydra-acp"))) {
+          return pkg.version;
+        }
+      }
+      const parent = path6.dirname(dir);
+      if (parent === dir) {
+        break;
+      }
+      dir = parent;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var HYDRA_VERSION = resolveVersion();
+
 // src/core/session-manager.ts
 var HYDRA_ID_ALPHABET3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var generateRawSessionId = customAlphabet3(HYDRA_ID_ALPHABET3, 16);
@@ -2580,7 +2903,8 @@ var SessionManager = class {
     this.registry = registry;
     this.spawner = spawner ?? ((opts) => AgentInstance.spawn(opts));
     this.store = store ?? new SessionStore();
-    this.histories = new HistoryStore();
+    this.sessionHistoryMaxEntries = options.sessionHistoryMaxEntries ?? 1e3;
+    this.histories = new HistoryStore({ maxEntries: this.sessionHistoryMaxEntries });
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
     this.defaultModels = options.defaultModels ?? {};
   }
@@ -2592,6 +2916,7 @@ var SessionManager = class {
   histories;
   idleTimeoutMs;
   defaultModels;
+  sessionHistoryMaxEntries;
   // Serialize meta.json read-modify-write operations per session id so
   // concurrent snapshot updates (e.g. an agent emitting model + mode
   // back-to-back) don't lose writes via interleaved reads.
@@ -2615,6 +2940,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
+      historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel
     });
     await this.attachManagerHooks(session);
@@ -2666,11 +2992,16 @@ var SessionManager = class {
       cwd: params.cwd,
       plan
     });
-    await agent.connection.request("initialize", {
-      protocolVersion: 1,
-      clientCapabilities: {},
-      clientInfo: { name: "hydra", version: "0.1.0" }
-    });
+    try {
+      await agent.connection.request("initialize", {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        clientCapabilities: {},
+        clientInfo: { name: "hydra", version: HYDRA_VERSION }
+      });
+    } catch (err) {
+      await agent.kill().catch(() => void 0);
+      throw err;
+    }
     let loadResult;
     try {
       loadResult = await agent.connection.request(
@@ -2682,10 +3013,12 @@ var SessionManager = class {
         }
       );
     } catch (err) {
-      await agent.kill().catch(() => void 0);
-      throw new Error(
-        `agent ${params.agentId} failed to load upstream session ${params.upstreamSessionId}: ${err.message}`
+      process.stderr.write(
+        `session/load failed for upstream ${params.upstreamSessionId} on ${params.agentId} (${err.message}); recovering via import-reseed
+`
       );
+      await agent.kill().catch(() => void 0);
+      return this.doResurrectFromImport(params);
     }
     const session = new Session({
       sessionId: params.hydraSessionId,
@@ -2699,6 +3032,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
+      historyMaxEntries: this.sessionHistoryMaxEntries,
       // Prefer what we previously stored from a current_model_update; if
       // we never captured one (e.g. old opencode sessions on disk before
       // this fix), fall back to the model the agent ships in its
@@ -2725,15 +3059,16 @@ var SessionManager = class {
   // so subsequent resurrects of this session use the normal session/load
   // path.
   async doResurrectFromImport(params) {
+    const cwd = await this.resolveImportCwd(params.cwd);
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
-      cwd: params.cwd,
+      cwd,
       agentArgs: params.agentArgs,
       mcpServers: []
     });
     const session = new Session({
       sessionId: params.hydraSessionId,
-      cwd: params.cwd,
+      cwd,
       agentId: params.agentId,
       agent: fresh.agent,
       upstreamSessionId: fresh.upstreamSessionId,
@@ -2743,6 +3078,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       historyStore: this.histories,
+      historyMaxEntries: this.sessionHistoryMaxEntries,
       // Prefer the stored value (set by a previous current_model_update);
       // fall back to whatever the agent ships in its session/new response.
       currentModel: params.currentModel ?? fresh.initialModel,
@@ -2756,6 +3092,16 @@ var SessionManager = class {
     void session.seedFromImport().catch(() => void 0);
     return session;
   }
+  async resolveImportCwd(cwd) {
+    try {
+      const stat2 = await fs8.stat(cwd);
+      if (stat2.isDirectory()) {
+        return cwd;
+      }
+    } catch {
+    }
+    return os2.homedir();
+  }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
   // → session/new. Shared by create() and the /hydra agent path so both
   // go through the same env / capabilities / error-handling.
@@ -2776,9 +3122,9 @@ var SessionManager = class {
     });
     try {
       await agent.connection.request("initialize", {
-        protocolVersion: 1,
+        protocolVersion: ACP_PROTOCOL_VERSION,
         clientCapabilities: {},
-        clientInfo: { name: "hydra", version: "0.1.0" }
+        clientInfo: { name: "hydra", version: HYDRA_VERSION }
       });
       const newResult = await agent.connection.request(
         "session/new",
@@ -3058,7 +3404,8 @@ var SessionManager = class {
       await this.writeImportedRecord({
         sessionId: existing.sessionId,
         bundle,
-        preservedCreatedAt: existing.createdAt
+        preservedCreatedAt: existing.createdAt,
+        cwd: opts.cwd
       });
       return {
         sessionId: existing.sessionId,
@@ -3067,7 +3414,11 @@ var SessionManager = class {
       };
     }
     const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
-    await this.writeImportedRecord({ sessionId: newId, bundle });
+    await this.writeImportedRecord({
+      sessionId: newId,
+      bundle,
+      cwd: opts.cwd
+    });
     return {
       sessionId: newId,
       importedFromSessionId: bundle.session.sessionId,
@@ -3097,7 +3448,7 @@ var SessionManager = class {
         upstreamSessionId: "",
         importedFromSessionId: args.bundle.session.sessionId,
         agentId: args.bundle.session.agentId,
-        cwd: args.bundle.session.cwd,
+        cwd: args.cwd ?? args.bundle.session.cwd,
         title: args.bundle.session.title,
         currentModel: args.bundle.session.currentModel,
         currentMode: args.bundle.session.currentMode,
@@ -3290,7 +3641,7 @@ function asString(value) {
 }
 async function loadPromptHistorySafely(sessionId) {
   try {
-    const raw = await fs7.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const raw = await fs8.readFile(paths.tuiHistoryFile(sessionId), "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       if (line.length === 0) {
@@ -3311,7 +3662,7 @@ async function loadPromptHistorySafely(sessionId) {
 }
 async function historyMtimeIso(sessionId) {
   try {
-    const st = await fs7.stat(paths.historyFile(sessionId));
+    const st = await fs8.stat(paths.historyFile(sessionId));
     return new Date(st.mtimeMs).toISOString();
   } catch {
     return void 0;
@@ -3319,10 +3670,10 @@ async function historyMtimeIso(sessionId) {
 }
 
 // src/core/extensions.ts
-import { spawn as spawn3 } from "child_process";
-import * as fs8 from "fs";
-import * as fsp2 from "fs/promises";
-import * as path5 from "path";
+import { spawn as spawn4 } from "child_process";
+import * as fs9 from "fs";
+import * as fsp3 from "fs/promises";
+import * as path7 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
 var STOP_GRACE_MS = 3e3;
@@ -3343,7 +3694,7 @@ var ExtensionManager = class {
     if (!this.context) {
       throw new Error("ExtensionManager: setContext must be called before start");
     }
-    await fsp2.mkdir(paths.extensionsDir(), { recursive: true });
+    await fsp3.mkdir(paths.extensionsDir(), { recursive: true });
     await this.reapOrphans();
     for (const entry of this.entries.values()) {
       if (!entry.config.enabled) {
@@ -3552,7 +3903,7 @@ var ExtensionManager = class {
   async reapOrphans() {
     let entries;
     try {
-      entries = await fsp2.readdir(paths.extensionsDir());
+      entries = await fsp3.readdir(paths.extensionsDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -3564,10 +3915,10 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path5.join(paths.extensionsDir(), entry);
+      const pidPath = path7.join(paths.extensionsDir(), entry);
       let pid;
       try {
-        const raw = await fsp2.readFile(pidPath, "utf8");
+        const raw = await fsp3.readFile(pidPath, "utf8");
         const parsed = Number.parseInt(raw.trim(), 10);
         if (Number.isInteger(parsed) && parsed > 0) {
           pid = parsed;
@@ -3590,7 +3941,7 @@ var ExtensionManager = class {
           }
         }
       }
-      await fsp2.unlink(pidPath).catch(() => void 0);
+      await fsp3.unlink(pidPath).catch(() => void 0);
     }
   }
   spawn(entry, attempt) {
@@ -3603,7 +3954,7 @@ var ExtensionManager = class {
     }
     const ext = entry.config;
     const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs8.createWriteStream(paths.extensionLogFile(ext.name), {
+    const logStream = fs9.createWriteStream(paths.extensionLogFile(ext.name), {
       flags: "a"
     });
     logStream.write(
@@ -3631,7 +3982,7 @@ var ExtensionManager = class {
     const args = [...baseArgs, ...ext.args];
     let child;
     try {
-      child = spawn3(cmd, args, {
+      child = spawn4(cmd, args, {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false
@@ -3653,7 +4004,7 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs8.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs9.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
@@ -3678,7 +4029,7 @@ var ExtensionManager = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs8.unlinkSync(paths.extensionPidFile(ext.name));
+        fs9.unlinkSync(paths.extensionPidFile(ext.name));
       } catch {
       }
       logStream.write(
@@ -3787,7 +4138,7 @@ function constantTimeEqual(a, b) {
 }
 
 // src/daemon/routes/sessions.ts
-import * as os2 from "os";
+import * as os3 from "os";
 
 // src/core/bundle.ts
 import { z as z5 } from "zod";
@@ -3857,7 +4208,6 @@ function decodeBundle(raw) {
 }
 
 // src/daemon/routes/sessions.ts
-var HYDRA_VERSION = "0.1.0";
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
@@ -3928,7 +4278,7 @@ function registerSessionRoutes(app, manager, defaults) {
       history: exported.history,
       promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
       hydraVersion: HYDRA_VERSION,
-      machine: os2.hostname()
+      machine: os3.hostname()
     });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     reply.header(
@@ -3943,6 +4293,14 @@ function registerSessionRoutes(app, manager, defaults) {
       reply.code(400).send({ error: "missing bundle" });
       return;
     }
+    let cwdOverride;
+    if (body.cwd !== void 0) {
+      if (typeof body.cwd !== "string" || body.cwd.length === 0) {
+        reply.code(400).send({ error: "cwd must be a non-empty string" });
+        return;
+      }
+      cwdOverride = body.cwd;
+    }
     let bundle;
     try {
       bundle = decodeBundle(body.bundle);
@@ -3955,7 +4313,8 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     try {
       const result = await manager.importBundle(bundle, {
-        replace: body.replace === true
+        replace: body.replace === true,
+        ...cwdOverride !== void 0 ? { cwd: cwdOverride } : {}
       });
       reply.code(201).send(result);
     } catch (err) {
@@ -4266,8 +4625,6 @@ function wsToMessageStream(ws) {
 }
 
 // src/daemon/acp-ws.ts
-var HYDRA_VERSION2 = "0.1.0";
-var HYDRA_PROTOCOL_VERSION = 1;
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -4530,8 +4887,8 @@ function buildResponseMeta(session) {
 }
 function buildInitializeResult() {
   return {
-    protocolVersion: HYDRA_PROTOCOL_VERSION,
-    agentInfo: { name: "hydra", version: HYDRA_VERSION2 },
+    protocolVersion: ACP_PROTOCOL_VERSION,
+    agentInfo: { name: "hydra", version: HYDRA_VERSION },
     agentCapabilities: {
       // hydra is a transparent proxy: prompt blocks and MCP server configs are
       // forwarded to the underlying agent unchanged. We claim the union of
@@ -4570,14 +4927,13 @@ function bindClientToSession(connection, session, state, clientInfo) {
 }
 
 // src/daemon/server.ts
-var HYDRA_VERSION3 = "0.1.0";
 async function startDaemon(config) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
-    key: await fsp3.readFile(config.daemon.tls.key),
-    cert: await fsp3.readFile(config.daemon.tls.cert)
+    key: await fsp4.readFile(config.daemon.tls.key),
+    cert: await fsp4.readFile(config.daemon.tls.cert)
   } : void 0;
-  await fsp3.mkdir(paths.home(), { recursive: true });
+  await fsp4.mkdir(paths.home(), { recursive: true });
   const { stream: logStream, fileStream } = await buildLogStream(
     config.daemon.logLevel
   );
@@ -4586,12 +4942,18 @@ async function startDaemon(config) {
       level: config.daemon.logLevel,
       stream: logStream
     },
-    https: httpsOptions ?? null
+    https: httpsOptions ?? null,
+    // Session bundles can be large (full history + tool output);
+    // the 1MB Fastify default rejects ordinary imports.
+    bodyLimit: 256 * 1024 * 1024
   });
   await app.register(websocketPlugin);
   setBinaryInstallLogger((msg) => {
     app.log.info(msg);
   });
+  setNpmInstallLogger((msg) => {
+    app.log.info(msg);
+  });
   const auth = bearerAuth({ config });
   app.addHook("onRequest", async (request, reply) => {
     if (request.routeOptions.config?.skipAuth) {
@@ -4603,12 +4965,14 @@ async function startDaemon(config) {
     await auth(request, reply);
   });
   const registry = new Registry(config);
-  const manager = new SessionManager(registry, void 0, void 0, {
+  const spawner = (opts) => AgentInstance.spawn({ ...opts, stderrTailBytes: config.daemon.agentStderrTailBytes });
+  const manager = new SessionManager(registry, spawner, void 0, {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
-    defaultModels: config.defaultModels
+    defaultModels: config.defaultModels,
+    sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries
   });
   const extensions = new ExtensionManager(extensionList(config));
-  registerHealthRoutes(app, HYDRA_VERSION3);
+  registerHealthRoutes(app, HYDRA_VERSION);
   registerSessionRoutes(app, manager, {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
@@ -4627,8 +4991,8 @@ async function startDaemon(config) {
   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 fsp3.mkdir(paths.home(), { recursive: true });
-  await fsp3.writeFile(
+  await fsp4.mkdir(paths.home(), { recursive: true });
+  await fsp4.writeFile(
     paths.pidFile(),
     JSON.stringify({
       pid: process.pid,
@@ -4654,9 +5018,10 @@ async function startDaemon(config) {
     await manager.closeAll();
     await manager.flushMetaWrites();
     setBinaryInstallLogger(null);
+    setNpmInstallLogger(null);
     await app.close();
     try {
-      fs9.unlinkSync(paths.pidFile());
+      fs10.unlinkSync(paths.pidFile());
     } catch {
     }
     try {