diff --git a/.env.example b/.env.example index 0e96e71..22f1388 100644 --- a/.env.example +++ b/.env.example @@ -1,2 +1,2 @@ -CLAUDE_UI_PASSWORD=your-password-here +CLAWTAP_PASSWORD=your-password-here PORT=3456 diff --git a/README.md b/README.md index b0d137f..89a7385 100644 --- a/README.md +++ b/README.md @@ -35,7 +35,7 @@ Real-time sync. Cross-AI review. Push notifications. ```bash npm install -g @kuannnn/clawtap -export CLAUDE_UI_PASSWORD=your-password +export CLAWTAP_PASSWORD=your-password clawtap ``` @@ -192,7 +192,7 @@ The app icon badge shows how many sessions have unread notifications. Entering a | Variable | Default | Description | |----------|---------|-------------| -| `CLAUDE_UI_PASSWORD` | *(required)* | Login password | +| `CLAWTAP_PASSWORD` | *(required)* | Login password | | `PORT` | `3456` | Server port | HTTPS is enabled automatically when `~/.clawtap/cert.pem` and `~/.clawtap/key.pem` exist. Otherwise the server runs on HTTP. Tailscale Serve is the easiest path to HTTPS. diff --git a/bin/clawtap b/bin/clawtap index 1764a13..a47d210 100755 --- a/bin/clawtap +++ b/bin/clawtap @@ -217,20 +217,20 @@ ensure_server() { fi # Password is required - if [ -z "$CLAUDE_UI_PASSWORD" ]; then + if [ -z "$CLAWTAP_PASSWORD" ]; then echo "ClawTap server not running." echo "" echo "Set a password and try again:" - echo " export CLAUDE_UI_PASSWORD=your-password" + echo " export CLAWTAP_PASSWORD=your-password" echo " clawtap" echo "" echo "Or start the server separately:" - echo " CLAUDE_UI_PASSWORD=your-password npm start" + echo " CLAWTAP_PASSWORD=your-password npm start" exit 1 fi echo "Starting ClawTap server on port $PORT..." - CLAUDE_UI_PASSWORD="$CLAUDE_UI_PASSWORD" PORT="$PORT" \ + CLAWTAP_PASSWORD="$CLAWTAP_PASSWORD" PORT="$PORT" \ nohup npx tsx "$SERVER_DIR/server/index.ts" >"$HOME/.clawtap/server.log" 2>&1 & SERVER_PID=$! @@ -252,7 +252,7 @@ ensure_server # Authenticate with the ClawTap server API get_auth_token() { local BODY - BODY=$(printf '%s' "$CLAUDE_UI_PASSWORD" | python3 -c 'import sys,json; print(json.dumps({"password": sys.stdin.read()}))' 2>/dev/null) + BODY=$(printf '%s' "$CLAWTAP_PASSWORD" | python3 -c 'import sys,json; print(json.dumps({"password": sys.stdin.read()}))' 2>/dev/null) curl -sk -X POST "${PROTOCOL}://localhost:${PORT}/api/auth/login" \ -H "Content-Type: application/json" \ -d "$BODY" 2>/dev/null | \ diff --git a/docs/superpowers/plans/2026-03-26-adapter-identity-fix.md b/docs/superpowers/plans/2026-03-26-adapter-identity-fix.md new file mode 100644 index 0000000..e653a6d --- /dev/null +++ b/docs/superpowers/plans/2026-03-26-adapter-identity-fix.md @@ -0,0 +1,403 @@ +# Adapter Identity Fix Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Fix sessions opening with wrong adapter by deferring initialization until adapter is confirmed (from prop/URL or server SESSION_CREATED). + +**Architecture:** Stop guessing adapter from localStorage. If adapter is known (session list click, URL with adapter param), initialize immediately. If unknown (bare URL, push notification), show loading until server tells us via SESSION_CREATED. Server is single source of truth. + +**Tech Stack:** React, TypeScript, WebSocket + +**Spec:** `docs/superpowers/specs/2026-03-26-adapter-identity-fix-design.md` + +--- + +## File Map + +| File | Action | Change | +|---|---|---| +| `src/hooks/useChat.ts` | Modify | Defer init when adapter unknown, handle SESSION_CREATED fully | +| `src/App.tsx` | Modify | URL includes adapter, URL parser reads adapter | +| `src/components/ChatView.tsx` | Modify | Loading state when adapter unknown | +| `server/session-manager.ts` | Modify | SESSION_CREATED includes cwd, handleQuery verifies adapter | +| `src/components/SessionsView.tsx` | Modify | Active sessions badge | +| `src/sw.ts` | Modify | Notification URL includes adapter | + +--- + +### Task 1: useChat — defer initialization when adapter unknown + +**Files:** +- Modify: `src/hooks/useChat.ts:114-127` (init), `src/hooks/useChat.ts:169-174` (SESSION_CREATED handler) + +- [ ] **Step 1: Change selectedAdapter to nullable, defer prefs init** + +Replace lines 114-127: + +```typescript +// Current: +const resolvedAdapter = initialAdapter || localStorage.getItem(STORAGE.ADAPTER) || 'claude'; +const initialPrefs = loadAdapterPrefs(resolvedAdapter); +const [model, setModel] = useState(initialPrefs.model || ''); +const [permissionMode, setPermissionMode] = useState(initialPrefs.permissionMode || 'default'); +const [effort, setEffort] = useState(initialPrefs.effort || 'high'); +// ... +const [selectedAdapter, setSelectedAdapter] = useState(resolvedAdapter); +``` + +With: + +```typescript +// If adapter is known (from prop or URL), use it immediately. +// If unknown (bare URL, push notification), null → wait for server SESSION_CREATED. +const knownAdapter = initialAdapter || null; +const initialPrefs = knownAdapter ? loadAdapterPrefs(knownAdapter) : null; + +const [model, setModel] = useState(initialPrefs?.model || ''); +const [permissionMode, setPermissionMode] = useState(initialPrefs?.permissionMode || 'default'); +const [effort, setEffort] = useState(initialPrefs?.effort || ''); +// ... +const [selectedAdapter, setSelectedAdapter] = useState(knownAdapter); +``` + +**Important:** `selectedAdapter` is now `string | null`. When null, it means "waiting for server to tell us." + +- [ ] **Step 2: Update SESSION_CREATED handler to fully initialize** + +Replace lines 169-174: + +```typescript +case WS.SESSION_CREATED: + setSessionId(msg.sessionId); + if (msg.adapter) { + setSelectedAdapter(msg.adapter); + // Load correct prefs now that we know the adapter + const prefs = loadAdapterPrefs(msg.adapter); + if (!knownAdapter) { + // First time learning adapter — initialize prefs from scratch + setModel(prefs.model || ''); + setPermissionMode(msg.permissionMode || prefs.permissionMode || 'default'); + setEffort(prefs.effort || ''); + } else { + // Adapter was already known — just update permissionMode if server provides it + if (msg.permissionMode) setPermissionMode(msg.permissionMode); + } + } else { + if (msg.permissionMode) setPermissionMode(msg.permissionMode); + } + break; +``` + +- [ ] **Step 3: Fix all null-safety issues in useChat.ts** + +`selectedAdapter` is now `string | null`. Every usage must be guarded: + +| Line | Code | Fix | +|---|---|---| +| 149 | `useRef(selectedAdapter)` | → `useRef(selectedAdapter)` | +| 363 | `patchAdapterPrefs(selectedAdapterRef.current, ...)` | → `if (selectedAdapterRef.current) patchAdapterPrefs(...)` | +| 408 | `client.setActiveSession(initialSessionId, selectedAdapter)` | → `client.setActiveSession(initialSessionId, selectedAdapter ?? undefined)` | +| 430 | `wsRef.current.setActiveSession(sessionId, selectedAdapter)` | → `wsRef.current.setActiveSession(sessionId, selectedAdapter ?? undefined)` | +| 436 | `api.adapterConfig(selectedAdapter)` | → `if (selectedAdapter) api.adapterConfig(selectedAdapter)...` | +| 455 | `adapter: selectedAdapter` in actualSend | → add `if (!selectedAdapter) return` at top of actualSend | +| 532 | `patchAdapterPrefs(selectedAdapter, { model })` | → `if (selectedAdapter) patchAdapterPrefs(...)` | +| 549 | `patchAdapterPrefs(selectedAdapter, { permissionMode })` | → `if (selectedAdapter) patchAdapterPrefs(...)` | + +- [ ] **Step 4: Fix effort default — keep 'high' not empty string** + +Change from the plan's `initialPrefs?.effort || ''` to: +```typescript +const [effort, setEffort] = useState(initialPrefs?.effort || 'high'); +``` +Empty string effort causes blank label in NewChatView and omits `--effort` flag in CLI. + +- [ ] **Step 5: Fix ws.ts — accept null adapter** + +`src/lib/ws.ts:72` — `setActiveSession(sessionId, adapter?: string)` cannot accept `null`. Change to: +```typescript +setActiveSession(sessionId: string | null, adapter?: string | null) { + this.activeSessionId = sessionId; + this.activeAdapter = adapter || null; +} +``` + +- [ ] **Step 6: TypeScript check** + +Run: `npx tsc --noEmit 2>&1 | head -10` +Expected: Zero errors in useChat.ts and ws.ts + +- [ ] **Step 7: Commit** + +```bash +git add src/hooks/useChat.ts src/lib/ws.ts +git commit -m "refactor: defer useChat init when adapter unknown — wait for server SESSION_CREATED" +``` + +--- + +### Task 2: App.tsx — URL includes adapter, parser reads it + +**Files:** +- Modify: `src/App.tsx:39-47` (navigateTo), `src/App.tsx:202-217` (URL parser), `src/App.tsx:191-200` (push notification handler) + +- [ ] **Step 1: navigateTo includes adapter in URL** + +Replace lines 39-47: + +```typescript +function navigateTo(view: View) { + persistView(view); + let url = '/'; + if (view.name === 'chat' && view.sessionId) { + url = `/?view=chat&session=${view.sessionId}`; + if (view.adapter) url += `&adapter=${view.adapter}`; + } else if (view.name === 'settings') { + url = '/?view=settings'; + } + window.history.pushState({ view }, '', url); +} +``` + +- [ ] **Step 2: URL parser reads adapter from URL** + +Replace lines 202-217: + +```typescript +useEffect(() => { + if (urlParamsHandled.current || !authed) return; + const params = new URLSearchParams(window.location.search); + const sessionId = params.get('session'); + const adapter = params.get('adapter'); + const action = params.get('action'); + if (sessionId) { + urlParamsHandled.current = true; + openChat(sessionId, undefined, adapter || undefined); + window.history.replaceState({}, '', '/'); + } else if (action === 'newchat') { + urlParamsHandled.current = true; + window.history.replaceState({}, '', '/'); + } +}, [authed, openChat]); +``` + +- [ ] **Step 3: Push notification handler — no change needed** + +The push notification handler calls `openChat(sessionId)` with no adapter. This is correct — adapter is unknown, useChat will show loading and wait for SESSION_CREATED. The service worker's fallback URL `/?session=${sessionId}` also works (URL parser handles it, adapter will be null → loading → server resolves). + +- [ ] **Step 4: Commit** + +```bash +git add src/App.tsx +git commit -m "feat: URL includes adapter param, parser reads it for instant adapter resolution" +``` + +--- + +### Task 3: ChatView — loading state when adapter unknown + +**Files:** +- Modify: `src/components/ChatView.tsx:141-149` (useChat destructuring), add loading check before render + +- [ ] **Step 1: Add loading state when selectedAdapter is null** + +After the useChat destructuring (line ~149), before the return JSX (line ~487), add: + +```typescript +// Waiting for server to tell us the adapter +if (!selectedAdapter) { + return ( +
+ +
+ ); +} +``` + +Import `LoadingAnimation` at the top of the file: +```typescript +import { LoadingAnimation } from './ui/LoadingAnimation'; +``` + +- [ ] **Step 2: Fix ChatView null-safety** + +The early return `if (!selectedAdapter)` guarantees all JSX below only runs when `selectedAdapter` is a string. TypeScript narrows it automatically. But verify: + +- Line 169: `.filter(a => a !== selectedAdapter)` — safe after guard (narrowed to string) +- Line 440: `` — safe (narrowed) +- All `getBrand(selectedAdapter)` calls — safe + +**StatusBar.tsx** prop type `selectedAdapter: string` does NOT need to change — it's only rendered after the null guard in ChatView. + +**Important**: Any code that runs BEFORE the null guard (e.g., useCallback hooks, useEffect hooks) must guard independently. Check: +- `closeReview` callback — uses `activeReviews`, not `selectedAdapter` → safe +- `openReview` callback — uses `reviewMenuMessageId` → safe +- `handleSendTo` — uses `activeReviews.length` → safe + +- [ ] **Step 3: Commit** + +```bash +git add src/components/ChatView.tsx +git commit -m "feat: ChatView shows loading when adapter unknown, waits for server" +``` + +--- + +### Task 4: Server — SESSION_CREATED includes cwd + +**Files:** +- Modify: `server/session-manager.ts:249-261` (sendSessionCreated) + +- [ ] **Step 1: Add cwd to SESSION_CREATED payload** + +The `sendSessionCreated` function currently sends `sessionId`, `adapter`, `permissionMode`. Add `cwd`: + +```typescript +function sendSessionCreated(conn: ClientConnection, adapter: IAdapter, sessionId: string): void { + const sessionObj = adapter.getSession(sessionId) as { + permissionMode?: string; + approvalPolicy?: string; + cwd?: string; + } | null; + const adapterName = sessionAdapterMap.get(sessionId) || sessionAdapters.get(sessionId); + send(conn, { + type: WS.SESSION_CREATED, + sessionId, + adapter: adapterName, + cwd: sessionObj?.cwd, + permissionMode: sessionObj?.permissionMode || sessionObj?.approvalPolicy, + }); +} +``` + +Note: for historical (non-active) sessions, `adapter.getSession(sessionId)` returns null, so `cwd` will be undefined. This is acceptable — the header will show "Session" instead of project name, which is better than showing the wrong project. + +- [ ] **Step 2: Commit** + +```bash +git add server/session-manager.ts +git commit -m "feat: SESSION_CREATED includes cwd for project name display" +``` + +--- + +### Task 5: Server — handleQuery verifies adapter on resumeSession + +**Files:** +- Modify: `server/session-manager.ts:293-307` (handleQuery) + +- [ ] **Step 1: Verify adapter before resumeSession** + +Replace lines 298-305: + +```typescript +let handle: { sessionId: string }; +if (sessionId) { + // Verify adapter — don't trust client blindly + const resolvedName = await resolveAdapterForSession(sessionId); + const actualAdapter = resolvedName ? getAdapter(resolvedName) : adapter; + const actualName = resolvedName || adapterName || DEFAULT_ADAPTER; + handle = await actualAdapter!.resumeSession(sessionId, cwd as string, { permissionMode }); + registerSessionAdapter(handle.sessionId, actualName); +} else { + handle = await adapter.startSession(cwd || process.cwd(), { model, permissionMode }); + registerSessionAdapter(handle.sessionId, adapterName || DEFAULT_ADAPTER); +} +registerClient(conn, handle.sessionId); +sendSessionCreated(conn, getAdapter(sessionAdapterMap.get(handle.sessionId) || DEFAULT_ADAPTER)!, handle.sessionId); +``` + +- [ ] **Step 2: Commit** + +```bash +git add server/session-manager.ts +git commit -m "fix: handleQuery verifies adapter on resumeSession — don't trust client blindly" +``` + +--- + +### Task 6: Active sessions tab — add adapter badge + +**Files:** +- Modify: `src/components/SessionsView.tsx:337-341` (active session card rendering) + +- [ ] **Step 1: Add adapter badge to active session cards** + +At line ~338, before the firstPrompt text, add the adapter badge: + +```typescript + + + {session.adapter && (() => { + const brand = getBrand(session.adapter); + return ( + + {brand.displayName} + + ); + })()} + {session.firstPrompt || session.sessionId} + +``` + +- [ ] **Step 2: Commit** + +```bash +git add src/components/SessionsView.tsx +git commit -m "feat: active sessions tab shows adapter badge" +``` + +--- + +### Task 7: Build + E2E Verification + +- [ ] **Step 1: TypeScript check** + +Run: `npx tsc --noEmit 2>&1 | grep "error TS" | head -10` +Expected: Zero errors + +- [ ] **Step 2: Build** + +Run: `npm run build 2>&1 | tail -3` +Expected: Clean build + +- [ ] **Step 3: E2E — Session list → Gemini historical session** + +1. Restart server +2. Open browser, login +3. Navigate to code-tap project → click a Gemini session +4. Verify: Gemini badge in status bar, correct model, messages loaded + +- [ ] **Step 4: E2E — Direct URL without adapter** + +1. Open `http://localhost:3456/?view=chat&session=` +2. Verify: Loading shown briefly → then correct Gemini adapter + messages + +- [ ] **Step 5: E2E — Direct URL with adapter** + +1. Open `http://localhost:3456/?view=chat&session=&adapter=gemini` +2. Verify: No loading flash, immediately shows Gemini + messages + +- [ ] **Step 6: E2E — Browser refresh on chat page** + +1. While viewing a Gemini session, press F5 +2. Verify: URL has `&adapter=gemini` → instant load, no flash + +- [ ] **Step 7: E2E — Multi-tab sync** + +1. Open same Gemini session in two tabs (via session list) +2. Send message from Tab 1 +3. Verify Tab 2: user message appears → thinking indicator → response + +- [ ] **Step 8: E2E — Active sessions tab** + +1. Go to Active tab +2. Verify: each session shows adapter badge (Claude/Codex/Gemini) + +- [ ] **Step 9: Final commit + push** + +```bash +git push origin main +``` diff --git a/docs/superpowers/plans/2026-03-27-interactive-prompts.md b/docs/superpowers/plans/2026-03-27-interactive-prompts.md new file mode 100644 index 0000000..2a0f1b2 --- /dev/null +++ b/docs/superpowers/plans/2026-03-27-interactive-prompts.md @@ -0,0 +1,195 @@ +# Interactive Prompts Implementation Plan (v2) + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Detect Gemini/Codex interactive prompts from tmux pane, normalize all adapters to a single InteractivePrompt format, and render a unified overlay in the frontend. + +**Architecture:** Pane monitors detect prompts and adapters emit interactive-prompt event. Session manager converts ALL prompt events (old Claude hooks + new pane detections) into WS.INTERACTIVE_PROMPT. Frontend uses a single InteractivePromptOverlay component. Response flows back via WS.PROMPT_RESPONSE and adapter sends keystrokes to tmux. + +**Tech Stack:** TypeScript, React, WebSocket, tmux pane monitoring + +**Spec:** docs/superpowers/specs/2026-03-27-interactive-prompts-design.md + +--- + +## File Map + +| File | Action | Change | +|---|---|---| +| server/types/messages.ts | Modify | Add InteractivePrompt, PromptResponse types | +| src/lib/ws-types.ts | Modify | Add INTERACTIVE_PROMPT, PROMPT_RESPONSE, PROMPT_DISMISSED | +| server/adapters/interface.ts | Modify | Add respondInteractivePrompt method | +| server/session-manager.ts | Modify | Convert old events to new format; add interactive-prompt listener; add handlePromptResponse; broadcast PROMPT_DISMISSED | +| server/adapters/gemini/pane-monitor.ts | Modify | Detect 4 prompt types, emit interactive-prompt | +| server/adapters/codex/pane-monitor.ts | Modify | Detect approval + user input, emit interactive-prompt | +| server/adapters/gemini/gemini-tmux-adapter.ts | Modify | Implement respondInteractivePrompt (numbered options + text) | +| server/adapters/codex/codex-tmux-adapter.ts | Modify | Implement respondInteractivePrompt (keyboard shortcuts + text) | +| server/adapters/claude/tmux-adapter.ts | Modify | Implement respondInteractivePrompt (delegates to existing) | +| src/hooks/useChat.ts | Modify | State type to InteractivePrompt; handle INTERACTIVE_PROMPT; add respondPrompt | +| src/components/InteractivePromptOverlay.tsx | Create | Unified overlay: options (buttons), textInput (field), or both (plan mode) | +| src/components/ChatView.tsx | Modify | Replace PermissionOverlay/AskQuestion with InteractivePromptOverlay | +| src/components/FloatingReviewPanel.tsx | Modify | Add prompt handling to ReviewTab | +| server/adapters/gemini/gemini-tmux-adapter.ts | Modify | _waitForReady: privacy notice, multi-folder trust, IDE nudge | + +--- + +### Task 1: Types + WS message types + +**Files:** +- Modify: server/types/messages.ts +- Modify: src/lib/ws-types.ts +- Modify: server/adapters/interface.ts + +- [ ] **Step 1:** Add InteractivePrompt and PromptResponse types to server/types/messages.ts +- [ ] **Step 2:** Add INTERACTIVE_PROMPT, PROMPT_RESPONSE, PROMPT_DISMISSED to src/lib/ws-types.ts WS enum +- [ ] **Step 3:** Add respondInteractivePrompt(requestId: string, selectedOption?: string, textValue?: string): void {} to IAdapter in server/adapters/interface.ts +- [ ] **Step 4:** Commit + +--- + +### Task 2: Session manager -- unified event conversion + response handling + +**Files:** +- Modify: server/session-manager.ts + +- [ ] **Step 1:** Replace existing permission-request listener to convert Claude hook data into InteractivePrompt format and broadcast as WS.INTERACTIVE_PROMPT (not WS.PERMISSION_REQUEST) + +- [ ] **Step 2:** Replace existing ask-question listener to convert Claude hook data into InteractivePrompt format (detect options vs free text) and broadcast as WS.INTERACTIVE_PROMPT + +- [ ] **Step 3:** Add interactive-prompt event listener for Gemini/Codex (already in InteractivePrompt format, just broadcast) + +- [ ] **Step 4:** Add WS.PROMPT_RESPONSE case to handleIncomingMessage switch. Create handlePromptResponse function that calls adapter.respondInteractivePrompt and broadcasts WS.PROMPT_DISMISSED to all clients for multi-tab sync. + +- [ ] **Step 5:** Commit + +--- + +### Task 3: Gemini pane monitor -- detect prompts + +**Files:** +- Modify: server/adapters/gemini/pane-monitor.ts + +- [ ] **Step 1:** Add lastPromptId instance variable for dedup. At start of _poll, call _detectPrompt. If detected and different from lastPromptId, emit interactive-prompt event. If no longer detected, reset lastPromptId. Return early (skip streaming text detection while prompt is showing). + +- [ ] **Step 2:** Implement _detectPrompt method. Detect 4 types: + - Tool Confirmation: content includes "Action Required" AND numbered options pattern + - AskUser: content includes "Answer Questions" + - Plan Approval: content includes "Approval" AND "Yes" options AND "feedback" + - Loop Detection: content includes "potential loop was detected" + + For each, extract title, description, options (via _parseNumberedOptions), and textInput if applicable. Return InteractivePrompt or null. + +- [ ] **Step 3:** Implement _parseNumberedOptions helper. Match regex for numbered list items. Return array of { value: String(index), label } where index is 0-based. + +- [ ] **Step 4:** Commit + +--- + +### Task 4: Codex pane monitor -- detect prompts + +**Files:** +- Modify: server/adapters/codex/pane-monitor.ts + +- [ ] **Step 1:** Add lastPromptId + detection at start of _poll (same dedup pattern as Gemini) + +- [ ] **Step 2:** Detect command/file/network approval: content includes "(y)" AND "proceed". Parse options with _parseCodexOptions matching (letter) label pattern. + +- [ ] **Step 3:** Detect user input: content includes "enter to submit" AND "esc to cancel". Determine if choice or free text. + +- [ ] **Step 4:** Implement _parseCodexOptions helper. Match regex for (x) Label format. Return array of { value: letter, label }. + +- [ ] **Step 5:** Commit + +--- + +### Task 5: Adapter respondInteractivePrompt implementations + +**Files:** +- Modify: server/adapters/gemini/gemini-tmux-adapter.ts +- Modify: server/adapters/codex/codex-tmux-adapter.ts +- Modify: server/adapters/claude/tmux-adapter.ts + +- [ ] **Step 1:** Gemini respondInteractivePrompt. If selectedOption: parse as integer index, navigate Down x index + Enter. If textValue: sendKeys text + Enter. + +- [ ] **Step 2:** Codex respondInteractivePrompt. If selectedOption: sendKeys with that single character (y/a/p/d/n). If textValue: sendKeys text + Enter. + +- [ ] **Step 3:** Claude respondInteractivePrompt. If textValue: delegate to existing respondQuestion. If selectedOption: delegate to existing respondPermission with value as PermissionBehavior. + +- [ ] **Step 4:** Commit + +--- + +### Task 6: Frontend -- InteractivePromptOverlay component + +**Files:** +- Create: src/components/InteractivePromptOverlay.tsx + +- [ ] **Step 1:** Create component with props { prompt: InteractivePrompt, onRespond: (requestId, selectedOption?, textValue?) => void }. Use BottomSheet container. Render: + - Title bar with type badge (permission=orange, question=blue, plan=purple, loop-detected=yellow) + - Description text + - If toolName + toolInput: collapsible tool info card + - If options: vertical button list + - If textInput: text input field + submit button + - If both options AND textInput: buttons above, text input below (plan mode) + - 120s countdown timer + +- [ ] **Step 2:** Commit + +--- + +### Task 7: useChat -- InteractivePrompt state + respondPrompt + +**Files:** +- Modify: src/hooks/useChat.ts + +- [ ] **Step 1:** Add InteractivePrompt type (mirror from server types). Replace PermissionRequest state with InteractivePrompt state. + +- [ ] **Step 2:** Replace WS.PERMISSION_REQUEST handler with WS.INTERACTIVE_PROMPT handler. Replace WS.PERMISSION_DISMISSED handler with WS.PROMPT_DISMISSED handler. + +- [ ] **Step 3:** Add respondPrompt callback that sends WS.PROMPT_RESPONSE and clears interactivePrompt state. + +- [ ] **Step 4:** Update return object: replace permissionRequest with interactivePrompt, add respondPrompt. Keep respondPermission and respondAsk temporarily for any remaining direct callers. + +- [ ] **Step 5:** Commit + +--- + +### Task 8: ChatView + ReviewTab -- use InteractivePromptOverlay + +**Files:** +- Modify: src/components/ChatView.tsx +- Modify: src/components/FloatingReviewPanel.tsx + +- [ ] **Step 1:** ChatView: replace PermissionOverlay/AskQuestion with InteractivePromptOverlay. Update useChat destructuring (interactivePrompt, respondPrompt). + +- [ ] **Step 2:** ReviewTab: destructure interactivePrompt + respondPrompt from useChat. Render InteractivePromptOverlay after ChatBody. + +- [ ] **Step 3:** Commit + +--- + +### Task 9: Gemini _waitForReady -- remaining startup prompts + +**Files:** +- Modify: server/adapters/gemini/gemini-tmux-adapter.ts + +- [ ] **Step 1:** Add detection in _waitForReady for: + - Privacy Notice / Terms of Service: dismiss with Esc + - Multi-folder trust: accept default with Enter + - IDE integration nudge: decline (Down + Enter) + + All before hasPrompt check, after existing folder trust check. + +- [ ] **Step 2:** Commit + +--- + +### Task 10: Build + E2E + +- [ ] **Step 1:** TypeScript check +- [ ] **Step 2:** Build +- [ ] **Step 3:** E2E: Gemini tool confirmation (default mode) +- [ ] **Step 4:** E2E: Gemini AskUser +- [ ] **Step 5:** E2E: Codex command approval (suggest mode) +- [ ] **Step 6:** E2E: Claude permissions (backwards compatible) +- [ ] **Step 7:** E2E: Multi-tab dismiss diff --git a/docs/superpowers/specs/2026-03-26-adapter-identity-fix-design.md b/docs/superpowers/specs/2026-03-26-adapter-identity-fix-design.md new file mode 100644 index 0000000..da35131 --- /dev/null +++ b/docs/superpowers/specs/2026-03-26-adapter-identity-fix-design.md @@ -0,0 +1,169 @@ +# Adapter Identity Fix — Design Spec + +**Date**: 2026-03-26 +**Status**: Draft + +## Problem + +When opening a historical session without explicit adapter info (URL direct access, browser refresh, push notification), the frontend guesses the adapter from localStorage and initializes model/permissionMode/effort from the wrong adapter's prefs. The server later corrects the adapter via SESSION_CREATED, but model/prefs are never corrected → wrong UI state. + +## Root Cause + +`useChat` eagerly initializes everything (adapter, model, permissionMode, effort, adapterConfig) at mount time before knowing the correct adapter. When the adapter is unknown, it guesses wrong. + +## Design Principle + +**Don't guess. Wait.** + +If the adapter is known (from prop or URL) → initialize immediately. +If the adapter is unknown → show loading → wait for server SESSION_CREATED → then initialize. + +Server is the single source of truth for adapter identity. + +## Changes + +### Change 1: useChat — defer initialization until adapter is confirmed + +**File:** `src/hooks/useChat.ts` + +Current: +```typescript +const resolvedAdapter = initialAdapter || localStorage.getItem(STORAGE.ADAPTER) || 'claude'; +const initialPrefs = loadAdapterPrefs(resolvedAdapter); +const [model, setModel] = useState(initialPrefs.model || ''); +// ... all initialized immediately with possibly wrong adapter +``` + +New: +```typescript +// adapter is either known from prop/URL, or null (wait for server) +const [selectedAdapter, setSelectedAdapter] = useState(initialAdapter || null); + +// model/prefs initialized only after adapter is confirmed +const [model, setModel] = useState(''); +const [permissionMode, setPermissionMode] = useState('default'); +const [effort, setEffort] = useState(''); +``` + +When SESSION_CREATED arrives: +```typescript +case WS.SESSION_CREATED: + setSessionId(msg.sessionId); + if (msg.adapter) { + setSelectedAdapter(msg.adapter); + // Load correct prefs now that we know the adapter + const prefs = loadAdapterPrefs(msg.adapter); + setModel(prefs.model || ''); + setPermissionMode(msg.permissionMode || prefs.permissionMode || 'default'); + setEffort(prefs.effort || ''); + } + break; +``` + +If `initialAdapter` was provided (session list click), everything initializes immediately at mount — no waiting, no loading state. + +### Change 2: ChatView — show loading when adapter unknown + +**File:** `src/components/ChatView.tsx` + +If `selectedAdapter` is null (waiting for server), render a loading indicator instead of the chat UI: + +```tsx +if (!selectedAdapter) { + return ; +} +``` + +This only happens for path B (URL) and C (notification). Path A (session list) always has adapter → no loading. + +### Change 3: URL includes adapter when available + +**File:** `src/App.tsx` + +`navigateTo()` includes adapter in URL when known: +```typescript +const url = view.sessionId + ? `/?view=chat&session=${view.sessionId}${view.adapter ? `&adapter=${view.adapter}` : ''}` + : '/'; +``` + +URL parser reads adapter from URL: +```typescript +const sessionId = params.get('session'); +const adapter = params.get('adapter'); +if (sessionId) { + openChat(sessionId, undefined, adapter || undefined); +} +``` + +Push notification service worker also includes adapter in URL if available. + +### Change 4: SERVER SESSION_CREATED includes adapter + cwd + +**File:** `server/session-manager.ts` + +`sendSessionCreated()` includes `adapter` name (already done) and `cwd`: +```typescript +send(conn, { + type: WS.SESSION_CREATED, + sessionId, + adapter: adapterName, + cwd: sessionObj?.cwd || resolvedCwd, + permissionMode: sessionObj?.permissionMode, +}); +``` + +The `cwd` allows the frontend to show the correct project name in the header even when opened from URL (which doesn't have `cwd`). + +### Change 5: handleQuery verifies adapter on resumeSession + +**File:** `server/session-manager.ts` + +When `handleQuery` receives a QUERY with a `sessionId` (resume path), verify the adapter: +```typescript +if (sessionId) { + const resolvedName = await resolveAdapterForSession(sessionId); + if (resolvedName) adapterName = resolvedName; // override client's adapter with truth + handle = await adapter.resumeSession(sessionId, cwd, { permissionMode }); +} +``` + +### Change 6: Active sessions tab shows adapter badge + +**File:** `src/components/SessionsView.tsx` + +Add adapter brand badge to active session cards (same pattern as project sessions list). + +## Flow After Fix + +### Path A (Session List Click): +``` +adapter = 'gemini' (from server API) → useChat initializes immediately → no loading +→ WS RECONNECT → server confirms → messages load → render +``` + +### Path B (URL Direct) / Path C (Push Notification): +``` +adapter = null (unknown) → useChat does NOT initialize prefs → ChatView shows loading +→ WS RECONNECT → server SESSION_CREATED { adapter: 'gemini', cwd: '...' } +→ useChat sets adapter, loads correct prefs → loading disappears → messages load → render +``` + +### Path B with adapter in URL: +``` +URL: ?session=UUID&adapter=gemini +adapter = 'gemini' (from URL) → useChat initializes immediately → no loading +→ WS RECONNECT → server confirms → messages load → render +``` + +## Verification + +1. **Session list → Gemini session**: Loads immediately, correct adapter/model/messages +2. **URL `?session=UUID` (no adapter)**: Shows loading → then correct adapter/messages +3. **URL `?session=UUID&adapter=gemini`**: Loads immediately, no flash +4. **Browser refresh on chat**: Adapter from URL → immediate load +5. **Push notification click**: Loading → then correct session +6. **Two tabs same session**: Both show correct adapter, messages sync +7. **Send from Tab A**: Tab B sees user message + thinking + response +8. **Active sessions tab**: Shows adapter badge +9. **New Chat (all adapters)**: Still works correctly diff --git a/docs/superpowers/specs/2026-03-27-interactive-prompts-design.md b/docs/superpowers/specs/2026-03-27-interactive-prompts-design.md new file mode 100644 index 0000000..5062cfb --- /dev/null +++ b/docs/superpowers/specs/2026-03-27-interactive-prompts-design.md @@ -0,0 +1,196 @@ +# Interactive Prompts — Normalized Handling Across All Adapters + +**Date**: 2026-03-27 +**Status**: Draft + +## Problem + +Gemini and Codex CLIs show interactive terminal prompts (tool confirmation, ask user question, plan approval, etc.) that ClawTap doesn't detect or handle. The UI freezes with a blinking cursor while the CLI waits for input. Claude's prompts are handled via hooks, but Gemini/Codex have no equivalent hook mechanism for runtime prompts. + +## Design Principle + +**One normalized format, adapter-agnostic frontend.** + +Each adapter detects prompts in its own way (Claude: hooks, Gemini/Codex: pane monitor), but all emit the same `InteractivePrompt` format. Frontend renders based on format, not adapter identity. + +## Normalized Types + +```typescript +interface InteractivePrompt { + requestId: string; + type: 'permission' | 'question' | 'plan' | 'loop-detected'; + title: string; + description: string; + toolName?: string; + toolInput?: any; + options?: { value: string; label: string }[]; + textInput?: { placeholder?: string }; +} + +interface PromptResponse { + requestId: string; + selectedOption?: string; + textValue?: string; +} +``` + +Render logic: +- `options` only → button list (permission overlay) +- `textInput` only → text input field (ask question) +- Both → buttons + text field (plan mode: approve buttons + feedback) + +## Changes + +### Change 1: Gemini pane monitor — detect interactive prompts + +**File:** `server/adapters/gemini/pane-monitor.ts` + +Add prompt detection to the existing poll loop. Each poll, check for known prompt patterns before processing streaming text: + +**Tool Confirmation** ("Action Required"): +``` +Pattern: content includes "Action Required" AND numbered options (● N.) +Extract: title, description (command/file/tool info), options list +Emit: { type: 'permission', options: [...] } +``` + +**AskUser** ("Answer Questions"): +``` +Pattern: content includes "Answer Questions" AND "> " input prompt +Extract: question text, input type (detect options vs free text) +Emit: { type: 'question', textInput or options } +``` + +**Plan Approval** ("Approval"): +``` +Pattern: content includes "Approval" header with plan content +Extract: plan text, approval options + feedback field +Emit: { type: 'plan', options: [...], textInput: { placeholder: 'Type your feedback...' } } +``` + +**Loop Detection**: +``` +Pattern: content includes "potential loop was detected" +Extract: options +Emit: { type: 'loop-detected', options: [...] } +``` + +Dedup: track last emitted requestId to avoid re-emitting the same prompt on each poll. + +### Change 2: Codex pane monitor — detect interactive prompts + +**File:** `server/adapters/codex/pane-monitor.ts` + +**Command/File/Network Approval**: +``` +Pattern: content includes "(y) Yes, proceed" or "Would you like to run" +Extract: command/file info, available options (y/a/p/d/n) +Emit: { type: 'permission', options: [...] } +``` + +**Request User Input**: +``` +Pattern: content includes "Question" header with "> " input +Extract: question text, options or free text field +Emit: { type: 'question', textInput or options } +``` + +### Change 3: Gemini adapter — respondPermission / respondQuestion + +**File:** `server/adapters/gemini/gemini-tmux-adapter.ts` + +Add methods to send keystrokes based on `PromptResponse`: + +- **Permission (numbered options):** Navigate Down × N to selected option, press Enter +- **Question (text):** Type answer text, press Enter +- **Question (select):** Navigate to selected option, press Enter +- **Plan:** Select approve option OR type feedback, press Enter + +### Change 4: Codex adapter — respondPermission / respondQuestion + +**File:** `server/adapters/codex/codex-tmux-adapter.ts` + +- **Permission:** Send the keyboard shortcut key (y/a/p/d/n) +- **Question (text):** Type answer text, press Enter +- **Question (select):** Navigate to option, press Enter + +### Change 5: Claude adapter — normalize existing events + +**File:** `server/adapters/claude/tmux-adapter.ts` + +Current `permission-request` and `ask-question` events already work but use adapter-specific format. Map to `InteractivePrompt` format in session-manager.ts event handlers (minimal change — add missing fields). + +### Change 6: Session manager — unified event handling + +**File:** `server/session-manager.ts` + +Current event listeners: +```typescript +adapter.on('permission-request', ...) → broadcast WS.PERMISSION_REQUEST +adapter.on('ask-question', ...) → broadcast WS.PERMISSION_REQUEST (toolName: 'AskUserQuestion') +``` + +Change to emit unified format: +```typescript +adapter.on('interactive-prompt', (sessionId, prompt: InteractivePrompt) => { + broadcast(sessionId, { type: WS.INTERACTIVE_PROMPT, ...prompt }); +}); +``` + +### Change 7: Frontend — InteractivePromptOverlay component + +**File:** `src/components/InteractivePromptOverlay.tsx` (new) + +Replaces `PermissionOverlay` and `AskQuestion` with a single adapter-agnostic component: + +- Renders `title` + `description` +- If `options` → button list +- If `textInput` → text input field +- If both → buttons + text field (plan mode layout) +- Sends `PromptResponse` back via WS + +**File:** `src/components/ChatView.tsx` + `src/components/FloatingReviewPanel.tsx` + +Replace `PermissionOverlay` / `AskQuestion` usage with `InteractivePromptOverlay`. + +### Change 8: useChat — handle new WS message type + +**File:** `src/hooks/useChat.ts` + +Replace `WS.PERMISSION_REQUEST` handler with `WS.INTERACTIVE_PROMPT`: +```typescript +case WS.INTERACTIVE_PROMPT: + setInteractivePrompt(msg); // replaces setPermissionRequest + break; +``` + +### Change 9: Remaining _waitForReady prompts + +**File:** `server/adapters/gemini/gemini-tmux-adapter.ts` + +Add detection for remaining startup prompts: +- Privacy Notice → send Esc +- Multi-folder trust → send option 1 +- IDE integration nudge → send "No" + +These are handled in `_waitForReady` (auto-bypass), not sent to frontend. + +## What Doesn't Change + +- **WS protocol**: Still uses WebSocket for all communication +- **tmux management**: Still uses tmux for CLI process management +- **JSONL watching**: Still uses file watchers for message history +- **Claude hooks**: Still uses hooks for Claude tool events (just normalizes the output format) + +## Scope Notes + +**Phase 1 (this spec):** +- Gemini: tool confirmation, ask user, plan approval, loop detection +- Codex: command/file/network approval, request user input +- Claude: normalize existing events to new format +- Frontend: InteractivePromptOverlay component + +**Phase 2 (future):** +- Diff rendering in file edit permissions +- Codex MCP elicitation forms (structured multi-field forms) +- Codex multi-agent thread approval routing diff --git a/package.json b/package.json index 1720668..7496579 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@kuannnn/clawtap", - "version": "0.1.1", + "version": "0.2.0", "description": "Use Claude Code from your phone. Real-time mobile UI synced with your desktop terminal via tmux.", "type": "module", "bin": { @@ -80,4 +80,4 @@ "vite": "^6.3.2", "vite-plugin-pwa": "^1.2.0" } -} \ No newline at end of file +} diff --git a/server/adapters/claude/hook-config.ts b/server/adapters/claude/hook-config.ts index 2be4c54..b3edbd3 100644 --- a/server/adapters/claude/hook-config.ts +++ b/server/adapters/claude/hook-config.ts @@ -30,14 +30,11 @@ interface HookIdentifiers { interface ClaudeSettings { hooks?: Record; statusLine?: { type: string; command: string }; - _clawtapOriginalStatusLine?: string; + _clawtapOriginalStatusLine?: string; // legacy, cleaned up on uninstall [key: string]: unknown; } export class ClaudeHookConfig { - /** Shared between install() wrapper construction and _extractOriginalFromWrapper() */ - private static readonly WRAPPER_TAIL = `fi; printf '%s' "$input" | `; - port: number | string; useHttps: boolean; @@ -79,16 +76,14 @@ export class ClaudeHookConfig { existing.hooks[event] = [...filtered, ...configs]; } - // Wrap statusLine to also POST to our server (non-blocking). - // - Has custom statusLine → wrap it (POST + original coexist) + // Insert our statusLine script into the pipe chain (if not already there). + // Our script is a passthrough: reads stdin, POSTs to server (background), outputs stdin. + // - Has custom statusLine → pipe through our script first // - No custom statusLine → don't touch it, preserve Claude Code built-in + const wrapperScript = this._ensureStatusLineScript(statuslineUrl); const existingCmd = existing.statusLine?.command || ''; - if (existingCmd && !existingCmd.includes(`:${port}/api/hooks/claude/statusline`)) { - existing._clawtapOriginalStatusLine = existingCmd; - const portCheck = this._portCheckCmd(); - const curlK = this.useHttps ? ' -k' : ''; - const wrapperCmd = `input=$(cat); if ${portCheck}; then printf '%s' "$input" | curl -sf${curlK} -X POST -H 'Content-Type:application/json' -d @- ${statuslineUrl} &>/dev/null & ${ClaudeHookConfig.WRAPPER_TAIL}${existingCmd}`; - existing.statusLine = { type: 'command', command: wrapperCmd }; + if (existingCmd && !existingCmd.includes(wrapperScript)) { + existing.statusLine = { type: 'command', command: `${wrapperScript} | ${existingCmd}` }; console.log(`[hooks] Wrapped statusLine to POST to ${statuslineUrl}`); } @@ -129,19 +124,23 @@ export class ClaudeHookConfig { if (Object.keys(existing.hooks).length === 0) delete existing.hooks; } - // --- Restore statusLine (independent of hooks) --- - // Restore original statusLine: try extraction from wrapper first (most reliable), - // then fall back to backup field, then delete only if truly no original existed. - if (existing.statusLine?.command?.includes(portTag)) { - const original = this._extractOriginalFromWrapper(existing.statusLine.command); - if (original) { - existing.statusLine = { type: 'command', command: original }; - } else if (existing._clawtapOriginalStatusLine) { - existing.statusLine = { type: 'command', command: existing._clawtapOriginalStatusLine }; + // --- Restore statusLine: remove our script from the pipe chain --- + const wrapperScript = this._statusLineScriptPath(); + if (existing.statusLine?.command?.includes(wrapperScript)) { + // Remove our script + pipe from the command string + const restored = existing.statusLine.command + .replace(`${wrapperScript} | `, '') + .replace(wrapperScript, '') + .replace(/\s*\|\s*$/, '') // trailing pipe + .replace(/^\s*\|\s*/, '') // leading pipe + .trim(); + if (restored) { + existing.statusLine = { type: 'command', command: restored }; } else { delete existing.statusLine; } } + // Clean up legacy backup field from old versions delete existing._clawtapOriginalStatusLine; writeFileSync(settingsPath, JSON.stringify(existing, null, 2)); @@ -160,14 +159,30 @@ export class ClaudeHookConfig { }; } - /** Extract the original statusLine command from our wrapper using WRAPPER_TAIL. */ - private _extractOriginalFromWrapper(cmd: string): string | null { - const tail = ClaudeHookConfig.WRAPPER_TAIL; - const idx = cmd.lastIndexOf(tail); - if (idx < 0) return null; - const original = cmd.substring(idx + tail.length).trim(); - if (!original || original.includes('/api/hooks/claude')) return null; - return original; + /** Path to our statusLine wrapper script */ + private _statusLineScriptPath(): string { + return join(homedir(), '.clawtap', 'hooks', 'claude-statusline.sh'); + } + + /** Create or update the statusLine wrapper script */ + private _ensureStatusLineScript(statuslineUrl: string): string { + const scriptPath = this._statusLineScriptPath(); + const scriptDir = join(homedir(), '.clawtap', 'hooks'); + mkdirSync(scriptDir, { recursive: true }); + + const portCheck = this._portCheckCmd(); + const curlInsecure = this.useHttps ? ' -k' : ''; + const script = `#!/bin/bash +input=$(cat) +# POST to ClawTap server (non-blocking, skip if server not running) +if ${portCheck}; then + printf '%s' "$input" | curl -sf${curlInsecure} --connect-timeout 2 --max-time 5 -X POST -H 'Content-Type:application/json' -d @- ${statuslineUrl} &>/dev/null & +fi +# Pass through to stdout +printf '%s' "$input" +`; + writeFileSync(scriptPath, script, { mode: 0o755 }); + return scriptPath; } private _isOurHookEntry(entry: HookEntry, portTag: string): boolean { diff --git a/server/adapters/claude/index.ts b/server/adapters/claude/index.ts index c12f277..c23dea5 100644 --- a/server/adapters/claude/index.ts +++ b/server/adapters/claude/index.ts @@ -79,10 +79,10 @@ export class ClaudeAdapter extends IAdapter { } setup(app: Express): void { - this.installHooks(); this._registerHookRoutes(app); } + setHookPort(port: number | string): void { this._hookConfig.port = port; } installHooks(): void { this._hookConfig.install(); } uninstallHooks(): void { this._hookConfig.uninstall(); } @@ -206,6 +206,7 @@ export class ClaudeAdapter extends IAdapter { async switchPermissionMode(sid: string, mode: string): Promise { return this._tmux.switchPermissionMode(sid, mode); } respondPermission(reqId: string, behavior: PermissionBehavior): void { this._tmux.respondPermission(reqId, behavior); } async respondQuestion(reqId: string, answer: string): Promise { return this._tmux.respondQuestion(reqId, answer); } + respondInteractivePrompt(reqId: string, opt?: string, text?: string): void { this._tmux.respondInteractivePrompt(reqId, opt, text); } releaseAllPending(sid: string): void { this._tmux.releaseAllPending(sid); } resolveAllPendingAs(sid: string, behavior: PermissionBehavior): void { this._tmux.resolveAllPendingAs(sid, behavior); } diff --git a/server/adapters/claude/jsonl-store.ts b/server/adapters/claude/jsonl-store.ts index e1119f2..c3955f1 100644 --- a/server/adapters/claude/jsonl-store.ts +++ b/server/adapters/claude/jsonl-store.ts @@ -139,6 +139,7 @@ export async function getMessages(sessionId: string, dir?: string): Promise = new Map(); // parentToolUseId → sub-tool blocks + const toolUseIndex: Map = new Map(); // tool_use id → content block const stream = createReadStream(filePath); const rl = createInterface({ input: stream, crlfDelay: Infinity }); try { @@ -162,9 +163,24 @@ export async function getMessages(sessionId: string, dir?: string): Promise b.type === 'tool_result')) continue; + // Attach tool results to their matching tool_use blocks + const toolResults = Array.isArray(content) + ? (content as ContentBlock[]).filter((b: ContentBlock) => b.type === 'tool_result' && b.tool_use_id) + : []; + if (toolResults.length > 0) { + for (const block of toolResults) { + const match = toolUseIndex.get(block.tool_use_id as string); + if (match) match._result = block; + } + continue; + } // Skip system/CLI messages (empty text, system patterns) if (isSystemMessage(text, content)) continue; // Convert "Implement the following plan:" messages to plan type diff --git a/server/adapters/claude/tmux-adapter.ts b/server/adapters/claude/tmux-adapter.ts index aa73c68..98d2c1d 100644 --- a/server/adapters/claude/tmux-adapter.ts +++ b/server/adapters/claude/tmux-adapter.ts @@ -611,6 +611,28 @@ export class TmuxAdapter extends EventEmitter { } } + respondInteractivePrompt(requestId: string, selectedOption?: string, textValue?: string): void { + if (textValue != null) { + this.respondQuestion(requestId, textValue); + } else if (selectedOption != null) { + // Permission behaviors are named ('allow', 'allow_session', 'deny') + // Question options are numeric indices ('0', '1', '2') + const isPermission = ['allow', 'allow_session', 'deny'].includes(selectedOption); + if (isPermission) { + this.respondPermission(requestId, selectedOption as any); + } else { + // Numeric index — validate before consuming the pending entry + const index = parseInt(selectedOption); + if (isNaN(index)) return; + const pending = this._permissions.resolveQuestion(requestId); + if (!pending) return; + const session = this.sessions.get(pending.sessionId); + if (!session) return; + this._selectOption(session.windowId, index).catch(() => {}); + } + } + } + /** * Respond to the CLI's plan approval selector. * Options: 0=bypass (auto-accept edits), 1=manually approve, 2=text feedback @@ -876,6 +898,23 @@ export class TmuxAdapter extends EventEmitter { if (attempt <= 3 || attempt % 5 === 0) { console.log(`[adapter] waitForReady #${attempt}: window=${windowId} prompt=${hasPrompt} lines=${lineCount}`); } + // Auto-accept bypass permissions confirmation prompt (Claude v2.1.85+). + // Detect by structure (numbered selection list) + context (bypass permissions). + const isSelectionPrompt = /❯\s+\d+\./.test(content); + const isBypassPrompt = /[Bb]ypass\s+[Pp]ermissions/.test(content); + if (isSelectionPrompt && isBypassPrompt) { + const acceptMatch = content.match(/(\d+)\.\s+Yes/); + const acceptOption = acceptMatch ? parseInt(acceptMatch[1]) : 2; + console.log(`[adapter] Bypass permissions prompt detected, selecting option ${acceptOption}`); + for (let i = 1; i < acceptOption; i++) { + await tmuxManager.sendControl(windowId, 'Down'); + await new Promise(r => setTimeout(r, 50)); + } + await tmuxManager.sendControl(windowId, 'Enter'); + await new Promise(r => setTimeout(r, 500)); + continue; + } + if (hasPrompt && lineCount >= 3) { console.log(`[adapter] CLI ready for ${windowId} in ${Date.now() - start}ms`); await new Promise(r => setTimeout(r, 300)); diff --git a/server/adapters/codex/codex-tmux-adapter.ts b/server/adapters/codex/codex-tmux-adapter.ts index 45cb37f..d170712 100644 --- a/server/adapters/codex/codex-tmux-adapter.ts +++ b/server/adapters/codex/codex-tmux-adapter.ts @@ -19,6 +19,7 @@ import type { ReconnectState } from '../../types/adapter.js'; import type { ActiveSessionInfo } from '../interface.js'; import { isLargeContent } from '../interface.js'; import { PermissionManager } from '../../permission-manager.js'; +import { findActiveSession } from '../shared/find-active-session.js'; import { readFile } from 'fs/promises'; // --------------------------------------------------------------------------- @@ -149,7 +150,7 @@ export class CodexTmuxAdapter extends EventEmitter { this._startMonitor(finalId, windowId); - return { sessionId: finalId }; + return { sessionId: finalId, pendingRekey: finalId === tempKey }; } async resumeSession(sessionId: string, cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string }> { @@ -606,6 +607,23 @@ export class CodexTmuxAdapter extends EventEmitter { await tmuxManager.sendKeys(session.windowId, answer, true); } + respondInteractivePrompt(requestId: string, selectedOption?: string, textValue?: string): void { + const pending = this._permissions.resolvePermission(requestId) + || this._permissions.resolveQuestion(requestId); + const sessionId = pending?.sessionId || findActiveSession(this.sessions); + if (!sessionId) return; + const session = this.sessions.get(sessionId); + if (!session) return; + + if (selectedOption != null) { + // Codex uses single-key shortcuts (y, a, p, d, n) + tmuxManager.sendKeys(session.windowId, selectedOption, false).catch(() => {}); + } + if (textValue != null) { + tmuxManager.sendKeys(session.windowId, textValue, true).catch(() => {}); + } + } + /** Release all pending requests for a session (e.g., when Mobile disconnects). */ releaseAllPending(sessionId: string): void { this._permissions.dismissAll(sessionId); diff --git a/server/adapters/codex/index.ts b/server/adapters/codex/index.ts index 7af52c0..659874f 100644 --- a/server/adapters/codex/index.ts +++ b/server/adapters/codex/index.ts @@ -87,10 +87,10 @@ export class CodexAdapter extends IAdapter { } setup(app: Express): void { - this.installHooks(); this._registerHookRoutes(app); } + setHookPort(port: number | string): void { this._hookConfig.port = port; } installHooks(): void { this._hookConfig.install(); } uninstallHooks(): void { this._hookConfig.uninstall(); } @@ -164,6 +164,7 @@ export class CodexAdapter extends IAdapter { async switchPermissionMode(sid: string, mode: string): Promise { return this._tmux.switchPermissionMode(sid, mode); } respondPermission(reqId: string, behavior: PermissionBehavior): void { this._tmux.respondPermission(reqId, behavior); } async respondQuestion(reqId: string, answer: string): Promise { return this._tmux.respondQuestion(reqId, answer); } + respondInteractivePrompt(reqId: string, opt?: string, text?: string): void { this._tmux.respondInteractivePrompt(reqId, opt, text); } releaseAllPending(sid: string): void { this._tmux.releaseAllPending(sid); } resolveAllPendingAs(sid: string, behavior: PermissionBehavior): void { this._tmux.resolveAllPendingAs(sid, behavior); } diff --git a/server/adapters/codex/jsonl-store.ts b/server/adapters/codex/jsonl-store.ts index 0c3b5e3..a6483ca 100644 --- a/server/adapters/codex/jsonl-store.ts +++ b/server/adapters/codex/jsonl-store.ts @@ -3,6 +3,7 @@ import { join } from 'path'; import { homedir } from 'os'; import { createReadStream } from 'fs'; import { createInterface } from 'readline'; +import { stripMarker } from '../shared/content-utils.js'; import { CodexTranscriptParser } from './transcript-parser.js'; import type { CodexJsonlEntry } from './transcript-parser.js'; import type { DirectoryEntry, MessagesResult } from '../interface.js'; @@ -202,7 +203,7 @@ export async function getSessions(dir?: string, limit?: number): Promise | null = null; private _lastContent: string = ''; private _lastResponseText: string = ''; + private lastPromptId: string | null = null; constructor( sessionId: string, @@ -84,7 +95,19 @@ export class CodexPaneMonitor { if (content === this._lastContent) return; this._lastContent = content; - // 1. Check for approval prompt (highest priority — blocks everything) + // 0. Check for interactive prompt (highest priority) + const interactivePrompt = this._detectPrompt(content); + if (interactivePrompt) { + if (interactivePrompt.requestId !== this.lastPromptId) { + this.lastPromptId = interactivePrompt.requestId; + this.emitter.emit('interactive-prompt', this.sessionId, interactivePrompt); + } + return; // Don't process streaming while prompt is showing + } else if (this.lastPromptId) { + this.lastPromptId = null; + } + + // 1. Check for approval prompt (legacy — kept for backwards compat) const approval = detectApprovalPrompt(content); if (approval) { this.emitter.emit('approval-prompt', this.sessionId, approval); @@ -108,6 +131,78 @@ export class CodexPaneMonitor { // Silently ignore — tmux window may have been killed } } + + /** + * Detect an interactive prompt in the Codex CLI pane content. + * Returns an InteractivePrompt if one is detected, null otherwise. + */ + private _detectPrompt(content: string): InteractivePrompt | null { + // Command/File/Network Approval: "(y)" with proceed/run/make patterns + if ( + content.includes('(y)') && + (/proceed/i.test(content) || /Would you like to run/i.test(content) || /Would you like to make/i.test(content)) + ) { + const options = this._parseCodexOptions(content); + const lines = content.split('\n'); + const tail = lines.slice(-20); + const promptLine = tail.find(l => /proceed|\brun\b|\bmake\b/i.test(l)) || 'Approve action'; + const description = tail.join('\n').trim(); + return { + requestId: `codex-perm-${simpleHash(description)}`, + promptType: 'permission', + title: typeof promptLine === 'string' ? promptLine.trim() : 'Approve action', + description, + options: options.length > 0 ? options : [ + { value: 'y', label: 'Yes' }, + { value: 'n', label: 'No' }, + ], + }; + } + + // User Input: "enter to submit" AND "esc to cancel" (but NOT approval patterns) + if ( + /enter to submit/i.test(content) && + /esc to cancel/i.test(content) && + !content.includes('(y)') + ) { + const lines = content.split('\n'); + const tail = lines.slice(-20); + const options = this._parseCodexOptions(content); + const description = tail.join('\n').trim(); + if (options.length > 0) { + return { + requestId: `codex-ask-${simpleHash(description)}`, + promptType: 'question', + title: 'User Input', + description, + options, + }; + } + return { + requestId: `codex-ask-${simpleHash(description)}`, + promptType: 'question', + title: 'User Input', + description, + textInput: { placeholder: 'Type your response...' }, + }; + } + + return null; + } + + /** + * Parse Codex-style options from content. + * Matches patterns like "(y) Yes" or "(a) Always approve". + */ + private _parseCodexOptions(content: string): { value: string; label: string }[] { + const results: { value: string; label: string }[] = []; + const regex = /\(([a-z])\)\s+(.+?)(?:\n|$)/g; + let match: RegExpExecArray | null; + while ((match = regex.exec(content)) !== null) { + results.push({ value: match[1]!, label: match[2]!.trim() }); + } + return results; + } } // ============================================================================= diff --git a/server/adapters/gemini/gemini-tmux-adapter.ts b/server/adapters/gemini/gemini-tmux-adapter.ts index e1fa234..3e10ba5 100644 --- a/server/adapters/gemini/gemini-tmux-adapter.ts +++ b/server/adapters/gemini/gemini-tmux-adapter.ts @@ -19,6 +19,7 @@ import type { ReconnectState } from '../../types/adapter.js'; import type { ActiveSessionInfo } from '../interface.js'; import { isLargeContent } from '../interface.js'; import { PermissionManager } from '../../permission-manager.js'; +import { findActiveSession } from '../shared/find-active-session.js'; import { readFile } from 'fs/promises'; // --------------------------------------------------------------------------- @@ -116,12 +117,13 @@ export class GeminiTmuxAdapter extends EventEmitter { // === Session Lifecycle === - async startSession(cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string }> { + async startSession(cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string; pendingRekey?: boolean }> { const mode = options.permissionMode || 'default'; const parts = ['gemini', '--approval-mode', this._toCliApprovalMode(mode)]; if (options.model) parts.push('-m', options.model); const tempName = `gemini-${Date.now()}`; + console.log(`[gemini-tmux] startSession: tempName=${tempName} cwd=${cwd} mode=${mode}`); const windowId = await tmuxManager.createWindow(tempName, cwd, parts.join(' ')); // Register session BEFORE _waitForReady — SessionStart hook fires during @@ -137,14 +139,16 @@ export class GeminiTmuxAdapter extends EventEmitter { const rekeyed = [...this.sessions.entries()].find(([, s]) => s.windowId === windowId)?.[0]; if (rekeyed) { finalId = rekeyed; + console.log(`[gemini-tmux] startSession: rekeyed ${tempName} → ${rekeyed}`); } else { console.warn(`[gemini-tmux] Session ${tempName} vanished during startup (windowId=${windowId})`); } } + console.log(`[gemini-tmux] startSession: finalId=${finalId} pendingRekey=${finalId === tempName}`); this._startMonitor(finalId, windowId); - return { sessionId: finalId }; + return { sessionId: finalId, pendingRekey: finalId === tempName }; } async resumeSession(sessionId: string, cwd: string, options: QueryOptions = {}): Promise<{ sessionId: string }> { @@ -581,6 +585,27 @@ export class GeminiTmuxAdapter extends EventEmitter { await tmuxManager.sendKeys(session.windowId, answer, true); } + respondInteractivePrompt(requestId: string, selectedOption?: string, textValue?: string): void { + const pending = this._permissions.resolvePermission(requestId) + || this._permissions.resolveQuestion(requestId); + // For pane-monitor-detected prompts, there may be no pending entry — find session from active sessions + const sessionId = pending?.sessionId || findActiveSession(this.sessions); + if (!sessionId) return; + const session = this.sessions.get(sessionId); + if (!session) return; + + if (selectedOption != null) { + const index = parseInt(selectedOption); + if (!isNaN(index)) { + // Gemini numbered options: navigate Down × index, then Enter + this._selectNumberedOption(session.windowId, index).catch(() => {}); + } + } + if (textValue != null) { + tmuxManager.sendKeys(session.windowId, textValue, true).catch(() => {}); + } + } + /** Release all pending requests for a session */ releaseAllPending(sessionId: string): void { this._permissions.dismissAll(sessionId); @@ -598,6 +623,14 @@ export class GeminiTmuxAdapter extends EventEmitter { } } + private async _selectNumberedOption(windowId: string, targetIndex: number): Promise { + for (let i = 0; i < targetIndex; i++) { + await tmuxManager.sendControl(windowId, 'Down'); + await new Promise(r => setTimeout(r, 50)); + } + await tmuxManager.sendControl(windowId, 'Enter'); + } + // === Cleanup === async destroy(): Promise { @@ -662,7 +695,7 @@ export class GeminiTmuxAdapter extends EventEmitter { * Wait for Gemini CLI to be ready. * Polls tmux pane content until a prompt indicator appears. */ - private async _waitForReady(windowId: string, timeoutMs: number = 30000): Promise { + private async _waitForReady(windowId: string, timeoutMs: number = 60000): Promise { const start = Date.now(); let attempt = 0; while (Date.now() - start < timeoutMs) { @@ -670,17 +703,69 @@ export class GeminiTmuxAdapter extends EventEmitter { try { const content = await tmuxManager.capturePane(windowId); const lines = content.split('\n'); - // Gemini shows > or similar prompt indicator - const hasPrompt = lines.some(l => /^\s*[>❯]/.test(l)); - const lineCount = lines.filter(l => l.trim()).length; - if (attempt <= 3 || attempt % 5 === 0) { - console.log(`[gemini-tmux] waitForReady #${attempt}: window=${windowId} prompt=${hasPrompt} lines=${lineCount}`); - } - if (hasPrompt && lineCount >= 2) { + // Gemini shows > (default), * (yolo), or ❯ as prompt indicator + const hasPrompt = lines.some(l => /^\s*[>*❯]/.test(l)); + + if (hasPrompt) { console.log(`[gemini-tmux] CLI ready for ${windowId} in ${Date.now() - start}ms`); await new Promise(r => setTimeout(r, 300)); return; } + + // Privacy Notice or Terms of Service popup — dismiss with Esc + if (!hasPrompt && (content.includes('Privacy Notice') || + (content.includes('Terms of Service') && !content.includes('trust the files')))) { + console.log('[gemini-tmux] Privacy/ToS notice detected, dismissing'); + await tmuxManager.sendControl(windowId, 'Escape'); + await new Promise(r => setTimeout(r, 500)); + continue; + } + + // Multi-folder trust dialog ("trust the following folders") + if (!hasPrompt && content.includes('trust the following folders')) { + console.log('[gemini-tmux] Multi-folder trust detected, accepting'); + await tmuxManager.sendControl(windowId, 'Enter'); + await new Promise(r => setTimeout(r, 1000)); + continue; + } + + // IDE integration nudge — decline + if (!hasPrompt && content.includes('Do you want to connect') && content.includes('Gemini CLI')) { + console.log('[gemini-tmux] IDE nudge detected, declining'); + await tmuxManager.sendControl(windowId, 'Down'); + await new Promise(r => setTimeout(r, 50)); + await tmuxManager.sendControl(windowId, 'Enter'); + await new Promise(r => setTimeout(r, 500)); + continue; + } + + // Auto-accept folder trust prompt (Gemini asks on first use in a directory). + // Only runs when prompt is NOT yet visible. + if (content.includes('trust the files') && content.includes('Trust folder')) { + const parentMatch = content.match(/(\d+)\.\s+Trust parent folder/); + if (parentMatch) { + const targetOption = parseInt(parentMatch[1]); + console.log(`[gemini-tmux] Folder trust prompt detected, selecting option ${targetOption} (Trust parent folder)`); + for (let i = 1; i < targetOption; i++) { + await tmuxManager.sendControl(windowId, 'Down'); + await new Promise(r => setTimeout(r, 50)); + } + } else { + console.log(`[gemini-tmux] Folder trust prompt detected, accepting default (Trust folder)`); + } + await tmuxManager.sendControl(windowId, 'Enter'); + await new Promise(r => setTimeout(r, 1000)); + continue; + } + + if (attempt <= 3 || attempt % 5 === 0) { + const lineCount = lines.filter(l => l.trim()).length; + console.log(`[gemini-tmux] waitForReady #${attempt}: window=${windowId} prompt=${hasPrompt} lines=${lineCount}`); + if (lineCount > 0) { + const nonEmpty = lines.filter(l => l.trim()); + console.log(`[gemini-tmux] waitForReady content: first="${nonEmpty[0]?.substring(0, 60)}" last="${nonEmpty[nonEmpty.length - 1]?.substring(0, 60)}"`); + } + } } catch (err) { console.log(`[gemini-tmux] waitForReady #${attempt}: ERROR ${(err as Error).message}`); } diff --git a/server/adapters/gemini/index.ts b/server/adapters/gemini/index.ts index 7acd523..62ecc68 100644 --- a/server/adapters/gemini/index.ts +++ b/server/adapters/gemini/index.ts @@ -73,10 +73,10 @@ export class GeminiAdapter extends IAdapter { } setup(app: Express): void { - this.installHooks(); this._registerHookRoutes(app); } + setHookPort(port: number | string): void { this._hookConfig.port = port; } installHooks(): void { this._hookConfig.install(); } uninstallHooks(): void { this._hookConfig.uninstall(); } @@ -167,6 +167,7 @@ export class GeminiAdapter extends IAdapter { async switchPermissionMode(sid: string, mode: string): Promise { return this._tmux.switchPermissionMode(sid, mode); } respondPermission(reqId: string, behavior: PermissionBehavior): void { this._tmux.respondPermission(reqId, behavior); } async respondQuestion(reqId: string, answer: string): Promise { return this._tmux.respondQuestion(reqId, answer); } + respondInteractivePrompt(reqId: string, opt?: string, text?: string): void { this._tmux.respondInteractivePrompt(reqId, opt, text); } releaseAllPending(sid: string): void { this._tmux.releaseAllPending(sid); } resolveAllPendingAs(sid: string, behavior: PermissionBehavior): void { this._tmux.resolveAllPendingAs(sid, behavior); } diff --git a/server/adapters/gemini/json-store.ts b/server/adapters/gemini/json-store.ts index e068203..52d38ed 100644 --- a/server/adapters/gemini/json-store.ts +++ b/server/adapters/gemini/json-store.ts @@ -2,6 +2,7 @@ import { readdirSync, readFileSync, statSync } from 'fs'; import { join } from 'path'; import { homedir } from 'os'; import { extractUserText } from './message-utils.js'; +import { stripMarker } from '../shared/content-utils.js'; import type { DirectoryEntry } from '../interface.js'; import type { SessionInfo } from '../../types/adapter.js'; @@ -123,7 +124,7 @@ export function getSessions(dir?: string, limit?: number): SessionInfo[] { if (m.type === 'user' && m.content != null) { const text = extractUserText(m.content); if (text.trim()) { - firstPrompt = text.slice(0, 200); + firstPrompt = stripMarker(text).slice(0, 200); break; } } @@ -223,7 +224,6 @@ export function getSessionMessages( const projectName = getProjectName(dir); if (projectName) { const chatsDir = join(GEMINI_TMP_DIR, projectName, 'chats'); - // Try exact match first, then scan try { const files = readdirSync(chatsDir); for (const file of files) { @@ -245,6 +245,8 @@ export function getSessionMessages( // chats dir not readable } } + // Fallback: project name mapping failed — scan all projects + if (!filePath) filePath = findSessionFile(sessionId); } else { filePath = findSessionFile(sessionId); } diff --git a/server/adapters/gemini/pane-monitor.ts b/server/adapters/gemini/pane-monitor.ts index 6cd2629..f35a758 100644 --- a/server/adapters/gemini/pane-monitor.ts +++ b/server/adapters/gemini/pane-monitor.ts @@ -16,6 +16,16 @@ // that will be refined through empirical testing with the actual Gemini CLI. import { EventEmitter } from 'events'; +import { InteractivePrompt } from '../../types/messages.js'; + +function simpleHash(str: string): string { + let hash = 0; + for (let i = 0; i < str.length; i++) { + hash = ((hash << 5) - hash) + str.charCodeAt(i); + hash |= 0; + } + return Math.abs(hash).toString(36); +} /** Minimal interface for the tmux manager dependency */ interface TmuxCapture { @@ -44,6 +54,7 @@ export class GeminiPaneMonitor { private interval: ReturnType | null = null; private _lastContent: string = ''; private _lastResponseText: string = ''; + private lastPromptId: string | null = null; constructor( sessionId: string, @@ -86,6 +97,20 @@ export class GeminiPaneMonitor { if (content === this._lastContent) return; this._lastContent = content; + const lines = content.split('\n'); + + // 0. Check for interactive prompt (highest priority) + const prompt = this._detectPrompt(content, lines); + if (prompt) { + if (prompt.requestId !== this.lastPromptId) { + this.lastPromptId = prompt.requestId; + this.emitter.emit('interactive-prompt', this.sessionId, prompt); + } + return; // Don't process streaming while prompt is showing + } else if (this.lastPromptId) { + this.lastPromptId = null; + } + // 1. Check for thinking indicator const thinking = detectThinking(content); if (thinking) { @@ -103,6 +128,103 @@ export class GeminiPaneMonitor { // Silently ignore — tmux window may have been killed } } + + /** + * Detect an interactive prompt in the Gemini CLI pane content. + * Returns an InteractivePrompt if one is detected, null otherwise. + */ + private _detectPrompt(content: string, _lines: string[]): InteractivePrompt | null { + // Tool Confirmation: "Action Required" with numbered options + if (content.includes('Action Required') && /●\s+\d+\./.test(content)) { + const description = this._extractBetween(content, 'Action Required', '●'); + const options = this._parseNumberedOptions(content); + return { + requestId: `gemini-perm-${simpleHash(description)}`, + promptType: 'permission', + title: 'Action Required', + description: description.trim(), + options, + }; + } + + // Plan Approval: "Approval" with "Yes" and "feedback" + if (content.includes('Approval') && /Yes/.test(content) && /feedback/i.test(content)) { + const description = this._extractBetween(content, 'Approval', '●'); + const options = this._parseNumberedOptions(content); + return { + requestId: `gemini-plan-${simpleHash(description)}`, + promptType: 'plan', + title: 'Plan Approval', + description: description.trim(), + options, + textInput: { placeholder: 'Provide feedback...' }, + }; + } + + // AskUser: "Answer Questions" + if (content.includes('Answer Questions')) { + const description = this._extractBetween(content, 'Answer Questions', '●'); + const options = this._parseNumberedOptions(content); + if (options.length > 0) { + return { + requestId: `gemini-ask-${simpleHash(description)}`, + promptType: 'question', + title: 'Answer Questions', + description: description.trim(), + options, + }; + } + return { + requestId: `gemini-ask-${simpleHash(description)}`, + promptType: 'question', + title: 'Answer Questions', + description: description.trim(), + textInput: { placeholder: 'Type your answer...' }, + }; + } + + // Loop Detection: "potential loop was detected" + if (content.includes('potential loop was detected')) { + const options = this._parseNumberedOptions(content); + return { + requestId: `gemini-loop-${simpleHash('loop-detected')}`, + promptType: 'loop-detected', + title: 'Loop Detected', + description: 'A potential loop was detected.', + options, + }; + } + + return null; + } + + /** + * Parse numbered options from Gemini CLI content. + * Matches patterns like "● 1. Allow this action" or "1. Allow this action". + * Returns 0-based index values. + */ + private _parseNumberedOptions(content: string): { value: string; label: string }[] { + const results: { value: string; label: string }[] = []; + const regex = /(?:●\s+)?(\d+)\.\s+(.+?)(?:\n|$)/g; + let match: RegExpExecArray | null; + while ((match = regex.exec(content)) !== null) { + const index = parseInt(match[1]!, 10); + results.push({ value: String(index - 1), label: match[2]!.trim() }); + } + return results; + } + + /** + * Extract text between two markers in the content. + */ + private _extractBetween(content: string, start: string, end: string): string { + const startIdx = content.indexOf(start); + if (startIdx === -1) return ''; + const afterStart = startIdx + start.length; + const endIdx = content.indexOf(end, afterStart); + if (endIdx === -1) return content.slice(afterStart).trim(); + return content.slice(afterStart, endIdx).trim(); + } } // ============================================================================= @@ -178,7 +300,7 @@ export function extractResponseText(content: string): string { // Gemini user prompt patterns (conservative): // - ">" or "❯" at start of line followed by user text // - "user:" prefix - if (/^\s*[>❯]\s+\S/.test(line) || /^\s*user:\s/i.test(line)) { + if (/^\s*[>*❯]\s+\S/.test(line) || /^\s*user:\s/i.test(line)) { lastUserPrompt = i; break; } @@ -204,7 +326,7 @@ export function extractResponseText(content: string): string { // Horizontal rules /^[─━═\-]{5,}/.test(line.trim()) || // New user prompt - /^\s*[>❯]\s+\S/.test(line) || + /^\s*[>*❯]\s+\S/.test(line) || // Spinner/thinking indicators (braille set) /^\s*[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/.test(line) ) { diff --git a/server/adapters/interface.ts b/server/adapters/interface.ts index e874e35..0a81bc6 100644 --- a/server/adapters/interface.ts +++ b/server/adapters/interface.ts @@ -92,7 +92,7 @@ export class IAdapter extends EventEmitter { // --- Session Lifecycle --- - async startSession(cwd: string, options?: QueryOptions): Promise<{ sessionId: string }> { throw new Error('Not implemented: startSession'); } + async startSession(cwd: string, options?: QueryOptions): Promise<{ sessionId: string; pendingRekey?: boolean }> { throw new Error('Not implemented: startSession'); } async resumeSession(sessionId: string, cwd: string, options?: QueryOptions): Promise<{ sessionId: string }> { throw new Error('Not implemented: resumeSession'); } async attachSession(sessionId: string, cwd: string, options?: QueryOptions): Promise<{ sessionId: string }> { throw new Error('Not implemented: attachSession'); } async destroySession(sessionId: string): Promise { throw new Error('Not implemented: destroySession'); } @@ -155,10 +155,14 @@ export class IAdapter extends EventEmitter { // --- Hooks --- + /** Update the port used by hooks (called when port fallback changes the port). */ + setHookPort(port: number | string): void {} /** Install adapter-specific hooks (e.g., write to CLI settings). No server needed. */ installHooks(): void {} /** Remove adapter-specific hooks. No server needed. */ uninstallHooks(): void {} + /** Respond to an interactive prompt (permission, question, plan, etc). */ + respondInteractivePrompt(requestId: string, selectedOption?: string, textValue?: string): void {} // --- Lifecycle --- diff --git a/server/adapters/registry.ts b/server/adapters/registry.ts index 9440132..c30768f 100644 --- a/server/adapters/registry.ts +++ b/server/adapters/registry.ts @@ -75,6 +75,14 @@ export function initAll(app: Express): Map { return adapters; } +/** Install hooks with confirmed port (called after server.listen succeeds) */ +export function installAllHooks(port: number | string): void { + for (const [, adapter] of adapters) { + adapter.setHookPort(port); + adapter.installHooks(); + } +} + export function getAll(): Map { return adapters; } diff --git a/server/adapters/shared/ask-question-utils.ts b/server/adapters/shared/ask-question-utils.ts new file mode 100644 index 0000000..ffc45e3 --- /dev/null +++ b/server/adapters/shared/ask-question-utils.ts @@ -0,0 +1,18 @@ +/** Parse Claude's AskUserQuestion nested input structure into a flat format */ +export function parseAskQuestionInput(input: any): { + question: string; + header?: string; + options?: { label: string; value: string }[]; +} { + const q = input?.questions?.[0] || input || {}; + const question = q.question || q.text || input?.question || input?.text || ''; + const header = q.header; + const rawOpts = q.options || input?.options; + const options = Array.isArray(rawOpts) && rawOpts.length > 0 + ? rawOpts.map((o: any, i: number) => ({ + value: typeof o === 'string' ? String(i) : (o.value ?? String(i)), + label: typeof o === 'string' ? o : (o.label || o.text || `Option ${i + 1}`), + })) + : undefined; + return { question, header, options }; +} diff --git a/server/adapters/shared/content-utils.ts b/server/adapters/shared/content-utils.ts new file mode 100644 index 0000000..c86c8fc --- /dev/null +++ b/server/adapters/shared/content-utils.ts @@ -0,0 +1,6 @@ +/** Strip [CLAWTAP_REF:...] and [CODETAP_REF:...] markers from message text. */ +const MARKER_REGEX = /^(?:\[(?:CLAWTAP_REF|CODETAP_REF):[^\]]+\]|\d+\])(?:\\n|\n)?/; + +export function stripMarker(text: string): string { + return text.replace(MARKER_REGEX, ''); +} diff --git a/server/adapters/shared/find-active-session.ts b/server/adapters/shared/find-active-session.ts new file mode 100644 index 0000000..11655f7 --- /dev/null +++ b/server/adapters/shared/find-active-session.ts @@ -0,0 +1,20 @@ +/** + * Find the session most likely showing an interactive prompt. + * Checks for actively processing sessions first, then falls back to most recent. + */ +export function findActiveSession( + sessions: Map +): string | null { + for (const [id, session] of sessions) { + if (session.isProcessing) return id; + } + let latest: string | null = null; + let latestTime = 0; + for (const [id, session] of sessions) { + if (session.lastActivity && session.lastActivity > latestTime) { + latestTime = session.lastActivity; + latest = id; + } + } + return latest; +} diff --git a/server/config.ts b/server/config.ts index 00c09a7..7473117 100644 --- a/server/config.ts +++ b/server/config.ts @@ -22,12 +22,12 @@ export interface AppConfig { } export function loadConfig(): AppConfig { - const password = process.env.CLAUDE_UI_PASSWORD; + const password = process.env.CLAWTAP_PASSWORD; if (!password) { throw new Error( - 'CLAUDE_UI_PASSWORD is required.\n' + + 'CLAWTAP_PASSWORD is required.\n' + 'Set it and try again:\n' + - ' export CLAUDE_UI_PASSWORD=your-password' + ' export CLAWTAP_PASSWORD=your-password' ); } diff --git a/server/db.ts b/server/db.ts index 90f6acd..e3bab94 100644 --- a/server/db.ts +++ b/server/db.ts @@ -61,6 +61,11 @@ export function initDB(config: AppConfig): void { ); CREATE INDEX IF NOT EXISTS idx_reviews_parent ON session_reviews(parent_cli_session_id); + CREATE TABLE IF NOT EXISTS session_adapters ( + session_id TEXT PRIMARY KEY, + adapter TEXT NOT NULL + ); + CREATE TABLE IF NOT EXISTS saved_instructions ( id TEXT PRIMARY KEY, label TEXT NOT NULL, @@ -122,6 +127,8 @@ interface PreparedStatements { instructionCreate: BetterSqlite3.Statement; instructionGetAll: BetterSqlite3.Statement; instructionDelete: BetterSqlite3.Statement; + sessionAdapterSet: BetterSqlite3.Statement; + sessionAdapterGet: BetterSqlite3.Statement; } let _stmts: PreparedStatements | null = null; @@ -202,6 +209,12 @@ function stmts(): PreparedStatements { instructionDelete: d.prepare( `DELETE FROM saved_instructions WHERE id = ?` ), + sessionAdapterSet: d.prepare( + `INSERT OR REPLACE INTO session_adapters (session_id, adapter) VALUES (?, ?)` + ), + sessionAdapterGet: d.prepare( + `SELECT adapter FROM session_adapters WHERE session_id = ?` + ), }; } return _stmts; @@ -284,6 +297,18 @@ export const preferences = { // --- Session Review Operations --- +// --- Session → Adapter Mapping (persists across restarts) --- + +export const sessionAdapters = { + set(sessionId: string, adapter: string): void { + stmts().sessionAdapterSet.run(sessionId, adapter); + }, + get(sessionId: string): string | null { + const row = stmts().sessionAdapterGet.get(sessionId) as { adapter: string } | undefined; + return row?.adapter ?? null; + }, +}; + let _childIdCache: Set | null = null; export const sessionReviews = { diff --git a/server/index.ts b/server/index.ts index c7f2dbe..072f03e 100644 --- a/server/index.ts +++ b/server/index.ts @@ -12,7 +12,7 @@ import { authMiddleware, } from './auth.js'; import './adapters/init.js'; -import { initAll, listAvailable, get as getAdapter, getAll as getAllAdapters, cleanupAll, DEFAULT_ADAPTER } from './adapters/registry.js'; +import { initAll, installAllHooks, listAvailable, get as getAdapter, getAll as getAllAdapters, cleanupAll, DEFAULT_ADAPTER } from './adapters/registry.js'; import { initPush, getVapidPublicKey, saveSubscription, removeSubscription, getPendingSessions } from './push.js'; import { setupSessionManager, @@ -25,7 +25,7 @@ import { import { WebSocketTransport } from './transport/websocket-transport.js'; import { loadConfig } from './config.js'; import type { AppConfig } from './config.js'; -import { initDB, closeDB, sessionReviews, savedInstructions } from './db.js'; +import { initDB, closeDB, sessionReviews, sessionAdapters, savedInstructions } from './db.js'; const __dirname = dirname(fileURLToPath(import.meta.url)); @@ -99,6 +99,10 @@ async function start(): Promise { ) ); const allSessions = results.flat(); + // Persist session→adapter mapping so server knows which adapter owns each session + for (const s of allSessions) { + if (s.sessionId && s.adapter) sessionAdapters.set(s.sessionId, s.adapter); + } allSessions.sort((a, b) => { const aTime = typeof a.lastModified === 'number' ? a.lastModified : new Date(a.lastModified || 0).getTime(); const bTime = typeof b.lastModified === 'number' ? b.lastModified : new Date(b.lastModified || 0).getTime(); @@ -251,9 +255,9 @@ async function start(): Promise { // Register a review after the child session is already created via QUERY app.post('/api/reviews/register', authMiddleware, async (req: Request, res: Response) => { try { - const { parentCliSessionId, childSessionId, targetAdapter, anchorMessageId, prompt, title } = req.body; - if (!parentCliSessionId || !childSessionId) { - return res.status(400).json({ error: 'parentCliSessionId and childSessionId required' }); + const { reviewId, parentCliSessionId, childSessionId, targetAdapter, anchorMessageId, prompt, title } = req.body; + if (!reviewId || !parentCliSessionId || !childSessionId) { + return res.status(400).json({ error: 'reviewId, parentCliSessionId and childSessionId required' }); } // Find which adapter owns the parent session @@ -262,7 +266,6 @@ async function start(): Promise { if (a.getSession(parentCliSessionId)) { parentAdapterName = name; break; } } - const reviewId = randomUUID(); sessionReviews.create(reviewId, parentCliSessionId, childSessionId, targetAdapter, parentAdapterName, anchorMessageId, prompt, title); // Ensure adapter mapping exists for the child session @@ -436,21 +439,49 @@ async function start(): Promise { } }); - // Initialize all adapters (registers hook routes, configures CLI hooks) + // Register adapter routes (before listen — routes don't depend on port) initAll(app); setupSessionManager(); - // --- Initialize and Listen --- + // --- Find available port and Listen --- await initAuth(config); initPush(config); - writeFileSync(config.paths.pid, String(process.pid)); + const protocol = config.https ? 'https' : 'http'; - server.listen(config.port, '0.0.0.0', () => { - console.log(`ClawTap running on ${protocol}://0.0.0.0:${config.port}${config.https ? ' (HTTPS)' : ''}`); + const actualPort = await new Promise((resolve, reject) => { + const maxRetries = 10; + let attempt = 0; + function tryListen(port: number) { + const onError = (err: NodeJS.ErrnoException) => { + if (err.code === 'EADDRINUSE' && attempt < maxRetries) { + attempt++; + const nextPort = port + 1; + console.log(`Port ${port} in use, trying ${nextPort}...`); + server.close(() => tryListen(nextPort)); + } else { + reject(err); + } + }; + server.once('error', onError); + server.listen(port, '0.0.0.0', () => { + server.removeListener('error', onError); + resolve(port); + }); + } + tryListen(config.port); }); + // Update config with actual port (may differ if fallback occurred) + config.port = actualPort; + + // Install hooks AFTER port is confirmed (hooks embed the port in CLI configs) + installAllHooks(actualPort); + + writeFileSync(config.paths.pid, String(process.pid)); + console.log(`ClawTap running on ${protocol}://0.0.0.0:${actualPort}${config.https ? ' (HTTPS)' : ''}`); + // --- Graceful Shutdown --- async function shutdown(signal: string): Promise { diff --git a/server/session-manager.ts b/server/session-manager.ts index 2c92d18..030d6a1 100644 --- a/server/session-manager.ts +++ b/server/session-manager.ts @@ -5,7 +5,8 @@ import type { ClientMessage, QueryOptions, PermissionBehavior } from './types/me import { sendPush, incrementPending, clearPending, getPendingSessions } from './push.js'; import { basename } from 'path'; import type { ClientConnection } from './transport/client-connection.js'; -import { sessionReviews } from './db.js'; +import { sessionReviews, sessionAdapters } from './db.js'; +import { parseAskQuestionInput } from './adapters/shared/ask-question-utils.js'; /** Push notification options */ interface PushOptions { @@ -94,14 +95,48 @@ export function setupSessionManager(): void { triggerPush(adapter, sessionId, { title: 'Claude finished', body: 'Turn complete', tagPrefix: 'idle' }); }); - adapter.on('permission-request', (sessionId: string, data: { toolName?: string; [key: string]: unknown }) => { - broadcast(sessionId, { type: WS.PERMISSION_REQUEST, ...data }); + adapter.on('permission-request', (sessionId: string, data: { requestId?: string; toolName?: string; input?: any; [key: string]: unknown }) => { + // Convert legacy Claude hook event to InteractivePrompt format + broadcast(sessionId, { + type: WS.INTERACTIVE_PROMPT, + requestId: data.requestId || `perm-${Date.now()}`, + promptType: 'permission', + title: 'Permission Request', + description: `${data.toolName || 'Tool'} wants to execute`, + toolName: data.toolName, + toolInput: data.input, + options: [ + { value: 'allow', label: 'Allow' }, + { value: 'allow_session', label: 'Allow All' }, + { value: 'deny', label: 'Deny' }, + ], + }); triggerPush(adapter, sessionId, { title: 'Permission needed', body: data.toolName || 'tool', tagPrefix: 'perm' }); }); - adapter.on('ask-question', (sessionId: string, data: { toolName?: string; [key: string]: unknown }) => { - broadcast(sessionId, { type: WS.PERMISSION_REQUEST, ...data }); - triggerPush(adapter, sessionId, { title: 'Question from Claude', body: 'Waiting for answer', tagPrefix: 'ask' }); + adapter.on('ask-question', (sessionId: string, data: { requestId?: string; toolName?: string; input?: any; [key: string]: unknown }) => { + const parsed = parseAskQuestionInput(data.input || {}); + broadcast(sessionId, { + type: WS.INTERACTIVE_PROMPT, + requestId: data.requestId || `ask-${Date.now()}`, + promptType: 'question', + title: parsed.header || 'Question', + description: parsed.question, + toolName: 'AskUserQuestion', + toolInput: data.input || {}, + options: parsed.options, + textInput: parsed.options ? undefined : { placeholder: 'Enter your response...' }, + }); + triggerPush(adapter, sessionId, { title: 'Question', body: questionText.substring(0, 50) || 'Waiting for answer', tagPrefix: 'ask' }); + }); + + adapter.on('interactive-prompt', (sessionId: string, prompt: any) => { + broadcast(sessionId, { type: WS.INTERACTIVE_PROMPT, ...prompt }); + const pushTitle = prompt.promptType === 'permission' ? 'Permission needed' + : prompt.promptType === 'question' ? 'Question' + : prompt.promptType === 'plan' ? 'Plan approval' + : 'Action needed'; + triggerPush(adapter, sessionId, { title: pushTitle, body: prompt.title || '', tagPrefix: 'prompt' }); }); adapter.on('status-update', (sessionId: string, status: Record) => { @@ -181,15 +216,12 @@ export function setupSessionManager(): void { } // Update any active reviews that reference the old key as child (FIX 3) sessionReviews.updateChildCliId(oldKey, newKey); - // Send updated SESSION_CREATED so frontend knows the real ID + // Send SESSION_CREATED with the real UUID — for pendingRekey adapters, + // this is the ONLY SESSION_CREATED the client receives. const resolvedAdapter = getAdapter(adapterName || DEFAULT_ADAPTER); if (resolvedAdapter && clients) { for (const conn of clients) { - send(conn, { - type: WS.SESSION_CREATED, - sessionId: newKey, - permissionMode: (resolvedAdapter.getSession(newKey) as any)?.permissionMode || (resolvedAdapter.getSession(newKey) as any)?.approvalPolicy, - }); + sendSessionCreated(conn, resolvedAdapter, newKey); } } }); @@ -204,20 +236,60 @@ export function setupSessionManager(): void { // === Helper: resolve adapter for a session === -function getAdapterForSession(conn: ClientConnection, sessionId?: string): { adapter: IAdapter | undefined; sid: string } { +/** + * Resolve which adapter owns a session. + * 1. In-memory map (fastest, covers active sessions) + * 2. SQLite (populated when /api/sessions is fetched, survives restarts) + * 3. Probe each adapter with getMessages (one-time cost, then cached) + * Returns null if no adapter recognizes the session. + */ +async function resolveAdapterForSession(sessionId: string): Promise { + // 1. Memory + const mapped = sessionAdapterMap.get(sessionId); + if (mapped) return mapped; + + // 2. SQLite + const persisted = sessionAdapters.get(sessionId); + if (persisted) { + sessionAdapterMap.set(sessionId, persisted); + return persisted; + } + + // 3. Probe each adapter — runs once per unknown session, then cached + for (const [name, adapter] of getAllAdapters()) { + try { + const { messages } = await adapter.getMessages(sessionId); + if (messages.length > 0) { + sessionAdapterMap.set(sessionId, name); + sessionAdapters.set(sessionId, name); + return name; + } + } catch (err) { + console.warn(`[resolveAdapter] probe ${name} for ${sessionId.slice(0, 8)} failed:`, (err as Error).message); + } + } + + return null; +} + +async function getAdapterForSession(conn: ClientConnection, sessionId?: string): Promise<{ adapter: IAdapter | undefined; sid: string }> { const sid = sessionId || conn.sessionId || ''; - const name = sessionAdapterMap.get(sid) || DEFAULT_ADAPTER; - return { adapter: getAdapter(name), sid }; + const name = await resolveAdapterForSession(sid); + return { adapter: name ? getAdapter(name) : undefined, sid }; } function sendSessionCreated(conn: ClientConnection, adapter: IAdapter, sessionId: string): void { const sessionObj = adapter.getSession(sessionId) as { permissionMode?: string; approvalPolicy?: string; + cwd?: string; } | null; + const adapterName = sessionAdapterMap.get(sessionId) || sessionAdapters.get(sessionId); send(conn, { type: WS.SESSION_CREATED, sessionId, + adapter: adapterName, + cwd: sessionObj?.cwd, permissionMode: sessionObj?.permissionMode || sessionObj?.approvalPolicy, }); } @@ -238,13 +310,18 @@ export async function handleIncomingMessage(conn: ClientConnection, msg: ClientM case WS.ABORT: return handleAbort(conn, msg.sessionId as string | undefined); case WS.RECONNECT: - return handleReconnect(conn, msg.sessionId as string | undefined, msg.adapter as string | undefined); + return handleReconnect(conn, msg.sessionId as string | undefined); case WS.SET_PERMISSION_MODE: return handleSetPermissionMode(conn, msg.sessionId as string, msg.mode as string); case WS.SET_MODEL: return handleSetModel(conn, msg.sessionId as string, msg.model as string); case WS.PLAN_RESPONSE: return handlePlanResponse(conn, msg.sessionId as string, msg.optionIndex as number, msg.text as string | undefined); + case WS.PROMPT_RESPONSE: + return handlePromptResponse(conn, msg.requestId as string, { + selectedOption: msg.selectedOption as string | undefined, + textValue: msg.textValue as string | undefined, + }); default: conn.send({ type: 'error', error: `Unknown message type: ${msg.type}` }); } @@ -253,20 +330,29 @@ export async function handleIncomingMessage(conn: ClientConnection, msg: ClientM // === Message Handlers === export async function handleQuery(conn: ClientConnection, prompt: string, options: QueryOptions): Promise { - const { cwd, model, sessionId, permissionMode, images, adapter: adapterName } = options; - const adapter = getAdapter(adapterName || DEFAULT_ADAPTER); + let { cwd, model, sessionId, permissionMode, images, adapter: adapterName } = options; + let adapter = getAdapter(adapterName || DEFAULT_ADAPTER); if (!adapter) throw new Error(`Unknown adapter: ${adapterName}`); - let handle: { sessionId: string }; + let handle: { sessionId: string; pendingRekey?: boolean }; if (sessionId) { + const resolvedName = await resolveAdapterForSession(sessionId); + if (resolvedName && resolvedName !== (adapterName || DEFAULT_ADAPTER)) { + adapter = getAdapter(resolvedName)!; + adapterName = resolvedName; + } handle = await adapter.resumeSession(sessionId, cwd as string, { permissionMode }); } else { handle = await adapter.startSession(cwd || process.cwd(), { model, permissionMode }); } - sessionAdapterMap.set(handle.sessionId, adapterName || DEFAULT_ADAPTER); + registerSessionAdapter(handle.sessionId, adapterName || DEFAULT_ADAPTER); registerClient(conn, handle.sessionId); - sendSessionCreated(conn, adapter, handle.sessionId); + // Adapters with pendingRekey (Codex/Gemini) don't get SESSION_CREATED here — + // the session-rekeyed handler sends it after rekey with the real UUID. + if (!handle.pendingRekey) { + sendSessionCreated(conn, adapter, handle.sessionId); + } // Send the message (images sent as text description for now) let messageText = prompt; @@ -280,8 +366,8 @@ export async function handleQuery(conn: ClientConnection, prompt: string, option await adapter.sendMessage(handle.sessionId, messageText, { clientId: conn.clientId }); } -export function handlePermissionResponse(conn: ClientConnection, requestId: string, response: { behavior: PermissionBehavior; alwaysAllow?: boolean }): void { - const { adapter, sid } = getAdapterForSession(conn); +export async function handlePermissionResponse(conn: ClientConnection, requestId: string, response: { behavior: PermissionBehavior; alwaysAllow?: boolean }): Promise { + const { adapter, sid } = await getAdapterForSession(conn); if (adapter) { adapter.respondPermission(requestId, response.behavior); broadcast(sid, { type: WS.PERMISSION_DISMISSED, requestId }); @@ -289,20 +375,28 @@ export function handlePermissionResponse(conn: ClientConnection, requestId: stri } export async function handleAskResponse(conn: ClientConnection, requestId: string, answers: string): Promise { - const { adapter, sid } = getAdapterForSession(conn); + const { adapter, sid } = await getAdapterForSession(conn); if (adapter) { adapter.respondQuestion(requestId, answers); broadcast(sid, { type: WS.PERMISSION_DISMISSED, requestId }); } } +export async function handlePromptResponse(conn: ClientConnection, requestId: string, response: { selectedOption?: string; textValue?: string }): Promise { + const { adapter, sid } = await getAdapterForSession(conn); + if (adapter) { + adapter.respondInteractivePrompt(requestId, response.selectedOption, response.textValue); + broadcast(sid, { type: WS.PROMPT_DISMISSED, requestId }); + } +} + export async function handleAbort(conn: ClientConnection, sessionId?: string): Promise { - const { adapter, sid } = getAdapterForSession(conn, sessionId); + const { adapter, sid } = await getAdapterForSession(conn, sessionId); if (sid && adapter) await adapter.interrupt(sid); } export async function handlePlanResponse(conn: ClientConnection, sessionId: string, optionIndex: number, text?: string): Promise { - const { adapter, sid } = getAdapterForSession(conn, sessionId); + const { adapter, sid } = await getAdapterForSession(conn, sessionId); if (!sid || !adapter) return; await adapter.respondPlan(sid, optionIndex, text); // Broadcast synthetic user message so plan card transitions to read-only on ALL clients @@ -312,17 +406,17 @@ export async function handlePlanResponse(conn: ClientConnection, sessionId: stri broadcast(sid, { type: WS.MESSAGE_COMPLETE, messages: [{ role: 'user', content: msg }] }); } -export async function handleReconnect(conn: ClientConnection, sessionId?: string, adapterHint?: string): Promise { +export async function handleReconnect(conn: ClientConnection, sessionId?: string): Promise { if (!sessionId) return; - // Resolve rekey alias (Codex temp key → real UUID) const resolvedId = rekeyAliases.get(sessionId) || sessionId; - const adapterName = sessionAdapterMap.get(resolvedId) || adapterHint || DEFAULT_ADAPTER; + const adapterName = await resolveAdapterForSession(resolvedId); + if (!adapterName) return; const adapter = getAdapter(adapterName); if (!adapter) return; - registerClient(conn, sessionId); // registerClient also resolves alias internally + registerClient(conn, sessionId); sessionAdapterMap.set(resolvedId, adapterName); // Clear pending push notifications for this session and update badge (only if there were pending) @@ -374,8 +468,6 @@ export async function handleReconnect(conn: ClientConnection, sessionId?: string const childAdapterObj = getAdapter(review.child_adapter); if (!childAdapterObj) continue; - // Check if child session still exists in adapter's in-memory Map. - // If not (server restarted or windows killed), mark review as ended. if (!childAdapterObj.getSession(review.child_cli_session_id)) { sessionReviews.endReview(review.id); continue; @@ -397,14 +489,14 @@ export async function handleReconnect(conn: ClientConnection, sessionId?: string } export async function handleSetModel(conn: ClientConnection, sessionId: string, model: string): Promise { - const { adapter, sid } = getAdapterForSession(conn, sessionId); + const { adapter, sid } = await getAdapterForSession(conn, sessionId); if (adapter && sid) { await adapter.switchModel(sid, model); } } export async function handleSetPermissionMode(conn: ClientConnection, sessionId: string, mode: string): Promise { - const { adapter, sid } = getAdapterForSession(conn, sessionId); + const { adapter, sid } = await getAdapterForSession(conn, sessionId); if (!sid || !adapter) return; const success = await adapter.switchPermissionMode(sid, mode); @@ -512,4 +604,5 @@ export function getClientCount(sessionId: string): number { export function registerSessionAdapter(sessionId: string, adapterName: string): void { sessionAdapterMap.set(sessionId, adapterName); + sessionAdapters.set(sessionId, adapterName); } diff --git a/server/types/messages.ts b/server/types/messages.ts index 893b619..51ba11b 100644 --- a/server/types/messages.ts +++ b/server/types/messages.ts @@ -65,3 +65,20 @@ export interface SessionStatus { model: string; cost: number; } + +export interface InteractivePrompt { + requestId: string; + promptType: 'permission' | 'question' | 'plan' | 'loop-detected'; + title: string; + description: string; + toolName?: string; + toolInput?: any; + options?: { value: string; label: string }[]; + textInput?: { placeholder?: string }; +} + +export interface PromptResponse { + requestId: string; + selectedOption?: string; + textValue?: string; +} diff --git a/server/ws-types.ts b/server/ws-types.ts index 2f902ac..66f3a74 100644 --- a/server/ws-types.ts +++ b/server/ws-types.ts @@ -30,6 +30,10 @@ export const WS = { CLIENT_ID: 'client-id', PENDING_NOTIFICATIONS: 'pending-notifications', ERROR: 'error', + // Interactive Prompts (unified permission/question/plan overlay) + INTERACTIVE_PROMPT: 'interactive-prompt', + PROMPT_RESPONSE: 'prompt-response', + PROMPT_DISMISSED: 'prompt-dismissed', // Cross-AI Review REVIEW_STARTED: 'review-started', REVIEW_ENDED: 'review-ended', diff --git a/src/App.tsx b/src/App.tsx index 52f7aa9..d3a0536 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -38,11 +38,13 @@ function persistView(view: View) { function navigateTo(view: View) { persistView(view); - const url = view.name === 'chat' && view.sessionId - ? `/?view=chat&session=${view.sessionId}` - : view.name === 'settings' - ? '/?view=settings' - : '/'; + let url = '/'; + if (view.name === 'chat' && view.sessionId) { + url = `/?view=chat&session=${view.sessionId}`; + if (view.adapter) url += `&adapter=${view.adapter}`; + } else if (view.name === 'settings') { + url = '/?view=settings'; + } window.history.pushState({ view }, '', url); } @@ -208,7 +210,8 @@ export function App() { const action = params.get('action'); if (sessionId) { urlParamsHandled.current = true; - openChat(sessionId); + const adapter = params.get('adapter'); + openChat(sessionId, undefined, adapter || undefined); window.history.replaceState({}, '', '/'); } else if (action === 'newchat') { urlParamsHandled.current = true; diff --git a/src/components/AskQuestion.tsx b/src/components/AskQuestion.tsx deleted file mode 100644 index 5a0a82c..0000000 --- a/src/components/AskQuestion.tsx +++ /dev/null @@ -1,64 +0,0 @@ -import { useState } from 'react'; -import { Button } from './ui/button'; -import { Send } from 'lucide-react'; - -export function AskQuestion({ toolUseId, input, onRespond }: { - toolUseId: string; input: any; onRespond: (toolUseId: string, response: string) => void; -}) { - const [customText, setCustomText] = useState(''); - const [showCustom, setShowCustom] = useState(false); - const [answered, setAnswered] = useState(false); - // SDK AskUserQuestion uses questions[0].question/options structure - const firstQ = input?.questions?.[0]; - const question = firstQ?.question || input?.question || input?.text || 'Choose an option'; - const options: Array<{ value: string; label: string; description?: string }> = firstQ?.options || input?.options || input?.choices || []; - - function select(value: string) { if (answered) return; setAnswered(true); onRespond(toolUseId, value); } - function submitCustom() { if (!customText.trim() || answered) return; setAnswered(true); onRespond(toolUseId, customText.trim()); } - - if (answered) return ( -
-

Question answered

-
- ); - - return ( -
-

{question}

-
- {options.map((opt, i) => ( - - ))} - {!showCustom ? ( - - ) : ( -
- setCustomText(e.target.value)} - onKeyDown={(e) => e.key === 'Enter' && submitCustom()} - placeholder="Type your answer..." - className="flex-1 bg-bg border border-border rounded-md px-3 py-2 text-text text-sm focus:outline-none focus:border-accent" - autoFocus - /> - -
- )} -
-
- ); -} diff --git a/src/components/ChatBody.tsx b/src/components/ChatBody.tsx index ff6d402..98ad259 100644 --- a/src/components/ChatBody.tsx +++ b/src/components/ChatBody.tsx @@ -146,7 +146,7 @@ export function ChatBody({ : isLastAssistant && interrupted ? 'interrupted' : 'success'; elements.push( - , + , ); } } diff --git a/src/components/ChatView.tsx b/src/components/ChatView.tsx index 6a3367b..f1408fe 100644 --- a/src/components/ChatView.tsx +++ b/src/components/ChatView.tsx @@ -1,9 +1,8 @@ import React, { useState, useRef, useEffect, useCallback, useMemo, Fragment, type RefObject } from 'react'; import { useChat } from '../hooks/useChat'; import { PLAN_OPTION } from '../lib/ws-types'; -import { PermissionOverlay } from './PermissionOverlay'; +import { InteractivePromptOverlay } from './InteractivePromptOverlay'; import { StatusBar } from './StatusBar'; -import { AskQuestion } from './AskQuestion'; import { PlanMode } from './PlanMode'; import { ChatBody } from './ChatBody'; import { FloatingReviewPanel, type ReviewPanelHandle } from './FloatingReviewPanel'; @@ -11,11 +10,11 @@ import { ReviewActionMenu } from './ReviewActionMenu'; import { SendToExistingSheet } from './SendToExistingSheet'; import { CollapsedReviewCard } from './CollapsedReviewCard'; import { BlockMarker } from './BlockMarker'; -import { BottomSheet } from './BottomSheet'; import { api } from '../lib/api'; import { getBrand } from '../lib/adapter-brands'; import { extractTextFromBlocks } from '../lib/content-utils'; import { patchAdapterPrefs } from '../lib/adapter-prefs'; +import { LoadingAnimation } from './ui/LoadingAnimation'; import { Button } from './ui/button'; import { Badge } from './ui/badge'; import { ChevronLeft, Copy, Check, X } from 'lucide-react'; @@ -140,11 +139,11 @@ export function ChatView({ const { messages, toolStatuses, streaming, pendingResponse, wsStatus, sessionId, liveStatus, - interrupted, sessionStatus, adapterConfig, selectedAdapter, permissionRequest, model, permissionMode, + interrupted, sessionStatus, adapterConfig, selectedAdapter, interactivePrompt, model, permissionMode, queuedMessage, clearQueuedMessage, activeReviews, setActiveReviews, activeReviewPanel, setActiveReviewPanel, historyReview, setHistoryReview, - sendMessage, respondPermission, respondAsk, respondPlan, abort, + sendMessage, respondPrompt, respondPlan, abort, updateModel, updatePermissionMode, } = useChat(initialSessionId, cwd, adapter, initialPrompt); @@ -189,22 +188,13 @@ export function ChatView({ // Shared cleanup for ending/closing an active review const closeReview = useCallback(async (reviewId?: string) => { - // Empty reviewId means the pending tab's close button — just cancel it - if (reviewId === '') { - setPendingReview(null); - return; - } const targetId = reviewId || activeReviews[0]?.reviewId; if (!targetId) return; - - const lastMsg = messages[messages.length - 1]; - const endAnchorMessageId = lastMsg?.id || undefined; - - try { await api.endReview(targetId, endAnchorMessageId); } catch {} - setActiveReviews(prev => prev.filter(r => r.reviewId !== targetId)); setHistoryReview(null); - setPendingReview(null); + const lastMsg = messages[messages.length - 1]; + const endAnchorMessageId = lastMsg?.id || undefined; + try { await api.endReview(targetId, endAnchorMessageId); } catch {} }, [activeReviews, messages]); // Close history panel only (does not affect active review) @@ -227,6 +217,7 @@ export function ChatView({ // New reviews added — batch into a single setReviews call const newReviews = activeReviews.filter(r => !prevIds.has(r.reviewId)); if (newReviews.length > 0) { + console.log(`[reviewSync] ${newReviews.length} new review(s):`, newReviews.map(r => `${r.reviewId.slice(0,8)} anchor=${r.anchorMessageId}`)); setReviews(prev => { const existingIds = new Set(prev.map(r => r.id)); const toAdd = newReviews @@ -303,23 +294,29 @@ export function ChatView({ const [saveToast, setSaveToast] = useState<{ instruction: string; label: string } | null>(null); - // Pending review: waiting for child session to be created (not yet in activeReviews) - const [pendingReview, setPendingReview] = useState<{ - childAdapter: string; - anchorMessageId: string; - reviewTitle: string; - prompt: string; - } | null>(null); - const openReview = useCallback((adapter: string, model: string, prompt: string, title: string) => { const anchorId = reviewMenuMessageId; setReviewMenuMessageId(null); if (!anchorId) return; + const reviewId = crypto.randomUUID(); + console.log(`[openReview] creating review=${reviewId.slice(0,8)} adapter=${adapter} anchor=${anchorId} prompt=${prompt?.substring(0, 30)}`); patchAdapterPrefs(adapter, { model }); setHistoryReview(null); - setPendingReview({ childAdapter: adapter, anchorMessageId: anchorId, reviewTitle: title, prompt }); + setActiveReviews(prev => { + console.log(`[openReview] activeReviews before: ${prev.length} entries, ids: ${prev.map(r => r.reviewId.slice(0,8)).join(',')}`); + return [...prev, { + reviewId, + childSessionId: '', + childCliSessionId: '', + childAdapter: adapter, + anchorMessageId: anchorId, + reviewTitle: title, + prompt, + permissionMode: adapter === 'gemini' ? 'yolo' : 'bypassPermissions', + }]; + }); setActiveReviewPanel('expanded'); - }, [reviewMenuMessageId, cwd]); + }, [reviewMenuMessageId]); const handleDirectSend = useCallback((adapter: string, model: string) => { const anchorMsg = messages.find(m => m.id === reviewMenuMessageId); @@ -437,7 +434,7 @@ export function ChatView({ permissionMode={permissionMode} sessionStatus={sessionStatus} adapterConfig={adapterConfig} - selectedAdapter={selectedAdapter} + selectedAdapter={selectedAdapter!} streaming={streaming} onModelChange={updateModel} onPermissionModeChange={updatePermissionMode} @@ -447,40 +444,38 @@ export function ChatView({ const isHistoryPanel = !!historyReview; - // Use ref so onSessionCreatedCallback always reads the latest pendingReview - // (prevents stale closure if a second review is opened while the first is still pending) - const pendingReviewRef = useRef(pendingReview); - pendingReviewRef.current = pendingReview; + const activeReviewsRef = useRef(activeReviews); + activeReviewsRef.current = activeReviews; - const onSessionCreatedCallback = useCallback(async (childSid: string) => { - const pending = pendingReviewRef.current; - if (!sessionId || !pending) return; + const onSessionCreatedCallback = useCallback(async (reviewId: string, childSid: string) => { + console.log(`[onSessionCreated] reviewId=${reviewId.slice(0,8)} childSid=${childSid.slice(0,8)} parentSid=${sessionId?.slice(0,8)}`); + if (!sessionId) return; + const review = activeReviewsRef.current.find(r => r.reviewId === reviewId); + if (!review) { console.log(`[onSessionCreated] review not found in activeReviews`); return; } try { - const result = await api.registerReview( - sessionId, - childSid, - pending.childAdapter, - pending.anchorMessageId, - pending.prompt, - pending.reviewTitle, - ); - setActiveReviews(prev => { - if (prev.some(r => r.reviewId === result.reviewId)) return prev; - return [...prev, { - reviewId: result.reviewId, - childSessionId: childSid, - childCliSessionId: childSid, - childAdapter: pending.childAdapter, - anchorMessageId: pending.anchorMessageId, - reviewTitle: pending.reviewTitle, - }]; + console.log(`[onSessionCreated] calling api.registerReview...`); + await api.registerReview({ + reviewId, + parentCliSessionId: sessionId, + childSessionId: childSid, + targetAdapter: review.childAdapter, + anchorMessageId: review.anchorMessageId || '', + prompt: review.prompt || '', + title: review.reviewTitle || '', }); } catch (err) { console.error('Failed to register review:', err); } - setPendingReview(null); }, [sessionId]); + if (!selectedAdapter) { + return ( +
+ +
+ ); + } + return (
{/* Header — auto-hides when scrolling up to view history */} @@ -516,31 +511,25 @@ export function ChatView({ className="flex-1" /> - {/* Floating review panel — active reviews (tabbed) + pending review */} - {activeReviewPanel === 'expanded' && (activeReviews.length > 0 || pendingReview) && ( - ({ + {/* Floating review panel — CSS-hidden when minimized to keep hooks alive */} + {activeReviews.length > 0 && ( +
+ ({ reviewId: r.reviewId, childSessionId: r.childSessionId, childAdapter: r.childAdapter, reviewTitle: r.reviewTitle, - })), - // Pending review: no reviewId yet, triggers session creation in ReviewTab - ...(pendingReview ? [{ - reviewId: '', - childSessionId: '', - childAdapter: pendingReview.childAdapter, - reviewTitle: pendingReview.reviewTitle, - }] : []), - ]} - onEnd={(reviewId) => closeReview(reviewId)} - onMinimize={() => setActiveReviewPanel('minimized')} - initialPrompt={pendingReview?.prompt || undefined} - cwd={cwd} - onSessionCreated={onSessionCreatedCallback} - /> + prompt: r.prompt, + permissionMode: r.permissionMode, + }))} + onEnd={(reviewId) => closeReview(reviewId)} + onMinimize={() => setActiveReviewPanel('minimized')} + cwd={cwd} + onSessionCreated={onSessionCreatedCallback} + /> +
)} {/* Floating review panel — read-only history view */} @@ -590,23 +579,13 @@ export function ChatView({
)} - {/* Permission / Ask overlays */} - {permissionRequest && permissionRequest.toolName === 'AskUserQuestion' ? ( - - respondAsk(requestId, response)} - /> - - ) : permissionRequest ? ( - respondPermission(permissionRequest.requestId, 'allow')} - onAllowAll={() => respondPermission(permissionRequest.requestId, 'allow_session')} - onDeny={(msg?: string) => respondPermission(permissionRequest.requestId, 'deny', msg)} + {/* Interactive prompt overlay (permissions, questions, plan approval, etc.) */} + {interactivePrompt && ( + - ) : null} + )} ); } diff --git a/src/components/FloatingReviewPanel.tsx b/src/components/FloatingReviewPanel.tsx index 5630e1c..538b25b 100644 --- a/src/components/FloatingReviewPanel.tsx +++ b/src/components/FloatingReviewPanel.tsx @@ -1,6 +1,7 @@ import React, { useState, useEffect, useRef, useCallback, forwardRef, useImperativeHandle } from 'react'; import { useChat } from '../hooks/useChat'; import { ChatBody } from './ChatBody'; +import { InteractivePromptOverlay } from './InteractivePromptOverlay'; import { getBrand } from '@/lib/adapter-brands'; import { extractTextFromBlocks } from '@/lib/content-utils'; import { api } from '@/lib/api'; @@ -12,15 +13,16 @@ export interface ReviewEntry { childSessionId: string; childAdapter: string; reviewTitle?: string; + prompt?: string; + permissionMode?: string; } interface ReviewPanelProps { reviews: ReviewEntry[]; onEnd: (reviewId: string) => void; onMinimize: () => void; - initialPrompt?: string; cwd?: string; - onSessionCreated?: (childSessionId: string) => void; + onSessionCreated?: (reviewId: string, childSessionId: string) => void; readOnly?: boolean; } @@ -30,23 +32,24 @@ export interface ReviewPanelHandle { // ===== ReviewTab (one per review, keeps useChat hook alive) ===== -const ReviewTab = React.memo(function ReviewTab({ review, cwd, initialPrompt, onSessionCreated, isActive, readOnly, sendRef }: { +const ReviewTab = React.memo(function ReviewTab({ review, cwd, onSessionCreated, isActive, readOnly, sendRef }: { review: ReviewEntry; cwd?: string; - initialPrompt?: string; - onSessionCreated?: (sid: string) => void; + onSessionCreated?: (reviewId: string, sid: string) => void; isActive: boolean; readOnly?: boolean; sendRef?: React.MutableRefObject void>>; }) { const { - messages, streaming, liveStatus, toolStatuses, + messages, streaming, pendingResponse, liveStatus, toolStatuses, sendMessage, abort, sessionId: chatSessionId, + interactivePrompt, respondPrompt, } = useChat( review.childSessionId || undefined, cwd, review.childAdapter, - initialPrompt, + review.prompt, + review.permissionMode, ); // Notify parent when child session is created @@ -54,9 +57,9 @@ const ReviewTab = React.memo(function ReviewTab({ review, cwd, initialPrompt, on useEffect(() => { if (chatSessionId && !review.childSessionId && onSessionCreated && !sessionCreatedRef.current) { sessionCreatedRef.current = true; - onSessionCreated(chatSessionId); + onSessionCreated(review.reviewId, chatSessionId); } - }, [chatSessionId, review.childSessionId, onSessionCreated]); + }, [chatSessionId, review.childSessionId, onSessionCreated, review.reviewId]); // Register sendMessage in parent's ref map for sendToReview useEffect(() => { @@ -89,6 +92,7 @@ const ReviewTab = React.memo(function ReviewTab({ review, cwd, initialPrompt, on + {interactivePrompt && ( + + )} ); }); @@ -107,7 +117,7 @@ const ReviewTab = React.memo(function ReviewTab({ review, cwd, initialPrompt, on // ===== Main Panel ===== export const FloatingReviewPanel = forwardRef( - function FloatingReviewPanel({ reviews, onEnd, onMinimize, initialPrompt, cwd, onSessionCreated, readOnly }, ref) { + function FloatingReviewPanel({ reviews, onEnd, onMinimize, cwd, onSessionCreated, readOnly }, ref) { const [activeTabIndex, setActiveTabIndex] = useState(Math.max(0, reviews.length - 1)); // Keep activeTabIndex in bounds @@ -162,7 +172,7 @@ export const FloatingReviewPanel = forwardRef ( void; +} + +const BADGE_COLORS: Record = { + permission: 'bg-orange-500/20 text-orange-400 border-orange-500/30', + question: 'bg-blue-500/20 text-blue-400 border-blue-500/30', + plan: 'bg-purple-500/20 text-purple-400 border-purple-500/30', + 'loop-detected': 'bg-yellow-500/20 text-yellow-400 border-yellow-500/30', +}; + +function formatToolInput(toolName: string, input: any): string { + if (!input) return ''; + if (toolName === 'Bash' && input.command) return input.command; + if (input.file_path) return input.file_path; + if (input.pattern) return input.pattern; + if (input.path) return input.path; + if (input.command) return input.command; + const str = JSON.stringify(input, null, 2); + return str.length > 300 ? str.slice(0, 300) + '...' : str; +} + +export function InteractivePromptOverlay({ prompt, onRespond }: Props) { + const [textValue, setTextValue] = useState(''); + const [countdown, setCountdown] = useState(120); + const onRespondRef = useRef(onRespond); + onRespondRef.current = onRespond; + const requestIdRef = useRef(prompt.requestId); + requestIdRef.current = prompt.requestId; + + // 120s countdown for permission type + useEffect(() => { + if (prompt.promptType !== 'permission') return; + setCountdown(120); + const timer = setInterval(() => { + setCountdown((c) => { + if (c <= 1) { + onRespondRef.current(requestIdRef.current, 'deny'); + return 0; + } + return c - 1; + }); + }, 1000); + return () => clearInterval(timer); + }, [prompt.requestId, prompt.promptType]); + + // Reset text when prompt changes + useEffect(() => { + setTextValue(''); + }, [prompt.requestId]); + + const handleOptionClick = useCallback((value: string) => { + onRespond(prompt.requestId, value); + }, [onRespond, prompt.requestId]); + + const handleTextSubmit = useCallback(() => { + if (!textValue.trim()) return; + onRespond(prompt.requestId, undefined, textValue.trim()); + }, [onRespond, prompt.requestId, textValue]); + + const badgeClass = BADGE_COLORS[prompt.promptType] || BADGE_COLORS.question; + + return ( + onRespond(prompt.requestId, 'deny')} + zIndex="z-40" + backdropClassName="backdrop-blur-sm" + className="p-5" + showHandle={false} + > + {/* Title bar */} +
+ + {prompt.title || prompt.promptType} + + {prompt.promptType === 'permission' && ( + {countdown}s + )} +
+ + {/* Description */} + {prompt.description && ( +

{prompt.description}

+ )} + + {/* Tool info card */} + {prompt.toolName && ( +
+
+ {prompt.toolName} +
+ {prompt.toolInput && ( + 
+              {formatToolInput(prompt.toolName, prompt.toolInput)}
+
+ )} +
+ )} + + {/* Options — vertical button list */} + {prompt.options && prompt.options.length > 0 && ( +
+ {prompt.options.map((opt, i) => ( + + ))} +
+ )} + + {/* Text input */} + {prompt.textInput && ( +
+