@unlinearity/cli-wechat-bridge 1.0.0 → 1.0.2

package/dist/bridge/bridge-adapters.shell.js

@@ -0,0 +1,363 @@
+import { getInteractiveShellCommandRejectionMessage, isHighRiskShellCommand, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
+import * as shared from "./bridge-adapters.shared.js";
+const { buildShellInputPayload, buildShellProfileCommand, resolveShellRuntime, } = shared;
+export class ShellCommandRejectedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ShellCommandRejectedError";
+    }
+}
+export class ShellAdapter extends AbstractPtyAdapter {
+    static COMPLETION_MARKER_PREFIX = "__WECHAT_BRIDGE_DONE__";
+    static POWERSHELL_LEADING_NOISE_PATTERNS = [
+        /^PS>>\s*/u,
+        /^PS [^>\n]*>\s*/u,
+        /^PS>\s*/u,
+        /^>>\s*/u,
+        /^>\s*/u,
+        /^function global:prompt \{ "" \}/u,
+        /^\$__wechatBridgePreviousErrorActionPreference = \$ErrorActionPreference/u,
+        /^\$ErrorActionPreference = 'Continue'/u,
+        /^\$global:LASTEXITCODE = 0/u,
+        /^try \{/u,
+        /^\$decoded = \[System\.Text\.Encoding\]::UTF8\.GetString\(\[System\.Convert\]::FromBase64String\(".*"\)\)/u,
+        /^\$scriptBlock = \[scriptblock\]::Create\(\$decoded\)/u,
+        /^& \$scriptBlock/u,
+        /^\} catch \{/u,
+        /^Write-Error \$_/u,
+        /^\$global:LASTEXITCODE = 1/u,
+        /^\} finally \{/u,
+        /^if \(-not \(\$global:LASTEXITCODE -is \[int\]\)\) \{ \$global:LASTEXITCODE = 0 \}/u,
+        /^Write-Output "__WECHAT_BRIDGE_DONE__:[^"]*"/u,
+        /^\$ErrorActionPreference = \$__wechatBridgePreviousErrorActionPreference/u,
+        /^\}/u,
+    ];
+    pendingShellCommand = null;
+    interruptTimer = null;
+    outputBuffer = "";
+    currentCompletionMarker = null;
+    expectedEchoLines = [];
+    commandSequence = 0;
+    buildSpawnArgs() {
+        return this.getShellRuntime().launchArgs;
+    }
+    buildEnv() {
+        const env = super.buildEnv();
+        if (this.getShellRuntime().family === "posix") {
+            env.PS1 = "";
+            env.PROMPT = "";
+            env.RPROMPT = "";
+        }
+        return env;
+    }
+    afterStart() {
+        if (this.options.profile) {
+            this.writeToPty(`${buildShellProfileCommand(this.options.profile, this.getShellRuntime().family)}\r`);
+        }
+        if (this.getShellRuntime().family === "powershell") {
+            this.writeToPty('function global:prompt { "" }\r');
+        }
+    }
+    async sendInput(text) {
+        if (!this.pty) {
+            throw new Error("shell adapter is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("shell is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingApproval || this.state.status === "awaiting_approval") {
+            throw new Error("A shell approval request is pending. Reply with /confirm <code> or /deny.");
+        }
+        const rejectionMessage = getInteractiveShellCommandRejectionMessage(text);
+        if (rejectionMessage) {
+            throw new ShellCommandRejectedError(rejectionMessage);
+        }
+        if (isHighRiskShellCommand(text)) {
+            this.pendingShellCommand = text;
+            const request = {
+                source: "shell",
+                summary: "High-risk shell command detected. Confirmation is required.",
+                commandPreview: truncatePreview(text, 180),
+            };
+            this.pendingApproval = request;
+            this.state.pendingApproval = request;
+            this.state.pendingApprovalOrigin = "wechat";
+            this.setStatus("awaiting_approval", "Waiting for shell command approval.");
+            this.emit({
+                type: "approval_required",
+                request,
+                timestamp: nowIso(),
+            });
+            return;
+        }
+        this.startShellCommand(text);
+    }
+    async interrupt() {
+        if (!this.pty) {
+            return false;
+        }
+        this.writeToPty("\u0003");
+        this.clearInterruptTimer();
+        this.interruptTimer = setTimeout(() => {
+            this.interruptTimer = null;
+            if (this.state.status === "busy" || this.state.status === "awaiting_approval") {
+                this.finishShellCommand({
+                    summary: "Interrupted",
+                    statusMessage: "Shell command interrupted.",
+                });
+            }
+        }, 1_500);
+        return true;
+    }
+    async applyApproval(action, _pendingApproval) {
+        if (!this.pendingApproval) {
+            return false;
+        }
+        if (action === "deny") {
+            this.pendingShellCommand = null;
+            this.finishShellCommand({
+                summary: "Denied",
+                statusMessage: "Shell command denied.",
+            });
+            return true;
+        }
+        const command = this.pendingShellCommand;
+        if (!command) {
+            return false;
+        }
+        this.pendingShellCommand = null;
+        this.startShellCommand(command);
+        return true;
+    }
+    handleData(rawText) {
+        const text = normalizeOutput(rawText);
+        if (!text) {
+            return;
+        }
+        this.state.lastOutputAt = nowIso();
+        if (!this.hasAcceptedInput) {
+            return;
+        }
+        this.outputBuffer = `${this.outputBuffer}${text}`;
+        this.flushShellOutputBuffer();
+    }
+    handleExit(exitCode) {
+        if (this.hasAcceptedInput) {
+            this.flushShellOutputBuffer(true);
+        }
+        this.resetShellCommandState();
+        super.handleExit(exitCode);
+    }
+    getShellRuntime() {
+        return resolveShellRuntime(this.options.command);
+    }
+    startShellCommand(text) {
+        if (!this.pty) {
+            throw new Error(`${this.options.kind} adapter is not running.`);
+        }
+        this.clearInterruptTimer();
+        this.resetShellCommandState({
+            preserveStatus: true,
+            preservePreview: true,
+        });
+        const completionMarker = this.createCompletionMarker();
+        const payload = buildShellInputPayload(text, this.getShellRuntime().family, completionMarker);
+        this.hasAcceptedInput = true;
+        this.currentPreview = truncatePreview(text);
+        this.state.lastInputAt = nowIso();
+        this.state.activeTurnOrigin = "wechat";
+        this.pendingApproval = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.currentCompletionMarker = completionMarker;
+        this.expectedEchoLines = normalizeOutput(payload)
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        this.writeToPty(payload);
+        this.setStatus("busy");
+    }
+    flushShellOutputBuffer(force = false) {
+        const lastNewlineIndex = this.outputBuffer.lastIndexOf("\n");
+        if (!force && lastNewlineIndex < 0) {
+            return;
+        }
+        const sliceEnd = force
+            ? this.outputBuffer.length
+            : Math.max(0, lastNewlineIndex + 1);
+        if (sliceEnd === 0) {
+            return;
+        }
+        const chunk = this.outputBuffer.slice(0, sliceEnd);
+        this.outputBuffer = this.outputBuffer.slice(sliceEnd);
+        const visibleLines = [];
+        let completedExitCode = null;
+        for (const rawLine of chunk.split("\n")) {
+            if (!rawLine && !force) {
+                continue;
+            }
+            const completionExitCode = this.parseCompletionExitCode(rawLine);
+            if (completionExitCode !== null) {
+                completedExitCode = completionExitCode;
+                continue;
+            }
+            const filtered = this.filterShellOutputLine(rawLine);
+            if (filtered) {
+                visibleLines.push(filtered);
+            }
+        }
+        const visibleText = visibleLines.join("\n").trim();
+        if (visibleText) {
+            this.emit({
+                type: "stdout",
+                text: visibleText,
+                timestamp: nowIso(),
+            });
+        }
+        if (completedExitCode !== null) {
+            this.finishShellCommand({ exitCode: completedExitCode });
+        }
+    }
+    filterShellOutputLine(line) {
+        const cleanedLine = this.getShellRuntime().family === "powershell"
+            ? this.stripLeadingPowerShellNoise(line)
+            : line;
+        const trimmed = cleanedLine.trim();
+        if (!trimmed) {
+            return null;
+        }
+        if (this.consumeExpectedEchoLine(trimmed)) {
+            return null;
+        }
+        if (this.isShellPromptLine(trimmed)) {
+            return null;
+        }
+        if (this.getShellRuntime().family === "posix") {
+            if (trimmed === "__wechat_bridge_status=$?" ||
+                trimmed.startsWith("printf '%s:%s\\n'") ||
+                trimmed.startsWith("printf '__WECHAT_BRIDGE_DONE__:%s")) {
+                return null;
+            }
+        }
+        return cleanedLine;
+    }
+    consumeExpectedEchoLine(line) {
+        if (!this.expectedEchoLines.length) {
+            return false;
+        }
+        const normalizedLine = this.normalizeEchoLine(line);
+        if (normalizedLine !== this.expectedEchoLines[0]) {
+            return false;
+        }
+        this.expectedEchoLines.shift();
+        return true;
+    }
+    normalizeEchoLine(line) {
+        const trimmed = line.trim();
+        if (this.getShellRuntime().family === "powershell") {
+            return trimmed.replace(/^(?:PS [^>]*>\s*|PS>\s*|>>\s*|>\s*)+/u, "").trim();
+        }
+        return trimmed.replace(/^(?:[$#>]\s*)+/u, "").trim();
+    }
+    isShellPromptLine(line) {
+        if (this.getShellRuntime().family === "powershell") {
+            return /^(?:PS [^>]*>\s*|PS>\s*|>>\s*|>\s*)+$/u.test(line);
+        }
+        return /^(?:[$#>]\s*)+$/u.test(line);
+    }
+    parseCompletionExitCode(line) {
+        const marker = this.currentCompletionMarker;
+        if (!marker) {
+            return null;
+        }
+        const trimmed = this.stripLeadingShellPromptTokens(line).trim();
+        const prefix = `${marker}:`;
+        if (!trimmed.startsWith(prefix)) {
+            return null;
+        }
+        const exitCodeText = trimmed.slice(prefix.length).trim();
+        if (!/^-?\d+$/u.test(exitCodeText)) {
+            return null;
+        }
+        return Number(exitCodeText);
+    }
+    finishShellCommand(options) {
+        const summary = options.summary ?? this.currentPreview;
+        this.resetShellCommandState();
+        this.setStatus("idle", options.statusMessage);
+        this.emit({
+            type: "task_complete",
+            exitCode: options.exitCode,
+            summary,
+            timestamp: nowIso(),
+        });
+    }
+    resetShellCommandState(options = {}) {
+        this.clearInterruptTimer();
+        this.clearCompletionTimer();
+        this.pendingApproval = null;
+        this.pendingShellCommand = null;
+        this.state.pendingApproval = null;
+        this.state.pendingApprovalOrigin = undefined;
+        this.state.activeTurnOrigin = undefined;
+        this.hasAcceptedInput = false;
+        this.outputBuffer = "";
+        this.currentCompletionMarker = null;
+        this.expectedEchoLines = [];
+        if (!options.preservePreview) {
+            this.currentPreview = "(idle)";
+        }
+        if (!options.preserveStatus && this.state.status !== "stopped") {
+            this.state.status = "idle";
+        }
+    }
+    clearInterruptTimer() {
+        if (!this.interruptTimer) {
+            return;
+        }
+        clearTimeout(this.interruptTimer);
+        this.interruptTimer = null;
+    }
+    createCompletionMarker() {
+        this.commandSequence += 1;
+        return `${ShellAdapter.COMPLETION_MARKER_PREFIX}:${this.commandSequence.toString(36)}`;
+    }
+    stripLeadingPowerShellNoise(line) {
+        let text = line.trimStart();
+        while (text) {
+            let stripped = false;
+            for (const pattern of ShellAdapter.POWERSHELL_LEADING_NOISE_PATTERNS) {
+                const next = text.replace(pattern, "");
+                if (next !== text) {
+                    text = next.trimStart();
+                    stripped = true;
+                    break;
+                }
+            }
+            if (!stripped) {
+                break;
+            }
+        }
+        return text;
+    }
+    stripLeadingShellPromptTokens(line) {
+        let text = line.trimStart();
+        if (this.getShellRuntime().family === "powershell") {
+            while (true) {
+                const next = text
+                    .replace(/^PS>>\s*/u, "")
+                    .replace(/^PS [^>\n]*>\s*/u, "")
+                    .replace(/^PS>\s*/u, "")
+                    .replace(/^>>\s*/u, "")
+                    .replace(/^>\s*/u, "");
+                if (next === text) {
+                    break;
+                }
+                text = next.trimStart();
+            }
+            return text;
+        }
+        return text.replace(/^(?:[$#>]\s*)+/u, "").trimStart();
+    }
+}

package/dist/bridge/bridge-controller.js

@@ -0,0 +1,44 @@
+import { clearLocalCompanionEndpoint, readLocalCompanionEndpoint, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
+import { hasLocalClientEndpointProvider } from "../runtime/runtime-types.js";
+export class BridgeController {
+    endpointInstanceId = null;
+    adapter;
+    cwd;
+    constructor(adapter, cwd) {
+        this.adapter = adapter;
+        this.cwd = cwd;
+    }
+    syncLocalClientEndpoint() {
+        if (!hasLocalClientEndpointProvider(this.adapter)) {
+            return;
+        }
+        const endpoint = this.adapter.getLocalClientEndpoint();
+        if (!endpoint) {
+            this.clearLocalClientEndpoint();
+            return;
+        }
+        const existing = readLocalCompanionEndpoint(this.cwd);
+        const adapterState = this.adapter.getState();
+        const nextEndpoint = existing?.instanceId === endpoint.instanceId
+            ? {
+                ...endpoint,
+                companionPid: endpoint.companionPid ?? existing.companionPid,
+                companionConnectedAt: endpoint.companionConnectedAt ?? existing.companionConnectedAt,
+                companionStatus: adapterState.status,
+                companionLastStateAt: new Date().toISOString(),
+                companionWorkerPid: adapterState.pid,
+            }
+            : {
+                ...endpoint,
+                companionStatus: adapterState.status,
+                companionLastStateAt: new Date().toISOString(),
+                companionWorkerPid: adapterState.pid,
+            };
+        this.endpointInstanceId = endpoint.instanceId;
+        writeLocalCompanionEndpoint(nextEndpoint);
+    }
+    clearLocalClientEndpoint() {
+        clearLocalCompanionEndpoint(this.cwd, this.endpointInstanceId ?? undefined);
+        this.endpointInstanceId = null;
+    }
+}

package/dist/bridge/bridge-final-reply.js

@@ -0,0 +1,31 @@
+import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, } from "./bridge-utils.js";
+export async function forwardWechatFinalReply(params) {
+    const { adapter, rawText, sender } = params;
+    const parsed = parseWechatFinalReply(rawText);
+    const visibleText = formatFinalReplyMessage(adapter, sanitizeWechatFinalReplyText(adapter, parsed.visibleText)).trim();
+    if (visibleText) {
+        await sender.sendText(visibleText);
+    }
+    for (const attachment of parsed.attachments) {
+        try {
+            switch (attachment.kind) {
+                case "image":
+                    await sender.sendImage(attachment.path);
+                    break;
+                case "file":
+                    await sender.sendFile(attachment.path);
+                    break;
+                case "voice":
+                    await sender.sendVoice(attachment.path);
+                    break;
+                case "video":
+                    await sender.sendVideo(attachment.path);
+                    break;
+            }
+        }
+        catch (error) {
+            const errorText = error instanceof Error ? error.message : String(error ?? "unknown error");
+            await sender.sendText(`Failed to send ${attachment.kind} attachment: ${attachment.path}\n${errorText}`);
+        }
+    }
+}