@hydra-acp/cli 0.1.32 → 0.1.33

package/dist/cli.js

@@ -12948,6 +12948,7 @@ import { dirname as dirname6, resolve as resolve5 } from "path";
 // src/cli/parse-args.ts
 var KNOWN_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "all",
+  "detach",
   "foreground",
   "help",
   "info",
@@ -17575,6 +17576,7 @@ async function runDaemonStart(flags = {}) {
     return;
   }
   if (flagBool(flags, "foreground")) {
+    process.title = "hydra-daemon";
     const handle = await startDaemon(config, serviceToken);
     process.stdout.write(
       `hydra-acp daemon listening on ${config.daemon.host}:${config.daemon.port}
@@ -18655,8 +18657,34 @@ function isResponse2(msg) {
   return !("method" in msg) && "id" in msg;
 }
 
+// src/core/process-title.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+var COMM_ANCHOR = "hydra";
+var defaultWriteComm = (text) => {
+  writeFileSync2("/proc/self/comm", text);
+};
+function setHydraProcessTitle(fullTitle, deps = {}) {
+  process.title = fullTitle;
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "linux") {
+    return;
+  }
+  const writeComm = deps.writeComm ?? defaultWriteComm;
+  try {
+    writeComm(COMM_ANCHOR);
+  } catch {
+  }
+}
+function buildTitleFromArgv(argv) {
+  if (argv.length === 0) {
+    return COMM_ANCHOR;
+  }
+  return `${COMM_ANCHOR} ${argv.join(" ")}`;
+}
+
 // src/shim/proxy.ts
 async function runShim(opts) {
+  setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
   const config = await loadConfig();
   const serviceToken = await ensureServiceToken();
   await ensureDaemonReachable(config);
@@ -18896,6 +18924,309 @@ function injectHydraMeta(msg, additions) {
   };
 }
 
+// src/cli/commands/cat.ts
+init_connection();
+init_ws_stream();
+init_config();
+init_service_token();
+init_daemon_bootstrap();
+init_render_update();
+init_types();
+init_hydra_version();
+import { WebSocket as WebSocket2 } from "ws";
+
+// src/cli/commands/cat-chunker.ts
+function createChunker(opts) {
+  let buffer = "";
+  let dataArrivedSinceSchedule = false;
+  let scheduled = false;
+  let ended = false;
+  const flush = () => {
+    if (buffer.length === 0) {
+      return;
+    }
+    const out = buffer;
+    buffer = "";
+    opts.onChunk(out);
+  };
+  const scheduleCheck = () => {
+    if (scheduled) {
+      return;
+    }
+    scheduled = true;
+    dataArrivedSinceSchedule = false;
+    opts.scheduleFlushCheck(() => {
+      scheduled = false;
+      if (dataArrivedSinceSchedule) {
+        scheduleCheck();
+        return;
+      }
+      flush();
+    });
+  };
+  return {
+    feed(data) {
+      if (ended || data.length === 0) {
+        return;
+      }
+      buffer += data;
+      if (scheduled) {
+        dataArrivedSinceSchedule = true;
+      } else {
+        scheduleCheck();
+      }
+    },
+    eof() {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      flush();
+    }
+  };
+}
+
+// src/cli/commands/cat.ts
+async function runCat(opts) {
+  setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
+  if (process.stdin.isTTY && !opts.prompt && !opts.sessionId) {
+    process.stderr.write(
+      "hydra-acp cat: nothing to send. Pipe input on stdin, pass -p <text>, or attach to an existing session with --session-id.\n"
+    );
+    process.exit(2);
+    return;
+  }
+  const config = await loadConfig();
+  const serviceToken = await ensureServiceToken();
+  await ensureDaemonReachable(config);
+  const protocol = config.daemon.tls ? "wss" : "ws";
+  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
+  const subprotocols = ["acp.v1", `hydra-acp-token.${serviceToken}`];
+  const ws = await openWs2(url, subprotocols);
+  const stream = wsToMessageStream(ws);
+  const conn = new JsonRpcConnection(stream);
+  const result = await runCatLoop({
+    conn,
+    opts,
+    stdin: process.stdin,
+    stdinIsTty: process.stdin.isTTY === true,
+    stdout: (chunk) => process.stdout.write(chunk),
+    stderr: (chunk) => {
+      process.stderr.write(chunk);
+    }
+  });
+  process.exit(result.exitCode);
+}
+async function runCatLoop(args) {
+  const { conn, opts, stdin, stdinIsTty, stdout, stderr } = args;
+  conn.setDefaultHandler(async () => {
+    return { error: { code: -32601, message: "method not implemented" } };
+  });
+  try {
+    await conn.request("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      },
+      clientInfo: { name: "hydra-acp-cat", version: HYDRA_VERSION }
+    });
+  } catch {
+  }
+  const sessionId = await openOrAttachSession(conn, opts);
+  let turnHadOutput = false;
+  let lastCharWasNewline = true;
+  const writeStdout = (text) => {
+    if (text.length === 0) {
+      return;
+    }
+    stdout(text);
+    lastCharWasNewline = text.charCodeAt(text.length - 1) === 10;
+  };
+  const finalizeTurn = () => {
+    if (turnHadOutput && !lastCharWasNewline) {
+      writeStdout("\n");
+    }
+    turnHadOutput = false;
+  };
+  conn.onNotification("session/update", (params) => {
+    const update = params?.update;
+    const event = mapUpdate(update);
+    if (!event) {
+      return;
+    }
+    if (event.kind === "agent-text") {
+      turnHadOutput = true;
+      writeStdout(event.text);
+    } else if (event.kind === "turn-complete") {
+      finalizeTurn();
+    }
+  });
+  const sendChunk = async (text) => {
+    const promptBlocks = [];
+    if (opts.prompt) {
+      promptBlocks.push({ type: "text", text: opts.prompt });
+    }
+    if (text.length > 0) {
+      promptBlocks.push({ type: "text", text });
+    }
+    if (promptBlocks.length === 0) {
+      return;
+    }
+    try {
+      await conn.request("session/prompt", {
+        sessionId,
+        prompt: promptBlocks
+      });
+    } catch (err) {
+      stderr(`hydra-acp cat: prompt failed: ${err.message}
+`);
+      return;
+    }
+    finalizeTurn();
+  };
+  let exitCode = 0;
+  let resolveDone;
+  const done = new Promise((resolve6) => {
+    resolveDone = resolve6;
+  });
+  let settled = false;
+  const settle = async (code) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    if (!opts.detach) {
+      conn.request("session/detach", { sessionId }).catch(() => void 0);
+    }
+    await conn.close().catch(() => void 0);
+    resolveDone({ exitCode: code });
+  };
+  conn.onClose((err) => {
+    if (err) {
+      stderr(`hydra-acp cat: ${err.message}
+`);
+      exitCode = 1;
+    }
+    if (!settled) {
+      settled = true;
+      resolveDone({ exitCode });
+    }
+  });
+  const chunkQueue = [];
+  let draining = false;
+  let stdinEnded = false;
+  const drainQueue = async () => {
+    if (draining) {
+      return;
+    }
+    draining = true;
+    try {
+      while (chunkQueue.length > 0) {
+        const next = chunkQueue.shift();
+        if (next === void 0) {
+          break;
+        }
+        await sendChunk(next);
+      }
+    } finally {
+      draining = false;
+      if (stdinEnded && chunkQueue.length === 0) {
+        await settle(exitCode);
+      }
+    }
+  };
+  const chunker = createChunker({
+    // setImmediate fires in the libuv "check" phase, after pending
+    // I/O has been polled and any back-to-back "data" events have
+    // been emitted. That makes it the natural hook for "the writer
+    // has paused, time to flush": if more bytes were sitting in the
+    // pipe buffer, Node would have emitted another "data" event
+    // before this fires, and the chunker would detect that and defer.
+    scheduleFlushCheck: (cb) => {
+      const h = setImmediate(cb);
+      return () => clearImmediate(h);
+    },
+    onChunk: (text) => {
+      chunkQueue.push(text);
+      void drainQueue();
+    }
+  });
+  if (stdinIsTty && !opts.sessionId) {
+    if (opts.prompt) {
+      await sendChunk("");
+    }
+    await settle(0);
+    return done;
+  }
+  if (typeof stdin.setEncoding === "function") {
+    stdin.setEncoding("utf8");
+  }
+  stdin.on("data", (data) => {
+    chunker.feed(typeof data === "string" ? data : data.toString("utf8"));
+  });
+  stdin.on("end", () => {
+    chunker.eof();
+    stdinEnded = true;
+    if (!draining && chunkQueue.length === 0) {
+      void settle(exitCode);
+    }
+  });
+  stdin.on("error", (err) => {
+    stderr(`hydra-acp cat: stdin error: ${err.message}
+`);
+    exitCode = 1;
+    stdinEnded = true;
+    if (!draining && chunkQueue.length === 0) {
+      void settle(exitCode);
+    }
+  });
+  return done;
+}
+async function openOrAttachSession(conn, opts) {
+  if (opts.sessionId) {
+    const attached = await conn.request("session/attach", {
+      sessionId: opts.sessionId,
+      historyPolicy: "pending_only",
+      clientInfo: { name: "hydra-acp-cat", version: HYDRA_VERSION }
+    });
+    return attached.sessionId;
+  }
+  const hydraMeta = {};
+  if (opts.name) {
+    hydraMeta.name = opts.name;
+  }
+  if (opts.model) {
+    hydraMeta.model = opts.model;
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const params = { cwd };
+  if (opts.agentId) {
+    params.agentId = opts.agentId;
+  }
+  if (Object.keys(hydraMeta).length > 0) {
+    params._meta = { [HYDRA_META_KEY]: hydraMeta };
+  }
+  const created = await conn.request("session/new", params);
+  void extractHydraMeta(created._meta);
+  return created.sessionId;
+}
+async function openWs2(url, subprotocols) {
+  return new Promise((resolve6, reject) => {
+    const ws = new WebSocket2(url, subprotocols);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve6(ws);
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+
 // src/cli.ts
 init_update_check();
 var suppressUpdateNotice = false;
@@ -18973,6 +19304,26 @@ async function main() {
       suppressUpdateNotice = true;
       await runShim({ sessionId, name, agentId: agentIdFromFlag, model });
       return;
+    case "cat": {
+      const promptFromShort = readShortPrompt(argv);
+      const longPrompt = typeof flags.prompt === "string" ? flags.prompt : void 0;
+      const prompt = promptFromShort ?? longPrompt;
+      const cwd = resolveOption(flags, "cwd");
+      const catOpts = {
+        prompt,
+        sessionId,
+        name,
+        model,
+        agentId: agentIdFromFlag,
+        detach: flags.detach === true
+      };
+      if (cwd !== void 0) {
+        catOpts.cwd = cwd;
+      }
+      suppressUpdateNotice = true;
+      await runCat(catOpts);
+      return;
+    }
     case "init":
       await runInit(flags);
       return;
@@ -19157,6 +19508,7 @@ async function dispatchTui(flags, base) {
     );
     process.exit(2);
   }
+  setHydraProcessTitle(buildTitleFromArgv(process.argv.slice(2)));
   const { runTui } = await Promise.resolve().then(() => (init_tui(), tui_exports));
   const tuiOpts = { resume, forceNew, readonly };
   if (base.sessionId !== void 0) {
@@ -19176,6 +19528,21 @@ async function dispatchTui(flags, base) {
   }
   await runTui(tuiOpts);
 }
+function readShortPrompt(argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const tok = argv[i];
+    if (tok === void 0) {
+      continue;
+    }
+    if (tok === "-p") {
+      return argv[i + 1];
+    }
+    if (tok.startsWith("-p") && !tok.startsWith("--")) {
+      return tok.slice(2);
+    }
+  }
+  return void 0;
+}
 function bareResumeError() {
   process.stderr.write(
     "hydra-acp: --resume requires a session id. Use --resume <id> to attach to a specific session, or --reattach to pick the most recent one in cwd.\n"
@@ -19202,6 +19569,19 @@ function printHelp() {
       "  hydra-acp                          Auto: TUI when stdout is a TTY, shim otherwise (the editor-spawned case)",
       "  hydra-acp shim                     Run as ACP shim explicitly (forces shim mode regardless of TTY)",
       "  hydra-acp tui [opts]               Run the terminal UI explicitly (see below for opts)",
+      "  hydra-acp cat [-p <prompt>] [--session-id <id>] [--detach] [--agent <id>] [--model <id>] [--name <label>]",
+      "                                     Pipe-friendly headless mode. Reads stdin and sends it",
+      "                                     as a prompt to a fresh session, streams the agent's",
+      "                                     response to stdout, exits when stdin closes. A bounded",
+      '                                     input (e.g. `cat file.log | hydra cat -p "..."`) goes in',
+      "                                     as one turn; a streaming input (e.g. `tail -f`) is",
+      "                                     chunked by the natural pauses in the writer. -p is an",
+      "                                     optional standing instruction prepended to every chunk;",
+      "                                     if stdin already contains the question, -p is not needed.",
+      "                                     With --session-id, attach to an existing session instead",
+      "                                     of creating a new one. With --detach, the session",
+      "                                     survives in the daemon for slack/browser/notifier",
+      "                                     extensions.",
       "  hydra-acp launch <agent> [agent-args...]",
       "                                     Shim mode, force daemon to spawn <agent>",
       "                                     from the registry. Args after <agent>",

package/dist/index.d.ts

@@ -1410,8 +1410,8 @@ declare const SessionListEntry: z.ZodObject<{
     status: z.ZodDefault<z.ZodEnum<["live", "cold"]>>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    status: "live" | "cold";
     cwd: string;
+    status: "live" | "cold";
     sessionId: string;
     updatedAt: string;
     attachedClients: number;
@@ -1480,8 +1480,8 @@ declare const SessionListResult: z.ZodObject<{
         status: z.ZodDefault<z.ZodEnum<["live", "cold"]>>;
         _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        status: "live" | "cold";
         cwd: string;
+        status: "live" | "cold";
         sessionId: string;
         updatedAt: string;
         attachedClients: number;
@@ -1521,8 +1521,8 @@ declare const SessionListResult: z.ZodObject<{
     nextCursor: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     sessions: {
-        status: "live" | "cold";
         cwd: string;
+        status: "live" | "cold";
         sessionId: string;
         updatedAt: string;
         attachedClients: number;
@@ -1594,14 +1594,14 @@ declare const AmendPromptParams: z.ZodObject<{
     replaceQueue: z.ZodOptional<z.ZodBoolean>;
     onTargetCompleted: z.ZodOptional<z.ZodEnum<["reject", "send_anyway"]>>;
 }, "strip", z.ZodTypeAny, {
-    sessionId: string;
     prompt: unknown[];
+    sessionId: string;
     targetMessageId: string;
     replaceQueue?: boolean | undefined;
     onTargetCompleted?: "reject" | "send_anyway" | undefined;
 }, {
-    sessionId: string;
     prompt: unknown[];
+    sessionId: string;
     targetMessageId: string;
     replaceQueue?: boolean | undefined;
     onTargetCompleted?: "reject" | "send_anyway" | undefined;

package/package.json

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