@leviyuan/lodestar 0.1.0

package/src/cards.ts

@@ -0,0 +1,304 @@
+/**
+ * Schema 2.0 Feishu card templates.
+ *
+ * Element-id convention (must be unique within a card):
+ *   user_input        — the collapsible "你说" panel
+ *   thinking          — the de-emphasized thinking stream
+ *   tool_<i>          — one collapsible per tool call, indexed from 0
+ *   assistant         — the main streaming assistant answer
+ *   footer            — runtime footer (timing / status)
+ */
+
+export const ELEMENTS = {
+  thinking: 'thinking',
+  footer: 'footer',
+  tool: (i: number) => `tool_${i}`,
+  /** Assistant text is segmented: every tool call closes the running segment
+   * and the next assistant chunk opens a new one, so element order in the
+   * card matches Claude's emission order. */
+  assistant: (i: number) => `assistant_${i}`,
+} as const
+
+/** Single-line summary used as a collapsible-panel header for a tool call. */
+export function summarizeToolInput(name: string, input: any): string {
+  if (!input || typeof input !== 'object') return ''
+  const truncate = (s: string, n: number) => s.length > n ? s.slice(0, n) + '…' : s
+  switch (name) {
+    case 'Bash':       return truncate(String(input.command ?? ''), 80)
+    case 'Read':
+    case 'Write':
+    case 'Edit':
+    case 'NotebookEdit': return truncate(String(input.file_path ?? ''), 80)
+    case 'Glob':       return truncate(String(input.pattern ?? ''), 80)
+    case 'Grep':       return truncate(`${input.pattern ?? ''}${input.path ? ' in ' + input.path : ''}`, 80)
+    case 'WebFetch':
+    case 'WebSearch': return truncate(String(input.url ?? input.query ?? ''), 80)
+    case 'Agent':
+    case 'Task':       return truncate(String(input.description ?? input.subject ?? ''), 80)
+    case 'Skill':      return truncate(String(input.skill ?? ''), 80)
+  }
+  // generic fallback: first string-valued field
+  for (const v of Object.values(input)) {
+    if (typeof v === 'string' && v) return truncate(v, 80)
+  }
+  return ''
+}
+
+interface MainCardOpts {
+  sessionName: string
+  turn: number
+  model?: string
+  effort?: string
+  userText: string
+}
+
+/** Initial card sent at the start of each turn. Streaming on. */
+export function mainConversationCard(_opts: MainCardOpts): object {
+  return {
+    schema: '2.0',
+    config: {
+      streaming_mode: true,
+      summary: { content: '[Lodestar 正在生成…]' },
+      streaming_config: {
+        print_frequency_ms: { default: 60, android: 60, ios: 60, pc: 30 },
+        print_step: { default: 2, android: 2, ios: 2, pc: 4 },
+        print_strategy: 'fast',
+      },
+    },
+    body: {
+      // Initial body has just thinking + footer; assistant segments and tool
+      // panels are inserted between them in real time as Claude streams.
+      // Note: empty-string content is rejected by CardKit PUT so the
+      // thinking element starts with a single space placeholder; the first
+      // real append overwrites it.
+      elements: [
+        { tag: 'markdown', element_id: ELEMENTS.thinking, content: ' ' },
+        { tag: 'markdown', element_id: ELEMENTS.footer, content: '⏳ working…' },
+      ],
+    },
+  }
+}
+
+/** Empty assistant segment to be inserted just before the footer. */
+export function assistantSegmentElement(i: number): object {
+  return { tag: 'markdown', element_id: ELEMENTS.assistant(i), content: ' ' }
+}
+
+/** Final state for the thinking section once a turn closes — collapse the
+ * full thinking text into a panel so the card stays clean.  Replaces the
+ * top-level `thinking` markdown element via PUT /elements/:id. */
+export function thinkingCollapsedPanel(fullText: string): object {
+  const trimmed = fullText.trim()
+  return {
+    tag: 'collapsible_panel',
+    element_id: ELEMENTS.thinking,
+    header: { title: { tag: 'plain_text', content: `💭 思考过程 (${trimmed.length} 字)` } },
+    expanded: false,
+    elements: [
+      { tag: 'markdown', content: trimmed.slice(0, 8000) || '_(空)_' },
+    ],
+  }
+}
+
+/** Element to insert for each tool call. expandable for big results.
+ *
+ * Header is a one-line summary: status + name + summarized input.
+ * Body holds the full input + (after completion) the full output. */
+export function toolCallElement(
+  i: number,
+  name: string,
+  input: any,
+  output: string | null,
+  status: '⏳' | '✅' | '❌' = '⏳',
+): object {
+  const summary = summarizeToolInput(name, input)
+  const headerText = summary
+    ? `${status} 🔧 ${name}: ${summary}`
+    : `${status} 🔧 ${name}`
+  const inputBlock = '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
+  const outputBlock = output != null
+    ? '\n---\n**output:**\n```\n' + output.slice(0, 3000) + '\n```'
+    : ''
+  return {
+    tag: 'collapsible_panel',
+    element_id: ELEMENTS.tool(i),
+    header: { title: { tag: 'plain_text', content: headerText } },
+    expanded: false,
+    elements: [
+      { tag: 'markdown', content: inputBlock + outputBlock },
+    ],
+  }
+}
+
+interface PermissionOpts {
+  sessionName: string
+  toolName: string
+  description: string
+  inputPreview: string
+  requestId: string
+}
+
+export function permissionCard(opts: PermissionOpts): object {
+  const { sessionName, toolName, description, inputPreview, requestId } = opts
+  let pretty = inputPreview
+  try { pretty = JSON.stringify(JSON.parse(inputPreview), null, 2) } catch {}
+  return {
+    schema: '2.0',
+    config: { update_multi: true },
+    header: {
+      title: { tag: 'plain_text', content: `🔐 权限请求 · ${toolName}` },
+      subtitle: { tag: 'plain_text', content: sessionName },
+      template: 'orange',
+    },
+    body: {
+      elements: [
+        { tag: 'markdown', content: description },
+        { tag: 'markdown', content: '```\n' + pretty.slice(0, 2000) + '\n```' },
+        {
+          tag: 'column_set',
+          columns: [
+            permissionButtonColumn('✅ 允许', 'primary', requestId, 'allow'),
+            permissionButtonColumn('♾️ 始终允许', 'default', requestId, 'allow_always'),
+            permissionButtonColumn('❌ 拒绝', 'danger', requestId, 'deny'),
+          ],
+        },
+      ],
+    },
+  }
+}
+
+function permissionButtonColumn(label: string, type: string, requestId: string, decision: string): object {
+  return {
+    tag: 'column', width: 'weighted', weight: 1,
+    elements: [{
+      tag: 'button',
+      text: { tag: 'plain_text', content: label },
+      type,
+      behaviors: [{ type: 'callback', value: { kind: 'permission', request_id: requestId, decision } }],
+    }],
+  }
+}
+
+export function permissionResolvedCard(
+  toolName: string,
+  decision: 'allow' | 'allow_always' | 'deny',
+  user: string,
+): object {
+  const ok = decision !== 'deny'
+  const label = decision === 'allow_always' ? '始终允许' : decision === 'allow' ? '已允许' : '已拒绝'
+  return {
+    schema: '2.0',
+    config: { update_multi: true },
+    header: {
+      title: { tag: 'plain_text', content: `🔐 权限请求 · ${toolName}` },
+      template: ok ? 'green' : 'red',
+    },
+    body: {
+      elements: [{
+        tag: 'markdown',
+        content: `${ok ? '✅' : '❌'} **${label}** by ${user || '匿名'} · ${new Date().toLocaleTimeString('zh-CN', { hour12: false })}`,
+      }],
+    },
+  }
+}
+
+interface ConsoleOpts {
+  sessionName: string
+  status: 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'
+  model?: string
+  effort?: string
+  uptime?: string
+  lastActivity?: string
+  hasSession: boolean
+}
+
+export function consoleCard(opts: ConsoleOpts): object {
+  const { sessionName, status, model, effort, uptime, lastActivity, hasSession } = opts
+  const statusEmoji = {
+    idle: '🟢 闲', working: '⚙️ 工作中', awaiting_permission: '🔐 等审批',
+    starting: '🚀 启动中', stopped: '⚪ 未运行',
+  }[status]
+  const meta = [
+    `状态: ${statusEmoji}`,
+    model ? `模型: ${model}${effort ? `/${effort}` : ''}` : null,
+    uptime ? `运行: ${uptime}` : null,
+    lastActivity ? `最近: ${lastActivity}` : null,
+  ].filter(Boolean).join(' · ')
+
+  const buttons: [string, string, string][] = hasSession
+    ? [
+        ['⏸ 中断', 'interrupt', 'default'],
+        ['🧹 /clear', 'clear', 'default'],
+        ['⏹ 终止', 'stop', 'danger'],
+        ['📁 ls', 'ls', 'default'],
+      ]
+    : [
+        ['🚀 启动', 'start', 'primary'],
+        ['🔁 续聊', 'resume', 'default'],
+        ['📁 ls', 'ls', 'default'],
+      ]
+
+  const template = status === 'working' ? 'blue'
+    : status === 'awaiting_permission' ? 'orange'
+    : status === 'stopped' ? 'grey'
+    : 'green'
+
+  return {
+    schema: '2.0',
+    config: { update_multi: true },
+    header: {
+      title: { tag: 'plain_text', content: `🌟 Lodestar · ${sessionName}` },
+      template,
+    },
+    body: {
+      elements: [
+        { tag: 'markdown', content: meta || '_(no state)_' },
+        {
+          tag: 'column_set',
+          columns: buttons.map(([label, action, kind]) => ({
+            tag: 'column', width: 'weighted', weight: 1,
+            elements: [{
+              tag: 'button',
+              text: { tag: 'plain_text', content: label },
+              type: kind,
+              behaviors: [{ type: 'callback', value: { kind: 'console', action } }],
+            }],
+          })),
+        },
+      ],
+    },
+  }
+}
+
+interface MenuOpts {
+  question: string
+  options: string[]
+  requestId: string
+}
+
+export function menuCard(opts: MenuOpts): object {
+  const { question, options, requestId } = opts
+  return {
+    schema: '2.0',
+    config: { update_multi: true },
+    header: {
+      title: { tag: 'plain_text', content: '📋 等待选择' },
+      template: 'turquoise',
+    },
+    body: {
+      elements: [
+        { tag: 'markdown', content: question || '_请选择一项：_' },
+        ...options.map((opt, i) => ({
+          tag: 'button',
+          text: { tag: 'plain_text', content: opt },
+          type: 'default',
+          behaviors: [{ type: 'callback', value: { kind: 'menu', request_id: requestId, choice: i } }],
+        })),
+      ],
+    },
+  }
+}
+
+export const STREAMING_OFF_SETTINGS = {
+  config: { streaming_mode: false, summary: { content: '✅ Lodestar 完成' } },
+}

package/src/claude-process.ts

@@ -0,0 +1,301 @@
+/**
+ * Headless Claude Code subprocess + SDK control protocol over NDJSON.
+ *
+ * Spawned with:
+ *   claude -p
+ *     --input-format=stream-json
+ *     --output-format=stream-json
+ *     --verbose
+ *     --permission-prompt-tool=stdio
+ *     --permission-mode={mode}
+ *     [--effort=max] [--model=...] [--append-system-prompt=...]
+ *     [--resume <id> --resume-session-at <uuid>]
+ *
+ * Stdin / stdout are line-delimited JSON. Stdout flows assistant chunks,
+ * tool_use, tool_result, control_request (can_use_tool / hook_callback)
+ * and finally `result` per turn.  Stdin carries user messages and our
+ * outbound control_responses + control_requests (Initialize / Interrupt /
+ * SetPermissionMode).
+ */
+
+import { spawn, type ChildProcessByStdio } from 'node:child_process'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { EventEmitter } from 'node:events'
+import type { Readable, Writable } from 'node:stream'
+import { log } from './log'
+
+interface SpawnOpts {
+  workDir: string
+  resumeSessionId?: string
+  resumeAtUuid?: string
+  model?: string
+  effort?: 'low' | 'medium' | 'high' | 'max'
+  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions'
+  appendSystemPrompt?: string
+}
+
+export interface CanUseToolRequest {
+  request_id: string
+  tool_name: string
+  input: any
+  permission_suggestions?: any
+  blocked_paths?: string[]
+  tool_use_id?: string
+}
+
+export interface HookCallbackRequest {
+  request_id: string
+  callback_id: string
+  input: any
+  tool_use_id?: string
+}
+
+export class ClaudeProcess extends EventEmitter {
+  private proc: ChildProcessByStdio<Writable, Readable, Readable>
+  private stdoutBuf = ''
+  private stderrBuf = ''
+  private requestCounter = 0
+  private alive = true
+  private expectedExit = false
+  sessionId: string | null = null
+  lastAssistantUuid: string | null = null
+
+  constructor(opts: SpawnOpts) {
+    super()
+    const claudeBin = join(homedir(), '.local', 'bin', 'claude')
+    const args = [
+      '-p',
+      '--input-format=stream-json',
+      '--output-format=stream-json',
+      '--verbose',
+      '--permission-prompt-tool=stdio',
+      `--permission-mode=${opts.permissionMode ?? 'default'}`,
+    ]
+    if (opts.model) args.push('--model', opts.model)
+    if (opts.effort) args.push('--effort', opts.effort)
+    if (opts.appendSystemPrompt) args.push('--append-system-prompt', opts.appendSystemPrompt)
+    if (opts.resumeSessionId) {
+      args.push('--resume', opts.resumeSessionId)
+      if (opts.resumeAtUuid) args.push('--resume-session-at', opts.resumeAtUuid)
+    }
+
+    log(`claude-process: spawn ${claudeBin} (cwd=${opts.workDir})`)
+    this.proc = spawn(claudeBin, args, {
+      cwd: opts.workDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        NPM_CONFIG_LOGLEVEL: 'error',
+        PATH: [
+          join(homedir(), '.local', 'bin'),
+          join(homedir(), '.bun', 'bin'),
+          join(homedir(), '.local', 'npm-global', 'bin'),
+          '/usr/local/bin', '/usr/bin', '/bin',
+        ].join(':'),
+      },
+    }) as ChildProcessByStdio<Writable, Readable, Readable>
+
+    this.proc.stdout.on('data', (chunk: Buffer) => this.onStdout(chunk))
+    this.proc.stderr.on('data', (chunk: Buffer) => this.onStderr(chunk))
+    this.proc.on('exit', (code, signal) => {
+      this.alive = false
+      log(`claude-process: exited code=${code} signal=${signal} expected=${this.expectedExit}`)
+      this.emit('exit', { code, signal, expected: this.expectedExit })
+    })
+    this.proc.on('error', err => {
+      log(`claude-process: spawn error: ${err}`)
+      this.emit('error', err)
+    })
+  }
+
+  // ── Stream parsers ─────────────────────────────────────────────────
+  private onStdout(chunk: Buffer): void {
+    this.stdoutBuf += chunk.toString()
+    let nl: number
+    while ((nl = this.stdoutBuf.indexOf('\n')) >= 0) {
+      const line = this.stdoutBuf.slice(0, nl).trim()
+      this.stdoutBuf = this.stdoutBuf.slice(nl + 1)
+      if (!line) continue
+      try {
+        const msg = JSON.parse(line)
+        this.handleMessage(msg)
+      } catch (e) {
+        log(`claude-process: bad json: ${line.slice(0, 200)} (${e})`)
+      }
+    }
+  }
+
+  private onStderr(chunk: Buffer): void {
+    this.stderrBuf += chunk.toString()
+    let nl: number
+    while ((nl = this.stderrBuf.indexOf('\n')) >= 0) {
+      const line = this.stderrBuf.slice(0, nl)
+      this.stderrBuf = this.stderrBuf.slice(nl + 1)
+      if (line.trim()) log(`claude-process[stderr]: ${line}`)
+    }
+  }
+
+  private handleMessage(msg: any): void {
+    const type = msg.type
+    if (type === 'system' && msg.subtype === 'init') {
+      this.sessionId = msg.session_id ?? null
+      log(`claude-process: session=${this.sessionId}`)
+      this.emit('init', msg)
+      return
+    }
+    if (type === 'control_request') {
+      const req = msg.request
+      if (req?.subtype === 'can_use_tool') {
+        this.emit('can_use_tool', {
+          request_id: msg.request_id,
+          tool_name: req.tool_name,
+          input: req.input,
+          permission_suggestions: req.permission_suggestions,
+          blocked_paths: req.blocked_paths,
+          tool_use_id: req.tool_use_id,
+        } as CanUseToolRequest)
+        return
+      }
+      if (req?.subtype === 'hook_callback') {
+        this.emit('hook_callback', {
+          request_id: msg.request_id,
+          callback_id: req.callback_id,
+          input: req.input,
+          tool_use_id: req.tool_use_id,
+        } as HookCallbackRequest)
+        return
+      }
+      log(`claude-process: unknown control_request subtype=${req?.subtype}`)
+      return
+    }
+    if (type === 'control_response') {
+      this.emit('control_response', msg)
+      return
+    }
+    if (type === 'assistant') {
+      const content = msg.message?.content ?? []
+      for (const block of content) {
+        if (block.type === 'text' && typeof block.text === 'string') {
+          this.emit('assistant_text', { uuid: msg.uuid, text: block.text })
+        } else if (block.type === 'tool_use') {
+          this.emit('tool_use', { uuid: msg.uuid, id: block.id, name: block.name, input: block.input })
+        } else if (block.type === 'thinking' && typeof block.thinking === 'string') {
+          this.emit('thinking', { uuid: msg.uuid, text: block.thinking })
+        }
+      }
+      if (msg.uuid) this.lastAssistantUuid = msg.uuid
+      return
+    }
+    if (type === 'user') {
+      const content = msg.message?.content ?? []
+      for (const block of content) {
+        if (block.type === 'tool_result') {
+          this.emit('tool_result', {
+            tool_use_id: block.tool_use_id,
+            content: block.content,
+            is_error: block.is_error ?? false,
+          })
+        }
+      }
+      return
+    }
+    if (type === 'result') {
+      this.emit('result', msg)
+      return
+    }
+    this.emit('raw', msg)
+  }
+
+  private write(obj: object): void {
+    if (!this.alive) {
+      log(`claude-process: write to dead process: ${JSON.stringify(obj).slice(0, 200)}`)
+      return
+    }
+    try {
+      this.proc.stdin.write(JSON.stringify(obj) + '\n')
+    } catch (e) { log(`claude-process: stdin write failed: ${e}`) }
+  }
+
+  // ── Outbound control ────────────────────────────────────────────────
+  sendInitialize(hooks: Record<string, any> = {}): void {
+    this.write({
+      type: 'control_request',
+      request_id: `init-${++this.requestCounter}`,
+      request: { subtype: 'initialize', hooks },
+    })
+  }
+
+  sendUserText(text: string, files: string[] = []): void {
+    const fileHints = files.length ? files.map(f => `[file: ${f}]`).join(' ') + '\n\n' : ''
+    this.write({
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{ type: 'text', text: fileHints + text }],
+      },
+    })
+  }
+
+  sendInterrupt(): void {
+    this.write({
+      type: 'control_request',
+      request_id: `int-${++this.requestCounter}`,
+      request: { subtype: 'interrupt' },
+    })
+  }
+
+  sendPermissionResponse(requestId: string, decision: 'allow' | 'deny', updatedInput?: any): void {
+    this.write({
+      type: 'control_response',
+      response: {
+        subtype: 'success',
+        request_id: requestId,
+        response: {
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: decision,
+            ...(updatedInput ? { permissionDecisionInput: updatedInput } : {}),
+          },
+        },
+      },
+    })
+  }
+
+  sendHookResponse(requestId: string, output: object = {}): void {
+    this.write({
+      type: 'control_response',
+      response: {
+        subtype: 'success',
+        request_id: requestId,
+        response: output,
+      },
+    })
+  }
+
+  sendSetPermissionMode(mode: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions'): void {
+    this.write({
+      type: 'control_request',
+      request_id: `mode-${++this.requestCounter}`,
+      request: { subtype: 'set_permission_mode', mode },
+    })
+  }
+
+  // ── Lifecycle ───────────────────────────────────────────────────────
+  isAlive(): boolean { return this.alive }
+
+  async kill(timeoutMs = 5000): Promise<void> {
+    if (!this.alive) return
+    this.expectedExit = true
+    log(`claude-process: SIGTERM (timeout=${timeoutMs}ms)`)
+    try { this.proc.kill('SIGTERM') } catch {}
+    const start = Date.now()
+    while (this.alive && Date.now() - start < timeoutMs) {
+      await new Promise(r => setTimeout(r, 100))
+    }
+    if (this.alive) {
+      log('claude-process: SIGKILL (graceful timeout)')
+      try { this.proc.kill('SIGKILL') } catch {}
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,83 @@
+/**
+ * Read config.toml — minimal hand-rolled parser sufficient for the
+ * two-section, scalar-value-only schema we expect:
+ *
+ *   [feishu]
+ *   app_id = "cli_..."
+ *   app_secret = "..."
+ *
+ *   [runtime]
+ *   projects_root = "~/"      # optional, defaults to $HOME
+ *
+ * Loaded synchronously at import time; downstream modules read the
+ * exported `config` object directly.
+ */
+
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { CONFIG_FILE } from './paths'
+
+export interface LodestarConfig {
+  feishu: {
+    app_id: string
+    app_secret: string
+  }
+  runtime: {
+    projects_root: string
+  }
+}
+
+function expandTilde(v: string): string {
+  return v.replace(/^~(?=\/|$)/, homedir())
+}
+
+function parseToml(text: string): Record<string, Record<string, string>> {
+  const out: Record<string, Record<string, string>> = { _: {} }
+  let section = '_'
+  for (const raw of text.split('\n')) {
+    const line = raw.replace(/(^|[^\\])#.*$/, '$1').trim()
+    if (!line) continue
+    const sec = line.match(/^\[([^\]]+)\]$/)
+    if (sec) {
+      section = sec[1].trim()
+      out[section] ??= {}
+      continue
+    }
+    const kv = line.match(/^([\w.-]+)\s*=\s*(.+)$/)
+    if (kv) {
+      let v = kv[2].trim()
+      if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+        v = v.slice(1, -1)
+      }
+      out[section][kv[1]] = v
+    }
+  }
+  return out
+}
+
+function loadConfig(): LodestarConfig {
+  let raw: string
+  try {
+    raw = readFileSync(CONFIG_FILE, 'utf8')
+  } catch (e) {
+    process.stderr.write(
+      `lodestar: cannot read config at ${CONFIG_FILE}\n` +
+      `  set LODESTAR_CONFIG=/path/to/config.toml to override, or create the file with:\n\n` +
+      `    [feishu]\n    app_id = "cli_xxx"\n    app_secret = "xxx"\n\n`,
+    )
+    throw e
+  }
+  const t = parseToml(raw)
+  const appId = t.feishu?.app_id
+  const appSecret = t.feishu?.app_secret
+  if (!appId || !appSecret) {
+    throw new Error(`lodestar: ${CONFIG_FILE} is missing [feishu].app_id / [feishu].app_secret`)
+  }
+  const projectsRoot = expandTilde(t.runtime?.projects_root ?? homedir())
+  return {
+    feishu: { app_id: appId, app_secret: appSecret },
+    runtime: { projects_root: projectsRoot },
+  }
+}
+
+export const config = loadConfig()