@crouton-kit/crouter 0.3.61 → 0.3.63

package/dist/builtin-views/canvas/core.mjs

@@ -62,7 +62,7 @@
  * @typedef {Object} Fault
  * @property {'pi→provider'|'viewer↔broker'|'relay↔broker'|'browser↔relay'|'cli→exa'|'daemon→node'} link
  * @property {string} op
- * @property {'rate-limit'|'overloaded'|'connection'|'auth'|'protocol'|'other'|'wedged'} kind
+ * @property {'rate-limit'|'overloaded'|'connection'|'auth'|'protocol'|'other'|'wedged'|'model-not-found'} kind
  * @property {FaultRetry} retry
  * @property {string} message  The raw engine error (capped).
  * @property {string} since    ISO 8601 — when the fault was first observed.
@@ -189,6 +189,7 @@ export function hangingLabel(kind) {
   if (kind === 'auth') return 'auth';
   if (kind === 'protocol') return 'protocol';
   if (kind === 'wedged') return 'wedged';
+  if (kind === 'model-not-found') return 'model-not-found';
   return 'other';
 }
 

package/dist/clients/attach/__tests__/context-message.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/context-message.test.js

@@ -0,0 +1,46 @@
+// Regression coverage for the attach viewer's collapsed hidden-context
+// rendering (context-message.ts + its dispatch in chat-view.ts).
+//
+// Both hidden-context custom types — `crtr-context` (fresh-birth bearings) and
+// `crtr-situational-context` (an existing node's ambient update, sent by
+// canvas-inbox-watcher.ts) — must render through the same collapsed
+// ContextMessageComponent, never the generic always-expanded
+// CustomMessageComponent: body text stays hidden until the user expands it
+// (Ctrl+O). These tests pin (a) the collapsed component itself never leaks
+// body text before expansion, for both labels it serves, and (b)
+// chat-view.ts's source wires the situational customType to that same
+// collapsed component (a full ChatView needs a live TUI/Container from
+// pi-tui, so this source-contract check is the smallest meaningful assertion
+// of the dispatch).
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { ContextMessageComponent } from '../context-message.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CHAT_VIEW = readFileSync(join(HERE, '..', 'chat-view.ts'), 'utf8');
+const identity = (s) => s;
+test('collapsed by default: body text is not rendered until expanded', () => {
+    const body = '<situational-context>\nthe user is mid-checkout\n</situational-context>';
+    const collapsed = new ContextMessageComponent(body, false, identity, identity, 'situational context', ' hint');
+    const collapsedLines = collapsed.render(80).join('\n');
+    assert.match(collapsedLines, /\[situational context\]/);
+    assert.doesNotMatch(collapsedLines, /mid-checkout/, 'collapsed state must never leak the body');
+    collapsed.setExpanded(true);
+    const expandedLines = collapsed.render(80).join('\n');
+    assert.match(expandedLines, /mid-checkout/, 'expanded state (Ctrl+O) still shows the full body — the LLM-visible content is never lost, only the default view folds it');
+});
+test('the crtr-context label/hint keep their defaults when callers omit the new params', () => {
+    const bearings = new ContextMessageComponent('some bearings body', false, identity, identity);
+    const line = bearings.render(80).join('\n');
+    assert.match(line, /\[crtr context\]/);
+    assert.match(line, /orienting bearings/);
+});
+test('chat-view.ts dispatches the situational customType to the collapsed component, not the generic fallback', () => {
+    assert.match(CHAT_VIEW, /SITUATIONAL_CONTEXT_CUSTOM_TYPE/, 'must reference the constant, not a duplicated literal');
+    const situationalBranch = CHAT_VIEW.slice(CHAT_VIEW.indexOf('customType === SITUATIONAL_CONTEXT_CUSTOM_TYPE'));
+    const nextBraceClose = situationalBranch.indexOf('\n          }');
+    const branchBody = situationalBranch.slice(0, nextBraceClose === -1 ? undefined : nextBraceClose);
+    assert.match(branchBody, /new ContextMessageComponent\(/, 'must render collapsed via the same component crtr-context uses, not CustomMessageComponent');
+});

package/dist/clients/attach/__tests__/transport-relay.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/transport-relay.test.js

@@ -0,0 +1,176 @@
+// transport-relay.test.ts — mock-relay coverage for RelayTransport
+// (`../transport-relay.ts`), the REMOTE half of the attach Transport seam.
+// Fast tier: a plain `ws` WebSocketServer standing in for model-auth-front's
+// relay, no pi boot, no broker. Exercises exactly what the handoff doc
+// flagged as unverified: the Authorization header, the one-JSON-frame-per-
+// WS-message wire, the 1011/1008 "gone" close-code classification (and its
+// NOT-gone counterparts), and a non-101 handshake response (bad token) not
+// hanging connect().
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { WebSocketServer } from 'ws';
+import { RelayTransport } from '../transport-relay.js';
+import { BrokerUnavailableError } from '../transport.js';
+/** Stand up a bare `ws` server on an ephemeral loopback port — the "relay" a
+ *  RelayTransport dials. Records the Authorization header + accepted sockets
+ *  of every connection so a test can assert on the wire, not just behavior. */
+function startMockRelay() {
+    return new Promise((resolve) => {
+        const wss = new WebSocketServer({ port: 0 });
+        const authHeaders = [];
+        const sockets = [];
+        wss.on('connection', (ws, req) => {
+            authHeaders.push(req.headers.authorization ?? '');
+            sockets.push(ws);
+        });
+        wss.once('listening', () => {
+            const addr = wss.address();
+            const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
+            resolve({
+                target: { previewEndpoint: `http://127.0.0.1:${port}`, relayToken: 'test-token' },
+                authHeaders,
+                sockets,
+                close: () => new Promise((res) => wss.close(() => res())),
+            });
+        });
+    });
+}
+/** Race connect/error the SAME way `attach-cmd.ts`'s runAttach does, cleaning
+ *  up whichever listener didn't fire so later `once('error', ...)` assertions
+ *  in the same test see only the events they're meant to. */
+function connectTransport(transport) {
+    return new Promise((resolve, reject) => {
+        const onConnect = () => {
+            transport.off('error', onError);
+            resolve();
+        };
+        const onError = (err) => {
+            transport.off('connect', onConnect);
+            reject(err);
+        };
+        transport.once('connect', onConnect);
+        transport.once('error', onError);
+        transport.connect();
+    });
+}
+test('RelayTransport sends Authorization: Bearer <token> on connect', async () => {
+    const relay = await startMockRelay();
+    const transport = new RelayTransport('node-auth', relay.target);
+    await connectTransport(transport);
+    assert.equal(relay.authHeaders[0], 'Bearer test-token');
+    transport.destroy();
+    await relay.close();
+});
+test('RelayTransport round-trips one JSON frame per WS message, both directions', async () => {
+    const relay = await startMockRelay();
+    const transport = new RelayTransport('node-echo', relay.target);
+    await connectTransport(transport);
+    // server → client: one broker-protocol frame, one WS message.
+    const ack = { type: 'ack', for: 'hello', ok: true, detail: 'welcome' };
+    const framePromise = new Promise((resolve) => transport.once('frame', resolve));
+    relay.sockets[0].send(JSON.stringify(ack));
+    assert.deepEqual(await framePromise, ack);
+    // client → server: send() produces exactly one WS text message per frame.
+    const hello = { type: 'hello', role: 'controller', client_id: 'c1' };
+    const serverMessages = [];
+    relay.sockets[0].on('message', (data) => serverMessages.push(JSON.parse(data.toString())));
+    transport.send(hello);
+    await new Promise((r) => setTimeout(r, 50));
+    assert.deepEqual(serverMessages, [hello]);
+    transport.destroy();
+    await relay.close();
+});
+test('a 1011 close with "no running broker for <id>" surfaces BrokerUnavailableError', async () => {
+    const relay = await startMockRelay();
+    const transport = new RelayTransport('node-gone', relay.target);
+    await connectTransport(transport);
+    const errorPromise = new Promise((resolve) => transport.once('error', resolve));
+    relay.sockets[0].close(1011, 'no running broker for node-gone');
+    const err = await errorPromise;
+    assert.ok(err instanceof BrokerUnavailableError, `expected BrokerUnavailableError, got ${err}`);
+    await relay.close();
+});
+test('a 1000 normal close does NOT surface BrokerUnavailableError', async () => {
+    const relay = await startMockRelay();
+    const transport = new RelayTransport('node-normal', relay.target);
+    await connectTransport(transport);
+    let sawError;
+    transport.on('error', (err) => {
+        sawError = err;
+    });
+    const closePromise = new Promise((resolve) => transport.once('close', resolve));
+    relay.sockets[0].close(1000, 'normal');
+    await closePromise;
+    assert.equal(sawError, undefined);
+    await relay.close();
+});
+test('an immediate post-upgrade 1011 "no node <id>" close is still caught by a listener installed BEFORE connect() is dialed', async () => {
+    // Mirrors server.ts's bridgeConnection exactly: the relay ACCEPTS the WS
+    // upgrade unconditionally, then discovers synchronously (no data exchange,
+    // no delay from app logic) that the node doesn't exist and closes 1011 —
+    // in the SAME tick the 'connection' handler runs. This is the ordering that
+    // broke `attach-cmd.ts`'s original startup race: the transport's 'connect'
+    // (WS 'open') is structurally guaranteed to fire before any close frame can
+    // be parsed (a close can't precede the handshake that establishes the
+    // connection), so a TEMPORARY connect-race listener torn down as soon as
+    // 'connect' resolves always misses this close. The fix installs a listener
+    // that is never removed instead — reproduced here.
+    const wss = new WebSocketServer({ port: 0 });
+    wss.on('connection', (ws) => {
+        ws.close(1011, 'no node node-gone-fast');
+    });
+    await new Promise((resolve) => wss.once('listening', resolve));
+    const addr = wss.address();
+    const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
+    const transport = new RelayTransport('node-gone-fast', {
+        previewEndpoint: `http://127.0.0.1:${port}`,
+        relayToken: 'test-token',
+    });
+    // Reproduce attach-cmd.ts's durable-listener fix: installed BEFORE
+    // connect() is dialed, and never removed — exactly the guard that survives
+    // the gap a temporary connect-race listener does not.
+    let terminalError;
+    transport.on('error', (err) => {
+        if (terminalError === undefined)
+            terminalError = err;
+    });
+    await new Promise((resolve) => {
+        transport.once('connect', resolve);
+        transport.connect();
+    });
+    // Proves the structural ordering the fix accounts for: 'connect' has ALREADY
+    // resolved here, before the close was ever observed — a naive connect-race
+    // would have already declared success and torn down its error listener.
+    // Compare a boolean rather than `terminalError` itself — `assert.equal`'s
+    // TS signature asserts the narrowed type on its first argument, which would
+    // otherwise wrongly pin `terminalError` to `undefined` for the rest of this
+    // test even though the listener above can still reassign it.
+    assert.equal(terminalError === undefined, true, "connect resolves before the close is observed — that's the bug");
+    // The close lands shortly after — caught by the durable listener, not a
+    // fresh temporary one (there is none left by now).
+    await new Promise((resolve) => transport.once('close', resolve));
+    assert.ok(terminalError !== undefined && terminalError instanceof BrokerUnavailableError, `expected the durable listener to have recorded a BrokerUnavailableError, got ${terminalError}`);
+    transport.destroy();
+    await new Promise((res) => wss.close(() => res()));
+});
+test('a non-101 handshake response (401, bad token) rejects connect() with a clear error, not a hang', async () => {
+    const wss = new WebSocketServer({
+        port: 0,
+        verifyClient: (_info, cb) => cb(false, 401, 'unauthorized'),
+    });
+    await new Promise((resolve) => wss.once('listening', resolve));
+    const addr = wss.address();
+    const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
+    const transport = new RelayTransport('node-401', {
+        previewEndpoint: `http://127.0.0.1:${port}`,
+        relayToken: 'bad-token',
+    });
+    const outcome = await Promise.race([
+        connectTransport(transport).then(() => 'connected', (err) => err),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timed out — connect() hung on a non-101 handshake response')), 3000)),
+    ]);
+    assert.notEqual(outcome, 'connected');
+    assert.ok(outcome instanceof Error);
+    assert.match(outcome.message, /relay transport error/);
+    await new Promise((res) => wss.close(() => res()));
+});