cli-wechat-bridge 1.0.5 → 1.0.7

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

@@ -1,12 +1,13 @@
 import { spawn as spawnChildProcess } from "node:child_process";
 import { OPENCODE_SERVER_HOST, OPENCODE_SERVER_READY_TIMEOUT_MS, OPENCODE_SSE_RECONNECT_DELAY_MS, OPENCODE_SESSION_IDLE_SETTLE_MS, OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS, buildCliEnvironment, isRecord, describeUnknownError, resolveSpawnTarget, reserveLocalPort, waitForTcpPort, delay, } from "./bridge-adapters.shared.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
-import { buildOneTimeCode, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
+import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, buildOneTimeCode, isWechatOutboundAttachmentMutationTool, isWechatOutboundAttachmentWriteCommand, normalizeOutput, nowIso, truncatePreview, OutputBatcher, } from "./bridge-utils.js";
 const OPENCODE_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(process.env.WECHAT_OPENCODE_DEBUG ?? "");
 const OPENCODE_DUPLICATE_EVENT_TTL_MS = 150;
 const OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS = 30_000;
 const OPENCODE_RECENT_LOCAL_PROMPT_TTL_MS = 10_000;
 const OPENCODE_LOCAL_SESSION_CREATE_FOLLOW_TTL_MS = 5_000;
+const OPENCODE_TUI_SELECT_RETRY_DELAYS_MS = [250, 750, 1_500];
 /* ------------------------------------------------------------------ */
 /*  Adapter                                                            */
 /* ------------------------------------------------------------------ */
@@ -82,7 +83,7 @@ export class OpenCodeServerAdapter {
             this.startSseListener();
             if (this.options.renderMode === "companion") {
                 await this.startNativeClient();
-                await this.syncVisibleSessionToShared({ force: true });
+                await this.syncVisibleSessionToShared({ force: true, retry: true });
             }
             else {
                 this.state.pid = serverProcess.pid;
@@ -177,6 +178,7 @@ export class OpenCodeServerAdapter {
             clearTrackedTurn: true,
             syncVisible: true,
             forceVisibleSync: true,
+            retryVisibleSync: true,
         });
     }
     async interrupt() {
@@ -365,7 +367,7 @@ export class OpenCodeServerAdapter {
         if (this.nativeProcess) {
             return;
         }
-        const env = buildCliEnvironment(this.options.kind);
+        const env = this.buildNativeClientEnv();
         const attachArgs = await this.buildNativeAttachArgs();
         const target = resolveSpawnTarget(this.options.command, this.options.kind, { env });
         const startedAt = nowIso();
@@ -410,6 +412,7 @@ export class OpenCodeServerAdapter {
     }
     async buildNativeAttachArgs() {
         const args = ["attach", this.getServerUrl()];
+        args.push("--dir", this.options.cwd);
         const sessionId = this.activeSessionId;
         if (sessionId && (await this.hasSession(sessionId))) {
             args.push("--session", sessionId);
@@ -417,6 +420,16 @@ export class OpenCodeServerAdapter {
         args.push(...(this.options.extraCliArgs ?? []));
         return args;
     }
+    buildNativeClientEnv() {
+        const env = buildCliEnvironment(this.options.kind);
+        if (this.activeSessionId) {
+            env.OPENCODE_ROUTE = JSON.stringify({
+                type: "session",
+                sessionID: this.activeSessionId,
+            });
+        }
+        return env;
+    }
     async createSdkClient() {
         try {
             const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
@@ -441,6 +454,21 @@ export class OpenCodeServerAdapter {
         if (!this.client) {
             return;
         }
+        if (this.options.sessionStartMode === "new") {
+            const session = this.unwrapOrThrow(await this.client.session.create({
+                directory: this.options.cwd,
+                workspace: this.activeWorkspaceId ?? undefined,
+            }));
+            this.switchSharedSession(session, {
+                source: "local",
+                reason: "local_follow",
+                syncVisible: false,
+            });
+            this.state.lastSessionSwitchAt = undefined;
+            this.state.lastSessionSwitchSource = undefined;
+            this.state.lastSessionSwitchReason = undefined;
+            return;
+        }
         let listedSessions = [];
         try {
             const result = await this.client.session.list();
@@ -801,6 +829,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         this.clearWechatWorkingNotice();
+        const denyMessage = this.getWechatOutboundAttachmentPermissionDenyMessage(properties, pendingPermission);
+        if (denyMessage) {
+            this.rejectPermission(pendingPermission, denyMessage);
+            return;
+        }
         const approval = this.toPendingApproval(pendingPermission);
         this.pendingPermission = pendingPermission;
         this.state.pendingApproval = approval;
@@ -817,6 +850,57 @@ export class OpenCodeServerAdapter {
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
     }
+    getWechatOutboundAttachmentPermissionDenyMessage(properties, pendingPermission) {
+        const metadata = isRecord(properties.metadata) ? properties.metadata : {};
+        const command = this.extractPermissionCommand(properties, metadata);
+        if (isWechatOutboundAttachmentWriteCommand(command)) {
+            return WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE;
+        }
+        const targetPath = [
+            command,
+            typeof metadata.path === "string" ? metadata.path : "",
+            typeof metadata.file === "string" ? metadata.file : "",
+            typeof metadata.filePath === "string" ? metadata.filePath : "",
+            typeof metadata.filepath === "string" ? metadata.filepath : "",
+            typeof metadata.parentDir === "string" ? metadata.parentDir : "",
+            typeof metadata.target === "string" ? metadata.target : "",
+            typeof metadata.detail === "string" ? metadata.detail : "",
+            Array.isArray(properties.patterns)
+                ? properties.patterns.filter((value) => typeof value === "string").join(" ")
+                : "",
+            typeof properties.pattern === "string" ? properties.pattern : "",
+        ].join(" ");
+        return isWechatOutboundAttachmentMutationTool(pendingPermission.request.toolName, targetPath)
+            ? WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE
+            : null;
+    }
+    rejectPermission(pendingPermission, denyMessage) {
+        const client = this.client;
+        if (!client) {
+            return;
+        }
+        void (async () => {
+            try {
+                const result = await client.permission.respond({
+                    sessionID: pendingPermission.sessionId,
+                    permissionID: pendingPermission.permissionId,
+                    directory: this.options.cwd,
+                    workspace: this.activeWorkspaceId ?? undefined,
+                    response: "reject",
+                });
+                if (result.error !== undefined) {
+                    throw new Error(`SDK error: ${describeUnknownError(result.error)}`);
+                }
+            }
+            catch (err) {
+                this.emit({
+                    type: "stderr",
+                    text: `${denyMessage}\nFailed to reject permission: ${describeUnknownError(err)}`,
+                    timestamp: nowIso(),
+                });
+            }
+        })();
+    }
     toPendingApproval(pendingPermission) {
         return {
             ...pendingPermission.request,
@@ -834,24 +918,14 @@ export class OpenCodeServerAdapter {
         if (!sessionId || !permissionId) {
             return null;
         }
-        const toolName = typeof properties.type === "string"
-            ? properties.type
-            : typeof properties.permission === "string"
-                ? properties.permission
-                : undefined;
+        const toolName = this.extractPermissionToolName(properties);
         const title = typeof properties.title === "string"
             ? properties.title
             : typeof properties.permission === "string"
                 ? `Permission request: ${properties.permission}`
                 : undefined;
         const metadata = isRecord(properties.metadata) ? properties.metadata : {};
-        const command = typeof metadata.command === "string"
-            ? metadata.command
-            : typeof metadata.detail === "string"
-                ? metadata.detail
-                : Array.isArray(properties.patterns)
-                    ? properties.patterns.filter((value) => typeof value === "string").join(", ")
-                    : undefined;
+        const command = this.extractPermissionCommand(properties, metadata);
         return {
             sessionId,
             permissionId,
@@ -869,6 +943,26 @@ export class OpenCodeServerAdapter {
             },
         };
     }
+    extractPermissionToolName(properties) {
+        return typeof properties.type === "string"
+            ? properties.type
+            : typeof properties.permission === "string"
+                ? properties.permission
+                : undefined;
+    }
+    extractPermissionCommand(properties, metadata) {
+        if (typeof metadata.command === "string") {
+            return metadata.command;
+        }
+        if (typeof metadata.detail === "string") {
+            return metadata.detail;
+        }
+        if (Array.isArray(properties.patterns)) {
+            const patterns = properties.patterns.filter((value) => typeof value === "string");
+            return patterns.length > 0 ? patterns.join(", ") : undefined;
+        }
+        return undefined;
+    }
     handleSessionCreated(properties) {
         if (!isRecord(properties)) {
             return;
@@ -1788,7 +1882,9 @@ export class OpenCodeServerAdapter {
             this.recordSessionSwitch(sessionId, options.source, options.reason, options.notify);
         }
         if (options.syncVisible !== false && (changed || options.forceVisibleSync)) {
-            void this.syncVisibleSessionSelection(typeof session === "string" ? { id: session } : session);
+            void this.syncVisibleSessionSelection(typeof session === "string" ? { id: session } : session, {
+                retry: options.retryVisibleSync,
+            });
         }
         return changed;
     }
@@ -1799,7 +1895,7 @@ export class OpenCodeServerAdapter {
         await this.syncVisibleSessionSelection({
             id: this.activeSessionId,
             workspaceID: this.activeWorkspaceId ?? undefined,
-        }, { force: options.force });
+        }, { force: options.force, retry: options.retry });
     }
     async syncVisibleSessionSelection(session, options = {}) {
         if (!this.client?.tui ||
@@ -1810,13 +1906,9 @@ export class OpenCodeServerAdapter {
         this.suppressedTuiSessionSelectId = session.id;
         this.logDebug(`[opencode-adapter:tui] selectSession session=${session.id} workspace=${session.workspaceID ?? this.activeWorkspaceId ?? "(none)"}`);
         try {
-            const result = await this.client.tui.selectSession({
-                directory: this.options.cwd,
-                workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
-                sessionID: session.id,
-            });
-            if (result.error !== undefined) {
-                throw result.error;
+            await this.sendVisibleSessionSelection(session);
+            if (options.retry === true) {
+                this.scheduleVisibleSessionSelectionRetries(session);
             }
         }
         catch (err) {
@@ -1826,6 +1918,33 @@ export class OpenCodeServerAdapter {
             this.logDebug(`[opencode-adapter:tui] selectSession failed for ${session.id}: ${describeUnknownError(err)}`);
         }
     }
+    async sendVisibleSessionSelection(session) {
+        if (!this.client?.tui) {
+            return;
+        }
+        const result = await this.client.tui.selectSession({
+            directory: this.options.cwd,
+            workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
+            sessionID: session.id,
+        });
+        if (result.error !== undefined) {
+            throw result.error;
+        }
+    }
+    scheduleVisibleSessionSelectionRetries(session) {
+        for (const retryDelayMs of OPENCODE_TUI_SELECT_RETRY_DELAYS_MS) {
+            setTimeout(() => {
+                if (this.shuttingDown ||
+                    this.options.renderMode !== "companion" ||
+                    this.activeSessionId !== session.id) {
+                    return;
+                }
+                void this.sendVisibleSessionSelection(session).catch((err) => {
+                    this.logDebug(`[opencode-adapter:tui] selectSession retry failed for ${session.id}: ${describeUnknownError(err)}`);
+                });
+            }, retryDelayMs).unref?.();
+        }
+    }
     isLocalSessionNavigationCommand(command) {
         if (!command) {
             return false;

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

@@ -2,13 +2,10 @@ import fs from "node:fs";
 import path from "node:path";
 import net from "node:net";
 import { fileURLToPath } from "node:url";
-import { spawn as spawnChild, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { spawn as spawnPty } from "node-pty";
-import { attachLocalCompanionMessageListener, buildLocalCompanionToken, clearLocalCompanionEndpoint, sendLocalCompanionMessage, writeLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
-import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
-import { buildClaudeFailureMessage, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeResumeConversationId, findInjectedClaudePromptIndex, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
-import { detectCliApproval, isHighRiskShellCommand, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
-import { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
+import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, containsWechatOutboundAttachmentPathDeep, isWechatOutboundAttachmentWriteCommand, isHighRiskShellCommand, normalizeOutput, truncatePreview, } from "./bridge-utils.js";
+import { getNotificationThreadId, isRecord, } from "./bridge-adapter-common.js";
 export { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
 export const DEFAULT_COLS = 120;
 export const DEFAULT_ROWS = 30;
@@ -152,8 +149,220 @@ export function buildCodexApprovalRequest(method, params) {
             commandPreview: truncatePreview(preview, 180),
         };
     }
+    if (method === "item/permissions/requestApproval") {
+        const reason = typeof params.reason === "string" ? params.reason : "";
+        const preview = summarizeCodexPermissionsRequest(params.permissions);
+        return {
+            source: "cli",
+            summary: reason
+                ? `Codex needs approval before granting extra permissions: ${truncatePreview(reason, 160)}`
+                : "Codex needs approval before granting extra permissions.",
+            commandPreview: truncatePreview(preview, 180),
+        };
+    }
+    return null;
+}
+export function getCodexWechatOutboundAttachmentDenyMessage(method, params) {
+    if (!isRecord(params)) {
+        return null;
+    }
+    if (method === "item/commandExecution/requestApproval") {
+        return isWechatOutboundAttachmentWriteCommand(params.command) ||
+            containsWechatOutboundAttachmentPathDeep(params.additionalPermissions)
+            ? WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE
+            : null;
+    }
+    if (method === "item/fileChange/requestApproval") {
+        return containsWechatOutboundAttachmentPath(params.grantRoot)
+            ? WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE
+            : null;
+    }
+    if (method === "item/permissions/requestApproval") {
+        return containsWechatOutboundAttachmentPathDeep(params.permissions)
+            ? WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE
+            : null;
+    }
     return null;
 }
+function commandApprovalAllowsAccept(availableDecisions) {
+    if (!Array.isArray(availableDecisions)) {
+        return true;
+    }
+    return availableDecisions.some((decision) => decision === "accept");
+}
+function normalizePermissionPath(pathValue) {
+    const normalized = pathValue.trim().replace(/\\/g, "/").toLowerCase();
+    return normalized === "/" ? normalized : normalized.replace(/\/+$/g, "");
+}
+function isHighRiskPermissionPath(pathValue) {
+    const normalized = normalizePermissionPath(pathValue);
+    if (!normalized) {
+        return false;
+    }
+    if (normalized === "/" || /^[a-z]:$/i.test(normalized)) {
+        return true;
+    }
+    return /^[a-z]:(?:\/windows|\/program files(?: \(x86\))?|\/programdata)(?:\/|$)/i.test(normalized);
+}
+function collectPermissionPaths(value, output) {
+    if (typeof value === "string") {
+        output.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectPermissionPaths(item, output);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    if (typeof value.path === "string") {
+        output.push(value.path);
+    }
+    if (typeof value.pattern === "string") {
+        output.push(value.pattern);
+    }
+    for (const item of Object.values(value)) {
+        collectPermissionPaths(item, output);
+    }
+}
+function hasRootSpecialPermissionPath(value) {
+    if (Array.isArray(value)) {
+        return value.some(hasRootSpecialPermissionPath);
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    if ((value.kind === "root" || value.kind === "Root") ||
+        (value.value === "root" || value.value === "Root")) {
+        return true;
+    }
+    return Object.values(value).some(hasRootSpecialPermissionPath);
+}
+function containsHighRiskPermissionTarget(value) {
+    if (hasRootSpecialPermissionPath(value)) {
+        return true;
+    }
+    const paths = [];
+    collectPermissionPaths(value, paths);
+    return paths.some(isHighRiskPermissionPath);
+}
+export function getCodexApprovalAutoResponse(method, params) {
+    if (method === "item/commandExecution/requestApproval") {
+        const command = typeof params.command === "string" ? params.command : "";
+        if (!commandApprovalAllowsAccept(params.availableDecisions)) {
+            return null;
+        }
+        if (command && isHighRiskShellCommand(command)) {
+            return null;
+        }
+        if (containsHighRiskPermissionTarget(params.additionalPermissions)) {
+            return null;
+        }
+        return {
+            result: { decision: "accept" },
+            reason: command
+                ? `low-risk command ${truncatePreview(command, 120)}`
+                : "low-risk command approval",
+        };
+    }
+    if (method === "item/fileChange/requestApproval") {
+        if (containsHighRiskPermissionTarget(params.grantRoot)) {
+            return null;
+        }
+        return {
+            result: { decision: "accept" },
+            reason: "low-risk file change approval",
+        };
+    }
+    if (method === "item/permissions/requestApproval") {
+        if (containsHighRiskPermissionTarget(params.permissions)) {
+            return null;
+        }
+        return {
+            result: buildCodexPermissionsRequestApprovalResponse(params, "confirm", {
+                strictAutoReview: true,
+            }),
+            reason: "low-risk permission grant",
+        };
+    }
+    return null;
+}
+function collectStringValues(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+}
+function summarizeCodexPermissionsRequest(permissions) {
+    if (!isRecord(permissions)) {
+        return "Additional permissions requested.";
+    }
+    const parts = [];
+    if (isRecord(permissions.network) && permissions.network.enabled === true) {
+        parts.push("network access");
+    }
+    if (isRecord(permissions.fileSystem)) {
+        const readPaths = collectStringValues(permissions.fileSystem.read);
+        const writePaths = collectStringValues(permissions.fileSystem.write);
+        if (readPaths.length > 0) {
+            parts.push(`read: ${readPaths.join(", ")}`);
+        }
+        if (writePaths.length > 0) {
+            parts.push(`write: ${writePaths.join(", ")}`);
+        }
+        if (Array.isArray(permissions.fileSystem.entries) && permissions.fileSystem.entries.length > 0) {
+            parts.push(`filesystem entries: ${permissions.fileSystem.entries.length}`);
+        }
+    }
+    return parts.length > 0 ? parts.join("; ") : "Additional permissions requested.";
+}
+function clonePermissionObject(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+export function buildCodexPermissionsRequestApprovalResponse(params, action = "deny", options = {}) {
+    const permissions = {};
+    if (action === "confirm" && isRecord(params) && isRecord(params.permissions)) {
+        const network = clonePermissionObject(params.permissions.network);
+        const fileSystem = clonePermissionObject(params.permissions.fileSystem);
+        if (network) {
+            permissions.network = network;
+        }
+        if (fileSystem) {
+            permissions.fileSystem = fileSystem;
+        }
+    }
+    const response = {
+        permissions,
+        scope: "turn",
+    };
+    if (options.strictAutoReview) {
+        response.strictAutoReview = true;
+    }
+    return response;
+}
+export function buildCodexMcpServerElicitationDeclineResponse() {
+    return {
+        action: "decline",
+        content: null,
+        _meta: null,
+    };
+}
+export function buildCodexDynamicToolCallFailureResponse() {
+    return {
+        contentItems: [
+            {
+                type: "inputText",
+                text: "Dynamic tool calls are not supported by the WeChat bridge.",
+            },
+        ],
+        success: false,
+    };
+}
 export function buildCodexUserInputRequest(params) {
     if (!isRecord(params) || !Array.isArray(params.questions)) {
         return null;
@@ -287,6 +496,7 @@ export function shouldRecoverCodexStaleBusyState(params) {
         !params.pendingTurnStart &&
         !params.hasActiveTurn &&
         !params.hasPendingApproval &&
+        !params.hasPendingUserInput &&
         !params.activeTurnId);
 }
 export function shouldAutoCompleteCodexWechatTurnAfterFinalReply(params) {
@@ -295,6 +505,7 @@ export function shouldAutoCompleteCodexWechatTurnAfterFinalReply(params) {
         params.activeTurnOrigin === "wechat" &&
         !params.pendingTurnStart &&
         !params.hasPendingApproval &&
+        !params.hasPendingUserInput &&
         params.hasFinalOutput &&
         !params.hasCompletedTurn &&
         typeof params.lastActivityAtMs === "number" &&

package/dist/bridge/bridge-process-reaper.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import path from "node:path";
 const PEER_BRIDGE_EXIT_TIMEOUT_MS = 4_000;
 const PEER_BRIDGE_EXIT_POLL_MS = 100;
 function isPidAlive(pid) {
@@ -24,7 +25,30 @@ function isRecord(value) {
 }
 export function isWechatBridgeCommandLine(commandLine) {
     return (/wechat-bridge\.(?:ts|js|mjs)/i.test(commandLine) &&
-        /(?:^|\s)--adapter(?:\s|=)/i.test(commandLine));
+        /(?:^|\s|["'])--adapter(?:(?:["']?\s)|=)/i.test(commandLine));
+}
+export function isWechatDaemonCommandLine(commandLine) {
+    return /wechat-daemon\.(?:ts|js|mjs)/i.test(commandLine);
+}
+function normalizeComparablePath(filePath) {
+    const normalized = path.resolve(filePath);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function extractCommandLineOption(commandLine, optionName) {
+    const escaped = optionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`(?:^|\\s|["'])--${escaped}(?:(?:["']?\\s+)|=)(?:"([^"]+)"|'([^']+)'|(\\S+))`, "i");
+    const match = pattern.exec(commandLine);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+export function isWechatDaemonCommandLineForCwd(commandLine, cwd) {
+    if (!isWechatDaemonCommandLine(commandLine)) {
+        return false;
+    }
+    const commandCwd = extractCommandLineOption(commandLine, "cwd");
+    if (!commandCwd) {
+        return true;
+    }
+    return normalizeComparablePath(commandCwd) === normalizeComparablePath(cwd);
 }
 /**
  * Detects `opencode serve` command lines spawned by the bridge adapter.
@@ -165,6 +189,21 @@ export function listPeerBridgeProcesses(currentPid = process.pid) {
         ? listWindowsBridgeProcesses(currentPid)
         : listPosixBridgeProcesses(currentPid);
 }
+export function getProcessRecordByPid(pid, currentPid = process.pid) {
+    if (!Number.isInteger(pid) || pid <= 0 || pid === currentPid) {
+        return null;
+    }
+    return listAllProcessesRaw(currentPid).find((record) => record.pid === pid) ?? null;
+}
+export function listWechatDaemonProcesses(params = {}) {
+    const currentPid = params.currentPid ?? process.pid;
+    const excludePids = new Set(params.excludePids ?? []);
+    return listAllProcessesRaw(currentPid)
+        .filter((record) => !excludePids.has(record.pid))
+        .filter((record) => params.cwd
+        ? isWechatDaemonCommandLineForCwd(record.commandLine, params.cwd)
+        : isWechatDaemonCommandLine(record.commandLine));
+}
 /**
  * List all managed OpenCode child processes (`serve` and `attach`) whose parent
  * PID is no longer alive. These are orphaned processes left behind when a bridge

package/dist/bridge/bridge-state.js

@@ -169,14 +169,17 @@ export class BridgeStateStore {
             lifecycle: options.lifecycle,
         };
         this.acquireLock();
+        const shouldRestoreSessionState = options.sessionStartMode !== "new";
         const persisted = this.readStateFile();
-        const persistedSharedSessionId = resolveRestorableSharedSessionId(persisted, options);
-        const persistedResumeConversationId = options.adapter === "claude" &&
+        const persistedSharedSessionId = resolveRestorableSharedSessionId(shouldRestoreSessionState ? persisted : null, options);
+        const persistedResumeConversationId = shouldRestoreSessionState &&
+            options.adapter === "claude" &&
             persisted?.cwd === options.cwd &&
             typeof persisted.resumeConversationId === "string"
             ? persisted.resumeConversationId
             : undefined;
-        const persistedTranscriptPath = options.adapter === "claude" &&
+        const persistedTranscriptPath = shouldRestoreSessionState &&
+            options.adapter === "claude" &&
             persisted?.cwd === options.cwd &&
             typeof persisted.transcriptPath === "string"
             ? persisted.transcriptPath