@modesto_ma/dsh-channels 0.5.0-beta.2 → 0.5.0-beta.4

package/src/streamer.ts

@@ -35,6 +35,12 @@
  * on the card. Ownership checks and the cancellation itself belong to the
  * caller.
  *
+ * Queued turns: a turn attached behind the session's active turn renders as
+ * a queued card (notice + steer button) until it becomes the front.
+ * `steerTargetOf()` resolves a clicked queued card; `mergeQueued()` lets the
+ * caller move the queued message into the running turn and retires the
+ * queued card, handing its trigger reaction to the running turn.
+ *
  * The first visible text delta flips the panel title 推理中 → 回复中; the
  * final patch flips it to 回复结束 or 回复失败. Patching is throttled to `refreshMs` and
  * only runs when the content actually changed. Segment sends are serialized
@@ -48,8 +54,8 @@
  * @module dsh-channels/streamer
  */
 
-import type { AssistantStreamFrame, Session, SessionEvent, TurnEndReason } from './dsh-types.ts'
-import { buildCard, segmentCardContent, segmentCardOptions } from './cards.ts'
+import type { AssistantStreamFrame, Session, SessionEvent, TurnEndReason, UserMessage } from './dsh-types.ts'
+import { buildCard, buildMergedCard, segmentCardContent, segmentCardOptions } from './cards.ts'
 import type { CardState, PanelPhase, StopControl } from './cards.ts'
 import type { FeishuChannel } from './feishu-channel.ts'
 import { cacheHitPct, foldAll, foldEvent } from './stats.ts'
@@ -147,13 +153,40 @@ interface SegmentCard {
   nextRetryAt: number
 }
 
+/** A Feishu message whose Typing reaction swaps to DONE/No when a turn settles. */
+interface TriggerReaction {
+  triggerMessageId: string
+  /** Reaction id of the Typing reaction (undefined when the add failed). */
+  reactionId: string | undefined
+}
+
+/** Settled outcome of one turn, as its card shows it. */
+export type TurnOutcome = 'done' | 'stopped' | 'error'
+
+/** Per-turn options of {@link TurnStreamer.attach}. */
+export interface AttachOptions {
+  /** Called once when the turn's card reaches its final state. */
+  readonly onSettled?: (outcome: TurnOutcome) => void
+  /**
+   * The prompt this turn will run; only a turn that carries it can be
+   * steered into the running turn while queued.
+   */
+  readonly message?: UserMessage
+}
+
 interface TurnState {
+  /** `AttachOptions.onSettled`. */
+  onSettled: ((outcome: TurnOutcome) => void) | undefined
   /** Turn number once known; undefined until the first `step/start`. */
   turn: number | undefined
   /** Message whose reaction carries Typing → DONE/No. */
   triggerMessageId: string
   /** Reaction id of the Typing reaction (undefined when the add failed). */
   reactionId: string | undefined
+  /** Prompt queued for this turn; a queued card can steer it into the running turn. */
+  message: UserMessage | undefined
+  /** Triggers of queued messages merged into this turn (settle together). */
+  mergedTriggers: TriggerReaction[]
   phase: PanelPhase
   reasoning: string
   /** Request header produced during THIS turn; never inherited from history. */
@@ -216,6 +249,8 @@ interface TurnState {
   stopRequested: boolean
   /** A non-owner clicked stop; the owner-only notice renders under the button. */
   stopDenied: boolean
+  /** A non-owner clicked the queued card's steer button. */
+  queuedDenied: boolean
 }
 
 /** Card/body lengths captured at one stream attempt's `start` frame. */
@@ -327,8 +362,21 @@ export class TurnStreamer {
     this.heartbeatMs = heartbeatMs
   }
 
-  /** Bind a freshly sent reply card to a session; seeds the stats fold from the log. */
-  attach(session: Session, cardMessageId: string, triggerMessageId: string, reactionId: string | undefined): void {
+  /**
+   * Bind a freshly sent reply card to a session; seeds the stats fold from the log.
+   * @param session - the Session whose next turn renders into the card.
+   * @param cardMessageId - the main card message (patched in place).
+   * @param triggerMessageId - the message carrying the Typing → DONE/No reaction.
+   * @param reactionId - the Typing reaction to remove, when one was added.
+   * @param options - per-turn options.
+   */
+  attach(
+    session: Session,
+    cardMessageId: string,
+    triggerMessageId: string,
+    reactionId: string | undefined,
+    options: AttachOptions = {},
+  ): void {
     this.sessions.set(session.id, session)
     let fold = this.folds.get(session.id)
     if (fold === undefined) {
@@ -337,9 +385,12 @@ export class TurnStreamer {
     }
     const queue = this.bySession.get(session.id) ?? []
     queue.push({
+      onSettled: options.onSettled,
       turn: undefined,
       triggerMessageId,
       reactionId,
+      message: options.message,
+      mergedTriggers: [],
       phase: 'thinking',
       reasoning: '',
       header: undefined,
@@ -377,6 +428,7 @@ export class TurnStreamer {
       attempts: new Map(),
       stopRequested: false,
       stopDenied: false,
+      queuedDenied: false,
     })
     this.bySession.set(session.id, queue)
     const state = queue[queue.length - 1]!
@@ -424,6 +476,94 @@ export class TurnStreamer {
     return undefined
   }
 
+  /**
+   * Whether the session has an unsettled turn that a new message would queue
+   * behind.
+   * @param sessionId - the session to inspect.
+   * @returns true while a turn is streaming or queued.
+   */
+  hasLiveTurn(sessionId: string): boolean {
+    return this.front(sessionId) !== undefined
+  }
+
+  /**
+   * The queued turn whose card is `messageId`, or undefined when the card is
+   * not a queued card (active, settled, merged, detached, or unknown).
+   * @param messageId Feishu message id of a clicked card.
+   * @returns The owning session id and the queued prompt.
+   */
+  steerTargetOf(messageId: string): { sessionId: string; message: UserMessage } | undefined {
+    const queued = this.queuedState(messageId)
+    return queued === undefined ? undefined : { sessionId: queued.sessionId, message: queued.message }
+  }
+
+  /** The steerable queued turn whose main card is `messageId`. */
+  private queuedState(messageId: string): { sessionId: string; state: TurnState; message: UserMessage } | undefined {
+    for (const [sessionId, queue] of this.bySession) {
+      const front = this.front(sessionId)
+      const state = queue.find(entry => !entry.finalized && entry !== front && entry.cards[0]?.messageId === messageId)
+      if (state?.message !== undefined) return { sessionId, state, message: state.message }
+    }
+    return undefined
+  }
+
+  /**
+   * Move the queued turn of `messageId` into the session's running turn.
+   * Refused (false) while the running turn is stopping, or when `steer`
+   * reports the message was no longer pending. On success the queued card
+   * becomes the merged notice, and its trigger reaction settles with the
+   * running turn.
+   * @param messageId - the queued card the owner clicked.
+   * @param steer - moves the message in the agent inbox; returns false when
+   *   the driver already claimed it.
+   * @returns whether the message moved.
+   */
+  mergeQueued(messageId: string, steer: (sessionId: string, message: UserMessage) => boolean): boolean {
+    const target = this.queuedState(messageId)
+    if (target === undefined) return false
+    const { sessionId, state } = target
+    const front = this.front(sessionId)!
+    if (front.stopRequested || !steer(sessionId, target.message)) return false
+    const queue = this.bySession.get(sessionId)!
+    queue.splice(queue.indexOf(state), 1)
+    state.disposed = true
+    if (state.timer !== undefined) clearTimeout(state.timer)
+    if (state.heartbeatTimer !== undefined) clearTimeout(state.heartbeatTimer)
+    front.mergedTriggers.push(
+      { triggerMessageId: state.triggerMessageId, reactionId: state.reactionId },
+      ...state.mergedTriggers,
+    )
+    void this.settleMergedCard(sessionId, messageId)
+    return true
+  }
+
+  /**
+   * Patch a merged queued card into its terminal notice, with up to two
+   * retries (1s / 2s backoff) so a transient failure does not leave a stale
+   * queued card whose button no longer acts.
+   */
+  private async settleMergedCard(sessionId: string, messageId: string): Promise<void> {
+    let lastError: unknown
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        await this.channel.updateCard(messageId, buildMergedCard())
+        return
+      } catch (error) {
+        lastError = error
+        if (attempt < 2) await this.delay(1_000 * 2 ** attempt)
+      }
+    }
+    this.hooks.onError(sessionId, lastError)
+  }
+
+  /** Add the owner-only notice under a queued card's steer button (once). */
+  markQueuedDenied(messageId: string): void {
+    const target = this.queuedState(messageId)
+    if (target === undefined || target.state.queuedDenied) return
+    target.state.queuedDenied = true
+    this.markDirty(target.sessionId, target.state)
+  }
+
   /**
    * Show (or clear) the approval wait on the session's live turn: the tool
    * line reads `⏳ 等待你审批：bash` while any approval card is undecided.
@@ -958,7 +1098,8 @@ export class TurnStreamer {
       const kind = this.noteKind('tool', tool, state.toolKind)
       if (kind !== undefined) state.toolKind = kind
     }
-    const stop: StopControl | undefined = !active || state.finalized || this.front(sessionId) !== state
+    const queued = !state.finalized && this.front(sessionId) !== state
+    const stop: StopControl | undefined = !active || state.finalized || queued
       ? undefined
       : state.stopRequested ? 'stopping' : 'ready'
     return {
@@ -968,6 +1109,7 @@ export class TurnStreamer {
       status: active ? state.status : '',
       tool: active ? state.tool : '',
       ...(stop === undefined ? {} : { stop, stopDenied: state.stopDenied }),
+      ...(queued ? { queued, queuedDenied: state.queuedDenied } : {}),
       stats: this.statsFor(sessionId, state),
     }
   }
@@ -1190,7 +1332,7 @@ export class TurnStreamer {
     }
 
     // Reaction swap: Typing → DONE on success, Typing → No on failure.
-    void this.swapReaction(state, failure !== undefined)
+    for (const trigger of [state, ...state.mergedTriggers]) void this.swapReaction(trigger, failure !== undefined)
 
     // Prune the finalized state lazily (kept until the next attach so the
     // front-scan skips it, then removed).
@@ -1205,9 +1347,16 @@ export class TurnStreamer {
     })
 
     this.hooks.onTurnFinalized(sessionId, state.turn ?? 0, state.cards[0]?.messageId ?? '')
+    if (state.onSettled !== undefined) {
+      try {
+        state.onSettled(state.phase === 'error' ? 'error' : state.phase === 'stopped' ? 'stopped' : 'done')
+      } catch (error) {
+        this.hooks.onError(sessionId, error)
+      }
+    }
   }
 
-  private async swapReaction(state: TurnState, failed: boolean): Promise<void> {
+  private async swapReaction(state: TriggerReaction, failed: boolean): Promise<void> {
     try {
       if (state.reactionId !== undefined) {
         await this.channel.removeReaction(state.triggerMessageId, state.reactionId)

package/src/workspaces.ts

@@ -5,6 +5,7 @@
  * - p2p:   workspace `<baseDir>/p2p/<user_id>/`
  * - group: workspace `<baseDir>/groups/<chat_id>/<user_id>/`
  * - topic: `<workspace>/topics/<topic-token>/` (the Session's effective cwd)
+ * - log-platform analysis: workspace `<baseDir>/analyze/<app>/<errorCode>/`
  *
  * The workspace root is the Session header cwd: it keeps the Session grouped
  * under the user's project in the GUI and stays the sandbox write boundary.
@@ -232,3 +233,33 @@ export async function ensureWorkspace(
     workspaceTitleFor(chatType, chatId, senderUserId),
   )
 }
+
+/**
+ * Workspace directory of one log-platform analysis subject:
+ * `<baseDir>/analyze/<app>/<errorCode>/`. Every analysis of the same
+ * application and error code is grouped there, each in its own topic
+ * directory.
+ */
+export function analyzeWorkspacePathFor(baseDir: string, app: string, errorCode: string): string {
+  return path.join(baseDir, 'analyze', safeSegment(app, 'app'), safeSegment(errorCode, 'errorCode'))
+}
+
+/** Workspace title of one analysis subject in the DSH workspace list. */
+export function analyzeWorkspaceTitleFor(app: string, errorCode: string): string {
+  return `日志分析 · ${app} · ${errorCode}`
+}
+
+/**
+ * Ensure one analysis subject's workspace exists and is registered (idempotent
+ * like {@link ensureWorkspace}).
+ */
+export async function ensureAnalyzeWorkspace(
+  ctx: HostContext,
+  baseDir: string,
+  app: string,
+  errorCode: string,
+): Promise<Workspace> {
+  const dir = analyzeWorkspacePathFor(baseDir, app, errorCode)
+  await mkdir(dir, { recursive: true })
+  return ctx.workspaceRegistry.create(dir, analyzeWorkspaceTitleFor(app, errorCode))
+}