@leviyuan/lodestar 0.1.4 → 0.1.6

package/daemon.ts

@@ -108,6 +108,18 @@ async function handleMessage(data: any): Promise<void> {
     if (await session.runCommand(text)) return
   }
 
+  // Pending AskUserQuestion: route the message as a custom answer
+  // instead of opening a new turn. This is how custom-text answers
+  // work in this version — Feishu schema 2.0 doesn't support form/
+  // input elements, so the chat box itself is the input. Only applies
+  // to text-only messages (an image attachment opens a new turn as
+  // usual). Bare-word commands have already been intercepted above.
+  if (msgType === 'text' && text && session.hasPendingAsk()) {
+    const userId = message.sender?.sender_id?.open_id ?? ''
+    await session.onAskMessageAnswer(text, userId)
+    return
+  }
+
   let filePath: string | undefined
   if (msgType === 'image' && contentObj.image_key) {
     filePath = await feishu.downloadAttachment(message.message_id, contentObj.image_key, 'image')
@@ -140,9 +152,20 @@ async function handleCardAction(data: any): Promise<any> {
     case 'menu':
       await session.onUserMessage(`(menu choice ${value.choice + 1})`)
       return { toast: { type: 'success', content: 'OK' } }
-    case 'ask':
+    case 'ask': {
+      // Custom-text branch: form submit packages the input under
+      // `form_value`. Try a couple of plausible keys since the exact
+      // shape can drift between Feishu schema versions; fall back to
+      // empty (onAskCustomAnswer ignores blank).
+      if (value.custom) {
+        const fv = action?.form_value ?? action?.input ?? {}
+        const customText: string = fv?.custom_answer ?? action?.input_value ?? ''
+        await session.onAskCustomAnswer(value.tool_use_id, value.question_idx ?? 0, customText, userId)
+        return { toast: { type: customText.trim() ? 'success' : 'error', content: customText.trim() ? '已回答' : '请输入答案' } }
+      }
       await session.onAskAnswer(value.tool_use_id, value.question_idx ?? 0, value.option_idx, userId)
       return { toast: { type: 'success', content: '已回答' } }
+    }
   }
   return { toast: { type: 'info', content: 'unknown action' } }
 }

package/package.json

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

package/src/cards.ts

@@ -332,56 +332,57 @@ export interface AskQuestion {
  * the first question only and a text-only listing for the rest (an
  * acceptable limitation — these are rare in practice and we can lift
  * it once the UX is validated). */
+/** Final-state info for an AskUserQuestion panel. Mutually-exclusive
+ * branches inside: either the user picked one of the SDK-provided
+ * options (`optionIdx`), or they typed a free-form answer
+ * (`customText`). When both are absent the panel is still pending. */
+export interface AskAnswered {
+  optionIdx?: number
+  customText?: string
+  user?: string
+}
+
 export function askUserQuestionElement(
   i: number,
   toolUseId: string,
   questions: AskQuestion[],
   status: '🤔' | '✅' | '❌' = '🤔',
-  /** When set, only this option is rendered as "picked" — every other
-   * option turns into plain text (no click target). Used after the
-   * user has answered so the panel freezes in a sensible terminal
-   * state instead of inviting another click. */
-  pickedOptionIdx?: number,
-  resolvedNote?: string,
+  answered?: AskAnswered,
 ): object {
   const primary = questions[0]
+  const isAnswered = !!answered && (answered.optionIdx !== undefined || !!answered.customText)
   const headerTag = primary?.header ? ` · ${primary.header}` : ''
-  const headerText = `${status} 🤔 AskUserQuestion${headerTag}`
+  let headerText: string
+  if (isAnswered) {
+    // Surface the picked answer in the header so a collapsed panel
+    // still tells the reader what was chosen.
+    const picked = answered!.customText
+      ?? (answered!.optionIdx !== undefined ? primary?.options[answered!.optionIdx]?.label : undefined)
+      ?? '?'
+    headerText = `${status} 已回答${headerTag}：${picked}`
+  } else {
+    headerText = `${status} 🤔 AskUserQuestion${headerTag}`
+  }
   const bodyElements: any[] = []
   if (primary) {
     bodyElements.push({ tag: 'markdown', content: `**${primary.question}**` })
-    // One row per option, each a full-width interactive_container so
-    // the entire row (label + description) is the click target. Looks
-    // cleaner than a row of squat buttons and matches the way IM
-    // quick-replies usually present themselves. After the user picks,
-    // we still render the same row layout (no JSON dump) but strip
-    // the callbacks — selected option marked ✅, others dimmed.
+    // One row per option. While pending, each row is a full-width
+    // interactive_container so the entire row is the click target.
+    // Once answered, rows degrade to plain markdown (Feishu has no
+    // generic non-interactive container — `div` doesn't exist, it
+    // rejects the PUT with code 300121).
     for (let optIdx = 0; optIdx < primary.options.length; optIdx++) {
       const opt = primary.options[optIdx]
-      const isPicked = pickedOptionIdx === optIdx
-      const isAnswered = pickedOptionIdx !== undefined
-      const labelLine = isPicked
-        ? `**✅ ${opt.label}**`
-        : isAnswered
-          ? `~~${opt.label}~~`
-          : `**${opt.label}**`
-      const descLine = opt.description ? `\n${opt.description}` : ''
-      const rowContent = { tag: 'markdown', content: `${labelLine}${descLine}` }
-      if (isAnswered) {
-        // Frozen — no behaviors, plain container so it stops looking
-        // clickable.
-        bodyElements.push({
-          tag: 'div',
-          elements: [rowContent],
-        })
-      } else {
+      const isPicked = answered?.optionIdx === optIdx
+      const desc = opt.description ? `  ·  ${opt.description}` : ''
+      if (!isAnswered) {
         bodyElements.push({
           tag: 'interactive_container',
           background_style: 'default',
           has_border: true,
           corner_radius: '6px',
           padding: '8px 12px',
-          margin: '4px 0',
+          margin: '4px 0px 4px 0px',
           behaviors: [{
             type: 'callback',
             value: {
@@ -391,13 +392,40 @@ export function askUserQuestionElement(
               option_idx: optIdx,
             },
           }],
-          elements: [rowContent],
+          elements: [{ tag: 'markdown', content: `**${opt.label}**${desc}` }],
+        })
+      } else if (isPicked) {
+        bodyElements.push({
+          tag: 'markdown',
+          content: `✅ **${opt.label}**${desc}`,
+        })
+      } else {
+        bodyElements.push({
+          tag: 'markdown',
+          content: `~~◯ ${opt.label}${desc}~~`,
         })
       }
     }
+    // Custom-answer hint (pending state only). Feishu schema 2.0
+    // doesn't actually have `form` / `input` elements — `tag: form`
+    // gets rejected with code 300315. Instead we route custom
+    // answers through a plain chat message: daemon.handleMessage
+    // detects a pending ask and forwards the next inbound text as
+    // the answer, no new turn opened. This is also more Feishu-
+    // native: the chat input is right there, no extra widget.
+    if (!isAnswered) {
+      bodyElements.push({
+        tag: 'markdown',
+        content: '_💬 也可以直接在群里回复你的答案（裸词命令 `hi`/`kill`/`restart`/`clear` 仍然优先）_',
+      })
+    } else if (answered?.customText) {
+      bodyElements.push({
+        tag: 'markdown',
+        content: `✏️ **自定义回答**：${answered.customText}`,
+      })
+    }
   }
-  // Secondary questions get text-only treatment (TODO: multi-question
-  // panels when actually requested by a real prompt).
+  // Secondary questions (rare): text-only listing. TODO when needed.
   for (let qi = 1; qi < questions.length; qi++) {
     const q = questions[qi]
     const opts = q.options.map(o => `  - ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n')
@@ -406,12 +434,19 @@ export function askUserQuestionElement(
       content: `\n---\n**(其他问题 #${qi + 1}, 暂未支持回答)** ${q.question}\n${opts}`,
     })
   }
-  if (resolvedNote) bodyElements.push({ tag: 'markdown', content: resolvedNote })
+  if (isAnswered && answered?.user) {
+    bodyElements.push({
+      tag: 'markdown',
+      content: `\n*— 由 ${answered.user} 回答*`,
+    })
+  }
   return {
     tag: 'collapsible_panel',
     element_id: ELEMENTS.tool(i),
     header: { title: { tag: 'plain_text', content: headerText } },
-    expanded: true,
+    // Collapse once answered: header carries the picked answer, body
+    // is just history at that point.
+    expanded: !isAnswered,
     elements: bodyElements,
   }
 }

package/src/session.ts

@@ -79,8 +79,9 @@ export class Session {
   /** Open AskUserQuestion tool calls — keyed by tool_use_id. The SDK
    * routes AskUserQuestion through the can_use_tool flow even under
    * bypass; we have to thread the permission `requestId` through here
-   * so onAskAnswer can answer it with `updatedInput.answers` populated.
-   * `deferredAnswer` covers the race where the user clicks a button
+   * so the answer (option click OR custom text submit) can resolve
+   * the permission with `updatedInput.answers` populated.
+   * `deferredAnswer` covers the race where the user clicks/submits
    * BEFORE can_use_tool arrives (addTool fires on the assistant
    * message; can_use_tool is a separate control_request that lands
    * slightly later). */
@@ -88,7 +89,12 @@ export class Session {
     questions: cards.AskQuestion[]
     i: number
     requestId?: string
-    deferredAnswer?: { questionIdx: number; optionIdx: number; user: string }
+    deferredAnswer?: {
+      questionIdx: number
+      optionIdx?: number
+      customText?: string
+      user: string
+    }
   }>()
   private turnCounter = 0
   // Last seen sessionId — preserved across `kill`/`stop` so a later
@@ -326,43 +332,96 @@ export class Session {
     }
   }
 
-  /** Click handler for an AskUserQuestion option button. The actual
-   * "send answer to Claude" plumbing lives in `resolveAsk` — this
-   * wrapper just chooses between answering immediately (the common
-   * case: can_use_tool has already arrived and parked a requestId on
-   * the pendingAsk record) versus deferring (the rare race where the
-   * user clicks before can_use_tool lands). */
+  /** True iff there's at least one open AskUserQuestion awaiting an
+   * answer in this session. `daemon.handleMessage` uses this to
+   * decide whether an inbound chat message should be a custom answer
+   * (routed to onAskMessageAnswer) instead of opening a new turn. */
+  hasPendingAsk(): boolean {
+    return this.pendingAsks.size > 0
+  }
+
+  /** Funnel an arbitrary chat message into the oldest pending ask as
+   * a `customText` answer. Falls back to a normal turn if for some
+   * reason there's nothing pending (defensive — handleMessage's gate
+   * should prevent that). Picks the first entry by Map insertion
+   * order, which is the earliest unanswered ask. */
+  async onAskMessageAnswer(text: string, user: string): Promise<void> {
+    const firstEntry = this.pendingAsks.entries().next()
+    if (firstEntry.done) {
+      log(`session "${this.sessionName}": onAskMessageAnswer with no pending — falling back to onUserMessage`)
+      await this.onUserMessage(text)
+      return
+    }
+    const [toolUseId, _pending] = firstEntry.value
+    await this.onAskCustomAnswer(toolUseId, 0, text, user)
+  }
+
+  /** Click handler for an AskUserQuestion option button. Dispatches
+   * to `resolveAsk` if can_use_tool has already arrived, otherwise
+   * parks the click on the pendingAsk record for renderPermission
+   * to drain. */
   async onAskAnswer(toolUseId: string, questionIdx: number, optionIdx: number, user: string): Promise<void> {
     const pending = this.pendingAsks.get(toolUseId)
     if (!pending) { log(`session "${this.sessionName}": stray ask answer for ${toolUseId}`); return }
     if (pending.requestId) {
-      this.resolveAsk(toolUseId, pending.requestId, questionIdx, optionIdx, user)
+      this.resolveAsk(toolUseId, pending.requestId, { questionIdx, optionIdx, user })
     } else {
-      // can_use_tool hasn't landed yet — park the click. renderPermission
-      // will drain it the moment the request arrives.
       pending.deferredAnswer = { questionIdx, optionIdx, user }
       log(`session "${this.sessionName}": ask answer deferred for ${toolUseId} (no requestId yet)`)
     }
   }
 
+  /** Form-submit handler for the custom-answer input on an
+   * AskUserQuestion panel. Same dispatch pattern as `onAskAnswer`,
+   * just routes a free-form string into `resolveAsk` instead of an
+   * option index. Empty/whitespace input is ignored (no answer
+   * sent, panel stays pending). */
+  async onAskCustomAnswer(toolUseId: string, questionIdx: number, customText: string, user: string): Promise<void> {
+    const pending = this.pendingAsks.get(toolUseId)
+    if (!pending) { log(`session "${this.sessionName}": stray ask custom for ${toolUseId}`); return }
+    const trimmed = (customText ?? '').trim()
+    if (!trimmed) { log(`session "${this.sessionName}": empty custom answer, ignoring`); return }
+    if (pending.requestId) {
+      this.resolveAsk(toolUseId, pending.requestId, { questionIdx, customText: trimmed, user })
+    } else {
+      pending.deferredAnswer = { questionIdx, customText: trimmed, user }
+      log(`session "${this.sessionName}": ask custom deferred for ${toolUseId} (no requestId yet)`)
+    }
+  }
+
   /** Settle an AskUserQuestion: emit the permission allow with the
-   * picked option folded into `updatedInput.answers` (this is the
-   * shape the SDK reads to synthesise the tool_result string), repaint
-   * the panel ✅, drop bookkeeping. Single source of truth — both the
-   * normal click path and the deferred-answer drain go through here. */
+   * picked option OR custom text folded into `updatedInput.answers`
+   * (this is the shape the SDK reads to synthesise the tool_result
+   * string), repaint the panel ✅, drop bookkeeping. Single source
+   * of truth — option-click, custom-submit, and the deferred drain
+   * all go through here. */
   private resolveAsk(
     toolUseId: string,
     requestId: string,
-    questionIdx: number,
-    optionIdx: number,
-    user: string,
+    answer: { questionIdx: number; optionIdx?: number; customText?: string; user: string },
   ): void {
     const pending = this.pendingAsks.get(toolUseId)
     if (!pending) return
-    const q = pending.questions[questionIdx]
-    const opt = q?.options?.[optionIdx]
-    if (!q || !opt) {
-      log(`session "${this.sessionName}": ask answer out of range q=${questionIdx} o=${optionIdx}`)
+    const q = pending.questions[answer.questionIdx]
+    if (!q) {
+      log(`session "${this.sessionName}": ask answer out of range q=${answer.questionIdx}`)
+      return
+    }
+    // Determine the literal string that will become the SDK's
+    // `answers` value for this question — custom wins if both are
+    // somehow set (shouldn't happen, but defensive).
+    let answerValue: string
+    if (answer.customText) {
+      answerValue = answer.customText
+    } else if (answer.optionIdx !== undefined) {
+      const opt = q.options?.[answer.optionIdx]
+      if (!opt) {
+        log(`session "${this.sessionName}": ask option out of range o=${answer.optionIdx}`)
+        return
+      }
+      answerValue = opt.label
+    } else {
+      log(`session "${this.sessionName}": resolveAsk called with neither optionIdx nor customText`)
       return
     }
     const turn = this.currentTurn
@@ -370,9 +429,8 @@ export class Session {
     const originalInput = meta?.input ?? {}
     // SDK keys the answer record by the question's text — confirmed
     // by the v0.1.2 jsonl trace (empty record formatted to "User has
-    // answered your questions: ."). Populate the key matching this
-    // question with the chosen option's label.
-    const answers: Record<string, string> = { [q.question]: opt.label }
+    // answered your questions: .").
+    const answers: Record<string, string> = { [q.question]: answerValue }
     this.proc?.sendPermissionResponse(requestId, 'allow', {
       updatedInput: { ...originalInput, answers },
     })
@@ -382,8 +440,11 @@ export class Session {
     if (turn && meta) {
       meta.output = JSON.stringify({ answers })
       meta.isError = false
-      const resolvedNote = `\n\n*已由 ${user || '匿名'} 回答*`
-      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', optionIdx, resolvedNote)
+      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', {
+        optionIdx: answer.optionIdx,
+        customText: answer.customText,
+        user: answer.user || '匿名',
+      })
       void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
     }
 
@@ -747,9 +808,14 @@ export class Session {
       ask.requestId = req.request_id
       this.pendingPermissions.set(req.request_id, { toolUseId })
       if (ask.deferredAnswer) {
-        const { questionIdx, optionIdx, user } = ask.deferredAnswer
+        const d = ask.deferredAnswer
         ask.deferredAnswer = undefined
-        this.resolveAsk(toolUseId, req.request_id, questionIdx, optionIdx, user)
+        this.resolveAsk(toolUseId, req.request_id, {
+          questionIdx: d.questionIdx,
+          optionIdx: d.optionIdx,
+          customText: d.customText,
+          user: d.user,
+        })
       }
       return
     }