@ccmsg/cli 0.11.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",

package/src/daemon/registry.ts

@@ -188,9 +188,16 @@ const STARTING_PRESETS = [
   },
   {
     name: "journal",
-    description: "日記用。人との往復と worker の答え、思考は要点だけ",
+    description: "日記用。人との往復と worker の答え、中断などの合図、思考は要点だけ",
     opts: {
-      types: ["message.user", "message.parent", "message.sub.in", "message.team.in", "thinking"],
+      types: [
+        "message.user",
+        "message.parent",
+        "message.sub.in",
+        "message.team.in",
+        "notice",
+        "thinking",
+      ],
     },
   },
   {

package/src/daemon/supervise.ts

@@ -1,6 +1,7 @@
 import { chmodSync, mkdirSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { type Env, resolveSupervisorSocket } from "../instance/paths.ts";
+import { WriteQueue } from "../transport/index.ts";
 import { CommandError, type SuperviseRequest } from "./link.ts";
 import {
   awaitGone,
@@ -194,11 +195,27 @@ export class Supervisor {
     }
     const handle = (frame: Record<string, unknown>): Promise<unknown> =>
       this.handle(frame as unknown as SuperviseRequest);
-    this.#listener = Bun.listen<{ buffer: string }>({
+    this.#listener = Bun.listen<ControlState>({
       unix: path,
       socket: {
         open(socket) {
-          socket.data = { buffer: "" };
+          // Every answer goes through the queue, because `socket.write` takes
+          // what fits in the socket buffer and returns a short count for the
+          // rest: an answer longer than that — `status --all` on a host with
+          // several instances — would otherwise arrive without its newline and
+          // leave the caller waiting for a line that never ends.
+          const queue = new WriteQueue<Uint8Array>({
+            encode: (line) => new TextEncoder().encode(line),
+            write(chunk) {
+              const written = socket.write(chunk);
+              if (written < 0) return undefined; // closing: nothing more will go
+              return written === chunk.length ? undefined : chunk.subarray(written);
+            },
+            flush: () => {
+              socket.flush();
+            },
+          });
+          socket.data = { buffer: "", queue };
         },
         data(socket, chunk) {
           socket.data.buffer += new TextDecoder().decode(chunk);
@@ -207,9 +224,12 @@ export class Supervisor {
             const line = socket.data.buffer.slice(0, at);
             socket.data.buffer = socket.data.buffer.slice(at + 1);
             if (line.trim() === "") continue;
-            void answer(socket, line, handle);
+            void answer(socket.data.queue, line, handle);
           }
         },
+        drain(socket) {
+          socket.data.queue.drain();
+        },
       },
     });
     chmodSync(path, 0o600);
@@ -489,9 +509,16 @@ export class Supervisor {
   }
 }
 
+/** What one control connection holds: the half-read line, and the answers
+ * waiting for a socket that is not taking them all at once. */
+interface ControlState {
+  buffer: string;
+  queue: WriteQueue<Uint8Array>;
+}
+
 /** Answer one line, in the shape a command reads: the result, or the error. */
 async function answer(
-  socket: Bun.Socket<{ buffer: string }>,
+  queue: WriteQueue<Uint8Array>,
   line: string,
   handle: (frame: Record<string, unknown>) => Promise<unknown>,
 ): Promise<void> {
@@ -499,18 +526,18 @@ async function answer(
   try {
     frame = JSON.parse(line) as Record<string, unknown>;
   } catch {
-    socket.write(
+    queue.push(
       `${JSON.stringify({ ok: false, error: { code: "bad_request", msg: "not valid JSON" } })}\n`,
     );
     return;
   }
   try {
-    socket.write(`${JSON.stringify({ ok: true, result: await handle(frame) })}\n`);
+    queue.push(`${JSON.stringify({ ok: true, result: await handle(frame) })}\n`);
   } catch (cause) {
     const error =
       cause instanceof CommandError
         ? { code: cause.code, msg: cause.message }
         : { code: "internal_error", msg: String(cause) };
-    socket.write(`${JSON.stringify({ ok: false, error })}\n`);
+    queue.push(`${JSON.stringify({ ok: false, error })}\n`);
   }
 }

package/src/transcript/items/document.ts

@@ -83,31 +83,14 @@ function heading(file: SessionDumpFile, view: DumpView): string[] {
 function draw(item: Item, child: Item | undefined, view: DumpView, parent?: string): string[] {
   const own = fragment(item);
   const answer = child === undefined ? undefined : fragment(child);
-  const nested = child !== undefined && spoken(child.type);
   const link = isResult(item)
     ? arrow("←", parent)
     : (arrow("→", fields(item)["result_item"]) ?? waiting(item));
   const head = isResult(item)
     ? words(prefix(item), link, own.head, clock(item))
-    : words(
-        prefix(item),
-        own.head,
-        link,
-        nested || answer === undefined ? undefined : answer.head,
-        clock(item),
-      );
-  const under = [
-    ...body(own.body, view),
-    ...(answer === undefined || nested ? [] : body(answer.body, view)),
-  ];
-  const lines = [head, ...under.map((line) => `${INDENT}${line}`)];
-  if (!nested || child === undefined || answer === undefined) return lines;
-  // The agent's answer, under the brief that asked for it. It keeps a heading
-  // of its own — it has its own instant, and often a status the brief could
-  // not have known — and is indented to say whose answer it is.
-  lines.push(`${INDENT}${words(prefix(child), answer.head, clock(child))}`);
-  for (const line of body(answer.body, view)) lines.push(`${INDENT}${INDENT}${line}`);
-  return lines;
+    : words(prefix(item), own.head, link, answer?.head, clock(item));
+  const under = [...body(own.body, view), ...(answer === undefined ? [] : body(answer.body, view))];
+  return [head, ...under.map((line) => `${INDENT}${line}`)];
 }
 
 /** `[id] type`, which is how an item is pointed at: the id is what the links
@@ -238,9 +221,11 @@ function pair(items: readonly Item[]): {
     const call = where.get(to);
     if (call === undefined) continue;
     // A pair the reader would have to scroll between is left where each half
-    // happened, unless it is an agent's: what an agent was asked and what it
-    // answered are one exchange whatever fell between them.
-    if (!spoken(item.type) && call !== at - 1) continue;
+    // happened. What is being read is a run of moments in the order they
+    // happened, and an answer that arrived minutes later — which is the usual
+    // case for an agent — would put a later moment in the middle of an earlier
+    // one. The two halves point at each other by id instead.
+    if (call !== at - 1) continue;
     child.set(call, at);
     folded.add(at);
   }
@@ -255,12 +240,3 @@ function pair(items: readonly Item[]): {
 function joined(item: Item, key: string): string {
   return `${item.type.startsWith("message.") ? "message" : "tool"}\n${key}`;
 }
-
-/** Whether an item is the conversation half of starting an agent, as opposed
- * to the call's own half. What was asked and what came back is one exchange
- * however many turns fell between them, so these are drawn together wherever
- * they ended up — a conversation split across the page is one nobody can
- * follow. */
-function spoken(type: string): boolean {
-  return type.startsWith("message.sub") || type.startsWith("message.team");
-}