@leviyuan/lodestar 0.1.0 → 2.0.14

package/runtime-api.ts

@@ -0,0 +1,569 @@
+/**
+ * Runtime API client for DeepSeek TUI serve --http.
+ *
+ * Encapsulates HTTP calls to the Runtime API, per-thread message queueing,
+ * SSE event streaming, and MCP config injection.
+ *
+ * Verified against: deepseek 0.8.31, serve --http --port 7878
+ * Design doc: LODESTAR_DEEPSEEK_DESIGN.md §5-7
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+// ── API response types (verified against deepseek 0.8.31) ──────────────────
+
+export interface ThreadInfo {
+  schema_version: number
+  id: string
+  created_at: string
+  updated_at: string
+  model: string
+  workspace: string
+  mode: string
+  allow_shell: boolean
+  trust_mode: boolean
+  auto_approve: boolean
+  archived: boolean
+  system_prompt?: string
+  coherence_state: string
+  latest_turn_id?: string
+}
+
+export interface TurnInfo {
+  schema_version: number
+  id: string
+  thread_id: string
+  status: string // 'in_progress' | 'completed' | 'error'
+  input_summary: string
+  created_at: string
+  started_at: string
+  ended_at?: string
+  duration_ms?: number
+  usage?: {
+    input_tokens: number
+    output_tokens: number
+    prompt_cache_hit_tokens: number
+    prompt_cache_miss_tokens: number
+    reasoning_tokens: number
+  }
+  item_ids: string[]
+  steer_count: number
+}
+
+export interface ItemInfo {
+  schema_version: number
+  id: string
+  turn_id: string
+  kind: 'user_message' | 'agent_reasoning' | 'agent_message' | 'tool_call' | 'status'
+  status: string
+  summary: string
+  detail: string
+  text?: string
+  artifact_refs: string[]
+  started_at: string
+  ended_at: string
+}
+
+export interface ThreadDetail {
+  thread: ThreadInfo
+  turns: TurnInfo[]
+  items: ItemInfo[]
+}
+
+export interface TurnResponse {
+  thread: ThreadInfo
+  turn: TurnInfo
+}
+
+// ── SSE event types (verified) ─────────────────────────────────────────────
+
+export interface SseRawEvent {
+  seq: number
+  timestamp: string
+  thread_id: string
+  turn_id: string | null
+  item_id: string | null
+  event: string
+  payload: any
+}
+
+export interface SseDelta {
+  kind: 'agent_reasoning' | 'agent_message' | 'tool_call' | 'user_message'
+  delta: string
+  item_id?: string
+}
+
+export interface ApiConfig {
+  baseUrl: string       // e.g. http://localhost:7878
+  authToken?: string    // optional bearer token
+}
+
+// ── RuntimeApiClient ─────────────────────────────────────────────────────────
+
+export class RuntimeApiClient {
+  private baseUrl: string
+  private authToken: string
+
+  constructor(config: ApiConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, '')
+    this.authToken = config.authToken || ''
+  }
+
+  private headers(): Record<string, string> {
+    const h: Record<string, string> = { 'Content-Type': 'application/json' }
+    if (this.authToken) h['Authorization'] = `Bearer ${this.authToken}`
+    return h
+  }
+
+  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const url = `${this.baseUrl}${path}`
+    const res = await fetch(url, {
+      method,
+      headers: this.headers(),
+      body: body ? JSON.stringify(body) : undefined,
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      throw new Error(`Runtime API ${method} ${path} failed (${res.status}): ${text.slice(0, 500)}`)
+    }
+    return res.json() as T
+  }
+
+  /** Check if serve --http is alive. */
+  async healthCheck(): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.baseUrl}/health`)
+      return res.ok
+    } catch { return false }
+  }
+
+  /** Create a new thread. */
+  async createThread(params: {
+    title: string
+    workspace: string
+    mode?: string
+    auto_approve?: boolean
+    system_prompt?: string
+    model?: string
+  }): Promise<ThreadInfo> {
+    return this.request('POST', '/v1/threads', {
+      title: params.title,
+      workspace: params.workspace,
+      mode: params.mode ?? 'yolo',
+      auto_approve: params.auto_approve ?? true,
+      ...(params.system_prompt ? { system_prompt: params.system_prompt } : {}),
+      ...(params.model ? { model: params.model } : {}),
+    })
+  }
+
+  /** Get thread detail (includes turns and items). */
+  async getThread(threadId: string): Promise<ThreadDetail> {
+    return this.request('GET', `/v1/threads/${threadId}`)
+  }
+
+  /** Get thread metadata only (no turns/items). Returns null if not found. */
+  async getThreadInfo(threadId: string): Promise<ThreadInfo | null> {
+    try {
+      const detail = await this.getThread(threadId)
+      return detail.thread
+    } catch {
+      return null
+    }
+  }
+
+  /** List all threads (returns array directly). */
+  async listThreads(): Promise<ThreadInfo[]> {
+    return this.request<ThreadInfo[]>('GET', '/v1/threads')
+  }
+
+  /** Patch thread (e.g. archive). */
+  async patchThread(threadId: string, patch: Record<string, unknown>): Promise<ThreadInfo> {
+    return this.request('PATCH', `/v1/threads/${threadId}`, patch)
+  }
+
+  /** Archive a thread (equivalent to `kill`). */
+  async archiveThread(threadId: string): Promise<ThreadInfo> {
+    return this.patchThread(threadId, { archived: true })
+  }
+
+  /** Fork a thread (equivalent to `restart`). */
+  async forkThread(threadId: string): Promise<ThreadInfo> {
+    return this.request('POST', `/v1/threads/${threadId}/fork`, {})
+  }
+
+  /** Compact a thread (equivalent to `clear`). */
+  async compactThread(threadId: string): Promise<unknown> {
+    return this.request('POST', `/v1/threads/${threadId}/compact`, {})
+  }
+
+  /** Inject a new turn (message) into a thread. Returns {thread, turn}. */
+  async createTurn(threadId: string, params: {
+    prompt: string
+    auto_approve?: boolean
+    mode?: string
+  }): Promise<TurnResponse> {
+    return this.request('POST', `/v1/threads/${threadId}/turns`, {
+      prompt: params.prompt,
+      auto_approve: params.auto_approve ?? true,
+      mode: params.mode ?? 'yolo',
+    })
+  }
+
+  /** Interrupt the currently active turn. */
+  async interruptTurn(threadId: string, turnId: string): Promise<unknown> {
+    return this.request('POST', `/v1/threads/${threadId}/turns/${turnId}/interrupt`, {})
+  }
+
+  /** Steer (append context) to an active turn. */
+  async steerTurn(threadId: string, turnId: string, context: string): Promise<unknown> {
+    return this.request('POST', `/v1/threads/${threadId}/turns/${turnId}/steer`, {
+      context,
+    })
+  }
+
+  /** Get SSE event stream for a thread. */
+  async eventsStream(threadId: string): Promise<Response> {
+    const url = `${this.baseUrl}/v1/threads/${threadId}/events`
+    const headers: Record<string, string> = { Accept: 'text/event-stream' }
+    if (this.authToken) headers['Authorization'] = `Bearer ${this.authToken}`
+    const res = await fetch(url, { headers })
+    if (!res.ok) {
+      const text = await res.text()
+      throw new Error(`SSE stream failed (${res.status}): ${text.slice(0, 500)}`)
+    }
+    return res
+  }
+
+  /** Handle an approval. */
+  async handleApproval(approvalId: string, decision: 'allow' | 'deny'): Promise<unknown> {
+    return this.request('POST', `/v1/approvals/${approvalId}`, { decision })
+  }
+}
+
+// ── MessageQueue ─────────────────────────────────────────────────────────────
+
+export interface QueuedMessage {
+  chatId: string
+  messageId: string
+  sender: string
+  text: string
+  filePath?: string
+  timestamp: number
+}
+
+export class MessageQueue {
+  private queues = new Map<string, QueuedMessage[]>()
+  private activeTurns = new Map<string, string>() // threadId → turnId
+
+  enqueue(threadId: string, msg: QueuedMessage): void {
+    if (!this.queues.has(threadId)) {
+      this.queues.set(threadId, [])
+    }
+    this.queues.get(threadId)!.push(msg)
+  }
+
+  dequeue(threadId: string): QueuedMessage | undefined {
+    return this.queues.get(threadId)?.shift()
+  }
+
+  hasPending(threadId: string): boolean {
+    const q = this.queues.get(threadId)
+    return q !== undefined && q.length > 0
+  }
+
+  queueSize(threadId: string): number {
+    return this.queues.get(threadId)?.length ?? 0
+  }
+
+  setActiveTurn(threadId: string, turnId: string): void {
+    this.activeTurns.set(threadId, turnId)
+  }
+
+  clearActiveTurn(threadId: string): void {
+    this.activeTurns.delete(threadId)
+  }
+
+  hasActiveTurn(threadId: string): boolean {
+    return this.activeTurns.has(threadId)
+  }
+
+  getActiveTurnId(threadId: string): string | undefined {
+    return this.activeTurns.get(threadId)
+  }
+
+  clearThread(threadId: string): void {
+    this.queues.delete(threadId)
+    this.activeTurns.delete(threadId)
+  }
+}
+
+// ── SSE Event parsing ──────────────────────────────────────────────────────
+
+export function parseSseLine(line: string): SseRawEvent | null {
+  if (!line || line.startsWith(':')) return null
+  if (line.startsWith('data: ')) {
+    try {
+      return JSON.parse(line.slice(6))
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+// ── SseEventHandler ──────────────────────────────────────────────────────────
+
+export type DeltaHandler = (threadId: string, delta: SseDelta) => void
+export type TurnCompletedHandler = (threadId: string, turn: TurnInfo) => void
+export type ApprovalHandler = (threadId: string, approval: any) => void
+export type ItemCompletedHandler = (threadId: string, item: ItemInfo) => void
+
+export class SseEventHandler {
+  private connections = new Map<string, AbortController>()
+  private api: RuntimeApiClient
+
+  onDelta: DeltaHandler | null = null
+  onTurnCompleted: TurnCompletedHandler | null = null
+  onApprovalRequired: ApprovalHandler | null = null
+  onItemCompleted: ItemCompletedHandler | null = null
+
+  constructor(api: RuntimeApiClient) {
+    this.api = api
+  }
+
+  async connect(threadId: string): Promise<void> {
+    this.disconnect(threadId)
+
+    const controller = new AbortController()
+    this.connections.set(threadId, controller)
+
+    const res = await this.api.eventsStream(threadId)
+    if (!res.body) {
+      throw new Error('SSE response has no body')
+    }
+
+    this.readStream(threadId, res.body, controller.signal).catch(err => {
+      console.error(`[sse] stream error for thread ${threadId}:`, err)
+    })
+  }
+
+  private async readStream(threadId: string, body: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void> {
+    const reader = body.getReader()
+    const decoder = new TextDecoder('utf-8')
+    let buffer = ''
+
+    try {
+      while (!signal.aborted) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() ?? ''
+
+        for (const line of lines) {
+          const trimmed = line.trimEnd()
+          if (!trimmed || trimmed.startsWith(':')) continue
+          if (trimmed.startsWith('event: ')) continue // event type is in the data payload
+
+          if (trimmed.startsWith('data: ')) {
+            try {
+              const event: SseRawEvent = JSON.parse(trimmed.slice(6))
+              this.dispatch(threadId, event)
+            } catch {
+              // ignore malformed JSON
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock()
+    }
+  }
+
+  private dispatch(threadId: string, event: SseRawEvent): void {
+    switch (event.event) {
+      case 'item.delta': {
+        if (this.onDelta && event.payload) {
+          this.onDelta(threadId, {
+            kind: event.payload.kind,
+            delta: event.payload.delta ?? '',
+            item_id: event.item_id ?? undefined,
+          })
+        }
+        break
+      }
+
+      case 'turn.completed': {
+        if (this.onTurnCompleted && event.payload?.turn) {
+          this.onTurnCompleted(threadId, event.payload.turn as TurnInfo)
+        }
+        break
+      }
+
+      case 'item.completed': {
+        if (this.onItemCompleted && event.payload?.item) {
+          this.onItemCompleted(threadId, event.payload.item as ItemInfo)
+        }
+        break
+      }
+
+      case 'approval.required': {
+        if (this.onApprovalRequired) {
+          this.onApprovalRequired(threadId, event.payload)
+        }
+        break
+      }
+
+      case 'turn.started':
+      case 'thread.started':
+      case 'item.started':
+      case 'turn.lifecycle':
+        // Informational, can be logged but not actionable
+        break
+
+      default:
+        break
+    }
+  }
+
+  disconnect(threadId: string): void {
+    const controller = this.connections.get(threadId)
+    if (controller) {
+      controller.abort()
+      this.connections.delete(threadId)
+    }
+  }
+
+  disconnectAll(): void {
+    for (const [threadId, controller] of this.connections.entries()) {
+      controller.abort()
+    }
+    this.connections.clear()
+  }
+}
+
+// ── ThreadMap ────────────────────────────────────────────────────────────────
+
+const THREAD_MAP_FILE = join(homedir(), '.deepseek', 'lodestar', 'session-thread-map.json')
+
+export class ThreadMap {
+  private map = new Map<string, string>() // sessionName → threadId
+
+  constructor() {
+    this.load()
+  }
+
+  private load(): void {
+    try {
+      const raw = readFileSync(THREAD_MAP_FILE, 'utf-8')
+      const obj = JSON.parse(raw)
+      for (const [name, id] of Object.entries(obj)) {
+        if (typeof id === 'string') this.map.set(name, id)
+      }
+    } catch {}
+  }
+
+  private save(): void {
+    try {
+      const dir = join(homedir(), '.deepseek', 'lodestar')
+      mkdirSync(dir, { recursive: true })
+      const obj: Record<string, string> = {}
+      for (const [name, id] of this.map.entries()) obj[name] = id
+      writeFileSync(THREAD_MAP_FILE, JSON.stringify(obj, null, 2))
+    } catch (err) {
+      console.error(`[thread-map] save failed: ${err}`)
+    }
+  }
+
+  getThreadId(sessionName: string): string | undefined {
+    return this.map.get(sessionName)
+  }
+
+  setThreadId(sessionName: string, threadId: string): void {
+    if (this.map.get(sessionName) === threadId) return
+    this.map.set(sessionName, threadId)
+    this.save()
+  }
+
+  removeThreadId(sessionName: string): void {
+    this.map.delete(sessionName)
+    this.save()
+  }
+
+  getSessionName(threadId: string): string | undefined {
+    for (const [name, id] of this.map.entries()) {
+      if (id === threadId) return name
+    }
+    return undefined
+  }
+
+  entries(): IterableIterator<[string, string]> {
+    return this.map.entries()
+  }
+
+  get size(): number {
+    return this.map.size
+  }
+}
+
+// ── McpConfigInjector ────────────────────────────────────────────────────────
+
+const MCP_JSON_PATH = join(homedir(), '.deepseek', 'mcp.json')
+
+export interface McpServerEntry {
+  command: string
+  args: string[]
+  env?: Record<string, string>
+}
+
+export function injectFeishuMcpConfig(): void {
+  let config: Record<string, McpServerEntry> = {}
+  try {
+    if (existsSync(MCP_JSON_PATH)) {
+      config = JSON.parse(readFileSync(MCP_JSON_PATH, 'utf-8'))
+    }
+  } catch {
+    config = {}
+  }
+
+  const mcpServerPath = join(homedir(), '.deepseek', 'lodestar', 'feishu-mcp.ts')
+
+  if (config.feishu) {
+    config.feishu.command = 'bun'
+    config.feishu.args = ['run', mcpServerPath]
+    console.log('[mcp-inject] feishu MCP entry already exists, updated path')
+  } else {
+    config.feishu = {
+      command: 'bun',
+      args: ['run', mcpServerPath],
+    }
+    console.log('[mcp-inject] added feishu MCP entry to mcp.json')
+  }
+
+  const dir = join(homedir(), '.deepseek')
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(MCP_JSON_PATH, JSON.stringify(config, null, 2))
+}
+
+export function buildSystemPrompt(groupName: string, chatId: string, workspace: string): string {
+  return [
+    `你是飞书群「${groupName}」的 AI 助手。`,
+    '',
+    `当前群聊 chat_id: ${chatId}`,
+    `工作目录: ${workspace}`,
+    '',
+    '你可以使用以下工具与飞书群交互：',
+    '- feishu_reply: 发送消息到群里（支持 Markdown 卡片渲染）',
+    '- feishu_react: 给消息添加表情反应',
+    '- feishu_send_file: 发送文件或图片到群里',
+    '- feishu_fetch_history: 获取群聊历史消息',
+    '',
+    '使用 feishu_reply 回复时，chat_id 固定为上述 chat_id。',
+    '所有你觉得用户应该看到的内容，都通过 feishu_reply 发送到群里。',
+    '',
+    '你是「夜航星」驱动的 AI 助手，保持高效、直接、有洞察力的沟通风格。',
+  ].join('\n')
+}

package/scripts/runtime-thread.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# ── 夜航星 Runtime API 线程管理工具 ────────────────────────────────────
+# 用法: source ~/.deepseek/channels/feishu/runtime-thread.sh
+#
+# 提供命令:
+#   ds-threads          列出所有 Runtime API 线程
+#   ds-resume <thread>  关闭 Runtime API 线程，在 TUI 中恢复会话
+#   ds-kill <thread>    归档指定线程
+
+API_URL="${DEEPSEEK_API_URL:-http://localhost:7878}"
+
+# Auto-detect token: env → file → default
+if [ -n "$DEEPSEEK_API_TOKEN" ]; then
+  TOKEN="$DEEPSEEK_API_TOKEN"
+elif [ -n "$DEEPSEEK_RUNTIME_TOKEN" ]; then
+  TOKEN="$DEEPSEEK_RUNTIME_TOKEN"
+elif [ -f "$HOME/.deepseek/lodestar/.runtime_token" ]; then
+  TOKEN=$(cat "$HOME/.deepseek/lodestar/.runtime_token")
+else
+  TOKEN="lodestar-runtime-token-v2"
+fi
+
+ds-threads() {
+  if ! curl -sf "$API_URL/health" > /dev/null 2>&1; then
+    echo "❌ deepseek serve --http 未运行在 $API_URL"
+    return 1
+  fi
+  echo "Runtime API 线程列表:"
+  echo "─────────────────────"
+  curl -sf "$API_URL/v1/threads" -H "Authorization: Bearer $TOKEN" | python3 -c "
+import sys, json
+threads = json.load(sys.stdin)
+for t in threads:
+    arch = '📦' if t.get('archived') else '🟢'
+    ws = t.get('workspace','?').replace('/home/$USER/','~/')
+    turn = t.get('latest_turn_id','-')
+    print(f'  {arch} {t[\"id\"]}  {ws}  turn={turn[:12]}...')
+print(f'共 {len(threads)} 个线程')
+" 2>/dev/null || echo "  (无法解析响应，请检查 TOKEN)"
+}
+
+ds-resume() {
+  local tid="${1:-}"
+  if [ -z "$tid" ]; then
+    echo "用法: ds-resume <thread_id>"
+    echo "  关闭 Runtime API 线程，在工作目录启动 TUI 会话"
+    return 1
+  fi
+  # 获取线程信息
+  local info
+  info=$(curl -sf "$API_URL/v1/threads/$tid" -H "Authorization: Bearer $TOKEN" 2>/dev/null)
+  if [ -z "$info" ]; then
+    echo "❌ 无法获取线程 $tid"
+    return 1
+  fi
+  local ws
+  ws=$(echo "$info" | python3 -c "import sys,json; print(json.load(sys.stdin)['thread']['workspace'])" 2>/dev/null)
+  if [ -z "$ws" ]; then
+    echo "❌ 无法解析 workspace"
+    return 1
+  fi
+  echo "线程: $tid"
+  echo "工作目录: $ws"
+  echo -n "归档线程并在 TUI 中恢复? [y/N] "
+  read -r confirm
+  if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
+    echo "已取消"
+    return 0
+  fi
+  # 归档线程
+  curl -s -X PATCH "$API_URL/v1/threads/$tid" \
+    -H "Authorization: Bearer $TOKEN" \
+    -H "Content-Type: application/json" \
+    -d '{"archived":true}' > /dev/null
+  echo "✅ 线程已归档"
+  echo "启动 TUI: cd $ws && deepseek"
+  cd "$ws" && deepseek
+}
+
+ds-kill() {
+  local tid="${1:-}"
+  if [ -z "$tid" ]; then
+    echo "用法: ds-kill <thread_id>"
+    return 1
+  fi
+  curl -s -X PATCH "$API_URL/v1/threads/$tid" \
+    -H "Authorization: Bearer $TOKEN" \
+    -H "Content-Type: application/json" \
+    -d '{"archived":true}' > /dev/null
+  echo "✅ 线程 $tid 已归档"
+}