cli-wechat-bridge 1.0.5

package/dist/bridge/claude-hook.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import net from "node:net";
+async function readStdin() {
+    return await new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => {
+            chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+        });
+        process.stdin.on("end", () => {
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        process.stdin.resume();
+    });
+}
+async function main() {
+    const portText = process.env.CLAUDE_WECHAT_HOOK_PORT;
+    const token = process.env.CLAUDE_WECHAT_HOOK_TOKEN;
+    const port = portText ? Number.parseInt(portText, 10) : Number.NaN;
+    if (!token || !Number.isInteger(port) || port <= 0) {
+        return;
+    }
+    const payload = await readStdin();
+    if (!payload.trim()) {
+        return;
+    }
+    const requestId = crypto.randomUUID();
+    let stdout = "";
+    await new Promise((resolve) => {
+        const socket = net.connect({ host: "127.0.0.1", port });
+        let buffer = "";
+        const finish = () => {
+            try {
+                socket.destroy();
+            }
+            catch {
+                // Best effort cleanup.
+            }
+            resolve();
+        };
+        socket.once("connect", () => {
+            try {
+                socket.write(`${JSON.stringify({ token, requestId, payload })}\n`);
+            }
+            catch {
+                finish();
+            }
+        });
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            while (true) {
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex < 0) {
+                    break;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line) {
+                    continue;
+                }
+                try {
+                    const response = JSON.parse(line);
+                    if (response.requestId === requestId && typeof response.stdout === "string") {
+                        stdout = response.stdout;
+                    }
+                }
+                catch {
+                    // Ignore malformed hook responses.
+                }
+            }
+        });
+        socket.once("close", finish);
+        socket.once("error", finish);
+    });
+    if (stdout) {
+        process.stdout.write(stdout);
+    }
+}
+main().catch(() => {
+    process.exit(0);
+});

package/dist/bridge/claude-hooks.js

@@ -0,0 +1,267 @@
+import { normalizeOutput, truncatePreview } from "./bridge-utils.js";
+function quoteWindowsCommandArg(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function quotePosixCommandArg(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function parseClaudeHookPayload(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractClaudeResumeConversationId(transcriptPath) {
+    if (typeof transcriptPath !== "string") {
+        return null;
+    }
+    const trimmed = transcriptPath.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const segments = trimmed.split(/[\\/]+/);
+    const fileName = segments[segments.length - 1] ?? "";
+    if (!fileName.toLowerCase().endsWith(".jsonl")) {
+        return null;
+    }
+    const conversationId = fileName.slice(0, -".jsonl".length).trim();
+    return conversationId || null;
+}
+export function buildClaudeHookSettings(command) {
+    const hook = {
+        hooks: [
+            {
+                type: "command",
+                command,
+            },
+        ],
+    };
+    return {
+        hooks: {
+            SessionStart: [hook],
+            UserPromptSubmit: [hook],
+            PermissionRequest: [hook],
+            Notification: [
+                {
+                    matcher: "permission_prompt",
+                    hooks: hook.hooks,
+                },
+            ],
+            Stop: [hook],
+            StopFailure: [hook],
+        },
+    };
+}
+export function buildClaudeHookScript(params) {
+    const runtimeArgs = ["--no-warnings"];
+    if (params.hookEntryPath.endsWith(".ts")) {
+        runtimeArgs.push("--experimental-strip-types");
+    }
+    runtimeArgs.push(params.hookEntryPath);
+    if (params.platform === "win32") {
+        const command = [
+            params.runtimeExecPath,
+            ...runtimeArgs,
+        ].map(quoteWindowsCommandArg).join(" ");
+        return [
+            "@echo off",
+            "setlocal",
+            `set "CLAUDE_WECHAT_HOOK_PORT=${params.hookPort}"`,
+            `set "CLAUDE_WECHAT_HOOK_TOKEN=${params.hookToken}"`,
+            // Claude reads hook decisions from stdout, so only stderr can be discarded here.
+            `${command} 2>nul`,
+            "exit /b 0",
+        ].join("\r\n");
+    }
+    const command = [
+        params.runtimeExecPath,
+        ...runtimeArgs,
+    ].map(quotePosixCommandArg).join(" ");
+    return [
+        "#!/bin/sh",
+        `export CLAUDE_WECHAT_HOOK_PORT=${quotePosixCommandArg(String(params.hookPort))}`,
+        `export CLAUDE_WECHAT_HOOK_TOKEN=${quotePosixCommandArg(params.hookToken)}`,
+        // Claude reads hook decisions from stdout, so only stderr can be discarded here.
+        `${command} 2>/dev/null || true`,
+        "exit 0",
+    ].join("\n");
+}
+function summarizeClaudePlan(plan) {
+    const lines = normalizeOutput(plan)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0) {
+        return "(empty plan)";
+    }
+    const heading = lines
+        .find((line) => /^#+\s+/.test(line))
+        ?.replace(/^#+\s+/, "")
+        .trim();
+    const description = lines.find((line) => !/^#+\s+/.test(line) &&
+        !/^[-*]\s+/.test(line) &&
+        !/^\d+\.\s+/.test(line));
+    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0] || "(empty plan)", 180);
+}
+function summarizeClaudeToolInput(toolName, toolInput) {
+    if (!toolInput) {
+        return {
+            detailLabel: "details",
+            detailPreview: "(no input)",
+        };
+    }
+    if (toolName === "ExitPlanMode" && typeof toolInput.plan === "string") {
+        return {
+            detailLabel: "plan",
+            detailPreview: summarizeClaudePlan(toolInput.plan),
+        };
+    }
+    if (typeof toolInput.command === "string" && toolInput.command.trim()) {
+        return {
+            detailLabel: "command",
+            detailPreview: toolInput.command.trim(),
+        };
+    }
+    if (typeof toolInput.file_path === "string" && toolInput.file_path.trim()) {
+        return {
+            detailLabel: "path",
+            detailPreview: toolInput.file_path.trim(),
+        };
+    }
+    if (typeof toolInput.pattern === "string" && toolInput.pattern.trim()) {
+        return {
+            detailLabel: "pattern",
+            detailPreview: toolInput.pattern.trim(),
+        };
+    }
+    if (typeof toolInput.url === "string" && toolInput.url.trim()) {
+        return {
+            detailLabel: "url",
+            detailPreview: toolInput.url.trim(),
+        };
+    }
+    return {
+        detailLabel: "details",
+        detailPreview: truncatePreview(JSON.stringify(toolInput), 180),
+    };
+}
+export function buildClaudePermissionApprovalRequest(payload) {
+    const toolName = typeof payload.tool_name === "string" && payload.tool_name.trim()
+        ? payload.tool_name.trim()
+        : "Tool";
+    const { detailLabel, detailPreview } = summarizeClaudeToolInput(toolName, payload.tool_input);
+    return {
+        source: "cli",
+        summary: `Claude permission is required for ${toolName}.`,
+        commandPreview: `${toolName}: ${detailPreview}`,
+        toolName,
+        detailLabel,
+        detailPreview,
+    };
+}
+export function buildClaudePermissionDecisionHookOutput(action) {
+    const decision = action === "confirm"
+        ? {
+            behavior: "allow",
+        }
+        : {
+            behavior: "deny",
+            message: "Permission denied from WeChat bridge.",
+            interrupt: false,
+        };
+    return JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "PermissionRequest",
+            decision,
+        },
+    });
+}
+export function extractClaudeAssistantMessageText(payload) {
+    return typeof payload.last_assistant_message === "string"
+        ? normalizeOutput(payload.last_assistant_message).trim()
+        : "";
+}
+function extractClaudeAssistantContentText(content) {
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = content
+        .flatMap((item) => {
+        if (!item || typeof item !== "object") {
+            return [];
+        }
+        const candidate = item;
+        if (candidate.type !== "text" || typeof candidate.text !== "string") {
+            return [];
+        }
+        const text = normalizeOutput(candidate.text).trim();
+        return text ? [text] : [];
+    });
+    return parts.join("\n\n").trim();
+}
+export function extractClaudeTranscriptFinalReply(rawTranscript) {
+    const lines = rawTranscript.split(/\r?\n/);
+    let fallbackText = null;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index]?.trim();
+        if (!line) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object") {
+            continue;
+        }
+        if (parsed.type !== "assistant" || !parsed.message || parsed.message.role !== "assistant") {
+            continue;
+        }
+        const text = extractClaudeAssistantContentText(parsed.message.content);
+        if (!text) {
+            continue;
+        }
+        if (parsed.message.stop_reason === "end_turn") {
+            return text;
+        }
+        fallbackText ??= text;
+    }
+    return fallbackText;
+}
+export function normalizeClaudeAssistantMessage(payload) {
+    return extractClaudeAssistantMessageText(payload) || "(no final reply)";
+}
+export function buildClaudeFailureMessage(payload) {
+    const details = [
+        typeof payload.last_assistant_message === "string"
+            ? normalizeOutput(payload.last_assistant_message).trim()
+            : "",
+        typeof payload.error_details === "string"
+            ? normalizeOutput(payload.error_details).trim()
+            : "",
+        typeof payload.error === "string" ? payload.error.trim() : "",
+    ].filter(Boolean);
+    return truncatePreview(details.join(" | ") || "Claude reported an unknown error.", 500);
+}
+export function findInjectedClaudePromptIndex(prompt, pendingInputs, nowMs = Date.now(), maxAgeMs = 15_000) {
+    const normalizedPrompt = normalizeOutput(prompt).trim();
+    if (!normalizedPrompt) {
+        return -1;
+    }
+    return pendingInputs.findIndex((candidate) => {
+        if (nowMs - candidate.createdAtMs > maxAgeMs) {
+            return false;
+        }
+        return candidate.normalizedText === normalizedPrompt;
+    });
+}