@unlinearity/cli-wechat-bridge 1.0.0 → 1.0.2

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

@@ -0,0 +1,348 @@
+import { spawnSync } from "node:child_process";
+const PEER_BRIDGE_EXIT_TIMEOUT_MS = 4_000;
+const PEER_BRIDGE_EXIT_POLL_MS = 100;
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isWechatBridgeCommandLine(commandLine) {
+    return (/wechat-bridge\.(?:ts|js|mjs)/i.test(commandLine) &&
+        /(?:^|\s)--adapter(?:\s|=)/i.test(commandLine));
+}
+/**
+ * Detects `opencode serve` command lines spawned by the bridge adapter.
+ * Matches patterns like:
+ *   opencode serve --port 12345 --hostname 127.0.0.1
+ *   opencode.exe serve --port 12345
+ * Also matches wrapper invocations (opencode.cmd / opencode.bat) on Windows.
+ */
+export function isOpencodeServeCommandLine(commandLine) {
+    return /\bopencode(?:\.exe|\.cmd|\.bat)?\b.*\bserve\b/i.test(commandLine);
+}
+/**
+ * Detects `opencode attach` command lines spawned by the local OpenCode companion.
+ * Matches patterns like:
+ *   opencode attach http://127.0.0.1:12345
+ *   opencode.exe attach http://127.0.0.1:12345 --session ses_123
+ */
+export function isOpencodeAttachCommandLine(commandLine) {
+    return /\bopencode(?:\.exe|\.cmd|\.bat)?\b.*\battach\b/i.test(commandLine);
+}
+function normalizeBridgeProcessRecord(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const pid = typeof value.ProcessId === "number"
+        ? value.ProcessId
+        : typeof value.pid === "number"
+            ? value.pid
+            : Number.NaN;
+    const commandLine = typeof value.CommandLine === "string"
+        ? value.CommandLine
+        : typeof value.commandLine === "string"
+            ? value.commandLine
+            : "";
+    if (!Number.isInteger(pid) || pid <= 0 || !commandLine) {
+        return null;
+    }
+    const record = {
+        pid,
+        commandLine,
+    };
+    const parentPid = typeof value.ParentProcessId === "number"
+        ? value.ParentProcessId
+        : typeof value.parentPid === "number"
+            ? value.parentPid
+            : undefined;
+    if (typeof parentPid === "number" && Number.isInteger(parentPid) && parentPid > 0) {
+        record.parentPid = parentPid;
+    }
+    const name = typeof value.Name === "string"
+        ? value.Name
+        : typeof value.name === "string"
+            ? value.name
+            : undefined;
+    if (name) {
+        record.name = name;
+    }
+    return record;
+}
+export function parseWindowsBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return [];
+    }
+    const values = Array.isArray(parsed) ? parsed : [parsed];
+    return values
+        .map(normalizeBridgeProcessRecord)
+        .filter((record) => Boolean(record))
+        .filter((record) => record.pid !== currentPid && isWechatBridgeCommandLine(record.commandLine));
+}
+export function parsePosixBridgeProcessProbeOutput(stdout, currentPid = process.pid) {
+    return stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const match = /^(\d+)\s+(.*)$/.exec(line);
+        if (!match) {
+            return null;
+        }
+        const pid = Number(match[1]);
+        const commandLine = match[2] ?? "";
+        if (!Number.isInteger(pid) || pid <= 0 || !commandLine) {
+            return null;
+        }
+        return {
+            pid,
+            commandLine,
+        };
+    })
+        .filter((record) => Boolean(record))
+        .filter((record) => record.pid !== currentPid && isWechatBridgeCommandLine(record.commandLine));
+}
+function listWindowsBridgeProcesses(currentPid = process.pid) {
+    const probe = spawnSync("powershell.exe", [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        [
+            "$ErrorActionPreference='Stop'",
+            "Get-CimInstance Win32_Process",
+            "| Where-Object { $_.CommandLine }",
+            "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",
+            "| ConvertTo-Json -Compress",
+        ].join(" "),
+    ], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 8_000,
+    });
+    if (probe.status !== 0 || typeof probe.stdout !== "string") {
+        return [];
+    }
+    return parseWindowsBridgeProcessProbeOutput(probe.stdout, currentPid);
+}
+function listPosixBridgeProcesses(currentPid = process.pid) {
+    const probe = spawnSync("ps", ["-ax", "-o", "pid=", "-o", "command="], {
+        encoding: "utf8",
+        timeout: 8_000,
+    });
+    if (probe.status !== 0 || typeof probe.stdout !== "string") {
+        return [];
+    }
+    return parsePosixBridgeProcessProbeOutput(probe.stdout, currentPid);
+}
+export function listPeerBridgeProcesses(currentPid = process.pid) {
+    return process.platform === "win32"
+        ? listWindowsBridgeProcesses(currentPid)
+        : listPosixBridgeProcesses(currentPid);
+}
+/**
+ * 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
+ * or local companion crashed or was killed without cleaning up its child
+ * OpenCode processes.
+ */
+export function listOrphanedOpencodeProcesses(currentPid = process.pid) {
+    const all = listAllProcessesRaw(currentPid);
+    return all.filter((record) => {
+        if (!isOpencodeServeCommandLine(record.commandLine) &&
+            !isOpencodeAttachCommandLine(record.commandLine)) {
+            return false;
+        }
+        if (!record.parentPid) {
+            return false;
+        }
+        if (record.parentPid === currentPid) {
+            return false;
+        }
+        return !isPidAlive(record.parentPid);
+    });
+}
+function listAllProcessesRaw(currentPid = process.pid) {
+    if (process.platform === "win32") {
+        const probe = spawnSync("powershell.exe", [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            [
+                "$ErrorActionPreference='Stop'",
+                "Get-CimInstance Win32_Process",
+                "| Where-Object { $_.CommandLine }",
+                "| Select-Object ProcessId,ParentProcessId,Name,CommandLine",
+                "| ConvertTo-Json -Compress",
+            ].join(" "),
+        ], {
+            encoding: "utf8",
+            windowsHide: true,
+            timeout: 8_000,
+        });
+        if (probe.status !== 0 || typeof probe.stdout !== "string") {
+            return [];
+        }
+        const trimmed = probe.stdout.trim();
+        if (!trimmed)
+            return [];
+        try {
+            const parsed = JSON.parse(trimmed);
+            const values = Array.isArray(parsed) ? parsed : [parsed];
+            return values
+                .map(normalizeBridgeProcessRecord)
+                .filter((r) => Boolean(r))
+                .filter((r) => r.pid !== currentPid);
+        }
+        catch {
+            return [];
+        }
+    }
+    const probe = spawnSync("ps", ["-ax", "-o", "pid=", "-o", "ppid=", "-o", "command="], {
+        encoding: "utf8",
+        timeout: 8_000,
+    });
+    if (probe.status !== 0 || typeof probe.stdout !== "string") {
+        return [];
+    }
+    return probe.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const match = /^(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+        if (!match)
+            return null;
+        const pid = Number(match[1]);
+        const parentPid = Number(match[2]);
+        const commandLine = match[3] ?? "";
+        if (!Number.isInteger(pid) || pid <= 0 || !commandLine)
+            return null;
+        const record = { pid, commandLine };
+        if (Number.isInteger(parentPid) && parentPid > 0)
+            record.parentPid = parentPid;
+        return record;
+    })
+        .filter((r) => Boolean(r))
+        .filter((r) => r.pid !== currentPid);
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isPidAlive(pid)) {
+            return true;
+        }
+        await sleep(Math.min(PEER_BRIDGE_EXIT_POLL_MS, deadline - Date.now()));
+    }
+    return !isPidAlive(pid);
+}
+/**
+ * Synchronously kill a process and its entire descendant tree.
+ * On Windows uses `taskkill /T /F /PID` to recursively kill all descendants.
+ * On other platforms uses `process.kill(pid)` directly.
+ */
+export function killProcessTreeSync(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return;
+    }
+    if (process.platform === "win32") {
+        try {
+            spawnSync("taskkill", ["/T", "/F", "/PID", String(pid)], {
+                windowsHide: true,
+                timeout: 5_000,
+            });
+        }
+        catch {
+            try {
+                process.kill(pid);
+            }
+            catch { /* best effort */ }
+        }
+    }
+    else {
+        try {
+            process.kill(pid);
+        }
+        catch { /* best effort */ }
+    }
+}
+export async function reapPeerBridgeProcesses(params = {}) {
+    const currentPid = params.currentPid ?? process.pid;
+    const peers = listPeerBridgeProcesses(currentPid);
+    const terminated = [];
+    for (const peer of peers) {
+        try {
+            params.logger?.(`peer_bridge_reap_attempt: pid=${peer.pid}${peer.name ? ` name=${peer.name}` : ""} command=${peer.commandLine}`);
+            killProcessTreeSync(peer.pid);
+            if (await waitForProcessExit(peer.pid, PEER_BRIDGE_EXIT_TIMEOUT_MS)) {
+                terminated.push(peer.pid);
+                params.logger?.(`peer_bridge_reaped: pid=${peer.pid}`);
+            }
+            else {
+                params.logger?.(`peer_bridge_reap_timeout: pid=${peer.pid}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            params.logger?.(`peer_bridge_reap_failed: pid=${peer.pid} error=${message}`);
+        }
+    }
+    return terminated;
+}
+/**
+ * Kill orphaned managed OpenCode processes (`serve` and `attach`) whose parent
+ * bridge/companion has already exited. These accumulate when a bridge crashes
+ * or is killed without cleaning up its child OpenCode processes (common on
+ * Windows where child processes are not automatically killed when the parent dies).
+ */
+export async function reapOrphanedOpencodeProcesses(params = {}) {
+    const currentPid = params.currentPid ?? process.pid;
+    const orphans = listOrphanedOpencodeProcesses(currentPid);
+    const terminated = [];
+    for (const orphan of orphans) {
+        try {
+            params.logger?.(`orphan_opencode_reap_attempt: pid=${orphan.pid}${orphan.name ? ` name=${orphan.name}` : ""} parentPid=${orphan.parentPid} command=${orphan.commandLine}`);
+            killProcessTreeSync(orphan.pid);
+            if (await waitForProcessExit(orphan.pid, PEER_BRIDGE_EXIT_TIMEOUT_MS)) {
+                terminated.push(orphan.pid);
+                params.logger?.(`orphan_opencode_reaped: pid=${orphan.pid}`);
+            }
+            else {
+                params.logger?.(`orphan_opencode_reap_timeout: pid=${orphan.pid}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            params.logger?.(`orphan_opencode_reap_failed: pid=${orphan.pid} error=${message}`);
+        }
+    }
+    return terminated;
+}

package/dist/bridge/bridge-state.js

@@ -0,0 +1,356 @@
+import fs from "node:fs";
+import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
+import { buildInstanceId } from "./bridge-utils.js";
+const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;
+const ORPHAN_LOCK_RECLAIM_POLL_MS = 100;
+function cloneState(state) {
+    return JSON.parse(JSON.stringify(state));
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleepSync(ms) {
+    if (ms <= 0) {
+        return;
+    }
+    // Rare startup-only reclaim path; blocking briefly here keeps the lock flow simple.
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function waitForProcessExitSync(pid, timeoutMs, isProcessAlive = isPidAlive) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        sleepSync(Math.min(ORPHAN_LOCK_RECLAIM_POLL_MS, deadline - Date.now()));
+    }
+    return !isProcessAlive(pid);
+}
+export function normalizeBridgeLockPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.pid !== "number" ||
+        typeof record.instanceId !== "string" ||
+        typeof record.adapter !== "string" ||
+        typeof record.command !== "string" ||
+        typeof record.cwd !== "string" ||
+        typeof record.startedAt !== "string") {
+        return null;
+    }
+    const adapter = record.adapter === "codex" ||
+        record.adapter === "claude" ||
+        record.adapter === "opencode" ||
+        record.adapter === "shell"
+        ? record.adapter
+        : null;
+    if (!adapter) {
+        return null;
+    }
+    const hasExplicitLifecycle = record.lifecycle === "persistent" || record.lifecycle === "companion_bound";
+    return {
+        pid: record.pid,
+        parentPid: typeof record.parentPid === "number" ? record.parentPid : 0,
+        instanceId: record.instanceId,
+        adapter,
+        command: record.command,
+        cwd: record.cwd,
+        startedAt: record.startedAt,
+        lifecycle: record.lifecycle === "companion_bound" ? "companion_bound" : "persistent",
+        legacyLifecycleFallback: hasExplicitLifecycle ? undefined : true,
+    };
+}
+export function readBridgeLockFile() {
+    try {
+        if (!fs.existsSync(BRIDGE_LOCK_FILE)) {
+            return null;
+        }
+        return normalizeBridgeLockPayload(JSON.parse(fs.readFileSync(BRIDGE_LOCK_FILE, "utf-8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function shouldAutoReclaimBridgeLock(lock, isProcessAlive = isPidAlive) {
+    if (lock.lifecycle === "companion_bound" ||
+        (lock.legacyLifecycleFallback === true && lock.adapter === "codex")) {
+        return lock.parentPid > 1 && !isProcessAlive(lock.parentPid);
+    }
+    // For persistent lifecycle (e.g. opencode), reclaim the lock if the
+    // lock-holding process is no longer alive.  This prevents stale locks
+    // from permanently blocking subsequent bridge starts when the process
+    // was force-killed (SIGKILL, Task Manager, OOM, etc.).
+    return !isProcessAlive(lock.pid);
+}
+export function evaluateBridgeRuntimeOwnership(params) {
+    const isProcessAlive = params.isProcessAlive ?? isPidAlive;
+    if (params.workspaceStateInstanceId &&
+        params.workspaceStateInstanceId !== params.currentInstanceId) {
+        return {
+            ok: false,
+            reason: "superseded",
+            activeInstanceId: params.workspaceStateInstanceId,
+        };
+    }
+    if (params.lock &&
+        params.lock.pid === params.currentPid &&
+        params.lock.instanceId === params.currentInstanceId) {
+        return {
+            ok: true,
+            rehydratedLock: false,
+        };
+    }
+    if (params.lock &&
+        params.lock.instanceId !== params.currentInstanceId &&
+        isProcessAlive(params.lock.pid)) {
+        return {
+            ok: false,
+            reason: "lock_conflict",
+            activeInstanceId: params.lock.instanceId,
+            activePid: params.lock.pid,
+        };
+    }
+    return {
+        ok: true,
+        rehydratedLock: true,
+    };
+}
+function buildLockConflictError(lock) {
+    return new Error(`Another bridge instance is already running (pid=${lock.pid}, instanceId=${lock.instanceId}, adapter=${lock.adapter}, cwd=${lock.cwd}, startedAt=${lock.startedAt}, lifecycle=${lock.lifecycle}). Stop it before starting a new bridge.`);
+}
+function tryTerminateOrphanedBridge(lock) {
+    try {
+        process.kill(lock.pid);
+    }
+    catch {
+        if (isPidAlive(lock.pid)) {
+            return false;
+        }
+    }
+    return waitForProcessExitSync(lock.pid, ORPHAN_LOCK_RECLAIM_TIMEOUT_MS);
+}
+export class BridgeStateStore {
+    state;
+    lockPayload;
+    bridgeStartedAtMs;
+    instanceId;
+    stateFilePath;
+    constructor(options) {
+        ensureChannelDataDir();
+        this.stateFilePath = ensureWorkspaceChannelDir(options.cwd).stateFile;
+        this.bridgeStartedAtMs = Date.now();
+        this.instanceId = buildInstanceId();
+        this.lockPayload = {
+            pid: process.pid,
+            parentPid: process.ppid,
+            instanceId: this.instanceId,
+            adapter: options.adapter,
+            command: options.command,
+            cwd: options.cwd,
+            startedAt: new Date(this.bridgeStartedAtMs).toISOString(),
+            lifecycle: options.lifecycle,
+        };
+        this.acquireLock();
+        const persisted = this.readStateFile();
+        const persistedSharedSessionId = persisted?.cwd === options.cwd
+            ? persisted.sharedSessionId ?? persisted.sharedThreadId
+            : undefined;
+        const persistedResumeConversationId = options.adapter === "claude" &&
+            persisted?.cwd === options.cwd &&
+            typeof persisted.resumeConversationId === "string"
+            ? persisted.resumeConversationId
+            : undefined;
+        const persistedTranscriptPath = options.adapter === "claude" &&
+            persisted?.cwd === options.cwd &&
+            typeof persisted.transcriptPath === "string"
+            ? persisted.transcriptPath
+            : undefined;
+        this.state = {
+            instanceId: this.instanceId,
+            adapter: options.adapter,
+            command: options.command,
+            cwd: options.cwd,
+            profile: options.profile,
+            authorizedUserId: options.authorizedUserId,
+            bridgeStartedAtMs: this.bridgeStartedAtMs,
+            ignoredBacklogCount: 0,
+            sharedSessionId: persistedSharedSessionId,
+            sharedThreadId: options.adapter === "codex" ? persistedSharedSessionId : undefined,
+            resumeConversationId: persistedResumeConversationId,
+            transcriptPath: persistedTranscriptPath,
+            lastActivityAt: persisted?.lastActivityAt,
+            pendingConfirmation: null,
+            pendingUserInput: null,
+        };
+        this.save();
+        if (persisted?.pendingConfirmation) {
+            this.appendLog("Cleared stale pending confirmation from previous bridge session.");
+        }
+        if (persisted?.pendingUserInput) {
+            this.appendLog("Cleared stale pending user input request from previous bridge session.");
+        }
+    }
+    getState() {
+        return cloneState(this.state);
+    }
+    touchActivity(timestamp = new Date().toISOString()) {
+        this.state.lastActivityAt = timestamp;
+        this.save();
+    }
+    setPendingConfirmation(pending) {
+        this.state.pendingConfirmation = pending;
+        this.save();
+    }
+    clearPendingConfirmation() {
+        if (!this.state.pendingConfirmation) {
+            return;
+        }
+        this.state.pendingConfirmation = null;
+        this.save();
+    }
+    setPendingUserInput(pending) {
+        this.state.pendingUserInput = pending;
+        this.save();
+    }
+    clearPendingUserInput() {
+        if (!this.state.pendingUserInput) {
+            return;
+        }
+        this.state.pendingUserInput = null;
+        this.save();
+    }
+    incrementIgnoredBacklog(count = 1) {
+        this.state.ignoredBacklogCount += count;
+        this.save();
+    }
+    setSharedSessionId(sessionId) {
+        this.state.sharedSessionId = sessionId;
+        this.state.sharedThreadId = this.state.adapter === "codex" ? sessionId : undefined;
+        this.save();
+    }
+    setSharedThreadId(threadId) {
+        this.setSharedSessionId(threadId);
+    }
+    clearSharedSessionId() {
+        if (!this.state.sharedSessionId && !this.state.sharedThreadId) {
+            return;
+        }
+        this.state.sharedSessionId = undefined;
+        this.state.sharedThreadId = undefined;
+        this.save();
+    }
+    clearSharedThreadId() {
+        this.clearSharedSessionId();
+    }
+    setClaudeResumeState(resumeConversationId, transcriptPath) {
+        if (this.state.adapter !== "claude") {
+            return;
+        }
+        this.state.resumeConversationId = resumeConversationId || undefined;
+        this.state.transcriptPath = transcriptPath || undefined;
+        this.save();
+    }
+    clearClaudeResumeState() {
+        if (this.state.adapter !== "claude" ||
+            (!this.state.resumeConversationId && !this.state.transcriptPath)) {
+            return;
+        }
+        this.state.resumeConversationId = undefined;
+        this.state.transcriptPath = undefined;
+        this.save();
+    }
+    appendLog(message) {
+        ensureChannelDataDir();
+        fs.appendFileSync(BRIDGE_LOG_FILE, `[${new Date().toISOString()}] ${message}\n`, "utf-8");
+    }
+    releaseLock() {
+        try {
+            const currentLock = readBridgeLockFile();
+            if (currentLock?.pid === process.pid) {
+                fs.rmSync(BRIDGE_LOCK_FILE, { force: true });
+            }
+        }
+        catch {
+            // Best effort cleanup.
+        }
+    }
+    save() {
+        ensureChannelDataDir();
+        fs.writeFileSync(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf-8");
+    }
+    acquireLock() {
+        const existing = readBridgeLockFile();
+        if (existing &&
+            existing.pid !== process.pid &&
+            isPidAlive(existing.pid)) {
+            if (shouldAutoReclaimBridgeLock(existing)) {
+                this.appendLog(`lock_reclaim_attempt: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
+                if (tryTerminateOrphanedBridge(existing)) {
+                    this.appendLog(`lock_reclaimed: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
+                }
+                else {
+                    this.appendLog(`lock_reclaim_failed: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
+                    throw buildLockConflictError(existing);
+                }
+            }
+            else {
+                this.appendLog(`lock_conflict: pid=${existing.pid} instanceId=${existing.instanceId} adapter=${existing.adapter} cwd=${existing.cwd}`);
+                throw buildLockConflictError(existing);
+            }
+        }
+        fs.writeFileSync(BRIDGE_LOCK_FILE, JSON.stringify(this.lockPayload, null, 2), "utf-8");
+    }
+    verifyRuntimeOwnership() {
+        const workspaceState = this.readWorkspaceStateFile();
+        const ownership = evaluateBridgeRuntimeOwnership({
+            currentInstanceId: this.instanceId,
+            currentPid: process.pid,
+            workspaceStateInstanceId: typeof workspaceState?.instanceId === "string"
+                ? workspaceState.instanceId
+                : undefined,
+            lock: readBridgeLockFile(),
+        });
+        if (!ownership.ok) {
+            return ownership;
+        }
+        if (!workspaceState?.instanceId) {
+            this.save();
+        }
+        if (ownership.rehydratedLock) {
+            fs.writeFileSync(BRIDGE_LOCK_FILE, JSON.stringify(this.lockPayload, null, 2), "utf-8");
+        }
+        return ownership;
+    }
+    readStateFile() {
+        try {
+            if (!fs.existsSync(this.stateFilePath)) {
+                return null;
+            }
+            return JSON.parse(fs.readFileSync(this.stateFilePath, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    readWorkspaceStateFile() {
+        try {
+            if (!fs.existsSync(this.stateFilePath)) {
+                return null;
+            }
+            return JSON.parse(fs.readFileSync(this.stateFilePath, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/bridge/bridge-types.js

@@ -0,0 +1 @@
+export {};