feat(cli): OpenTUI migration live-session and input batch

packages/cli/package.json

@@ -84,6 +84,7 @@
     "qrcode-terminal": "^0.12.0",
     "react": "^19.2.4",
     "read-package-up": "^11.0.0",
+    "remend": "^1.3.1",
     "shell-quote": "^1.9.0",
     "simple-git": "^3.36.0",
     "string-width": "^7.1.0",

packages/cli/src/ui/opentui/client-tool-run.test.ts

@@ -0,0 +1,161 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Client-initiated tool scheduling tests (/restore, /setup-github parity):
+ * the one-shot CoreToolScheduler runs with isClientInitiated requests, its
+ * completion feeds tool-result/tool-end events, and the result never becomes
+ * a model follow-up (the generator ends with `done`).
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import type { Config } from '@qwen-code/qwen-code-core';
+import type { OpenTuiStreamEvent } from './event-adapter.js';
+
+interface ScheduledCall {
+  request: { callId: string; name: string; args?: unknown };
+  status: string;
+  response?: { resultDisplay?: unknown };
+}
+
+let schedulerBehavior: (
+  options: {
+    onToolCallsUpdate?: (calls: unknown[]) => void;
+    onAllToolCallsComplete?: (calls: ScheduledCall[]) => Promise<void>;
+  },
+  requests: Array<{ callId: string; name: string; args?: unknown }>,
+) => Promise<void>;
+
+vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@qwen-code/qwen-code-core')>();
+  return {
+    ...actual,
+    CoreToolScheduler: class {
+      constructor(
+        private readonly options: {
+          onToolCallsUpdate?: (calls: unknown[]) => void;
+          onAllToolCallsComplete?: (calls: ScheduledCall[]) => Promise<void>;
+        },
+      ) {}
+      async schedule(
+        request:
+          | { callId: string; name: string; args?: unknown }
+          | Array<{ callId: string; name: string; args?: unknown }>,
+      ): Promise<void> {
+        const requests = Array.isArray(request) ? request : [request];
+        await schedulerBehavior(this.options, requests);
+      }
+    },
+  };
+});
+
+import { clientToolEvents } from './client-tool-run.js';
+
+async function collect(
+  generator: AsyncGenerator<OpenTuiStreamEvent>,
+): Promise<OpenTuiStreamEvent[]> {
+  const events: OpenTuiStreamEvent[] = [];
+  for await (const event of generator) events.push(event);
+  return events;
+}
+
+describe('clientToolEvents', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const config = {} as Config;
+
+  it('schedules a client-initiated call and streams its result', async () => {
+    schedulerBehavior = async (options, requests) => {
+      await options.onAllToolCallsComplete?.(
+        requests.map((request) => ({
+          request,
+          status: 'success',
+          response: { resultDisplay: 'restored 3 files' },
+        })),
+      );
+    };
+    const events = await collect(
+      clientToolEvents(config, 'restore_files', { checkpoint: 'c1' }),
+    );
+    const types = events.map((event) => event.type);
+    expect(types).toEqual([
+      'tool-start',
+      'tool-args',
+      'tool-result',
+      'tool-end',
+      'done',
+    ]);
+    const start = events[0];
+    if (start?.type === 'tool-start') {
+      expect(start.tool).toBe('restore_files');
+    }
+    const result = events[2];
+    if (result?.type === 'tool-result') {
+      expect(result.display).toBe('restored 3 files');
+    }
+    const end = events[3];
+    if (end?.type === 'tool-end') {
+      expect(end.success).toBe(true);
+    }
+  });
+
+  it('marks failed executions as unsuccessful tool-end events', async () => {
+    schedulerBehavior = async (options, requests) => {
+      await options.onAllToolCallsComplete?.(
+        requests.map((request) => ({
+          request,
+          status: 'error',
+          response: { resultDisplay: 'boom' },
+        })),
+      );
+    };
+    const events = await collect(
+      clientToolEvents(config, 'run_shell_command', { command: 'false' }),
+    );
+    const end = events.find((event) => event.type === 'tool-end');
+    if (end?.type === 'tool-end') {
+      expect(end.success).toBe(false);
+      expect(end.summary).toBe('error');
+    } else {
+      throw new Error('expected a tool-end event');
+    }
+  });
+
+  it('surfaces awaiting_approval calls through onWaitingCall', async () => {
+    const onConfirm = vi.fn();
+    schedulerBehavior = async (options, requests) => {
+      options.onToolCallsUpdate?.([
+        {
+          status: 'awaiting_approval',
+          request: requests[0],
+          confirmationDetails: { type: 'exec', onConfirm },
+        },
+      ]);
+      await options.onAllToolCallsComplete?.(
+        requests.map((request) => ({ request, status: 'success' })),
+      );
+    };
+    const waiting: Array<{ name: string }> = [];
+    const events = await collect(
+      clientToolEvents(
+        config,
+        'run_shell_command',
+        { command: 'gh auth status' },
+        undefined,
+        {
+          onWaitingCall: (call) => {
+            waiting.push({ name: call.name });
+          },
+        },
+      ),
+    );
+    expect(waiting).toEqual([{ name: 'run_shell_command' }]);
+    expect(events.map((event) => event.type)).toContain('done');
+  });
+});

packages/cli/src/ui/opentui/client-tool-run.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Client-initiated tool scheduling for the OpenTUI backend (audit 01 G-6b).
+ *
+ * Ink commands that return `{ type: 'tool' }` (/restore, /setup-github) are
+ * scheduled through `useGeminiStream`'s `schedule_tool` branch: a
+ * `ToolCallRequestInfo` with `isClientInitiated: true` goes to the
+ * `CoreToolScheduler`, and the completed calls are NOT fed back to the model
+ * (useGeminiStream only submits functionResponses for provider-initiated
+ * calls). This module reproduces that one-shot schedule as a neutral event
+ * stream the backend folds into its transcript, using the same scheduler
+ * callbacks the live turn uses (approval requests included).
+ */
+
+import {
+  CoreToolScheduler,
+  type Config,
+  type ToolCallConfirmationDetails,
+  type ToolCallRequestInfo,
+} from '@qwen-code/qwen-code-core';
+import {
+  extractFileDiff,
+  renderResultDisplay,
+  type OpenTuiStreamEvent,
+} from './event-adapter.js';
+
+interface LooseCompletedCall {
+  request: { callId: string; name?: string; args?: unknown };
+  status: string;
+  response?: {
+    responseParts?: unknown[];
+    resultDisplay?: unknown;
+    error?: unknown;
+  };
+}
+
+export interface ClientToolRunOptions {
+  /**
+   * Scheduler-level confirmation requests (DEFAULT mode edit/exec approval).
+   * The backend renders the dialog and resolves the call through
+   * `confirmationDetails.onConfirm`; without it the call never settles.
+   */
+  onWaitingCall?: (call: {
+    callId: string;
+    name: string;
+    confirmationDetails: ToolCallConfirmationDetails;
+  }) => void;
+}
+
+/**
+ * Runs one client-initiated tool call through the real CoreToolScheduler and
+ * yields neutral events (tool-start → args/output/result → tool-end, ending
+ * with `done`). Esc aborts through the signal.
+ */
+export async function* clientToolEvents(
+  config: Config,
+  toolName: string,
+  toolArgs: Record<string, unknown>,
+  signal?: AbortSignal,
+  options?: ClientToolRunOptions,
+): AsyncGenerator<OpenTuiStreamEvent> {
+  const abort = signal ?? new AbortController().signal;
+  const callId = `${toolName}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const request: ToolCallRequestInfo = {
+    callId,
+    name: toolName,
+    args: toolArgs,
+    isClientInitiated: true,
+    prompt_id: `opentui-cmd-${Date.now()}`,
+  };
+
+  yield { type: 'tool-start', id: callId, tool: toolName, title: toolName };
+  const formattedArgs = JSON.stringify(toolArgs ?? {});
+  if (formattedArgs !== '{}') {
+    yield { type: 'tool-args', id: callId, args: formattedArgs };
+  }
+
+  let waitingSeen = false;
+  const completed = await new Promise<LooseCompletedCall[]>((resolve) => {
+    const scheduler = new CoreToolScheduler({
+      config,
+      getPreferredEditor: () => undefined,
+      onEditorClose: () => {},
+      // No outputUpdateHandler: like the live turn, the completion path
+      // emits the full result; execution-time chunks are not streamed.
+      onToolCallsUpdate: (calls) => {
+        if (!options?.onWaitingCall) return;
+        for (const call of calls) {
+          if (call.status !== 'awaiting_approval') continue;
+          if (waitingSeen) continue;
+          waitingSeen = true;
+          options.onWaitingCall({
+            callId: call.request.callId,
+            name: call.request.name,
+            confirmationDetails: call.confirmationDetails,
+          });
+        }
+      },
+      onAllToolCallsComplete: async (calls) => {
+        resolve(calls as unknown as LooseCompletedCall[]);
+      },
+    });
+    void scheduler.schedule([request], abort);
+  });
+
+  for (const call of completed) {
+    // FileDiff results ride as structured payloads so the tool card renders
+    // colored diff lines (ink DiffResultRenderer parity).
+    const diff = extractFileDiff(call.response?.resultDisplay);
+    if (diff) {
+      yield { type: 'tool-result', id: call.request.callId, display: '', diff };
+    } else {
+      const display = renderResultDisplay(call.response?.resultDisplay);
+      if (display) {
+        yield { type: 'tool-result', id: call.request.callId, display };
+      }
+    }
+    const failed = call.status === 'error' || call.status === 'cancelled';
+    yield {
+      type: 'tool-end',
+      id: call.request.callId,
+      success: !failed,
+      summary: failed
+        ? call.status === 'cancelled'
+          ? 'cancelled'
+          : 'error'
+        : 'ok',
+    };
+  }
+  // Client-initiated tools never feed the model back (ink parity: only
+  // provider-initiated calls become functionResponses).
+  yield { type: 'done' };
+}