@north-light/crouter 0.3.173 → 0.3.175

package/dist/clients/attach/__tests__/attach-remote-readonly.test.js

@@ -1,90 +1,20 @@
-// attach-remote-readonly.test.ts — Phase 3 review Major 1: a REMOTE attach
+// attach-remote-readonly.test.ts — a REMOTE attach
 // (`crtr surface attach --canvas <name>`) must be a strictly VIEW-ONLY
-// surface. Three defenses are proven independently here:
+// surface. Two defenses are proven here:
 //
-//   A. slash/dispatch.ts's REMOTE_SAFE_BUILTIN_NAMES gate — a remote attach
-//      never even dispatches a mutating builtin slash command.
-//   B. input/controller.ts's central `emitCommand` choke point — even if a
-//      caller somehow got past A, the REAL InputController (constructed
-//      against fakes, not stubbed out) never lets a drive frame reach
-//      `hooks.onCommand`, for every input path (submit, `!bash`, Esc-abort,
-//      and every direct keybinding).
-//   C. viewer.ts's `resolveHelloRole` — the hello handshake always
-//      claims 'observer' for a remote attach, regardless of `--observer`.
+//   A. input/controller.ts's central `emitCommand` choke point — the REAL
+//      InputController (constructed against fakes, not stubbed out) never
+//      lets a drive frame reach `hooks.onCommand`, for every input path
+//      (submit, `!bash`, Esc-abort, every direct keybinding, and dequeue).
+//      The same paths emit normally when remote is false, proving the guard
+//      is conditional rather than a dead wiring.
+//   B. viewer.ts's `resolveHelloRole` — the hello handshake always claims
+//      'observer' for a remote attach, regardless of `--observer`.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { dispatchSlashCommand } from '../slash/dispatch.js';
 import { InputController } from '../input/controller.js';
+import { createViewerCapabilities } from '../input/capabilities.js';
 import { resolveHelloRole } from '../session/connection.js';
-// ---------------------------------------------------------------------------
-// Half A — slash-command gate
-// ---------------------------------------------------------------------------
-function fakeSlashContext(remote, nodeId) {
-    const notices = [];
-    const sent = [];
-    const ctx = {
-        send: (frame) => sent.push(frame),
-        notify: (m) => notices.push(m),
-        cwd: '/tmp/does-not-matter',
-        nodeId,
-        remote,
-    };
-    return { ctx, notices, sent };
-}
-const MUTATING_BUILTINS = [
-    '/new', '/compact', '/name test', '/model', '/resume', '/fork', '/tree',
-    '/settings', '/share', '/clone', '/import', '/reload', '/scoped-models',
-    '/login', '/logout', '/export',
-];
-test('dispatchSlashCommand blocks every mutating/wrong-host builtin in remote mode, never sending a frame', () => {
-    const { ctx, notices, sent } = fakeSlashContext(true, 'a');
-    for (const cmd of MUTATING_BUILTINS) {
-        notices.length = 0;
-        const handled = dispatchSlashCommand(cmd, ctx);
-        assert.equal(handled, true, `${cmd} must be handled (blocked, never forwarded to the engine as a prompt)`);
-        assert.equal(notices.length, 1, `${cmd} must notify exactly once, got: ${JSON.stringify(notices)}`);
-        assert.match(notices[0], /not available for a remote attach/, `${cmd} must produce the remote-block notice, got: ${notices[0]}`);
-    }
-    assert.equal(sent.length, 0, 'no command frame must ever reach ctx.send for a blocked remote builtin');
-});
-test('the same builtins dispatch normally in local mode (remote unaffected proof)', () => {
-    const { ctx, sent } = fakeSlashContext(false, '');
-    assert.equal(dispatchSlashCommand('/name a-new-name', ctx), true);
-    assert.equal(dispatchSlashCommand('/new', ctx), true);
-    const types = sent.map((f) => f.type);
-    assert.ok(types.includes('set_session_name'), `expected set_session_name in local mode, got ${JSON.stringify(types)}`);
-    assert.ok(types.includes('new_session'), `expected new_session in local mode, got ${JSON.stringify(types)}`);
-});
-test('/copy /session /changelog /hotkeys /quit remain reachable in remote mode (not blocked by the gate)', () => {
-    const { ctx, notices } = fakeSlashContext(true, 'a');
-    notices.length = 0;
-    ctx.state = { model: 'test-model' };
-    dispatchSlashCommand('/session', ctx);
-    assert.equal(notices.length, 1);
-    assert.ok(!/not available for a remote attach/.test(notices[0]), `/session must not hit the remote-block notice, got: ${notices[0]}`);
-    notices.length = 0;
-    dispatchSlashCommand('/changelog', ctx);
-    assert.equal(notices.length, 1);
-    assert.ok(!/not available for a remote attach/.test(notices[0]));
-    notices.length = 0;
-    dispatchSlashCommand('/hotkeys', ctx);
-    assert.equal(notices.length, 1);
-    assert.ok(!/not available for a remote attach/.test(notices[0]));
-    notices.length = 0;
-    let copied = false;
-    ctx.onCopy = () => { copied = true; };
-    dispatchSlashCommand('/copy', ctx);
-    assert.equal(copied, true, '/copy must reach its onCopy hook in remote mode');
-    notices.length = 0;
-    let quit = false;
-    ctx.onQuit = () => { quit = true; };
-    dispatchSlashCommand('/quit', ctx);
-    assert.equal(quit, true, '/quit must reach its onQuit hook in remote mode');
-});
-// ---------------------------------------------------------------------------
-// Half B — InputController's central emitCommand gate, against a REAL
-// InputController built from minimal fakes.
-// ---------------------------------------------------------------------------
 function fakeEditor() {
     const actions = new Map();
     let text = '';
@@ -101,88 +31,64 @@ function fakeEditor() {
     };
     return { obj, actions, setText: (t) => { text = t; } };
 }
-function fakeTui() {
-    return {
+function buildController(remote) {
+    const sent = [];
+    const notices = [];
+    const editor = fakeEditor();
+    const tui = {
         requestRender: () => { },
         setFocus: () => { },
         showOverlay: () => ({ hide: () => { } }),
         start: () => { },
         stop: () => { },
     };
-}
-function buildController(remote) {
-    const sent = [];
-    const notices = [];
-    const editor = fakeEditor();
-    const tui = fakeTui();
     const ic = new InputController(tui, editor.obj, {}, {
         onCommand: (f) => sent.push(f),
         onDialogResponse: () => { },
         onNotice: (m) => notices.push(m),
-        remote,
-    });
+    }, createViewerCapabilities({ role: 'controller', remote, nodeId: 'test', profileId: undefined }));
     return { ic, editor, sent, notices };
 }
-test('InputController never emits a drive frame to onCommand when remote is true — every input path', () => {
-    const { ic, editor, sent, notices } = buildController(true);
-    // 1. Text submission → would have been `prompt`.
+/** Drive every input path that can produce a broker frame. */
+function driveEveryInputPath(built) {
+    const { ic, editor } = built;
     editor.setText('');
-    editor.obj.onSubmit('hello');
-    assert.equal(sent.length, 0);
-    // 2. `!` bash → would have been `bash`.
+    editor.obj.onSubmit('hello'); // → prompt
     editor.setText('');
-    editor.obj.onSubmit('!ls');
-    assert.equal(sent.length, 0);
-    // 3. Esc while streaming → would have been `abort`.
+    editor.obj.onSubmit('!ls'); // → bash
     ic.setState({ isStreaming: true });
-    editor.obj.onEscape();
-    assert.equal(sent.length, 0);
-    // 4. Direct keybindings → new_session, cycle_model×2, cycle_thinking.
+    editor.obj.onEscape(); // → abort
     editor.actions.get('app.session.new')();
     editor.actions.get('app.model.cycleForward')();
     editor.actions.get('app.model.cycleBackward')();
     editor.actions.get('app.thinking.cycle')();
+}
+test('InputController never emits a drive frame to onCommand when remote is true — every input path', () => {
+    const built = buildController(true);
+    const { editor, sent, notices } = built;
+    driveEveryInputPath(built);
     assert.equal(sent.length, 0, `remote InputController must never emit a frame, got: ${JSON.stringify(sent)}`);
-    // 5. The gate must have actually fired (proves the hooks weren't simply
-    // never wired — a real block happened).
+    // The gate must have actually fired — proves the hooks weren't simply never wired.
     assert.ok(notices.some((n) => /Read-only remote attach/.test(n)), `expected a "Read-only remote attach" notice, got: ${JSON.stringify(notices)}`);
-    // 6. `app.message.dequeue` → handleDequeue's own remote guard (a second
-    // frame type, `dequeue`, not covered by the direct-keybinding block above).
+    // `app.message.dequeue` has its own remote guard for a second frame type.
     notices.length = 0;
     editor.actions.get('app.message.dequeue')();
     assert.equal(sent.length, 0, `remote dequeue must never emit a frame, got: ${JSON.stringify(sent)}`);
     assert.ok(notices.some((n) => /Read-only remote attach/.test(n)), `expected a "Read-only remote attach" notice from dequeue, got: ${JSON.stringify(notices)}`);
 });
-test('InputController emits the SAME drive frames normally when remote is false (local unaffected proof)', () => {
-    const { ic, editor, sent, notices } = buildController(false);
-    editor.setText('');
-    editor.obj.onSubmit('hello');
-    editor.setText('');
-    editor.obj.onSubmit('!ls');
-    ic.setState({ isStreaming: true });
-    editor.obj.onEscape();
-    editor.actions.get('app.session.new')();
-    editor.actions.get('app.model.cycleForward')();
-    editor.actions.get('app.model.cycleBackward')();
-    editor.actions.get('app.thinking.cycle')();
-    // `app.message.dequeue` locally never hits the remote guard (it falls
-    // through to the "not available in this viewer" branch since the fake
-    // hooks supply no `onRequest`) — proves handleDequeue's remote check is
-    // remote-conditional, not an unconditional block.
+test('InputController emits the same drive frames normally when remote is false (guard is conditional)', () => {
+    const built = buildController(false);
+    const { editor, sent, notices } = built;
+    driveEveryInputPath(built);
     notices.length = 0;
     editor.actions.get('app.message.dequeue')();
     assert.ok(!notices.some((n) => /Read-only remote attach/.test(n)), `local dequeue must not hit the read-only remote notice, got: ${JSON.stringify(notices)}`);
     const types = sent.map((f) => f.type);
-    assert.ok(types.includes('prompt'), `expected prompt, got ${JSON.stringify(types)}`);
-    assert.ok(types.includes('bash'), `expected bash, got ${JSON.stringify(types)}`);
-    assert.ok(types.includes('abort'), `expected abort, got ${JSON.stringify(types)}`);
-    assert.ok(types.includes('new_session'), `expected new_session, got ${JSON.stringify(types)}`);
+    for (const expected of ['prompt', 'bash', 'abort', 'new_session', 'cycle_thinking']) {
+        assert.ok(types.includes(expected), `expected ${expected}, got ${JSON.stringify(types)}`);
+    }
     assert.equal(types.filter((t) => t === 'cycle_model').length, 2, `expected two cycle_model frames, got ${JSON.stringify(types)}`);
-    assert.ok(types.includes('cycle_thinking'), `expected cycle_thinking, got ${JSON.stringify(types)}`);
 });
-// ---------------------------------------------------------------------------
-// Half C — hello role
-// ---------------------------------------------------------------------------
 test('resolveHelloRole always claims observer for remote, regardless of --observer', () => {
     assert.equal(resolveHelloRole(true, false), 'observer');
     assert.equal(resolveHelloRole(true, true), 'observer');

package/dist/clients/attach/__tests__/chat-view-snapshot-ordering.test.js

@@ -11,12 +11,14 @@
 //   2. A second welcome delivered while the first build is suspended must
 //      supersede it outright: the newest snapshot wins and the stale build
 //      abandons itself instead of appending into the replaced transcript.
-//   3. Rebuilding from a welcome snapshot must settle any live bash component;
+//   3. A tool result landing after a snapshot yield must repaint the tool row;
+//      it used to stay cached in its pending state.
+//   4. Rebuilding from a welcome snapshot must settle any live bash component;
 //      otherwise its unmounted Loader keeps requesting renders every 80 ms.
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { Container, TUI } from '@earendil-works/pi-tui';
-import { AssistantMessageComponent, ToolExecutionComponent, UserMessageComponent, initTheme, } from '@earendil-works/pi-coding-agent';
+import { AssistantMessageComponent, UserMessageComponent, initTheme, } from '@earendil-works/pi-coding-agent';
 import { ChatView } from '../render/chat-view.js';
 /** A headless terminal so TUI.requestRender's scheduled writes are no-ops (the
  *  test only inspects component state, never real output). */
@@ -62,156 +64,6 @@ function assistantSnapshot(count, tag) {
 }
 const countOf = (children, ctor) => children.filter((c) => c instanceof ctor).length;
 initTheme(undefined, false);
-test('folded tools are separated from preceding assistant prose and thinking', async () => {
-    const tui = new TUI(fakeTerminal());
-    const container = new Container();
-    const view = new ChatView(tui, container, { hideThinking: false });
-    const internals = view;
-    internals.foldSettledTools = true;
-    await view.applySnapshot({
-        messages: [
-            { role: 'assistant', content: [{ type: 'text', text: 'Prose.' }, { type: 'toolCall', id: 'text-tool', name: 'bash', arguments: { command: 'true' } }] },
-            { role: 'toolResult', toolCallId: 'text-tool', toolName: 'bash', content: [{ type: 'text', text: '' }], isError: false },
-            { role: 'assistant', content: [{ type: 'thinking', thinking: 'Think.' }, { type: 'toolCall', id: 'thinking-tool', name: 'bash', arguments: { command: 'true' } }] },
-            { role: 'toolResult', toolCallId: 'thinking-tool', toolName: 'bash', content: [{ type: 'text', text: '' }], isError: false },
-        ],
-        stats: {},
-        state: { isStreaming: false },
-    });
-    internals.applyToolDisplay();
-    const separators = internals.historyContainer.children.filter((child) => child.render(80).length === 1 && child.render(80)[0] === '');
-    assert.equal(separators.length, 2, 'both visible assistant blocks receive a folded-tool gap');
-});
-test('live bash animation survives history caching and stops on a welcome snapshot', async () => {
-    let renderRequests = 0;
-    const tui = {
-        requestRender: () => { renderRequests += 1; },
-        terminal: { rows: 24 },
-    };
-    const container = new Container();
-    const view = new ChatView(tui, container);
-    view.bashStart('sleep 999');
-    const component = view.bashComponent;
-    try {
-        const firstFrame = container.render(80).join('\n');
-        await new Promise((resolve) => setTimeout(resolve, 120));
-        const nextFrame = container.render(80).join('\n');
-        assert.notEqual(nextFrame, firstFrame, 'history caching froze the live bash animation');
-        await view.applySnapshot({
-            messages: [],
-            stats: {},
-            state: { isStreaming: false },
-        });
-        const settledRenderRequests = renderRequests;
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        assert.equal(renderRequests, settledRenderRequests, 'the unmounted bash loader kept requesting renders');
-    }
-    finally {
-        // Ensure a regression fails cleanly instead of leaving the loader interval
-        // alive until the test runner timeout.
-        component.setComplete(undefined, true);
-    }
-});
-test('dormant broker settlement clears a working activity without an agent event', () => {
-    const { view, internals } = makeChatView();
-    try {
-        view.handleEvent({ type: 'agent_start' });
-        assert.ok(internals.activityLoader, 'agent start shows working activity');
-        view.settleRun();
-        assert.equal(internals.activityLoader, undefined, 'dormant settlement clears working activity');
-    }
-    finally {
-        view.dispose();
-    }
-});
-test('activity renders keep history cached while streaming updates invalidate it', async () => {
-    const tui = {
-        requestRender() { },
-        terminal: { rows: 24 },
-    };
-    const container = new Container();
-    const view = new ChatView(tui, container);
-    try {
-        await view.applySnapshot({
-            messages: [{
-                    role: 'assistant',
-                    content: [{ type: 'text', text: 'before' }],
-                }],
-            stats: {},
-            state: { isStreaming: true },
-        });
-        const history = view.historyContainer;
-        const assistant = history.children.find((child) => child instanceof AssistantMessageComponent);
-        assert.ok(assistant);
-        const originalRender = assistant.render.bind(assistant);
-        let assistantRenderCount = 0;
-        assistant.render = (width) => {
-            assistantRenderCount += 1;
-            return originalRender(width);
-        };
-        container.render(80);
-        const cachedRenderCount = assistantRenderCount;
-        container.render(80);
-        container.render(80);
-        assert.equal(assistantRenderCount, cachedRenderCount, 'activity-only renders rebuilt the transcript');
-        view.handleEvent({
-            type: 'message_update',
-            message: { role: 'assistant', content: [{ type: 'text', text: 'after' }] },
-        });
-        const updatedLines = container.render(80);
-        assert.equal(assistantRenderCount, cachedRenderCount + 1, 'streaming update did not invalidate history');
-        assert.match(updatedLines.join('\n'), /after/);
-    }
-    finally {
-        view.dispose();
-    }
-});
-test('a tool result after a snapshot yield invalidates the cached pending tool', async () => {
-    const tui = {
-        requestRender() { },
-        terminal: { rows: 24 },
-    };
-    const container = new Container();
-    const view = new ChatView(tui, container);
-    const messages = [
-        {
-            role: 'assistant',
-            content: [{ type: 'toolCall', id: 'tool-1', name: 'unknown', arguments: {} }],
-            stopReason: 'endTurn',
-        },
-        ...Array.from({ length: 49 }, (_, i) => ({
-            role: 'assistant',
-            content: [{ type: 'text', text: `filler-${i}` }],
-            stopReason: 'endTurn',
-        })),
-        {
-            role: 'toolResult',
-            toolCallId: 'tool-1',
-            toolName: 'unknown',
-            content: [{ type: 'text', text: 'complete' }],
-            isError: false,
-        },
-    ];
-    const build = view.applySnapshot({
-        messages,
-        stats: {},
-        state: { isStreaming: false },
-    });
-    const history = view.historyContainer;
-    const tool = history.children.find((child) => child instanceof ToolExecutionComponent);
-    assert.ok(tool, 'tool call rendered before the snapshot yield');
-    const originalRender = tool.render.bind(tool);
-    let toolRenderCount = 0;
-    tool.render = (width) => {
-        toolRenderCount += 1;
-        return originalRender(width);
-    };
-    container.render(80);
-    const pendingRenderCount = toolRenderCount;
-    await build;
-    container.render(80);
-    assert.equal(toolRenderCount, pendingRenderCount + 1, 'completed tool result remained cached as pending');
-});
 test('live turn frames arriving during a yielded welcome replay after the build and keep live state', async () => {
     const { view, historyChildren, internals } = makeChatView();
     // Start a large non-streaming catch-up: it appends the first chunk of
@@ -254,3 +106,70 @@ test('a second welcome delivered mid-build supersedes the first and the stale bu
     assert.equal(countOf(children, AssistantMessageComponent), 3, 'newest welcome wins; no interleaved stale tail');
     assert.equal(internals.applyingSnapshot, false, 'gate released');
 });
+test('a tool result after a snapshot yield repaints the tool row instead of staying pending', async () => {
+    const tui = {
+        requestRender() { },
+        terminal: { rows: 24 },
+    };
+    const container = new Container();
+    const view = new ChatView(tui, container);
+    const messages = [
+        {
+            role: 'assistant',
+            content: [{ type: 'toolCall', id: 'tool-1', name: 'unknown', arguments: {} }],
+            stopReason: 'endTurn',
+        },
+        ...Array.from({ length: 49 }, (_, i) => ({
+            role: 'assistant',
+            content: [{ type: 'text', text: `filler-${i}` }],
+            stopReason: 'endTurn',
+        })),
+        {
+            role: 'toolResult',
+            toolCallId: 'tool-1',
+            toolName: 'unknown',
+            content: [{ type: 'text', text: 'RESULT-LANDED' }],
+            isError: false,
+        },
+    ];
+    const build = view.applySnapshot({
+        messages,
+        stats: {},
+        state: { isStreaming: false },
+    });
+    // Render mid-build so the pending tool row lands in the render cache.
+    const pending = container.render(80).join('\n');
+    assert.doesNotMatch(pending, /RESULT-LANDED/, 'the result has not arrived yet mid-build');
+    await build;
+    assert.match(container.render(80).join('\n'), /RESULT-LANDED/, 'completed tool result remained cached as pending');
+});
+test('live bash animation survives history caching and stops on a welcome snapshot', async () => {
+    let renderRequests = 0;
+    const tui = {
+        requestRender: () => { renderRequests += 1; },
+        terminal: { rows: 24 },
+    };
+    const container = new Container();
+    const view = new ChatView(tui, container);
+    view.bashStart('sleep 999');
+    const component = view.bashComponent;
+    try {
+        const firstFrame = container.render(80).join('\n');
+        await new Promise((resolve) => setTimeout(resolve, 120));
+        const nextFrame = container.render(80).join('\n');
+        assert.notEqual(nextFrame, firstFrame, 'history caching froze the live bash animation');
+        await view.applySnapshot({
+            messages: [],
+            stats: {},
+            state: { isStreaming: false },
+        });
+        const settledRenderRequests = renderRequests;
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        assert.equal(renderRequests, settledRenderRequests, 'the unmounted bash loader kept requesting renders');
+    }
+    finally {
+        // Ensure a regression fails cleanly instead of leaving the loader interval
+        // alive until the test runner timeout.
+        component.setComplete(undefined, true);
+    }
+});