@hua-labs/tap 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,272 @@
+type RuntimeName = "claude" | "codex" | "gemini";
+type BridgeMode = "native-push" | "app-server" | "polling";
+type Platform = "win32" | "darwin" | "linux";
+/** Unique, immutable identifier for a runtime instance. e.g. "codex", "codex-reviewer" */
+type InstanceId = string;
+interface AdapterContext {
+    commsDir: string;
+    repoRoot: string;
+    stateDir: string;
+    platform: Platform;
+}
+interface ProbeResult {
+    installed: boolean;
+    configPath: string | null;
+    configExists: boolean;
+    runtimeCommand: string | null;
+    version: string | null;
+    canWrite: boolean;
+    warnings: string[];
+    issues: string[];
+}
+type ArtifactKind = "json-path" | "toml-table" | "file";
+interface OwnedArtifact {
+    kind: ArtifactKind;
+    path: string;
+    selector: string;
+    backupPath?: string;
+}
+type PatchOpType = "set" | "merge" | "append" | "create-file";
+interface PatchOp {
+    type: PatchOpType;
+    path: string;
+    key?: string;
+    value?: unknown;
+    content?: string;
+}
+interface PatchPlan {
+    runtime: RuntimeName;
+    operations: PatchOp[];
+    ownedArtifacts: OwnedArtifact[];
+    backupDir: string;
+    restartRequired: boolean;
+    conflicts: string[];
+    warnings: string[];
+}
+interface ApplyResult {
+    success: boolean;
+    appliedOps: number;
+    backupCreated: boolean;
+    lastAppliedHash: string;
+    ownedArtifacts: OwnedArtifact[];
+    changedFiles: string[];
+    restartRequired: boolean;
+    warnings: string[];
+}
+interface VerifyCheck {
+    name: string;
+    passed: boolean;
+    message?: string;
+}
+interface VerifyResult {
+    ok: boolean;
+    checks: VerifyCheck[];
+    restartRequired: boolean;
+    warnings: string[];
+}
+interface RuntimeAdapter {
+    readonly runtime: RuntimeName;
+    probe(ctx: AdapterContext): Promise<ProbeResult>;
+    plan(ctx: AdapterContext, probe: ProbeResult): Promise<PatchPlan>;
+    apply(ctx: AdapterContext, plan: PatchPlan): Promise<ApplyResult>;
+    verify(ctx: AdapterContext, plan: PatchPlan): Promise<VerifyResult>;
+    bridgeMode(): BridgeMode;
+    /** Resolve the bridge script path. Only called for app-server mode. */
+    resolveBridgeScript?(ctx: AdapterContext): string | null;
+}
+type AgentRole = "reviewer" | "validator" | "long-running";
+interface HeadlessConfig {
+    enabled: boolean;
+    role: AgentRole;
+    /** Max review rounds before forced termination. Default: 5 */
+    maxRounds: number;
+    /** Severity floor for quality-threshold strategy. Default: "high" */
+    qualitySeverityFloor: "critical" | "high" | "medium";
+}
+interface BridgeState {
+    pid: number;
+    statePath: string;
+    lastHeartbeat: string;
+}
+/** Runtime instance state. Supports multiple instances per runtime (e.g. codex-reviewer, codex-builder). */
+interface InstanceState {
+    instanceId: InstanceId;
+    runtime: RuntimeName;
+    agentName: string | null;
+    port: number | null;
+    installed: boolean;
+    configPath: string;
+    bridgeMode: BridgeMode;
+    restartRequired: boolean;
+    ownedArtifacts: OwnedArtifact[];
+    backupPath: string;
+    lastAppliedHash: string;
+    lastVerifiedAt: string | null;
+    bridge: BridgeState | null;
+    /** Headless mode configuration. null = interactive (default). */
+    headless: HeadlessConfig | null;
+    warnings: string[];
+}
+/** @deprecated Use InstanceState. Kept for v1 state migration. */
+interface RuntimeState {
+    installed: boolean;
+    configPath: string;
+    bridgeMode: BridgeMode;
+    restartRequired: boolean;
+    ownedArtifacts: OwnedArtifact[];
+    backupPath: string;
+    lastAppliedHash: string;
+    lastVerifiedAt: string | null;
+    bridge: BridgeState | null;
+    warnings: string[];
+}
+/** Schema v2: instances keyed by InstanceId */
+interface TapState {
+    schemaVersion: number;
+    createdAt: string;
+    updatedAt: string;
+    commsDir: string;
+    repoRoot: string;
+    packageVersion: string;
+    instances: Record<InstanceId, InstanceState>;
+}
+/** Schema v1: runtimes keyed by RuntimeName. Used for migration only. */
+interface TapStateV1 {
+    schemaVersion: 1;
+    createdAt: string;
+    updatedAt: string;
+    commsDir: string;
+    repoRoot: string;
+    packageVersion: string;
+    runtimes: Partial<Record<RuntimeName, RuntimeState>>;
+}
+type CommandName = "init" | "init-worktree" | "add" | "remove" | "status" | "serve" | "bridge" | "dashboard" | "unknown";
+type CommandCode = "TAP_INIT_OK" | "TAP_ADD_OK" | "TAP_REMOVE_OK" | "TAP_STATUS_OK" | "TAP_SERVE_OK" | "TAP_NO_OP" | "TAP_ALREADY_INITIALIZED" | "TAP_NOT_INITIALIZED" | "TAP_RUNTIME_UNKNOWN" | "TAP_RUNTIME_NOT_FOUND" | "TAP_CONFIG_INVALID" | "TAP_LOCAL_SERVER_MISSING" | "TAP_INVALID_ARGUMENT" | "TAP_INSTANCE_NOT_FOUND" | "TAP_INSTANCE_AMBIGUOUS" | "TAP_PORT_CONFLICT" | "TAP_PATCH_FAILED" | "TAP_VERIFY_FAILED" | "TAP_ROLLBACK_FAILED" | "TAP_BRIDGE_START_OK" | "TAP_BRIDGE_START_FAILED" | "TAP_BRIDGE_STOP_OK" | "TAP_BRIDGE_STATUS_OK" | "TAP_BRIDGE_NOT_RUNNING" | "TAP_BRIDGE_SCRIPT_MISSING" | "TAP_SERVE_NO_SERVER" | "TAP_SERVE_BUN_REQUIRED" | "TAP_REVIEW_START_OK" | "TAP_REVIEW_TERMINATED" | "TAP_INTERNAL_ERROR";
+interface CommandResult<T = Record<string, unknown>> {
+    ok: boolean;
+    command: CommandName;
+    runtime?: RuntimeName;
+    instanceId?: InstanceId;
+    code: CommandCode;
+    message: string;
+    warnings: string[];
+    data: T;
+}
+
+declare function stateExists(repoRoot: string): boolean;
+declare function loadState(repoRoot: string): TapState | null;
+declare function saveState(repoRoot: string, state: TapState): void;
+declare function createInitialState(commsDir: string, repoRoot: string, packageVersion: string): TapState;
+
+declare const version = "0.1.0";
+
+/**
+ * Shared config (tap-config.json) — git tracked, repo-level defaults.
+ * All paths are repo-relative unless explicitly absolute.
+ */
+interface TapSharedConfig {
+    /** Comms directory path. Repo-relative or absolute. */
+    commsDir?: string;
+    /** State directory path. Defaults to .tap-comms/ under repoRoot. */
+    stateDir?: string;
+    /** Runtime command: "bun" | "node". */
+    runtimeCommand?: string;
+    /** App server WebSocket URL for bridge connections. */
+    appServerUrl?: string;
+}
+/**
+ * Local config (tap-config.local.json) — gitignored, machine-specific overrides.
+ * Same shape as shared, overrides shared values.
+ */
+type TapLocalConfig = TapSharedConfig;
+/**
+ * Resolved config — all values populated, absolute paths.
+ */
+interface TapResolvedConfig {
+    repoRoot: string;
+    commsDir: string;
+    stateDir: string;
+    runtimeCommand: string;
+    appServerUrl: string;
+}
+/** Config resolution source for diagnostics. */
+type ConfigSource = "cli-flag" | "env" | "local-config" | "shared-config" | "auto";
+interface ConfigResolution {
+    config: TapResolvedConfig;
+    sources: Record<keyof TapResolvedConfig, ConfigSource>;
+}
+
+declare const SHARED_CONFIG_FILE = "tap-config.json";
+declare const LOCAL_CONFIG_FILE = "tap-config.local.json";
+declare function loadSharedConfig(repoRoot: string): TapSharedConfig | null;
+declare function loadLocalConfig(repoRoot: string): TapLocalConfig | null;
+interface ConfigOverrides {
+    commsDir?: string;
+    stateDir?: string;
+    runtimeCommand?: string;
+    appServerUrl?: string;
+}
+/**
+ * Resolve config with priority: CLI flag > env > local config > shared config > auto.
+ */
+declare function resolveConfig(overrides?: ConfigOverrides, startDir?: string): ConfigResolution;
+declare function saveSharedConfig(repoRoot: string, config: TapSharedConfig): void;
+declare function saveLocalConfig(repoRoot: string, config: TapLocalConfig): void;
+
+declare function rotateLog(logPath: string): void;
+/**
+ * Update the heartbeat timestamp for a running bridge.
+ * Bridge processes should call this periodically.
+ *
+ * Only the owning process (matching PID) can update the heartbeat.
+ * This prevents state dir collision when multiple writers exist.
+ * See: 묵 finding — bridge-heartbeat-state-dir-collision
+ */
+declare function updateBridgeHeartbeat(stateDir: string, instanceId: InstanceId): void;
+/**
+ * Get heartbeat age in seconds. Returns null if no state or no heartbeat.
+ */
+declare function getHeartbeatAge(stateDir: string, instanceId: InstanceId): number | null;
+
+/**
+ * Common Node.js runtime resolver for all tap-comms child processes.
+ *
+ * Resolution chain:
+ *   .node-version + fnm probe → configured command → tsx fallback
+ *
+ * Extracted from codex-bridge-runner.ts (M69) to share across:
+ *   - bridge engine spawn
+ *   - bridge runner spawn
+ *   - future CLI commands
+ */
+type RuntimeSource = "fnm" | "config" | "path" | "tsx-fallback" | "bun";
+interface ResolvedRuntime {
+    /** Absolute path or command name for the resolved runtime. */
+    command: string;
+    /** Whether --experimental-strip-types is supported and should be used. */
+    supportsStripTypes: boolean;
+    /** Where the runtime was resolved from (for diagnostics). */
+    source: RuntimeSource;
+    /** Detected major version, if available. */
+    majorVersion: number | null;
+}
+declare function readNodeVersion(repoRoot: string): string | null;
+declare function probeFnmNode(desiredVersion: string): string | null;
+/**
+ * Returns the directory containing the fnm-managed node binary,
+ * suitable for prepending to PATH in child processes.
+ */
+declare function getFnmBinDir(repoRoot: string): string | null;
+/**
+ * Resolve the Node.js runtime to use for spawning child processes.
+ *
+ * Priority: bun passthrough → .node-version + fnm → configured command → tsx fallback
+ */
+declare function resolveNodeRuntime(configCommand: string, repoRoot: string): ResolvedRuntime;
+/**
+ * Build an env object with fnm Node prepended to PATH.
+ * Use this when spawning child processes that need the correct Node.
+ */
+declare function buildRuntimeEnv(repoRoot: string, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+
+export { type AdapterContext, type ApplyResult, type ArtifactKind, type BridgeMode, type BridgeState, type CommandCode, type CommandName, type CommandResult, type ConfigOverrides, type ConfigResolution, type ConfigSource, type InstanceId, type InstanceState, LOCAL_CONFIG_FILE, type OwnedArtifact, type PatchOp, type PatchOpType, type PatchPlan, type Platform, type ProbeResult, type ResolvedRuntime, type RuntimeAdapter, type RuntimeName, type RuntimeSource, type RuntimeState, SHARED_CONFIG_FILE, type TapLocalConfig, type TapResolvedConfig, type TapSharedConfig, type TapState, type TapStateV1, type VerifyCheck, type VerifyResult, buildRuntimeEnv, createInitialState, getFnmBinDir, getHeartbeatAge, loadLocalConfig, loadSharedConfig, loadState, probeFnmNode, readNodeVersion, resolveConfig, resolveNodeRuntime, rotateLog, saveLocalConfig, saveSharedConfig, saveState, stateExists, updateBridgeHeartbeat, version };

package/dist/index.mjs

@@ -0,0 +1,439 @@
+// src/state.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as crypto from "crypto";
+
+// src/config/resolve.ts
+import * as fs from "fs";
+import * as path from "path";
+var SHARED_CONFIG_FILE = "tap-config.json";
+var LOCAL_CONFIG_FILE = "tap-config.local.json";
+var DEFAULT_RUNTIME_COMMAND = "node";
+var DEFAULT_APP_SERVER_URL = "ws://127.0.0.1:4501";
+function findRepoRoot(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+function loadJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function loadSharedConfig(repoRoot) {
+  return loadJsonFile(path.join(repoRoot, SHARED_CONFIG_FILE));
+}
+function loadLocalConfig(repoRoot) {
+  return loadJsonFile(path.join(repoRoot, LOCAL_CONFIG_FILE));
+}
+function resolveConfig(overrides = {}, startDir) {
+  const repoRoot = findRepoRoot(startDir);
+  const shared = loadSharedConfig(repoRoot) ?? {};
+  const local = loadLocalConfig(repoRoot) ?? {};
+  const sources = {
+    repoRoot: "auto",
+    commsDir: "auto",
+    stateDir: "auto",
+    runtimeCommand: "auto",
+    appServerUrl: "auto"
+  };
+  let commsDir;
+  if (overrides.commsDir) {
+    commsDir = path.resolve(overrides.commsDir);
+    sources.commsDir = "cli-flag";
+  } else if (process.env.TAP_COMMS_DIR) {
+    commsDir = path.resolve(process.env.TAP_COMMS_DIR);
+    sources.commsDir = "env";
+  } else if (local.commsDir) {
+    commsDir = resolvePath(repoRoot, local.commsDir);
+    sources.commsDir = "local-config";
+  } else if (shared.commsDir) {
+    commsDir = resolvePath(repoRoot, shared.commsDir);
+    sources.commsDir = "shared-config";
+  } else {
+    commsDir = path.join(path.dirname(repoRoot), "tap-comms");
+  }
+  let stateDir;
+  if (overrides.stateDir) {
+    stateDir = path.resolve(overrides.stateDir);
+    sources.stateDir = "cli-flag";
+  } else if (process.env.TAP_STATE_DIR) {
+    stateDir = path.resolve(process.env.TAP_STATE_DIR);
+    sources.stateDir = "env";
+  } else if (local.stateDir) {
+    stateDir = resolvePath(repoRoot, local.stateDir);
+    sources.stateDir = "local-config";
+  } else if (shared.stateDir) {
+    stateDir = resolvePath(repoRoot, shared.stateDir);
+    sources.stateDir = "shared-config";
+  } else {
+    stateDir = path.join(repoRoot, ".tap-comms");
+  }
+  let runtimeCommand;
+  if (overrides.runtimeCommand) {
+    runtimeCommand = overrides.runtimeCommand;
+    sources.runtimeCommand = "cli-flag";
+  } else if (process.env.TAP_RUNTIME_COMMAND) {
+    runtimeCommand = process.env.TAP_RUNTIME_COMMAND;
+    sources.runtimeCommand = "env";
+  } else if (local.runtimeCommand) {
+    runtimeCommand = local.runtimeCommand;
+    sources.runtimeCommand = "local-config";
+  } else if (shared.runtimeCommand) {
+    runtimeCommand = shared.runtimeCommand;
+    sources.runtimeCommand = "shared-config";
+  } else {
+    runtimeCommand = DEFAULT_RUNTIME_COMMAND;
+  }
+  let appServerUrl;
+  if (overrides.appServerUrl) {
+    appServerUrl = overrides.appServerUrl;
+    sources.appServerUrl = "cli-flag";
+  } else if (process.env.TAP_APP_SERVER_URL) {
+    appServerUrl = process.env.TAP_APP_SERVER_URL;
+    sources.appServerUrl = "env";
+  } else if (local.appServerUrl) {
+    appServerUrl = local.appServerUrl;
+    sources.appServerUrl = "local-config";
+  } else if (shared.appServerUrl) {
+    appServerUrl = shared.appServerUrl;
+    sources.appServerUrl = "shared-config";
+  } else {
+    appServerUrl = DEFAULT_APP_SERVER_URL;
+  }
+  return {
+    config: { repoRoot, commsDir, stateDir, runtimeCommand, appServerUrl },
+    sources
+  };
+}
+function saveSharedConfig(repoRoot, config) {
+  const filePath = path.join(repoRoot, SHARED_CONFIG_FILE);
+  const tmp = `${filePath}.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs.renameSync(tmp, filePath);
+}
+function saveLocalConfig(repoRoot, config) {
+  const filePath = path.join(repoRoot, LOCAL_CONFIG_FILE);
+  const tmp = `${filePath}.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs.renameSync(tmp, filePath);
+}
+function resolvePath(repoRoot, p) {
+  return path.isAbsolute(p) ? p : path.resolve(repoRoot, p);
+}
+
+// src/state.ts
+var STATE_FILE = "state.json";
+var SCHEMA_VERSION = 2;
+function getStateDir(repoRoot) {
+  const { config } = resolveConfig({}, repoRoot);
+  return config.stateDir;
+}
+function getStatePath(repoRoot) {
+  return path2.join(getStateDir(repoRoot), STATE_FILE);
+}
+function stateExists(repoRoot) {
+  return fs2.existsSync(getStatePath(repoRoot));
+}
+function migrateStateV1toV2(v1) {
+  const instances = {};
+  for (const [runtime, rs] of Object.entries(v1.runtimes)) {
+    if (!rs) continue;
+    const instanceId = runtime;
+    instances[instanceId] = {
+      instanceId,
+      runtime,
+      agentName: null,
+      port: null,
+      headless: null,
+      ...rs
+    };
+  }
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    createdAt: v1.createdAt,
+    updatedAt: v1.updatedAt,
+    commsDir: v1.commsDir,
+    repoRoot: v1.repoRoot,
+    packageVersion: v1.packageVersion,
+    instances
+  };
+}
+function loadState(repoRoot) {
+  const statePath = getStatePath(repoRoot);
+  if (!fs2.existsSync(statePath)) return null;
+  const raw = fs2.readFileSync(statePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (parsed.schemaVersion === 1 || parsed.runtimes) {
+    const migrated = migrateStateV1toV2(parsed);
+    saveState(repoRoot, migrated);
+    return migrated;
+  }
+  return parsed;
+}
+function saveState(repoRoot, state) {
+  const stateDir = getStateDir(repoRoot);
+  fs2.mkdirSync(stateDir, { recursive: true });
+  const statePath = getStatePath(repoRoot);
+  const tmp = `${statePath}.tmp.${process.pid}`;
+  fs2.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  fs2.renameSync(tmp, statePath);
+}
+function createInitialState(commsDir, repoRoot, packageVersion) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    createdAt: now,
+    updatedAt: now,
+    commsDir: path2.resolve(commsDir),
+    repoRoot: path2.resolve(repoRoot),
+    packageVersion,
+    instances: {}
+  };
+}
+
+// src/version.ts
+var version = "0.1.0";
+
+// src/engine/bridge.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { spawn, execSync as execSync2 } from "child_process";
+
+// src/runtime/resolve-node.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { execSync } from "child_process";
+function readNodeVersion(repoRoot) {
+  const nvFile = path3.join(repoRoot, ".node-version");
+  if (!fs3.existsSync(nvFile)) return null;
+  try {
+    const raw = fs3.readFileSync(nvFile, "utf-8").trim();
+    return raw.length > 0 ? raw.replace(/^v/, "") : null;
+  } catch {
+    return null;
+  }
+}
+function fnmCandidateDirs() {
+  if (process.platform === "win32") {
+    return [
+      process.env.FNM_DIR,
+      process.env.APPDATA ? path3.join(process.env.APPDATA, "fnm") : null,
+      process.env.LOCALAPPDATA ? path3.join(process.env.LOCALAPPDATA, "fnm") : null,
+      process.env.USERPROFILE ? path3.join(process.env.USERPROFILE, "scoop", "persist", "fnm") : null
+    ].filter(Boolean);
+  }
+  return [
+    process.env.FNM_DIR,
+    process.env.HOME ? path3.join(process.env.HOME, ".local", "share", "fnm") : null,
+    process.env.HOME ? path3.join(process.env.HOME, ".fnm") : null,
+    process.env.XDG_DATA_HOME ? path3.join(process.env.XDG_DATA_HOME, "fnm") : null
+  ].filter(Boolean);
+}
+function nodeExecutableName() {
+  return process.platform === "win32" ? "node.exe" : "node";
+}
+function probeFnmNode(desiredVersion) {
+  const dirs = fnmCandidateDirs();
+  const exe = nodeExecutableName();
+  for (const baseDir of dirs) {
+    const candidate = path3.join(
+      baseDir,
+      "node-versions",
+      `v${desiredVersion}`,
+      "installation",
+      exe
+    );
+    if (!fs3.existsSync(candidate)) continue;
+    try {
+      const v = execSync(`"${candidate}" --version`, {
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      if (v.startsWith(`v${desiredVersion.split(".")[0]}.`)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function detectNodeMajorVersion(command) {
+  try {
+    const version2 = execSync(`"${command}" --version`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    const match = version2.match(/^v?(\d+)\./);
+    return match ? parseInt(match[1], 10) : null;
+  } catch {
+    return null;
+  }
+}
+function checkStripTypesSupport(command) {
+  const major = detectNodeMajorVersion(command);
+  if (major !== null && major >= 22) return true;
+  try {
+    execSync(`"${command}" --experimental-strip-types -e ""`, {
+      timeout: 5e3,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findTsxFallback(repoRoot) {
+  const candidates = [
+    path3.join(repoRoot, "node_modules", ".bin", "tsx.exe"),
+    path3.join(repoRoot, "node_modules", ".bin", "tsx.CMD"),
+    path3.join(repoRoot, "node_modules", ".bin", "tsx")
+  ];
+  for (const c of candidates) {
+    if (fs3.existsSync(c)) return c;
+  }
+  return null;
+}
+function getFnmBinDir(repoRoot) {
+  const desiredVersion = readNodeVersion(repoRoot);
+  if (!desiredVersion) return null;
+  const nodePath = probeFnmNode(desiredVersion);
+  if (!nodePath) return null;
+  return path3.dirname(nodePath);
+}
+function resolveNodeRuntime(configCommand, repoRoot) {
+  if (configCommand === "bun" || configCommand.endsWith("bun.exe")) {
+    return {
+      command: configCommand,
+      supportsStripTypes: false,
+      source: "bun",
+      majorVersion: null
+    };
+  }
+  const desiredVersion = readNodeVersion(repoRoot);
+  if (desiredVersion) {
+    const fnmNode = probeFnmNode(desiredVersion);
+    if (fnmNode) {
+      const major2 = detectNodeMajorVersion(fnmNode);
+      return {
+        command: fnmNode,
+        supportsStripTypes: checkStripTypesSupport(fnmNode),
+        source: "fnm",
+        majorVersion: major2
+      };
+    }
+  }
+  const major = detectNodeMajorVersion(configCommand);
+  if (major !== null) {
+    return {
+      command: configCommand,
+      supportsStripTypes: checkStripTypesSupport(configCommand),
+      source: major === detectNodeMajorVersion("node") ? "path" : "config",
+      majorVersion: major
+    };
+  }
+  const tsx = findTsxFallback(repoRoot);
+  if (tsx) {
+    return {
+      command: tsx,
+      supportsStripTypes: false,
+      source: "tsx-fallback",
+      majorVersion: null
+    };
+  }
+  return {
+    command: configCommand,
+    supportsStripTypes: false,
+    source: "path",
+    majorVersion: null
+  };
+}
+function buildRuntimeEnv(repoRoot, baseEnv = process.env) {
+  const fnmBin = getFnmBinDir(repoRoot);
+  if (!fnmBin) return { ...baseEnv };
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const currentPath = baseEnv[pathKey] ?? baseEnv.PATH ?? "";
+  return {
+    ...baseEnv,
+    [pathKey]: `${fnmBin}${path3.delimiter}${currentPath}`
+  };
+}
+
+// src/engine/bridge.ts
+function pidFilePath(stateDir, instanceId) {
+  return path4.join(stateDir, "pids", `bridge-${instanceId}.json`);
+}
+function loadBridgeState(stateDir, instanceId) {
+  const pidPath = pidFilePath(stateDir, instanceId);
+  if (!fs4.existsSync(pidPath)) return null;
+  try {
+    const raw = fs4.readFileSync(pidPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveBridgeState(stateDir, instanceId, state) {
+  const pidPath = pidFilePath(stateDir, instanceId);
+  fs4.mkdirSync(path4.dirname(pidPath), { recursive: true });
+  const tmp = `${pidPath}.tmp.${process.pid}`;
+  fs4.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  fs4.renameSync(tmp, pidPath);
+}
+function rotateLog(logPath) {
+  if (!fs4.existsSync(logPath)) return;
+  try {
+    const stats = fs4.statSync(logPath);
+    if (stats.size === 0) return;
+    const prevPath = `${logPath}.prev`;
+    fs4.renameSync(logPath, prevPath);
+  } catch {
+  }
+}
+function updateBridgeHeartbeat(stateDir, instanceId) {
+  const state = loadBridgeState(stateDir, instanceId);
+  if (!state) return;
+  if (state.pid !== process.pid) return;
+  state.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+  saveBridgeState(stateDir, instanceId, state);
+}
+function getHeartbeatAge(stateDir, instanceId) {
+  const state = loadBridgeState(stateDir, instanceId);
+  if (!state?.lastHeartbeat) return null;
+  const heartbeatTime = new Date(state.lastHeartbeat).getTime();
+  if (isNaN(heartbeatTime)) return null;
+  return Math.floor((Date.now() - heartbeatTime) / 1e3);
+}
+export {
+  LOCAL_CONFIG_FILE,
+  SHARED_CONFIG_FILE,
+  buildRuntimeEnv,
+  createInitialState,
+  getFnmBinDir,
+  getHeartbeatAge,
+  loadLocalConfig,
+  loadSharedConfig,
+  loadState,
+  probeFnmNode,
+  readNodeVersion,
+  resolveConfig,
+  resolveNodeRuntime,
+  rotateLog,
+  saveLocalConfig,
+  saveSharedConfig,
+  saveState,
+  stateExists,
+  updateBridgeHeartbeat,
+  version
+};
+//# sourceMappingURL=index.mjs.map