draken 0.1.6 → 0.2.0

package/voice/realtime/peer.mjs

@@ -0,0 +1,116 @@
+/** Media-only browser boundary. It owns transferred tracks, never credentials or sync data.
+ * No automatic microphone acquisition/reconnect; callers must obtain a stream explicitly.
+ */
+export class VoicePeer {
+  #pc;
+  #context;
+  #input;
+  #sender;
+  #remote = new Set();
+  #sources = [];
+  #meter;
+  #gain;
+  #decoder;
+  #samples = new Float32Array(1024);
+  #controller = new AbortController();
+  #closed = false;
+  #opened = false;
+  #mutedOutput = false;
+  #rejectConnection;
+  #timer;
+  #onClose;
+  #onEvent;
+  constructor({ onClose = () => {}, onEvent = () => {} } = {}) { this.#onClose = onClose; this.#onEvent = onEvent; }
+  get closed() { return this.#closed; }
+  get clock() { return !this.#closed && this.#context?.state === 'running' ? this.#context.currentTime : NaN; }
+  get audioState() { return this.#context?.state || 'closed'; }
+  async resume() { if (!this.#closed) { await this.#context?.resume(); await this.#decoder?.play(); } }
+  gateInput(enabled) { this.#input?.getAudioTracks().forEach(track => { track.enabled = !!enabled; }); }
+  get inputActive() { return !!this.#input?.getAudioTracks().some(track => track.readyState === 'live'); }
+  get level() {
+    if (this.#closed || this.#mutedOutput || this.#context?.state !== 'running' || !this.#meter) return 0;
+    this.#meter.getFloatTimeDomainData(this.#samples);
+    const rms = Math.sqrt(this.#samples.reduce((sum, value) => sum + value * value, 0) / this.#samples.length);
+    return Number.isFinite(rms) ? Math.min(1, rms * 12) : 0;
+  }
+  async open(input, negotiate) {
+    if (this.#opened || this.#closed) { input.getTracks().forEach(track => track.stop()); throw new Error('A voice peer can open only once.'); }
+    this.#opened = true; this.#input = input;
+    try {
+      if (input.getAudioTracks().length !== 1 || input.getVideoTracks().length) throw new Error('Exactly one audio track is required.');
+      this.#pc = new RTCPeerConnection(); this.#context = new AudioContext();
+      this.#meter = this.#context.createAnalyser(); this.#meter.fftSize = this.#samples.length;
+      this.#gain = this.#context.createGain(); this.#meter.connect(this.#gain); this.#gain.connect(this.#context.destination);
+      this.#timer = setTimeout(() => this.close('Voice connection timed out.'), 60_000);
+      await this.#context.resume();
+      if (this.#closed || this.#context.state !== 'running') throw new Error('Voice playback could not start.');
+      this.#sender = this.#pc.addTrack(input.getAudioTracks()[0], input);
+      const channel = this.#pc.createDataChannel('oai-events');
+      const connected = new Promise((resolve, reject) => {
+        this.#rejectConnection = reject;
+        const check = () => {
+          if (this.#pc.connectionState === 'connected' && channel.readyState === 'open') { this.#rejectConnection = undefined; clearTimeout(this.#timer); resolve(); }
+          else if (['failed', 'disconnected', 'closed'].includes(this.#pc.connectionState)) this.close('Voice connection lost. Start a new call explicitly.');
+        };
+        this.#pc.onconnectionstatechange = check; channel.onopen = check;
+        channel.onclose = () => this.close('Voice event connection closed.');
+        channel.onerror = () => this.close('Voice event connection failed.');
+      });
+      // A close during the HTTP negotiation must not cause an unhandled rejection.
+      void connected.catch(() => {});
+      channel.onmessage = event => {
+        if (this.#closed) return;
+        if (typeof event.data !== 'string' || event.data.length > 200_000) { this.close('Voice event exceeds its limit.'); return; }
+        try { this.#onEvent(JSON.parse(event.data)); } catch { this.close('Invalid voice event.'); }
+      };
+      this.#pc.ontrack = event => {
+        if (this.#closed) { event.track.stop(); return; }
+        if (event.track.kind !== 'audio' || this.#remote.size) { this.close('Unexpected remote media track.'); return; }
+        this.#remote.add(event.track);
+        const stream = new MediaStream([event.track]);
+        // Chromium can leave a WebRTC track silent when only Web Audio consumes
+        // it. A muted media element starts the receiver; the graph is the sole
+        // audible output, so this does not play the voice twice.
+        this.#decoder = new Audio(); this.#decoder.muted = true; this.#decoder.srcObject = stream;
+        void this.#decoder.play().catch(() => this.close('Voice playback could not start.'));
+        const source = this.#context.createMediaStreamSource(stream);
+        this.#sources.push(source); source.connect(this.#meter);
+        event.track.onended = () => this.close('Voice output ended.');
+      };
+      await this.#pc.setLocalDescription(await this.#pc.createOffer());
+      if (this.#closed) throw new Error('Voice connection cancelled.');
+      const answer = await negotiate(this.#pc.localDescription.sdp, this.#controller.signal);
+      if (this.#closed) throw new Error('Voice connection cancelled.');
+      if (typeof answer !== 'string' || answer.length > 64_000 || !answer.startsWith('v=0')) throw new Error('Invalid voice answer.');
+      await this.#pc.setRemoteDescription({ type: 'answer', sdp: answer });
+      await connected;
+    } catch (error) { this.close('Voice connection failed or cancelled.'); throw error; }
+  }
+  muteOutput(muted) { this.#mutedOutput = !!muted; if (this.#gain) this.#gain.gain.value = muted ? 0 : 1; }
+  stopInput() {
+    this.#input?.getTracks().forEach(track => track.stop()); this.#input = undefined;
+    if (this.#sender && !this.#closed) void this.#sender.replaceTrack(null).catch(() => this.close('Cannot mute voice input.'));
+  }
+  async replaceInput(stream) {
+    if (this.#closed || !this.#sender || stream.getAudioTracks().length !== 1 || stream.getVideoTracks().length) {
+      stream.getTracks().forEach(track => track.stop()); throw new Error('Cannot attach voice input.');
+    }
+    const old = this.#input; this.#input = stream;
+    old?.getTracks().forEach(track => track.stop());
+    try { await this.#sender.replaceTrack(stream.getAudioTracks()[0]); }
+    catch (error) { stream.getTracks().forEach(track => track.stop()); this.close('Cannot attach voice input.'); throw error; }
+    if (this.#closed || this.#input !== stream) { stream.getTracks().forEach(track => track.stop()); throw new Error('Voice input was superseded.'); }
+  }
+  close(reason = 'Call ended.') {
+    if (this.#closed) return;
+    this.#closed = true; clearTimeout(this.#timer); this.#controller.abort();
+    this.#rejectConnection?.(new Error(reason)); this.#rejectConnection = undefined;
+    this.#pc?.close(); this.#input?.getTracks().forEach(track => track.stop());
+    this.#remote.forEach(track => track.stop()); this.#remote.clear();
+    this.#sources.forEach(source => source.disconnect()); this.#sources = [];
+    this.#meter?.disconnect(); this.#gain?.disconnect(); this.#samples.fill(0);
+    if (this.#decoder) { this.#decoder.pause(); this.#decoder.srcObject = null; this.#decoder = undefined; }
+    if (this.#context && this.#context.state !== 'closed') void this.#context.close().catch(() => {});
+    try { this.#onClose(reason); } catch { /* Cleanup must not depend on the UI. */ }
+  }
+}

package/voice/realtime/probe-browser.mjs

@@ -0,0 +1,81 @@
+import { VoicePeer } from './peer.mjs';
+let peer, context, monitor, poll, finished = false, cursor = 0, pollRunning = false;
+const startButton = document.querySelector('#start'), endButton = document.querySelector('#end'), status = document.querySelector('#status');
+const result = window.voiceResult = { completed: false, success: false, setupMs: null, audioFrames: 0, questions: [], transcripts: [], events: {}, errors: [], localCleanup: false, helperCleanup: false };
+const waitFor = async (predicate, ms = 20_000) => {
+  const deadline = performance.now() + ms;
+  while (!predicate()) { if (finished || performance.now() > deadline) throw new Error('Synthetic voice turn did not complete.'); await new Promise(resolve => setTimeout(resolve, 50)); }
+};
+async function end() {
+  if (finished) return;
+  finished = true; clearInterval(monitor); clearInterval(poll); peer?.close();
+  if (context && context.state !== 'closed') await context.close();
+  result.localCleanup = !!peer?.closed && !peer?.inputActive && (!context || context.state === 'closed');
+  try {
+    const response = await fetch('/end', { method: 'POST', signal: AbortSignal.timeout(5000) });
+    result.helperCleanup = response.ok && (await response.json()).helperExited === true;
+  } catch { /* Lab lease is the final guard; do not claim confirmed helper cleanup. */ }
+  if (!result.helperCleanup) result.success = false;
+  result.completed = true; endButton.disabled = true; status.textContent = result.success ? 'Synthetic exchange passed. Account quota and human-device behaviour still need testing.' : 'Test ended; see the private structural report.';
+}
+endButton.onclick = () => { void end(); };
+window.addEventListener('pagehide', () => { peer?.close(); void fetch('/end', { method: 'POST', keepalive: true }); });
+startButton.onclick = async () => {
+  startButton.disabled = true; endButton.disabled = false; status.textContent = 'Connecting…';
+  const start = performance.now(); let lastAudible = 0, current;
+  try {
+    context = new AudioContext(); await context.resume();
+    if (finished) throw new Error('Test cancelled before audio setup.');
+    const input = context.createMediaStreamDestination();
+    // A real microphone continues sending silence between utterances. Keep
+    // the synthetic source active too, rather than ending its audio graph.
+    const silence = context.createConstantSource(); silence.offset.value = 0; silence.connect(input); silence.start();
+    peer = new VoicePeer({ onClose: () => { if (!finished) { result.errors.push('Media connection closed.'); void end(); } }, onEvent: event => {
+      const type = typeof event.type === 'string' ? event.type : 'unknown';
+      result.events[type] = (result.events[type] || 0) + 1;
+      if (event.type === 'error') { result.errors.push('Remote voice event reported an error.'); void end(); }
+    } });
+    poll = setInterval(async () => {
+      if (pollRunning || finished) return; pollRunning = true;
+      try {
+        const response = await fetch(`/events?after=${cursor}`, { signal: AbortSignal.timeout(5000) });
+        if (!response.ok) throw new Error('Events unavailable.');
+        for (const event of await response.json()) {
+          cursor = event.sequence;
+          if (event.method === 'thread/realtime/transcript/done') result.transcripts.push(event.params);
+          if (['thread/realtime/error', 'thread/realtime/closed', 'draken/closed', 'draken/blocked'].includes(event.method)) { result.errors.push(event.method); void end(); }
+        }
+      } catch { result.errors.push('Native voice event stream failed.'); void end(); }
+      finally { pollRunning = false; }
+    }, 250);
+    await peer.open(input.stream, async (offer, signal) => {
+      const response = await fetch('/call', { method: 'POST', body: offer, signal });
+      if (!response.ok) throw new Error('Native voice connection was rejected.');
+      return response.text();
+    });
+    result.setupMs = Math.round(performance.now() - start); status.textContent = 'Running two spoken turns on one connection…';
+    monitor = setInterval(() => {
+      if (peer.level > 0.01) {
+        result.audioFrames++; lastAudible = performance.now();
+        if (current && current.firstAudioAt === undefined) current.firstAudioAt = Math.round(lastAudible);
+      }
+    }, 20);
+    const buffer = await context.decodeAudioData(await (await fetch('/question.wav')).arrayBuffer());
+    for (let index = 0; index < 2; index++) {
+      const assistantBefore = result.transcripts.filter(item => item.role === 'assistant').length;
+      const userBefore = result.transcripts.filter(item => item.role === 'user').length;
+      const framesBefore = result.audioFrames;
+      current = { index, inputStartedAt: Math.round(performance.now()) }; result.questions.push(current);
+      const source = context.createBufferSource(); source.buffer = buffer; source.connect(input);
+      await new Promise(resolve => { source.onended = resolve; source.start(); });
+      current.inputEndedAt = Math.round(performance.now()); source.disconnect();
+      await waitFor(() => result.transcripts.filter(item => item.role === 'assistant').slice(assistantBefore).some(item => /pass/i.test(item.text)) &&
+        result.transcripts.filter(item => item.role === 'user').slice(userBefore).some(item => /export.*test/i.test(item.text)) &&
+        result.audioFrames > framesBefore + 5 && performance.now() - lastAudible > 900);
+      current.firstAudioAfterFixtureMs = current.firstAudioAt - current.inputEndedAt;
+      current = undefined;
+    }
+    result.success = true;
+  } catch (error) { result.errors.push(error.message); }
+  finally { await end(); }
+};

package/voice/realtime/probe-server.mjs

@@ -0,0 +1,86 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { NativeVoice } from './native.mjs';
+
+/** Synthetic-only lab server. Not mounted in Draken; never imports its DB or routes. */
+export async function createProbeServer({ voiceFactory = () => new NativeVoice({
+  // Deliberately fixed synthetic facts, not a coding model or real sync context.
+  answer: async () => 'The targeted export tests passed. Deployment has not been checked.',
+}), leaseMs = 10_000, lifetimeMs = 90_000 } = {}) {
+  const token = randomBytes(32).toString('hex');
+  const expected = Buffer.from(`Bearer ${token}`);
+  let call, accepted = false, touched = Date.now(), origin, closing;
+  const events = []; let sequence = 0;
+  const finish = () => { if (!closing) closing = Promise.resolve().then(() => call?.close()); return closing; };
+  const body = async req => {
+    req.setEncoding('utf8');
+    let data = ''; for await (const chunk of req) { data += chunk; if (data.length > 64_000) throw new Error('Request too large.'); }
+    return data;
+  };
+  const server = http.createServer(async (req, res) => {
+    res.setHeader('Cache-Control', 'no-store'); res.setHeader('X-Content-Type-Options', 'nosniff');
+    const auth = Buffer.from(typeof req.headers.authorization === 'string' ? req.headers.authorization : '');
+    if (auth.length !== expected.length || !timingSafeEqual(auth, expected)) { res.writeHead(401); res.end(); return; }
+    if (req.headers.host !== new URL(origin).host || (req.headers.origin && req.headers.origin !== origin)) { res.writeHead(403); res.end(); return; }
+    try {
+      const url = new URL(req.url, origin);
+      if (req.method === 'GET' && url.pathname === '/') {
+        res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'; connect-src 'self'; media-src 'self' blob:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'");
+        res.setHeader('Content-Type', 'text/html'); res.end(fs.readFileSync(new URL('./probe.html', import.meta.url))); return;
+      }
+      if (req.method === 'GET' && ['/peer.mjs', '/probe-browser.mjs'].includes(url.pathname)) {
+        res.setHeader('Content-Type', 'text/javascript'); res.end(fs.readFileSync(new URL(`.${url.pathname}`, import.meta.url))); return;
+      }
+      if (req.method === 'GET' && url.pathname === '/question.wav') {
+        res.setHeader('Content-Type', 'audio/wav'); res.end(fs.readFileSync(fileURLToPath(new URL('../../tests/fixtures/voice-question.wav', import.meta.url)))); return;
+      }
+      if (req.method === 'GET' && url.pathname === '/events') {
+        const after = Number(url.searchParams.get('after') || 0);
+        if (!Number.isSafeInteger(after) || after < 0) { res.writeHead(400); res.end(); return; }
+        touched = Date.now(); res.setHeader('Content-Type', 'application/json'); res.end(JSON.stringify(events.filter(event => event.sequence > after))); return;
+      }
+      if (req.method === 'POST' && url.pathname === '/call') {
+        if (accepted || closing) { res.writeHead(409); res.end(); return; }
+        accepted = true; touched = Date.now();
+        const offer = await body(req);
+        if (closing) throw new Error('Call setup cancelled.');
+        call = voiceFactory();
+        call.subscribe(event => {
+          const method = event.method;
+          if (!['thread/realtime/transcript/done', 'thread/realtime/error', 'thread/realtime/closed', 'thread/realtime/started', 'draken/closed', 'draken/blocked'].includes(method)) return;
+          // Only synthetic transcripts and event kinds. Never SDP, tokens, helper errors or IDs.
+          const params = method === 'thread/realtime/transcript/done' && ['user', 'assistant'].includes(event.params?.role)
+            ? { role: event.params.role, text: String(event.params.text || '').slice(0, 4000) } : {};
+          events.push({ sequence: ++sequence, method, params }); if (events.length > 128) events.shift();
+          if (['thread/realtime/error', 'thread/realtime/closed', 'draken/closed', 'draken/blocked'].includes(method)) void finish();
+        });
+        const controller = new AbortController();
+        res.on('close', () => { if (!res.writableEnded) { controller.abort(); void finish(); } });
+        const answer = await call.open(offer, { signal: controller.signal });
+        res.setHeader('Content-Type', 'application/sdp'); res.end(answer); return;
+      }
+      if (req.method === 'POST' && url.pathname === '/text') {
+        const question = JSON.parse(await body(req)).question;
+        if (!call || closing || typeof question !== 'string' || question.length > 2000) { res.writeHead(400); res.end(); return; }
+        touched = Date.now(); await call.text(question); res.end('{}'); return;
+      }
+      if (req.method === 'POST' && url.pathname === '/end') {
+        const result = await finish();
+        res.setHeader('Content-Type', 'application/json');
+        if (result?.helperExited === false) res.statusCode = 502;
+        res.end(JSON.stringify({ helperExited: result?.helperExited !== false })); return;
+      }
+      res.writeHead(404); res.end();
+    } catch { await finish(); if (!res.headersSent) res.writeHead(502); res.end('Native voice qualification failed. No provider fallback was attempted.'); }
+  });
+  server.requestTimeout = 65_000;
+  server.headersTimeout = 10_000;
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
+  origin = `http://127.0.0.1:${server.address().port}`;
+  const sweep = setInterval(() => { if (accepted && Date.now() - touched > leaseMs) void finish(); }, Math.min(1000, leaseMs)); sweep.unref();
+  const deadline = setTimeout(() => { void finish(); }, lifetimeMs); deadline.unref();
+  return { origin, token, events,
+    async close() { clearInterval(sweep); clearTimeout(deadline); await finish(); server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); } };
+}

package/voice/realtime/probe.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Draken private voice qualification</title></head>
+<body>
+<h1>Private voice qualification</h1>
+<p>Synthetic audio only. No microphone capture, sync database, tools, work execution, or paid-key fallback.</p>
+<button id="start">Run synthetic call</button> <button id="end" disabled>End test</button>
+<p id="status" role="status">Ready. This test is separate from the deployed call screen.</p>
+<script type="module" src="/probe-browser.mjs"></script>
+</body>
+</html>

package/voice/realtime/probe.mjs

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { realtimeRoot, nativeStatus } from './native.mjs';
+import { createProbeServer } from './probe-server.mjs';
+
+process.umask(0o077);
+let browser, lab, stopping = false;
+const onSignal = signal => {
+  if (stopping) return; stopping = true;
+  void Promise.allSettled([browser?.close(), lab?.close()]).then(() => process.exit(signal === 'SIGINT' ? 130 : 143));
+};
+process.once('SIGINT', onSignal); process.once('SIGTERM', onSignal);
+try {
+  const flags = process.argv.slice(2);
+  if (flags.length !== 1 || !['--check', '--allow-provider'].includes(flags[0])) throw new Error('Use --check, or explicitly --allow-provider for one bounded synthetic audio test.');
+  const status = await nativeStatus();
+  if (flags[0] === '--check') console.log(JSON.stringify(status, null, 2));
+  else {
+    if (!status.readyForProbe) throw new Error('Native ChatGPT sign-in is missing or the pinned helper is unavailable. Run npm run voice:realtime:setup, then npm run voice:realtime:login. No provider request was made.');
+    const { chromium } = await import('@playwright/test');
+    lab = await createProbeServer(); browser = await chromium.launch();
+    const context = await browser.newContext({ extraHTTPHeaders: { Authorization: `Bearer ${lab.token}` } });
+    // Do not let page HTTP requests carry the lab credential to any other origin.
+    await context.route('**/*', route => new URL(route.request().url()).origin === lab.origin ? route.continue() : route.abort());
+    const page = await context.newPage(); const pageErrors = [];
+    page.on('pageerror', () => pageErrors.push('Browser runtime error.'));
+    await page.goto(lab.origin); await page.getByRole('button', { name: 'Run synthetic call' }).click();
+    await page.waitForFunction(() => window.voiceResult?.completed, {}, { timeout: 85_000 });
+    const result = await page.evaluate(() => window.voiceResult);
+    result.errors.push(...pageErrors);
+    result.success = result.success && result.localCleanup && result.helperCleanup && result.questions.length === 2 && result.audioFrames > 10 && !result.errors.length;
+    result.audioVerified = result.success;
+    result.authentication = 'native-chatgpt-only'; result.syntheticOnly = true;
+    result.interruptionVerified = false; result.realSyncVerified = false; result.quotaAccountingKnown = false;
+    const dir = path.join(realtimeRoot, 'reports'); fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const report = path.join(dir, `voice-${Date.now()}.json`); fs.writeFileSync(report, JSON.stringify(result, null, 2), { mode: 0o600 });
+    console.log(JSON.stringify({ success: result.success, setupMs: result.setupMs, spokenTurns: result.questions.length,
+      receivedAudioFrames: result.audioFrames, transcripts: result.transcripts.length, localCleanup: result.localCleanup, helperCleanup: result.helperCleanup, report }, null, 2));
+    if (!result.success) process.exitCode = 1;
+  }
+} catch (error) { console.error(error.message); process.exitCode = 1; }
+finally { await browser?.close(); await lab?.close(); process.removeListener('SIGINT', onSignal); process.removeListener('SIGTERM', onSignal); }

package/voice/realtime/rpc.mjs

@@ -0,0 +1,118 @@
+import { spawn } from 'node:child_process';
+
+/** Private stdio only. No HTTP listener, shell, generic command route, or raw logging. */
+export class NativeRpc {
+  #child;
+  #pending = new Map();
+  #listeners = new Set();
+  #sequence = 0;
+  #buffer = '';
+  #closed = false;
+  #exited = false;
+  #killTimer;
+  #exitPromise;
+  #resolveExit;
+  constructor(binary, args, { cwd, env, spawnProcess = spawn } = {}) {
+    this.#exitPromise = new Promise(resolve => { this.#resolveExit = resolve; });
+    this.#child = spawnProcess(binary, args, { cwd, env, shell: false, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
+    this.#child.stdout.setEncoding('utf8');
+    this.#child.stdout.on('data', chunk => this.#receive(chunk));
+    // Native diagnostics can contain prompts, transcripts, paths and auth details.
+    // Drain them, but never copy them into routine logs or browser errors.
+    this.#child.stderr.resume();
+    this.#child.stdin.on('error', () => this.close('Native voice input closed.'));
+    this.#child.on('error', () => this.close('Cannot start the pinned native voice helper.'));
+    this.#child.on('close', () => {
+      this.#exited = true;
+      clearTimeout(this.#killTimer);
+      this.#resolveExit(true);
+      this.close('Native voice helper stopped.');
+    });
+  }
+  get closed() { return this.#closed; }
+  subscribe(listener) { this.#listeners.add(listener); return () => this.#listeners.delete(listener); }
+  #emit(event) {
+    for (const listener of this.#listeners) {
+      try { listener(event); } catch { this.close('Native voice event consumer failed.'); return; }
+    }
+  }
+  #receive(chunk) {
+    if (this.#closed) return;
+    this.#buffer += chunk;
+    if (this.#buffer.length > 1_000_000) return this.close('Native voice event exceeds its limit.');
+    let newline;
+    while ((newline = this.#buffer.indexOf('\n')) >= 0) {
+      const line = this.#buffer.slice(0, newline); this.#buffer = this.#buffer.slice(newline + 1);
+      if (!line.trim()) continue;
+      let event;
+      try { event = JSON.parse(line); } catch { return this.close('Malformed native voice event.'); }
+      if (!event || typeof event !== 'object' || Array.isArray(event)) return this.close('Malformed native voice event.');
+      if (typeof event.method === 'string') {
+        // A call must never become an execution/approval/elicitation client.
+        // Do not accept even a nominally read-only command request.
+        if (Object.hasOwn(event, 'id')) {
+          try { this.#send({ id: event.id, error: { code: -32601, message: 'Draken voice does not execute tools or grant approvals.' } }); }
+          catch { /* A closed input pipe cannot grant an operation. */ }
+          finally { this.close('Native voice requested an unsupported operation.'); }
+          return;
+        }
+        this.#emit(event);
+        if (this.#closed) return;
+      } else if (Object.hasOwn(event, 'id')) {
+        const pending = this.#pending.get(event.id);
+        if (!pending) continue; // A timed-out response must not settle a later request.
+        this.#pending.delete(event.id); pending.cleanup();
+        if (Object.hasOwn(event, 'error')) pending.reject(new Error('Native voice request was rejected. Check account access and helper compatibility.'));
+        else if (Object.hasOwn(event, 'result')) pending.resolve(event.result);
+        else { pending.reject(new Error('Malformed native voice response.')); this.close(); }
+      } else return this.close('Malformed native voice event.');
+    }
+  }
+  #send(value) {
+    if (this.#closed || this.#child.stdin.destroyed) throw new Error('Native voice connection is closed.');
+    const line = JSON.stringify(value) + '\n';
+    if (line.length > 200_000 || this.#child.stdin.writableLength > 1_000_000) throw new Error('Native voice input exceeds its limit.');
+    this.#child.stdin.write(line);
+  }
+  notify(method, params = {}) { this.#send({ method, params }); }
+  request(method, params = {}, { timeoutMs = 15_000, signal } = {}) {
+    if (this.#closed || signal?.aborted) return Promise.reject(new Error('Native voice request cancelled.'));
+    if (this.#pending.size >= 16) return Promise.reject(new Error('Too many pending native voice requests.'));
+    const id = ++this.#sequence;
+    return new Promise((resolve, reject) => {
+      const abort = () => this.close('Native voice request cancelled.');
+      const timer = setTimeout(() => this.close('Native voice request timed out.'), Math.max(1, Math.min(timeoutMs, 60_000)));
+      const cleanup = () => { clearTimeout(timer); signal?.removeEventListener('abort', abort); };
+      this.#pending.set(id, { resolve, reject, cleanup });
+      signal?.addEventListener('abort', abort, { once: true });
+      try { this.#send({ id, method, params }); } catch { this.close('Cannot send native voice request.'); }
+      if (signal?.aborted) abort();
+    });
+  }
+  async waitForExit(timeoutMs = 2500) {
+    let timer;
+    try { return await Promise.race([this.#exitPromise, new Promise(resolve => { timer = setTimeout(() => resolve(false), timeoutMs); })]); }
+    finally { clearTimeout(timer); }
+  }
+  #terminate(signal) {
+    // The official npm launcher owns a native child. On Unix terminate the
+    // entire group, including escalation if a launcher exits before its child.
+    if (process.platform !== 'win32' && Number.isInteger(this.#child.pid) && this.#child.pid > 1) {
+      try { process.kill(-this.#child.pid, signal); return; } catch { /* Already gone, or test double. */ }
+    }
+    try { this.#child.kill(signal); } catch { /* Exit confirmation is separate. */ }
+  }
+  close(reason = 'Native voice connection closed.') {
+    if (this.#closed) return;
+    this.#closed = true; this.#buffer = '';
+    for (const pending of this.#pending.values()) { pending.cleanup(); pending.reject(new Error(reason)); }
+    this.#pending.clear();
+    this.#child.stdin.destroy();
+    if (!this.#exited) {
+      this.#terminate('SIGTERM');
+      this.#killTimer = setTimeout(() => this.#terminate('SIGKILL'), 1500); this.#killTimer.unref();
+    }
+    this.#emit({ method: 'draken/closed', params: { reason } });
+    this.#listeners.clear();
+  }
+}

package/voice/realtime/setup.mjs

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { npmCli } from '../../dist/npm-cli.js';
+import { CODEX_VERSION, realtimeRoot, defaultBinary, defaultHome, helperEnvironment, nativeStatus } from './native.mjs';
+
+process.umask(0o077);
+const flags = process.argv.slice(2);
+if (flags.length !== 1 || !['--install', '--login', '--check'].includes(flags[0])) {
+  console.error('Usage: node voice/realtime/setup.mjs --install | --login | --check'); process.exitCode = 2;
+} else {
+  const run = (binary, args, env) => new Promise((resolve, reject) => {
+    const child = spawn(binary, args, { stdio: 'inherit', shell: false, env });
+    child.once('error', () => reject(new Error('Cannot start the requested helper.')));
+    child.once('exit', code => code === 0 ? resolve() : reject(new Error('The requested helper did not complete.')));
+  });
+  try {
+    if (flags[0] === '--install') {
+      fs.mkdirSync(realtimeRoot, { recursive: true, mode: 0o700 });
+      await run(process.execPath, [npmCli(), 'install', '--prefix', path.join(realtimeRoot, 'runtime'), '--ignore-scripts', '--no-audit', '--no-fund', '--save-exact', `@openai/codex@${CODEX_VERSION}`], helperEnvironment(defaultHome));
+    }
+    if (flags[0] === '--login') {
+      if (!(await nativeStatus()).installed) throw new Error('Run npm run voice:realtime:setup first.');
+      fs.mkdirSync(defaultHome, { recursive: true, mode: 0o700 });
+      if (fs.existsSync(path.join(defaultHome, 'config.toml'))) throw new Error('The dedicated voice account directory must not contain a custom config.toml.');
+      // An explicit operator command, not an automatic browser popup or token conversion.
+      // This is native ChatGPT sign-in, not API-key login and not pi's direct-token registration.
+      await run(defaultBinary, ['-c', 'cli_auth_credentials_store="file"', '-c', 'forced_login_method="chatgpt"', 'login', '--device-auth'], helperEnvironment(defaultHome));
+    }
+    console.log(JSON.stringify(await nativeStatus(), null, 2));
+  } catch (error) { console.error(error.message); process.exitCode = 1; }
+}

package/voice/tls.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// Creates a private local CA and LAN certificate. Does NOT install trust or open a firewall.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+import { X509Certificate, createPrivateKey } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+
+const args = process.argv.slice(2);
+const host = args.includes('--host') ? args[args.indexOf('--host') + 1] : process.env.DRAKEN_HOST || 'localhost';
+const dir = process.env.DRAKEN_TLS_DIR || path.join(process.env.DRAKEN_DATA_DIR || path.join(os.homedir(), '.draken'), 'runtime/tls');
+const ca = path.join(dir, 'draken-local-root.crt'), caKey = path.join(dir, 'draken-local-root.key');
+const cert = path.join(dir, 'draken-server.crt'), key = path.join(dir, 'draken-server.key');
+let locked = false;
+const run = args => execFileSync('openssl', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+try {
+  if (!host || (!net.isIP(host) && !/^[a-zA-Z0-9][a-zA-Z0-9.-]{0,252}$/.test(host)) || ['0.0.0.0', '::'].includes(host))
+    throw new Error('Use --host with the actual LAN IP or hostname used in your browser, not a wildcard bind address.');
+  process.umask(0o077); fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(path.join(dir, '.setup-lock')); locked = true;
+  if (fs.existsSync(ca) !== fs.existsSync(caKey)) throw new Error('Incomplete existing CA. Refusing to overwrite it.');
+  if (!fs.existsSync(ca)) {
+    run(['req', '-x509', '-newkey', 'rsa:2048', '-sha256', '-days', '3650', '-nodes', '-keyout', caKey, '-out', ca,
+      '-subj', '/CN=Draken local voice root', '-addext', 'basicConstraints=critical,CA:TRUE,pathlen:0', '-addext', 'keyUsage=critical,keyCertSign,cRLSign']);
+  }
+  const root = new X509Certificate(fs.readFileSync(ca));
+  if (!root.ca || !root.checkPrivateKey(createPrivateKey(fs.readFileSync(caKey)))) throw new Error('The existing CA and private key do not match');
+  const hosts = [...new Set([host, 'localhost', '127.0.0.1', '::1'])];
+  let valid = false;
+  if (fs.existsSync(cert) && fs.existsSync(key)) {
+    const current = new X509Certificate(fs.readFileSync(cert));
+    valid = current.verify(root.publicKey) && current.checkPrivateKey(createPrivateKey(fs.readFileSync(key))) &&
+      Date.parse(current.validTo) > Date.now() + 30 * 86400000 && hosts.every(name => net.isIP(name) ? current.checkIP(name) : current.checkHost(name));
+  }
+  if (!valid) {
+    const request = path.join(dir, 'server.csr'), extensions = path.join(dir, 'server.ext');
+    fs.writeFileSync(extensions, `basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\nsubjectAltName=${hosts.map(name => `${net.isIP(name) ? 'IP' : 'DNS'}:${name}`).join(',')}\n`);
+    run(['req', '-new', '-newkey', 'rsa:2048', '-sha256', '-nodes', '-keyout', key + '.new', '-out', request, '-subj', '/CN=Draken local voice']);
+    run(['x509', '-req', '-in', request, '-CA', ca, '-CAkey', caKey, '-CAcreateserial', '-days', '365', '-sha256', '-extfile', extensions, '-out', cert + '.new']);
+    fs.renameSync(key + '.new', key); fs.renameSync(cert + '.new', cert);
+    fs.rmSync(request); fs.rmSync(extensions);
+  }
+  console.log(`DRAKEN_HTTPS_PORT=44433\nDRAKEN_TLS_CERT=${cert}\nDRAKEN_TLS_KEY=${key}\nDRAKEN_TLS_CA=${ca}`);
+  console.log(`\nPublic CA SHA-256 fingerprint: ${root.fingerprint256}`);
+  console.log('Keep both .key files private. Install ONLY draken-local-root.crt as a trusted CA on your client device. See VOICE.md.');
+  console.log('Existing CA retained on reruns. Restart Draken after configuring TLS; allow the HTTPS port on your trusted LAN if needed.');
+} catch (error) { console.error(error.message); process.exitCode = 1; }
+finally { if (locked) fs.rmdirSync(path.join(dir, '.setup-lock')); }

package/dist/db/queries.d.ts

@@ -1,16 +0,0 @@
-import { Project, Task } from '../types';
-export declare function getAllProjects(): Project[];
-export declare function getProjectById(id: number): Project | undefined;
-export declare function createProject(name: string, path: string): Project;
-export declare function deleteProject(id: number): boolean;
-export declare function updateProjectDockerfileStatus(id: number, exists: boolean): void;
-export declare function getTasksByProjectId(projectId: number): Task[];
-export declare function getTaskById(id: number): Task | undefined;
-export declare function createTask(projectId: number, prompt: string, parentTaskId?: number): Task;
-export declare function updateTaskSessionId(id: number, sessionId: string): void;
-export declare function getLatestTaskWithSession(projectId: number): Task | undefined;
-export declare function updateTaskStatus(id: number, status: Task['status'], containerId?: string): void;
-export declare function updateTaskCompleted(id: number, status: Task['status']): void;
-export declare function appendTaskLogs(id: number, newLogs: string): void;
-export declare function getRunningTasks(): Task[];
-//# sourceMappingURL=queries.d.ts.map

package/dist/db/queries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../src/db/queries.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGzC,wBAAgB,cAAc,IAAI,OAAO,EAAE,CAG1C;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAG9D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAIjE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAIjD;AAED,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAG/E;AAGD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,CAG7D;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAGxD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAIzF;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAGvE;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAQ5E;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAO/F;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAG5E;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAKhE;AAED,wBAAgB,eAAe,IAAI,IAAI,EAAE,CAGxC"}