cli-wechat-bridge 1.1.2 → 1.1.4

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

@@ -0,0 +1,707 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { assertNoReservedExtraCliArgs, buildCliEnvironment, describeUnknownError, isRecord, resolveSpawnTarget, } from "./bridge-adapters.shared.js";
+import { killProcessTreeSync } from "./bridge-process-reaper.js";
+import { normalizeOutput, nowIso } from "./bridge-utils.js";
+const PI_TUI_CONNECT_WARNING_MS = 30_000;
+const PI_TUI_REQUEST_TIMEOUT_MS = 30_000;
+const PI_TUI_RECONNECT_TIMEOUT_MS = 10_000;
+const PI_TUI_MAX_BUFFER_SIZE = 8 * 1024 * 1024;
+function expandHomePath(value) {
+    if (value === "~") {
+        return os.homedir();
+    }
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return path.join(os.homedir(), value.slice(2));
+    }
+    return value;
+}
+export function buildPiSessionDirectory(cwd, env = process.env) {
+    const customSessionDir = env.PI_CODING_AGENT_SESSION_DIR;
+    if (customSessionDir) {
+        return path.resolve(expandHomePath(customSessionDir));
+    }
+    const agentDir = env.PI_CODING_AGENT_DIR
+        ? path.resolve(expandHomePath(env.PI_CODING_AGENT_DIR))
+        : path.join(os.homedir(), ".pi", "agent");
+    const resolvedCwd = path.resolve(cwd);
+    const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    return path.join(agentDir, "sessions", safePath);
+}
+function extractMessageText(message) {
+    if (!isRecord(message)) {
+        return "";
+    }
+    const content = message.content;
+    if (typeof content === "string") {
+        return normalizeOutput(content).trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return normalizeOutput(content
+        .filter((block) => isRecord(block))
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n")).trim();
+}
+function summarizePiSessionFile(filePath, cwd) {
+    try {
+        const entries = fs
+            .readFileSync(filePath, "utf8")
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((entry) => isRecord(entry));
+        const header = entries.find((entry) => entry.type === "session");
+        if (!header || typeof header.id !== "string") {
+            return null;
+        }
+        if (typeof header.cwd === "string" && path.resolve(header.cwd) !== path.resolve(cwd)) {
+            return null;
+        }
+        let sessionName = "";
+        let firstUserMessage = "";
+        for (const entry of entries) {
+            if (entry.type === "session_info" && typeof entry.name === "string") {
+                sessionName = normalizeOutput(entry.name).trim();
+            }
+            if (firstUserMessage || entry.type !== "message" || !isRecord(entry.message)) {
+                continue;
+            }
+            if (entry.message.role === "user") {
+                firstUserMessage = extractMessageText(entry.message);
+            }
+        }
+        return {
+            sessionId: header.id,
+            title: sessionName || firstUserMessage || header.id,
+            lastUpdatedAt: fs.statSync(filePath).mtime.toISOString(),
+            source: "pi",
+            filePath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function listPiResumeSessions(cwd, limit = 10, env = process.env) {
+    const sessionDir = buildPiSessionDirectory(cwd, env);
+    if (!fs.existsSync(sessionDir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(sessionDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+        .map((entry) => path.join(sessionDir, entry.name))
+        .map((filePath) => summarizePiSessionFile(filePath, cwd))
+        .filter((entry) => entry !== null)
+        .sort((left, right) => Date.parse(right.lastUpdatedAt) - Date.parse(left.lastUpdatedAt))
+        .slice(0, Math.max(1, limit))
+        .map(({ filePath: _filePath, ...candidate }) => candidate);
+}
+function findPiSessionFile(cwd, sessionId, env = process.env) {
+    const sessionDir = buildPiSessionDirectory(cwd, env);
+    if (!fs.existsSync(sessionDir)) {
+        return null;
+    }
+    for (const entry of fs.readdirSync(sessionDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        const filePath = path.join(sessionDir, entry.name);
+        if (summarizePiSessionFile(filePath, cwd)?.sessionId === sessionId) {
+            return filePath;
+        }
+    }
+    return null;
+}
+export function buildPiTuiCliArgs(options) {
+    const extraCliArgs = options.extraCliArgs ?? [];
+    assertNoReservedExtraCliArgs(extraCliArgs, [
+        "--mode",
+        "--print",
+        "-p",
+        "--approve",
+        "-a",
+        "--no-approve",
+        "-na",
+        "--continue",
+        "-c",
+        "--resume",
+        "-r",
+        "--session",
+        "--session-id",
+        "--session-dir",
+        "--no-session",
+    ], "Pi TUI runtime");
+    const args = ["--approve", "--extension", options.extensionPath];
+    if (options.sessionStartMode !== "new") {
+        if (options.initialSessionId) {
+            args.push("--session-id", options.initialSessionId);
+        }
+        else {
+            args.push("--continue");
+        }
+    }
+    return [...args, ...extraCliArgs];
+}
+export function attachPiTuiJsonlReader(stream, onFrame, onError) {
+    let buffer = "";
+    const onData = (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (buffer.length > PI_TUI_MAX_BUFFER_SIZE) {
+            buffer = "";
+            onError(new Error("Pi TUI bridge buffer exceeded 8MB without a complete LF frame."));
+            return;
+        }
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(line);
+                if (isRecord(parsed)) {
+                    onFrame(parsed);
+                }
+            }
+            catch (error) {
+                onError(new Error(`Invalid Pi TUI bridge frame: ${describeUnknownError(error)}`));
+            }
+        }
+    };
+    stream.on("data", onData);
+    return () => stream.removeListener("data", onData);
+}
+function getPiBridgeExtensionPath() {
+    const modulePath = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(modulePath), "..", "companion", `pi-tui-bridge-extension${path.extname(modulePath)}`);
+}
+export class PiTuiAdapter {
+    options;
+    deps;
+    state;
+    eventSink = () => undefined;
+    child = null;
+    server = null;
+    socket = null;
+    socketReaders = new Map();
+    retiringSockets = new Set();
+    connectWarningTimer = null;
+    reconnectTimer = null;
+    requestCounter = 0;
+    pendingRequests = new Map();
+    extensionReady = false;
+    disposing = false;
+    authenticated = new WeakSet();
+    currentAssistantText = "";
+    currentTurnError = "";
+    finalizingTurn = false;
+    pendingSessionSwitch = null;
+    token = crypto.randomBytes(32).toString("hex");
+    constructor(options, deps = {}) {
+        this.options = options;
+        this.deps = {
+            spawnProcess: deps.spawnProcess ?? spawn,
+            killProcessTree: deps.killProcessTree ?? killProcessTreeSync,
+            createServer: deps.createServer ?? net.createServer,
+        };
+        this.state = {
+            kind: "pi",
+            status: "stopped",
+            cwd: options.cwd,
+            command: options.command,
+            profile: options.profile,
+            sharedSessionId: options.sessionStartMode === "new" ? undefined : options.initialSharedSessionId,
+            activeRuntimeSessionId: options.sessionStartMode === "new" ? undefined : options.initialSharedSessionId,
+        };
+    }
+    setEventSink(sink) {
+        this.eventSink = sink;
+    }
+    async start() {
+        if (this.child) {
+            return;
+        }
+        this.disposing = false;
+        this.extensionReady = false;
+        this.setStatus("starting", "Starting the native Pi TUI...");
+        const port = await this.startServer();
+        const extensionPath = getPiBridgeExtensionPath();
+        if (!fs.existsSync(extensionPath)) {
+            await this.dispose();
+            throw new Error(`Pi TUI bridge extension is missing: ${extensionPath}`);
+        }
+        const cliArgs = buildPiTuiCliArgs({
+            extensionPath,
+            sessionStartMode: this.options.sessionStartMode,
+            initialSessionId: this.options.initialSharedSessionId,
+            extraCliArgs: this.options.extraCliArgs,
+        });
+        const target = resolveSpawnTarget(this.options.command, "pi", {
+            forwardArgs: cliArgs,
+        });
+        const env = {
+            ...buildCliEnvironment("pi"),
+            CLI_BRIDGE_PI_TUI_PORT: String(port),
+            CLI_BRIDGE_PI_TUI_TOKEN: this.token,
+        };
+        const child = this.deps.spawnProcess(target.file, target.args, {
+            cwd: this.options.cwd,
+            env,
+            stdio: "inherit",
+            windowsHide: false,
+            shell: false,
+        });
+        this.child = child;
+        this.state.pid = child.pid;
+        this.state.startedAt = nowIso();
+        child.once("error", (error) => {
+            this.clearConnectWarningTimer();
+            this.rejectPendingRequests(error);
+            if (!this.disposing) {
+                this.emit({
+                    type: "fatal_error",
+                    message: `Failed to start Pi TUI: ${describeUnknownError(error)}`,
+                    timestamp: nowIso(),
+                });
+            }
+        });
+        child.once("exit", (code, signal) => this.handleProcessExit(code, signal));
+        this.scheduleConnectWarning();
+    }
+    async sendInput(text) {
+        this.assertConnected();
+        const prompt = text.trim();
+        if (!prompt) {
+            return;
+        }
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Wait for the current reply or use /stop.");
+        }
+        this.beginTurn("wechat");
+        try {
+            await this.sendCommand("prompt", { text: prompt });
+        }
+        catch (error) {
+            this.clearActiveTurn();
+            this.setStatus("idle");
+            throw error;
+        }
+    }
+    async listResumeSessions(limit = 10) {
+        return listPiResumeSessions(this.options.cwd, limit);
+    }
+    async resumeSession(sessionId) {
+        this.assertConnected();
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Stop the current turn before switching sessions.");
+        }
+        const sessionPath = findPiSessionFile(this.options.cwd, sessionId);
+        if (!sessionPath) {
+            throw new Error(`Pi session not found for this workspace: ${sessionId}`);
+        }
+        this.pendingSessionSwitch = { source: "wechat", reason: "wechat_resume" };
+        try {
+            const response = await this.sendCommand("switch_session", { sessionPath });
+            this.applySessionState(response.data, "wechat", "wechat_resume", true);
+            if (isRecord(response.data) && response.data.cancelled === true) {
+                throw new Error("Pi session switch was cancelled by an extension.");
+            }
+        }
+        finally {
+            this.pendingSessionSwitch = null;
+        }
+    }
+    async createSession() {
+        this.assertConnected();
+        if (this.state.status === "busy") {
+            throw new Error("Pi is still working. Stop the current turn before creating a session.");
+        }
+        this.pendingSessionSwitch = { source: "wechat", reason: "wechat_resume" };
+        try {
+            const response = await this.sendCommand("new_session");
+            this.applySessionState(response.data, "wechat", "wechat_resume", true);
+            if (isRecord(response.data) && response.data.cancelled === true) {
+                throw new Error("Pi session creation was cancelled by an extension.");
+            }
+        }
+        finally {
+            this.pendingSessionSwitch = null;
+        }
+    }
+    async interrupt() {
+        if (!this.socket || this.state.status !== "busy") {
+            return false;
+        }
+        await this.sendCommand("abort");
+        return true;
+    }
+    async reset() {
+        await this.createSession();
+    }
+    async resolveApproval(_action) {
+        return false;
+    }
+    async resolveAllApprovals(_action) {
+        return 0;
+    }
+    async submitUserInput(_answers) {
+        return false;
+    }
+    async dispose() {
+        this.disposing = true;
+        this.clearConnectWarningTimer();
+        this.clearReconnectTimer();
+        this.rejectPendingRequests(new Error("Pi TUI adapter is shutting down."));
+        for (const [socket, detach] of this.socketReaders) {
+            detach();
+            socket.destroy();
+        }
+        this.socketReaders.clear();
+        this.retiringSockets.clear();
+        this.socket = null;
+        if (this.server) {
+            const server = this.server;
+            this.server = null;
+            if (server.listening) {
+                await new Promise((resolve) => {
+                    try {
+                        server.close(() => resolve());
+                    }
+                    catch {
+                        resolve();
+                    }
+                });
+            }
+        }
+        const child = this.child;
+        this.child = null;
+        if (child?.pid) {
+            try {
+                this.deps.killProcessTree(child.pid);
+            }
+            catch {
+                // Best effort.
+            }
+        }
+        this.state.status = "stopped";
+        this.state.pid = undefined;
+        this.extensionReady = false;
+        this.clearActiveTurn();
+    }
+    getState() {
+        return JSON.parse(JSON.stringify(this.state));
+    }
+    async startServer() {
+        const server = this.deps.createServer((socket) => this.acceptSocket(socket));
+        this.server = server;
+        return await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1", () => {
+                server.removeListener("error", reject);
+                const address = server.address();
+                if (!address || typeof address === "string") {
+                    reject(new Error("Pi TUI bridge server did not expose a TCP port."));
+                    return;
+                }
+                resolve(address.port);
+            });
+        });
+    }
+    acceptSocket(socket) {
+        socket.setEncoding("utf8");
+        socket.setNoDelay(true);
+        const detach = attachPiTuiJsonlReader(socket, (frame) => {
+            if (!this.authenticated.has(socket)) {
+                if (frame.type !== "hello" || frame.token !== this.token) {
+                    socket.destroy();
+                    return;
+                }
+                this.authenticated.add(socket);
+                this.clearReconnectTimer();
+                const previousSocket = this.socket;
+                this.socket = socket;
+                this.extensionReady = true;
+                this.clearConnectWarningTimer();
+                if (this.state.status === "starting") {
+                    this.setStatus("idle", "Native Pi TUI connected with full local permissions.");
+                }
+                if (previousSocket && previousSocket !== socket) {
+                    if (this.hasPendingSessionCommand()) {
+                        this.retiringSockets.add(previousSocket);
+                    }
+                    else {
+                        previousSocket.destroy();
+                    }
+                }
+                return;
+            }
+            this.handleFrame(frame, socket);
+        }, (error) => this.handleProtocolError(error));
+        socket.once("close", () => {
+            detach();
+            this.socketReaders.delete(socket);
+            this.retiringSockets.delete(socket);
+            if (this.socket === socket) {
+                this.socket = null;
+                this.scheduleReconnectFailure();
+            }
+        });
+        socket.once("error", () => {
+            // Close handling owns reconnect behavior.
+        });
+        this.socketReaders.set(socket, detach);
+    }
+    handleFrame(frame, sourceSocket) {
+        if (frame.type === "response") {
+            this.handleResponse(frame);
+            if (this.retiringSockets.has(sourceSocket) && !this.hasPendingSessionCommand()) {
+                sourceSocket.destroy();
+            }
+            return;
+        }
+        switch (frame.type) {
+            case "session_state": {
+                const pending = this.pendingSessionSwitch;
+                this.applySessionState(frame, pending?.source ?? "local", pending?.reason ?? "local_follow", Boolean(this.state.sharedSessionId));
+                this.setStatus(this.state.status);
+                break;
+            }
+            case "local_input":
+                if (typeof frame.text === "string" && frame.text.trim()) {
+                    this.handleLocalInput(frame.text.trim());
+                }
+                break;
+            case "agent_start":
+                if (!this.state.activeTurnOrigin) {
+                    this.beginTurn("local");
+                }
+                break;
+            case "assistant_message":
+                if (typeof frame.text === "string") {
+                    this.currentAssistantText = normalizeOutput(frame.text).trim();
+                }
+                if (frame.stopReason === "error") {
+                    this.currentTurnError =
+                        typeof frame.errorMessage === "string"
+                            ? frame.errorMessage
+                            : "Pi stopped because the model returned an error.";
+                }
+                break;
+            case "agent_settled":
+                void this.finalizeTurn();
+                break;
+        }
+    }
+    handleLocalInput(text) {
+        this.emit({
+            type: "mirrored_user_input",
+            text,
+            origin: "local",
+            timestamp: nowIso(),
+        });
+    }
+    beginTurn(origin) {
+        this.currentAssistantText = "";
+        this.currentTurnError = "";
+        this.state.activeTurnId = `${Date.now()}-${++this.requestCounter}`;
+        this.state.activeTurnOrigin = origin;
+        this.state.lastInputAt = nowIso();
+        this.setStatus("busy", origin === "wechat" ? "Pi TUI is handling a WeChat request." : "Pi TUI is working.");
+    }
+    async finalizeTurn() {
+        if (this.finalizingTurn || !this.state.activeTurnOrigin) {
+            return;
+        }
+        this.finalizingTurn = true;
+        const origin = this.state.activeTurnOrigin;
+        try {
+            if (this.currentTurnError) {
+                if (origin === "wechat") {
+                    this.emit({ type: "task_failed", message: this.currentTurnError, timestamp: nowIso() });
+                }
+            }
+            else if (origin === "wechat" && this.currentAssistantText) {
+                this.emit({ type: "final_reply", text: this.currentAssistantText, timestamp: nowIso() });
+            }
+            this.state.lastOutputAt = nowIso();
+            this.clearActiveTurn();
+            this.setStatus("idle");
+        }
+        finally {
+            this.finalizingTurn = false;
+        }
+    }
+    applySessionState(value, source, reason, emitSwitch) {
+        if (!isRecord(value) || typeof value.sessionId !== "string") {
+            return;
+        }
+        const previousSessionId = this.state.sharedSessionId;
+        this.state.sharedSessionId = value.sessionId;
+        this.state.activeRuntimeSessionId = value.sessionId;
+        this.state.transcriptPath =
+            typeof value.sessionFile === "string" ? value.sessionFile : undefined;
+        if (emitSwitch && value.sessionId !== previousSessionId) {
+            this.emit({
+                type: "session_switched",
+                sessionId: value.sessionId,
+                source,
+                reason,
+                timestamp: nowIso(),
+            });
+        }
+    }
+    sendCommand(command, payload = {}) {
+        this.assertConnected();
+        const socket = this.socket;
+        if (!socket || socket.destroyed) {
+            return Promise.reject(new Error("Native Pi TUI is not connected to the WeChat bridge."));
+        }
+        const id = `pi-tui-${++this.requestCounter}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Timed out waiting for Pi TUI command: ${command}`));
+            }, PI_TUI_REQUEST_TIMEOUT_MS);
+            this.pendingRequests.set(id, { command, resolve, reject, timer });
+            try {
+                socket.write(`${JSON.stringify({ id, type: command, ...payload })}\n`);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(error);
+            }
+        });
+    }
+    handleResponse(frame) {
+        const id = typeof frame.id === "string" ? frame.id : "";
+        const pending = this.pendingRequests.get(id);
+        if (!pending) {
+            return;
+        }
+        this.pendingRequests.delete(id);
+        clearTimeout(pending.timer);
+        if (frame.success === false) {
+            pending.reject(new Error(typeof frame.error === "string"
+                ? frame.error
+                : `Pi TUI command failed: ${pending.command}`));
+            return;
+        }
+        pending.resolve(frame);
+    }
+    hasPendingSessionCommand() {
+        return [...this.pendingRequests.values()].some((pending) => pending.command === "new_session" || pending.command === "switch_session");
+    }
+    assertConnected() {
+        if (!this.child || !this.socket || this.socket.destroyed) {
+            throw new Error("Native Pi TUI is not connected to the WeChat bridge.");
+        }
+    }
+    clearActiveTurn() {
+        this.state.activeTurnId = undefined;
+        this.state.activeTurnOrigin = undefined;
+    }
+    rejectPendingRequests(error) {
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    scheduleReconnectFailure() {
+        this.clearReconnectTimer();
+        if (this.disposing || !this.child) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.socket && !this.disposing) {
+                // Reset the turn state alongside the fatal error: leaving status at
+                // "busy" would keep rejecting every message with "still working"
+                // while /stop stays unavailable (no socket) and /reset is the only
+                // way out.
+                this.clearActiveTurn();
+                this.setStatus("idle", "The Pi TUI extension disconnected; the bridge is waiting for a reconnect.");
+                this.emit({
+                    type: "fatal_error",
+                    message: "The native Pi TUI bridge extension disconnected and did not reconnect.",
+                    timestamp: nowIso(),
+                });
+            }
+        }, PI_TUI_RECONNECT_TIMEOUT_MS);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    scheduleConnectWarning() {
+        this.clearConnectWarningTimer();
+        this.connectWarningTimer = setTimeout(() => {
+            this.connectWarningTimer = null;
+            if (!this.extensionReady && !this.disposing && this.child) {
+                this.setStatus("starting", "Native Pi TUI is still loading; waiting for the bridge extension to connect.");
+            }
+        }, PI_TUI_CONNECT_WARNING_MS);
+        this.connectWarningTimer.unref?.();
+    }
+    clearConnectWarningTimer() {
+        if (this.connectWarningTimer) {
+            clearTimeout(this.connectWarningTimer);
+            this.connectWarningTimer = null;
+        }
+    }
+    handleProtocolError(error) {
+        if (!this.disposing) {
+            this.emit({ type: "fatal_error", message: error.message, timestamp: nowIso() });
+        }
+    }
+    handleProcessExit(code, signal) {
+        this.clearConnectWarningTimer();
+        this.rejectPendingRequests(new Error(`Pi TUI exited (code=${code ?? "none"}, signal=${signal ?? "none"}).`));
+        this.child = null;
+        this.state.pid = undefined;
+        this.state.status = "stopped";
+        this.extensionReady = false;
+        this.clearActiveTurn();
+        if (!this.disposing) {
+            // Report unexpected exits as fatal errors, matching the other adapters:
+            // a bare "stopped" status is only logged by the bridge, so WeChat users
+            // would get no signal that the TUI is gone until their next message
+            // fails with a cryptic not-connected error.
+            this.emit({
+                type: "fatal_error",
+                message: `Pi TUI exited unexpectedly (code=${code ?? "none"}, signal=${signal ?? "none"}). Restart the bridge or use /reset to recover.`,
+                timestamp: nowIso(),
+            });
+        }
+    }
+    setStatus(status, message) {
+        this.state.status = status;
+        this.emit({ type: "status", status, message, timestamp: nowIso() });
+    }
+    emit(event) {
+        this.eventSink(event);
+    }
+}