@andypai/orb 0.1.1

package/src/pipeline/processors/agent.ts

@@ -0,0 +1,38 @@
+import type { Frame } from '../frames'
+import { createFrame } from '../frames'
+import type { Processor } from '../processor'
+import type { AgentAdapterConfig } from '../adapters/types'
+import { createAnthropicAdapter } from '../adapters/anthropic'
+import { createOpenAiAdapter } from '../adapters/openai'
+import { isAbortError } from '../adapters/utils'
+
+/**
+ * AgentProcessor: receives UserTextFrame, dispatches to the appropriate adapter,
+ * and yields agent frames (text deltas, tool calls, completion).
+ * All other frames pass through unchanged.
+ */
+export function createAgentProcessor(adapterConfig: AgentAdapterConfig): Processor {
+  return async function* agentProcessor(upstream: AsyncIterable<Frame>): AsyncGenerator<Frame> {
+    for await (const frame of upstream) {
+      if (frame.kind !== 'user-text') {
+        yield frame
+        continue
+      }
+
+      const adapter =
+        adapterConfig.appConfig.llmProvider === 'openai'
+          ? createOpenAiAdapter(adapterConfig)
+          : createAnthropicAdapter(adapterConfig)
+
+      try {
+        yield* adapter.stream(frame.text)
+      } catch (err) {
+        if (!isAbortError(err)) {
+          yield createFrame('agent-error', {
+            error: err instanceof Error ? err : new Error(String(err)),
+          })
+        }
+      }
+    }
+  }
+}

package/src/pipeline/processors/tts.ts

@@ -0,0 +1,120 @@
+import type { Frame } from '../frames'
+import { createFrame } from '../frames'
+import type { Processor } from '../processor'
+import type { AppConfig } from '../../types'
+import { TTSError } from '../../types'
+import {
+  createStreamingSpeechController,
+  type StreamingSpeechController,
+} from '../../services/streaming-tts'
+import { speak, stopSpeaking } from '../../services/tts'
+
+export interface TTSCompletionHandle {
+  waitForCompletion(): Promise<void>
+  stop(): void
+}
+
+export interface TTSRunControl {
+  setCompletion(handle: TTSCompletionHandle | null): void
+}
+
+/**
+ * TTSProcessor: intercepts agent text frames to drive TTS.
+ *
+ * Streaming mode: wraps StreamingSpeechController, feeds text deltas,
+ * emits speaking start/end/error frames, and hands a completion handle
+ * to the PipelineTask to await.
+ *
+ * Batch mode: hands a completion handle to the PipelineTask on completion
+ * that speaks the full text.
+ *
+ * All frames pass through to downstream (transport sees them for UI updates).
+ */
+export function createTTSProcessor(appConfig: AppConfig, runControl?: TTSRunControl): Processor {
+  return async function* ttsProcessor(upstream: AsyncIterable<Frame>): AsyncGenerator<Frame> {
+    if (!appConfig.ttsEnabled) {
+      runControl?.setCompletion(null)
+      yield* upstream
+      return
+    }
+
+    const useStreaming = appConfig.ttsStreamingEnabled
+    let controller: StreamingSpeechController | null = null
+    let controllerHandedOff = false
+    const pendingTTSFrames: Frame[] = []
+
+    if (useStreaming) {
+      controller = createStreamingSpeechController(appConfig, {
+        onSpeakingStart: () => {
+          pendingTTSFrames.push(createFrame('tts-speaking-start'))
+        },
+        onSpeakingEnd: () => {
+          pendingTTSFrames.push(createFrame('tts-speaking-end'))
+        },
+        onError: (err: TTSError) => {
+          pendingTTSFrames.push(
+            createFrame('tts-error', {
+              errorType: err.type,
+              message: err.message,
+            }),
+          )
+        },
+      })
+    }
+
+    function* drainPending(): Iterable<Frame> {
+      while (pendingTTSFrames.length > 0) {
+        yield pendingTTSFrames.shift()!
+      }
+    }
+
+    let completedText = ''
+
+    try {
+      for await (const frame of upstream) {
+        // Feed text deltas to streaming TTS controller
+        if (frame.kind === 'agent-text-delta' && controller) {
+          controller.feedText(frame.delta)
+        }
+
+        // On agent completion, finalize TTS
+        if (frame.kind === 'agent-text-complete') {
+          completedText = frame.text
+
+          if (controller) {
+            // Streaming mode: finalize and yield pending frame
+            controller.finalize()
+            yield frame
+            yield* drainPending()
+
+            if (controller.isActive()) {
+              const ctrl = controller
+              controllerHandedOff = true
+              runControl?.setCompletion({
+                waitForCompletion: () => ctrl.waitForCompletion(),
+                stop: () => ctrl.stop(),
+              })
+            }
+            continue
+          }
+
+          // Batch mode: hand the synthesized playback work to the task layer.
+          yield frame
+          runControl?.setCompletion({
+            waitForCompletion: () => speak(completedText, appConfig),
+            stop: () => stopSpeaking(),
+          })
+          continue
+        }
+
+        // Pass through all frames + drain any TTS side-effect frames
+        yield frame
+        yield* drainPending()
+      }
+    } finally {
+      if (!controllerHandedOff) {
+        controller?.stop()
+      }
+    }
+  }
+}

package/src/pipeline/task.ts

@@ -0,0 +1,239 @@
+import { TTSError, type AppState, type AgentSession, type AppConfig } from '../types'
+import type { Frame } from './frames'
+import { createFrame } from './frames'
+import { singleFrame } from './processor'
+import { createPipeline } from './pipeline'
+import type { PipelineObserver } from './observer'
+import { createAgentProcessor } from './processors/agent'
+import { createTTSProcessor, type TTSCompletionHandle } from './processors/tts'
+import type { Transport, OutboundFrame } from './transports/types'
+import { isAbortError } from './adapters/utils'
+
+export type TaskState = AppState
+
+export interface RunResult {
+  entryId: string
+  text: string
+  session?: AgentSession
+  error?: Error
+  cancelled: boolean
+}
+
+export interface PipelineTaskConfig {
+  appConfig: AppConfig
+  session?: AgentSession
+  transport: Transport
+  observers?: PipelineObserver[]
+}
+
+type StateListener = (state: TaskState) => void
+
+export interface PipelineTask {
+  readonly state: TaskState
+  onStateChange(listener: StateListener): () => void
+  run(query: string, entryId: string): Promise<RunResult>
+  cancel(): void
+  updateConfig(config: AppConfig): void
+}
+
+/** Outbound frame kinds that get routed to the transport */
+const OUTBOUND_KINDS = new Set<Frame['kind']>([
+  'agent-text-delta',
+  'agent-text-complete',
+  'tool-call-start',
+  'tool-call-result',
+  'agent-error',
+  'tts-speaking-start',
+  'tts-speaking-end',
+  'tts-error',
+])
+
+export function createPipelineTask(taskConfig: PipelineTaskConfig): PipelineTask {
+  let state: TaskState = 'idle'
+  let config = taskConfig.appConfig
+  let session: AgentSession | undefined = taskConfig.session
+  const transport = taskConfig.transport
+  const observers = taskConfig.observers ?? []
+  const stateListeners = new Set<StateListener>()
+
+  let runCounter = 0
+  let currentAbort: AbortController | null = null
+  let currentTtsCompletion: TTSCompletionHandle | null = null
+
+  function setState(next: TaskState): void {
+    if (next === state) return
+    state = next
+    for (const listener of stateListeners) {
+      listener(next)
+    }
+  }
+
+  function isOutboundFrame(frame: Frame): frame is OutboundFrame {
+    return OUTBOUND_KINDS.has(frame.kind)
+  }
+
+  const task: PipelineTask = {
+    get state() {
+      return state
+    },
+
+    onStateChange(listener: StateListener): () => void {
+      stateListeners.add(listener)
+      return () => stateListeners.delete(listener)
+    },
+
+    async run(query: string, entryId: string): Promise<RunResult> {
+      // Cancel any in-progress run
+      if (currentAbort) {
+        currentAbort.abort()
+        currentAbort = null
+      }
+      if (currentTtsCompletion) {
+        currentTtsCompletion.stop()
+        currentTtsCompletion = null
+      }
+
+      const runId = ++runCounter
+      const abortController = new AbortController()
+      currentAbort = abortController
+
+      setState('processing')
+
+      let finalText = ''
+      let finalSession: AgentSession | undefined
+      let ttsCompletion: TTSCompletionHandle | null = null
+      let error: Error | undefined
+
+      // Notify observers
+      for (const observer of observers) {
+        observer.onRunStart?.(runId)
+      }
+
+      // Build pipeline: agent → tts
+      const pipeline = createPipeline({
+        processors: [
+          createAgentProcessor({
+            appConfig: config,
+            session,
+            abortController,
+          }),
+          createTTSProcessor(config, {
+            setCompletion(handle) {
+              ttsCompletion = handle
+              currentTtsCompletion = handle
+            },
+          }),
+        ],
+        observers,
+      })
+
+      // Create frame source
+      const source = singleFrame(createFrame('user-text', { text: query, entryId }))
+
+      try {
+        for await (const frame of pipeline(source)) {
+          // Stale run check
+          if (runId !== runCounter) break
+
+          switch (frame.kind) {
+            case 'agent-text-complete':
+              finalText = frame.text
+              if (frame.session) finalSession = frame.session
+              break
+
+            case 'agent-session':
+              finalSession = frame.session
+              break
+
+            case 'agent-error':
+              error = frame.error
+              break
+
+            case 'tts-speaking-start':
+              setState(state === 'processing' ? 'processing_speaking' : 'speaking')
+              break
+
+            case 'tts-speaking-end':
+              if (state === 'processing_speaking') setState('processing')
+              else if (state === 'speaking') setState('idle')
+              break
+          }
+
+          // Route displayable frames to transport
+          if (isOutboundFrame(frame)) {
+            transport.sendOutbound(frame)
+          }
+        }
+      } catch (err) {
+        if (!isAbortError(err)) {
+          error = err instanceof Error ? err : new Error(String(err))
+        }
+      }
+
+      // Handle TTS pending work (speaking state after agent completes)
+      if (ttsCompletion && runId === runCounter && !error) {
+        const completion = ttsCompletion as TTSCompletionHandle
+        setState('speaking')
+        try {
+          await completion.waitForCompletion()
+        } catch (err) {
+          if (runId === runCounter && err instanceof TTSError) {
+            transport.sendOutbound(
+              createFrame('tts-error', {
+                errorType: err.type,
+                message: err.message,
+              }) as OutboundFrame,
+            )
+          }
+        } finally {
+          if (currentTtsCompletion === completion) {
+            currentTtsCompletion = null
+          }
+        }
+      }
+
+      // Notify observers of run end
+      for (const observer of observers) {
+        observer.onRunEnd?.({
+          runId,
+          startTime: 0, // observers track their own startTime via onRunStart
+          endTime: Date.now(),
+          totalTextChars: 0,
+          toolCallCount: 0,
+          toolErrorCount: 0,
+          ttsErrorCount: 0,
+          frameCounts: {},
+        })
+      }
+
+      // Final state transition
+      const cancelled = runId !== runCounter
+      if (!cancelled) {
+        setState('idle')
+        currentAbort = null
+
+        // Update session for future runs
+        if (finalSession) {
+          session = finalSession
+        }
+      }
+
+      return { entryId, text: finalText, session: finalSession, error, cancelled }
+    },
+
+    cancel(): void {
+      runCounter++ // invalidate current run
+      currentAbort?.abort()
+      currentAbort = null
+      currentTtsCompletion?.stop()
+      currentTtsCompletion = null
+      setState('idle')
+    },
+
+    updateConfig(newConfig: AppConfig): void {
+      config = newConfig
+    },
+  }
+
+  return task
+}

package/src/pipeline/transports/terminal-text.ts

@@ -0,0 +1,24 @@
+import type { Transport, OutboundFrame } from './types'
+
+type OutboundListener = (frame: OutboundFrame) => void
+
+/**
+ * In-memory transport for same-process terminal UI.
+ * Synchronous dispatch — both pipeline and React UI live in the same Bun process.
+ */
+export function createTerminalTextTransport(): Transport {
+  const outboundListeners = new Set<OutboundListener>()
+
+  return {
+    onOutbound(listener: OutboundListener): () => void {
+      outboundListeners.add(listener)
+      return () => outboundListeners.delete(listener)
+    },
+
+    sendOutbound(frame: OutboundFrame): void {
+      for (const listener of outboundListeners) {
+        listener(frame)
+      }
+    },
+  }
+}

package/src/pipeline/transports/types.ts

@@ -0,0 +1,33 @@
+import type {
+  AgentTextDeltaFrame,
+  AgentTextCompleteFrame,
+  ToolCallStartFrame,
+  ToolCallResultFrame,
+  AgentErrorFrame,
+  TTSSpeakingStartFrame,
+  TTSSpeakingEndFrame,
+  TTSErrorFrame,
+} from '../frames'
+
+/** Frames the pipeline task sends to the UI */
+export type OutboundFrame =
+  | AgentTextDeltaFrame
+  | AgentTextCompleteFrame
+  | ToolCallStartFrame
+  | ToolCallResultFrame
+  | AgentErrorFrame
+  | TTSSpeakingStartFrame
+  | TTSSpeakingEndFrame
+  | TTSErrorFrame
+
+/**
+ * Transport: boundary between pipeline system and UI.
+ * Outbound: task → UI (agent/TTS frames for rendering)
+ */
+export interface Transport {
+  /** Subscribe to outbound frames (UI listens here) */
+  onOutbound(listener: (frame: OutboundFrame) => void): () => void
+
+  /** Send an outbound frame from the task side */
+  sendOutbound(frame: OutboundFrame): void
+}

package/src/services/auth-utils.ts

@@ -0,0 +1,149 @@
+import { Buffer } from 'node:buffer'
+
+export interface CodexTokens {
+  accessToken: string
+  refreshToken: string
+  expiresAt: number // Unix timestamp in ms
+  accountId?: string
+}
+
+const TOKEN_KEYS = [
+  'access_token',
+  'accessToken',
+  'token',
+  'id_token',
+  'idToken',
+  'session_token',
+  'sessionToken',
+]
+
+export function findToken(value: unknown): string | null {
+  if (!value) return null
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    return trimmed || null
+  }
+
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const found = findToken(entry)
+      if (found) return found
+    }
+    return null
+  }
+
+  if (typeof value !== 'object') return null
+
+  const record = value as Record<string, unknown>
+
+  // Check well-known token keys first
+  for (const key of TOKEN_KEYS) {
+    const candidate = record[key]
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return candidate.trim()
+    }
+  }
+
+  // Search recursively through all keys
+  for (const [key, candidate] of Object.entries(record)) {
+    if (!candidate) continue
+
+    if (key.toLowerCase().includes('token') && typeof candidate === 'string') {
+      const trimmed = candidate.trim()
+      if (trimmed) return trimmed
+    }
+
+    const found = findToken(candidate)
+    if (found) return found
+  }
+
+  return null
+}
+
+export async function readJsonFile(path: string): Promise<unknown | null> {
+  try {
+    const file = Bun.file(path)
+    if (!(await file.exists())) return null
+    return (await file.json()) as unknown
+  } catch {
+    return null
+  }
+}
+
+export function extractAccountId(tokens: {
+  id_token?: string
+  access_token?: string
+}): string | undefined {
+  const token = tokens.id_token || tokens.access_token
+  if (!token) return undefined
+
+  const parts = token.split('.')
+  if (parts.length !== 3) return undefined
+
+  const payloadPart = parts[1]
+  if (!payloadPart) return undefined
+
+  try {
+    const payload = Buffer.from(payloadPart, 'base64url').toString('utf8')
+    const claims = JSON.parse(payload) as Record<string, unknown>
+
+    // Check known locations for account ID
+    if (typeof claims.chatgpt_account_id === 'string') {
+      return claims.chatgpt_account_id
+    }
+
+    const auth = claims['https://api.openai.com/auth'] as Record<string, unknown> | undefined
+    if (auth && typeof auth.chatgpt_account_id === 'string') {
+      return auth.chatgpt_account_id
+    }
+
+    const orgs = claims.organizations as Array<{ id?: string }> | undefined
+    if (Array.isArray(orgs) && orgs[0]?.id) {
+      return orgs[0].id
+    }
+  } catch {
+    return undefined
+  }
+
+  return undefined
+}
+
+export function parseCodexAuthFile(data: unknown): CodexTokens | null {
+  if (!data || typeof data !== 'object') return null
+
+  const record = data as Record<string, unknown>
+  const tokens = record.tokens as Record<string, string> | undefined
+
+  if (!tokens || typeof tokens !== 'object') return null
+
+  const accessToken = tokens.access_token
+  const refreshToken = tokens.refresh_token
+
+  if (typeof accessToken !== 'string' || !accessToken.trim()) return null
+  if (typeof refreshToken !== 'string' || !refreshToken.trim()) return null
+
+  // Parse last_refresh to estimate expiry (tokens typically last 1 hour)
+  let expiresAt: number
+  const lastRefresh = record.last_refresh
+  if (typeof lastRefresh === 'string') {
+    const refreshTime = new Date(lastRefresh).getTime()
+    // Assume 1 hour expiry from last refresh
+    expiresAt = refreshTime + 3600 * 1000
+  } else {
+    // If no last_refresh, assume token expires in 5 minutes (forces refresh check)
+    expiresAt = Date.now() + 5 * 60 * 1000
+  }
+
+  return {
+    accessToken: accessToken.trim(),
+    refreshToken: refreshToken.trim(),
+    expiresAt,
+    accountId: extractAccountId(tokens),
+  }
+}
+
+export async function writeJsonFile(filePath: string, data: unknown): Promise<void> {
+  const json = JSON.stringify(data, null, 2)
+  await Bun.write(filePath, json)
+}