@indianic/dialout 1.10.0 → 1.12.0

package/node_modules/@indianic/dialout-shared/src/notices.ts

@@ -0,0 +1,159 @@
+import { thinkingDuration } from './thinking';
+
+// Not every "user" message in a transcript came from a person.
+//
+// The CLIs inject their own machinery into the user role: a background task
+// finishing, a subagent handing its report back, a slash command, the output
+// of a local command, a reminder the harness wants the model to re-read. Each
+// arrives as an XML-ish frame, and rendering those frames verbatim is what
+// filled the chat with `<task-notification>` and `<tool-use-id>` instead of
+// the one line the terminal prints for the same event.
+//
+// So a user message is read before it is rendered. It comes back as the
+// person's words, as a one-line notice with the detail folded away, or as
+// nothing at all — the terminal shows no trace of a system reminder and
+// neither should we. The body kept on a notice is markdown, dedented, ready
+// for the same renderer that draws an agent's reply.
+
+export type NoticeKind = 'task' | 'handback' | 'session' | 'command' | 'output' | 'compact';
+
+export interface MessageNotice {
+  kind: NoticeKind;
+  /** The single line, the way the terminal would print it. */
+  label: string;
+  /** What the line earns a suffix for: a duration, a tool count, an id. */
+  detail?: string;
+  /** Markdown worth keeping behind a toggle; absent means nothing to open. */
+  body?: string;
+}
+
+export type ReadMessage =
+  | { kind: 'text'; text: string }
+  | { kind: 'notice'; notice: MessageNotice }
+  | { kind: 'hidden' };
+
+/** Reminders are a frame around other content as often as they are content. */
+const REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+const CAVEAT = /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g;
+const HANDBACK_FRAME = 'The report follows:';
+
+function tag(src: string, name: string): string {
+  const m = new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(src);
+  return m ? m[1].trim() : '';
+}
+
+/**
+ * Strip the indent a frame added, so the markdown inside survives.
+ *
+ * The hand-back frame indents every line of a subagent's report by two
+ * spaces — deliberately, so a forged frame line at column zero is visible.
+ * Left in place that indent turns the report's `- ` bullets into continuation
+ * lines and its fenced blocks into something the parser never reaches.
+ */
+export function dedent(src: string): string {
+  const lines = String(src || '').replace(/\r\n?/g, '\n').split('\n')
+    .map((l) => l.replace(/\t/g, '  '));
+  let min = Infinity;
+  for (const l of lines) {
+    if (!l.trim()) continue;
+    min = Math.min(min, (/^ */.exec(l) as RegExpExecArray)[0].length);
+  }
+  if (!isFinite(min) || min === 0) return lines.join('\n').trim();
+  return lines.map((l) => (l.trim() ? l.slice(min) : '')).join('\n').trim();
+}
+
+function taskNotice(src: string): MessageNotice {
+  const n = src.slice(src.indexOf('<task-notification>'));
+  const summary = tag(n, 'summary');
+  const status = tag(n, 'status');
+  const ms = Number(tag(n, 'duration_ms') || 0);
+  const tools = Number(tag(n, 'tool_uses') || 0);
+  const bits: string[] = [];
+  if (ms > 0) bits.push(thinkingDuration(ms));
+  if (tools > 0) bits.push(`${tools} tool${tools === 1 ? '' : 's'}`);
+  // The result is usually a pointer to the report rather than the report, and
+  // the note explains the lifecycle. Both are worth keeping, neither is worth
+  // a line of its own.
+  const body = [tag(n, 'result'), tag(n, 'note')].filter(Boolean).join('\n\n');
+  return {
+    kind: 'task',
+    label: summary || (status ? `Background task ${status}` : 'Background task'),
+    detail: bits.join(' · ') || undefined,
+    body: body || undefined,
+  };
+}
+
+function handbackNotice(src: string, from: string): MessageNotice {
+  const open = /<agent-message from="([^"]*)">/.exec(src);
+  let body = open ? src.slice((open.index ?? 0) + open[0].length) : src;
+  body = body.replace(/<\/agent-message>\s*$/, '');
+  const handback = body.includes('[Subagent hand-back]');
+  // Everything before "The report follows:" is the harness explaining that
+  // the report carries no user authority. True, and already enforced by the
+  // fact that we render it as a notice rather than as a request.
+  const at = body.indexOf(HANDBACK_FRAME);
+  if (at >= 0) body = body.slice(at + HANDBACK_FRAME.length);
+  const who = (from || '').trim();
+  return {
+    kind: handback ? 'handback' : 'session',
+    label: handback ? 'Report from a delegated agent' : 'Message from another session',
+    detail: who || undefined,
+    body: dedent(body) || undefined,
+  };
+}
+
+/**
+ * What to draw for one user-role message.
+ *
+ * Order matters: a task notification usually arrives wrapped in a reminder,
+ * and a slash command carries its own stdout, so the frames are peeled before
+ * anything is matched and the more specific shape is tested first.
+ */
+export function readUserMessage(raw: string): ReadMessage {
+  const full = String(raw || '').replace(/\r\n?/g, '\n');
+  const src = full.replace(REMINDER, '\n').replace(CAVEAT, '\n').trim();
+  if (!src) return { kind: 'hidden' };
+
+  if (src.includes('<task-notification>')) {
+    return { kind: 'notice', notice: taskNotice(src) };
+  }
+
+  const from = /<agent-message from="([^"]*)">/.exec(src);
+  if (from || src.startsWith('Another Claude session sent a message')) {
+    return { kind: 'notice', notice: handbackNotice(src, from ? from[1] : '') };
+  }
+
+  if (src.includes('<command-name>')) {
+    const name = tag(src, 'command-name');
+    const args = tag(src, 'command-args');
+    const out = tag(src, 'local-command-stdout');
+    return {
+      kind: 'notice',
+      notice: {
+        kind: 'command',
+        label: [name || 'Command', args].filter(Boolean).join(' '),
+        body: out || undefined,
+      },
+    };
+  }
+
+  if (src.includes('<local-command-stdout>')) {
+    const out = tag(src, 'local-command-stdout');
+    return { kind: 'notice', notice: { kind: 'output', label: 'Command output', body: out || undefined } };
+  }
+
+  if (src.includes('<tools-used-before-summary>')
+    || src.startsWith('This session is being continued from a previous conversation')) {
+    return {
+      kind: 'notice',
+      notice: { kind: 'compact', label: 'Earlier conversation summarised', body: src },
+    };
+  }
+
+  // A frame we do not know, with nothing but tags inside it, is machinery too.
+  if (/^<[a-z][\w-]*>/.test(src) && !/[^\s<>/\w-]/.test(src.replace(/<[^>]*>/g, ''))) {
+    return { kind: 'hidden' };
+  }
+
+  return { kind: 'text', text: src };
+}

package/node_modules/@indianic/dialout-shared/src/pane-prompt.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { detectPanePrompt, isSafeKeyList, promptKeys } from './pane-prompt';
+import { detectPanePrompt, freeTextRow, isFreeTextOption, isSafeKeyList, promptKeys, promptMoveKeys } from './pane-prompt';
 
 // Shapes as the CLIs draw them (spacing kept), plus the noise around them.
 const CLAUDE_BASH = `
@@ -177,3 +177,25 @@ describe('promptKeys', () => {
     expect(isSafeKeyList('Enter')).toBe(false);
   });
 });
+
+describe('free-text rows', () => {
+  it('knows which rows want typing, and moves there without choosing', () => {
+    expect(isFreeTextOption('Type something.')).toBe(true);
+    expect(isFreeTextOption('Other')).toBe(true);
+    expect(isFreeTextOption('No, and tell Claude what to do differently (esc)')).toBe(false);
+    expect(isFreeTextOption('Yes')).toBe(false);
+    const p = detectPanePrompt(CLAUDE_QUESTION)!;
+    expect(promptMoveKeys(p, 3)).toEqual(['Down', 'Down']);
+    expect(promptMoveKeys(p, 1)).toEqual([]);
+  });
+
+  it('finds the row that wants typing, and stops once it holds text', () => {
+    const p = detectPanePrompt(CLAUDE_QUESTION)!;
+    expect(freeTextRow(p)).toBe(3);
+    // The TUI echoes what is typed in place of the label; the row is then
+    // mid-answer, not an empty invitation, so the card must not reopen on it.
+    const typed = detectPanePrompt(CLAUDE_QUESTION.replace('3. Type something.', '3. Teal like the sea'))!;
+    expect(freeTextRow(typed)).toBe(0);
+    expect(freeTextRow(detectPanePrompt(CLAUDE_BASH)!)).toBe(0);
+  });
+});

package/node_modules/@indianic/dialout-shared/src/pane-prompt.ts

@@ -216,3 +216,30 @@ export function promptKeys(p: PanePrompt, n: number): string[] {
   const move = to > from ? Array(to - from).fill('Down') : Array(from - to).fill('Up');
   return [...move, 'Enter'];
 }
+
+/**
+ * A row that takes typed text rather than being an answer itself: Claude
+ * Code's "Type something." / an "Other" row. Picking it with Enter answers
+ * with nothing, so the card asks for the text first.
+ */
+export function isFreeTextOption(label: string): boolean {
+  return /^(type something|type your own|other|something else)\.?(\s*\(.*\))?$/i.test(label.trim());
+}
+
+/**
+ * Keys that put the cursor on row `n` without choosing it. For a free-text
+ * row: move there, then the text is typed and Enter pressed (as one message).
+ */
+export function promptMoveKeys(p: PanePrompt, n: number): string[] {
+  return promptKeys(p, n).slice(0, -1);
+}
+
+/**
+ * The free-text row's number, or 0 if the menu has none. A TUI echoes what is
+ * typed in place of that row's label, so a row that already holds text no
+ * longer matches — which is correct: it is mid-answer, not an empty invitation.
+ */
+export function freeTextRow(p: PanePrompt): number {
+  const row = p.options.find((o) => o.checked === null && isFreeTextOption(o.label));
+  return row ? row.n : 0;
+}

package/node_modules/@indianic/dialout-shared/src/thinking.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { thinkingDuration, thinkingLabel } from './thinking';
+
+describe('thinkingDuration', () => {
+  it('reads like a stopwatch at every scale', () => {
+    expect(thinkingDuration(490)).toBe('490ms');
+    expect(thinkingDuration(1422)).toBe('1.4s');
+    expect(thinkingDuration(12252)).toBe('12s');
+    expect(thinkingDuration(59_400)).toBe('59s');
+    expect(thinkingDuration(60_000)).toBe('1m');
+    expect(thinkingDuration(125_000)).toBe('2m 5s');
+  });
+
+  it('says nothing rather than "0s" when there is no duration to report', () => {
+    expect(thinkingDuration(0)).toBe('');
+    expect(thinkingDuration(-5)).toBe('');
+    expect(thinkingDuration(NaN)).toBe('');
+    expect(thinkingDuration(Infinity)).toBe('');
+  });
+});
+
+describe('thinkingLabel', () => {
+  it('names the duration when the vendor gave one', () => {
+    expect(thinkingLabel(1422)).toBe('Thought for 1.4s');
+    expect(thinkingLabel(12252)).toBe('Thought for 12s');
+  });
+
+  it('falls back to the vague wording, never a bare "thinking…"', () => {
+    expect(thinkingLabel(undefined)).toBe('Thought for a moment');
+    expect(thinkingLabel(0)).toBe('Thought for a moment');
+  });
+});

package/node_modules/@indianic/dialout-shared/src/thinking.ts

@@ -0,0 +1,32 @@
+// How a spell of reasoning is labelled in the transcript.
+//
+// Most of it never reaches us. Claude Code runs adaptive thinking with a
+// `clear_thinking_20251015` context edit, which strips the words out of the
+// persisted history and leaves a signed, empty block behind — measured at 515
+// of 615 blocks in one real session. Codex and Grok encrypt theirs outright.
+// So a thinking row usually has no words to show, only the fact that it
+// happened and `thinkingDurationMs` saying how long for. That is worth
+// showing: it is the difference between an agent that is stuck and one that is
+// thinking hard.
+
+/** "1.4s", "12s", "2m 5s" — the duration Claude Code reports for a turn. */
+export function thinkingDuration(ms: number): string {
+  if (!Number.isFinite(ms) || ms <= 0) return '';
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  const s = ms / 1000;
+  if (s < 10) return `${s.toFixed(1)}s`;
+  if (s < 60) return `${Math.round(s)}s`;
+  const m = Math.floor(s / 60);
+  const rest = Math.round(s % 60);
+  return rest ? `${m}m ${rest}s` : `${m}m`;
+}
+
+/**
+ * The label for a thinking row. "Thought for 1.4s" when the vendor said how
+ * long, and the vaguer wording only when it did not — never a bare
+ * "thinking…", which read as though something were still in flight.
+ */
+export function thinkingLabel(ms?: number): string {
+  const d = ms == null ? '' : thinkingDuration(ms);
+  return d ? `Thought for ${d}` : 'Thought for a moment';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Dialout agent — reach your office, home or build machine from any browser or phone. Remote tmux terminals, live port checks, filesystem browsing, process control and HTTP tunnels. The agent dials out: no inbound ports, no VPN, no port forwarding.",
   "bin": {
     "dialout": "./bin/devdash-agent.js"