@jacexh/claude-web-console 0.11.1 → 0.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacexh/claude-web-console",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "Web-based console for Claude Code — manage sessions, switch models, preview artifacts",
   "type": "module",
   "bin": {

package/server/src/__tests__/turn-started-broadcast.test.ts

@@ -11,7 +11,7 @@ import { describe, it, expect } from 'vitest'
  * We extract the logic into a pure function so it can be tested
  * without mocking the full SessionManager.
  */
-import { shouldBroadcastTurnStarted } from '../turn-lifecycle'
+import { shouldBroadcastTurnStarted, shouldResetToIdleOnStreamEnd, isTurnMessage } from '../turn-lifecycle'
 
 describe('shouldBroadcastTurnStarted', () => {
   it('returns true for the first message of a turn', () => {
@@ -51,3 +51,51 @@ describe('shouldBroadcastTurnStarted', () => {
     expect(shouldBroadcastTurnStarted(state)).toBe(false)
   })
 })
+
+describe('shouldResetToIdleOnStreamEnd', () => {
+  it('returns true when current status is running (stream ended without result)', () => {
+    expect(shouldResetToIdleOnStreamEnd('running')).toBe(true)
+  })
+
+  it('returns false when current status is idle (result already set idle)', () => {
+    expect(shouldResetToIdleOnStreamEnd('idle')).toBe(false)
+  })
+
+  it('returns false when current status is stopped (session closed)', () => {
+    expect(shouldResetToIdleOnStreamEnd('stopped')).toBe(false)
+  })
+})
+
+describe('isTurnMessage', () => {
+  it('returns false for system/init (session initialization, not a turn)', () => {
+    expect(isTurnMessage({ type: 'system', subtype: 'init' })).toBe(false)
+  })
+
+  it('returns true for assistant messages (agent generating)', () => {
+    expect(isTurnMessage({ type: 'assistant' })).toBe(true)
+  })
+
+  it('returns true for user messages (tool results)', () => {
+    expect(isTurnMessage({ type: 'user' })).toBe(true)
+  })
+
+  it('returns true for result messages (turn complete)', () => {
+    expect(isTurnMessage({ type: 'result' })).toBe(true)
+  })
+
+  it('returns true for system/task_started', () => {
+    expect(isTurnMessage({ type: 'system', subtype: 'task_started' })).toBe(true)
+  })
+
+  it('returns true for system/task_progress', () => {
+    expect(isTurnMessage({ type: 'system', subtype: 'task_progress' })).toBe(true)
+  })
+
+  it('returns true for system/task_notification', () => {
+    expect(isTurnMessage({ type: 'system', subtype: 'task_notification' })).toBe(true)
+  })
+
+  it('returns false for system/init even with extra fields', () => {
+    expect(isTurnMessage({ type: 'system', subtype: 'init', model: 'claude-sonnet' })).toBe(false)
+  })
+})

package/server/src/session-manager.ts

@@ -17,7 +17,7 @@ import { join } from 'node:path'
 import { homedir } from 'node:os'
 import type { FastifyBaseLogger } from 'fastify'
 import type { SessionInfo, EffortLevel } from './types.js'
-import { shouldBroadcastTurnStarted, type TurnState } from './turn-lifecycle.js'
+import { shouldBroadcastTurnStarted, shouldResetToIdleOnStreamEnd, isTurnMessage, type TurnState } from './turn-lifecycle.js'
 import { SessionStatusTracker } from './session-status.js'
 
 type PermissionResolver = {
@@ -537,8 +537,8 @@ export class SessionManager {
             } as unknown as SDKMessage))
           }
 
-          // Set session status to running on first message of each turn
-          if (shouldBroadcastTurnStarted(turnState)) {
+          // Set session status to running on first turn message (skip system/init)
+          if (isTurnMessage(msgAny) && shouldBroadcastTurnStarted(turnState)) {
             this.sessionStatus.set(sessionId, 'running')
           }
           this.broadcast(sessionId, (l) => l.onMessage(sessionId, msg))
@@ -549,7 +549,7 @@ export class SessionManager {
         try { sessionId = session.sessionId } catch { break }
         if (this.closedSessionIds.has(sessionId)) break
         // Reset to idle if stream ended without a result (e.g. init-only stream)
-        if (this.sessionStatus.get(sessionId) === 'running') {
+        if (shouldResetToIdleOnStreamEnd(this.sessionStatus.get(sessionId))) {
           this.sessionStatus.set(sessionId, 'idle')
         }
         // Wait briefly before re-entering stream() for next turn

package/server/src/turn-lifecycle.ts

@@ -0,0 +1,21 @@
+export interface TurnState {
+  turnStarted: boolean
+}
+
+/** Returns true (and flips the flag) on the first call per turn. */
+export function shouldBroadcastTurnStarted(state: TurnState): boolean {
+  if (state.turnStarted) return false
+  state.turnStarted = true
+  return true
+}
+
+/** Returns true if status should be reset to idle when a stream ends without a result. */
+export function shouldResetToIdleOnStreamEnd(currentStatus: string): boolean {
+  return currentStatus === 'running'
+}
+
+/** Returns true if this SDK message is part of an active turn (not session init). */
+export function isTurnMessage(msg: Record<string, unknown>): boolean {
+  if (msg.type === 'system' && msg.subtype === 'init') return false
+  return true
+}