@leviyuan/lodestar 0.2.3 → 0.2.5

package/README.md

@@ -50,9 +50,9 @@ AI 不是帮手,是倍率。它放大的不是体力,是你——你的直觉、
 | --- | --- |
 | `hi` | 未运行时启动;运行中弹一张**状态卡片** |
 | `stop` | 软打断当前 turn + 清空 type-ahead 排队;子进程保活,刚排队中的消息会被打 `CrossMark` 反应表示取消 |
-| `kill` | 优雅关闭 Claude 进程;记住 `sessionId`,下次 `restart` 还能 resume |
-| `restart` | 用上一次的 `sessionId` 重启会话(保留上下文) |
-| `clear` | 杀掉进程并启动一个全新 session(等价于 Claude Code 的 `/clear`) |
+| `kill` | 优雅关闭 Claude 进程;`sessionId` 仍记在磁盘,下次 `restart` 还能 resume |
+| `restart` | 用上一次的 `sessionId` 重启会话(保留上下文);无进程时也能用,等于"恢复上一会话" |
+| `clear` | 杀掉当前进程并启动一个全新 session(等价于 Claude Code 的 `/clear`);**无进程时无效** |
 
 > 这五个词被全局保留:在群里发 "hi" 当问候也会触发控制台卡片,不会到 Claude 那边。换来的是手机上单手打字的便利。
 

package/daemon.ts

@@ -192,9 +192,6 @@ async function handleCardAction(data: any): Promise<any> {
     case 'permission':
       await session.onPermissionDecision(value.request_id, value.decision, userId)
       return { toast: { type: value.decision === 'deny' ? 'error' : 'success', content: '已处理' } }
-    case 'console':
-      await session.onConsoleAction(value.action)
-      return { toast: { type: 'info', content: value.action } }
     case 'menu':
       await session.onUserMessage(`(menu choice ${value.choice + 1})`)
       return { toast: { type: 'success', content: 'OK' } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leviyuan/lodestar",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "publishConfig": {
     "access": "public"
   },

package/src/cards.ts

@@ -171,7 +171,6 @@ interface MainCardOpts {
   turn: number
   model?: string
   effort?: string
-  userText: string
   /** What started this turn. `'scheduled'` adds a top-of-card banner so
    * the user can tell a cron-fired wakeup apart from one of their own
    * messages — the user's message bubble is otherwise the only visual
@@ -200,7 +199,8 @@ export function mainConversationCard(opts: MainCardOpts): object {
       // 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.
+      // real append overwrites it. No echo of the user's message inside
+      // the card — the chat bubble above already shows it.
       elements: [
         ...banner,
         { tag: 'markdown', element_id: ELEMENTS.thinking, content: ' ' },
@@ -550,7 +550,6 @@ interface ConsoleOpts {
   cumStats?: { tokens: number; costUsd: number; turns: number }
   lastTurn?: { tokens: number; costUsd: number; durationMs: number }
   sessionId?: string | null
-  hasSession: boolean
 }
 
 /** Format token counts as a compact human-readable string: 1,234 → 1.2K. */
@@ -656,7 +655,7 @@ export function consoleUsageContent(
 export function consoleCard(opts: ConsoleOpts): object {
   const {
     sessionName, status, model, effort, uptimeMs, peers, usage,
-    contextTokens, contextLimit, cumStats, lastTurn, sessionId, hasSession,
+    contextTokens, contextLimit, cumStats, lastTurn, sessionId,
   } = opts
   const statusEmoji = {
     idle: '🟢 闲', working: '⚙️ 工作中', awaiting_permission: '🔐 等审批',
@@ -698,12 +697,6 @@ export function consoleCard(opts: ConsoleOpts): object {
     lines.push(`**🆔 session**　\`${sessionId.slice(0, 8)}…\``)
   }
 
-  void hasSession // accept the field for caller compat; lifecycle is now
-  // driven by bare-word commands (`hi` / `kill` / `restart` / `clear`),
-  // not buttons — keeps the panel pure-readout and one-handed mobile-
-  // friendly. The 'refresh' / 'ls' actions stay in onConsoleAction for
-  // backward compat with any still-floating older cards in chat history.
-
   const template = status === 'working' ? 'blue'
     : status === 'awaiting_permission' ? 'orange'
     : status === 'stopped' ? 'grey'

package/src/feishu.ts

@@ -8,6 +8,7 @@
 
 import * as lark from '@larksuiteoapi/node-sdk'
 import { execSync } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
 import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, extname, join } from 'node:path'
@@ -165,32 +166,84 @@ export async function refreshChatList(): Promise<void> {
 }
 
 // ── Outbound: text + card ──────────────────────────────────────────────
-export async function sendText(chatId: string, text: string): Promise<string | null> {
-  try {
-    const res: any = await client.im.message.create({
-      params: { receive_id_type: 'chat_id' },
-      data: { receive_id: chatId, msg_type: 'text', content: JSON.stringify({ text }) },
-    })
-    if (res?.code && res.code !== 0) {
-      log(`feishu: sendText rejected chat=${chatId} code=${res.code} msg=${res.msg}`)
-      return null
+/** Delay schedule for sendText/sendCard SDK retries. Three attempts total
+ * (the leading 0 is the eager first try). Tuned for the bun+axios+lark-SDK
+ * ECONNREFUSED transient we've been seeing — by ~5s the socket pool
+ * usually recovers. Business errors (Feishu code != 0) are NOT retried;
+ * only thrown network errors are. */
+const SEND_RETRY_DELAYS_MS = [0, 1000, 4000]
+
+async function sendViaSdkWithRetry(
+  what: 'text' | 'card',
+  chatId: string,
+  msgType: 'text' | 'interactive',
+  content: string,
+): Promise<string | null> {
+  // Same uuid across retries → Feishu dedupes on its side so a successful-
+  // but-response-lost first attempt doesn't produce a duplicate message.
+  const uuid = randomUUID()
+  let lastErr: unknown = null
+  for (let i = 0; i < SEND_RETRY_DELAYS_MS.length; i++) {
+    if (SEND_RETRY_DELAYS_MS[i] > 0) {
+      await new Promise(r => setTimeout(r, SEND_RETRY_DELAYS_MS[i]))
     }
-    return res?.data?.message_id ?? null
-  } catch (e) { log(`feishu: sendText failed chat=${chatId}: ${e}`); return null }
+    try {
+      const res: any = await client.im.message.create({
+        params: { receive_id_type: 'chat_id' },
+        data: { receive_id: chatId, msg_type: msgType, content, uuid },
+      })
+      if (res?.code && res.code !== 0) {
+        log(`feishu: send${what === 'text' ? 'Text' : 'Card'} rejected chat=${chatId} code=${res.code} msg=${res.msg}`)
+        return null
+      }
+      return res?.data?.message_id ?? null
+    } catch (e) {
+      lastErr = e
+      log(`feishu: send${what === 'text' ? 'Text' : 'Card'} attempt ${i + 1}/${SEND_RETRY_DELAYS_MS.length} chat=${chatId} failed: ${e}`)
+    }
+  }
+  log(`feishu: send${what === 'text' ? 'Text' : 'Card'} chat=${chatId} EXHAUSTED ${SEND_RETRY_DELAYS_MS.length} retries: ${lastErr}`)
+  return null
+}
+
+export async function sendText(chatId: string, text: string): Promise<string | null> {
+  return sendViaSdkWithRetry('text', chatId, 'text', JSON.stringify({ text }))
 }
 
 export async function sendCard(chatId: string, card: object): Promise<string | null> {
+  return sendViaSdkWithRetry('card', chatId, 'interactive', JSON.stringify(card))
+}
+
+/** Last-resort text send that bypasses the lark SDK and uses raw fetch
+ * (which is what cardkit.ts uses and has never had stability issues on
+ * this runtime). Used by callers that need to *surface a failure when
+ * the SDK send path itself is the broken thing* — e.g. `openTurnCard`'s
+ * `sendCard` exhausted retries on ECONNREFUSED and we still owe the
+ * user a visible "your message was lost, please retry" notice. Do not
+ * use this as a general-purpose send; it's the failure-surfacing
+ * channel, not a silent fallback. */
+export async function sendTextRaw(chatId: string, text: string): Promise<string | null> {
   try {
-    const res: any = await client.im.message.create({
-      params: { receive_id_type: 'chat_id' },
-      data: { receive_id: chatId, msg_type: 'interactive', content: JSON.stringify(card) },
+    const token = await getTenantToken()
+    const res = await fetch('https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=chat_id', {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        receive_id: chatId,
+        msg_type: 'text',
+        content: JSON.stringify({ text }),
+      }),
     })
-    if (res?.code && res.code !== 0) {
-      log(`feishu: sendCard rejected chat=${chatId} code=${res.code} msg=${res.msg}`)
+    const json = await res.json() as any
+    if (json?.code !== 0) {
+      log(`feishu: sendTextRaw rejected chat=${chatId} code=${json?.code} msg=${json?.msg}`)
       return null
     }
-    return res?.data?.message_id ?? null
-  } catch (e) { log(`feishu: sendCard failed chat=${chatId}: ${e}`); return null }
+    return json.data?.message_id ?? null
+  } catch (e) {
+    log(`feishu: sendTextRaw chat=${chatId} failed: ${e}`)
+    return null
+  }
 }
 
 // ── Reactions ──────────────────────────────────────────────────────────

package/src/session.ts

@@ -34,7 +34,6 @@ interface TurnState {
    * not signal. Ask / permission urgents inside the turn still fire
    * regardless (those genuinely need attention even mid-schedule). */
   trigger: 'user_message' | 'scheduled'
-  userText: string
   thinkingText: string
   toolCount: number
   /** `output` / `isError` are filled in by completeTool — kept on the
@@ -399,9 +398,23 @@ export class Session {
         await this.stop()
         return true
       case 'restart':
+        // resume the prior conversation — kills the current proc (if
+        // any) and spawns a new one with `--resume <lastSessionId>`.
+        // If no process is running, this is how the user gets back the
+        // previous conversation after a `kill` or a daemon crash.
         await this.restart(true)
         return true
       case 'clear':
+        // "throw away current conversation, start a new one". By design
+        // this only makes sense when there IS a current conversation:
+        // calling clear from stopped state is a no-op (user-confirmed
+        // 2026-05-16) — we don't want a stray `clear` to silently spawn
+        // a fresh session the user didn't ask for. To start from cold,
+        // use `hi`.
+        if (!this.isRunning()) {
+          await feishu.sendText(this.chatId, `⚪ session "${this.sessionName}" 当前未运行,clear 无效;用 \`hi\` 启动或 \`restart\` 恢复上一会话`)
+          return true
+        }
         await this.restart(false)
         return true
     }
@@ -439,7 +452,6 @@ export class Session {
           }
         : undefined,
       sessionId: this.proc?.sessionId ?? this.lastSessionId,
-      hasSession: this.isRunning(),
     })
     const messageId = await feishu.sendCard(this.chatId, card)
     if (!messageId) return
@@ -480,12 +492,47 @@ export class Session {
       const ok = await this.start()
       if (!ok) return
     }
+    // Garbage-collect leftover state from a batch the SDK abandoned —
+    // most commonly an AskUserQuestion mid-turn, which makes the SDK
+    // emit `QUEUE remove × N` and drop every msg we'd already
+    // sendText'd into its queue. The daemon doesn't see those remove
+    // events, so `pendingUserMessageCount` and `pendingReactionIds`
+    // stay stuck. If the SDK is idle right now (no turn, no eager-
+    // open in flight) AND init has already fired at least once
+    // (otherwise we'd be in the bootstrap race window where
+    // leftover count IS valid — see wasBusy comment below), the
+    // leftover count is stale and must be cleared BEFORE the
+    // wasBusy computation — otherwise this fresh solo message gets
+    // falsely wrapped `<u>…</u>` and its card closes with
+    // `📨 转交新卡` instead of `✅`.
+    if (this.initCount >= 1 && !this.currentTurn && !this.openingTurn && this.pendingUserMessageCount > 0) {
+      this.pendingUserMessageCount = 0
+      // Release stale ⏳ reactions left on the abandoned batch's
+      // chat messages. addReaction callbacks still in flight will
+      // fall through to the orphan path in the wasBusy branch
+      // below (which deletes whatever rid lands after both maps
+      // are empty).
+      for (const [m, rid] of this.pendingReactionIds) {
+        if (rid) void feishu.deleteReaction(m, rid)
+      }
+      this.pendingReactionIds = new Map()
+    }
     // Capture busy-state SYNC, before any state mutation — this decides
     // whether the message will visibly queue (gets the OneSecond → later
     // CheckMark lifecycle reactions on its Feishu chat message) or
     // eager-open its own card (no reaction needed; the card itself is
     // the acknowledgement).
-    const wasBusy = this.currentTurn !== null || this.openingTurn
+    //
+    // `pendingUserMessageCount > 0` catches the bootstrap race: daemon
+    // just spawned, `initCount` is still 0 so no card is open yet, but
+    // we've already sendText'd a previous user message into the SDK.
+    // The next message lands in the SAME merged-batch SDK queue, so
+    // it IS mid-flight from the SDK's perspective — without this
+    // check, the daemon would mark it as solo (no `<u>` wrap, no ⏳
+    // reaction) and the model would see e.g. "123" + "321" + "1"
+    // glued into a single string "1233211" (2026-05-16 accumulator
+    // bug).
+    const wasBusy = this.currentTurn !== null || this.openingTurn || this.pendingUserMessageCount > 0
     this.pendingUserMessageCount++
     this.lastUserOpenId = userOpenId
     // When the SDK will merge this msg with siblings into a multi-
@@ -496,8 +543,9 @@ export class Session {
     // chars and `<u>1</u><u>45</u>` became "145" to the model
     // (2026-05-16 accumulator test). HTML-tag wrap is visible but
     // models parse `<tag>` boundaries very reliably from training.
-    // Solo (eager-open) msgs don't get wrapped — no sibling, no
-    // merge, no need. Contract declared in CHANNEL_INSTRUCTIONS.
+    // Only the very first solo message of a fresh SDK turn slot
+    // skips the wrap — no sibling, no merge, no need. Contract
+    // declared in CHANNEL_INSTRUCTIONS.
     const wireText = wasBusy ? `<u>${text}</u>` : text
     this.proc!.sendUserText(wireText, files)
     if (wasBusy && msgId) {
@@ -509,11 +557,34 @@ export class Session {
       this.pendingReactionIds.set(msgId, '')
       void (async () => {
         const rid = await feishu.addReaction(msgId, 'OneSecond')
-        if (rid && this.pendingReactionIds.has(msgId)) {
+        if (!rid) return
+        if (this.pendingReactionIds.has(msgId)) {
           this.pendingReactionIds.set(msgId, rid)
+        } else if (this.currentBatchReactionIds.has(msgId)) {
+          // Init handler renamed the sentinel into the batch map while
+          // addReaction was in flight — record the rid there so the
+          // batch's close-time deleteReaction sees it.
+          this.currentBatchReactionIds.set(msgId, rid)
+        } else {
+          // Orphan: both maps cleared (closeTurnCard already released
+          // them) before our add returned. The reaction is now stuck
+          // on the Feishu message with no one tracking it — delete
+          // directly so the user doesn't see a stale ⏳ forever.
+          // (Observed bug 2026-05-16: 8 OneSeconds added during a M0
+          // turn, 2 addReaction callbacks landed after close fired the
+          // release loop, those rids never made it back into either
+          // map → 2 stuck ⏳ in chat.)
+          void feishu.deleteReaction(msgId, rid)
         }
       })()
     }
+    // Mid-turn user messages don't touch the in-flight card — the SDK
+    // queues them and dequeues them on its next turn boundary, at
+    // which point `result` closes the current card with `📨 转交新卡`
+    // and `init` opens a fresh card for the merged batch turn. The
+    // user's own message bubble in the chat (plus the OneSecond ⏳
+    // reaction added above) is the only mid-flight feedback they get;
+    // no card edit, no echo inside the card.
     if (!this.currentTurn && !this.openingTurn && this.initCount >= 1) {
       // Eager open: this message is going to be processed solo (no current
       // turn to merge with on the SDK side, so SDK runs it as its own turn).
@@ -524,7 +595,7 @@ export class Session {
       this.openingTurn = true
       this.pendingUserMessageCount--
       try {
-        await this.openTurnCard(text, userOpenId, 'user_message')
+        await this.openTurnCard(userOpenId, 'user_message')
         this.status = 'working'
       } finally {
         this.openingTurn = false
@@ -719,19 +790,6 @@ export class Session {
     }
   }
 
-  async onConsoleAction(action: string): Promise<void> {
-    log(`session "${this.sessionName}": console action=${action}`)
-    switch (action) {
-      case 'interrupt': this.interrupt(); break
-      case 'clear':     await this.restart(false); break
-      case 'stop':      await this.stop(); break
-      case 'start':     await this.start(); break
-      case 'resume':    await this.restart(true); break
-      case 'refresh':   await this.showConsole(); break
-      case 'ls':        await feishu.sendText(this.chatId, `📁 ${this.workDir}`); break
-    }
-  }
-
   // ── Wiring Claude → Feishu ─────────────────────────────────────────
   private wireProc(p: ClaudeProcess): void {
     p.on('init', () => {
@@ -744,31 +802,22 @@ export class Session {
       }
       this.initCount++
 
-      // The boot init (initCount === 1) only happens once per spawn and
-      // is claimed by whichever user message gets processed first — that
-      // message's card is opened eagerly in `onUserMessage`, so the boot
-      // init itself opens nothing. EXCEPTION: if a user message landed
-      // before the boot init (rare race during start()), the queue has
-      // an entry — drain it here.
+      // Boot init (initCount === 1) is claimed by `onUserMessage`'s
+      // eager-open path — if a user message landed before the init
+      // arrived, it sits in `pendingUserMessageCount` and we drain it
+      // below; otherwise the init opens nothing. Subsequent inits
+      // (initCount >= 2) mark the start of an SDK-initiated turn:
+      // either the SDK is draining the type-ahead queue we fed it via
+      // `sendUserText` (isUserBatch), or it's a CronCreate /
+      // ScheduleWakeup fire from idle (isScheduledFire).
       //
-      // Subsequent inits (initCount >= 2) mark the start of an SDK-
-      // initiated turn — either the SDK draining its internal type-ahead
-      // queue (we'll have an entry in `pendingUserMessages` mirroring
-      // it) or a CronCreate / ScheduleWakeup fire (queue empty). The
-      // `currentTurn` / `openingTurn` checks guard the race where
-      // `onUserMessage` already eager-opened (or is mid-open) for the
-      // same user message and the SDK emitted an init#≥2 we don't need
-      // to act on. The init handler ALSO claims `openingTurn` for its
-      // own async open so a user message landing during the open
-      // doesn't spawn a duplicate card.
+      // SDK-driven rotation puts the boundary HERE: the previous
+      // turn's `result` already closed the in-flight card with
+      // `📨 转交新卡` (because pendingUserMessageCount > 0). Now we
+      // open a fresh card whose top panel shows the queued messages.
+      // currentTurn should be null at this point (result null'd it);
+      // the openingTurn guard catches the eager-open vs init race.
       if (this.currentTurn || this.openingTurn) return
-      // `pendingUserMessageCount > 0` ⇒ SDK is about to fire an init for a
-      // merged batch of one-or-more user messages we already sendText'd
-      // (the eager-open path didn't claim them because a turn was still
-      // running at the time). Claim the ENTIRE count here — the SDK
-      // collapses them into ONE turn, so only one card opens; any further
-      // messages that arrive after this point will start a fresh count
-      // and a fresh batch.
       const isUserBatch = this.pendingUserMessageCount > 0
       const isScheduledFire = !isUserBatch && this.initCount > 1
       if (!isUserBatch && !isScheduledFire) return
@@ -784,11 +833,7 @@ export class Session {
       this.openingTurn = true
       void (async () => {
         try {
-          await this.openTurnCard(
-            isUserBatch ? '' : '⏰ 定时唤醒',
-            userOpenId,
-            isUserBatch ? 'user_message' : 'scheduled',
-          )
+          await this.openTurnCard(userOpenId, isUserBatch ? 'user_message' : 'scheduled')
           this.status = 'working'
         } finally {
           this.openingTurn = false
@@ -816,7 +861,14 @@ export class Session {
     })
     p.on('result', () => {
       this.accumulateResultStats()
-      void this.closeTurnCard()
+      // SDK-driven rotation: if any mid-turn user messages stacked up
+      // (the SDK is about to dequeue them into a fresh merged-batch
+      // turn), close the in-flight card with `📨 转交新卡` so the user
+      // sees the cut. The next `init` for that batch turn will open a
+      // new card whose top panel echoes those queued messages. No
+      // pending → natural ✅ close.
+      const suffix = this.pendingUserMessageCount > 0 ? '📨 转交新卡' : undefined
+      void this.closeTurnCard(suffix)
       this.status = 'idle'
     })
     p.on('exit', ({ code, signal, expected }: any) => {
@@ -880,17 +932,35 @@ export class Session {
     return this.proc?.lastContextWindow ?? 200_000
   }
 
-  private async openTurnCard(userText: string, userOpenId: string, trigger: 'user_message' | 'scheduled'): Promise<void> {
+  private async openTurnCard(userOpenId: string, trigger: 'user_message' | 'scheduled'): Promise<void> {
     const turn = ++this.turnCounter
     const card = cards.mainConversationCard({
       sessionName: this.sessionName,
       turn,
       effort: 'max',
-      userText,
       kind: trigger,
     })
     const messageId = await feishu.sendCard(this.chatId, card)
-    if (!messageId) { log(`session "${this.sessionName}": openTurnCard sendCard failed`); return }
+    if (!messageId) {
+      log(`session "${this.sessionName}": openTurnCard sendCard EXHAUSTED retries — surfacing via raw text`)
+      // sendCard already retried 3× through the SDK. If it still came back
+      // null we're either on a sustained SDK-axios outage or a Feishu
+      // business reject. Either way the user just sent us a message and
+      // it's gone into a black hole — surface that explicitly so they
+      // know to resend instead of waiting for a reply that won't come.
+      // Use raw fetch (not sendText) because if the SDK is the broken
+      // thing we'd be doomed to silence otherwise.
+      await feishu.sendTextRaw(
+        this.chatId,
+        '❌ 创建对话卡片失败 (Feishu SDK 重试 3 次后仍连不上)。你这条消息没能送到 Claude,请稍后重发。',
+      )
+      // Halt Claude — we already wrote the user text to its stdin in
+      // onUserMessage, but with no card to stream into the response would
+      // be lost. Interrupt now so the model doesn't burn tokens producing
+      // an answer that has nowhere to land.
+      this.proc?.sendInterrupt()
+      return
+    }
     let cardId: string
     try { cardId = await cardkit.convertMessageToCard(messageId) }
     catch (e) { log(`session "${this.sessionName}": id_convert failed: ${e}`); return }
@@ -899,7 +969,6 @@ export class Session {
       messageId,
       userOpenId,
       trigger,
-      userText,
       thinkingText: '',
       toolCount: 0,
       toolByUseId: new Map(),