Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013#!/usr/bin/env nodeimport WebSocket from 'ws';import http from 'http';import CDP from './cdp.mjs';
// Colorsconst RESET = '\x1b[0m';const BOLD = '\x1b[1m';const RED_BG = '\x1b[41m';const PINK = '\x1b[95m';const PURPLE_BG = '\x1b[45m';const WHITE = '\x1b[97m';
const redLog = (msg) => console.log(`${RED_BG}${PINK}${msg}${RESET}`);const brightLog = (msg) => console.log(`${RED_BG}${PINK}${BOLD}${msg}${RESET}`);const darkLog = (msg) => console.log(`${RED_BG}${PINK}${msg}${RESET}`);const consoleLog = (msg) => console.log(`${PURPLE_BG}${WHITE}💉${RESET} ${msg}`);
// Auto-detect CDP host based on environmentfunction getCDPHost() { // Not in a container - use localhost if (process.env.REMOTE_CONTAINERS !== 'true' && process.env.CODESPACES !== 'true') { return 'localhost'; } // In a container - need to reach the host // On Mac/Windows Docker Desktop, host.docker.internal works // On Linux, we need HOST_IP env var or to detect the gateway // First check if HOST_IP is set (common in devcontainer setups) if (process.env.HOST_IP) { return process.env.HOST_IP; } // Try host.docker.internal (works on Docker Desktop for Mac/Windows) // This will be validated at connection time return 'host.docker.internal';}
// Try multiple hosts to find CDP - returns first working one// Returns { host, port } objectasync function findWorkingCDPHost() { const candidates = []; // Not in a container - only try localhost with common CDP ports if (process.env.REMOTE_CONTAINERS !== 'true' && process.env.CODESPACES !== 'true') { // Try multiple ports in case 9222 is taken for (const port of [9333, 9222]) { try { const works = await new Promise((resolve) => { const req = http.get({ hostname: 'localhost', port: port, path: '/json', timeout: 1000, }, (res) => { let data = ''; res.on('data', (chunk) => data += chunk); res.on('end', () => resolve(data.length > 0)); }); req.on('error', () => resolve(false)); req.on('timeout', () => { req.destroy(); resolve(false); }); }); if (works) return { host: 'localhost', port }; } catch (e) {} } return { host: 'localhost', port: 9333 }; } // In a container - try multiple host:port combinations // Order matters: try most reliable options first candidates.push({ host: 'host.docker.internal', port: 9333 }); // Windows with new port candidates.push({ host: 'host.docker.internal', port: 9222 }); // Mac/Windows Docker Desktop candidates.push({ host: 'localhost', port: 9333 }); // SSH tunnel with new port candidates.push({ host: 'localhost', port: 9222 }); // SSH tunnel or VS Code forward candidates.push({ host: '172.17.0.1', port: 9224 }); // Docker bridge + socat (Linux) candidates.push({ host: '172.17.0.1', port: 9223 }); // Docker bridge + socat alt candidates.push({ host: '172.17.0.1', port: 9222 }); // Docker bridge direct if (process.env.HOST_IP) { candidates.push({ host: process.env.HOST_IP, port: 9333 }); candidates.push({ host: process.env.HOST_IP, port: 9223 }); candidates.push({ host: process.env.HOST_IP, port: 9222 }); } for (const { host, port } of candidates) { try { const works = await new Promise((resolve) => { const req = http.get({ hostname: host, port: port, path: '/json', timeout: 1000, headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', (chunk) => data += chunk); res.on('end', () => resolve(data.length > 0)); }); req.on('error', () => resolve(false)); req.on('timeout', () => { req.destroy(); resolve(false); }); }); if (works) { return { host, port }; } } catch (e) { // Continue to next candidate } } // Return the first candidate as fallback (will fail with better error) return candidates[0] || { host: 'localhost', port: 9222 };}
const CDP_HOST = getCDPHost();
class Artery { constructor() { this.ws = null; this.messageId = 0; this.pendingRequests = new Map(); this.eventHandlers = new Map(); this.debuggerUrl = null; this.reconnectInterval = null; this.shouldReconnect = false; this.consoleCallback = null; // Store console callback for reconnects }
async findAestheticTarget() { // Try to find a working CDP host dynamically const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); // Store for getAllTargets and other methods this.cdpHost = cdpHost; this.cdpPort = cdpPort; const targets = await this.getAllTargets(); // Look for AC iframe - either localhost or aesthetic.computer const acTarget = targets.find(t => t.type === 'iframe' && (t.url?.includes('localhost:8888') || t.url?.includes('aesthetic.computer')) ); if (!acTarget) throw new Error('AC not found'); redLog('🩸 Found AC'); // Fix WebSocket URL based on environment - only replace if localhost is in URL this.debuggerUrl = acTarget.webSocketDebuggerUrl; this.cdpHost = cdpHost; // Store for later use this.cdpPort = cdpPort; if (this.debuggerUrl.includes('localhost')) { // Handle both localhost:PORT and localhost (without port) this.debuggerUrl = this.debuggerUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } return acTarget; } // Get all CDP targets (uses dynamic host/port from findAestheticTarget) async getAllTargets() { // Use stored CDP host/port or detect dynamically const cdpHost = this.cdpHost || (await findWorkingCDPHost()).host; const cdpPort = this.cdpPort || (await findWorkingCDPHost()).port; return new Promise((resolve, reject) => { http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', (chunk) => data += chunk); res.on('end', () => { try { resolve(JSON.parse(data)); } catch (e) { reject(new Error('Parse failed')); } }); }).on('error', reject); }); } // List all AC frames (main + split players) async listACFrames() { const targets = await this.getAllTargets(); const acFrames = targets.filter(t => t.type === 'iframe' && (t.url?.includes('localhost:8888') || t.url?.includes('aesthetic.computer')) ); return acFrames.map(t => { const url = new URL(t.url); const player = url.searchParams.get('player'); const piece = url.pathname.replace('/', '') || 'prompt'; return { id: t.id, url: t.url, piece, player: player ? parseInt(player) : 0, // 0 = main, 1 = top, 2 = bottom label: player ? `Player ${player} (${piece})` : `Main (${piece})`, webSocketDebuggerUrl: t.webSocketDebuggerUrl }; }); } // Connect to a specific player frame (1 = top, 2 = bottom, 0 = main) async connectToPlayer(playerNum) { const frames = await this.listACFrames(); const target = frames.find(f => f.player === playerNum); if (!target) { throw new Error(`Player ${playerNum} not found. Available: ${frames.map(f => f.label).join(', ')}`); } brightLog(`🩸 Connecting to ${target.label}`); this.debuggerUrl = target.webSocketDebuggerUrl; if (CDP_HOST !== 'localhost') { this.debuggerUrl = this.debuggerUrl .replace('localhost', `${CDP_HOST}:9222`) .replace(':9222:9222', ':9222'); } this.currentPlayer = playerNum; return this.connect(); }
async connect(enableReconnect = false) { this.shouldReconnect = enableReconnect; if (!this.debuggerUrl) await this.findAestheticTarget();
return new Promise((resolve, reject) => { redLog('🩸 Connecting...'); this.ws = new WebSocket(this.debuggerUrl); this.ws.on('open', () => { brightLog('🩸 Connected!'); if (this.reconnectInterval) { clearInterval(this.reconnectInterval); this.reconnectInterval = null; } resolve(); }); this.ws.on('message', (data) => this.handleMessage(JSON.parse(data.toString()))); this.ws.on('error', (err) => { if (!this.shouldReconnect) redLog(`💔 ${err.message}`); reject(err); }); this.ws.on('close', () => { if (this.shouldReconnect) { darkLog('🩸 Reconnecting...'); this.attemptReconnect(); } else { darkLog('🩸 Closed'); } }); }); }
async attemptReconnect() { if (!this.shouldReconnect || this.reconnectInterval) return; darkLog('🩸 Retry every 2s...'); this.reconnectInterval = setInterval(async () => { try { await this.findAestheticTarget(); await this.connect(true); await this.enableConsole(); brightLog('🩸 Reconnected!'); } catch (e) {} }, 2000); }
handleMessage(msg) { if (msg.id !== undefined) { const pending = this.pendingRequests.get(msg.id); if (pending) { msg.error ? pending.reject(new Error(msg.error.message)) : pending.resolve(msg.result); this.pendingRequests.delete(msg.id); } } if (msg.method) { (this.eventHandlers.get(msg.method) || []).forEach(h => h(msg.params)); } }
async send(method, params = {}) { return new Promise((resolve, reject) => { const id = ++this.messageId; this.pendingRequests.set(id, { resolve, reject }); this.ws.send(JSON.stringify({ id, method, params })); setTimeout(() => { if (this.pendingRequests.has(id)) { this.pendingRequests.delete(id); reject(new Error('Timeout')); } }, 30000); }); }
on(eventMethod, handler) { if (!this.eventHandlers.has(eventMethod)) this.eventHandlers.set(eventMethod, []); this.eventHandlers.get(eventMethod).push(handler); }
// Clear handlers for an event method off(eventMethod) { this.eventHandlers.delete(eventMethod); }
// Enable console log tracking from the browser async enableConsole(callback) { // Store callback for use on reconnects if (callback !== undefined) this.consoleCallback = callback; const cb = this.consoleCallback; await this.send('Runtime.enable'); // Clear any existing console handlers to avoid duplicates this.off('Runtime.consoleAPICalled'); this.on('Runtime.consoleAPICalled', (params) => { const { type, args } = params; const message = args.map(arg => { if (arg.type === 'string') return arg.value; if (arg.type === 'number') return arg.value; if (arg.type === 'boolean') return arg.value; if (arg.type === 'undefined') return 'undefined'; if (arg.type === 'object' && arg.preview) { return JSON.stringify(arg.preview.properties?.reduce((obj, p) => { obj[p.name] = p.value; return obj; }, {}) || arg.preview); } return arg.description || arg.value || `[${arg.type}]`; }).join(' '); if (cb) { cb(type, message); } else { // Default: print to console with prefix const prefix = type === 'error' ? '❌' : type === 'warn' ? '⚠️' : '📝'; consoleLog(`${prefix} ${message}`); } }); }
async eval(expr) { const result = await this.send('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true }); if (result.exceptionDetails) throw new Error(`JS error: ${result.exceptionDetails.text}`); return result.result.value; }
async jump(piece) { brightLog(`🩸 Jump: ${piece}`); // Use pushState + popstate to navigate without a full page reload. // BIOS listens for popstate and sends a "history-load" to the worker, // keeping the CDP session, panel state, and audio context alive. await this.eval(` window.preloaded = false; window.history.pushState(null, "", "/${piece}"); window.dispatchEvent(new PopStateEvent("popstate")); `); // Wait for the piece to finish booting before returning. await this.waitForPiece(piece); }
async getCurrentPiece() { const href = await this.eval('window.location.href'); const match = href.match(/localhost:8888\/(.+)/); return match ? match[1] : null; }
async openPanel() { brightLog('🩸 Opening AC panel...'); // Use stored CDP host/port from findAestheticTarget, or find dynamically const cdpHost = this.cdpHost || (await findWorkingCDPHost()).host; const cdpPort = this.cdpPort || (await findWorkingCDPHost()).port; // We need to execute the VS Code command in the main workbench context // First, get all targets const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); // Find the main workbench target (type: 'page', url contains 'workbench.html') const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { darkLog('💔 Could not find VS Code workbench target'); return; } // Connect to workbench and execute command - URL might already have correct host let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { // Handle both localhost:PORT and localhost (without port) wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); }); // Execute the command const cmdId = Math.floor(Math.random() * 1000000); ws.send(JSON.stringify({ id: cmdId, method: 'Runtime.evaluate', params: { expression: `vscode.commands.executeCommand('aestheticComputer.openWindow')`, awaitPromise: true } })); await new Promise(resolve => setTimeout(resolve, 1500)); // Wait for panel to open ws.close(); brightLog('🩸 AC panel opened'); }
// Wait for boot/piece to be fully ready before activating audio // NOTE: `window.currentPiece` does not exist — currentPiece is a local // variable inside bios.mjs boot(). The reliable signal is `window.preloaded` // which is set to true by bios when "disk-loaded-and-booted" fires. async waitForBoot(timeoutMs = 15000) { brightLog('🩸 Waiting for boot to complete...');
const startTime = Date.now(); let lastLogTime = 0;
while (Date.now() - startTime < timeoutMs) { const bootStatus = await this.eval(`({ preloaded: window.preloaded === true, hasSend: typeof window.acSEND === 'function', hasActivateSound: typeof window.activateSound === 'function', canvasExists: !!document.querySelector('canvas'), locationPath: window.location?.pathname || '', hasAudioContext: !!window.audioContext })`);
// Boot is complete when preloaded is true and acSEND is available if (bootStatus.preloaded && bootStatus.hasSend) { const elapsed = Date.now() - startTime; brightLog(`🩸 Boot complete in ${elapsed}ms (path: ${bootStatus.locationPath})`); return true; }
// Log status every 2 seconds for debugging const elapsed = Date.now() - startTime; if (elapsed - lastLogTime > 2000) { darkLog(`🩸 Waiting... preloaded=${bootStatus.preloaded}, hasSend=${bootStatus.hasSend}, canvas=${bootStatus.canvasExists}, path=${bootStatus.locationPath}`); lastLogTime = elapsed; }
await new Promise(r => setTimeout(r, 100)); }
darkLog('⚠️ Boot timeout - proceeding anyway'); return false; }
// Wait for a specific piece to be fully loaded and ready. // More targeted than waitForBoot — checks URL path and preloaded signal. async waitForPiece(expectedPath = null, timeoutMs = 10000) { const label = expectedPath ? `"${expectedPath}"` : 'piece'; darkLog(`🩸 Waiting for ${label} to load...`);
const startTime = Date.now();
while (Date.now() - startTime < timeoutMs) { const status = await this.eval(`({ preloaded: window.preloaded === true, hasSend: typeof window.acSEND === 'function', path: window.location?.pathname || '', hasCanvas: !!document.querySelector('canvas'), })`);
const pathOk = !expectedPath || status.path?.includes(expectedPath); if (status.preloaded && status.hasSend && pathOk) { const elapsed = Date.now() - startTime; brightLog(`🩸 ${label} ready in ${elapsed}ms`); return { ready: true, ...status }; }
await new Promise(r => setTimeout(r, 150)); }
darkLog(`⚠️ ${label} wait timeout after ${timeoutMs}ms`); return { ready: false, timedOut: true }; }
async activateAudio() { brightLog('🩸 Activating audio context...');
// FIRST: Wait for boot to complete so activateSound listener exists await this.waitForBoot();
// Dispatch real pointerdown event to trigger activateSound listener in bios await this.eval(` (function() { const event = new PointerEvent('pointerdown', { bubbles: true, cancelable: true, view: window, clientX: 100, clientY: 100 }); window.dispatchEvent(event); console.log('🩸 Dispatched pointerdown event'); })() `);
await new Promise(r => setTimeout(r, 300));
// Click canvas multiple times for good measure for (let clickAttempt = 0; clickAttempt < 2; clickAttempt++) { await this.click(100 + clickAttempt * 20, 100 + clickAttempt * 20); await new Promise(r => setTimeout(r, 100)); }
// Manually resume AudioContext if it exists and is suspended await this.eval(` (async function() { if (window.audioContext) { if (window.audioContext.state === 'suspended') { try { await window.audioContext.resume(); console.log('🩸 AudioContext manually resumed'); } catch (e) { console.warn('Failed to resume AudioContext:', e); } } } })() `);
await new Promise(r => setTimeout(r, 500));
// Wait for audio context to actually be running // Check audioWorkletReady flag set by bios when speaker processor is connected const maxAttempts = 50; // 10 seconds max for (let i = 0; i < maxAttempts; i++) { const status = await this.eval(`({ workletReady: window.audioWorkletReady, audioState: window.audioContext?.state, hasAudioContext: !!window.audioContext })`);
if (status.workletReady) { brightLog('🩸 Audio worklet is ready'); return; }
if (i % 5 === 0 && i > 0) { darkLog(`🩸 Waiting for audio... (workletReady: ${status.workletReady}, state: ${status.audioState}, hasContext: ${status.hasAudioContext})`); // Click again and try to resume every 5 attempts await this.click(100, 100); await this.eval(` window.audioContext?.resume?.().catch(e => console.warn('Resume failed:', e)) `); }
await new Promise(r => setTimeout(r, 200)); }
// Final desperate attempt brightLog('🩸 Final activation attempt - clicking and resuming...'); await this.click(100, 100); await this.eval(`window.audioContext?.resume?.()`); await new Promise(r => setTimeout(r, 1000));
const finalStatus = await this.eval(`({ workletReady: window.audioWorkletReady, audioState: window.audioContext?.state, hasAudioContext: !!window.audioContext })`);
if (!finalStatus.workletReady) { const error = `Audio worklet failed to initialize (context state: ${finalStatus.audioState}, hasContext: ${finalStatus.hasAudioContext})`; darkLog(`❌ ${error}`); throw new Error(error); } }
async type(text) { brightLog(`🩸 Typing: ${text}`); for (const char of text) { await this.send('Input.dispatchKeyEvent', { type: 'keyDown', text: char }); await this.send('Input.dispatchKeyEvent', { type: 'keyUp', text: char }); } }
async pressKey(key) { brightLog(`🩸 Pressing: ${key}`); const keyMap = { 'escape': 'Escape', 'esc': 'Escape', 'enter': 'Enter', 'tab': 'Tab', 'backspace': 'Backspace', 'delete': 'Delete', 'arrowup': 'ArrowUp', 'arrowdown': 'ArrowDown', 'arrowleft': 'ArrowLeft', 'arrowright': 'ArrowRight', 'space': ' ' }; const keyCode = keyMap[key.toLowerCase()] || key; await this.send('Input.dispatchKeyEvent', { type: 'keyDown', key: keyCode }); await this.send('Input.dispatchKeyEvent', { type: 'keyUp', key: keyCode }); }
async click(x, y) { brightLog(`🩸 Clicking at: ${x}, ${y}`); await this.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 }); await this.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 }); }
async moveMouse(x, y) { await this.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }); }
close() { this.shouldReconnect = false; if (this.reconnectInterval) { clearInterval(this.reconnectInterval); this.reconnectInterval = null; } if (this.ws) this.ws.close(); } // Static method to open panel without needing AC connection static async openPanelStandalone() { brightLog('🩸 Opening AC panel...'); // Find working CDP host dynamically const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); // Get all targets const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); // Find the main workbench target const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } // Connect to workbench - URL might already have correct host from socat let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { // Handle both localhost:PORT and localhost (without port) wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout connecting to workbench')), 5000); }); // Wait for response to get element coordinates let resolveResponse; const responsePromise = new Promise(resolve => { resolveResponse = resolve; }); ws.on('message', (data) => { const msg = JSON.parse(data); if (msg.id === 1000) { resolveResponse(msg); } }); // Check panel state and toggle if needed using Enter key (which works!) ws.send(JSON.stringify({ id: 1000, method: 'Runtime.evaluate', params: { expression: ` (function() { // Find AC panel by text content since aria-label doesn't contain 'Aesthetic Computer' const headers = Array.from(document.querySelectorAll('.pane-header')); const header = headers.find(h => h.textContent?.includes('Aesthetic Computer')); if (!header) return { found: false }; const isExpanded = header.getAttribute('aria-expanded') === 'true'; if (!isExpanded) { // Focus and press Enter to expand header.focus(); const enterEvent = new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true }); header.dispatchEvent(enterEvent); const keyupEvent = new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true }); header.dispatchEvent(keyupEvent); return { found: true, toggled: true }; } else { return { found: true, isExpanded: true }; } })() `, returnByValue: true } })); const response = await responsePromise; if (response.result && response.result.result && response.result.result.value && response.result.result.value.found) { const { isExpanded, toggled } = response.result.result.value; if (toggled) { await new Promise(resolve => setTimeout(resolve, 300)); // Wait for panel to open brightLog('🩸 AC panel opened'); } else if (isExpanded) { darkLog(`🩸 Panel already open`); } } else { darkLog('💔 Could not find Aesthetic Computer panel'); } ws.close(); } // Static method to close the panel static async closePanelStandalone() { brightLog('🩸 Closing AC panel...'); const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { // Handle both localhost:PORT and localhost (without port) wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout')), 5000); }); let resolveResponse; const responsePromise = new Promise(resolve => { resolveResponse = resolve; }); ws.on('message', (data) => { const msg = JSON.parse(data); if (msg.id === 1000) { resolveResponse(msg); } }); // Find panel and toggle if expanded using Enter key ws.send(JSON.stringify({ id: 1000, method: 'Runtime.evaluate', params: { expression: ` (function() { // Find AC panel by text content since aria-label doesn't contain 'Aesthetic Computer' const headers = Array.from(document.querySelectorAll('.pane-header')); const header = headers.find(h => h.textContent?.includes('Aesthetic Computer')); if (!header) return { found: false }; const isExpanded = header.getAttribute('aria-expanded') === 'true'; if (isExpanded) { // Focus and press Enter to collapse header.focus(); const enterEvent = new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true }); header.dispatchEvent(enterEvent); header.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true })); return { found: true, closed: true }; } else { return { found: true, alreadyClosed: true }; } })() `, returnByValue: true } })); const response = await responsePromise; if (response.result?.result?.value?.found) { const { closed, alreadyClosed } = response.result.result.value; if (closed) { await new Promise(resolve => setTimeout(resolve, 300)); brightLog('🩸 AC panel closed'); } else if (alreadyClosed) { darkLog('🩸 Panel already closed'); } } ws.close(); } // Static method to toggle the panel open/closed static async togglePanelStandalone() { const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout')), 5000); }); let resolveResponse; const responsePromise = new Promise(resolve => { resolveResponse = resolve; }); ws.on('message', (data) => { const msg = JSON.parse(data); if (msg.id === 1000) { resolveResponse(msg); } }); // Toggle panel state using Enter key ws.send(JSON.stringify({ id: 1000, method: 'Runtime.evaluate', params: { expression: ` (function() { // Find AC panel by text content since aria-label doesn't contain 'Aesthetic Computer' const headers = Array.from(document.querySelectorAll('.pane-header')); const header = headers.find(h => h.textContent?.includes('Aesthetic Computer')); if (!header) return { found: false }; const wasExpanded = header.getAttribute('aria-expanded') === 'true'; // Focus and press Enter to toggle header.focus(); const enterEvent = new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true }); header.dispatchEvent(enterEvent); header.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true })); return { found: true, wasExpanded, nowExpanded: !wasExpanded }; })() `, returnByValue: true } })); const response = await responsePromise; let result = { toggled: false, nowExpanded: false }; if (response.result?.result?.value?.found) { const { wasExpanded, nowExpanded } = response.result.result.value; await new Promise(resolve => setTimeout(resolve, 300)); if (nowExpanded) { brightLog('🩸 AC panel opened'); } else { brightLog('🩸 AC panel closed'); } result = { toggled: true, nowExpanded }; } else { darkLog('💔 Could not find Aesthetic Computer panel'); } ws.close(); return result; } // Reload KidLisp.com page via CDP (close panel and reopen fresh) static async reloadKidLispWindow() { const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); const kidlispTarget = targetsJson.find(t => t.url?.includes('kidlisp.com')); if (!kidlispTarget) { // If no page open, open it instead return Artery.openKidLispWindow(); } // Close existing panel via command palette, then reopen brightLog('🔄 Closing KidLisp.com panel...'); // Connect to workbench to close the panel via command palette const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout')), 5000); }); let msgId = 1; const send = (method, params = {}) => { const id = msgId++; ws.send(JSON.stringify({ id, method, params })); return id; }; // Press F1 to open command palette send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 }); await new Promise(r => setTimeout(r, 300)); // Type close command - close active editor, not all panels const cmd = '>View: Close Editor'; for (const char of cmd) { send('Input.dispatchKeyEvent', { type: 'char', text: char }); await new Promise(r => setTimeout(r, 20)); } await new Promise(r => setTimeout(r, 400)); // Press Enter send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }); await new Promise(r => setTimeout(r, 500)); ws.close(); // Now reopen fresh await Artery.openKidLispWindow(); brightLog('🔄 KidLisp.com reloaded (close + reopen)'); }
// Static method to open KidLisp.com window in VS Code static async openKidLispWindow() { brightLog('🌈 Opening KidLisp.com window...'); const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout connecting to workbench')), 5000); }); let msgId = 1; const send = (method, params = {}) => { const id = msgId++; ws.send(JSON.stringify({ id, method, params })); return id; }; // Use keyboard simulation to open command palette and run the command // Press F1 to open command palette send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 }); await new Promise(r => setTimeout(r, 300)); // Wait for palette to open // Type the command const cmd = '>KidLisp.com: Open'; for (const char of cmd) { send('Input.dispatchKeyEvent', { type: 'char', text: char }); await new Promise(r => setTimeout(r, 20)); } await new Promise(r => setTimeout(r, 400)); // Wait for results // Press Enter to execute send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }); await new Promise(resolve => setTimeout(resolve, 500)); // Wait for window to open ws.close(); brightLog('🌈 KidLisp.com window opened'); }
// Static method to open News window in VS Code static async openNewsWindow() { brightLog('📰 Opening News window...'); const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout connecting to workbench')), 5000); }); let msgId = 1; const send = (method, params = {}) => { const id = msgId++; ws.send(JSON.stringify({ id, method, params })); return id; }; // Use keyboard simulation to open command palette and run the command send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'F1', code: 'F1', windowsVirtualKeyCode: 112 }); await new Promise(r => setTimeout(r, 300)); const cmd = '>News: Open'; for (const char of cmd) { send('Input.dispatchKeyEvent', { type: 'char', text: char }); await new Promise(r => setTimeout(r, 20)); } await new Promise(r => setTimeout(r, 400)); send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }); await new Promise(resolve => setTimeout(resolve, 500)); ws.close(); brightLog('📰 News window opened'); } // Toggle local development mode (localhost:8888 vs aesthetic.computer) static async toggleLocalDevelopment() { brightLog('🩸 Toggling local development mode...'); const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json', headers: { 'Host': 'localhost' } }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); const workbenchTarget = targetsJson.find(t => t.type === 'page' && t.url && t.url.includes('workbench.html') ); if (!workbenchTarget) { throw new Error('Could not find VS Code workbench target'); } let wsUrl = workbenchTarget.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { // Handle both localhost:PORT and localhost (without port) wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout')), 5000); }); // Execute the toggle command via VS Code's command palette ws.send(JSON.stringify({ id: 2000, method: 'Runtime.evaluate', params: { expression: ` (async function() { // Execute VS Code command to toggle local development await vscode.commands.executeCommand('aestheticComputer.localServer'); return { success: true }; })() `, awaitPromise: true, returnByValue: true } })); await new Promise(resolve => setTimeout(resolve, 1000)); brightLog('🩸 Local development mode toggled'); ws.close(); } // Close all editor tabs in VS Code static async closeAllEditors() { brightLog('🩸 Closing all editor tabs...'); const { host: cdpHost, port: cdpPort } = await findWorkingCDPHost(); const targetsJson = await new Promise((resolve, reject) => { const req = http.get({ hostname: cdpHost, port: cdpPort, path: '/json' }, (res) => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve(JSON.parse(data))); }); req.on('error', reject); req.end(); }); // Find VS Code workbench for keyboard shortcut method const workbench = targetsJson.find(t => t.url && t.url.includes('workbench.html') ); if (!workbench) { redLog('💔 VS Code workbench not found'); process.exit(1); } let wsUrl = workbench.webSocketDebuggerUrl; if (wsUrl.includes('localhost')) { wsUrl = wsUrl.replace(/localhost(:\d+)?/, `${cdpHost}:${cdpPort}`); } const ws = new WebSocket(wsUrl); await new Promise((resolve, reject) => { ws.on('open', () => resolve()); ws.on('error', reject); setTimeout(() => reject(new Error('Timeout')), 5000); }); let msgId = 1; const send = (method, params = {}) => { const id = msgId++; ws.send(JSON.stringify({ id, method, params })); return id; }; // Use CDP Input.dispatchKeyEvent to simulate Ctrl+K, W chord // which is the VS Code keybinding for "Close All Editors in Group" // First: Ctrl+K (first part of chord) send('Input.dispatchKeyEvent', { type: 'keyDown', modifiers: 2, // Ctrl key: 'k', code: 'KeyK', windowsVirtualKeyCode: 75 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', modifiers: 2, key: 'k', code: 'KeyK', windowsVirtualKeyCode: 75 }); await new Promise(r => setTimeout(r, 50)); // Second: W (second part of chord, no modifier) send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'w', code: 'KeyW', windowsVirtualKeyCode: 87 }); await new Promise(r => setTimeout(r, 50)); send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'w', code: 'KeyW', windowsVirtualKeyCode: 87 }); await new Promise(resolve => setTimeout(resolve, 200)); brightLog('🩸 All editor tabs closed'); ws.close(); } // ═══════════════════════════════════════════════════════════════════════════ // 🧠 Emacs Integration - Execute elisp via emacsclient // ═══════════════════════════════════════════════════════════════════════════ /** * Execute Emacs Lisp code via emacsclient * @param {string} code - The elisp code to execute * @returns {Promise<string>} - The result from Emacs */ static async execEmacs(code) { const { spawn } = await import('child_process'); const emacsclient = process.env.EMACSCLIENT || '/usr/sbin/emacsclient'; return new Promise((resolve, reject) => { const proc = spawn(emacsclient, ['--eval', code]); let stdout = ''; let stderr = ''; proc.stdout.on('data', (data) => { stdout += data.toString(); }); proc.stderr.on('data', (data) => { stderr += data.toString(); }); proc.on('close', (exitCode) => { if (exitCode === 0) { resolve(stdout.trim()); } else { reject(new Error(stderr.trim() || `emacsclient exited with code ${exitCode}`)); } }); proc.on('error', (err) => { reject(new Error(`Failed to start emacsclient: ${err.message}`)); }); }); } /** * Get list of Emacs buffers * @returns {Promise<string[]>} - Array of buffer names */ static async emacsListBuffers() { const result = await Artery.execEmacs(` (mapcar #'buffer-name (buffer-list)) `); // Parse the lisp list format: (#<buffer name> ...) // The output is like: ("buffer1" "buffer2" ...) const match = result.match(/\("([^"]+)"(?:\s+"([^"]+)")*\)/); if (match) { return result.slice(1, -1).split('" "').map(s => s.replace(/^"|"$/g, '')); } return result.split('\n').filter(Boolean); } /** * Switch to a buffer in Emacs * @param {string} bufferName - Name of the buffer to switch to */ static async emacsSwitchBuffer(bufferName) { return Artery.execEmacs(`(switch-to-buffer "${bufferName}")`); } /** * Open a file in Emacs * @param {string} filePath - Path to the file to open */ static async emacsOpenFile(filePath) { return Artery.execEmacs(`(find-file "${filePath}")`); } /** * Get current buffer content (first N characters) * @param {string} bufferName - Buffer name * @param {number} maxChars - Maximum characters to return (default 1000) */ static async emacsGetBufferContent(bufferName, maxChars = 1000) { return Artery.execEmacs(` (with-current-buffer "${bufferName}" (buffer-substring-no-properties (point-min) (min (point-max) (+ (point-min) ${maxChars})))) `); } /** * Insert text at cursor position in Emacs * @param {string} text - Text to insert */ static async emacsInsert(text) { // Escape quotes and backslashes in the text const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"'); return Artery.execEmacs(`(insert "${escaped}")`); } /** * Get Emacs version and check if server is running */ static async emacsVersion() { return Artery.execEmacs('(emacs-version)'); }}
async function main() { const command = process.argv[2]; const args = process.argv.slice(3); // Panel command doesn't need AC connection if (command === 'panel') { try { await Artery.openPanelStandalone(); process.exit(0); } catch (error) { redLog(`💔 ${error.message}`); process.exit(1); } } // Emacs commands - don't need AC connection if (command === 'emacs') { try { const elisp = args.join(' '); if (!elisp) { // Show Emacs version if no args const version = await Artery.emacsVersion(); brightLog('🧠 Emacs connected'); console.log(version); } else { // Execute the elisp brightLog(`🧠 Executing: ${elisp}`); const result = await Artery.execEmacs(elisp); console.log(result); } process.exit(0); } catch (error) { redLog(`💔 ${error.message}`); process.exit(1); } } if (command === 'emacs-buffers') { try { const result = await Artery.execEmacs('(mapcar #\'buffer-name (buffer-list))'); brightLog('🧠 Emacs Buffers:'); // Parse and display buffers const buffers = result.slice(1, -1).split(' ').map(s => s.replace(/^"|"$/g, '')); buffers.forEach(b => console.log(` ${b}`)); process.exit(0); } catch (error) { redLog(`💔 ${error.message}`); process.exit(1); } } // Toggle local development mode if (command === 'toggle-local') { try { await Artery.toggleLocalDevelopment(); process.exit(0); } catch (error) { redLog(`💔 ${error.message}`); process.exit(1); } } // Performance monitoring command if (command === 'perf') { const client = new Artery(); try { await client.connect(true); await client.enableConsole(); const duration = parseInt(args[0]) || 5; // Default 5 seconds brightLog(`🩸 WEBGPU PERFORMANCE MONITOR (${duration}s)`); console.log('═'.repeat(50)); const samples = []; const startTime = Date.now(); // Sample performance every 100ms const interval = setInterval(async () => { try { const stats = await client.eval(` (function() { // Try to get WebGPU stats from the renderer const webgpu = window.WebGPU; if (webgpu && typeof webgpu.getPerfStats === 'function') { return webgpu.getPerfStats(); } return null; })() `); if (stats) { samples.push(stats); const bar = '█'.repeat(Math.min(50, Math.floor(stats.fps / 2))); const msBar = stats.frameDelta < 16.67 ? '🟢' : stats.frameDelta < 33.33 ? '🟡' : '🔴'; console.log(`${msBar} FPS: ${String(stats.fps).padStart(3)} | MS: ${stats.frameDelta.toFixed(1).padStart(5)} | DC: ${String(stats.drawCalls).padStart(4)} | ${bar}`); } } catch (e) { // Ignore eval errors during sampling } }, 100); // Stop after duration setTimeout(() => { clearInterval(interval); console.log('═'.repeat(50)); if (samples.length > 0) { const avgFps = samples.reduce((a, s) => a + s.fps, 0) / samples.length; const avgMs = samples.reduce((a, s) => a + s.frameDelta, 0) / samples.length; const minFps = Math.min(...samples.map(s => s.fps)); const maxFps = Math.max(...samples.map(s => s.fps)); const avgDc = samples.reduce((a, s) => a + s.drawCalls, 0) / samples.length; brightLog('📊 SUMMARY'); console.log(` Samples: ${samples.length}`); console.log(` Avg FPS: ${avgFps.toFixed(1)}`); console.log(` Min FPS: ${minFps}`); console.log(` Max FPS: ${maxFps}`); console.log(` Avg MS: ${avgMs.toFixed(2)}`); console.log(` Avg DC: ${avgDc.toFixed(0)}`); } else { darkLog('💔 No WebGPU stats available. Make sure:'); console.log(' 1. WebGPU mode is enabled (api.webgpu.enabled = true)'); console.log(' 2. Perf overlay is on (api.webgpu.perf(true))'); } console.log('═'.repeat(50)); client.close(); process.exit(0); }, duration * 1000); return; // Keep process alive } catch (error) { redLog(`💔 ${error.message}`); process.exit(1); } } const client = new Artery(); try { const isRepl = command === 'repl'; // Handle frames command before connecting (needs raw target listing) if (command === 'frames') { const frames = await client.listACFrames(); if (frames.length === 0) { redLog('💔 No AC frames found'); process.exit(1); } brightLog('🩸 AC Frames:'); for (const frame of frames) { const prefix = frame.player === 0 ? ' 📺' : ` 🎮`; console.log(`${prefix} ${frame.label}`); console.log(` ${PINK}${frame.url}${RESET}`); } process.exit(0); } // Handle player-specific connection if (command === 'player') { const playerNum = parseInt(args[0]); if (isNaN(playerNum) || playerNum < 0 || playerNum > 2) { redLog('💔 Usage: artery player <0|1|2>'); console.log(' 0 = Main frame'); console.log(' 1 = Player 1 (top split)'); console.log(' 2 = Player 2 (bottom split)'); process.exit(1); } await client.connectToPlayer(playerNum); await client.enableConsole(); brightLog(`🩸 Connected to Player ${playerNum}, streaming console...`); // Keep alive for console streaming return; } // Handle close-editors before trying to connect to AC frame if (command === 'close-editors') { await Artery.closeAllEditors(); process.exit(0); } // Handle kidlisp command (open KidLisp window) before connecting to AC if (command === 'kidlisp') { await Artery.openKidLispWindow(); process.exit(0); } await client.connect(isRepl); if (isRepl) await client.enableConsole(); switch (command) { case 'jump': if (!args[0]) { redLog('💔 Missing piece'); process.exit(1); } await client.jump(args[0]); brightLog(`🩸 Jumped!`); break; case 'current': const current = await client.getCurrentPiece(); brightLog(`🩸 Current: ${current || '(none)'}`); break; case 'eval': const expr = args.join(' '); if (!expr) { redLog('💔 Missing expression'); process.exit(1); } const result = await client.eval(expr); brightLog('🩸 Result:'); console.log(result); break; case 'type': const text = args.join(' '); if (!text) { redLog('💔 Missing text'); process.exit(1); } await client.type(text); brightLog('🩸 Typed!'); break; case 'key': if (!args[0]) { redLog('💔 Missing key'); process.exit(1); } await client.pressKey(args[0]); brightLog('🩸 Pressed!'); break; case 'click': const x = parseInt(args[0]); const y = parseInt(args[1]); if (isNaN(x) || isNaN(y)) { redLog('💔 Usage: artery click <x> <y>'); process.exit(1); } await client.click(x, y); brightLog('🩸 Clicked!'); break; case 'audio': await client.activateAudio(); brightLog('🩸 Audio activated!'); break; case 'hiphop': // Close the client we just opened (hiphop manages its own) client.close(); // Dynamically import and run the hiphop test with remaining args const { main: runHiphop } = await import('./test-hiphop.mjs'); // Override process.argv for the test to parse process.argv = ['node', 'test-hiphop.mjs', ...args]; await runHiphop(); return; case 'trapwaltz': // Close the client we just opened (trapwaltz manages its own) client.close(); const { main: runTrapwaltz } = await import('./test-trapwaltz.mjs'); process.argv = ['node', 'test-trapwaltz.mjs', ...args]; await runTrapwaltz(); return; case '1v1': case 'split': // Close the client we just opened (1v1 manages its own) client.close(); const { main: run1v1 } = await import('./test-1v1-split.mjs'); process.argv = ['node', 'test-1v1-split.mjs', ...args]; await run1v1(); return; case 'kidlisp-test': // Close the client we just opened (kidlisp test manages its own) client.close(); process.argv = ['node', 'test-kidlisp.mjs', ...args]; await import('./test-kidlisp.mjs'); return; case 'repl': // Clear screen and show header console.clear(); console.log('═'.repeat(70)); brightLog('🩸 ARTERY REPL - Live connection to Aesthetic Computer'); console.log('═'.repeat(70)); console.log(''); console.log(' Commands:'); console.log(` ${PINK}.jump <piece>${RESET} - Navigate to piece`); console.log(` ${PINK}.current${RESET} - Show current piece`); console.log(` ${PINK}.type <text>${RESET} - Type text into AC`); console.log(` ${PINK}.key <key>${RESET} - Press key (escape, enter, tab, etc)`); console.log(` ${PINK}.click <x> <y>${RESET} - Click at coordinates`); console.log(` ${PINK}.audio${RESET} - Activate audio context`); console.log(` ${PINK}.panel${RESET} - Open/focus AC panel`); console.log(` ${PINK}.exit${RESET} - Close connection`); console.log(''); console.log(' Type any JavaScript to execute in AC context'); console.log(''); console.log('─'.repeat(70)); console.log(`${PURPLE_BG}${WHITE} AC CONSOLE OUTPUT ${RESET}`); console.log('─'.repeat(70)); console.log(''); const readline = await import('readline'); const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: `\n${RED_BG}${PINK}🩸 ${RESET} ` }); rl.prompt(); rl.on('line', async (line) => { const input = line.trim(); if (input === '.exit') { console.log(''); console.log('─'.repeat(70)); darkLog('🩸 Connection closed'); console.log('═'.repeat(70)); rl.close(); client.close(); process.exit(0); } else if (input.startsWith('.jump ')) { const p = input.substring(6).trim(); console.log(''); console.log('─'.repeat(70)); await client.jump(p); brightLog(`🩸 Navigated to: ${p}`); console.log('─'.repeat(70)); } else if (input === '.current') { const c = await client.getCurrentPiece(); console.log(''); console.log('─'.repeat(70)); brightLog(`🩸 Current piece: ${c || '(none)'}`); console.log('─'.repeat(70)); } else if (input.startsWith('.type ')) { const text = input.substring(6); console.log(''); console.log('─'.repeat(70)); await client.type(text); console.log('─'.repeat(70)); } else if (input.startsWith('.key ')) { const key = input.substring(5).trim(); console.log(''); console.log('─'.repeat(70)); await client.pressKey(key); console.log('─'.repeat(70)); } else if (input.startsWith('.click ')) { const parts = input.substring(7).split(' '); const x = parseInt(parts[0]); const y = parseInt(parts[1]); if (isNaN(x) || isNaN(y)) { redLog('💔 Usage: .click <x> <y>'); } else { console.log(''); console.log('─'.repeat(70)); await client.click(x, y); console.log('─'.repeat(70)); } } else if (input === '.audio') { console.log(''); console.log('─'.repeat(70)); await client.activateAudio(); console.log('─'.repeat(70)); } else if (input === '.panel') { console.log(''); console.log('─'.repeat(70)); await client.openPanel(); console.log('─'.repeat(70)); } else if (input) { try { console.log(''); console.log('─'.repeat(70)); console.log(`${PINK}↓ Result${RESET}`); const r = await client.eval(input); console.log(r); console.log('─'.repeat(70)); } catch (e) { console.log(''); console.log('─'.repeat(70)); redLog(`💔 Error: ${e.message}`); console.log('─'.repeat(70)); } } rl.prompt(); }); rl.on('close', () => { client.close(); process.exit(0); }); break; default: brightLog('🩸 ARTERY'); console.log(''); console.log('artery jump <piece> - Navigate to piece'); console.log('artery current - Show current piece'); console.log('artery eval <expr> - Evaluate JavaScript in AC'); console.log('artery type <text> - Type text into AC'); console.log('artery key <key> - Press key'); console.log('artery click <x> <y> - Click at coordinates'); console.log('artery audio - Activate audio context'); console.log('artery panel - Open AC sidebar panel'); console.log('artery perf [seconds] - Monitor WebGPU performance'); console.log('artery repl - Interactive REPL mode'); console.log(''); console.log('🧠 Emacs:'); console.log('artery emacs - Show Emacs version'); console.log('artery emacs <elisp> - Execute elisp in Emacs'); console.log('artery emacs-buffers - List Emacs buffers'); console.log(''); console.log('🎮 Split/Multiplayer:'); console.log('artery frames - List all AC frames (main + players)'); console.log('artery player <0|1|2> - Connect to specific player frame'); console.log(' 0=main, 1=player1 (top), 2=player2 (bottom)'); console.log(''); console.log('🧪 Tests:'); console.log('artery hiphop [opts] - Hip-hop beat generator test'); console.log('artery trapwaltz [opts] - Trap waltz generator (3/4 + trap)'); console.log('artery 1v1 [p1] [p2] - Test split view for 1v1 dueling'); console.log('artery kidlisp-test [suite] - Run KidLisp.com test suite'); console.log(' Suites: basic, editor, playback, ui, console, examples, errors, all'); console.log(''); console.log('🛠️ Utilities:'); console.log('artery kidlisp - Open KidLisp.com window in VS Code'); console.log('artery close-editors - Close all VS Code editor tabs'); } setTimeout(() => { client.close(); process.exit(0); }, 1000); } catch (error) { redLog(`💔 ${error.message}`); process.exit(1); }}
if (import.meta.url === `file://${process.argv[1]}`) { main();}
// Export both Artery class and CDP module for convenienceexport default Artery;export { CDP };