handmux 0.29.2 → 0.31.0

package/dist/src/agents/claudeInteraction.js

@@ -1,134 +1,4 @@
-import { createHash } from 'node:crypto';
-import { parsePendingPrompt } from '../pendingPrompt.js';
-function normalizedPrompt(text, pendingKind) {
-    const prompt = parsePendingPrompt(text);
-    if (!prompt) {
-        if (pendingKind !== 'permission')
-            return null;
-        const tail = text.split('\n').map((line) => line.trim()).filter(Boolean).slice(-3).join('\n');
-        const promptText = tail.slice(0, 2_000) || 'Claude is waiting for permission in the terminal.';
-        const id = `claude-permission:${createHash('sha256').update(promptText).digest('hex').slice(0, 24)}`;
-        return {
-            id, type: 'local_only', prompt: promptText,
-        };
-    }
-    const signature = JSON.stringify(prompt);
-    const id = `claude-prompt:${createHash('sha256').update(signature).digest('hex').slice(0, 24)}`;
-    return {
-        id,
-        type: 'select',
-        prompt: prompt.leadIn ? `${prompt.leadIn}\n${prompt.title}` : prompt.title,
-        options: prompt.options.map((option) => ({
-            id: `choice:${option.n}`,
-            label: option.description ? `${option.label} — ${option.description}` : option.label,
-        })),
-    };
-}
+import { createHookInteractionAdapter } from './hookInteraction.js';
 export function createClaudeInteractionAdapter(control, pollMs = 750, reportHealth = () => { }) {
-    if (!control || typeof control.capturePlain !== 'function'
-        || typeof control.sendChoice !== 'function' || !Number.isFinite(pollMs) || pollMs <= 0) {
-        throw new TypeError('Claude Interaction adapter requires pane capture and choice control');
-    }
-    const active = new Map();
-    return {
-        apiVersion: 1,
-        async observeNative(run, sink) {
-            let closed = false;
-            let cursor = 0;
-            let pending = normalizedPrompt(await control.capturePlain(run.ref.paneId), control.pendingKind?.(run.ref.paneId));
-            let timer;
-            let tail = Promise.resolve();
-            let failures = 0;
-            const binding = { run, pending };
-            active.set(run.ref.runId, binding);
-            const close = () => {
-                closed = true;
-                if (timer)
-                    clearTimeout(timer);
-                timer = undefined;
-                if (active.get(run.ref.runId) === binding)
-                    active.delete(run.ref.runId);
-            };
-            const schedule = (delay = pollMs) => {
-                if (closed || run.signal.aborted)
-                    return;
-                timer = setTimeout(() => {
-                    tail = tail.then(async () => {
-                        if (closed || run.signal.aborted)
-                            return;
-                        const next = normalizedPrompt(await control.capturePlain(run.ref.paneId), control.pendingKind?.(run.ref.paneId));
-                        if (failures > 0)
-                            reportHealth('ready');
-                        failures = 0;
-                        if (pending?.id === next?.id)
-                            return;
-                        if (pending)
-                            await sink({
-                                type: 'resolved', sourceCursor: `claude-interaction:${++cursor}`,
-                                interactionId: pending.id,
-                            });
-                        pending = next;
-                        binding.pending = next;
-                        if (next)
-                            await sink({
-                                type: 'opened', sourceCursor: `claude-interaction:${++cursor}`, interaction: next,
-                            });
-                    }).catch(async () => {
-                        failures += 1;
-                        if (failures >= 2) {
-                            reportHealth('degraded', 'Interaction polling is temporarily unavailable');
-                            if (pending) {
-                                const abandoned = pending;
-                                pending = null;
-                                binding.pending = null;
-                                await Promise.resolve(sink({
-                                    type: 'cancelled', sourceCursor: `claude-interaction:${++cursor}`,
-                                    interactionId: abandoned.id, reason: 'temporarily_unavailable',
-                                })).catch(close);
-                            }
-                        }
-                    }).finally(() => schedule(Math.min(10_000, pollMs * (2 ** Math.min(failures, 4)))));
-                }, delay);
-                timer.unref?.();
-            };
-            const onAbort = () => close();
-            run.signal.addEventListener('abort', onAbort, { once: true });
-            schedule();
-            return {
-                checkpoint: {
-                    sourceCursor: `claude-interaction:${cursor}`,
-                    pending: pending ? [pending] : [],
-                },
-                close() {
-                    run.signal.removeEventListener('abort', onAbort);
-                    close();
-                },
-            };
-        },
-        async dispatchResponse(run, request) {
-            const binding = active.get(run.ref.runId);
-            if (!binding || binding.run !== run || run.signal.aborted)
-                return { status: 'stale_run' };
-            if (!binding.pending || binding.pending.id !== request.interactionId) {
-                return { status: 'already_resolved' };
-            }
-            const optionIds = request.value.type === 'selection' ? request.value.optionIds
-                : request.value.type === 'approval' ? [request.value.optionId] : [];
-            if (optionIds.length !== 1) {
-                return { status: 'rejected', reason: 'invalid_value' };
-            }
-            const optionId = optionIds[0];
-            const match = optionId.match(/^choice:(\d+)$/);
-            if (!match || !binding.pending.options?.some((option) => option.id === optionId)) {
-                return { status: 'rejected', reason: 'invalid_value' };
-            }
-            try {
-                await control.sendChoice(run.ref.paneId, match[1]);
-                return { status: 'accepted' };
-            }
-            catch {
-                return { status: 'unknown', reason: 'temporarily_unavailable' };
-            }
-        },
-    };
+    return createHookInteractionAdapter(control, { id: 'claude', label: 'Claude' }, pollMs, reportHealth);
 }

package/dist/src/agents/claudePaneInput.js

@@ -1,42 +1,42 @@
-import { serializePaneInput } from '../paneInput.js';
+import { describeEditorArea, serializePaneInput, singleLineDraft } from '../paneInput.js';
 const SUBMIT_GAP_MS = 120;
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-// Read the entire one-line native editor, bounded by its two rules. Wrapped input, attachments,
-// selection menus and unknown layouts fail closed. End is sent first: placeholder text is painted
-// after the cursor but isn't part of the editor; actual text places the cursor at its end.
+// Claude's editor is the shared one-line shape, with `❯` as its prompt.
 export function claudeSingleLineDraft(screen, cursor) {
-    const lines = screen.split('\n');
-    const line = lines[cursor.cursorY];
-    if (!line || !/^─{3,}$/.test(lines[cursor.cursorY - 1]?.trim() ?? '')
-        || !/^─{3,}$/.test(lines[cursor.cursorY + 1]?.trim() ?? '')
-        || !/^❯[ \u00a0]/.test(line))
-        return null;
-    const value = line.slice(2).trimEnd();
-    if (cursor.cursorX === 2)
-        return ''; // Native suggestions are painted here but End does not enter them.
-    if (!value || /[\x00-\x1f\x7f]/.test(value) || cursor.cursorX <= 2)
-        return null;
-    return value;
+    return singleLineDraft(screen, cursor);
 }
-export function sendClaudePanePrompt(commands, paneId, text, restoredPrompt, guard) {
+export function sendClaudePanePrompt(commands, paneId, text, restoredPrompt, guard, reportUnreadable) {
     return serializePaneInput(paneId, async () => {
         if (guard && !await guard.validate())
             return { nativeMutation: false };
         await commands.exitCopyModeIfActive(paneId);
         await commands.sendKey(paneId, 'End');
         await delay(SUBMIT_GAP_MS);
-        const readDraft = async () => claudeSingleLineDraft(await commands.capturePlain(paneId), await commands.paneInfo(paneId));
-        const draft = await readDraft();
-        if (draft === null || (draft !== '' && draft !== restoredPrompt())) {
+        const readEditor = async () => {
+            const screen = await commands.capturePlain(paneId);
+            const cursor = await commands.paneInfo(paneId);
+            return { screen, cursor, draft: claudeSingleLineDraft(screen, cursor) };
+        };
+        const draft = await readEditor();
+        if (draft.draft === null) {
+            // Unreadable: record the shape, never the text we could not read (see describeEditorArea).
+            reportUnreadable?.(describeEditorArea(draft.screen, draft.cursor));
+            return { nativeMutation: false, reason: 'terminal_draft_conflict' };
+        }
+        if (draft.draft !== '' && draft.draft !== restoredPrompt()) {
             return { nativeMutation: false, reason: 'terminal_draft_conflict' };
         }
         if (guard && !await guard.validate())
             return { nativeMutation: false };
-        if (draft) {
+        if (draft.draft) {
             await commands.sendKey(paneId, 'C-u');
             await delay(SUBMIT_GAP_MS);
-            if (await readDraft() !== '')
+            const cleared = await readEditor();
+            if (cleared.draft !== '') {
+                if (cleared.draft === null)
+                    reportUnreadable?.(describeEditorArea(cleared.screen, cleared.cursor));
                 return { nativeMutation: false, reason: 'terminal_draft_conflict' };
+            }
         }
         await commands.sendText(paneId, text);
         if (text)

package/dist/src/agents/codebuddy.js

@@ -0,0 +1,100 @@
+// The CodeBuddy Code agent adapter. Everything here is what Handmux knows that is SPECIFIC to CodeBuddy;
+// the shared engine consumes this descriptor like any other provider.
+//
+// CodeBuddy is npm-first. `codebuddy`, `codebuddy-code` and `cbc` are symlinks onto one bin/codebuddy entry,
+// so tmux only reports a stable name for the native build. In the documented npm layout the CLI runs INSIDE
+// a Node process (`node /usr/local/bin/codebuddy` — verified live on 2.154.0), which makes three of the usual
+// identity routes unusable:
+//   - `#{pane_current_command}` is a bare "node", so no exact command can ever own the pane;
+//   - the process's real executable (lsof/proc) is the Node binary, so executable-backed proof — the Claude
+//     and Codex route — cannot name CodeBuddy;
+//   - the Agent never spawns a native child binary, so the single-leaf foreground view, which deliberately
+//     prefers a non-launcher descendant for ambiguous launchers, can hand back a transient tool child
+//     (an npm/ruby update check) instead of the Agent itself.
+// Identity therefore comes from the pane's whole foreground group, matched at a path boundary against the
+// published launch entry points. We only ever answer "yes" from positive evidence, and we stay inconclusive
+// rather than negative when the group was not actually read.
+import os from 'node:os';
+import path from 'node:path';
+// The three entries the CodeBuddy CLI installs, plus the package that owns the npm layout.
+const LAUNCH_NAMES = new Set(['codebuddy', 'codebuddy-code', 'cbc']);
+const NPM_PACKAGE_MARKER = '/@tencent-ai/codebuddy-code/';
+const NODE_PROGRAM_RE = /^(\S*\/)?node$/;
+const basename = (value) => value.split('/').at(-1) ?? '';
+// CodeBuddy's own on-disk layout, in one place because three readers need the same answer: the conversation
+// adapter reads a session's JSONL, the native tail resolves a pane's session from its registry row, and the
+// session binding reads the hook state file. A session log is
+// `<projects>/<cwd with its slashes replaced by dashes>/<session-id>.jsonl`; a running session publishes
+// `~/.codebuddy/sessions/<pid>.json` (pid, sessionId, cwd, heartbeat — never a status).
+export const codebuddyProjectsDir = (home = os.homedir()) => path.join(home, '.codebuddy', 'projects');
+export const codebuddySessionsDir = (home = os.homedir()) => path.join(home, '.codebuddy', 'sessions');
+// Node's entry argument is the first non-flag token after the program. Nothing beyond it may be searched:
+// the agent's own arguments (a prompt, a file path, a session id) are free to contain any word, and matching
+// those would turn "some Node script that was passed the word codebuddy" into a false identity.
+function nodeEntryArgument(rest) {
+    return rest.split(/\s+/).find((token) => token.length > 0 && !token.startsWith('-')) ?? '';
+}
+// Exported for the contract tests that freeze the accepted launch shapes.
+export function isCodeBuddyCommandLine(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    const segments = trimmed.split(/\s+/);
+    const program = (segments[0] ?? '').replace(/^-/, '');
+    // Native build: the launcher itself is the program token.
+    if (LAUNCH_NAMES.has(basename(program)))
+        return true;
+    // npm / Node launcher: `node <entry> …`. The entry must carry one of the published names AND sit in a
+    // recognised install layout — a bare `node codebuddy`, or an unrelated file that merely shares the name,
+    // is not proof.
+    if (!NODE_PROGRAM_RE.test(program))
+        return false;
+    const entry = nodeEntryArgument(segments.slice(1).join(' '));
+    if (!entry || !LAUNCH_NAMES.has(basename(entry)))
+        return false;
+    return entry.includes(NPM_PACKAGE_MARKER) || /(?:^|\/)(?:\.bin|bin)\//.test(entry);
+}
+// Returns the matched row rather than a bare `true`: that row is CodeBuddy's process, and the Runtime needs
+// it as the lease anchor precisely because the pane's foreground leaf is NOT CodeBuddy. A row whose start time
+// could not be resolved is still returned — the Runtime then declines to publish a lease until it can name a
+// process generation, which is the same rule it applies to every other Agent.
+export async function verifyCodeBuddyProcess(pane, context) {
+    const group = await context.inspectForegroundGroup?.(pane);
+    // A host that cannot supply the group cannot confirm a CodeBuddy pane (the single-leaf view may return a
+    // transient tool child), so CodeBuddy goes unidentified there. That is deliberately a plain `false` and not
+    // a thrown error: an inconclusive verdict is contagious — resolveAgentIdentity downgrades the WHOLE pane to
+    // `unknown` when any ambiguous candidate is unresolved, which would poison Codex/Pi on those hosts. Every
+    // production host builds its ProcessContext from createLocalAgentProcessContext, which does supply the group.
+    if (!group)
+        return false;
+    return group.find((entry) => isCodeBuddyCommandLine(entry.commandLine ?? '')) ?? false;
+}
+export const codebuddy = {
+    adapterApiVersion: 1,
+    id: 'codebuddy',
+    label: 'CodeBuddy',
+    process: {
+        commands: ['codebuddy', 'codebuddy-code', 'cbc'],
+        ambiguousCommands: ['node'],
+        // Process presence alone establishes the sessionless run. Beyond being the base every later capability
+        // builds on, this is what puts CodeBuddy on the pane roster the phone reads: the per-window Agent badge
+        // for windows you are NOT looking at comes from the Runtime's active runs (`/states`), not from pane
+        // identity — the pane you have selected is the only one resolved by `identifyPanes`.
+        runtimeAttach: true,
+        verify: verifyCodeBuddyProcess,
+    },
+    presentation: { iconId: 'codebuddy' },
+    // Only what is actually implemented. Inbox is delivered by CodeBuddy's Claude-compatible Hooks through
+    // its own Connector (connectors/codebuddy) + the Bridge durable lane; Conversation (with composer and
+    // interrupt, like Claude's) reads the session JSONL through ../../agents/codebuddyConversation.ts;
+    // Interaction reads the pending menu off the pane through ../../agents/codebuddyInteraction.ts — its
+    // question, review and permission screens were captured from a live 2.156.0 pane and all three parse with
+    // the shared parser, with the option digit as the key that drives them.
+    // The classification of its `src`→kind events lives in ../../codebuddyEvents.ts, next to the shared
+    // Hook vocabulary, because that is the module the Connector consumes.
+    capabilities: {
+        inbox: { apiVersion: 1 },
+        conversation: { apiVersion: 1, experimental: true },
+        interaction: { apiVersion: 1 },
+    },
+};