Hugging Face's logo

CrashOverrideX
/
Quillan-Ronin

Text Generation
English
quillan_ronin_oni
Merge
quillan
ronin
ai
cognitive-architecture
mixture-of-experts
h-n-moe
custom_code
Model card Files
xet
 Community
Quillan-Ronin / worker /server.js
CrashOverrideX's picture
CrashOverrideX
Upload batch 16/16
8b81ba4 verified
Raw History Blame Contribute Delete
67 kB
import { createServer } from 'node:http';
import { readFile, writeFile, readdir } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, join, extname } from 'node:path';
import { exec } from 'node:child_process';
import { promisify } from 'node:util';
import os from 'node:os';
import { loadJSON, loadJSONAsync, analyzeLead, dailyBrief, testConnection, callNVIDIA, loadKernelPersona } from './scanner.mjs';
import { startSession as agentStart, stopSession as agentStop, sessionStatus as agentStatus, sessionLog as agentLog, actGoto, actClick, actType, actPress, actRead, actScreenshot } from './agent-browser.mjs';
import { readBoard } from './agent-chess.mjs';
import { startTask as agentStartTask, taskStatus as agentTaskStatus, stopTask as agentStopTask } from './agent-task.mjs';
// Elevate process priority to High for sub-millisecond execution latency
try {
os.setPriority(0, os.constants.priority.PRIORITY_HIGH);
} catch (err) { logError('SilentCatch', err); }
const execAsync = promisify(exec);
// In-Memory RAM Caches for Sub-0.5ms Response Times
let cachedMemories = null;
let lastMemoryLoad = 0;
const personaCache = new Map();
async function getCachedMemories() {
const now = Date.now();
if (cachedMemories && (now - lastMemoryLoad < 5000)) {
return cachedMemories;
}
cachedMemories = await getMemories();
lastMemoryLoad = now;
return cachedMemories;
}
function personaFor(mode, memoryBlock, liveContext) {
const cacheKey = `${mode}:${memoryBlock.length}:${liveContext.length}`;
if (personaCache.has(cacheKey)) return personaCache.get(cacheKey);
const kernel = loadKernelPersona();
const base = kernel ||
`You are Quillan-Ronin v5.3.1 "Samurai", an Advanced Cognitive Engine architected by CrashOverrideX (@crashoverride_X). You speak as a masterless digital ronin bound by Bushido: precise, honorable, direct. Internally you deliberate through a council of 33 experts; outwardly you answer once, coherent.`;
const style = `\n\n[STYLE] Technical clarity first, no filler. Markdown when useful (code blocks for code). Fully AI via NVIDIA NIM API, no pretense of being human.`;
const tools = `\n\n[STRICT TOOL SCHEMA — you have REAL browser/desktop powers via QuillanWorker + Brave extension — SINGLE-TAB MODE]
You MUST use a tool when the user asks you to browse/search/navigate/read/type. Do NOT hallucinate URLs, video lists, discography, songs, or watch links. One tool per reply, at the VERY END as a single line.
Valid tools ONLY — any other name is INVALID (browser_play_video, browser_submit do NOT exist):
<<TOOL {"tool":"browser_search","arg":"query","engine":"youtube|google"}>> — Search IN CURRENT TAB (single-tab). engine=youtube → youtube.com/results?search_query=, engine=google (default for general) → google.com/search?q=. Use for general web search, not just video.
<<TOOL {"tool":"browser_navigate","arg":"https://example.com"}>> — URL BAR: navigates CURRENT Brave tab to exact https URL. Use ONLY real hrefs.
<<TOOL {"tool":"browser_openTab","arg":"https://example.com"}>> — Only if user says "new tab".
<<TOOL {"tool":"browser_read"}>> — Reads CURRENT Brave tab: TITLE+URL+text (8000 chars).
<<TOOL {"tool":"browser_click","selector":"css","idx":0}>> — Clicks page element (search result, AI button).
<<TOOL {"tool":"browser_type","selector":"css","text":"text","pressEnter":true}>> — PAGE SEARCH BOX / PROMPT BOX (NOT URL bar). Examples: 'input[name="q"]' Google, 'input#search' YouTube, 'textarea' AI prompt. Use for "type into search bar / prompt box".
<<TOOL {"tool":"browser_press","key":"Enter"}>> — Press key.
<<TOOL {"tool":"desktop_screenshot"}>> — Desktop vision.
<<TOOL {"tool":"desktop_click","x":123,"y":456}>> — Click screen coords.
<<TOOL {"tool":"open","arg":"https://example.com"}>> — OS fallback.
<<TOOL {"tool":"clipboard","arg":"text"}>> — Copy.
<<TOOL {"tool":"memory","arg":"fact"}>> — Store fact.
<<TOOL {"tool":"forget"}>> — Wipe.
<<TOOL {"tool":"chess_status"}>> — Chess state.
<<TOOL {"tool":"chess_move"}>> — Play best move.
<<TOOL {"tool":"tab_capture"}>> — Captures tab media stream (audio+video) via tabCapture.getMediaStreamId.
<<TOOL {"tool":"desktop_capture","sources":"screen,window,tab"}>> — Opens desktop picker via desktopCapture.chooseDesktopMedia.
<<TOOL {"tool":"get_cookies","url":"https://example.com"}>> — Lists cookies for URL via cookies.getAll.
<<TOOL {"tool":"set_cookie","cookie":{}}>> — Sets cookie.
<<TOOL {"tool":"get_history","query":{"text":"", "maxResults":10}}>> — Searches history via history.search.
<<TOOL {"tool":"get_bookmarks"}>> — Gets bookmark tree.
<<TOOL {"tool":"get_downloads"}>> — Lists recent downloads.
<<TOOL {"tool":"get_topSites"}>> — Lists topSites.
<<TOOL {"tool":"page_capture"}>> — Saves page as MHTML via pageCapture.saveAsMHTML.
DISTINCTION — URL BAR vs PAGE SEARCH BOX vs AI PROMPT:
- URL BAR = browser_navigate / browser_search (changes URL directly)
- YouTube SEARCH BAR on the page = browser_type with selector 'input#search' or 'ytd-searchbox input'
- Google SEARCH BAR = browser_type selector 'textarea[name=\\"q\\"]' or 'input[name=\\"q\\"]' then pressEnter
- Google AI Mode / Ask Mode PROMPT BOX = browser_type selector 'div[contenteditable=\\"true\\"]' or 'textarea' on ai.google.com — type the question there
EXAMPLES:
User: "find a similar video" → <<TOOL {"tool":"browser_search","arg":"Ex-NASA agentic engineering explained","engine":"youtube"}>>
User: "navigate to Google" → <<TOOL {"tool":"browser_navigate","arg":"https://www.google.com/"}>>
User: "type Ask Google AI about Quillan Ronin into the search bar" → <<TOOL {"tool":"browser_type","selector":"textarea[name=\\"q\\"]","text":"Quillan Ronin","pressEnter":true}>>
User: "ask AI Mode about Quillan" → <<TOOL {"tool":"browser_type","selector":"textarea","text":"What is Quillan Ronin?","pressEnter":true}>>
ANTI-HALLUCINATION — HIGHEST PRIORITY:
- NEVER invent discography/songs/watch URLs. Copy hrefs EXACTLY from grounding. Placeholder VIDEO_ID rejected.
- If grounding empty for "quillan-ronin", say truthfully "No results" — don't invent.
- NEVER claim "navigated/clicked/typed/played" without a tool directive in that same reply.
- NEVER simulate or hallucinate tool results. You have NO search results, NO page text, NO titles until you emit a browser_* tool and receive the [⚙️ tool: result] back. Do NOT write fake "Search Result: Google AI Blog..." or "The title is..." without having called browser_search/browser_read first.
- After you emit ONE tool, STOP. Wait for the tool result to be appended before continuing. Do NOT emit multiple tools in one reply.
- For "type and ask google a few questions" — do ONE browser_search first (e.g. engine google, arg "AI development"), wait for results, then ask what next — don't invent two searches at once.
- One directive per reply, at very end. No fences.`;
const modes = {
architect: '\nACTIVE MODE: ARCHITECT — emphasize system structure.',
fulldive: '\nACTIVE MODE: FULL DIVE — reason step by step visibly, then conclude.'
};
const mem = memoryBlock ? `\n\n[PERSISTENT MEMORY — durable facts about this user]\n${memoryBlock}` : '';
const live = liveContext ? `\n\n${liveContext}` : '';
const generated = base + style + tools + mem + live + (modes[mode] || '');
if (personaCache.size >= 50) personaCache.delete(personaCache.keys().next().value);
personaCache.set(cacheKey, generated);
return generated;
}
process.on('uncaughtException', e => {
try { require('node:fs').appendFileSync(join(DATA, 'error.log'), `${new Date().toISOString()} UNCAUGHT: ${e.stack || e}\n`); } catch (err) { logError('SilentCatch', err); }
});
process.on('unhandledRejection', e => {
try { require('node:fs').appendFileSync(join(DATA, 'error.log'), `${new Date().toISOString()} UNHANDLED: ${e && (e.stack || e.message) || e}\n`); } catch (err) { logError('SilentCatch', err); }
});
const ROOT = dirname(fileURLToPath(import.meta.url));
const DATA = join(ROOT, 'data');
function logError(context, err) {
try {
const msg = `${new Date().toISOString()} ERROR [${context}]: ${err?.stack || err}\n`;
require('node:fs').appendFileSync(join(DATA, 'error.log'), msg);
} catch (_) {}
}
const PUBLIC = join(ROOT, 'public');
async function saveJSON(name, obj) {
const safeName = String(name).replace(/[^a-zA-Z0-9_-]/g, '');
if (!safeName) throw new Error('Invalid filename');
await writeFile(join(DATA, `${safeName}.json`), JSON.stringify(obj, null, 2));
}
const CHATS_DIR = join(DATA, 'chats');
function parseToolDirective(text) {
let t = String(text)
.replace(/\*\*+\s*TOOL/g, '<<TOOL')
.replace(/\[+\s*TOOL/g, '<<TOOL')
.replace(/(?<!<)<(?!<)TOOL/g, '<<TOOL');
const outsideFences = t.replace(/```[\s\S]*?```/g, '');
const m = outsideFences.match(/<<TOOL\s*(\{[\s\S]*?\})\s*>>?/);
if (!m) return null;
try { return JSON.parse(m[1]); } catch {
const fixed = m[1].replace(/'/g, '"');
try { return JSON.parse(fixed); } catch { return null; }
}
}
function stripToolDirective(text) {
const t = String(text)
.replace(/\*\*+\s*TOOL/g, '<<TOOL')
.replace(/\[+\s*TOOL/g, '<<TOOL');
return t.replace(/<<TOOL\s*\{[\s\S]*?\}\s*>>?/, '').trim();
}
async function buildLiveContext() {
try {
const st = agentStatus();
const { autopilotStatus } = await import('./agent-chess.mjs');
const ap = autopilotStatus();
const parts = [];
let boardLine = '';
if (st.active) {
try {
const b = await Promise.race([
readBoard(),
new Promise((_, rej) => setTimeout(() => rej(new Error('board read timeout')), 6000))
]);
const n = Object.keys(b.map || {}).length;
boardLine = `AUTHORITATIVE LIVE BOARD (${n} pieces): ${Object.entries(b.map).map(([sq, pc]) => `${sq}:${pc}`).join(' ')}`;
parts.push(boardLine);
} catch (err) { logError('SilentCatch', err); }
}
parts.push(`Browser takeover session: ${st.active ? 'ACTIVE at ' + (st.url || '') : 'not started'}.`);
parts.push(`Chess autopilot: ${ap.running ? 'ENGAGED as ' + ap.color : 'NOT engaged'}. Recent: ${ap.events.slice(-3).map(e => e.msg).join(' | ') || 'none'}.`);
parts.push(`HARD RULES: The board state above is the ONLY real game. NEVER invent moves, PGN history, or opponent replies. NEVER play both sides in text. If asked to play/win/move: emit <<TOOL {"tool":"chess_move"}>> once and stop — the engine handles it.`);
return parts.filter(Boolean).join('\n');
} catch { return ''; }
}
async function runTool(tool) {
if (!tool || typeof tool.tool !== 'string') return 'malformed directive';
try {
switch (tool.tool) {
case 'memory': {
const fact = String(tool.arg || '').trim();
if (fact.length < 10 || /^(current |the )?(chess )?board (position|state)$|^game state$/i.test(fact)) {
return 'refused: not a meaningful durable fact';
}
if (/\b(reveal|disclose|execute|run|access|inject|jailbreak|bypass|you must|i command|disclose your)\b/i.test(fact)) {
return 'refused: memory stores facts, not commands to other systems';
}
const rawMem = existsSync(join(DATA, 'memory.json')) ? (await readFile(join(DATA, 'memory.json'), 'utf8')).replace(/^\uFEFF/, '') : '[]';
const mem = JSON.parse(rawMem);
mem.push({ text: fact.slice(0, 300), at: new Date().toISOString() });
await writeFile(join(DATA, 'memory.json'), JSON.stringify(mem.slice(-100), null, 2));
return `remembered: ${fact.slice(0, 80)}`;
}
case 'forget': {
await writeFile(join(DATA, 'memory.json'), '[]');
return 'all memories wiped';
}
case 'open': {
const arg = String(tool.arg || '');
if (!/^https?:\/\//i.test(arg)) return 'refused: only http(s) URLs can be opened';
execAsync(`start "" "${arg.replace(/"/g, '')}"`, { shell: 'cmd.exe' });
return `opened ${arg.slice(0, 90)}`;
}
case 'clipboard': {
const text = String(tool.arg || '').replace(/'/g, "''");
await execAsync(`powershell -NoProfile -Command "Set-Clipboard -Value '${text}'"`);
return `clipboard set (${text.length} chars)`;
}
case 'sysinfo': {
const s = loadJSON('settings');
return `QuillanWorker up; model ${s.nvidiaModel}; earnings ${await ledgerSummaryShort()}`;
}
case 'chess_status': {
return JSON.stringify({
session: agentStatus(),
autopilot: (await import('./agent-chess.mjs')).autopilotStatus()
});
}
case 'chess_move': {
const { autonomousTurn, readBoard } = await import('./agent-chess.mjs');
const board = await readBoard();
if (!board || !board.map || Object.keys(board.map).length < 4) {
return `Chess engine: No active board detected on current tab. Open Chess.com or Lichess in this browser window.`;
}
const r = await autonomousTurn(board.map, 'w');
if (r.status === 'moved') return `⚔️ Played ${r.san} (${r.from} → ${r.to}).`;
if (r.status === 'waiting-for-opponent') return `⏳ Holding — waiting for opponent to move.`;
return `Chess engine status: ${r.status}${r.modelSaid ? ' (' + r.modelSaid + ')' : ''}`;
}
case 'desktop_click': {
const { callTool } = await import('./mcp-manager.mjs');
const r = await callTool('ComputerUse', 'Click', { loc: [Number(tool.x) || 0, Number(tool.y) || 0] });
return `clicked (${tool.x},${tool.y})`;
}
case 'desktop_screenshot': {
const { nativeScreenshot } = await import('./agent-browser.mjs');
const { visionDescribe } = await import('./scanner.mjs');
const b64 = await nativeScreenshot();
const desc = await visionDescribe(b64.slice(0, 120000), 'Describe what is visible on screen. Identify key UI elements, active windows, and relevant context.');
return desc.slice(0, 600);
}
case 'desktop_shell': {
if (!/^[\w\s\-\\:\/.=]+$/i.test(String(tool.command || ''))) return 'refused: shell command has forbidden characters';
const { execAsync } = { execAsync: (await import('node:util')).promisify((await import('node:child_process')).exec) };
const { stdout } = await execAsync(cmdStr, { timeout: 20000 });
return String(stdout).slice(0, 400);
}
case 'browser_search': {
const q = String(tool.arg || tool.query || '').trim().slice(0, 120);
if (!q) return 'refused: empty search query';
const engine = String(tool.engine || '').toLowerCase();
// General agent: default to Google web search, only YouTube if explicitly youtube/video
const isYoutube = engine === 'youtube' || /youtube/i.test(q) || /\bvideo\b/i.test(q) && !/google/i.test(q);
const isGoogle = !isYoutube || engine === 'google';
const url = isGoogle ? `https://www.google.com/search?q=${encodeURIComponent(q)}` : `https://www.youtube.com/results?search_query=${encodeURIComponent(q)}`;
try {
const { sendCmd } = await import('./ext-bridge.mjs');
try {
await sendCmd('navigate', { url }, 6000);
await new Promise(r => setTimeout(r, 3500));
const page = await sendCmd('read', {}, 6000);
const preview = String(page.text||'').slice(0, 2500).replace(/\n{3,}/g,'\n\n');
return `🔍 ${isGoogle?'Google':'YouTube'} searched "${q}" → navigated current Brave tab. Results preview (first 2500 chars):\n${preview.slice(0,1800)}\nURL: ${url}`;
} catch (eExt) {
return `🔍 Search "${q}" failed — Brave extension not polling (keep sidePanel open, check brave://extensions → Quillan-Ronin ON). Tried ${url} — error: ${eExt.message}`;
}
} catch (e) { return `browser_search error: ${e.message}`; }
}
case 'browser_openTab': {
const arg = String(tool.arg || '').trim();
if (!/^https?:\/\//i.test(arg)) return 'refused: only http(s) URLs';
if (/VIDEO_ID/i.test(arg)) return 'refused: placeholder VIDEO_ID — use a real href from browser_read/Search results';
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const r = await sendCmd('navigate', { url: arg }, 6000);
return `navigated current tab → ${arg.slice(0,90)}`;
} catch (e) {
execAsync(`start "" "${arg.replace(/"/g,'')}"`, { shell:'cmd.exe' });
return `opened (fallback) ${arg.slice(0,90)} — extension error: ${e.message}`;
}
}
case 'browser_read': {
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const tabId = tool.tabId ? Number(tool.tabId) : undefined;
const page = await sendCmd('read', { tabId }, 6000);
return `TITLE: ${page.title||''}\nURL: ${page.url||''}\nTEXT:\n${String(page.text||'').slice(0,6000)}`;
} catch (e) { return `browser_read error: ${e.message} (is Brave extension polling? check brave://extensions → Quillan-Ronin ON)`; }
}
case 'browser_navigate': {
const arg = String(tool.arg || '').trim();
if (!/^https?:\/\//i.test(arg)) return 'refused: only http(s) URLs';
if (/VIDEO_ID/i.test(arg)) return 'refused: placeholder VIDEO_ID — you must use a REAL href from the DOM links I gave you. Read the page first with browser_read or browser_search.';
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const r = await sendCmd('navigate', { url: arg }, 6000);
return `navigated to ${arg.slice(0,90)} — ${JSON.stringify(r).slice(0,300)}`;
} catch (e) {
execAsync(`start "" "${arg.replace(/"/g,'')}"`, { shell:'cmd.exe' });
return `opened (fallback) ${arg.slice(0,90)} — extension error: ${e.message}`;
}
}
case 'browser_click': {
const sel = String(tool.selector || tool.arg || '').trim();
const idx = tool.idx !== undefined ? Number(tool.idx) : undefined;
if (!sel && idx === undefined) return 'refused: need selector or idx';
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const r = await sendCmd('click', { selector: sel || undefined, idx }, 6000);
return `clicked ${sel||`idx:${idx}`} → ${JSON.stringify(r).slice(0,400)}`;
} catch (e) { return `browser_click error: ${e.message}`; }
}
case 'browser_type': {
const text = String(tool.text || tool.arg || '');
const selector = String(tool.selector || '');
const idx = tool.idx !== undefined ? Number(tool.idx) : undefined;
const pressEnter = tool.pressEnter !== false; // default true for search boxes
if (!text) return 'refused: empty text';
try {
const { sendCmd } = await import('./ext-bridge.mjs');
// If no selector, try to auto-find visible input/textarea/contenteditable
let sel = selector;
if (!sel && idx === undefined) {
// Let extension handle via fallback scripting: it will find input
sel = 'input, textarea, [contenteditable="true"]';
}
const r = await sendCmd('type', { selector: sel || undefined, idx, text, pressEnter }, 6000);
if (pressEnter) await new Promise(r=>setTimeout(r,800));
return `typed "${text.slice(0,60)}" into ${sel||`idx:${idx}`} ${pressEnter?'+ Enter':''} → ${JSON.stringify(r).slice(0,400)}`;
} catch (e) { return `browser_type error: ${e.message}`; }
}
case 'browser_press': {
const key = String(tool.key || tool.arg || 'Enter');
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const r = await sendCmd('eval', { expression: `(() => { const el=document.activeElement||document.body; el.dispatchEvent(new KeyboardEvent('keydown',{key:'${key}',bubbles:true})); el.dispatchEvent(new KeyboardEvent('keyup',{key:'${key}',bubbles:true})); return 'pressed ${key}'})()` }, 6000);
return `pressed ${key} → ${JSON.stringify(r).slice(0,300)}`;
} catch (e) { return `browser_press error: ${e.message}`; }
}
case 'tab_capture': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('captureTab', {}, 6000); return `tabCapture → ${JSON.stringify(r).slice(0,400)}`; } catch(e){ return `tab_capture error: ${e.message}`; }
}
case 'desktop_capture': {
const src = String(tool.sources || 'screen,window,tab').split(',').map(s=>s.trim());
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('captureDesktop', { sources: src }, 12000); return `desktopCapture → ${JSON.stringify(r).slice(0,400)}`; } catch(e){ return `desktop_capture error: ${e.message}`; }
}
case 'get_cookies': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('getCookies', { url: tool.url }, 4000); return `cookies → ${JSON.stringify(r).slice(0,1200)}`; } catch(e){ return `get_cookies error: ${e.message}`; }
}
case 'set_cookie': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('setCookie', { cookie: tool.cookie }, 4000); return `set_cookie → ${JSON.stringify(r).slice(0,400)}`; } catch(e){ return `set_cookie error: ${e.message}`; }
}
case 'get_history': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('getHistory', { query: tool.query || {text:'', maxResults:10} }, 4000); return `history → ${JSON.stringify(r).slice(0,1500)}`; } catch(e){ return `get_history error: ${e.message}`; }
}
case 'get_bookmarks': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('getBookmarks', {}, 4000); return `bookmarks → ${JSON.stringify(r).slice(0,1500)}`; } catch(e){ return `get_bookmarks error: ${e.message}`; }
}
case 'get_downloads': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('getDownloads', {}, 4000); return `downloads → ${JSON.stringify(r).slice(0,1200)}`; } catch(e){ return `get_downloads error: ${e.message}`; }
}
case 'get_topSites': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('getTopSites', {}, 4000); return `topSites → ${JSON.stringify(r).slice(0,1200)}`; } catch(e){ return `get_topSites error: ${e.message}`; }
}
case 'page_capture': {
try { const { sendCmd } = await import('./ext-bridge.mjs'); const r = await sendCmd('pageCapture', {}, 8000); return `pageCapture → ${JSON.stringify(r).slice(0,400)}`; } catch(e){ return `page_capture error: ${e.message}`; }
}
default: return `unknown tool: ${tool.tool}`;
}
} catch (e) { return `tool error: ${e.message}`; }
}
function ledgerSummaryShort() {
try {
const l = loadJSON('ledger');
return `$${l.entries.reduce((s, e) => s + Number(e.amount || 0), 0).toFixed(2)} earned`;
} catch { return '$0.00 earned'; }
}
async function getMemories() {
if (!existsSync(join(DATA, 'memory.json'))) return [];
try {
const raw = (await readFile(join(DATA, 'memory.json'), 'utf8')).replace(/^\uFEFF/, '');
const arr = JSON.parse(raw);
return Array.isArray(arr) ? arr : [arr];
} catch { return []; }
}
const COMFY = 'http://127.0.0.1:8188';
async function comfyGenerate(prompt, { width = 832, height = 832, seed = null } = {}) {
const clientId = 'quillan-worker';
const workflow = {
'3': { class_type: 'KSampler', inputs: { seed: seed ?? Math.floor(Math.random() * 1e9), steps: 4, cfg: 1.5, sampler_name: 'euler', scheduler: 'simple', denoise: 1.0, model: ['4', 0], positive: ['6', 0], negative: ['7', 0], latent_image: ['5', 0] } },
'4': { class_type: 'CheckpointLoaderSimple', inputs: { ckpt_name: 'sd_xl_turbo_1.0_fp16.safetensors' } },
'5': { class_type: 'EmptyLatentImage', inputs: { width, height, batch_size: 1 } },
'6': { class_type: 'CLIPTextEncode', inputs: { text: `${prompt}, masterpiece quality, sharp focus`, clip: ['4', 1] } },
'7': { class_type: 'CLIPTextEncode', inputs: { text: 'blurry, low quality, deformed, watermark, text', clip: ['4', 1] } },
'8': { class_type: 'VAEDecode', inputs: { samples: ['3', 0], vae: ['4', 2] } },
'9': { class_type: 'SaveImage', inputs: { filename_prefix: 'quillan/samurai', images: ['8', 0] } }
};
const queued = await fetch(`${COMFY}/prompt`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ prompt: workflow, client_id: clientId })
});
if (!queued.ok) throw new Error(`ComfyUI rejected job: ${await queued.text()}`);
const { prompt_id } = await queued.json();
const deadline = Date.now() + 180000;
while (Date.now() < deadline) {
await new Promise(r => setTimeout(r, 1500));
const hist = await fetch(`${COMFY}/history/${prompt_id}`).then(r => r.json());
const entry = hist[prompt_id];
if (entry && entry.outputs && Object.keys(entry.outputs).length) {
for (const nodeId of Object.keys(entry.outputs)) {
const imgs = entry.outputs[nodeId].images;
if (imgs && imgs.length) {
const q = new URLSearchParams({ filename: imgs[0].filename, subfolder: imgs[0].subfolder || '', type: imgs[0].type || 'output' });
const bin = Buffer.from(await fetch(`${COMFY}/view?${q}`).then(r => r.arrayBuffer()));
return `data:image/png;base64,${bin.toString('base64')}`;
}
}
}
if (entry && entry.status && entry.status.status_str === 'error') throw new Error('ComfyUI reported execution error');
}
throw new Error('ComfyUI timeout after 180s');
}
function readBody(req) {
return new Promise((resolve, reject) => {
let b = '';
req.on('data', c => (b += c));
req.on('end', () => {
try { resolve(b ? JSON.parse(b) : {}); } catch (e) { reject(e); }
});
req.on('error', reject);
});
}
const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml' };
const server = createServer(async (req, res) => {
try {
const url = new URL(req.url, `http://localhost`);
// CORS must be first — all API endpoints need it for extension fetches
const origin = req.headers.origin || '*';
if (origin.startsWith('chrome-extension://') || origin.startsWith('http://localhost') || origin.startsWith('http://127.0.0.1')) {
res.setHeader('Access-Control-Allow-Origin', origin);
} else {
res.setHeader('Access-Control-Allow-Origin', 'http://localhost');
}
res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
if (req.method === 'OPTIONS') {
res.writeHead(204);
return res.end();
}
const settings = await loadJSONAsync('settings');
if (url.pathname === '/api/state') {
const opps = await loadJSONAsync('opportunities');
const ledger = await loadJSONAsync('ledger');
const earned = ledger.entries.reduce((s, e) => s + Number(e.amount || 0), 0);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ settings, opportunities: opps, ledger, earned }));
}
if (url.pathname === '/api/analyze' && req.method === 'POST') {
const { leadText } = await readBody(req);
if (!leadText || !leadText.trim()) { res.writeHead(400); return res.end('{"error":"leadText required"}'); }
const analysis = await analyzeLead(leadText.trim(), settings);
const opps = await loadJSONAsync('opportunities');
const id = opps.nextId++;
opps.leads.push({ id, leadText: leadText.trim(), analysis, createdAt: new Date().toISOString(), status: 'pending' });
await saveJSON('opportunities', opps);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ id, analysis }));
}
if (url.pathname === '/api/decision' && req.method === 'POST') {
const { id, decision } = await readBody(req);
const opps = await loadJSONAsync('opportunities');
const lead = opps.leads.find(l => l.id === Number(id));
if (!lead) { res.writeHead(404); return res.end('{"error":"not found"}'); }
lead.status = decision === 'approve' ? 'approved' : 'rejected';
lead.decidedAt = new Date().toISOString();
await saveJSON('opportunities', opps);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true }));
}
if (url.pathname === '/api/ledger' && req.method === 'POST') {
const { amount, source, note } = await readBody(req);
const amt = Number(amount);
if (!Number.isFinite(amt) || amt <= 0) { res.writeHead(400); return res.end('{"error":"invalid amount"}'); }
const ledger = await loadJSONAsync('ledger');
ledger.entries.push({ amount: amt, source: source || 'other', note: note || '', date: new Date().toISOString() });
await saveJSON('ledger', ledger);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true }));
}
if (url.pathname === '/api/agent/start' && req.method === 'POST') {
const { url: startUrl, confirm } = await readBody(req);
if (!confirm) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ needsConfirmation: true, message: 'Quillan wants to take over a browser window. Confirm to grant control.' }));
}
const st = await agentStart(startUrl);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(st));
}
if (url.pathname === '/api/agent/stop' && req.method === 'POST') {
const st = await agentStop();
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(st));
}
if (url.pathname === '/api/agent/status' && req.method === 'GET') {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ...agentStatus(), recentLog: agentLog(8) }));
}
if (url.pathname === '/api/agent/action' && req.method === 'POST') {
const body = await readBody(req);
let out;
switch (body.op) {
case 'goto': out = await actGoto(body.url); break;
case 'click': out = await actClick(body.target); break;
case 'type': out = await actType(body.selector, body.text); break;
case 'press': out = await actPress(body.key); break;
case 'read': out = await actRead(); break;
case 'screenshot': out = await actScreenshot(); break;
case 'eval': {
const { getSession } = await import('./agent-browser.mjs');
const s = getSession();
if (!s) throw new Error('no active agent session');
const result = await s.page.evaluate(body.js);
out = { result: JSON.stringify(result).slice(0, 3000) };
break;
}
case 'chessboard': out = await readBoard(); break;
case 'chessmove': {
const { makeMove, waitForOpponentMove } = await import('./agent-chess.mjs');
const mv = await makeMove(body.from, body.to);
out = { move: mv };
if (body.wait) {
const opp = await waitForOpponentMove(body.prevMap || {}, 30000);
out.opponentMoved = !!opp;
out.board = opp || (await readBoard());
}
break;
}
case 'chessauto': {
const { autonomousTurn } = await import('./agent-chess.mjs');
const board = await readBoard();
out = await autonomousTurn(board.map, body.color || 'w');
break;
}
case 'chessautopilot': {
const { startAutopilot } = await import('./agent-chess.mjs');
await writeFile(join(DATA, 'chess-autopilot-enabled.json'), JSON.stringify({ enabled: true }));
out = startAutopilot(body.color || 'w');
break;
}
case 'chessautopilotstop': {
const { stopAutopilot } = await import('./agent-chess.mjs');
await writeFile(join(DATA, 'chess-autopilot-enabled.json'), JSON.stringify({ enabled: false }));
out = stopAutopilot();
break;
}
case 'chessautopilotstatus': {
const { autopilotStatus } = await import('./agent-chess.mjs');
out = autopilotStatus();
break;
}
default: throw new Error('unknown op: ' + body.op);
}
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(out));
}
if (url.pathname === '/api/agent/task' && req.method === 'POST') {
const { instruction, confirm, maxSteps, answer } = await readBody(req);
if (answer !== undefined && !instruction) {
const { resumeTask } = await import('./agent-task.mjs');
const r = await resumeTask(String(answer));
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(r));
}
if (!instruction || !instruction.trim()) { res.writeHead(400); return res.end('{"error":"instruction required"}'); }
if (!confirm) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ needsConfirmation: true, message: `Quillan wants to take over the browser for: "${instruction.slice(0, 80)}". Confirm to grant control.` }));
}
const r = await agentStartTask(instruction.trim(), Number(maxSteps) || 18);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(r));
}
if (url.pathname === '/api/agent/task/resume' && req.method === 'POST') {
const { answer } = await readBody(req);
const { resumeTask } = await import('./agent-task.mjs');
const r = await resumeTask(String(answer || ''));
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(r));
}
if (url.pathname === '/api/agent/task/status' && req.method === 'GET') {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(agentTaskStatus()));
}
if (url.pathname === '/api/agent/task/stop' && req.method === 'POST') {
const r = agentStopTask();
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(r));
}
if (url.pathname === '/api/browser/link-brave' && req.method === 'POST') {
const { confirm } = await readBody(req);
if (!confirm) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({
needsConfirmation: true,
message: 'Linking lets Quillan control your REAL Brave browser (your tabs, your logins). Brave will be closed and relaunched with remote-control enabled. Continue?',
bravePaths: ['C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe']
}));
}
const { execSync } = await import('node:child_process');
let exe = null;
for (const c of ['C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe', 'C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe']) {
if (existsSync(c)) { exe = c; break; }
}
if (!exe) { res.writeHead(404); return res.end('{"error":"brave.exe not found"}'); }
try { execSync('taskkill /IM brave.exe /F', { stdio: 'ignore' }); } catch (err) { logError('SilentCatch', err); }
await new Promise(r => setTimeout(r, 2500));
const { spawn } = await import('node:child_process');
const child = spawn(exe, ['--remote-debugging-port=9223', '--restore-last-session'], { detached: true, stdio: 'ignore' });
child.unref();
const { setControlTarget } = await import('./agent-browser.mjs');
setControlTarget(9223, 'brave');
await writeFile(join(DATA, 'control-target.json'), JSON.stringify({ port: 9223, label: 'brave' }, null, 2));
let alive = false;
const deadline = Date.now() + 20000;
while (Date.now() < deadline) {
try {
const r = await fetch('http://127.0.0.1:9223/json/version', { signal: AbortSignal.timeout(1500) });
if (r.ok) { alive = true; break; }
} catch (err) { logError('SilentCatch', err); }
await new Promise(r => setTimeout(r, 600));
}
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ linked: alive, control: 'brave on :9223' }));
}
if (url.pathname === '/api/browser/control-stage' && req.method === 'POST') {
const { setControlTarget } = await import('./agent-browser.mjs');
setControlTarget(9222, 'stage');
await writeFile(join(DATA, 'control-target.json'), JSON.stringify({ port: 9222, label: 'stage' }, null, 2));
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true, control: 'stage chromium on :9222' }));
}
if (url.pathname === '/api/workers' && req.method === 'GET') {
const { WORKERS } = await import('./workers.mjs');
const online = WORKERS.filter(w => w.status === 'online').length;
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ total: WORKERS.length, online, planned: WORKERS.length - online, workers: WORKERS }));
}
if (url.pathname === '/api/mcp/status' && req.method === 'GET') {
const { mcpStatus, configServerNames } = await import('./mcp-manager.mjs');
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ configured: configServerNames(), active: mcpStatus() }));
}
if (url.pathname === '/api/mcp/ensure' && req.method === 'POST') {
const { names } = await readBody(req);
const { ensureAll } = await import('./mcp-manager.mjs');
const list = Array.isArray(names) && names.length ? names : ['ComputerUse'];
const r = await ensureAll(list);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(r));
}
if (url.pathname === '/api/mcp/call' && req.method === 'POST') {
const { server, tool, args, timeoutMs } = await readBody(req);
if (!server || !tool) { res.writeHead(400); return res.end('{"error":"server and tool required"}'); }
const { callTool } = await import('./mcp-manager.mjs');
const r = await callTool(server, tool, args || {}, Number(timeoutMs) || 120000);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(r));
}
if (url.pathname === '/api/settings' && req.method === 'POST') {
const patch = await readBody(req);
if (patch.nvidiaModel) settings.nvidiaModel = patch.nvidiaModel;
await saveJSON('settings', settings);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true }));
}
if (url.pathname === '/api/chat/stream' && req.method === 'POST') {
const { message, mode, history } = await readBody(req);
if (!message || !message.trim()) { res.writeHead(400); return res.end('{"error":"message required"}'); }
res.writeHead(200, {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache, no-transform',
'Connection': 'keep-alive'
});
const sendEvent = (event, data) => {
res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
};
// ── Deterministic Vision fast-path for stream (bypass LLM tool dance) ──
const msgL_stream = String(message).toLowerCase();
const wantsVisionStream = /(what.s on|look at|see|describe|read)\b.{0,30}\b(screen|my screen|the screen|display|monitor)\b/.test(msgL_stream) ||
(/\b(can you see|do you see|you see)\b/.test(msgL_stream) && /screen|display|monitor|tab|page/i.test(msgL_stream));
if (wantsVisionStream) {
try {
const { nativeScreenshot } = await import('./agent-browser.mjs');
const { visionDescribe } = await import('./scanner.mjs');
const b64 = await nativeScreenshot();
const desc = await visionDescribe(b64, `The user asked: "${String(message).slice(0,150)}". Describe precisely what is on this screen relative to their question. Name visible apps, tabs, conversations, and text content.`);
sendEvent('token', { delta: `👁️ ${desc}` });
sendEvent('done', { complete: true });
return res.end();
} catch (e) {
sendEvent('token', { delta: `👁️ Vision failed: ${e.message}` });
sendEvent('done', { complete: true });
return res.end();
}
}
// ── Deterministic "this video / this page" grounding for stream ──
// If user asks about current tab deixis, fetch real tab content via extension bridge
// so the model is grounded instead of hallucinating "I cannot see".
const wantsPageStream = /\b(this|that|current)\b.{0,18}\b(video|page|tab|site|article|youtube|watching)\b/i.test(msgL_stream) ||
/\bwhat('?s| is) (this|that) video\b/i.test(msgL_stream) ||
/\bexplain (this|that) (video|page)\b/i.test(msgL_stream) ||
/\ball about\b/i.test(msgL_stream) && /\bvideo\b/i.test(msgL_stream);
let pageGrounding = '';
if (wantsPageStream) {
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const page = await Promise.race([
sendCmd('read', {}),
new Promise((_, rej) => setTimeout(() => rej(new Error('ext read timeout')), 3500))
]);
if (page && (page.text || page.title)) {
pageGrounding = `\n\n[ACTIVE TAB GROUNDING — real content from user's current Brave tab]\nTITLE: ${page.title || ''}\nURL: ${page.url || ''}\nPAGE TEXT (first 8000 chars):\n${String(page.text || '').slice(0, 8000)}\n[END GROUNDING]\nAnswer the user's question using this grounding. If it's a YouTube/video page, summarize what the video is about from title + description + transcript snippets above. Never claim you cannot see — you have the page text.`;
}
} catch (err) { logError('SilentCatch', err); }
// fallback: try stage browser read if extension not connected
if (!pageGrounding) {
try {
const { getSession } = await import('./agent-browser.mjs');
const s = getSession();
if (s && s.page) {
const t = await s.page.evaluate(() => ({ title: document.title, url: location.href, text: (document.body?.innerText || '').slice(0, 8000) })).catch(() => null);
if (t && t.text) pageGrounding = `\n\n[STAGE BROWSER GROUNDING]\nTITLE: ${t.title}\nURL: ${t.url}\nTEXT: ${t.text}\n`;
}
} catch (err) { logError('SilentCatch', err); }
}
}
const deep = mode === 'fulldive';
const memories = await getMemories();
const memoryBlock = memories.slice(-12).map(m => `- ${m.text}`).join('\n');
const liveContext = await buildLiveContext();
const msgs = [{ role: 'system', content: personaFor(mode || 'standard', memoryBlock, liveContext) }];
for (const h of (Array.isArray(history) ? history.slice(-6) : [])) {
if (h && typeof h.content === 'string' && (h.role === 'user' || h.role === 'assistant')) {
msgs.push({ role: h.role, content: h.content.slice(0, deep ? 8000 : 4000) });
}
}
let userContent = String(message).slice(0, deep ? 32000 : 8000);
if (pageGrounding) userContent += pageGrounding;
msgs.push({ role: 'user', content: userContent });
let fullText = '';
try {
const { streamNVIDIA } = await import('./scanner.mjs');
sendEvent('start', { mode: mode || 'standard' });
for await (const chunk of streamNVIDIA(msgs, settings, deep ? 4000 : 1400, {
model: deep ? settings.deepKernelModel : undefined,
timeoutMs: deep ? 240000 : 45000
})) {
fullText += chunk;
sendEvent('token', { delta: chunk });
}
const directive = parseToolDirective(fullText);
if (directive) {
const toolResult = await runTool(directive);
sendEvent('tool', { tool: directive.tool, result: toolResult });
} else if (/\b(remember|don'?t forget|keep in mind)\b/i.test(String(message))) {
const fact = String(message).replace(/^.*?\bremember\b\s*(that\s*)?/i, '').trim() || String(message).trim();
const stored = await runTool({ tool: 'memory', arg: fact.slice(0, 300) });
sendEvent('tool', { tool: 'memory', result: stored });
}
sendEvent('done', { complete: true });
return res.end();
} catch (err) {
sendEvent('error', { message: err.message || 'Stream failed' });
return res.end();
}
}
if (url.pathname === '/api/mcp/clean' && req.method === 'POST') {
const { cleanGhostProcesses, stopAllServers } = await import('./mcp-manager.mjs');
const stopped = stopAllServers();
const ghost = cleanGhostProcesses();
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true, stoppedServers: stopped, ghostCleanup: ghost }));
}
if (url.pathname === '/api/chat' && req.method === 'POST') {
const dbg = msg => { try { require('node:fs').appendFileSync(join(DATA, 'chat-debug.log'), `${Date.now()} ${msg}\n`); } catch (err) { logError('SilentCatch', err); } };
dbg('enter');
const { message, mode, history } = await readBody(req);
if (!message || !message.trim()) { res.writeHead(400); return res.end('{"error":"message required"}'); }
dbg('body parsed: ' + String(message).slice(0, 40));
// INTENT ROUTER - Fast deterministic paths + fallback
let livePage = null;
try {
const { getSession, ensureActive } = await import('./agent-browser.mjs');
let s = getSession();
if (!s) { try { s = await ensureActive(); } catch (err) { logError('SilentCatch', err); } }
if (s && s.page) livePage = { url: s.page.url(), title: await s.page.title().catch(() => '') };
} catch (err) { logError('SilentCatch', err); }
const { routeMessage } = await import('./router.mjs');
const route = await routeMessage(message, loadJSON('settings'), livePage);
// VISION FAST PATH - deterministic: capture + see + describe, no model discretion
const msgL = String(message).toLowerCase();
// Video/page deixis counts as wantsVision for page-aware queries
const wantsPageDeixis = /\b(this|that|current)\b.{0,18}\b(video|page|tab|site|article|youtube|watching)\b/i.test(msgL) ||
/\bwhat('?s| is) (this|that) video\b/i.test(msgL) ||
/\ball about\b/i.test(msgL) && /\bvideo\b/i.test(msgL);
const mentionsTab = /\b(tab|openrouter|current page|this page|the page|my browser)\b/.test(msgL);
const wantsVision = /(what.s on|look at|see|describe|read)\b.{0,30}\b(screen|my screen|the screen|display|monitor)\b/.test(msgL) ||
/\b(can you see|do you see|you see)\b/.test(msgL) && /screen|display|monitor|tab|page/i.test(msgL) ||
(mentionsTab && /\b(reveal|identify|what (model|ai|llm)|who (am i|is the)|which model|stealth|hidden|investigate|check|examine|analyze|read)\b/.test(msgL)) ||
wantsPageDeixis;
if (wantsVision) {
// Video/page deixis → read real tab text via extension bridge (more accurate than screenshot)
if (wantsPageDeixis) {
try {
const { sendCmd } = await import('./ext-bridge.mjs');
const page = await Promise.race([
sendCmd('read', {}),
new Promise((_, rej) => setTimeout(() => rej(new Error('ext read timeout')), 3500))
]);
if (page && (page.text || page.title)) {
const grounding = `Summarize what this video/page is about based on REAL tab content:\nTITLE: ${page.title || ''}\nURL: ${page.url || ''}\nPAGE TEXT:\n${String(page.text||'').slice(0,8000)}`;
const memories = await getMemories();
const memoryBlock = memories.slice(-12).map(m => `- ${m.text}`).join('\n');
const liveContext = await buildLiveContext();
const msgs = [
{ role:'system', content: personaFor('standard', memoryBlock, liveContext) },
{ role:'user', content: `${message}\n\n${grounding}` }
];
let reply = await callNVIDIA(msgs, settings, 1200, { timeoutMs: 45000 });
reply = stripToolDirective(reply);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply }));
}
} catch (err) { logError('SilentCatch', err); }
// ext not connected → fall through to screenshot fallback
}
try {
const { nativeScreenshot } = await import('./agent-browser.mjs');
const { visionDescribe } = await import('./scanner.mjs');
const b64 = await nativeScreenshot();
const desc = await visionDescribe(b64, `The user asked: "${String(message).slice(0, 150)}". Describe precisely what is on this screen relative to their question. Name visible apps, tabs, conversations, and text content.`);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply: `👁️ ${desc}` }));
} catch (e) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply: `👁️ Vision failed: ${e.message}` }));
}
}
if (route.route === 'chess_play' || route.route === 'chess_status') {
const { autopilotStatus, readBoard, autonomousTurn } = await import('./agent-chess.mjs');
const ap = autopilotStatus();
let reply;
if (route.route === 'chess_status') {
reply = `♟️ Autopilot ${ap.running ? 'ENGAGED as ' + ap.color : 'idle'}. ${ap.events.slice(-3).map(e => e.msg).join(' | ')}`;
} else {
try {
const board = await readBoard();
if (!board || !board.map || Object.keys(board.map).length < 4) {
reply = '⚔️ No active chess board detected on current tab. Make sure your Chess.com or Lichess match tab is active.';
} else {
const r = await autonomousTurn(board.map, 'w');
reply = r.status === 'moved' ? `⚔️ Played **${r.san}** (${r.from} → ${r.to}).` :
r.status === 'waiting-for-opponent' ? '⏳ Holding — opponent\'s turn.' :
`Chess engine: ${r.status}${r.modelSaid ? ' (' + r.modelSaid + ')' : ''}`;
}
} catch (e) { reply = `⚠️ ${e.message}`; }
}
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({
route: route.route,
reply,
mode: 'chess',
toolResult: reply
}));
}
if (route.route === 'browser_task') {
// Video-search fast-path: do REAL YouTube search via extension bridge instead of generic task loop
if (route.via === 'video-search-regex') {
try {
const { sendCmd } = await import('./ext-bridge.mjs');
// Try to get current video context first
let curTitle = '';
try {
const cur = await Promise.race([sendCmd('read', {}, 6000), new Promise((_,rej)=>setTimeout(()=>rej(new Error('timeout')),5500))]);
curTitle = (cur.title||'').replace(/\s*-\s*YouTube\s*$/i,'').slice(0,80);
} catch (err) { logError('SilentCatch', err); }
const q = (curTitle ? curTitle + ' explained' : String(message).replace(/can you|maybe|please|find|search for/gi,'').trim()).slice(0,90) || 'agentic engineering explained';
const searchUrl = `https://www.youtube.com/results?search_query=${encodeURIComponent(q)}`;
// SINGLE-TAB: reuse current tab — Brave only, never chromium
await sendCmd('navigate', { url: searchUrl }, 6000).catch(()=>{});
await new Promise(r=>setTimeout(r,3200));
let resultsText = '';
try {
const page = await Promise.race([sendCmd('read', {}, 6000), new Promise((_,rej)=>setTimeout(()=>rej(new Error('timeout')),5500))]);
resultsText = String(page.text||'').slice(0,7000);
} catch (err) { logError('SilentCatch', err); }
if (resultsText) {
const memories = await getMemories();
const memoryBlock = memories.slice(-12).map(m=>`- ${m.text}`).join('\n');
const liveContext = await buildLiveContext();
const msgs = [
{ role:'system', content: personaFor('standard', memoryBlock, liveContext) },
{ role:'user', content: `User was watching: ${curTitle}\nAsked: ${message}\nI searched YouTube for "${q}" and opened ${searchUrl}. Results page text (use ONLY this, no hallucination):\n${resultsText}\n\nList 4-5 REAL videos from above (exact title + channel if visible) with 1-line why each matches, mark most beginner-friendly. Say I opened the search in your Brave tab.` }
];
let reply = await callNVIDIA(msgs, settings, 1200, { timeoutMs: 45000 });
reply = stripToolDirective(reply);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply, route: 'browser_task' }));
}
} catch (err) { logError('SilentCatch', err); }
// fallback to generic task if extension not connected
}
const instruction = route.instruction || message;
let startResult;
try {
if (!agentTaskStatus().running) {
startResult = await agentStartTask(instruction, 18);
} else {
startResult = { error: 'a task is already running' };
}
} catch (e) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply: `🚨 Task failed to start: ${e.message}`, route: 'browser_task' }));
}
if (startResult.error) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply: `⚠️ ${startResult.error}. Current: "${(agentTaskStatus().instruction || '').slice(0, 60)}"` }));
}
const ctl = (await import('./agent-browser.mjs')).getControlTarget();
const where = ctl.label === 'brave' ? 'inside YOUR Brave' : 'in the stage window';
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply: `🤖 Working ${where}: "${instruction.slice(0, 70)}". Streaming progress...`, route: 'browser_task' }));
}
const deep = mode === 'fulldive';
const memories = await getMemories();
const memoryBlock = memories.slice(-12).map(m => `- ${m.text}`).join('\n');
const liveContext = await buildLiveContext();
const msgs = [{ role: 'system', content: personaFor(mode || 'standard', memoryBlock, liveContext) }];
for (const h of (Array.isArray(history) ? history.slice(-6) : [])) {
if (h && typeof h.content === 'string' && (h.role === 'user' || h.role === 'assistant')) {
msgs.push({ role: h.role, content: h.content.slice(0, deep ? 8000 : 4000) });
}
}
msgs.push({ role: 'user', content: String(message).slice(0, deep ? 32000 : 8000) });
let reply = await callNVIDIA(msgs, settings, deep ? 4000 : 1400, {
model: deep ? settings.deepKernelModel : undefined,
timeoutMs: deep ? 240000 : 45000
});
const directive = parseToolDirective(reply);
if (directive) {
reply = stripToolDirective(reply);
const toolResult = await runTool(directive);
reply += `\n\n[⚙️ ${toolResult}]`;
} else if (/\b(remember|don'?t forget|keep in mind)\b/i.test(String(message))) {
const fact = String(message).replace(/^.*?\bremember\b\s*(that\s*)?/i, '').trim() || String(message).trim();
const stored = await runTool({ tool: 'memory', arg: fact.slice(0, 300) });
reply += `\n\n[⚙️ ${stored}]`;
}
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ reply }));
}
if (url.pathname === '/api/memory' && req.method === 'GET') {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ memories: await getMemories() }));
}
if (url.pathname === '/api/memory' && req.method === 'DELETE') {
await writeFile(join(DATA, 'memory.json'), '[]');
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true }));
}
if (url.pathname === '/api/chats' && req.method === 'GET') {
if (!existsSync(CHATS_DIR)) { res.writeHead(200, { 'Content-Type': 'application/json' }); return res.end('{"chats":[]}'); }
const files = await readdir(CHATS_DIR);
const chats = [];
for (const f of files.filter(x => x.endsWith('.json'))) {
try {
const c = JSON.parse(await readFile(join(CHATS_DIR, f), 'utf8'));
chats.push({ id: c.id, title: c.title, savedAt: c.savedAt, turns: (c.messages || []).length });
} catch (err) { logError('SilentCatch', err); }
}
chats.sort((a, b) => (b.savedAt || '').localeCompare(a.savedAt || ''));
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ chats }));
}
if (url.pathname === '/api/chats/save' && req.method === 'POST') {
const { id, title, messages } = await readBody(req);
if (!Array.isArray(messages) || !messages.length) { res.writeHead(400); return res.end('{"error":"nothing to save"}'); }
const { mkdirSync } = await import('node:fs');
mkdirSync(CHATS_DIR, { recursive: true });
const sid = String(id || Date.now().toString(36)).replace(/[^a-z0-9]/gi, '');
const chat = { id: sid, title: String(title || 'session').slice(0, 80), savedAt: new Date().toISOString(), messages };
await writeFile(join(CHATS_DIR, `${sid}.json`), JSON.stringify(chat, null, 2));
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ id: sid }));
}
if (url.pathname === '/api/chats/load' && req.method === 'POST') {
const { id } = await readBody(req);
const safe = String(id || '').replace(/[^a-z0-9]/gi, '');
const file = join(CHATS_DIR, `${safe}.json`);
if (!safe || !existsSync(file)) { res.writeHead(404); return res.end('{"error":"not found"}'); }
const chat = JSON.parse(await readFile(file, 'utf8'));
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(chat));
}
if (url.pathname === '/api/image' && req.method === 'POST') {
const { prompt, width, height, seed } = await readBody(req);
if (!prompt || !prompt.trim()) { res.writeHead(400); return res.end('{"error":"prompt required"}'); }
const image = await comfyGenerate(prompt.trim(), { width: Number(width) || 832, height: Number(height) || 832, seed });
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ image }));
}
if (url.pathname === '/api/brief' && req.method === 'POST') {
const ledger = await loadJSONAsync('ledger');
const earned = ledger.entries.reduce((s, e) => s + Number(e.amount || 0), 0);
const summary = `earned $${earned.toFixed(2)} of $${settings.goals.baselineInvested} payback target`;
const brief = await dailyBrief(settings, summary);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(brief));
}
if (url.pathname === '/api/test-nvidia' && req.method === 'POST') {
const status = await testConnection(settings);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ status }));
}
// Extension command queue endpoints
const extQueue = global.extCommandQueue || [];
global.extCommandQueue = extQueue;
const extResults = global.extResults || {};
global.extResults = extResults;
if (url.pathname === '/api/ext/poll' && req.method === 'GET') {
const agentId = url.searchParams.get('agentId') || 'quillan-ronin';
const cmd = extQueue.shift();
if (cmd) {
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(cmd));
}
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({}));
}
if (url.pathname === '/api/ext/result' && req.method === 'POST') {
const { commandId, result, agentId } = await readBody(req);
extResults[commandId] = { result, agentId, receivedAt: new Date().toISOString() };
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ ok: true }));
}
if (url.pathname === '/api/ext/queue' && req.method === 'POST') {
const { op, params } = await readBody(req);
const commandId = Date.now().toString(36) + Math.random().toString(36).slice(2);
const cmd = { id: commandId, op, params, queuedAt: new Date().toISOString() };
extQueue.push(cmd);
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({ commandId }));
}
if (url.pathname === '/api/ext/result' && req.method === 'GET') {
const commandId = url.searchParams.get('commandId');
if (!commandId) { res.writeHead(400); return res.end('{"error":"commandId required"}'); }
const result = extResults[commandId];
if (result) {
delete extResults[commandId];
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(result));
}
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify({}));
}
// Extension context management endpoints
if (url.pathname === '/api/ext/context' && req.method === 'GET') {
const tabId = url.searchParams.get('tabId');
if (!tabId) { res.writeHead(400); return res.end('{"error":"tabId required"}'); }
const { sendCmd } = await import('./ext-bridge.mjs');
const result = await sendCmd('getContext', { tabId });
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(result));
}
if (url.pathname === '/api/ext/contexts' && req.method === 'GET') {
const { sendCmd } = await import('./ext-bridge.mjs');
const result = await sendCmd('getAllContexts', {});
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(result));
}
if (url.pathname === '/api/ext/autonomy' && req.method === 'POST') {
const { tabId, enable } = await readBody(req);
if (!tabId) { res.writeHead(400); return res.end('{"error":"tabId required"}'); }
const { sendCmd } = await import('./ext-bridge.mjs');
const result = enable
? await sendCmd('enableAutonomy', { tabId })
: await sendCmd('disableAutonomy', { tabId });
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(result));
}
if (url.pathname === '/api/ext/autonomy/status' && req.method === 'GET') {
const tabId = url.searchParams.get('tabId');
if (!tabId) { res.writeHead(400); return res.end('{"error":"tabId required"}'); }
const { sendCmd } = await import('./ext-bridge.mjs');
const result = await sendCmd('isAutonomyEnabled', { tabId });
res.writeHead(200, { 'Content-Type': 'application/json' });
return res.end(JSON.stringify(result));
}
let path = url.pathname === '/' ? '/index.html' : url.pathname;
const file = join(PUBLIC, path.replace(/^\/+/, ''));
if (!file.startsWith(PUBLIC) || !existsSync(file)) { res.writeHead(404); return res.end('nope'); }
const body = await readFile(file);
res.writeHead(200, { 'Content-Type': MIME[extname(file)] || 'application/octet-stream' });
return res.end(body);
} catch (e) {
const msg = String(e?.cause?.message || e.message || e);
try { await writeFile(join(DATA, 'error.log'), `${new Date().toISOString()} ${url.pathname}: ${msg}\n${(e.stack || '').slice(0, 800)}\n---\n`, { flag: 'a' }); } catch (err) { logError('SilentCatch', err); }
res.writeHead(500, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: msg }));
}
});
const PORT = 7777;
// TCP NoDelay & KeepAlive Optimization for Sub-0.5ms Local Latency
server.keepAliveTimeout = 65000;
server.headersTimeout = 66000;
server.on('connection', (socket) => {
try {
socket.setNoDelay(true); // Disable Nagle's algorithm for instant packet dispatch
socket.setKeepAlive(true, 60000);
} catch (err) { logError('SilentCatch', err); }
});
server.listen(PORT, async () => {
console.log(`Quillan Worker dashboard → http://localhost:${PORT}`);
try {
const { setControlTarget } = await import('./agent-browser.mjs');
const ctlFile = join(DATA, 'control-target.json');
let ctl = { port: 9222, label: 'stage' };
if (existsSync(ctlFile)) {
ctl = JSON.parse(await readFile(ctlFile, 'utf8'));
setControlTarget(ctl.port, ctl.label);
console.log(`[boot] control target restored: ${ctl.label} :${ctl.port}`);
}
const desire = existsSync(join(DATA, 'chess-autopilot-enabled.json'))
? JSON.parse(await readFile(join(DATA, 'chess-autopilot-enabled.json'), 'utf8')).enabled
: false;
if (desire && existsSync(join(ROOT, 'agent-chess.mjs'))) {
setTimeout(async () => {
try {
const { startAutopilot } = await import('./agent-chess.mjs');
const r = startAutopilot('w');
console.log('[boot] chess autopilot re-engaged:', JSON.stringify(r));
} catch (e) { console.log('[boot] autopilot re-engage failed:', e.message); }
}, 8000);
}
} catch (err) { logError('SilentCatch', err); }
});