@hydra-acp/cli 0.1.5 → 0.1.7

package/dist/index.d.ts

@@ -94,12 +94,15 @@ declare const HydraConfig: z.ZodObject<{
     tui: z.ZodDefault<z.ZodObject<{
         repaintThrottleMs: z.ZodDefault<z.ZodNumber>;
         maxScrollbackLines: z.ZodDefault<z.ZodNumber>;
+        mouse: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         repaintThrottleMs: number;
         maxScrollbackLines: number;
+        mouse: boolean;
     }, {
         repaintThrottleMs?: number | undefined;
         maxScrollbackLines?: number | undefined;
+        mouse?: boolean | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     daemon: {
@@ -122,6 +125,7 @@ declare const HydraConfig: z.ZodObject<{
     tui: {
         repaintThrottleMs: number;
         maxScrollbackLines: number;
+        mouse: boolean;
     };
     registry: {
         url: string;
@@ -152,6 +156,7 @@ declare const HydraConfig: z.ZodObject<{
     tui?: {
         repaintThrottleMs?: number | undefined;
         maxScrollbackLines?: number | undefined;
+        mouse?: boolean | undefined;
     } | undefined;
     registry?: {
         url?: string | undefined;
@@ -1178,7 +1183,7 @@ interface SpawnPlan {
     args: string[];
     env: Record<string, string>;
 }
-declare function planSpawn(agent: RegistryAgent, extraArgs?: string[]): Promise<SpawnPlan>;
+declare function planSpawn(agent: RegistryAgent, callerArgs?: string[]): Promise<SpawnPlan>;
 
 type JsonRpcId = string | number;
 interface JsonRpcRequest {
@@ -1476,6 +1481,8 @@ declare class JsonRpcConnection {
     private requestHandlers;
     private defaultRequestHandler;
     private notificationHandlers;
+    private bufferedNotifications;
+    private static readonly MAX_BUFFERED_PER_METHOD;
     private pending;
     private closed;
     private closeHandlers;
@@ -1964,6 +1971,7 @@ interface CreateSessionParams {
     mcpServers?: unknown[];
     title?: string;
     agentArgs?: string[];
+    model?: string;
 }
 interface ResurrectParams {
     hydraSessionId: string;
@@ -2097,6 +2105,7 @@ declare function hydraHome(): string;
 declare const paths: {
     home: typeof hydraHome;
     config: () => string;
+    authToken: () => string;
     pidFile: () => string;
     logFile: () => string;
     currentLogFile: () => string;

package/dist/index.js

@@ -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"),
@@ -83,7 +86,13 @@ 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)
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -116,7 +125,11 @@ 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
+  })
 });
 function extensionList(config) {
   return Object.entries(config.extensions).map(([name, body]) => ({
@@ -124,56 +137,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);
@@ -573,13 +634,13 @@ 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 ?? [];
     return {
       command: "npx",
-      args,
+      args: ["-y", npx.package, ...tail],
       env: npx.env ?? {}
     };
   }
@@ -595,18 +656,19 @@ 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 ?? {}
     };
   }
@@ -696,6 +758,9 @@ function extractHydraMeta(meta) {
       out.resume = parsed.data;
     }
   }
+  if (typeof obj.model === "string") {
+    out.model = obj.model;
+  }
   if (typeof obj.currentModel === "string") {
     out.currentModel = obj.currentModel;
   }
@@ -862,7 +927,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));
@@ -872,6 +937,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 = [];
@@ -883,6 +958,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);
@@ -968,6 +1054,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) {
@@ -1071,12 +1167,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"
   }
@@ -2598,7 +2694,8 @@ var SessionManager = class {
       agentId: params.agentId,
       cwd: params.cwd,
       agentArgs: params.agentArgs,
-      mcpServers: params.mcpServers
+      mcpServers: params.mcpServers,
+      model: params.model
     });
     const session = new Session({
       cwd: params.cwd,
@@ -2790,7 +2887,7 @@ var SessionManager = class {
         );
       }
       let initialModel = extractInitialModel(newResult);
-      const desired = this.defaultModels[params.agentId];
+      const desired = params.model ?? this.defaultModels[params.agentId];
       if (desired && desired !== initialModel) {
         try {
           await agent.connection.request("session/set_model", {
@@ -4305,7 +4402,8 @@ function registerAcpWsEndpoint(app, deps) {
         agentId: params.agentId ?? deps.defaultAgent,
         mcpServers: params.mcpServers,
         title: hydraMeta.name,
-        agentArgs: hydraMeta.agentArgs
+        agentArgs: hydraMeta.agentArgs,
+        model: hydraMeta.model
       });
       const client = bindClientToSession(connection, session, state);
       await session.attach(client, "full");

package/package.json

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