151 lines
5.2 KiB
TypeScript
151 lines
5.2 KiB
TypeScript
export type SessionState = 'idle' | 'running' | 'requires_action'
|
|
|
|
/**
|
|
* Context carried with requires_action transitions so downstream
|
|
* surfaces (CCR sidebar, push notifications) can show what the
|
|
* session is blocked on, not just that it's blocked.
|
|
*
|
|
* Two delivery paths:
|
|
* - tool_name + action_description → RequiresActionDetails proto
|
|
* (webhook payload, typed, logged in Datadog)
|
|
* - full object → external_metadata.pending_action (queryable JSON
|
|
* on the Session, lets the frontend iterate on shape without
|
|
* proto round-trips)
|
|
*/
|
|
export type RequiresActionDetails = {
|
|
tool_name: string
|
|
/** Human-readable summary, e.g. "Editing src/foo.ts", "Running npm test" */
|
|
action_description: string
|
|
tool_use_id: string
|
|
request_id: string
|
|
/** Raw tool input — the frontend reads from external_metadata.pending_action.input
|
|
* to parse question options / plan content without scanning the event stream. */
|
|
input?: Record<string, unknown>
|
|
}
|
|
|
|
import { isEnvTruthy } from './envUtils.js'
|
|
import type { PermissionMode } from './permissions/PermissionMode.js'
|
|
import { enqueueSdkEvent } from './sdkEventQueue.js'
|
|
|
|
// CCR external_metadata keys — push in onChangeAppState, restore in
|
|
// externalMetadataToAppState.
|
|
export type SessionExternalMetadata = {
|
|
permission_mode?: string | null
|
|
is_ultraplan_mode?: boolean | null
|
|
model?: string | null
|
|
pending_action?: RequiresActionDetails | null
|
|
// Opaque — typed at the emit site. Importing PostTurnSummaryOutput here
|
|
// would leak the import path string into sdk.d.ts via agentSdkBridge's
|
|
// re-export of SessionState.
|
|
post_turn_summary?: unknown
|
|
// Mid-turn progress line from the forked-agent summarizer — fires every
|
|
// ~5 steps / 2min so long-running turns still surface "what's happening
|
|
// right now" before post_turn_summary arrives.
|
|
task_summary?: string | null
|
|
}
|
|
|
|
type SessionStateChangedListener = (
|
|
state: SessionState,
|
|
details?: RequiresActionDetails,
|
|
) => void
|
|
type SessionMetadataChangedListener = (
|
|
metadata: SessionExternalMetadata,
|
|
) => void
|
|
type PermissionModeChangedListener = (mode: PermissionMode) => void
|
|
|
|
let stateListener: SessionStateChangedListener | null = null
|
|
let metadataListener: SessionMetadataChangedListener | null = null
|
|
let permissionModeListener: PermissionModeChangedListener | null = null
|
|
|
|
export function setSessionStateChangedListener(
|
|
cb: SessionStateChangedListener | null,
|
|
): void {
|
|
stateListener = cb
|
|
}
|
|
|
|
export function setSessionMetadataChangedListener(
|
|
cb: SessionMetadataChangedListener | null,
|
|
): void {
|
|
metadataListener = cb
|
|
}
|
|
|
|
/**
|
|
* Register a listener for permission-mode changes from onChangeAppState.
|
|
* Wired by print.ts to emit an SDK system:status message so CCR/IDE clients
|
|
* see mode transitions in real time — regardless of which code path mutated
|
|
* toolPermissionContext.mode (Shift+Tab, ExitPlanMode dialog, slash command,
|
|
* bridge set_permission_mode, etc.).
|
|
*/
|
|
export function setPermissionModeChangedListener(
|
|
cb: PermissionModeChangedListener | null,
|
|
): void {
|
|
permissionModeListener = cb
|
|
}
|
|
|
|
let hasPendingAction = false
|
|
let currentState: SessionState = 'idle'
|
|
|
|
export function getSessionState(): SessionState {
|
|
return currentState
|
|
}
|
|
|
|
export function notifySessionStateChanged(
|
|
state: SessionState,
|
|
details?: RequiresActionDetails,
|
|
): void {
|
|
currentState = state
|
|
stateListener?.(state, details)
|
|
|
|
// Mirror details into external_metadata so GetSession carries the
|
|
// pending-action context without proto changes. Cleared via RFC 7396
|
|
// null on the next non-blocked transition.
|
|
if (state === 'requires_action' && details) {
|
|
hasPendingAction = true
|
|
metadataListener?.({
|
|
pending_action: details,
|
|
})
|
|
} else if (hasPendingAction) {
|
|
hasPendingAction = false
|
|
metadataListener?.({ pending_action: null })
|
|
}
|
|
|
|
// task_summary is written mid-turn by the forked summarizer; clear it at
|
|
// idle so the next turn doesn't briefly show the previous turn's progress.
|
|
if (state === 'idle') {
|
|
metadataListener?.({ task_summary: null })
|
|
}
|
|
|
|
// Mirror to the SDK event stream so non-CCR consumers (scmuxd, VS Code)
|
|
// see the same authoritative idle/running signal the CCR bridge does.
|
|
// 'idle' fires after heldBackResult flushes — lets scmuxd flip IDLE and
|
|
// show the bg-task dot instead of a stuck generating spinner.
|
|
//
|
|
// Opt-in until CCR web + mobile clients learn to ignore this subtype in
|
|
// their isWorking() last-message heuristics — the trailing idle event
|
|
// currently pins them at "Running...".
|
|
// https://anthropic.slack.com/archives/C093BJBD1CP/p1774152406752229
|
|
if (isEnvTruthy(process.env.CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS)) {
|
|
enqueueSdkEvent({
|
|
type: 'system',
|
|
subtype: 'session_state_changed',
|
|
state,
|
|
})
|
|
}
|
|
}
|
|
|
|
export function notifySessionMetadataChanged(
|
|
metadata: SessionExternalMetadata,
|
|
): void {
|
|
metadataListener?.(metadata)
|
|
}
|
|
|
|
/**
|
|
* Fired by onChangeAppState when toolPermissionContext.mode changes.
|
|
* Downstream listeners (CCR external_metadata PUT, SDK status stream) are
|
|
* both wired through this single choke point so no mode-mutation path can
|
|
* silently bypass them.
|
|
*/
|
|
export function notifyPermissionModeChanged(mode: PermissionMode): void {
|
|
permissionModeListener?.(mode)
|
|
}
|