@adhdev/daemon-core 0.9.82-rc.169 → 0.9.82-rc.170

package/src/providers/spec/cli-adapter.ts

@@ -25,6 +25,15 @@ import type { CliAdapter, CliAdapterStatus } from '../../cli-adapter-types.js';
 import type { ChatMessage } from '../../types.js';
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
 import { LOG } from '../../logging/logger.js';
+import {
+    buildClaudeInteractiveTuiAnswerSteps,
+    buildClaudeInteractiveToolResult,
+    detectClaudeAskUserQuestionPromptFromJson,
+    detectClaudeAskUserQuestionPromptFromTuiPages,
+    type ClaudeInteractiveTuiPage,
+    type InteractivePrompt,
+    type InteractivePromptResponse,
+} from '../types/interactive-prompt.js';
 
 export class SpecCliAdapter implements CliAdapter {
     readonly cliType: string;
@@ -48,6 +57,10 @@ export class SpecCliAdapter implements CliAdapter {
     private statusCallback: (() => void) | null = null;
     private ptyDataCallback: ((data: string) => void) | null = null;
     private partialResponse = '';
+    private activeInteractivePrompt: InteractivePrompt | null = null;
+    private interactivePromptTransport: 'stream-json' | 'tui' | null = null;
+    private claudeTuiPromptCaptureInFlight = false;
+    private jsonLineTail = '';
     private exited = false;
     private spawned = false;
     private providerSessionId: string | undefined;
@@ -115,15 +128,15 @@ export class SpecCliAdapter implements CliAdapter {
     }
 
     getStatus(): CliAdapterStatus {
-        if (this.exited) return { status: 'stopped', messages: [], activeModal: null };
-        if (!this.spawned) return { status: 'starting', messages: [], activeModal: null };
+        if (this.exited) return { status: 'stopped', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt };
+        if (!this.spawned) return { status: 'starting', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt };
 
         // Refresh native history lazily — the watch_path is cheap to stat,
         // but parsing a full session.jsonl every call would be wasteful.
         this.maybeRefreshNativeHistory();
 
         const state = this.latestState;
-        if (!state) return { status: 'starting', messages: [], activeModal: null };
+        if (!state) return { status: 'starting', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt };
 
         const modal = this.latestModal;
         const lc = state.id.toLowerCase();
@@ -135,12 +148,13 @@ export class SpecCliAdapter implements CliAdapter {
                     message: modal.title ?? state.label,
                     buttons: modal.buttons.map(b => b.label),
                 },
+                activeInteractivePrompt: this.activeInteractivePrompt,
             };
         }
         if (/busy|generating|working|running|thinking/i.test(lc + ' ' + state.label)) {
-            return { status: 'generating', messages: [], activeModal: null };
+            return { status: 'generating', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt };
         }
-        return { status: 'idle', messages: [], activeModal: null };
+        return { status: 'idle', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt };
     }
 
     private maybeRefreshNativeHistory(): void {
@@ -216,6 +230,24 @@ export class SpecCliAdapter implements CliAdapter {
         this.resolveModal(target);
     }
 
+    async setInteractivePromptResponse(response: InteractivePromptResponse): Promise<void> {
+        const prompt = this.activeInteractivePrompt;
+        if (!prompt || prompt.promptId !== response.promptId) throw new Error('Interactive prompt response does not match active prompt');
+        if (this.cliType !== 'claude-cli') return;
+        if (this.interactivePromptTransport === 'tui') {
+            const steps = buildClaudeInteractiveTuiAnswerSteps(prompt, response);
+            for (const step of steps) {
+                this.driver.dispatch({ kind: 'pty_write', data: step });
+                await new Promise(resolve => setTimeout(resolve, 180));
+            }
+        } else {
+            this.driver.dispatch({ kind: 'pty_write', data: `${buildClaudeInteractiveToolResult(response)}\n` });
+        }
+        this.activeInteractivePrompt = null;
+        this.interactivePromptTransport = null;
+        this.statusCallback?.();
+    }
+
     isApprovalRecentlyResolved(): boolean { return false; }
     clearHistory(): void { /* no transcript buffer yet */ }
     updateRuntimeSettings(): void { /* no runtime settings in spec model yet */ }
@@ -274,6 +306,7 @@ export class SpecCliAdapter implements CliAdapter {
             spec_id: this.spec.id,
             current_state: this.latestState,
             current_modal: this.latestModal,
+            activeInteractivePrompt: this.activeInteractivePrompt,
             exited: this.exited,
         };
     }
@@ -307,9 +340,12 @@ export class SpecCliAdapter implements CliAdapter {
                 if (ev.state.title) {
                     LOG.debug('SpecAdapter', `[${this.cliType}] state.title=${JSON.stringify(ev.state.title)}`);
                 }
+                this.maybeCaptureClaudeTuiPrompt();
                 this.statusCallback?.();
                 return;
             case 'pty_data':
+                this.detectInteractivePromptFromPtyChunk(ev.chunk);
+                this.maybeCaptureClaudeTuiPrompt();
                 try { this.ptyDataCallback?.(ev.chunk); } catch { /* ignore */ }
                 return;
             case 'exit':
@@ -323,5 +359,72 @@ export class SpecCliAdapter implements CliAdapter {
                 return;
         }
     }
-}
 
+    private detectInteractivePromptFromPtyChunk(chunk: string): void {
+        if (this.cliType !== 'claude-cli' || !chunk) return;
+        this.jsonLineTail += chunk;
+        if (this.jsonLineTail.length > 64 * 1024) this.jsonLineTail = this.jsonLineTail.slice(-64 * 1024);
+        const lines = this.jsonLineTail.split(/\r?\n/);
+        this.jsonLineTail = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('{') || !trimmed.includes('AskUserQuestion')) continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                const prompt = detectClaudeAskUserQuestionPromptFromJson(parsed, this.cliType);
+                if (!prompt) continue;
+                this.activeInteractivePrompt = prompt;
+                this.interactivePromptTransport = 'stream-json';
+                this.statusCallback?.();
+            } catch {
+                // PTY output is not guaranteed to be machine JSON.
+            }
+        }
+    }
+
+    private maybeCaptureClaudeTuiPrompt(): void {
+        if (this.cliType !== 'claude-cli'
+            || this.activeInteractivePrompt
+            || this.claudeTuiPromptCaptureInFlight) return;
+        const screenText = this.driver.snapshot();
+        const headers = this.readClaudeTuiHeaders(screenText);
+        if (headers.length === 0 || !screenText.includes('Enter to select')) return;
+        this.claudeTuiPromptCaptureInFlight = true;
+        void this.captureClaudeTuiPrompt(screenText, headers).finally(() => {
+            this.claudeTuiPromptCaptureInFlight = false;
+        });
+    }
+
+    private readClaudeTuiHeaders(screenText: string): string[] {
+        const navLine = screenText.split(/\r?\n/).find(line => line.includes('✔ Submit') && /[☐☒]/.test(line));
+        if (!navLine) return [];
+        const headers: string[] = [];
+        for (const match of navLine.matchAll(/[☐☒]\s+(.+?)(?=\s+[☐☒]|\s+✔\s+Submit)/g)) {
+            const header = match[1]?.trim();
+            if (header) headers.push(header);
+        }
+        return headers;
+    }
+
+    private async captureClaudeTuiPrompt(firstScreen: string, headers: string[]): Promise<void> {
+        const pages: ClaudeInteractiveTuiPage[] = [{ screenText: firstScreen, header: headers[0] }];
+        for (let index = 1; index < headers.length; index += 1) {
+            this.driver.dispatch({ kind: 'pty_write', data: '\t' });
+            await new Promise(resolve => setTimeout(resolve, 120));
+            pages.push({ screenText: this.driver.snapshot(), header: headers[index] });
+        }
+        for (let index = headers.length - 1; index > 0; index -= 1) {
+            this.driver.dispatch({ kind: 'pty_write', data: '\x1b[Z' });
+            await new Promise(resolve => setTimeout(resolve, 80));
+        }
+
+        const prompt = detectClaudeAskUserQuestionPromptFromTuiPages(pages, {
+            promptId: `ask-user-${this.providerSessionId || 'claude'}-${Date.now()}`,
+            providerType: this.cliType,
+        });
+        if (!prompt) return;
+        this.activeInteractivePrompt = prompt;
+        this.interactivePromptTransport = 'tui';
+        this.statusCallback?.();
+    }
+}

package/src/providers/spec/driver.ts

@@ -180,6 +180,10 @@ export class SpecDriver {
         }
     }
 
+    snapshot(): string {
+        return this.adapter.snapshot();
+    }
+
     shutdown(): void {
         for (const t of this.delegateTimers.values()) clearTimeout(t);
         this.delegateTimers.clear();

package/src/providers/types/interactive-prompt.ts

@@ -0,0 +1,297 @@
+export interface InteractivePrompt {
+  promptId: string;
+  origin: 'cli' | 'mcp' | 'agent';
+  providerType: string;
+  createdAt: number;
+  questions: InteractiveQuestion[];
+}
+
+export interface InteractiveQuestion {
+  questionId: string;
+  question: string;
+  header?: string;
+  multiSelect: boolean;
+  options: InteractiveOption[];
+  allowFreeform?: boolean;
+}
+
+export interface InteractiveOption {
+  label: string;
+  description?: string;
+  preview?: string;
+}
+
+export interface InteractivePromptResponse {
+  promptId: string;
+  answers: Record<string, InteractiveAnswer>;
+}
+
+export interface InteractiveAnswer {
+  selectedLabels: string[];
+  freeformText?: string;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.map((item) => readString(item)).filter((item): item is string => !!item)
+    : [];
+}
+
+function normalizeOption(raw: unknown): InteractiveOption | null {
+  if (typeof raw === 'string') {
+    const label = raw.trim();
+    return label ? { label } : null;
+  }
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const label = readString(record.label);
+  if (!label) return null;
+  const description = readString(record.description);
+  const preview = readString(record.preview);
+  return {
+    label,
+    ...(description ? { description } : {}),
+    ...(preview ? { preview } : {}),
+  };
+}
+
+function normalizeQuestion(raw: unknown, index: number): InteractiveQuestion | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const question = readString(record.question);
+  if (!question) return null;
+  const questionId = readString(record.questionId) || readString(record.id) || `q${index + 1}`;
+  const options = Array.isArray(record.options)
+    ? record.options.map(normalizeOption).filter((item): item is InteractiveOption => !!item)
+    : [];
+  const header = readString(record.header);
+  return {
+    questionId,
+    question,
+    ...(header ? { header } : {}),
+    multiSelect: record.multiSelect === true,
+    options,
+    ...(record.allowFreeform === true ? { allowFreeform: true } : {}),
+  };
+}
+
+export function normalizeInteractivePrompt(raw: unknown): InteractivePrompt | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const promptId = readString(record.promptId);
+  const providerType = readString(record.providerType);
+  const origin = record.origin === 'mcp' || record.origin === 'agent' ? record.origin : 'cli';
+  const questions = Array.isArray(record.questions)
+    ? record.questions.map(normalizeQuestion).filter((item): item is InteractiveQuestion => !!item)
+    : [];
+  if (!promptId || !providerType || questions.length === 0) return null;
+  const createdAt = typeof record.createdAt === 'number' && Number.isFinite(record.createdAt)
+    ? record.createdAt
+    : Date.now();
+  return { promptId, origin, providerType, createdAt, questions };
+}
+
+export function normalizeInteractivePromptResponse(raw: unknown): InteractivePromptResponse {
+  if (!raw || typeof raw !== 'object') throw new Error('Interactive prompt response must be an object');
+  const record = raw as Record<string, unknown>;
+  const promptId = readString(record.promptId);
+  if (!promptId) throw new Error('promptId must be a non-empty string');
+  if (!record.answers || typeof record.answers !== 'object' || Array.isArray(record.answers)) {
+    throw new Error('answers must be an object');
+  }
+  const answers: Record<string, InteractiveAnswer> = {};
+  for (const [questionId, answerRaw] of Object.entries(record.answers as Record<string, unknown>)) {
+    if (!answerRaw || typeof answerRaw !== 'object' || Array.isArray(answerRaw)) continue;
+    const answer = answerRaw as Record<string, unknown>;
+    const selectedLabels = readStringArray(answer.selectedLabels);
+    const freeformText = readString(answer.freeformText);
+    answers[questionId] = {
+      selectedLabels,
+      ...(freeformText ? { freeformText } : {}),
+    };
+  }
+  return { promptId, answers };
+}
+
+export function buildClaudeInteractiveToolResult(response: InteractivePromptResponse): string {
+    return JSON.stringify({
+    type: 'user',
+    message: {
+      role: 'user',
+      content: [{
+        type: 'tool_result',
+        tool_use_id: response.promptId,
+        content: JSON.stringify({ answers: response.answers }),
+        is_error: false,
+      }],
+    },
+  });
+}
+
+export interface ClaudeInteractiveTuiPage {
+  screenText: string;
+  header?: string;
+}
+
+function claudeTuiQuestionHeaders(screenText: string): string[] {
+  const navLine = screenText.split(/\r?\n/).find(line => line.includes('✔ Submit') && /[☐☒]/.test(line));
+  if (!navLine) return [];
+  const headers: string[] = [];
+  const pattern = /[☐☒]\s+(.+?)(?=\s+[☐☒]|\s+✔\s+Submit)/g;
+  for (const match of navLine.matchAll(pattern)) {
+    const header = readString(match[1]);
+    if (header) headers.push(header);
+  }
+  return headers;
+}
+
+function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index: number): InteractiveQuestion | null {
+  const lines = page.screenText.split(/\r?\n/);
+  let navIndex = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].includes('✔ Submit') && /[☐☒]/.test(lines[i])) {
+      navIndex = i;
+      break;
+    }
+  }
+  if (navIndex < 0 || !page.screenText.includes('Enter to select')) return null;
+
+  let question = '';
+  let questionLineIndex = -1;
+  for (let i = navIndex + 1; i < lines.length; i += 1) {
+    const candidate = lines[i].trim();
+    if (!candidate || /^─+$/.test(candidate)) continue;
+    if (candidate === 'Review your answers' || candidate === 'Ready to submit your answers?') return null;
+    question = candidate;
+    questionLineIndex = i;
+    break;
+  }
+  if (!question) return null;
+
+  const options: InteractiveOption[] = [];
+  let allowFreeform = false;
+  const optionPattern = /^\s*(?:[❯›>]\s*)?(\d+)\.\s+(.+?)\s*$/;
+  for (let i = questionLineIndex + 1; i < lines.length; i += 1) {
+    const match = lines[i].match(optionPattern);
+    if (!match) continue;
+    const label = match[2].trim();
+    if (/^Type something\.?$/i.test(label)) {
+      allowFreeform = true;
+      continue;
+    }
+    if (/^Chat about this$/i.test(label)) continue;
+
+    let description: string | undefined;
+    const nextLine = lines[i + 1]?.trim();
+    if (nextLine
+      && !optionPattern.test(lines[i + 1])
+      && !/^─+$/.test(nextLine)
+      && !/^Enter to select\b/.test(nextLine)) {
+      description = nextLine;
+    }
+    options.push({ label, ...(description ? { description } : {}) });
+  }
+  if (options.length === 0) return null;
+
+  const header = readString(page.header);
+  return {
+    questionId: `q${index + 1}`,
+    question,
+    ...(header ? { header } : {}),
+    multiSelect: /Space to select|toggle selections/i.test(page.screenText),
+    options,
+    ...(allowFreeform ? { allowFreeform: true } : {}),
+  };
+}
+
+export function detectClaudeAskUserQuestionPromptFromTuiPages(
+  pages: ClaudeInteractiveTuiPage[],
+  options: { promptId: string; providerType?: string; createdAt?: number },
+): InteractivePrompt | null {
+  if (pages.length === 0) return null;
+  const headers = claudeTuiQuestionHeaders(pages[0].screenText);
+  const questions = pages.map((page, index) => parseClaudeInteractiveTuiQuestion({
+    ...page,
+    header: page.header || headers[index],
+  }, index)).filter((question): question is InteractiveQuestion => !!question);
+  if (questions.length !== pages.length) return null;
+  return {
+    promptId: options.promptId,
+    origin: 'cli',
+    providerType: options.providerType || 'claude-cli',
+    createdAt: options.createdAt || Date.now(),
+    questions,
+  };
+}
+
+export function buildClaudeInteractiveTuiAnswerSteps(
+  prompt: InteractivePrompt,
+  response: InteractivePromptResponse,
+): string[] {
+  if (response.promptId !== prompt.promptId) throw new Error('Interactive prompt response does not match active prompt');
+  const steps: string[] = [];
+  for (const question of prompt.questions) {
+    if (question.multiSelect) throw new Error('Claude TUI multi-select prompts are not supported yet');
+    const answer = response.answers[question.questionId];
+    if (!answer) throw new Error(`Missing answer for ${question.questionId}`);
+    if (answer.freeformText) throw new Error('Claude TUI freeform answers are not supported yet');
+    if (answer.selectedLabels.length !== 1) throw new Error(`Expected one selected label for ${question.questionId}`);
+    const selectedIndex = question.options.findIndex(option => option.label === answer.selectedLabels[0]);
+    if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${answer.selectedLabels[0]}`);
+    steps.push(`${'\x1b[B'.repeat(selectedIndex)}\r`);
+  }
+  steps.push('\r');
+  return steps;
+}
+
+export function interactivePromptFromClaudeAskUserQuestion(input: unknown, options: {
+  promptId: string;
+  providerType: string;
+  createdAt?: number;
+  origin?: InteractivePrompt['origin'];
+}): InteractivePrompt | null {
+  if (!input || typeof input !== 'object') return null;
+  const record = input as Record<string, unknown>;
+  const questions = Array.isArray(record.questions)
+    ? record.questions.map(normalizeQuestion).filter((item): item is InteractiveQuestion => !!item)
+    : [];
+  if (questions.length === 0) return null;
+  return {
+    promptId: options.promptId,
+    origin: options.origin || 'cli',
+    providerType: options.providerType,
+    createdAt: options.createdAt || Date.now(),
+    questions,
+  };
+}
+
+export function detectClaudeAskUserQuestionPromptFromJson(value: unknown, providerType = 'claude-cli'): InteractivePrompt | null {
+  if (!value || typeof value !== 'object') return null;
+  const record = value as Record<string, unknown>;
+  const blocks: unknown[] = [];
+  if (Array.isArray(record.content)) blocks.push(...record.content);
+  const message = record.message;
+  if (message && typeof message === 'object' && Array.isArray((message as Record<string, unknown>).content)) {
+    blocks.push(...((message as Record<string, unknown>).content as unknown[]));
+  }
+  if (record.type === 'tool_use') blocks.push(record);
+
+  for (const block of blocks) {
+    if (!block || typeof block !== 'object') continue;
+    const b = block as Record<string, unknown>;
+    const name = readString(b.name);
+    if (b.type !== 'tool_use' || name !== 'AskUserQuestion') continue;
+    const id = readString(b.id) || readString(record.id) || `ask-user-${Date.now()}`;
+    const prompt = interactivePromptFromClaudeAskUserQuestion(b.input, {
+      promptId: id,
+      providerType,
+      origin: 'cli',
+    });
+    if (prompt) return prompt;
+  }
+  return null;
+}

package/src/shared-types.ts

@@ -56,6 +56,7 @@ import type {
     GitWorkspaceUpdate,
     WorkspaceGitSubscriptionParams,
 } from './git/git-types.js';
+import type { InteractivePrompt } from './providers/types/interactive-prompt.js';
 
 export type {
     GitCommandName,
@@ -110,6 +111,7 @@ export interface ReadChatSyncResult {
     status: string;
     title?: string;
     activeModal?: { message: string; buttons: string[] } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     /**
      * Chat source provenance from ChatSourceMachine (A2). Carries the
      * selected source, transition cause, lock state, and legacy
@@ -372,6 +374,7 @@ export interface SessionEntry {
     runtimeRecoveryState?: string | null;
     resume?: ProviderResumeCapability;
     activeChat: SessionActiveChatData | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     capabilities?: SessionCapability[];
     /** Effective message input/media support for this session. Defaults fail-closed to text-only. */
     messageInput?: MessageInputSupport;

package/src/status/builders.ts

@@ -326,6 +326,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         mode: state.mode,
         resume: state.resume,
         activeChat,
+        ...(state.activeInteractivePrompt ? { activeInteractivePrompt: state.activeInteractivePrompt } : {}),
         ...(summaryMetadata && { summaryMetadata }),
         ...(includeSessionMetadata && {
             capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,