bloby-bot 0.32.1 → 0.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.32.1",
+  "version": "0.33.0",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",

package/supervisor/harnesses/codex.ts

@@ -1,73 +1,591 @@
 /**
- * Codex (OpenAI app-server) harness — STUB for Phase 1.
+ * Codex (OpenAI app-server) harness — Phase 2.
  *
- * Phase 1 introduces the harness split with zero behavior change for Claude
- * users. Codex routing is wired up but every method emits a clear "not
- * implemented yet" error so we can spot any accidental route during testing.
+ * One long-lived `codex app-server` subprocess per conversation. We talk to
+ * it via JSON-RPC 2.0 over stdio — bidirectional: client → server requests,
+ * server → client notifications. Tokens come from `~/.codex/auth.json`
+ * (codex reads them itself; we don't pass anything).
  *
- * Phase 2 will spawn `codex app-server` over stdio JSON-RPC, manage threads,
- * and translate item/turn notifications into the shared `bot:*` event vocab.
+ * Lifecycle per live conversation:
+ *   spawn → initialize → initialized → thread/start → turn/start (per
+ *   user message; turn/steer to inject mid-turn) → turn/completed → idle
+ *   → endConversation → turn/interrupt (if needed) → kill subprocess
+ *
+ * Lifecycle per one-shot query: same as above, but the subprocess is killed
+ * as soon as `turn/completed` arrives.
+ *
+ * Model strings accept either bare ids (`gpt-5.5`) or `<id>:<effort>` where
+ * effort is one of low|medium|high|xhigh — the suffix is split off and
+ * passed as `effort` on `turn/start`.
+ *
+ * Notes on parity with Claude harness:
+ *   - System prompt → `baseInstructions` on `thread/start`
+ *   - Sub-agents → not implemented (Codex has Skills, different model)
+ *   - MCP servers → not wired yet (Codex has its own MCP layer)
+ *   - Mid-turn input uses `turn/steer` (better than Claude's queue)
  */
 
+import { spawn, type ChildProcessWithoutNullStreams } from 'child_process';
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
 import { log } from '../../shared/logger.js';
-import type { OnAgentMessage, RecentMessage, AgentAttachment } from './types.js';
+import { WORKSPACE_DIR } from '../../shared/paths.js';
 import type { SavedFile } from '../file-saver.js';
+import { getCodexAccessToken } from '../../worker/codex-auth.js';
+import { assembleSystemPrompt } from '../../worker/prompts/prompt-assembler.js';
+import type { OnAgentMessage, RecentMessage, AgentAttachment } from './types.js';
+export type { RecentMessage, AgentAttachment };
+
+/* ── Constants ─────────────────────────────────────────────────────────── */
+
+const CLIENT_INFO = { name: 'bloby', title: 'Bloby', version: '1' };
+const REQUEST_TIMEOUT_MS = 60_000;
+const VALID_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
+
+/* ── Prompt-assembly helpers (duplicated from claude.ts to keep that file
+ *    untouched per the project rule) ───────────────────────────────────── */
+
+function readMemoryFile(filename: string): string {
+  try {
+    const content = fs.readFileSync(path.join(WORKSPACE_DIR, filename), 'utf-8').trim();
+    return content || '(empty)';
+  } catch {
+    return '(empty)';
+  }
+}
+
+function readMemoryFiles() {
+  return {
+    myself: readMemoryFile('MYSELF.md'),
+    myhuman: readMemoryFile('MYHUMAN.md'),
+    memory: readMemoryFile('MEMORY.md'),
+    pulse: readMemoryFile('PULSE.json'),
+    crons: readMemoryFile('CRONS.json'),
+  };
+}
+
+function formatConversationHistory(messages: RecentMessage[]): string {
+  if (!messages.length) return '';
+  return messages.map((m) => `${m.role}: ${m.content}`).join('\n\n');
+}
+
+async function assembleBaseInstructions(
+  names?: { botName: string; humanName: string },
+  recentMessages?: RecentMessage[],
+): Promise<string> {
+  const memoryFiles = readMemoryFiles();
+  const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName);
+  let prompt = basePrompt;
+  prompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
+
+  try {
+    const { loadConfig: loadCfg } = await import('../../shared/config.js');
+    const cfg = loadCfg();
+    const channels = (cfg as any).channels;
+    if (channels) {
+      prompt += `\n\n---\n# Channel Config\n\`\`\`json\n${JSON.stringify(channels, null, 2)}\n\`\`\``;
+    }
+  } catch {}
+
+  if (recentMessages?.length) {
+    prompt += `\n\n---\n# Recent Conversation\n${formatConversationHistory(recentMessages)}`;
+  }
+
+  return prompt;
+}
+
+/** Split `gpt-5.5:high` into `{ id: 'gpt-5.5', effort: 'high' }`. */
+function parseModelString(model: string): { id: string; effort?: string } {
+  const idx = model.lastIndexOf(':');
+  if (idx <= 0) return { id: model };
+  const candidate = model.slice(idx + 1);
+  if (!VALID_EFFORTS.has(candidate)) return { id: model };
+  return { id: model.slice(0, idx), effort: candidate };
+}
+
+/* ── JSON-RPC client over stdio ────────────────────────────────────────── */
+
+type RpcResult<T = any> = { id: number; result?: T; error?: { code?: number; message: string } };
+type RpcNotification = { method: string; params?: any };
+
+interface PendingRequest {
+  resolve: (value: any) => void;
+  reject: (err: Error) => void;
+  timer: NodeJS.Timeout;
+}
+
+class CodexRpc {
+  private proc: ChildProcessWithoutNullStreams | null = null;
+  private pending = new Map<number, PendingRequest>();
+  private nextId = 1;
+  private notificationHandler: (n: RpcNotification) => void = () => {};
+  private closeHandler: (code: number | null) => void = () => {};
+  private closed = false;
+  private stderrBuf = '';
+
+  start(): void {
+    this.proc = spawn('codex', ['app-server'], { stdio: ['pipe', 'pipe', 'pipe'] });
+    const rl = readline.createInterface({ input: this.proc.stdout });
+    rl.on('line', (line) => this.onLine(line));
+
+    this.proc.stderr.on('data', (chunk) => {
+      this.stderrBuf += chunk.toString();
+      // Trim if growing unbounded.
+      if (this.stderrBuf.length > 16_000) this.stderrBuf = this.stderrBuf.slice(-8_000);
+    });
+
+    this.proc.on('exit', (code) => {
+      if (this.closed) return;
+      this.closed = true;
+      const err = new Error(`codex app-server exited (code=${code}). Stderr tail:\n${this.stderrBuf.trim().slice(-1000)}`);
+      for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(err);
+      }
+      this.pending.clear();
+      this.closeHandler(code);
+    });
+
+    this.proc.on('error', (err) => {
+      if (this.closed) return;
+      this.closed = true;
+      log.warn(`[codex-rpc] spawn error: ${err.message}`);
+      for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(err);
+      }
+      this.pending.clear();
+      this.closeHandler(null);
+    });
+  }
+
+  onNotification(handler: (n: RpcNotification) => void): void { this.notificationHandler = handler; }
+  onClose(handler: (code: number | null) => void): void { this.closeHandler = handler; }
+
+  private onLine(line: string): void {
+    if (!line.trim()) return;
+    let msg: any;
+    try { msg = JSON.parse(line); } catch {
+      log.warn(`[codex-rpc] malformed JSON from server: ${line.slice(0, 200)}`);
+      return;
+    }
+    if (typeof msg.id === 'number') {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      clearTimeout(pending.timer);
+      if (msg.error) pending.reject(new Error(msg.error.message || 'RPC error'));
+      else pending.resolve(msg.result);
+      return;
+    }
+    if (typeof msg.method === 'string') {
+      this.notificationHandler({ method: msg.method, params: msg.params });
+    }
+  }
+
+  request<T = any>(method: string, params?: any, timeoutMs = REQUEST_TIMEOUT_MS): Promise<T> {
+    if (this.closed || !this.proc) return Promise.reject(new Error('RPC connection closed'));
+    const id = this.nextId++;
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`codex app-server: ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.proc!.stdin.write(JSON.stringify({ method, id, params }) + '\n');
+      } catch (err: any) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+
+  notify(method: string, params?: any): void {
+    if (this.closed || !this.proc) return;
+    try {
+      this.proc.stdin.write(JSON.stringify({ method, params }) + '\n');
+    } catch (err: any) {
+      log.warn(`[codex-rpc] notify ${method} failed: ${err.message}`);
+    }
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error('RPC connection closed'));
+    }
+    this.pending.clear();
+    try { this.proc?.stdin.end(); } catch {}
+    try { this.proc?.kill('SIGTERM'); } catch {}
+    this.proc = null;
+  }
+}
+
+/* ── Per-conversation state ────────────────────────────────────────────── */
+
+interface CodexConversation {
+  id: string;
+  rpc: CodexRpc;
+  threadId: string;
+  effort?: string;
+  onMessage: OnAgentMessage;
+  /** Currently in-flight turn id (set on `turn/started`, cleared on `turn/completed`). */
+  currentTurnId: string | null;
+  /** Streaming text accumulator for the current turn's agentMessage items. */
+  fullText: string;
+  /** Tools/items used during the current turn, for the bot:turn-complete payload. */
+  usedFileTools: boolean;
+  /**
+   * Queue of messages submitted via `pushMessage` that arrived while no turn
+   * was active *and* we hadn't yet returned from the previous turn — almost
+   * always empty, but covers a tight push-during-completed race.
+   */
+  pendingInputs: string[];
+  /** True once the harness has emitted the per-turn completion event. */
+  busy: boolean;
+  /** True for one-shot queries — the conversation ends after the first turn completes. */
+  oneShot: boolean;
+}
+
+const conversations = new Map<string, CodexConversation>();
+
+/* ── Helpers ───────────────────────────────────────────────────────────── */
+
+function buildUserInput(text: string, savedFiles?: SavedFile[]): Array<Record<string, any>> {
+  const input: Array<Record<string, any>> = [];
+
+  let promptText = text || '(attached files)';
+  if (savedFiles?.length) {
+    const lines = savedFiles.map((f) => `- ${f.name} -> ${f.relPath}`);
+    promptText += `\n\n[Attached files saved to disk]\n${lines.join('\n')}\nYou can read or reference these files using the paths above (relative to your cwd).`;
+  }
+  input.push({ type: 'text', text: promptText });
 
-const NOT_READY = 'OpenAI/Codex harness is not implemented yet. Switch the provider back to Anthropic, or wait for Phase 2 of the harness work.';
+  // Codex understands `localImage` (path on disk) — Bloby's file-saver already
+  // wrote attachments to disk, so we just point at the absolute path.
+  if (savedFiles?.length) {
+    for (const f of savedFiles) {
+      if (f.type === 'image') input.push({ type: 'localImage', path: f.absPath });
+    }
+  }
 
-function emitNotReady(conversationId: string, onMessage: OnAgentMessage): void {
-  log.warn(`[codex-harness] ${NOT_READY}`);
-  onMessage('bot:error', { conversationId, error: NOT_READY });
-  onMessage('bot:done', { conversationId, usedFileTools: false });
+  return input;
+}
+
+async function startTurn(conv: CodexConversation, content: string, savedFiles?: SavedFile[]): Promise<void> {
+  const input = buildUserInput(content, savedFiles);
+  conv.busy = true;
+  conv.fullText = '';
+  conv.usedFileTools = false;
+  conv.onMessage('bot:typing', { conversationId: conv.id });
+  try {
+    const params: Record<string, any> = { threadId: conv.threadId, input };
+    if (conv.effort) params.effort = conv.effort;
+    await conv.rpc.request('turn/start', params);
+  } catch (err: any) {
+    conv.busy = false;
+    conv.onMessage('bot:error', { conversationId: conv.id, error: `turn/start failed: ${err.message}` });
+  }
+}
+
+async function steerOrQueue(conv: CodexConversation, content: string, savedFiles?: SavedFile[]): Promise<void> {
+  if (!conv.currentTurnId) {
+    // No active turn — start a fresh one.
+    await startTurn(conv, content, savedFiles);
+    return;
+  }
+  // Active turn — inject mid-flight.
+  const input = buildUserInput(content, savedFiles);
+  try {
+    await conv.rpc.request('turn/steer', {
+      threadId: conv.threadId,
+      expectedTurnId: conv.currentTurnId,
+      input,
+    });
+    conv.onMessage('bot:typing', { conversationId: conv.id });
+  } catch (err: any) {
+    // expectedTurnId mismatch most likely means the turn just finished —
+    // retry as a fresh turn.
+    log.warn(`[codex] turn/steer failed (${err.message}); falling back to turn/start`);
+    if (!conv.currentTurnId) await startTurn(conv, content, savedFiles);
+    else conv.pendingInputs.push(content);
+  }
+}
+
+function handleNotification(conv: CodexConversation, n: { method: string; params?: any }): void {
+  const p = n.params || {};
+  switch (n.method) {
+    case 'turn/started': {
+      conv.currentTurnId = p.turn?.id || null;
+      conv.fullText = '';
+      conv.usedFileTools = false;
+      break;
+    }
+
+    case 'item/agentMessage/delta': {
+      const delta: string = p.delta || '';
+      if (!delta) break;
+      conv.fullText += delta;
+      conv.onMessage('bot:token', { conversationId: conv.id, token: delta });
+      break;
+    }
+
+    case 'item/started': {
+      const item = p.item || {};
+      // Surface tool-like items so the dashboard can show activity.
+      switch (item.type) {
+        case 'commandExecution':
+          conv.onMessage('bot:tool', {
+            conversationId: conv.id,
+            name: 'shell',
+            input: { command: item.command || item.commandLine || '' },
+          });
+          break;
+        case 'mcpToolCall':
+          conv.onMessage('bot:tool', {
+            conversationId: conv.id,
+            name: item.toolName || item.name || 'mcp_tool',
+            input: item.arguments || item.input || {},
+          });
+          break;
+        case 'fileChange':
+          conv.usedFileTools = true;
+          conv.onMessage('bot:tool', {
+            conversationId: conv.id,
+            name: 'file_change',
+            input: { changes: (item.changes || []).map((c: any) => c.path).filter(Boolean) },
+          });
+          break;
+        case 'webSearch':
+          conv.onMessage('bot:tool', {
+            conversationId: conv.id,
+            name: 'web_search',
+            input: { query: item.query || '' },
+          });
+          break;
+        // userMessage / agentMessage / reasoning — no tool-style event.
+      }
+      break;
+    }
+
+    case 'item/completed': {
+      const item = p.item || {};
+      if (item.type === 'fileChange') conv.usedFileTools = true;
+      // If a final agentMessage arrives without preceding deltas (rare), grab it now.
+      if (item.type === 'agentMessage' && !conv.fullText) {
+        const text = (item.content || []).map((c: any) => c.text || '').join('') || item.text || '';
+        if (text) {
+          conv.fullText = text;
+          conv.onMessage('bot:token', { conversationId: conv.id, token: text });
+        }
+      }
+      break;
+    }
+
+    case 'turn/completed': {
+      const status: string = p.turn?.status || 'completed';
+      const turnError = p.turn?.error;
+
+      conv.currentTurnId = null;
+      conv.busy = false;
+
+      if (status === 'failed' || status === 'systemError') {
+        conv.onMessage('bot:error', {
+          conversationId: conv.id,
+          error: turnError?.message || 'Codex turn failed.',
+        });
+      } else if (conv.fullText) {
+        conv.onMessage('bot:response', { conversationId: conv.id, content: conv.fullText });
+      }
+
+      if (conv.oneShot) {
+        conv.onMessage('bot:done', { conversationId: conv.id, usedFileTools: conv.usedFileTools });
+        teardownConversation(conv.id);
+      } else {
+        conv.onMessage('bot:turn-complete', { conversationId: conv.id, usedFileTools: conv.usedFileTools });
+
+        // Drain any messages that were submitted while we were busy.
+        const next = conv.pendingInputs.shift();
+        if (next !== undefined) void startTurn(conv, next);
+      }
+      break;
+    }
+
+    case 'error': {
+      const errMsg = p.error?.message || 'Codex error notification';
+      conv.onMessage('bot:error', { conversationId: conv.id, error: errMsg });
+      break;
+    }
+
+    // thread/started, thread/status/changed, mcpServer/startupStatus/updated,
+    // remoteControl/status/changed — informational, no-op for the dashboard.
+  }
+}
+
+function teardownConversation(conversationId: string): void {
+  const conv = conversations.get(conversationId);
+  if (!conv) return;
+  conversations.delete(conversationId);
+  try { conv.rpc.close(); } catch {}
+  conv.onMessage('bot:conversation-ended', { conversationId });
+}
+
+async function spawnAndInitialize(
+  conversationId: string,
+  model: string,
+  onMessage: OnAgentMessage,
+  baseInstructions: string,
+  oneShot: boolean,
+): Promise<CodexConversation | null> {
+  // Pre-flight: confirm we have valid OAuth tokens before spending time spawning.
+  const token = await getCodexAccessToken();
+  if (!token) {
+    onMessage('bot:error', {
+      conversationId,
+      error: 'Codex credentials not found or expired. Re-authenticate from the dashboard.',
+    });
+    return null;
+  }
+
+  const { id: modelId, effort } = parseModelString(model);
+  const rpc = new CodexRpc();
+  rpc.start();
+
+  const conv: CodexConversation = {
+    id: conversationId,
+    rpc,
+    threadId: '',
+    effort,
+    onMessage,
+    currentTurnId: null,
+    fullText: '',
+    usedFileTools: false,
+    pendingInputs: [],
+    busy: false,
+    oneShot,
+  };
+
+  rpc.onNotification((n) => handleNotification(conv, n));
+  rpc.onClose(() => {
+    if (conversations.get(conversationId) === conv) {
+      conversations.delete(conversationId);
+      onMessage('bot:conversation-ended', { conversationId });
+    }
+  });
+
+  try {
+    log.info(`[codex] init conversation ${conversationId} (model=${modelId}${effort ? `, effort=${effort}` : ''})`);
+    await rpc.request('initialize', { clientInfo: CLIENT_INFO });
+    rpc.notify('initialized', {});
+    const startResult = await rpc.request<{ thread: { id: string } }>('thread/start', {
+      cwd: WORKSPACE_DIR,
+      model: modelId,
+      baseInstructions,
+    });
+    conv.threadId = startResult.thread.id;
+    conversations.set(conversationId, conv);
+    log.ok(`[codex] thread started ${conv.threadId}`);
+    return conv;
+  } catch (err: any) {
+    rpc.close();
+    onMessage('bot:error', { conversationId, error: `Failed to initialize Codex: ${err.message}` });
+    return null;
+  }
+}
+
+/* ── Harness implementation ────────────────────────────────────────────── */
+
+export function hasConversation(conversationId: string): boolean {
+  return conversations.has(conversationId);
+}
+
+export function isConversationBusy(conversationId: string): boolean {
+  return conversations.get(conversationId)?.busy ?? false;
 }
 
 export async function startConversation(
   conversationId: string,
-  _model: string,
+  model: string,
   onMessage: OnAgentMessage,
-  _names?: { botName: string; humanName: string },
-  _recentMessages?: RecentMessage[],
+  names?: { botName: string; humanName: string },
+  recentMessages?: RecentMessage[],
 ): Promise<boolean> {
-  emitNotReady(conversationId, onMessage);
-  return false;
+  if (conversations.has(conversationId)) endConversation(conversationId);
+  const baseInstructions = await assembleBaseInstructions(names, recentMessages);
+  const conv = await spawnAndInitialize(conversationId, model, onMessage, baseInstructions, false);
+  return !!conv;
 }
 
 export function pushMessage(
   conversationId: string,
-  _content: string,
+  content: string,
   _attachments?: AgentAttachment[],
-  _savedFiles?: SavedFile[],
+  savedFiles?: SavedFile[],
 ): boolean {
-  log.warn(`[codex-harness] pushMessage(${conversationId}) — ${NOT_READY}`);
-  return false;
+  const conv = conversations.get(conversationId);
+  if (!conv) {
+    log.warn(`[codex] pushMessage: no live conversation ${conversationId}`);
+    return false;
+  }
+  void steerOrQueue(conv, content, savedFiles);
+  return true;
+}
+
+export function endConversation(conversationId: string): void {
+  const conv = conversations.get(conversationId);
+  if (!conv) return;
+  log.info(`[codex] ending conversation ${conversationId}`);
+  if (conv.currentTurnId) {
+    void conv.rpc.request('turn/interrupt', {
+      threadId: conv.threadId,
+      turnId: conv.currentTurnId,
+    }).catch(() => {});
+  }
+  teardownConversation(conversationId);
+}
+
+export function endAllConversations(): void {
+  for (const id of Array.from(conversations.keys())) endConversation(id);
 }
 
-export function hasConversation(_conversationId: string): boolean {
-  return false;
+export async function stopSubAgentTask(_conversationId: string, _taskId: string): Promise<void> {
+  // Codex doesn't expose Claude-style sub-agent tasks. No-op for now.
 }
 
-export function endConversation(_conversationId: string): void { /* no-op */ }
-export function endAllConversations(): void { /* no-op */ }
-export function isConversationBusy(_conversationId: string): boolean { return false; }
-export async function stopSubAgentTask(_conversationId: string, _taskId: string): Promise<void> { /* no-op */ }
 export async function warmUpForLiveConversation(
   _model: string,
   _names?: { botName: string; humanName: string },
-): Promise<void> { /* no-op */ }
+): Promise<void> {
+  // No subprocess pre-warming yet — `codex app-server` startup is fast enough
+  // (~hundreds of ms). Re-evaluate if it becomes noticeable on the Pi.
+}
 
 export async function startBlobyAgentQuery(
   conversationId: string,
-  _prompt: string,
-  _model: string,
+  prompt: string,
+  model: string,
   onMessage: OnAgentMessage,
   _attachments?: AgentAttachment[],
-  _savedFiles?: SavedFile[],
-  _names?: { botName: string; humanName: string },
-  _recentMessages?: RecentMessage[],
-  _supportPrompt?: string,
+  savedFiles?: SavedFile[],
+  names?: { botName: string; humanName: string },
+  recentMessages?: RecentMessage[],
+  supportPrompt?: string,
   _maxTurns?: number,
 ): Promise<void> {
-  emitNotReady(conversationId, onMessage);
+  if (conversations.has(conversationId)) endConversation(conversationId);
+  const baseInstructions = supportPrompt
+    ? supportPrompt
+    : await assembleBaseInstructions(names, recentMessages);
+  const conv = await spawnAndInitialize(conversationId, model, onMessage, baseInstructions, true);
+  if (!conv) return;
+  await startTurn(conv, prompt, savedFiles);
 }
 
-export function stopBlobyAgentQuery(_conversationId: string): void { /* no-op */ }
+export function stopBlobyAgentQuery(conversationId: string): void {
+  endConversation(conversationId);
+}