pikiclaw 0.3.68 → 0.3.70

package/dist/agent/drivers/claude-tui.js

@@ -323,6 +323,68 @@ export function detectClaudeTuiTerminalLimitNotice(msgOrText) {
         return null;
     return limitNoticeFromText(extractTextBlocks(msgOrText.content));
 }
+/**
+ * Detect Claude Code's startup "Bypass Permissions mode" confirmation dialog in
+ * a slice of (ANSI-stripped) PTY screen output. When pikiclaw spawns the TUI
+ * with `--permission-mode bypassPermissions` (the default) on a machine that
+ * has not yet accepted bypass mode, Claude paints a blocking prompt:
+ *
+ *     WARNING: Claude Code running in Bypass Permissions mode
+ *     ...
+ *   ❯ 1. No, exit
+ *     2. Yes, I accept
+ *
+ * The default highlight sits on "No, exit", so the driver's blind prompt-submit
+ * Enter nudge would pick *exit* — the message never gets processed and the turn
+ * hangs on a pre-prompt. Seeding `bypassPermissionsModeAccepted` in config is
+ * not a reliable fix: it is version-fragile (observed no-op on 2.1.169) and
+ * gated by org policy (`isBypassPermissionsModeAvailable`). So we detect the
+ * dialog on the wire and auto-select "Yes, I accept". Require all three
+ * distinctive fragments so ordinary text mentioning "bypass" can't trigger it.
+ */
+export function detectClaudeBypassPrompt(screen) {
+    if (typeof screen !== 'string' || !screen)
+        return false;
+    // Claude's TUI lays words out with cursor-move escapes (`\x1b[<col>G`) rather
+    // than literal spaces, so once ANSI is stripped the on-screen text runs
+    // together — the real dialog reads "BypassPermissionsmode" / "Yes,Iaccept" /
+    // "No,exit", not the spaced form. Collapse all whitespace before matching so
+    // the detector fires on the live PTY screen *and* on space-preserving
+    // renderings. (Verified against claude 2.1.168's actual bypass screen.)
+    const t = stripAnsiEscapes(screen).replace(/\s+/g, '').toLowerCase();
+    return t.includes('bypasspermissionsmode')
+        && t.includes('yes,iaccept')
+        && t.includes('no,exit');
+}
+/**
+ * Capture-only classifier for the stall watchdog. When the turn goes quiet we
+ * cannot tell from timing alone whether the TUI is (a) frozen mid-turn (the
+ * known CLI bug — PTY dead), (b) just thinking for a long time (PTY repaints a
+ * spinner), or (c) blocked on an interactive prompt that bypass mode does NOT
+ * suppress and that's waiting for input it will never get (trust-a-new-folder,
+ * a "Do you want to proceed?" confirmation, an expired-login prompt, …). The
+ * raw PTY screen is the only thing that disambiguates them, and we don't
+ * otherwise persist it — so on a stall we record a compact stripped sample plus
+ * a conservative "looks like an interactive prompt" flag. Changes no control
+ * flow; it exists purely to make the next stall diagnosable from data.
+ */
+export function classifyStallScreen(screen) {
+    if (typeof screen !== 'string' || !screen)
+        return { looksLikePrompt: false, sample: '' };
+    const stripped = stripAnsiEscapes(screen);
+    const sample = stripped.replace(/\s+/g, ' ').trim().slice(-400);
+    // Claude positions words with cursor moves, so the live screen is spaceless;
+    // match against the despaced form (see detectClaudeBypassPrompt).
+    const ds = stripped.replace(/\s+/g, '').toLowerCase();
+    const looksLikePrompt = ds.includes('esctocancel') // claude's confirm-dialog footer ("Enter to confirm · Esc to cancel")
+        || ds.includes('doyouwant')
+        || ds.includes('wouldyoulike')
+        || ds.includes('trustthisfolder')
+        || ds.includes('yes,iaccept')
+        || ds.includes('(y/n)')
+        || (ds.includes('❯') && ds.includes('1.') && ds.includes('2.')); // numbered select with cursor
+    return { looksLikePrompt, sample };
+}
 /**
  * Extract text / thinking blocks from an assistant JSONL event and route them:
  * text → the chunked stream buffer (slow drain), thinking → `s.thinking`
@@ -1055,6 +1117,30 @@ export async function doClaudeTuiStream(opts) {
     const dbg = process.env.PIKICLAW_CLAUDE_TUI_DEBUG === '1';
     /** Wall-clock of the last raw PTY byte — stall watchdog fast-path signal. */
     let lastPtyDataAt = Date.now();
+    // Startup-dialog auto-answer. Claude's TUI can paint a blocking "Bypass
+    // Permissions mode" confirmation before it accepts our positional prompt
+    // (default highlight = "No, exit"). We keep a bounded ANSI-stripped tail of
+    // the screen, detect that dialog (see detectClaudeBypassPrompt), and select
+    // "Yes, I accept" so the turn never stalls on a pre-prompt.
+    const SCREEN_TAIL_MAX = 8192;
+    const BYPASS_ACCEPT_MAX_ATTEMPTS = 3;
+    // Settle delay after the dialog first paints before we send any key. Claude's
+    // Ink select drops input aimed at it during the first frames — sending the
+    // digit too early is a no-op. ~500ms is comfortably past readiness in repro.
+    const BYPASS_SETTLE_MS = 500;
+    // Gap between the selection key and the confirm Enter. Claude's Ink select
+    // swallows a combined "2\r" (only the digit lands; the Enter is dropped before
+    // the highlight repaints), so the two keystrokes must be split in time —
+    // 600ms is what reproduces reliably against the live 2.1.168 dialog.
+    const BYPASS_CONFIRM_DELAY_MS = 600;
+    // How long after the last bypass-dialog repaint we still treat it as on
+    // screen — suppresses the blind prompt-submit Enter nudge across the whole
+    // select→confirm sequence so a stray CR can't land on "No, exit".
+    const BYPASS_DIALOG_ACTIVE_WINDOW_MS = 2000;
+    let screenTail = '';
+    let bypassPromptLastSeenAt = 0;
+    let bypassAcceptAttempts = 0;
+    let bypassPhase = 'idle';
     proc.onData((data) => {
         // We deliberately do not parse the TUI screen output. The JSONL is the
         // canonical source of structured events. Stash bytes only when debugging.
@@ -1068,6 +1154,55 @@ export async function doClaudeTuiStream(opts) {
             }
             catch { }
         }
+        // Auto-answer the bypass-permissions confirmation. Detect it the moment it
+        // paints (off the raw PTY, not the 200ms poll tick) and arm a short timed
+        // keystroke sequence. Keep a bounded stripped tail across chunks so a dialog
+        // split across reads still matches.
+        screenTail = (screenTail + stripAnsiEscapes(data)).slice(-SCREEN_TAIL_MAX);
+        if (detectClaudeBypassPrompt(screenTail)) {
+            bypassPromptLastSeenAt = Date.now();
+            if (bypassPhase === 'idle' && bypassAcceptAttempts < BYPASS_ACCEPT_MAX_ATTEMPTS) {
+                bypassAcceptAttempts++;
+                bypassPhase = 'armed';
+                // Three timed steps — verified 3/3 against the live 2.1.168 dialog:
+                //   settle (dialog ignores input on its first frames)
+                //   → "2"  (jumps to the second option "Yes, I accept"; idempotent —
+                //           re-sending can't overshoot a 2-option menu onto "No, exit")
+                //   → Enter (confirms; must arrive *after* the highlight repaints — a
+                //            combined "2\r" gets swallowed, only the digit lands).
+                agentLog(`[claude-tui] bypass-permissions prompt — auto-accepting "Yes, I accept" (attempt ${bypassAcceptAttempts}/${BYPASS_ACCEPT_MAX_ATTEMPTS})`);
+                setTimeout(() => {
+                    if (processExited)
+                        return;
+                    try {
+                        proc.write('2');
+                    }
+                    catch { }
+                    setTimeout(() => {
+                        if (processExited)
+                            return;
+                        try {
+                            proc.write('\r');
+                        }
+                        catch { }
+                        bypassPhase = 'confirmed';
+                        agentLog('[claude-tui] bypass-permissions — confirm Enter sent');
+                        // Drop the buffered dialog frame: the post-accept REPL output can be
+                        // tiny (e.g. a "Not logged in" line), so the old dialog text would
+                        // otherwise linger in the 8192-char tail and make the re-arm below
+                        // re-fire on a stale screen — typing "2"/Enter into the live prompt.
+                        // Clearing means the re-arm only sees output that arrives *after*
+                        // the confirm, so it re-fires only on a genuine repaint of the
+                        // dialog (accept didn't take), never on stale bytes.
+                        screenTail = '';
+                        setTimeout(() => {
+                            if (!processExited && detectClaudeBypassPrompt(screenTail))
+                                bypassPhase = 'idle';
+                        }, 1200);
+                    }, BYPASS_CONFIRM_DELAY_MS);
+                }, BYPASS_SETTLE_MS);
+            }
+        }
         // Capture stderr-ish bytes (TUI startup errors, "claude: command not
         // found"-style messages) for the final error payload when the run aborts
         // before any JSONL is written. Strip ANSI on the way in — otherwise the
@@ -1314,8 +1449,15 @@ export async function doClaudeTuiStream(opts) {
         else if (state.transcriptPath && state.transcriptPath !== activeJsonlPath) {
             activeJsonlPath = state.transcriptPath;
         }
-        // Submit nudge — only if UserPromptSubmit hook hasn't fired yet.
-        if (!promptNudged && !state.promptSubmittedAt && Date.now() - start > PROMPT_SUBMIT_NUDGE_MS) {
+        // Submit nudge — only if UserPromptSubmit hook hasn't fired yet. Suppress
+        // it while the bypass-permissions dialog is (or was just) on screen: a blind
+        // CR there lands on the default "No, exit" and kills the session. The dialog
+        // auto-answer in onData drives that screen instead; once it clears the
+        // prompt submits on its own (or this nudge fires on a later tick).
+        const bypassDialogActive = bypassPromptLastSeenAt > 0
+            && Date.now() - bypassPromptLastSeenAt < BYPASS_DIALOG_ACTIVE_WINDOW_MS;
+        if (!promptNudged && !state.promptSubmittedAt && !bypassDialogActive
+            && Date.now() - start > PROMPT_SUBMIT_NUDGE_MS) {
             promptNudged = true;
             try {
                 proc.write('\r');
@@ -1488,6 +1630,9 @@ export async function doClaudeTuiStream(opts) {
                         stallDiagPtyAliveWhileQuiet = true;
                     if (nowMs - lastStallDiagHeartbeatAt >= STALL_DIAG_HEARTBEAT_INTERVAL_MS) {
                         lastStallDiagHeartbeatAt = nowMs;
+                        // Snapshot the screen so a quiet stretch can later be classified as
+                        // a frozen stream vs a long think vs a blocking interactive prompt.
+                        const screenInfo = classifyStallScreen(screenTail);
                         writeStallDiag({
                             kind: 'quiet',
                             sessionId: activeSessionId,
@@ -1503,6 +1648,8 @@ export async function doClaudeTuiStream(opts) {
                             pendingHookTools: pendingHookToolIds.size,
                             pendingBgAgents: pendingBgForStall,
                             pendingBgBash: pendingClaudeBackgroundBashCount(s),
+                            looksLikePrompt: screenInfo.looksLikePrompt,
+                            screenSample: screenInfo.sample,
                         });
                     }
                 }
@@ -1518,6 +1665,7 @@ export async function doClaudeTuiStream(opts) {
                 const quietMin = Math.round((Date.now() - lastProgressAt) / 60_000);
                 const ptyQuietS = Math.round((Date.now() - lastPtyDataAt) / 1000);
                 s.stopReason = 'stalled';
+                const stallScreen = classifyStallScreen(screenTail);
                 writeStallDiag({
                     kind: 'stall',
                     sessionId: activeSessionId,
@@ -1532,6 +1680,11 @@ export async function doClaudeTuiStream(opts) {
                     lastJsonlType: lastMainJsonlType,
                     pendingHookTools: pendingHookToolIds.size,
                     pendingBgAgents: pendingBgForStall,
+                    // looksLikePrompt=true here is the signal that the "stall" was really
+                    // a blocking interactive prompt waiting for input bypass can't skip —
+                    // the mid-turn dialog-hang hypothesis, confirmable from screenSample.
+                    looksLikePrompt: stallScreen.looksLikePrompt,
+                    screenSample: stallScreen.sample,
                 });
                 if (!s.errors) {
                     s.errors = [`Claude process went silent mid-turn for ${quietMin}m (no JSONL, hook, or sub-agent events; PTY quiet ${ptyQuietS}s) — known claude CLI freeze. Terminated for auto-resume.`];

package/dist/agent/drivers/claude.js

@@ -2398,7 +2398,7 @@ async function doClaudeWithRetry(opts) {
             ok: false,
             incomplete: true,
             message: [
-                'The agent process stalled mid-turn and could not be auto-recovered (known claude CLI freeze, seen on 2.1.160).',
+                'The agent process stalled mid-turn and could not be auto-recovered (a known claude CLI mid-turn freeze).',
                 'Your session is intact — re-send your message (or say "continue") to pick up where it stopped.',
             ].join(' '),
         };

package/dist/bot/render-shared.js

@@ -276,12 +276,6 @@ function renderSubAgentsForPreview(meta) {
     }
     return lines.join('\n');
 }
-/** After this much wall-clock, a still-running turn shows a text-only "still
- *  working" banner (see StreamPreviewData.longRunHint) so a long silent
- *  operation (held background task, slow command) doesn't read as a frozen
- *  card. Deliberately above the chunked-stream cadence so quick turns never
- *  flash it. */
-const LONG_RUN_HINT_AFTER_MS = 60_000;
 export function extractStreamPreviewData(input) {
     const maxBody = 2400;
     const display = input.bodyText.trim();
@@ -299,13 +293,6 @@ export function extractStreamPreviewData(input) {
     // freshly-opened card doesn't flash "0s".
     const elapsedMs = Math.max(0, input.elapsedMs);
     const thinkingProgressText = elapsedMs >= 1000 ? fmtCompactUptime(elapsedMs) : null;
-    // After a turn has run a while, a long silent operation (a held background
-    // task, a slow command) can make the card look frozen. Surface a text-only
-    // "still working" line so the user knows it's alive and can switch away. No
-    // elapsed time here — the footer keeps the single clock, so no second timer.
-    const longRunHint = elapsedMs >= LONG_RUN_HINT_AFTER_MS
-        ? '⏳ Still working — the result will update in this card'
-        : null;
     return {
         display,
         rawThinking,
@@ -318,6 +305,5 @@ export function extractStreamPreviewData(input) {
         thinkSnippet,
         preview,
         thinkingProgressText,
-        longRunHint,
     };
 }

package/dist/channels/feishu/render.js

@@ -246,8 +246,6 @@ function buildPreviewMarkdown(input, options) {
         // heartbeat, so the card still visibly advances.
         parts.push(`**${data.label}**`);
     }
-    if (data.longRunHint)
-        parts.push(data.longRunHint);
     if (options?.includeFooter !== false) {
         parts.push(formatPreviewFooter(input.agent, input.elapsedMs, input.meta ?? null, {
             model: input.model,

package/dist/channels/telegram/render.js

@@ -345,8 +345,6 @@ export function buildStreamPreviewHtml(input) {
         // heartbeat, so the card still visibly advances.
         parts.push(`<blockquote><b>${escapeHtml(data.label)}</b></blockquote>`);
     }
-    if (data.longRunHint)
-        parts.push(`<i>${escapeHtml(data.longRunHint)}</i>`);
     parts.push(formatPreviewFooterHtml(input.agent, input.elapsedMs, input.meta ?? null, {
         model: input.model,
         effort: input.effort,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.3.68",
+  "version": "0.3.70",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {