@hydra-acp/cli 0.1.30 → 0.1.32

package/dist/index.d.ts

@@ -1320,10 +1320,12 @@ declare const SessionAttachParams: z.ZodObject<{
         name: string;
         version?: string | undefined;
     }>>;
+    readonly: z.ZodOptional<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     sessionId: string;
     historyPolicy: "full" | "pending_only" | "none" | "after_message";
+    readonly?: boolean | undefined;
     clientInfo?: {
         name: string;
         version?: string | undefined;
@@ -1333,6 +1335,7 @@ declare const SessionAttachParams: z.ZodObject<{
     _meta?: Record<string, unknown> | undefined;
 }, {
     sessionId: string;
+    readonly?: boolean | undefined;
     clientInfo?: {
         name: string;
         version?: string | undefined;
@@ -1779,6 +1782,7 @@ interface AttachedClient {
         name: string;
         version?: string;
     };
+    readonly?: boolean;
 }
 type CachedNotification = HistoryEntry;
 interface SpawnReplacementAgentParams {
@@ -2400,6 +2404,7 @@ declare class SessionManager {
     private bootstrapAgent;
     private attachManagerHooks;
     getHistory(sessionId: string): Promise<HistoryEntry[] | undefined>;
+    loadHistory(sessionId: string): Promise<HistoryEntry[]>;
     loadFromDisk(sessionId: string): Promise<ResurrectParams | undefined>;
     private deriveTitleFromHistory;
     get(sessionId: string): Session | undefined;

package/dist/index.js

@@ -168,12 +168,12 @@ var TuiConfig = z.object({
   // 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),
-  // 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),
+  // When true, 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. Default
+  // false — wheel scrollback stops working, but plain click-drag
+  // selects text via the terminal emulator. Set true to opt back in.
+  mouse: z.boolean().default(false),
   // 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),
@@ -188,13 +188,13 @@ var TuiConfig = z.object({
   // just don't want it.
   progressIndicator: z.boolean().default(true),
   // What the unmodified Enter key does in the prompt composer.
-  //   "enqueue" (default) — Enter enqueues the prompt (sends immediately
-  //     when idle, queues behind an in-flight turn); Shift+Enter amends
-  //     the in-flight turn.
-  //   "amend" — flips the two: Enter amends the in-flight turn,
-  //     Shift+Enter enqueues. With no turn in flight either key just
-  //     enqueues, since there's nothing to amend.
-  defaultEnterAction: z.enum(["enqueue", "amend"]).default("enqueue")
+  //   "amend" (default) — Enter amends the in-flight turn; Shift+Enter
+  //     enqueues. With no turn in flight either key just enqueues,
+  //     since there's nothing to amend.
+  //   "enqueue" — flips the two: Enter enqueues the prompt (sends
+  //     immediately when idle, queues behind an in-flight turn);
+  //     Shift+Enter amends the in-flight turn.
+  defaultEnterAction: z.enum(["enqueue", "amend"]).default("amend")
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -235,11 +235,11 @@ var HydraConfig = z.object({
   tui: TuiConfig.default({
     repaintThrottleMs: 1e3,
     maxScrollbackLines: 1e4,
-    mouse: true,
+    mouse: false,
     logMaxBytes: 5 * 1024 * 1024,
     cwdColumnMaxWidth: 24,
     progressIndicator: true,
-    defaultEnterAction: "enqueue"
+    defaultEnterAction: "amend"
   })
 });
 function extensionList(config) {
@@ -1075,6 +1075,12 @@ var SessionAttachParams = z3.object({
     name: z3.string(),
     version: z3.string().optional()
   }).optional(),
+  // When true, the connection observes the session but cannot mutate
+  // it: state-changing methods (session/prompt, session/cancel,
+  // session/set_model, etc.) are rejected with -32011, and attaching
+  // to a cold session does not resurrect or spawn an agent — just
+  // streams history from disk. Used by the TUI's view-only mode.
+  readonly: z3.boolean().optional(),
   _meta: z3.record(z3.unknown()).optional()
 });
 var HYDRA_META_KEY = "hydra-acp";
@@ -4893,6 +4899,13 @@ var SessionManager = class {
     }
     return this.histories.load(sessionId).catch(() => []);
   }
+  // Read the on-disk history.jsonl for a session without constructing a
+  // Session instance. Used by the daemon's read-only viewer attach path
+  // (cli/src/daemon/acp-ws.ts) to stream replay events to a client for
+  // a cold session without spawning an agent.
+  async loadHistory(sessionId) {
+    return this.histories.load(sessionId);
+  }
   async loadFromDisk(sessionId) {
     const record = await this.store.read(sessionId);
     if (!record) {
@@ -6066,6 +6079,9 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       if (activeVersions.has(version)) {
         continue;
       }
+      if (version.includes(".partial-")) {
+        continue;
+      }
       const versionDir = path8.join(agentDir, version);
       try {
         await fsp4.rm(versionDir, { recursive: true, force: true });
@@ -7714,6 +7730,16 @@ function registerAcpWsEndpoint(app, deps) {
       }
       state.attached.clear();
     });
+    const denyIfReadonly = (sessionId, method) => {
+      const att = state.attached.get(sessionId);
+      if (att?.readonly) {
+        const err = new Error(
+          `${method} not permitted on a read-only attachment`
+        );
+        err.code = JsonRpcErrorCodes.PermissionDenied;
+        throw err;
+      }
+    };
     connection.onRequest("initialize", async (raw) => {
       InitializeParams.parse(raw ?? {});
       return buildInitializeResult();
@@ -7740,7 +7766,8 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly: false
       });
       setImmediate(() => {
         void (async () => {
@@ -7766,11 +7793,46 @@ function registerAcpWsEndpoint(app, deps) {
     connection.onRequest("session/attach", async (raw) => {
       const params = SessionAttachParams.parse(raw);
       const hydraHints = extractHydraMeta(params._meta).resume;
+      const readonly = params.readonly === true;
       app.log.info(
-        `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints}`
+        `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints} readonly=${readonly}`
       );
       const lookupId = hydraHints ? params.sessionId : await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
       let session = deps.manager.get(lookupId);
+      if (!session && readonly) {
+        const fromDisk = await deps.manager.loadFromDisk(lookupId);
+        if (!fromDisk) {
+          const err = new Error(
+            `session ${params.sessionId} not found`
+          );
+          err.code = JsonRpcErrorCodes.SessionNotFound;
+          throw err;
+        }
+        const history = await deps.manager.loadHistory(lookupId);
+        const viewerClientId = params.clientId ?? `cli_${nanoid2(8)}`;
+        state.attached.set(fromDisk.hydraSessionId, {
+          sessionId: fromDisk.hydraSessionId,
+          clientId: viewerClientId,
+          readonly: true
+        });
+        app.log.info(
+          `session/attach OK (viewer) sessionId=${fromDisk.hydraSessionId} clientId=${viewerClientId} attachedCount=${state.attached.size} replayed=${history.length}`
+        );
+        for (const entry of history) {
+          await connection.notify(entry.method, entry.params).catch(() => void 0);
+        }
+        return {
+          sessionId: fromDisk.hydraSessionId,
+          clientId: viewerClientId,
+          connectedClients: [viewerClientId],
+          // No Session.attach() ran, so no history policy was applied —
+          // the viewer always gets full history. Report "full" so the
+          // wire shape matches the normal attach response.
+          historyPolicy: "full",
+          replayed: history.length,
+          _meta: buildViewerResponseMeta(fromDisk)
+        };
+      }
       if (!session) {
         const fromDisk = await deps.manager.loadFromDisk(lookupId);
         let resurrectParams = fromDisk;
@@ -7814,10 +7876,11 @@ function registerAcpWsEndpoint(app, deps) {
       );
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -7861,6 +7924,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("session/prompt", async (raw) => {
       const params = SessionPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "session/prompt");
       const att = state.attached.get(params.sessionId);
       if (!att) {
         app.log.warn(
@@ -7909,6 +7973,12 @@ function registerAcpWsEndpoint(app, deps) {
       if (!att) {
         return;
       }
+      if (att.readonly) {
+        app.log.warn(
+          `session/cancel dropped (readonly attachment) sessionId=${params.sessionId}`
+        );
+        return;
+      }
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         return;
@@ -7921,11 +7991,14 @@ function registerAcpWsEndpoint(app, deps) {
     };
     connection.onNotification("session/cancel", handleCancelParams);
     connection.onRequest("session/cancel", async (raw) => {
+      const params = SessionCancelParams.parse(raw);
+      denyIfReadonly(params.sessionId, "session/cancel");
       handleCancelParams(raw);
       return null;
     });
     connection.onRequest("hydra-acp/cancel_prompt", async (raw) => {
       const params = CancelPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/cancel_prompt");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -7936,6 +8009,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("hydra-acp/update_prompt", async (raw) => {
       const params = UpdatePromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/update_prompt");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -7946,6 +8020,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("hydra-acp/amend_prompt", async (raw) => {
       const params = AmendPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/amend_prompt");
       const att = state.attached.get(params.sessionId);
       if (!att) {
         const err = new Error("not attached to session");
@@ -7985,7 +8060,8 @@ function registerAcpWsEndpoint(app, deps) {
       const { entries: replay } = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
-        clientId: client.clientId
+        clientId: client.clientId,
+        readonly: false
       });
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -8004,6 +8080,10 @@ function registerAcpWsEndpoint(app, deps) {
       };
     });
     connection.onRequest("session/set_model", async (rawParams) => {
+      const sessionIdField = rawParams?.sessionId;
+      if (typeof sessionIdField === "string") {
+        denyIfReadonly(sessionIdField, "session/set_model");
+      }
       const decision = decideSetModel(rawParams, deps.manager);
       if (decision.kind === "error") {
         app.log.warn(decision.logMessage);
@@ -8037,6 +8117,7 @@ function registerAcpWsEndpoint(app, deps) {
         err.code = JsonRpcErrorCodes.MethodNotFound;
         throw err;
       }
+      denyIfReadonly(sessionId, method);
       const session = deps.manager.get(sessionId);
       if (!session) {
         const err = new Error(`session ${sessionId} not found`);
@@ -8175,6 +8256,38 @@ function decideSetModel(rawParams, manager) {
     logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
   };
 }
+function buildViewerResponseMeta(fromDisk) {
+  const ours = {
+    upstreamSessionId: fromDisk.upstreamSessionId,
+    agentId: fromDisk.agentId,
+    cwd: fromDisk.cwd
+  };
+  if (fromDisk.title !== void 0) {
+    ours.name = fromDisk.title;
+  }
+  if (fromDisk.agentArgs && fromDisk.agentArgs.length > 0) {
+    ours.agentArgs = fromDisk.agentArgs;
+  }
+  if (fromDisk.currentModel !== void 0) {
+    ours.currentModel = fromDisk.currentModel;
+  }
+  if (fromDisk.currentMode !== void 0) {
+    ours.currentMode = fromDisk.currentMode;
+  }
+  if (fromDisk.currentUsage !== void 0) {
+    ours.currentUsage = fromDisk.currentUsage;
+  }
+  if (fromDisk.agentCommands && fromDisk.agentCommands.length > 0) {
+    ours.availableCommands = fromDisk.agentCommands;
+  }
+  if (fromDisk.agentModes && fromDisk.agentModes.length > 0) {
+    ours.availableModes = fromDisk.agentModes;
+  }
+  if (fromDisk.agentModels && fromDisk.agentModels.length > 0) {
+    ours.availableModels = fromDisk.agentModels;
+  }
+  return { [HYDRA_META_KEY]: ours };
+}
 function buildResponseMeta(session) {
   const ours = {
     upstreamSessionId: session.upstreamSessionId,

package/package.json

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