@scotthuang/agent-knock-knock 0.3.2 → 0.4.0

package/dist/src/claude-terminal-agent-adapter.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { redactString } from "./runtime-log.js";
@@ -73,33 +72,12 @@ const CLAUDE_EXCERPT_LINES = 80;
 const CLAUDE_PERMISSION_DETAIL_LENGTH = 600;
 const CLAUDE_AUTO_APPROVAL_COMMAND_LENGTH = 2000;
 const CLAUDE_NATIVE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/u;
-const TRUSTED_CLAUDE_SHELL_PATHS = new Set([
-    "/bin/bash",
-    "/bin/dash",
-    "/bin/sh",
-    "/bin/zsh",
-    "/usr/bin/bash",
-    "/usr/bin/dash",
-    "/usr/bin/sh",
-    "/usr/bin/zsh"
-]);
-const TRUSTED_CLAUDE_SHELL_TARGETS = new Set([...TRUSTED_CLAUDE_SHELL_PATHS].flatMap((shell) => {
-    try {
-        return [fs.realpathSync(shell)];
-    }
-    catch {
-        return [];
-    }
-}));
 const ANSI_ESCAPE_PATTERN = /\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/gu;
 export function createClaudeTerminalAgentAdapter(options = {}) {
     const agentRows = options.agentRows ?? [];
-    const hookStore = options.hookStore;
     const transcriptCompletionDetector = options.detectDurableCompletion;
     const transcriptApprovalDetector = options.detectPendingApproval;
-    const trustedTokenjuiceLaunchers = options.trustedTokenjuiceLaunchers ?? [];
-    const durableCompletion = hookStore !== undefined ||
-        transcriptCompletionDetector !== undefined;
+    const durableCompletion = transcriptCompletionDetector !== undefined;
     return {
         agent: "claude",
         displayName: "Claude Code",
@@ -117,23 +95,11 @@ export function createClaudeTerminalAgentAdapter(options = {}) {
             return classifyClaudeProcess(snapshot, agentRows);
         },
         inspectScreen(screenOptions) {
-            return inspectClaudeScreenWithHooks(screenOptions, hookStore, transcriptApprovalDetector, trustedTokenjuiceLaunchers);
+            return transcriptApprovalScreenInspection(inspectClaudeScreen(screenOptions), screenOptions, transcriptApprovalDetector);
         },
-        ...(hookStore
-            ? {
-                async resolveApproval(request) {
-                    return resolveClaudeHookApproval(hookStore, request);
-                }
-            }
-            : {}),
         ...(durableCompletion
             ? {
                 async detectDurableCompletion(request) {
-                    // A configured legacy hook store is authoritative. Falling back when it
-                    // reports pending could bypass its background-task and cron evidence.
-                    if (hookStore) {
-                        return detectClaudeHookCompletion(hookStore, request);
-                    }
                     return transcriptCompletionDetector?.(request);
                 }
             }
@@ -231,34 +197,6 @@ function hasManagedClaudeApprovalIdentity(runtime) {
         Boolean(nonEmptyString(runtime?.messageId)) &&
         Boolean(nonEmptyString(runtime?.terminalTarget));
 }
-function inspectClaudeScreenWithHooks(options, hookStore, transcriptApprovalDetector, trustedTokenjuiceLaunchers) {
-    const screenInspection = inspectClaudeScreen(options);
-    if (!hookStore) {
-        return transcriptApprovalScreenInspection(screenInspection, options, transcriptApprovalDetector);
-    }
-    const identity = exactClaudeHookIdentity(options.runtime);
-    if (!identity) {
-        return screenInspection.approval.blocked
-            ? unverifiedHookApproval(screenInspection, "Claude hook permission could not be verified without an exact session id or pid")
-            : screenInspection;
-    }
-    let hookInspection;
-    try {
-        hookInspection = hookStore.inspectPermission(identity);
-    }
-    catch (error) {
-        return screenInspection.approval.blocked
-            ? unverifiedHookApproval(screenInspection, `Claude hook permission identity could not be verified: ${errorMessage(error)}`)
-            : screenInspection;
-    }
-    if (hookInspection.blocked) {
-        return hookPermissionScreenInspection(screenInspection, hookInspection, trustedTokenjuiceLaunchers);
-    }
-    if (screenInspection.approval.blocked) {
-        return unverifiedHookApproval(screenInspection, `Claude terminal permission is visible but no current structured hook request matched: ${hookInspection.reason}`);
-    }
-    return screenInspection;
-}
 function transcriptApprovalScreenInspection(screenInspection, options, detector) {
     const managedPermissionInspection = (options.managedRequest || hasManagedClaudeApprovalIdentity(options.runtime)) &&
         screenInspection.approval.blocked &&
@@ -364,105 +302,8 @@ function privacySafeManagedClaudePermissionInspection(screenInspection, screen,
         screenExcerpt: omitClaudePermissionDetails(screen, undefined, maxExcerptLength)
     };
 }
-function hookPermissionScreenInspection(screenInspection, hookInspection, trustedTokenjuiceLaunchers) {
-    if (!hookInspection.approvable) {
-        return {
-            ...screenInspection,
-            activity: {
-                state: "awaiting_approval",
-                reason: hookInspection.reason
-            },
-            approval: {
-                blocked: true,
-                approvable: false,
-                reason: hookInspection.reason,
-                promptKind: "claude_permission"
-            }
-        };
-    }
-    const display = claudePermissionDisplay(hookInspection.toolName, hookInspection.toolInput);
-    const command = hookInspection.command === undefined
-        ? undefined
-        : claudePermissionCommandForApproval(hookInspection.command, trustedTokenjuiceLaunchers);
-    const requestDetail = command && command.command === undefined
-        ? [
-            command.display ? `Command: ${command.display}` : undefined,
-            display.requestDetail
-        ].filter((value) => Boolean(value))
-            .join("; ")
-            .slice(0, CLAUDE_PERMISSION_DETAIL_LENGTH)
-        : display.requestDetail;
-    return {
-        ...screenInspection,
-        activity: {
-            state: "awaiting_approval",
-            reason: hookInspection.reason
-        },
-        approval: {
-            blocked: true,
-            approvable: true,
-            promptKind: hookInspection.promptKind,
-            cwd: hookInspection.cwd,
-            toolName: display.toolName,
-            ...(requestDetail ? { requestDetail } : {}),
-            ...(command?.command === undefined ? {} : { command: command.command }),
-            action: {
-                mode: "structured",
-                keys: [],
-                label: "Allow once",
-                requestId: hookInspection.requestId
-            }
-        }
-    };
-}
-/**
- * Tokenjuice's official Claude PreToolUse hook wraps Bash through a login shell before
- * PermissionRequest runs. Recover only that exact, source-tagged shape so policy matching
- * sees Claude's original command; every other wrapper remains visible and fails closed.
- */
-export function normalizeClaudePermissionCommand(command, trustedTokenjuiceLaunchers = []) {
-    const tokens = tokenizeTrustedWrapperCommand(command);
-    let normalized = command;
-    const launcher = tokens?.[0];
-    const canonicalLauncher = launcher && path.isAbsolute(launcher)
-        ? realpathOrUndefined(launcher)
-        : undefined;
-    const trustedLauncher = launcher
-        ? trustedTokenjuiceLaunchers.find((candidate) => candidate.configuredPath === launcher)
-        : undefined;
-    if (tokens &&
-        canonicalLauncher &&
-        trustedLauncher?.canonicalPath === canonicalLauncher &&
-        tokens[1] === "wrap") {
-        let index = 2;
-        if (tokens[index] === "--source" && tokens[index + 1] === "claude-code") {
-            index += 2;
-        }
-        else if (tokens[index] === "--source=claude-code") {
-            index += 1;
-        }
-        else {
-            return command;
-        }
-        const shell = tokens[index + 1];
-        const canonicalShell = shell && path.isAbsolute(shell)
-            ? realpathOrUndefined(shell)
-            : undefined;
-        if (tokens[index] === "--" &&
-            shell !== undefined &&
-            TRUSTED_CLAUDE_SHELL_PATHS.has(shell) &&
-            canonicalShell !== undefined &&
-            TRUSTED_CLAUDE_SHELL_TARGETS.has(canonicalShell) &&
-            tokens[index + 2] === "-lc" &&
-            tokens.length === index + 4 &&
-            tokens[index + 3]) {
-            normalized = tokens[index + 3];
-        }
-    }
-    return normalized;
-}
-export function claudePermissionCommandForApproval(command, trustedTokenjuiceLaunchers = []) {
-    const normalized = normalizeClaudePermissionCommand(command, trustedTokenjuiceLaunchers);
+export function claudePermissionCommandForApproval(command) {
+    const normalized = command;
     const redacted = redactString(normalized);
     const display = singleLineClaudePermissionValue(redacted, CLAUDE_PERMISSION_DETAIL_LENGTH - 20);
     const policySafe = normalized.length <= CLAUDE_AUTO_APPROVAL_COMMAND_LENGTH && redacted === normalized;
@@ -471,39 +312,6 @@ export function claudePermissionCommandForApproval(command, trustedTokenjuiceLau
         display
     };
 }
-function claudePermissionDisplay(toolName, toolInput) {
-    const safeToolName = singleLineClaudePermissionValue(toolName, 120) || "Unknown Claude tool";
-    if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) {
-        return { toolName: safeToolName };
-    }
-    const input = toolInput;
-    const fields = [
-        ["file_path", "File"],
-        ["path", "Path"],
-        ["notebook_path", "Notebook"],
-        ["url", "URL"],
-        ["query", "Query"],
-        ["pattern", "Pattern"],
-        ["description", "Description"],
-        ["domain", "Domain"]
-    ];
-    const details = [];
-    for (const [key, label] of fields) {
-        const value = input[key];
-        if (typeof value !== "string") {
-            continue;
-        }
-        const safeValue = singleLineClaudePermissionValue(value, 300);
-        if (safeValue) {
-            details.push(`${label}: ${safeValue}`);
-        }
-        if (details.length === 3) {
-            break;
-        }
-    }
-    const requestDetail = details.join("; ").slice(0, CLAUDE_PERMISSION_DETAIL_LENGTH);
-    return requestDetail ? { toolName: safeToolName, requestDetail } : { toolName: safeToolName };
-}
 function singleLineClaudePermissionValue(value, maxLength) {
     return redactString(value)
         .replace(/[\u0000-\u001F\u007F]+/gu, " ")
@@ -511,239 +319,6 @@ function singleLineClaudePermissionValue(value, maxLength) {
         .trim()
         .slice(0, maxLength);
 }
-function unverifiedHookApproval(screenInspection, reason) {
-    return {
-        ...screenInspection,
-        activity: {
-            state: "awaiting_approval",
-            reason
-        },
-        approval: {
-            blocked: true,
-            approvable: false,
-            reason,
-            promptKind: screenInspection.approval.promptKind ?? "claude_permission",
-            ...(screenInspection.approval.command === undefined
-                ? {}
-                : { command: screenInspection.approval.command })
-        }
-    };
-}
-async function resolveClaudeHookApproval(hookStore, request) {
-    if (request.expectedFingerprint !== request.actualFingerprint) {
-        return {
-            resolved: false,
-            reason: "Claude approval fingerprint changed before the structured decision"
-        };
-    }
-    if (!request.inspection.approval.approvable ||
-        request.inspection.approval.action.mode !== "structured" ||
-        !request.inspection.approval.action.requestId) {
-        return {
-            resolved: false,
-            reason: "Claude approval is not a current structured hook request"
-        };
-    }
-    const runtime = request.runtime;
-    const identity = exactClaudeHookIdentity(runtime);
-    if (!identity || !runtime?.conversationId || !runtime.messageId) {
-        return {
-            resolved: false,
-            requestId: request.inspection.approval.action.requestId,
-            reason: "Claude structured approval requires exact session or pid plus conversation and message identity"
-        };
-    }
-    try {
-        const current = hookStore.inspectPermission(identity);
-        if (!current.blocked || !current.approvable) {
-            return {
-                resolved: false,
-                requestId: request.inspection.approval.action.requestId,
-                reason: current.reason
-            };
-        }
-        if (current.requestId !== request.inspection.approval.action.requestId) {
-            return {
-                resolved: false,
-                requestId: current.requestId,
-                reason: "Claude permission request changed before the structured decision"
-            };
-        }
-        if (current.conversationId !== runtime.conversationId || current.messageId !== runtime.messageId) {
-            return {
-                resolved: false,
-                requestId: current.requestId,
-                reason: "Claude permission request belongs to a different conversation message"
-            };
-        }
-        if (runtime.sessionId !== undefined && current.sessionId !== runtime.sessionId) {
-            return {
-                resolved: false,
-                requestId: current.requestId,
-                reason: "Claude permission request belongs to a different session"
-            };
-        }
-        const lease = hookStore.resolveLease(identity);
-        if (!lease?.authorizationEligible ||
-            lease.lease.conversationId !== runtime.conversationId ||
-            lease.lease.messageId !== runtime.messageId ||
-            (runtime.terminalTarget !== undefined && lease.lease.terminalTarget !== runtime.terminalTarget)) {
-            return {
-                resolved: false,
-                requestId: current.requestId,
-                reason: "Claude managed lease no longer matches the terminal conversation"
-            };
-        }
-        hookStore.decidePermission({
-            sessionId: current.sessionId,
-            requestId: current.requestId,
-            fingerprint: current.fingerprint,
-            conversationId: runtime.conversationId,
-            messageId: runtime.messageId,
-            decision: request.decision,
-            ...(request.decision === "deny" && request.interrupt !== undefined
-                ? { interrupt: request.interrupt }
-                : {})
-        });
-        return {
-            resolved: true,
-            requestId: current.requestId,
-            reason: request.decision === "allow"
-                ? "Claude one-time permission was allowed through the structured hook"
-                : "Claude permission was denied through the structured hook"
-        };
-    }
-    catch (error) {
-        return {
-            resolved: false,
-            requestId: request.inspection.approval.action.requestId,
-            reason: `Claude structured permission could not be resolved: ${errorMessage(error)}`
-        };
-    }
-}
-async function detectClaudeHookCompletion(hookStore, request) {
-    if (!request.startedAt) {
-        return undefined;
-    }
-    const runtime = completionRuntime(request.context);
-    if (!runtime.conversationId || !runtime.messageId) {
-        return undefined;
-    }
-    const identity = {
-        ...(runtime.sessionId ?? request.sessionId
-            ? { sessionId: runtime.sessionId ?? request.sessionId }
-            : {}),
-        ...(runtime.pid === undefined ? {} : { pid: runtime.pid }),
-        ...(runtime.cwd ?? request.cwd ? { cwd: runtime.cwd ?? request.cwd } : {}),
-        requireUnique: true
-    };
-    if (!identity.sessionId && identity.pid === undefined && !identity.cwd) {
-        return undefined;
-    }
-    let completion;
-    try {
-        completion = hookStore.detectCompletion({
-            ...identity,
-            startedAt: request.startedAt,
-            ...(runtime.promptId === undefined ? {} : { promptId: runtime.promptId }),
-            conversationId: runtime.conversationId,
-            messageId: runtime.messageId
-        });
-    }
-    catch {
-        return undefined;
-    }
-    if (completion.status === "done") {
-        return {
-            source: "durable",
-            outcome: "success",
-            text: completion.text,
-            timestamp: completion.timestamp,
-            id: completion.eventId,
-            confidence: "high",
-            metadata: {
-                match: "claude_stop_hook",
-                session_id: completion.sessionId,
-                prompt_id: completion.promptId,
-                cwd: completion.cwd
-            }
-        };
-    }
-    if (completion.status === "failed") {
-        return {
-            source: "durable",
-            outcome: "failure",
-            text: claudeFailureText(completion),
-            timestamp: completion.failure.receivedAt,
-            id: completion.failure.eventId,
-            confidence: "high",
-            metadata: {
-                match: "claude_stop_failure_hook",
-                session_id: completion.sessionId,
-                prompt_id: completion.promptId,
-                error: completion.failure.code,
-                ...(completion.failure.details === undefined
-                    ? {}
-                    : { error_details: completion.failure.details })
-            }
-        };
-    }
-    // Pending background work and unknown/incomplete hook payloads are not completion evidence.
-    return undefined;
-}
-function exactClaudeHookIdentity(runtime) {
-    if (!runtime || (runtime.sessionId === undefined && runtime.pid === undefined)) {
-        return undefined;
-    }
-    return {
-        ...(runtime.sessionId === undefined ? {} : { sessionId: runtime.sessionId }),
-        ...(runtime.pid === undefined ? {} : { pid: runtime.pid }),
-        ...(runtime.cwd === undefined ? {} : { cwd: runtime.cwd }),
-        requireUnique: true
-    };
-}
-function completionRuntime(context) {
-    const direct = recordValue(context);
-    const nativeTakeover = recordValue(direct?.nativeTakeover);
-    const conversation = recordValue(direct?.conversation);
-    return {
-        sessionId: nonEmptyString(nativeTakeover?.terminal_agent_session_id) ??
-            nonEmptyString(direct?.sessionId),
-        pid: positiveInteger(nativeTakeover?.terminal_agent_pid) ?? positiveInteger(direct?.pid),
-        cwd: nonEmptyString(nativeTakeover?.source_cwd) ?? nonEmptyString(direct?.cwd),
-        promptId: nonEmptyString(nativeTakeover?.terminal_agent_prompt_id) ??
-            nonEmptyString(direct?.promptId) ??
-            nonEmptyString(direct?.prompt_id),
-        conversationId: nonEmptyString(direct?.conversationId) ??
-            nonEmptyString(conversation?.conversation_id),
-        messageId: nonEmptyString(direct?.messageId) ??
-            nonEmptyString(nativeTakeover?.terminal_bridge_message_id)
-    };
-}
-function claudeFailureText(completion) {
-    const details = completion.failure.details === undefined
-        ? undefined
-        : typeof completion.failure.details === "string"
-            ? completion.failure.details
-            : JSON.stringify(completion.failure.details);
-    return [
-        `Claude Code turn failed (${completion.failure.code}).`,
-        completion.failure.message,
-        details === undefined ? undefined : `Details: ${details}`
-    ].filter((part) => Boolean(part)).join(" ");
-}
-function recordValue(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function positiveInteger(value) {
-    const parsed = typeof value === "number" ? value : Number(value);
-    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 export function detectClaudeApprovalPrompt(screen) {
     const lines = claudeDetectionTail(screen);
     const markerIndexes = lines
@@ -1030,66 +605,6 @@ function shortOptionValue(args, option) {
     }
     return undefined;
 }
-function realpathOrUndefined(value) {
-    try {
-        return fs.realpathSync(value);
-    }
-    catch {
-        return undefined;
-    }
-}
-function tokenizeTrustedWrapperCommand(command) {
-    const tokens = [];
-    let token = "";
-    let quote;
-    let escaped = false;
-    let started = false;
-    for (const character of command.trim()) {
-        if (escaped) {
-            token += character;
-            escaped = false;
-            started = true;
-            continue;
-        }
-        if (character === "\\" && quote !== "'") {
-            escaped = true;
-            started = true;
-            continue;
-        }
-        if (quote) {
-            if (character === quote) {
-                quote = undefined;
-            }
-            else {
-                token += character;
-            }
-            started = true;
-            continue;
-        }
-        if (character === "'" || character === '"') {
-            quote = character;
-            started = true;
-            continue;
-        }
-        if (/\s/u.test(character)) {
-            if (started) {
-                tokens.push(token);
-                token = "";
-                started = false;
-            }
-            continue;
-        }
-        token += character;
-        started = true;
-    }
-    if (escaped || quote) {
-        return undefined;
-    }
-    if (started) {
-        tokens.push(token);
-    }
-    return tokens;
-}
 function tokenizeCommand(command) {
     const tokens = [];
     let token = "";