@semalt-ai/code 1.19.0 → 1.20.1

package/test/chat-history-nocolor.test.js

@@ -0,0 +1,155 @@
+'use strict';
+
+// NO_COLOR sweep for lib/ui/chat-history.js chrome.
+//
+// Two-sided per surface (mirrors theme-palette.test.js): under NO_COLOR=1 (or
+// non-TTY) every chrome site must emit ZERO ANSI, while a colour-ON render must
+// still carry an `\x1b[` escape — proving the gate is CONDITIONAL, not a blanket
+// strip. Glyphs (✓ ✗ ● ⚠ •) are NOT colour and must survive into NO_COLOR.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { ChatHistory } = require('../lib/ui/chat-history');
+const { UI_ICONS } = require('../lib/ui/theme');
+
+// Render one message through a ChatHistory, capturing everything that would
+// reach scrollback (incl. any committed detail band). Seams overridden the same
+// way the class documents for tests (_commit / _setDetail / _commitDetail).
+function render(msg, { color }) {
+  const origTTY = process.stdout.isTTY;
+  const origNoColor = process.env.NO_COLOR;
+  if (color) {
+    process.stdout.isTTY = true;
+    delete process.env.NO_COLOR;
+  } else {
+    process.stdout.isTTY = true;       // TTY on, NO_COLOR forces it off
+    process.env.NO_COLOR = '1';
+  }
+  try {
+    const h = new ChatHistory();
+    const chunks = [];
+    h._commit = (t) => chunks.push(t);
+    h._setDetail = () => {};
+    h._commitDetail = (t) => { if (t) chunks.push(t); };
+    h.addMessage(msg);
+    return chunks.join('');
+  } finally {
+    process.stdout.isTTY = origTTY;
+    if (origNoColor === undefined) delete process.env.NO_COLOR;
+    else process.env.NO_COLOR = origNoColor;
+  }
+}
+
+// Assert the gate is conditional for a given message: plain under NO_COLOR,
+// escaped under colour-ON. `glyphs` (if any) must appear in BOTH renders.
+function assertGated(label, msg, glyphs = []) {
+  const off = render(msg, { color: false });
+  const on = render(msg, { color: true });
+  assert.ok(!off.includes('\x1b'), `${label}: zero ANSI under NO_COLOR`);
+  assert.ok(on.includes('\x1b['), `${label}: colour-ON still emits ANSI`);
+  for (const g of glyphs) {
+    assert.ok(off.includes(g), `${label}: glyph ${JSON.stringify(g)} survives NO_COLOR`);
+    assert.ok(on.includes(g), `${label}: glyph ${JSON.stringify(g)} present colour-ON`);
+  }
+}
+
+// (a) user bubble — also the EL (\x1b[K) must be gone, not just the SGR colours.
+test('user bubble: gated, and NO_COLOR carries no stray EL escape', () => {
+  const msg = { role: 'user', content: 'hello\nworld', ts: new Date('2026-06-22T10:00:00Z') };
+  assertGated('user bubble', msg);
+  const off = render(msg, { color: false });
+  assert.ok(!off.includes('\x1b[K'), 'no erase-to-EOL leaks under NO_COLOR');
+  assert.ok(!off.includes('\x1b'), 'user bubble is byte-clean of every escape');
+  const on = render(msg, { color: true });
+  assert.ok(on.includes('\x1b[K'), 'EL still present colour-ON (fills bg tint to edge)');
+});
+
+// (b) tool summary — both the history (summarizeToolResult) and legacy-header
+// branches. Status glyph must survive.
+test('tool summary (history branch): gated, ✓ glyph preserved', () => {
+  assertGated('tool summary history', { role: 'tool', content: 'Read 5 lines' }, [UI_ICONS.success]);
+});
+
+test('tool summary (legacy header branch): gated, ✓ glyph + category preserved', () => {
+  const msg = { role: 'tool', tag: 'read_file', content: 'foo.js', output: 'line one\n' };
+  assertGated('tool summary legacy', msg, [UI_ICONS.success]);
+  const off = render(msg, { color: false });
+  assert.ok(off.includes('file:'), 'category label still rendered under NO_COLOR');
+});
+
+// (c) shell echo.
+test('shell echo: gated', () => {
+  assertGated('shell echo', { role: 'shell', cmd: 'ls -la', content: 'file1\nfile2' });
+});
+
+// (d) permission message — ⚠ glyph preserved.
+test('permission message: gated, ⚠ glyph preserved', () => {
+  assertGated('permission', { role: 'permission', content: 'approve shell?' }, [UI_ICONS.warn]);
+});
+
+// (e) system/fallback error — ✗ glyph preserved, multi-line continuation gated.
+test('system/fallback error: gated, ✗ glyph preserved', () => {
+  assertGated('system error', { role: 'system', isError: true, content: 'boom\ndetail line' }, [UI_ICONS.error]);
+});
+
+// (f) output-preview band (collapsible shell/MCP/subagent body).
+//
+// The band's BODY lines route their content through formatOutputPreview →
+// truncateVisible (lib/ui/utils.js). truncateVisible now appends its defensive
+// `\x1b[0m` ONLY when the (possibly truncated) output already contains an escape
+// (content-conditional), so for escape-free body content the band is fully
+// escape-clean under NO_COLOR — body lines included. We assert that here in
+// addition to this file's own chrome gating (DIM / subtle / FG_DARK wrappers).
+//
+// A tool's output can carry the child process's OWN SGR escapes into the body.
+// formatOutputPreview now strips those under NO_COLOR (a stripAnsi pass gated on
+// colorEnabled, BEFORE truncateVisible) so the body line is byte-clean; with
+// colour on the captured colour is preserved. Asserted two-sided below.
+//
+// NOTE (out of scope, deferred): the strip is SGR-only (the shared stripAnsi
+// regex /\x1b\[[^m]*m/g). A non-SGR escape in the body (EL `\x1b[K`, cursor
+// moves, OSC titles) is NOT removed and would still trip truncateVisible's
+// defensive RST, so such a line would not be fully byte-clean under NO_COLOR.
+// Closing that needs a broader strip with over-stripping/measurement trade-offs.
+const DIM = '\x1b[2m';
+const SUBTLE = '\x1b[38;5;244m';
+const FG_DARK = '\x1b[38;5;240m';
+
+test('output-preview band: escape-free body is fully clean under NO_COLOR; chrome gated', () => {
+  const output = ['l1', 'l2', 'l3', 'l4', 'l5', 'l6'].join('\n');
+  const msg = { role: 'tool', output, previewLines: 2 };
+  const off = render(msg, { color: false });
+  const on = render(msg, { color: true });
+  // None of this file's chrome colours leak when colour is off.
+  for (const code of [DIM, SUBTLE, FG_DARK]) {
+    assert.ok(!off.includes(code), `band chrome ${JSON.stringify(code)} gated under NO_COLOR`);
+  }
+  // With escape-free body content the WHOLE band — body lines + hint — is now
+  // byte-clean of every escape (no residual truncateVisible RST leak).
+  assert.ok(!off.includes('\x1b'), 'whole band is escape-clean under NO_COLOR for escape-free body');
+  const bodyLine = off.split('\n').find((l) => l.includes('l1'));
+  assert.ok(bodyLine && !bodyLine.includes('\x1b'), 'preview body line carries no trailing RST under NO_COLOR');
+  const hint = off.split('\n').find((l) => l.includes('more lines'));
+  assert.ok(hint && !hint.includes('\x1b'), 'the "… more lines" hint is escape-clean');
+  // Colour-ON still paints the chrome — proving the gate is conditional.
+  assert.ok(on.includes(DIM) && on.includes(SUBTLE), 'band chrome present colour-ON');
+});
+
+// (g) subprocess ANSI in the body — the leak this fix closes. A child process's
+// own SGR (e.g. a coloured compiler/test line) is stripped under NO_COLOR so the
+// body line is byte-clean, and preserved when colour is on.
+test('output-preview band: subprocess SGR stripped under NO_COLOR, preserved colour-ON', () => {
+  const output = ['\x1b[31mred\x1b[0m line', 'plain line'].join('\n');
+  const msg = { role: 'tool', output, previewLines: 5 };
+  const off = render(msg, { color: false });
+  const on = render(msg, { color: true });
+  // Under NO_COLOR the body line carrying subprocess SGR is fully escape-clean.
+  const offBody = off.split('\n').find((l) => l.includes('red'));
+  assert.ok(offBody, 'the subprocess-coloured body line is rendered');
+  assert.ok(!offBody.includes('\x1b'), 'subprocess SGR stripped from body under NO_COLOR');
+  assert.ok(!off.includes('\x1b'), 'whole band escape-clean under NO_COLOR with subprocess SGR input');
+  // Colour-ON preserves the captured command colour in the body.
+  const onBody = on.split('\n').find((l) => l.includes('red'));
+  assert.ok(onBody && onBody.includes('\x1b[31m'), 'command colour preserved in body colour-ON');
+});

package/test/chat-relogin.test.js

@@ -0,0 +1,207 @@
+'use strict';
+
+// Coverage for the relogin chat-context reset + 404 self-heal on save.
+// Root cause: /logout and /login did NOT reset ctx.currentChatId, so a stale id
+// survived a relogin and suppressed fresh-chat creation; the next save POSTed to
+// a chat the new principal can't see → 404 "Chat not found" → warn-and-drop.
+//
+// The two factories (createChatSession / createSlashHandlers) both take a plain
+// `ctx`; in production cmdChat hands them the SAME ctx. We mirror that by passing
+// one shared ctx, so a slash handler's reset is visible to the session helpers.
+
+const test = require('node:test');
+const assert = require('node:assert');
+
+const { createChatSession } = require('../lib/commands/chat-session');
+const { createSlashHandlers } = require('../lib/commands/chat-slash');
+
+// Build a shared ctx with recording stubs. Only the fields the functions under
+// test touch are real; the rest are inert so the destructures don't throw.
+function makeCtx(overrides = {}) {
+  const warns = [];
+  const saves = [];   // { chatId, count }
+  let createSeq = 0;
+  const created = [];
+
+  const config = {
+    auth_token: 'tok', dashboard_model_id: 'm1', ...(overrides.config || {}),
+  };
+
+  const ctx = {
+    // session state
+    messages: overrides.messages || [],
+    currentChatId: overrides.currentChatId !== undefined ? overrides.currentChatId : null,
+    savedUpTo: overrides.savedUpTo || 0,
+    currentModel: 'test-model',
+    resolvedTokenLimit: 1000,
+
+    // collaborators used by chat-session helpers
+    msgs: { sysWarn: (m) => warns.push(m) },
+    getConfig: () => config,
+    setConfig: (c) => Object.assign(config, c),
+    storage: { list: () => [], save() {}, load: () => null },
+    approxTokens: (s) => Math.ceil((s || '').length / 4),
+    PAGE_SIZE: 10, sessionStart: 0, getCols: () => 80,
+    FG_GRAY: '', RST: '',
+    cleanOrphanedToolMessages: (m) => ({ messages: m, droppedTool: 0, droppedAssistantCalls: 0, droppedAssistantMsgs: 0 }),
+    reconstructLoadedMessage: (m) => m,
+    resolveTokenLimit: async () => 1000,
+
+    dashboardCreateChat: overrides.dashboardCreateChat || (async () => {
+      const id = `chat-${++createSeq}`; created.push(id); return { chat: { id } };
+    }),
+    dashboardSaveMessages: overrides.dashboardSaveMessages || (async (chatId, msgs) => {
+      saves.push({ chatId, count: msgs.length }); return {};
+    }),
+    dashboardGetChat: async () => ({ messages: [] }),
+    dashboardGetModelForCli: async () => ({ model: null }),
+
+    // collaborators used by slash handlers
+    chatHistory: { addMessage() {} },
+    statusBar: { update() {}, setModel() {}, setContextLimit() {} },
+    inputField: { setDisabled() {} },
+    permissionManager: { clear() { ctx._permClears = (ctx._permClears || 0) + 1; } },
+    loginFlow: overrides.loginFlow || (async () => {}),
+    ensureDefaultModel: overrides.ensureDefaultModel || (async () => null),
+    dashboardLogout: overrides.dashboardLogout || (async () => ({})),
+
+    _warns: warns, _saves: saves, _created: created,
+  };
+
+  // Note: createChatIfNeeded reads `created` length via the default stub above.
+  Object.defineProperty(ctx, '_createdCount', { get: () => created.length });
+  return ctx;
+}
+
+// (b) /login resets currentChatId and savedUpTo (and mirrors /new: messages + approvals).
+test('/login resets chat context (currentChatId, savedUpTo, messages)', async () => {
+  const ctx = makeCtx({ currentChatId: 'stale', savedUpTo: 5, messages: [{ role: 'user', content: 'x' }] });
+  const handlers = createSlashHandlers(ctx);
+  await handlers['/login']();
+  assert.strictEqual(ctx.currentChatId, null);
+  assert.strictEqual(ctx.savedUpTo, 0);
+  assert.deepStrictEqual(ctx.messages, []);
+  assert.strictEqual(ctx._permClears, 1, 'approvals cleared on principal change');
+});
+
+// (c) /logout resets them too, even if the dashboardLogout HTTP call failed.
+test('/logout resets chat context even when dashboardLogout HTTP fails', async () => {
+  const err503 = Object.assign(new Error('Service Unavailable'), { statusCode: 503 });
+  const ctx = makeCtx({
+    currentChatId: 'stale', savedUpTo: 5,
+    dashboardLogout: async () => { throw err503; },
+  });
+  const handlers = createSlashHandlers(ctx);
+  await handlers['/logout']();   // early-returns on the 503, but reset must still hold
+  assert.strictEqual(ctx.currentChatId, null);
+  assert.strictEqual(ctx.savedUpTo, 0);
+});
+
+// (a) in-process /logout → /login → next turn creates a NEW chat; save targets it.
+test('logout then login: next turn creates a fresh chat and save targets it', async () => {
+  const ctx = makeCtx({
+    currentChatId: 'chat-old', savedUpTo: 3,
+    loginFlow: async () => { ctx.setConfig({ auth_token: 'newtok' }); },
+  });
+  const session = createChatSession(ctx);
+  const handlers = createSlashHandlers(ctx);
+
+  await handlers['/logout']();
+  assert.strictEqual(ctx.currentChatId, null, 'logout dropped the stale id');
+  await handlers['/login']();
+  assert.strictEqual(ctx.currentChatId, null, 'login left it null for lazy create');
+
+  // Next turn.
+  ctx.messages.push({ role: 'user', content: 'hello' }, { role: 'assistant', content: 'hi' });
+  await session.createChatIfNeeded('hello');
+  await session.saveTurnToDashboard();
+
+  assert.strictEqual(ctx._createdCount, 1, 'exactly one fresh chat created');
+  assert.strictEqual(ctx._saves.length, 1);
+  assert.strictEqual(ctx._saves[0].chatId, 'chat-1', 'save went to the new chat, not chat-old');
+  assert.deepStrictEqual(ctx._warns, [], 'no "Chat not found" warning');
+});
+
+// (d) 404 on save → self-heal: new chat, re-save same slice, advance savedUpTo after success.
+test('saveTurnToDashboard self-heals on 404 (recreate + re-save, once)', async () => {
+  let createSeq = 0;
+  const saves = [];
+  const ctx = makeCtx({
+    currentChatId: 'stale', savedUpTo: 0,
+    messages: [{ role: 'user', content: 'hi' }, { role: 'assistant', content: 'yo' }],
+    dashboardCreateChat: async () => ({ chat: { id: `fresh-${++createSeq}` } }),
+    dashboardSaveMessages: async (chatId, msgs) => {
+      saves.push({ chatId, count: msgs.length });
+      if (chatId === 'stale') throw Object.assign(new Error('Chat not found'), { statusCode: 404 });
+      return {};
+    },
+  });
+  const session = createChatSession(ctx);
+  await session.saveTurnToDashboard();
+
+  assert.strictEqual(createSeq, 1, 'exactly one new chat created (no retry loop)');
+  assert.strictEqual(ctx.currentChatId, 'fresh-1');
+  assert.deepStrictEqual(saves.map((s) => s.chatId), ['stale', 'fresh-1'], 'retried on the fresh chat');
+  assert.strictEqual(saves[1].count, 2, 're-saved the SAME pending slice');
+  assert.strictEqual(ctx.savedUpTo, 2, 'savedUpTo advanced only after re-save succeeded');
+  assert.ok(!ctx._warns.some((w) => /history save failed/.test(w)), 'no failure warning on success');
+});
+
+// (e) non-404 (503) → does NOT recreate; warns; savedUpTo unchanged.
+test('saveTurnToDashboard does not recover on non-404 (503)', async () => {
+  let creates = 0;
+  const ctx = makeCtx({
+    currentChatId: 'stale', savedUpTo: 0,
+    messages: [{ role: 'user', content: 'hi' }, { role: 'assistant', content: 'yo' }],
+    dashboardCreateChat: async () => { creates++; return { chat: { id: 'x' } }; },
+    dashboardSaveMessages: async () => { throw Object.assign(new Error('Service Unavailable'), { statusCode: 503 }); },
+  });
+  const session = createChatSession(ctx);
+  await session.saveTurnToDashboard();
+
+  assert.strictEqual(creates, 0, 'transient error must NOT spawn a new chat');
+  assert.strictEqual(ctx.currentChatId, 'stale', 'chat id untouched');
+  assert.strictEqual(ctx.savedUpTo, 0, 'savedUpTo unadvanced so a later turn retries');
+  assert.ok(ctx._warns.some((w) => /history save failed/.test(w)), 'warned');
+});
+
+// (f) createChatIfNeeded creation failure is surfaced, not swallowed.
+test('createChatIfNeeded surfaces a creation failure (not silent)', async () => {
+  const ctx = makeCtx({
+    currentChatId: null,
+    dashboardCreateChat: async () => { throw new Error('boom'); },
+  });
+  const session = createChatSession(ctx);
+  await session.createChatIfNeeded('hello');
+  assert.strictEqual(ctx.currentChatId, null, 'still no chat (non-fatal)');
+  assert.ok(ctx._warns.some((w) => /could not create dashboard chat/.test(w)), 'failure surfaced');
+});
+
+// (g) regression: normal session and --resume session save to the right chat.
+test('regression: normal session lazily creates and saves; --resume saves to resumed id', async () => {
+  // Normal session: currentChatId starts null → lazy create → save.
+  const a = makeCtx({ currentChatId: null, savedUpTo: 0, messages: [{ role: 'user', content: 'q' }, { role: 'assistant', content: 'a' }] });
+  const sa = createChatSession(a);
+  await sa.createChatIfNeeded('q');
+  await sa.saveTurnToDashboard();
+  assert.strictEqual(a._created.length, 1);
+  assert.strictEqual(a._saves[0].chatId, 'chat-1');
+  assert.strictEqual(a.savedUpTo, 2);
+  assert.deepStrictEqual(a._warns, []);
+
+  // --resume session: currentChatId set, savedUpTo at resumed length; a new turn
+  // saves the incremental slice to the SAME chat (no reset, no new chat).
+  const b = makeCtx({
+    currentChatId: 'resumed-id', savedUpTo: 2,
+    messages: [{ role: 'user', content: 'q1' }, { role: 'assistant', content: 'a1' }],
+  });
+  const sb = createChatSession(b);
+  await sb.createChatIfNeeded('ignored');   // no-op: currentChatId already set
+  b.messages.push({ role: 'user', content: 'q2' }, { role: 'assistant', content: 'a2' });
+  await sb.saveTurnToDashboard();
+  assert.strictEqual(b._created.length, 0, '--resume must not create a new chat');
+  assert.strictEqual(b._saves.length, 1);
+  assert.strictEqual(b._saves[0].chatId, 'resumed-id');
+  assert.strictEqual(b._saves[0].count, 2, 'only the incremental slice saved');
+  assert.strictEqual(b.savedUpTo, 4);
+});