pi-tau-web-server 1.0.8

package/src/public/websocket-client.ts

@@ -0,0 +1,165 @@
+/**
+ * WebSocket Client - Handles connection to backend WebSocket server
+ */
+
+export class WebSocketClient extends EventTarget {
+  url: string;
+  ws: WebSocket | null;
+  reconnectAttempts: number;
+  maxReconnectAttempts: number;
+  reconnectDelay: number;
+  maxReconnectDelay: number;
+  isIntentionallyClosed: boolean;
+  reconnectTimer: ReturnType<typeof setTimeout> | null;
+  connectionState: 'idle' | 'connecting' | 'open' | 'closed';
+
+  constructor(url: string) {
+    super();
+    this.url = url;
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = Infinity;
+    this.reconnectDelay = 1000;
+    this.maxReconnectDelay = 10000;
+    this.isIntentionallyClosed = false;
+    this.reconnectTimer = null;
+    this.connectionState = 'idle';
+  }
+
+  connect() {
+    if (this.connectionState === 'connecting') return;
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) return;
+    if (this.ws && this.ws.readyState === WebSocket.CONNECTING) return;
+
+    this.isIntentionallyClosed = false;
+    this.connectionState = 'connecting';
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    // Close only fully stale sockets before reconnecting
+    if (this.ws && (this.ws.readyState === WebSocket.CLOSING || this.ws.readyState === WebSocket.CLOSED)) {
+      this.ws = null;
+    }
+    this.ws = new WebSocket(this.url);
+
+    this.ws.onopen = () => {
+      console.log('[WS] Connected');
+      this.reconnectAttempts = 0;
+      this.connectionState = 'open';
+      this.dispatchEvent(new CustomEvent('connected'));
+    };
+
+    this.ws.onmessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        this.handleMessage(message);
+      } catch (error) {
+        console.error('[WS] Failed to parse message:', error);
+      }
+    };
+
+    this.ws.onerror = (error) => {
+      console.error('[WS] Error:', error);
+      this.dispatchEvent(new CustomEvent('error', { detail: error }));
+    };
+
+    this.ws.onclose = (event) => {
+      console.log(`[WS] Disconnected (code=${event.code}, reason=${event.reason || 'n/a'})`);
+      this.connectionState = 'closed';
+      this.dispatchEvent(new CustomEvent('disconnected'));
+
+      if (!this.isIntentionallyClosed) {
+        this.attemptReconnect();
+      }
+    };
+  }
+
+  disconnect() {
+    this.isIntentionallyClosed = true;
+    this.connectionState = 'closed';
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+
+  // Force reconnect — resets attempt counter and connects fresh
+  forceReconnect() {
+    this.reconnectAttempts = 0;
+    this.isIntentionallyClosed = false;
+    this.connectionState = 'closed';
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try { this.ws.close(1000, 'force reconnect'); } catch (e) {}
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.connect();
+  }
+
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error('[WS] Max reconnection attempts reached');
+      this.dispatchEvent(new CustomEvent('reconnectFailed'));
+      return;
+    }
+
+    this.reconnectAttempts++;
+    const delay = Math.min(this.maxReconnectDelay, this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1));
+    
+    console.log(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+    
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+
+  send(data: unknown) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    } else {
+      console.error('[WS] Cannot send, not connected');
+    }
+  }
+
+  handleMessage(message: { type?: string; [key: string]: unknown }) {
+    // Emit events based on message type
+    switch (message.type) {
+      case 'event':
+        this.dispatchEvent(new CustomEvent('rpcEvent', { detail: { sessionId: message.sessionId, event: message.event } }));
+        break;
+      case 'state':
+        this.dispatchEvent(new CustomEvent('stateUpdate', { detail: message }));
+        break;
+      case 'error':
+        this.dispatchEvent(new CustomEvent('serverError', { detail: message }));
+        break;
+      case 'session_switch':
+        this.dispatchEvent(new CustomEvent('sessionSwitch'));
+        break;
+      case 'live_session_snapshot':
+        this.dispatchEvent(new CustomEvent('liveSessionSnapshot', { detail: message }));
+        break;
+      case 'response':
+        this.dispatchEvent(new CustomEvent('rpcResponse', { detail: message }));
+        break;
+      case 'live_session_created':
+        this.dispatchEvent(new CustomEvent('liveSessionCreated', { detail: message.session }));
+        break;
+      case 'live_session_updated':
+        this.dispatchEvent(new CustomEvent('liveSessionUpdated', { detail: message.session }));
+        break;
+      case 'live_session_closed':
+        this.dispatchEvent(new CustomEvent('liveSessionClosed', { detail: message }));
+        break;
+      default:
+        console.warn('[WS] Unknown message type:', message.type);
+    }
+  }
+}

package/src/server/auth.ts

@@ -0,0 +1,88 @@
+/*
+ * Session-cookie auth on top of HTTP Basic.
+ *
+ * iOS Safari (and the installed PWA) evicts cached Basic credentials when the
+ * user switches apps, so Basic alone re-prompts on every return. After a
+ * successful Basic request the server mints a signed, stateless session token
+ * carried in a browser-session cookie (no Max-Age): it survives app switching
+ * but ends with the browser session, and the embedded expiry bounds its life
+ * even if the browser restores session cookies with restored tabs.
+ */
+
+const crypto = require('node:crypto');
+
+import { TAU_SETTINGS, saveTauSetting } from './config.js';
+
+export const SESSION_COOKIE_NAME = 'tau_session';
+export const SESSION_TTL_SECONDS = 12 * 3600;
+export const SESSION_REFRESH_THRESHOLD_SECONDS = 6 * 3600;
+
+let cachedSecret = '';
+
+// Lazy so installs that never enable auth never write settings.json.
+function getCookieSecret(): string {
+  if (cachedSecret) return cachedSecret;
+  if (TAU_SETTINGS.cookieSecret) {
+    cachedSecret = TAU_SETTINGS.cookieSecret;
+    return cachedSecret;
+  }
+  cachedSecret = crypto.randomBytes(32).toString('hex');
+  if (!saveTauSetting('cookieSecret', cachedSecret)) {
+    console.warn('tau: could not persist tau.cookieSecret to settings.json; session cookies will not survive a server restart (every restart will log all devices out). Set TAU_COOKIE_SECRET to work around this.');
+  }
+  return cachedSecret;
+}
+
+// Recomputed per call so tokens die when the credentials change. The newline
+// separator cannot appear in either field, unlike ':' which passwords allow.
+function credentialFingerprint(): string {
+  return crypto.createHash('sha256').update(TAU_SETTINGS.user + '\n' + TAU_SETTINGS.pass).digest('hex');
+}
+
+function signToken(expiresAtSeconds: number): string {
+  return crypto.createHmac('sha256', getCookieSecret())
+    .update('v1.' + expiresAtSeconds + '.' + credentialFingerprint())
+    .digest('base64url');
+}
+
+export function issueSessionToken(expiresAtSeconds?: number): string {
+  const expires = expiresAtSeconds ?? Math.floor(Date.now() / 1000) + SESSION_TTL_SECONDS;
+  return 'v1.' + expires + '.' + signToken(expires);
+}
+
+export function verifySessionToken(token: string): { valid: boolean; expiresAt: number } {
+  const invalid = { valid: false, expiresAt: 0 };
+  try {
+    const parts = String(token).split('.');
+    if (parts.length !== 3 || parts[0] !== 'v1') return invalid;
+    const expiresAt = parseInt(parts[1], 10);
+    if (!Number.isFinite(expiresAt) || expiresAt <= Math.floor(Date.now() / 1000)) return invalid;
+    const expected = Buffer.from(signToken(expiresAt));
+    const actual = Buffer.from(parts[2]);
+    if (expected.length !== actual.length || !crypto.timingSafeEqual(expected, actual)) return invalid;
+    return { valid: true, expiresAt };
+  } catch {
+    return invalid;
+  }
+}
+
+// Manual parser because the WebSocket upgrade path has no framework.
+export function parseCookies(header: string | undefined): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!header) return out;
+  for (const part of header.split(';')) {
+    const eq = part.indexOf('=');
+    if (eq === -1) continue;
+    const name = part.slice(0, eq).trim();
+    if (!name) continue;
+    try { out[name] = decodeURIComponent(part.slice(eq + 1).trim()); } catch {}
+  }
+  return out;
+}
+
+// No Max-Age/Expires on purpose: a browser-session cookie is dropped when the
+// browser session ends, so killing the browser re-prompts for Basic auth.
+export function buildSessionCookie(token: string, opts: { secure: boolean; clear?: boolean }): string {
+  if (opts.clear) return `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`;
+  return `${SESSION_COOKIE_NAME}=${token}; Path=/; HttpOnly; SameSite=Lax` + (opts.secure ? '; Secure' : '');
+}

package/src/server/config.ts

@@ -0,0 +1,88 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+import type { TauArgs, TauSettings, TauSettingsFile } from './types.js';
+
+export function parseArgs(argv: string[]): TauArgs {
+  const out: TauArgs = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+    const key = arg.slice(2);
+    if (key === 'open') { out.open = true; continue; }
+    const next = argv[i + 1];
+    if (next && !next.startsWith('--')) { out[key] = next; i++; }
+  }
+  return out;
+}
+
+export const ARGS = parseArgs(process.argv.slice(2));
+export const USER_HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+export const PI_AGENT_DIR = process.env.PI_CODING_AGENT_DIR || path.join(USER_HOME, '.pi', 'agent');
+export const SESSIONS_DIR = process.env.PI_CODING_AGENT_SESSION_DIR || path.join(PI_AGENT_DIR, 'sessions');
+
+export function expandHome(p: string) {
+  if (!p || typeof p !== 'string') return p;
+  return p.startsWith('~') ? path.join(USER_HOME, p.slice(1)) : p;
+}
+
+export function loadTauSettings(): TauSettings {
+  let settings: TauSettingsFile['tau'] = {};
+  try {
+    const settingsPath = path.join(PI_AGENT_DIR, 'settings.json');
+    settings = ((JSON.parse(fs.readFileSync(settingsPath, 'utf8')) as TauSettingsFile).tau || {});
+  } catch {}
+  return {
+    port: parseInt(String(ARGS.port || process.env.TAU_PORT || settings.port || '3001'), 10),
+    host: ARGS.host || process.env.TAU_HOST || settings.host || '0.0.0.0',
+    user: process.env.TAU_USER || settings.user || '',
+    pass: process.env.TAU_PASS || settings.pass || '',
+    authEnabled: settings.authEnabled,
+    cookieSecret: process.env.TAU_COOKIE_SECRET || settings.cookieSecret || '',
+    projectsDir: expandHome(ARGS['projects-dir'] || process.env.TAU_PROJECTS_DIR || settings.projectsDir || ''),
+  };
+}
+
+export const TAU_SETTINGS = loadTauSettings();
+export const AUTH_CONFIGURED = !!(TAU_SETTINGS.user && TAU_SETTINGS.pass);
+export const PORT = TAU_SETTINGS.port;
+export const HOST = TAU_SETTINGS.host;
+export const STATIC_DIR = process.env.TAU_STATIC_DIR || findPublicDir();
+
+function findPublicDir() {
+  const candidates: string[] = [];
+  const add = (p: string) => candidates.push(path.resolve(p));
+  add(path.join(__dirname, '..', 'public'));
+  add(path.join(process.cwd(), 'public'));
+  try {
+    const pkgPath = require.resolve('pi-tau-web-server/package.json');
+    add(path.join(path.dirname(pkgPath), 'public'));
+  } catch {}
+  add(path.join(process.cwd(), 'node_modules', 'pi-tau-web-server', 'public'));
+  return candidates.find((c) => fs.existsSync(path.join(c, 'index.html'))) || candidates[0];
+}
+
+export const MIME_TYPES = {
+  '.html': 'text/html', '.css': 'text/css', '.js': 'application/javascript',
+  '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp',
+  '.svg': 'image/svg+xml', '.ico': 'image/x-icon', '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+};
+
+export function saveTauSetting(key: string, value: unknown): boolean {
+  const settingsPath = path.join(PI_AGENT_DIR, 'settings.json');
+  try {
+    let settings: TauSettingsFile = {};
+    try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')) as TauSettingsFile; } catch {}
+    if (!settings.tau) settings.tau = {};
+    settings.tau[key] = value;
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+

package/src/server/model-utils.ts

@@ -0,0 +1,122 @@
+const { execFile } = require('node:child_process');
+
+import type { JsonRecord, ModelIdentity, ParsedModelSpec, StatusError } from './types.js';
+
+type ExecFileCallback = (err: NodeJS.ErrnoException | null, stdout: string, stderr: string) => void;
+type ExecFileFn = (file: string, args: string[], opts: JsonRecord, callback: ExecFileCallback) => void;
+
+export function modelLabel(model: ModelIdentity | string | null | undefined, fallback = '') {
+  if (!model) return fallback || '';
+  if (typeof model === 'string') return model;
+  if (model.provider && model.id) return `${model.provider}/${model.id}`;
+  return model.id || model.name || fallback || '';
+}
+
+// Normalize any model value into the canonical form: null or a full
+// {provider, id, ...} object. Bare `provider/id` strings (and "id" strings
+// with no slash) are parsed into objects; anything unrecognizable becomes null.
+export function normalizeModel(value: unknown): ModelIdentity | null {
+  if (!value) return null;
+  if (typeof value === 'object') {
+    const record = value as ModelIdentity;
+    if (record.provider && record.id) return { ...record };
+    if (record.id) return { ...record, provider: record.provider || '' };
+    return null;
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const slashIdx = trimmed.indexOf('/');
+    if (slashIdx === -1) return { provider: '', id: trimmed };
+    const provider = trimmed.slice(0, slashIdx);
+    const id = trimmed.slice(slashIdx + 1);
+    if (!id) return null;
+    return { provider, id };
+  }
+  return null;
+}
+
+// Parse a `provider/id[:level]` spec string (as passed on session creation or
+// the model-input box) into a canonical {provider, id} object plus an optional
+// thinking level. Returns {model, level} where `model` is null when unparseable.
+export function parseModelSpecToModel(spec: unknown): ParsedModelSpec {
+  const trimmed = String(spec || '').trim();
+  if (!trimmed) return { model: null, level: null };
+  let level = null;
+  const colonIdx = trimmed.lastIndexOf(':');
+  if (colonIdx !== -1) {
+    const candidate = trimmed.slice(colonIdx + 1).toLowerCase();
+    if (['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(candidate)) {
+      level = candidate;
+    }
+  }
+  const core = (colonIdx !== -1 && level) ? trimmed.slice(0, colonIdx) : trimmed;
+  return { model: normalizeModel(core), level };
+}
+
+export function parseYesNo(value: unknown) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'yes') return true;
+  if (normalized === 'no') return false;
+  return value;
+}
+
+export function parsePiListModels(output: string) {
+  const lines = String(output || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const models = [];
+  for (const line of lines) {
+    if (/^provider\s+model\s+/i.test(line)) continue;
+    const parts = line.split(/\s{2,}/).map((part) => part.trim()).filter(Boolean);
+    if (parts.length < 2) continue;
+    const [provider, id, context, maxOutput, thinking, images] = parts;
+    if (!provider || !id) continue;
+    models.push({
+      provider,
+      id,
+      ...(context !== undefined ? { context } : {}),
+      ...(maxOutput !== undefined ? { maxOutput } : {}),
+      ...(thinking !== undefined ? { thinking: parseYesNo(thinking) } : {}),
+      ...(images !== undefined ? { images: parseYesNo(images) } : {}),
+    });
+  }
+  return models;
+}
+
+const MODEL_LIST_CACHE_MS = 5 * 60 * 1000;
+let modelListCache: { at: number; models: ModelIdentity[] } = { at: 0, models: [] };
+let _execFileForTest: ExecFileFn | null = null;
+
+export function execFileAsync(file: string, args: string[], opts: JsonRecord): Promise<{ stdout: string; stderr: string }> {
+  const runner: ExecFileFn = _execFileForTest || execFile;
+  return new Promise((resolve, reject) => {
+    runner(file, args, opts, (err: NodeJS.ErrnoException | null, stdout: string, stderr: string) => {
+      if (err) {
+        (err as StatusError).stderr = stderr;
+        reject(err);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+export async function getAvailableModels() {
+  const now = Date.now();
+  if (modelListCache.at && now - modelListCache.at < MODEL_LIST_CACHE_MS) {
+    return modelListCache.models;
+  }
+  try {
+    const { stdout } = await execFileAsync('pi', ['--list-models'], { timeout: 30000, encoding: 'utf8' });
+    const models = parsePiListModels(stdout);
+    modelListCache = { at: now, models };
+    return models;
+  } catch (err) {
+    console.warn('[Tau] Failed to list Pi models:', err instanceof Error ? err.message : err);
+    modelListCache = { at: now, models: modelListCache.models || [] };
+    return modelListCache.models;
+  }
+}
+
+
+export function _setExecFileForTest(fn: ExecFileFn | null | undefined) { _execFileForTest = fn || null; modelListCache = { at: 0, models: [] }; }
+export function _clearModelListCacheForTest() { modelListCache = { at: 0, models: [] }; }