Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
#!/usr/bin/env node
/*
* W7a-Smoke: die entkernte Menuezeile, die eingebaute Hilfeseite, die
* ehrlichen Twin-Saetze und die Kommandozeile, die Tippen wirklich annimmt.
*
* Was hier bewiesen wird, kann kein Unit-Test beweisen. Die Unit-Tests zeigen,
* dass der Katalog keine Attrappe mehr traegt, dass die Hilfe ihre sieben
* Abschnitte in der richtigen Reihenfolge baut und dass ein blanker Buchstabe
* kein Kuerzel mehr ist. Sie sagen nichts darueber, ob im gebauten Programm
* wirklich nur noch verdrahtete Punkte in der Zeile stehen, ob ein Klick auf
* [?]help die Seite aufschlaegt, ob die Taste `?` dasselbe tut, ob Escape sie
* schliesst, ob sich in ihr etwas ueberlagert oder aus seinem Kasten ragt, und
* vor allem: ob das Wort "create", ohne vorher zu klicken getippt, in der
* Kommandozeile ankommt, statt ueber sein `c` ein Panel aufzuschlagen. Genau
* das war der Nutzerbefund vom 2026-08-29.
*
* Ablauf:
* 1. `npm run build`
* 2. isoliertes HOME, eigenes Rendezvous-Verzeichnis (CBM_RUNTIME_DIR)
* 3. fixtures/atlas-sample indizieren (die Fixture wird nur gelesen)
* 4. C-Server auf einem freien Port >= 4370, dist/ auf einem zweiten
* 5. Chromium ohne Aussenwelt, plus Route-Sperre
* 6a. Menuezeile lesen: was steht da, ist alles verdrahtet, gibt es noch
* irgendwo einen "not wired"-Tooltip
* 6b. Hilfe per Klick, Abschnitte, Grenzen, Tastentabelle, Netz-Links,
* Farbe, Lesbarkeit (auch durchgescrollt), Bild
* 6c. Hilfe per Taste `?`, zu per Escape
* 6d. Die Kommandozeile: tippen ohne Klick, kein Panel dabei, Fokus sichtbar,
* Fokustaste, Ein-Zeichen-Hinweis, kein nativer Tooltip
* 6e. Der Twin: die beiden Linsen aufschalten und ihre Saetze lesen
* 7. abraeumen, Restprozesse zaehlen, verification/w7/help.json schreiben
*
* Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w7a).
*
* ## Warum die verdrahtete Tastenliste aus dem QUELLTEXT gelesen wird
*
* `helpListsEveryShortcut` vergleicht die Tabelle der Hilfe nicht mit einer
* Liste, die in dieser Datei steht: das waere ein dritter Katalog und damit die
* dritte Gelegenheit, dass etwas auseinanderlaeuft. Gelesen wird die Verdrahtung
* selbst (src/app/shortcuts.ts, src/app/keyboard.ts, tour-player.ts,
* overlay-model.ts), und verglichen wird sie mit dem, was im Browser wirklich
* in der Tabelle steht.
*/
import { spawn } from 'node:child_process';
import { existsSync, readFileSync } from 'node:fs';
import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import {
countListeners,
findFreePort,
indexRepository,
sleep,
startServer,
stopServer,
} from './lib/cbm-server.mjs';
import {
DELIBERATE_OVERLAYS,
READABILITY_EXCLUSIONS,
measureReadability,
resetScroll,
scrollRegionsToEnd,
} from './lib/readability.mjs';
import { startStaticProxy } from './lib/static-proxy.mjs';
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
const BINARY = join(ROOT, 'cbm', 'build', 'c', 'codebase-memory-mcp');
const DIST = join(ROOT, 'dist');
const FIXTURE = join(ROOT, 'fixtures', 'atlas-sample');
const PROJECT = 'codeatlasweb-w7a';
const OUT_DIR = join(ROOT, 'verification', 'w7');
const OUT_JSON = join(OUT_DIR, 'help.json');
const MIN_PORT = 4370;
/** Das Symbol, an dem die beiden Twin-Linsen gelesen werden. */
const TARGET = 'createUser';
/** Das Wort aus dem Nutzerbefund: sein `c` schlug die Aenderungsansicht auf. */
const TYPED_WORD = 'create';
/** Die drei Verbote, die woertlich in der Hilfe stehen muessen. */
const LIMIT_PHRASES = ['read-only', 'cannot edit', 'cannot run', 'no terminal', 'no cloud'];
/** Die Flaechen, deren Auftauchen ein "ein Panel ging auf" waere. */
const PANEL_TESTIDS = [
'atlas-impact',
'atlas-bugwizard',
'atlas-entry',
'atlas-flow-overlay',
'atlas-help',
];
/** Chromium ohne Aussenwelt. Wortgleich mit smoke-w4c. */
const CHROMIUM_ARGS = [
'--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1, EXCLUDE localhost',
'--disable-background-networking',
'--disable-component-update',
'--disable-domain-reliability',
'--disable-client-side-phishing-detection',
'--disable-sync',
'--disable-default-apps',
'--no-first-run',
'--no-default-browser-check',
'--metrics-recording-only',
'--no-pings',
'--disable-breakpad',
'--disable-features=Translate,OptimizationHints,MediaRouter,AutofillServerCommunication,InterestFeedContentSuggestions,DialMediaRouteProvider,CalculateNativeWinOcclusion',
'--use-angle=swiftshader',
'--enable-unsafe-swiftshader',
];
const log = (...parts) => console.log('[smoke-w7a]', ...parts);
const serverLog = [];
function run(command, args, options = {}) {
return new Promise((done) => {
const child = spawn(command, args, {
cwd: options.cwd ?? ROOT,
env: {
...process.env,
...(options.env ?? {}),
NO_UPDATE_NOTIFIER: '1',
npm_config_update_notifier: 'false',
npm_config_audit: 'false',
npm_config_fund: 'false',
},
stdio: ['pipe', 'pipe', 'pipe'],
});
let out = '';
let err = '';
child.stdout.on('data', (d) => {
out += d.toString();
});
child.stderr.on('data', (d) => {
err += d.toString();
});
child.on('error', (error) => done({ code: 127, out, err: err + error.message }));
child.on('close', (code) => done({ code: code ?? 1, out, err }));
child.stdin.end();
});
}
/** Die `case`-Tasten einer Absichtsfunktion, aus ihrem Quelltext. */
function casesOf(source, functionName) {
const start = source.indexOf(`export function ${functionName}(`);
if (start < 0) {
throw new Error(`${functionName} nicht gefunden`);
}
const end = source.indexOf('\n}', start);
const body = source.slice(start, end);
const keys = [...body.matchAll(/case '([^']+)':/g)].map((match) => match[1]);
return [...new Set(keys.map((key) => (key.length === 1 ? key.toLowerCase() : key)))].sort();
}
/**
* Die verdrahteten Tasten, aus der Verdrahtung selbst gelesen.
*
* Drei Quellen, so wie es im Programm drei sind. Die Menuezeile fuehrt ihre
* Buchstaben als Liste (dort entstehen sie), die beiden anderen Bereiche
* entscheiden je Taste in einer Funktion, und deren `case`-Zweige sind die
* Liste.
*/
function wiredKeysFromSource() {
const shortcuts = readFileSync(join(ROOT, 'src', 'app', 'shortcuts.ts'), 'utf8');
const declared = /WIRED_MENU_SHORTCUTS: readonly string\[\] = \[([^\]]*)\]/.exec(shortcuts)?.[1] ?? '';
const menu = declared
.split(',')
.map((word) => word.trim().replace(/^'|'$/g, ''))
.filter((word) => word.length > 0);
const keyboard = readFileSync(join(ROOT, 'src', 'app', 'keyboard.ts'), 'utf8');
const focusKey = /FOCUS_COMMAND_KEY = '([^']+)'/.exec(keyboard)?.[1] ?? '';
const player = readFileSync(join(ROOT, 'src', 'tours', 'tour-player.ts'), 'utf8');
const overlay = readFileSync(join(ROOT, 'src', 'search', 'overlay-model.ts'), 'utf8');
return {
menu: [...menu, focusKey].sort(),
walk: casesOf(player, 'playerIntent'),
search: casesOf(overlay, 'overlayIntent'),
};
}
/** Alles, was die Menuezeile gerade zeigt. */
const menuSeam = (page) =>
page.evaluate(() => {
const row = document.querySelector('[data-testid="atlas-menu"]');
const items = [...(row?.querySelectorAll('[data-menu]') ?? [])].map((node) => ({
menu: node.getAttribute('data-menu') ?? '',
label: node.textContent?.replace(/\s+/g, ' ').trim() ?? '',
state: node.getAttribute('data-state') ?? '',
disabled: node.getAttribute('aria-disabled') === 'true' || node.hasAttribute('disabled'),
title: node.getAttribute('title') ?? '',
tag: node.tagName,
}));
const titles = [...document.querySelectorAll('[title]')].map((node) => node.getAttribute('title') ?? '');
return {
items,
legend: row?.querySelector('[data-testid="atlas-menu-legend"]')?.textContent?.trim() ?? '',
titles,
};
});
/** Alles, was die Hilfeseite gerade zeigt, in einem Zug abgelesen. */
const helpSeam = (page) =>
page.evaluate(() => {
const page_ = document.querySelector('[data-testid="atlas-help"]');
if (page_ === null) {
return { present: false };
}
const style = globalThis.getComputedStyle(page_);
const parts = /rgba?\(([^)]+)\)/.exec(style.backgroundColor);
const channels = parts === null ? [] : parts[1].split(',').map((value) => Number(value.trim()));
const luminance = channels.length >= 3
? (0.299 * channels[0] + 0.587 * channels[1] + 0.114 * channels[2]) / 255
: 1;
const text = page_.textContent?.replace(/\s+/g, ' ').trim() ?? '';
return {
present: true,
sections: [...page_.querySelectorAll('[data-testid="atlas-help-section"]')]
.map((node) => node.getAttribute('data-section') ?? ''),
shortcuts: [...page_.querySelectorAll('[data-testid="atlas-help-shortcut"]')].map((node) => ({
scope: node.getAttribute('data-scope') ?? '',
key: node.getAttribute('data-key') ?? '',
label: node.querySelector('td')?.textContent?.trim() ?? '',
does: [...node.querySelectorAll('td')][2]?.textContent?.trim() ?? '',
})),
paths: [...page_.querySelectorAll('[data-testid="atlas-help-path"]')]
.map((node) => node.textContent?.trim() ?? ''),
anchors: page_.querySelectorAll('a').length,
text,
backgroundColor: style.backgroundColor,
color: style.color,
fontFamily: style.fontFamily,
luminance,
};
});
/** Wo die Tastatur gerade hingeht und was die Zeile zeigt. */
const commandSeam = (page) =>
page.evaluate((panelIds) => {
const line = document.querySelector('[data-testid="atlas-command"]');
const input = document.querySelector('[data-testid="atlas-command-input"]');
const prompt = document.querySelector('[data-testid="atlas-command-prompt"]');
const results = document.querySelector('[data-testid="atlas-search-results"]');
return {
value: input === null ? '' : input.value,
focused: document.activeElement === input,
activeElement: document.activeElement?.tagName ?? '',
dataFocused: line?.getAttribute('data-focused') ?? '',
promptColor: prompt === null ? '' : globalThis.getComputedStyle(prompt).color,
lineBorder: line === null ? '' : globalThis.getComputedStyle(line).borderTopColor,
lineBackground: line === null ? '' : globalThis.getComputedStyle(line).backgroundColor,
hasTitle: (input?.hasAttribute('title') ?? false) || (line?.hasAttribute('title') ?? false),
hint: document.querySelector('.atlas-command-hint')?.textContent?.trim() ?? '',
resultsShown: results !== null,
resultsHeadline:
document.querySelector('[data-testid="atlas-search-headline"]')?.textContent?.trim() ?? '',
openPanels: panelIds.filter((id) => document.querySelector(`[data-testid="${id}"]`) !== null),
galaxyVisible:
document.querySelector('[data-testid="atlas-galaxy"]')?.getAttribute('data-visible') ?? '',
};
}, PANEL_TESTIDS);
/** Die beiden Linsen des Twins, so wie sie im Panel stehen. */
const twinLensSeam = (page) =>
page.evaluate(() => {
const sectionText = (name) =>
document.querySelector(`[data-testid="codeatlas-twin-section-${name}"]`)
?.textContent?.replace(/\s+/g, ' ').trim() ?? '';
return {
runtime: sectionText('runtime'),
changes: sectionText('changes'),
effects: sectionText('effects'),
};
});
async function main() {
const totalStarted = Date.now();
let serverChild = null;
let proxy = null;
let browser = null;
let home = null;
let runtimeDir = null;
let serverPort = 0;
let uiPort = 0;
let failure = null;
const timings = {};
const report = {
menuItems: [],
noNotWiredTooltip: false,
everyMenuItemWired: false,
helpOpensByClick: false,
helpOpensByKey: false,
helpEscCloses: false,
helpSectionsShown: 0,
helpListsEveryShortcut: false,
helpNamesLimits: false,
helpHasNoWebLinks: false,
darkStyled: false,
overlapViolations: 0,
clippingViolations: 0,
twinRuntimeSentenceHonest: false,
twinChangesSentenceHonest: false,
typingWithoutClickReachesLine: false,
typingNeverOpensPanelAccidentally: false,
focusVisible: false,
focusKeyWorks: false,
oneCharHintInResultRow: false,
noNativeTooltipOnCommandLine: false,
menuShortcutByAltWorks: false,
port: 0,
leftoverProcesses: 0,
};
const extras = { blockedRequests: [], consoleErrors: [], pageErrors: [], readability: [] };
try {
if (!existsSync(BINARY)) {
throw new Error(`Binary fehlt: ${BINARY} (erst 'make -f Makefile.cbm cbm-with-ui' im cbm-Clone bauen)`);
}
if (!existsSync(FIXTURE)) {
throw new Error(`Fixture fehlt: ${FIXTURE}`);
}
// ------------------------------------------------------------ 1. Bau
log('npm run build');
const buildStarted = Date.now();
const build = await run('npm', ['run', 'build']);
timings.buildMs = Date.now() - buildStarted;
if (build.code !== 0) {
throw new Error(`npm run build endete mit ${build.code}: ${build.err.trim().slice(-600)}`);
}
if (!existsSync(join(DIST, 'index.html'))) {
throw new Error('dist/index.html fehlt nach dem Build');
}
// ---------------------------------------------- 2. HOME, Rendezvous
home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w7a-home-'));
runtimeDir = await mkdtemp('/private/tmp/codeatlasweb-w7a-run-');
process.env.CBM_RUNTIME_DIR = runtimeDir;
log('isoliertes HOME:', home);
log('Rendezvous:', runtimeDir);
// --------------------------------------------------------- 3. Index
const indexed = await indexRepository(BINARY, { home, repoPath: FIXTURE, project: PROJECT });
extras.indexed = { nodes: indexed.nodes, edges: indexed.edges };
log(`indiziert: ${indexed.nodes} Knoten, ${indexed.edges} Kanten`);
// -------------------------------------------------------- 4. Server
serverPort = await findFreePort(MIN_PORT);
const started = await startServer(BINARY, { home, port: serverPort, log: serverLog });
serverChild = started.child;
timings.serverStartMs = started.durationMs;
uiPort = await findFreePort(MIN_PORT, [serverPort]);
proxy = await startStaticProxy({ distDir: DIST, upstreamPort: serverPort, port: uiPort });
report.port = uiPort;
extras.serverPort = serverPort;
log(`C-Server auf ${serverPort}, dist/ auf ${uiPort}`);
// ------------------------------------------------------- 5. Browser
const { chromium } = await import('playwright');
browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
const context = await browser.newContext({ viewport: { width: 1680, height: 1050 } });
const origin = `http://127.0.0.1:${uiPort}`;
await context.route('**/*', async (route) => {
const url = route.request().url();
if (url.startsWith(origin) || url.startsWith('data:') || url.startsWith('blob:')) {
await route.continue();
return;
}
extras.blockedRequests.push(url);
await route.abort();
});
const page = await context.newPage();
page.on('console', (message) => {
if (message.type() === 'error') {
extras.consoleErrors.push(message.text());
}
});
page.on('pageerror', (error) => extras.pageErrors.push(String(error)));
await mkdir(OUT_DIR, { recursive: true });
/** Laden, bis der Baum steht. Jeder Halt beginnt so. */
const load = async () => {
await page.goto(`${origin}/?project=${PROJECT}`, { waitUntil: 'load' });
await page.waitForSelector('[data-testid="atlas-tree-row"]', { timeout: 30000 });
await page.waitForTimeout(500);
};
/**
* Die Lesbarkeit an dieser Stelle, oben und durchgescrollt.
*
* Zweimal, weil eine Seite, die oben ordentlich aussieht und unten
* kollidiert, eine Seite ist, die kollidiert.
*/
const readability = async (name) => {
const top = await measureReadability(page);
const scrolled = await scrollRegionsToEnd(page);
await page.waitForTimeout(200);
const bottom = await measureReadability(page);
await resetScroll(page);
extras.readability.push({
name,
scrolledRegions: scrolled.length,
top: { candidates: top.candidates, overlaps: top.overlaps, clipped: top.clipped, layers: top.layers },
bottom: { candidates: bottom.candidates, overlaps: bottom.overlaps, clipped: bottom.clipped },
});
report.overlapViolations += top.overlaps.length + bottom.overlaps.length;
report.clippingViolations += top.clipped.length + bottom.clipped.length;
};
// ------------------------------------------- 6a. Die Menuezeile
await load();
const menu = await menuSeam(page);
extras.menu = menu;
report.menuItems = menu.items.map((item) => item.label);
report.noNotWiredTooltip = !menu.titles.some((title) => /not wired/i.test(title));
const wired = wiredKeysFromSource();
extras.wiredKeys = wired;
const letterOf = (label) => /\[([a-z?])\]/.exec(label)?.[1];
report.everyMenuItemWired =
menu.items.length > 0
&& menu.items.every((item) => !item.disabled && item.tag === 'BUTTON')
&& menu.items.every((item) => {
const letter = letterOf(item.label);
return letter !== undefined && wired.menu.includes(letter);
});
log(`Menuezeile: ${report.menuItems.join(' ')} (Legende "${menu.legend}")`);
await page.screenshot({ path: join(OUT_DIR, 'menu.png'), fullPage: true });
// --------------------------------- 6b. Die Hilfe, per Klick geoeffnet
await page.click('[data-menu="?"]');
await page.waitForSelector('[data-testid="atlas-help"]', { timeout: 15000 });
await page.waitForTimeout(400);
const help = await helpSeam(page);
extras.help = {
sections: help.sections,
shortcuts: help.shortcuts,
paths: help.paths,
anchors: help.anchors,
backgroundColor: help.backgroundColor,
color: help.color,
fontFamily: help.fontFamily,
luminance: help.luminance,
textLength: help.text.length,
};
report.helpOpensByClick = help.present === true;
report.helpSectionsShown = help.sections.length;
report.helpNamesLimits = LIMIT_PHRASES.every((phrase) => help.text.includes(phrase));
report.helpHasNoWebLinks = help.anchors === 0 && !/https?:\/\//i.test(help.text);
report.darkStyled = help.luminance < 0.2 && /mono/i.test(help.fontFamily);
const shownKeys = {
menu: [...new Set(help.shortcuts
.filter((row) => ['mnemonic', 'bare', 'line'].includes(row.scope))
.map((row) => row.key))].sort(),
walk: [...new Set(help.shortcuts.filter((row) => row.scope === 'walk').map((row) => row.key))].sort(),
search: [...new Set(help.shortcuts.filter((row) => row.scope === 'search').map((row) => row.key))].sort(),
};
extras.shownKeys = shownKeys;
report.helpListsEveryShortcut =
JSON.stringify(shownKeys.menu) === JSON.stringify(wired.menu)
&& JSON.stringify(shownKeys.walk) === JSON.stringify(wired.walk)
&& JSON.stringify(shownKeys.search) === JSON.stringify(wired.search)
&& help.shortcuts.every((row) => row.does.length > 0);
log(`Hilfe: ${help.sections.join(', ')} (${help.shortcuts.length} Tasten, `
+ `Grenzen woertlich: ${report.helpNamesLimits})`);
await readability('help-open');
await page.screenshot({ path: join(OUT_DIR, 'help.png'), fullPage: true });
// ------------------------------- 6c. Zu per Knopf, auf per Taste, zu per Escape
await page.click('[data-testid="atlas-help-close"]');
await page.waitForSelector('[data-testid="atlas-help"]', { state: 'detached', timeout: 10000 });
extras.helpCloseButtonWorks = true;
await page.locator('.atlas-brand').click();
await page.keyboard.press('?');
await page.waitForSelector('[data-testid="atlas-help"]', { timeout: 10000 }).catch(() => undefined);
report.helpOpensByKey = (await page.locator('[data-testid="atlas-help"]').count()) > 0;
await page.keyboard.press('Escape');
await page.waitForSelector('[data-testid="atlas-help"]', { state: 'detached', timeout: 10000 })
.catch(() => undefined);
report.helpEscCloses = (await page.locator('[data-testid="atlas-help"]').count()) === 0;
log(`Hilfe per Taste: ${report.helpOpensByKey}, Escape schliesst: ${report.helpEscCloses}`);
// ---------------------------------------------- 6d. Die Kommandozeile
//
// Frisch geladen, damit der Fokus dort liegt, wo er nach dem Laden
// wirklich liegt: nirgends. Genau in diesem Zustand hat der Nutzer
// getippt und nichts gesehen.
await load();
const before = await commandSeam(page);
extras.commandBeforeTyping = before;
await page.keyboard.type(TYPED_WORD, { delay: 60 });
await page.waitForTimeout(600);
const afterTyping = await commandSeam(page);
extras.commandAfterTyping = afterTyping;
report.typingWithoutClickReachesLine =
before.activeElement === 'BODY' && afterTyping.value === TYPED_WORD;
report.typingNeverOpensPanelAccidentally =
afterTyping.openPanels.length === 0
&& afterTyping.galaxyVisible === before.galaxyVisible;
report.noNativeTooltipOnCommandLine = afterTyping.hasTitle === false;
report.focusVisible =
before.dataFocused === 'false'
&& afterTyping.dataFocused === 'true'
&& afterTyping.focused === true
&& afterTyping.promptColor !== before.promptColor;
log(`getippt ohne Klick: "${afterTyping.value}" (Panels offen: `
+ `${afterTyping.openPanels.join(', ') || 'keins'})`);
/*
* Ein Bild vom Befund selbst: die Zeile traegt das getippte Wort, der
* Prompt leuchtet, das Trefferfenster steht darueber, und kein Panel ist
* aufgegangen. Der frozen Test verlangt dieses Bild nicht; der Nutzer
* hat den Fehler an einem Screenshot gemeldet, und die Antwort darauf
* gehoert als Screenshot ins Artefakt.
*/
await page.screenshot({ path: join(OUT_DIR, 'command.png'), fullPage: true });
// Der Ein-Zeichen-Hinweis, dort wo die Treffer stehen wuerden.
await load();
await page.keyboard.press('c');
await page.waitForTimeout(400);
const oneChar = await commandSeam(page);
extras.commandOneChar = oneChar;
report.oneCharHintInResultRow =
oneChar.value === 'c'
&& oneChar.resultsShown === true
&& /one more letter/i.test(oneChar.resultsHeadline);
await page.screenshot({ path: join(OUT_DIR, 'onechar.png'), fullPage: true });
log(`ein Zeichen: "${oneChar.value}", Fenster sagt "${oneChar.resultsHeadline}"`);
// Die Fokustaste holt die Zeile, ohne sich selbst hineinzuschreiben.
await load();
const focusKey = /FOCUS_COMMAND_KEY = '([^']+)'/
.exec(readFileSync(join(ROOT, 'src', 'app', 'keyboard.ts'), 'utf8'))?.[1] ?? '/';
await page.keyboard.press(focusKey);
await page.waitForTimeout(300);
const afterFocusKey = await commandSeam(page);
extras.commandAfterFocusKey = { key: focusKey, ...afterFocusKey };
report.focusKeyWorks = afterFocusKey.focused === true && afterFocusKey.value === '';
log(`Fokustaste "${focusKey}": Zeile fokussiert ${afterFocusKey.focused}, `
+ `Inhalt "${afterFocusKey.value}"`);
/*
* Die Gegenprobe zu AC8: der Buchstabe TUT weiterhin etwas, nur mit
* Alt/Option davor.
*
* Ohne diesen Halt waere die Zusicherung des Zyklus halbiert: "kein
* blanker Buchstabe oeffnet ein Panel" ist billig zu haben, indem man
* die Kuerzel abschaltet. Gemessen wird deshalb beides am selben Lauf,
* an zwei Kuerzeln: `a` schaltet die Galaxie, `c` schlaegt die
* Aenderungsansicht auf (dasselbe Kuerzel, das im Nutzerbefund
* versehentlich ausgeloest wurde).
*/
await load();
const galaxyBefore = await page.evaluate(
() => document.querySelector('[data-testid="atlas-galaxy"]')?.getAttribute('data-visible') ?? '',
);
await page.locator('.atlas-brand').click();
await page.keyboard.press('Alt+a');
await page.waitForFunction(
(before) => document.querySelector('[data-testid="atlas-galaxy"]')?.getAttribute('data-visible') !== before,
galaxyBefore,
{ timeout: 15000 },
).catch(() => undefined);
const afterAltA = await commandSeam(page);
await page.keyboard.press('Alt+c');
await page.waitForSelector('[data-testid="atlas-impact"]', { timeout: 30000 }).catch(() => undefined);
const afterAltC = await commandSeam(page);
extras.altShortcuts = {
galaxyBefore,
galaxyAfterAltA: afterAltA.galaxyVisible,
lineAfterAltA: afterAltA.value,
panelsAfterAltC: afterAltC.openPanels,
lineAfterAltC: afterAltC.value,
};
report.menuShortcutByAltWorks =
afterAltA.galaxyVisible !== galaxyBefore
&& afterAltA.value === ''
&& afterAltC.openPanels.includes('atlas-impact')
&& afterAltC.value === '';
log(`Alt-Kuerzel: Galaxie ${galaxyBefore} -> ${afterAltA.galaxyVisible}, `
+ `Panels nach Alt+c: ${afterAltC.openPanels.join(', ') || 'keins'}`);
await page.keyboard.press('Escape');
await page.waitForTimeout(300);
await readability('command-line');
// ------------------------------------------------- 6e. Die zwei Linsen
//
// Zum Symbol ueber dieselbe Suche, die die Kommandozeile fuehrt, und
// diesmal ohne einen Klick in die Zeile: das ist die zweite Haelfte des
// Beweises fuer AC8.
await load();
await page.keyboard.type(TARGET, { delay: 40 });
await page.waitForSelector(`[data-testid="atlas-search-row"][data-name="${TARGET}"]`, { timeout: 30000 });
await page.waitForTimeout(500);
await page.click(`[data-testid="atlas-search-row"][data-name="${TARGET}"]`);
await page.waitForFunction(
() => /userService\.createUser$/.test(globalThis.__atlasTwin?.qualifiedName ?? ''),
undefined,
{ timeout: 40000 },
);
// Die beiden Linsen sind per Vorgabe aus (TWIN_PROFILE): sie werden hier
// eingeschaltet, weil ihre Saetze sonst gar nicht dastehen.
for (const facet of ['runtime', 'changes']) {
await page.click(`[data-facet="${facet}"]`);
await page.waitForSelector(`[data-testid="codeatlas-twin-section-${facet}"]`, { timeout: 20000 });
}
await page.waitForTimeout(400);
const lenses = await twinLensSeam(page);
extras.twinLenses = lenses;
report.twinRuntimeSentenceHonest =
/BUG hunt/.test(lenses.runtime)
&& /ingest_traces/.test(lenses.runtime)
&& !/\byet\b/i.test(lenses.runtime)
&& !/Import runtime traces/i.test(lenses.runtime);
report.twinChangesSentenceHonest =
/\[c\]hange scope/.test(lenses.changes)
&& /detect_changes/.test(lenses.changes)
&& !/\byet\b/i.test(lenses.changes);
log(`Runtime-Zeile ehrlich: ${report.twinRuntimeSentenceHonest}, `
+ `Changes-Zeile ehrlich: ${report.twinChangesSentenceHonest}`);
await readability('twin-lenses');
extras.apiRoutes = { ...proxy.log.apiRoutes };
extras.rpcTools = { ...proxy.log.rpcTools };
await context.close();
} catch (err) {
failure = err;
console.error('[smoke-w7a] FEHLER:', err.message);
if (serverLog.length > 0) {
console.error('[smoke-w7a] Server-Log (letzte 20 Zeilen):\n' + serverLog.slice(-20).join('\n'));
}
}
if (browser !== null) {
await browser.close().catch(() => undefined);
}
if (proxy !== null) {
await proxy.close();
}
await stopServer(serverChild);
await sleep(500);
const leftovers = [];
for (const port of [serverPort, uiPort].filter((value) => value > 0)) {
leftovers.push(await countListeners(port));
}
report.leftoverProcesses = leftovers.reduce((sum, value) => sum + value, 0);
log('leftoverProcesses:', report.leftoverProcesses);
timings.totalMs = Date.now() - totalStarted;
await mkdir(OUT_DIR, { recursive: true });
await writeFile(
OUT_JSON,
JSON.stringify({
...report,
project: PROJECT,
fixture: 'fixtures/atlas-sample (nur gelesen)',
typedWord: TYPED_WORD,
limitPhrases: LIMIT_PHRASES,
panelsWatched: PANEL_TESTIDS,
readabilityExclusions: READABILITY_EXCLUSIONS,
deliberateOverlays: DELIBERATE_OVERLAYS,
timings,
generatedAt: new Date().toISOString(),
error: failure ? failure.message : null,
extras,
}, null, 2) + '\n',
'utf8',
);
log('geschrieben:', OUT_JSON);
const ok =
failure === null
&& report.menuItems.length > 0
&& report.noNotWiredTooltip === true
&& report.everyMenuItemWired === true
&& report.helpOpensByClick === true
&& report.helpOpensByKey === true
&& report.helpEscCloses === true
&& report.helpSectionsShown >= 6
&& report.helpListsEveryShortcut === true
&& report.helpNamesLimits === true
&& report.helpHasNoWebLinks === true
&& report.darkStyled === true
&& report.overlapViolations === 0
&& report.clippingViolations === 0
&& report.twinRuntimeSentenceHonest === true
&& report.twinChangesSentenceHonest === true
&& report.typingWithoutClickReachesLine === true
&& report.typingNeverOpensPanelAccidentally === true
&& report.focusVisible === true
&& report.focusKeyWorks === true
&& report.oneCharHintInResultRow === true
&& report.noNativeTooltipOnCommandLine === true
&& report.menuShortcutByAltWorks === true
&& report.port >= MIN_PORT
&& report.leftoverProcesses === 0
&& extras.blockedRequests.length === 0
&& extras.pageErrors.length === 0;
if (!ok) {
console.error('[smoke-w7a] W7a-Smoke NICHT gruen.');
if (home) {
console.error('[smoke-w7a] isoliertes HOME bleibt zum Nachsehen liegen:', home);
}
process.exitCode = 1;
return;
}
for (const directory of [home, runtimeDir]) {
if (directory) {
await rm(directory, { recursive: true, force: true });
}
}
log('W7a-Smoke gruen.');
}
main().catch((err) => {
console.error('[smoke-w7a] unerwarteter Fehler:', err);
process.exitCode = 1;
});