@hua-labs/tap 0.1.1 → 0.2.1

package/dist/bridges/codex-bridge-runner.mjs

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 };
 
 // src/engine/termination.ts
-import * as fs3 from "fs";
+import * as fs5 from "fs";
 import * as crypto from "crypto";
 function isAtOrAbove(severity, floor) {
   return SEVERITY_RANK[severity] >= SEVERITY_RANK[floor];
@@ -20,7 +20,7 @@ function computeFindingHash(findings) {
   return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function evalManualStop(ctx) {
-  if (fs3.existsSync(ctx.stopSignalPath)) {
+  if (fs5.existsSync(ctx.stopSignalPath)) {
     return {
       verdict: "stop",
       reason: `Manual stop signal found at ${ctx.stopSignalPath}`,
@@ -145,11 +145,11 @@ var init_termination = __esm({
 });
 
 // src/engine/review.ts
-import * as fs4 from "fs";
-import * as path3 from "path";
+import * as fs6 from "fs";
+import * as path5 from "path";
 import * as crypto2 from "crypto";
 function parseInboxFilename(filename) {
-  const base = path3.basename(filename, ".md");
+  const base = path5.basename(filename, ".md");
   const match = base.match(/^(\d{8})-([^-]+)-([^-]+)-(.+)$/);
   if (!match) return null;
   return {
@@ -201,7 +201,7 @@ function buildReviewPrompt(request, agentName, round) {
     `4. Write structured findings`,
     ``,
     `## Output`,
-    `Write review to: ${path3.join("reviews", request.generation, `review-PR${request.prNumber}-${agentName}.md`)}`,
+    `Write review to: ${path5.join("reviews", request.generation, `review-PR${request.prNumber}-${agentName}.md`)}`,
     ``,
     `### Review File Format`,
     `\`\`\`markdown`,
@@ -287,8 +287,8 @@ function extractFindings(content) {
   return findings;
 }
 function parseReviewOutput(reviewFilePath2, round) {
-  if (!fs4.existsSync(reviewFilePath2)) return null;
-  const content = fs4.readFileSync(reviewFilePath2, "utf-8");
+  if (!fs6.existsSync(reviewFilePath2)) return null;
+  const content = fs6.readFileSync(reviewFilePath2, "utf-8");
   const findings = extractFindings(content);
   const suggestedDiffLines = extractSuggestedDiffLines(content);
   return {
@@ -301,7 +301,7 @@ function parseReviewOutput(reviewFilePath2, round) {
   };
 }
 function reviewFilePath(commsDir, generation, prNumber, agentName) {
-  return path3.join(
+  return path5.join(
     commsDir,
     "reviews",
     generation,
@@ -315,42 +315,42 @@ function isStaleReviewRequest(request, commsDir, agentName) {
     request.prNumber,
     agentName
   );
-  if (fs4.existsSync(revPath) && fs4.existsSync(request.sourcePath)) {
-    const reviewStat = fs4.statSync(revPath);
-    const requestStat = fs4.statSync(request.sourcePath);
+  if (fs6.existsSync(revPath) && fs6.existsSync(request.sourcePath)) {
+    const reviewStat = fs6.statSync(revPath);
+    const requestStat = fs6.statSync(request.sourcePath);
     if (reviewStat.mtimeMs > requestStat.mtimeMs) return true;
   }
   return false;
 }
 function computeRequestMarkerId(filePath) {
-  const stat = fs4.statSync(filePath);
+  const stat = fs6.statSync(filePath);
   const input = `${filePath}|${stat.mtimeMs}`;
   return crypto2.createHash("sha1").update(input).digest("hex");
 }
 function isAlreadyProcessed(stateDir, filePath) {
   const markerId = computeRequestMarkerId(filePath);
-  return fs4.existsSync(path3.join(stateDir, "processed", `${markerId}.done`));
+  return fs6.existsSync(path5.join(stateDir, "processed", `${markerId}.done`));
 }
 function unmarkProcessed(stateDir, request) {
   const markerId = computeRequestMarkerId(request.sourcePath);
-  const markerPath = path3.join(stateDir, "processed", `${markerId}.done`);
-  if (fs4.existsSync(markerPath)) {
-    fs4.unlinkSync(markerPath);
+  const markerPath = path5.join(stateDir, "processed", `${markerId}.done`);
+  if (fs6.existsSync(markerPath)) {
+    fs6.unlinkSync(markerPath);
   }
 }
 function markAsProcessed(stateDir, request) {
   const markerId = computeRequestMarkerId(request.sourcePath);
-  const markerDir = path3.join(stateDir, "processed");
-  fs4.mkdirSync(markerDir, { recursive: true });
-  const markerPath = path3.join(markerDir, `${markerId}.done`);
+  const markerDir = path5.join(stateDir, "processed");
+  fs6.mkdirSync(markerDir, { recursive: true });
+  const markerPath = path5.join(markerDir, `${markerId}.done`);
   const payload = {
     prNumber: request.prNumber,
     sourcePath: request.sourcePath,
     processedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const tmp = `${markerPath}.tmp.${process.pid}`;
-  fs4.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf-8");
-  fs4.renameSync(tmp, markerPath);
+  fs6.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf-8");
+  fs6.renameSync(tmp, markerPath);
 }
 function writeReviewReceipt(commsDir, request, agentName) {
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
@@ -360,14 +360,14 @@ function writeReviewReceipt(commsDir, request, agentName) {
     ``,
     `- PR #${request.prNumber} review request received.`,
     `- headless reviewer processing.`,
-    `- request: ${path3.basename(request.sourcePath)}`
+    `- request: ${path5.basename(request.sourcePath)}`
   ].join("\n");
-  const inboxDir = path3.join(commsDir, "inbox");
-  fs4.mkdirSync(inboxDir, { recursive: true });
-  const inboxPath = path3.join(inboxDir, filename);
+  const inboxDir = path5.join(commsDir, "inbox");
+  fs6.mkdirSync(inboxDir, { recursive: true });
+  const inboxPath = path5.join(inboxDir, filename);
   const tmp = `${inboxPath}.tmp.${process.pid}`;
-  fs4.writeFileSync(tmp, content, "utf-8");
-  fs4.renameSync(tmp, inboxPath);
+  fs6.writeFileSync(tmp, content, "utf-8");
+  fs6.renameSync(tmp, inboxPath);
   return inboxPath;
 }
 function isHeadlessReviewer() {
@@ -382,13 +382,13 @@ function getHeadlessEnvConfig() {
   };
 }
 function scanInboxForReviews(commsDir, stateDir, generation, agentName) {
-  const inboxDir = path3.join(commsDir, "inbox");
-  if (!fs4.existsSync(inboxDir)) return [];
-  const files = fs4.readdirSync(inboxDir).filter((f) => f.endsWith(".md"));
+  const inboxDir = path5.join(commsDir, "inbox");
+  if (!fs6.existsSync(inboxDir)) return [];
+  const files = fs6.readdirSync(inboxDir).filter((f) => f.endsWith(".md"));
   const requests = [];
   for (const file of files) {
-    const filePath = path3.join(inboxDir, file);
-    const content = fs4.readFileSync(filePath, "utf-8");
+    const filePath = path5.join(inboxDir, file);
+    const content = fs6.readFileSync(filePath, "utf-8");
     const request = detectReviewRequest(filePath, content, generation);
     if (!request) continue;
     const to = request.recipient.toLowerCase();
@@ -437,8 +437,8 @@ var headless_loop_exports = {};
 __export(headless_loop_exports, {
   createHeadlessLoop: () => createHeadlessLoop
 });
-import * as fs5 from "fs";
-import * as path4 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 function createHeadlessLoop(options) {
   const envConfig = getHeadlessEnvConfig();
   const terminationConfig = {
@@ -481,12 +481,12 @@ function createHeadlessLoop(options) {
       const prompt = buildReviewPrompt(request, options.agentName, 1);
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
       const dispatchFilename = `${date}-headless-${options.agentName}-review-PR${request.prNumber}.md`;
-      const inboxDir = path4.join(options.commsDir, "inbox");
-      fs5.mkdirSync(inboxDir, { recursive: true });
-      const dispatchFile = path4.join(inboxDir, dispatchFilename);
+      const inboxDir = path6.join(options.commsDir, "inbox");
+      fs7.mkdirSync(inboxDir, { recursive: true });
+      const dispatchFile = path6.join(inboxDir, dispatchFilename);
       const tmp = `${dispatchFile}.tmp.${process.pid}`;
-      fs5.writeFileSync(tmp, prompt, "utf-8");
-      fs5.renameSync(tmp, dispatchFile);
+      fs7.writeFileSync(tmp, prompt, "utf-8");
+      fs7.renameSync(tmp, dispatchFile);
       state.activeSession = {
         request,
         agentName: options.agentName,
@@ -512,8 +512,8 @@ function createHeadlessLoop(options) {
     if (!state.activeSession) return;
     const session = state.activeSession;
     const revPath = session.reviewFilePath;
-    if (!fs5.existsSync(revPath)) return;
-    const stat = fs5.statSync(revPath);
+    if (!fs7.existsSync(revPath)) return;
+    const stat = fs7.statSync(revPath);
     const lastRound = session.rounds[session.rounds.length - 1];
     const lastCheck = lastRound?.timestamp ?? session.startedAt;
     if (stat.mtime.toISOString() <= lastCheck) return;
@@ -524,7 +524,7 @@ function createHeadlessLoop(options) {
     log(
       `PR #${session.request.prNumber} round ${roundNum}: ${round.findingCount} findings, ${round.suggestedDiffLines} suggested diff lines`
     );
-    const stopSignalPath = path4.join(options.stateDir, "stop-signal");
+    const stopSignalPath = path6.join(options.stateDir, "stop-signal");
     const ctx = {
       round: roundNum,
       rounds: session.rounds,
@@ -546,21 +546,21 @@ function createHeadlessLoop(options) {
     const prompt = buildReviewPrompt(session.request, options.agentName, round);
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
     const dispatchFilename = `${date}-headless-${options.agentName}-review-PR${session.request.prNumber}-r${round}.md`;
-    const inboxDir = path4.join(options.commsDir, "inbox");
-    fs5.mkdirSync(inboxDir, { recursive: true });
-    const dispatchFile = path4.join(inboxDir, dispatchFilename);
+    const inboxDir = path6.join(options.commsDir, "inbox");
+    fs7.mkdirSync(inboxDir, { recursive: true });
+    const dispatchFile = path6.join(inboxDir, dispatchFilename);
     const tmp = `${dispatchFile}.tmp.${process.pid}`;
-    fs5.writeFileSync(tmp, prompt, "utf-8");
-    fs5.renameSync(tmp, dispatchFile);
+    fs7.writeFileSync(tmp, prompt, "utf-8");
+    fs7.renameSync(tmp, dispatchFile);
   }
   function completeSession(session) {
     session.terminatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const inboxDir = path4.join(options.commsDir, "inbox");
-    if (fs5.existsSync(inboxDir)) {
+    const inboxDir = path6.join(options.commsDir, "inbox");
+    if (fs7.existsSync(inboxDir)) {
       const prefix = `headless-${options.agentName}-review-PR${session.request.prNumber}`;
-      const files = fs5.readdirSync(inboxDir).filter((f) => f.includes(prefix));
+      const files = fs7.readdirSync(inboxDir).filter((f) => f.includes(prefix));
       for (const f of files) {
-        fs5.unlinkSync(path4.join(inboxDir, f));
+        fs7.unlinkSync(path6.join(inboxDir, f));
       }
     }
     state.activeSession = null;
@@ -604,48 +604,90 @@ var init_headless_loop = __esm({
 });
 
 // src/bridges/codex-bridge-runner.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
-import { spawn } from "child_process";
-import { fileURLToPath } from "url";
+import * as fs8 from "fs";
+import * as path7 from "path";
+import { spawn as spawn2 } from "child_process";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 
 // src/config/resolve.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/utils.ts
 import * as fs from "fs";
 import * as path from "path";
+var _noGitWarned = false;
+function _setNoGitWarned() {
+  _noGitWarned = true;
+}
+
+// src/config/resolve.ts
 var SHARED_CONFIG_FILE = "tap-config.json";
 var LOCAL_CONFIG_FILE = "tap-config.local.json";
+var LEGACY_CONFIG_FILE = ".tap-config";
 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);
+  let dir = path2.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 (fs2.existsSync(path2.join(dir, ".git"))) return dir;
+    if (fs2.existsSync(path2.join(dir, "package.json"))) {
+      if (!_noGitWarned) {
+        _setNoGitWarned();
+        console.error(
+          "[tap] warning: No .git directory found. Resolved via package.json. Use --comms-dir to specify explicitly."
+        );
+      }
+      return dir;
+    }
+    const parent = path2.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
+  if (!_noGitWarned) {
+    _setNoGitWarned();
+    console.error(
+      "[tap] warning: No git repository found. Using cwd as root. Run 'git init' or use --comms-dir."
+    );
+  }
   return process.cwd();
 }
 function loadJsonFile(filePath) {
-  if (!fs.existsSync(filePath)) return null;
+  if (!fs2.existsSync(filePath)) return null;
   try {
-    const raw = fs.readFileSync(filePath, "utf-8");
+    const raw = fs2.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function loadSharedConfig(repoRoot) {
-  return loadJsonFile(path.join(repoRoot, SHARED_CONFIG_FILE));
+  return loadJsonFile(path2.join(repoRoot, SHARED_CONFIG_FILE));
 }
 function loadLocalConfig(repoRoot) {
-  return loadJsonFile(path.join(repoRoot, LOCAL_CONFIG_FILE));
+  return loadJsonFile(path2.join(repoRoot, LOCAL_CONFIG_FILE));
+}
+function readLegacyShellValue(configText, key) {
+  const match = configText.match(new RegExp(`^${key}="?(.+?)"?$`, "m"));
+  return match?.[1]?.trim() || null;
+}
+function loadLegacyShellConfig(repoRoot) {
+  const filePath = path2.join(repoRoot, LEGACY_CONFIG_FILE);
+  if (!fs2.existsSync(filePath)) return null;
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const commsDir = readLegacyShellValue(raw, "TAP_COMMS_DIR");
+    if (!commsDir) return null;
+    return { commsDir };
+  } catch {
+    return null;
+  }
 }
 function resolveConfig(overrides = {}, startDir) {
   const repoRoot = findRepoRoot(startDir);
   const shared = loadSharedConfig(repoRoot) ?? {};
   const local = loadLocalConfig(repoRoot) ?? {};
+  const legacy = loadLegacyShellConfig(repoRoot) ?? {};
   const sources = {
     repoRoot: "auto",
     commsDir: "auto",
@@ -655,10 +697,10 @@ function resolveConfig(overrides = {}, startDir) {
   };
   let commsDir;
   if (overrides.commsDir) {
-    commsDir = path.resolve(overrides.commsDir);
+    commsDir = resolvePath(repoRoot, overrides.commsDir);
     sources.commsDir = "cli-flag";
   } else if (process.env.TAP_COMMS_DIR) {
-    commsDir = path.resolve(process.env.TAP_COMMS_DIR);
+    commsDir = resolvePath(repoRoot, process.env.TAP_COMMS_DIR);
     sources.commsDir = "env";
   } else if (local.commsDir) {
     commsDir = resolvePath(repoRoot, local.commsDir);
@@ -666,15 +708,18 @@ function resolveConfig(overrides = {}, startDir) {
   } else if (shared.commsDir) {
     commsDir = resolvePath(repoRoot, shared.commsDir);
     sources.commsDir = "shared-config";
+  } else if (legacy.commsDir) {
+    commsDir = resolvePath(repoRoot, legacy.commsDir);
+    sources.commsDir = "legacy-shell-config";
   } else {
-    commsDir = path.join(path.dirname(repoRoot), "tap-comms");
+    commsDir = path2.join(repoRoot, "tap-comms");
   }
   let stateDir;
   if (overrides.stateDir) {
-    stateDir = path.resolve(overrides.stateDir);
+    stateDir = resolvePath(repoRoot, overrides.stateDir);
     sources.stateDir = "cli-flag";
   } else if (process.env.TAP_STATE_DIR) {
-    stateDir = path.resolve(process.env.TAP_STATE_DIR);
+    stateDir = resolvePath(repoRoot, process.env.TAP_STATE_DIR);
     sources.stateDir = "env";
   } else if (local.stateDir) {
     stateDir = resolvePath(repoRoot, local.stateDir);
@@ -683,7 +728,7 @@ function resolveConfig(overrides = {}, startDir) {
     stateDir = resolvePath(repoRoot, shared.stateDir);
     sources.stateDir = "shared-config";
   } else {
-    stateDir = path.join(repoRoot, ".tap-comms");
+    stateDir = path2.join(repoRoot, ".tap-comms");
   }
   let runtimeCommand;
   if (overrides.runtimeCommand) {
@@ -723,18 +768,40 @@ function resolveConfig(overrides = {}, startDir) {
   };
 }
 function resolvePath(repoRoot, p) {
-  return path.isAbsolute(p) ? p : path.resolve(repoRoot, p);
+  const normalized = normalizeTapPath(p);
+  return path2.isAbsolute(normalized) ? normalized : path2.resolve(repoRoot, normalized);
+}
+function normalizeTapPath(input) {
+  const trimmed = input.trim().replace(/^["'`]+|["'`]+$/g, "");
+  if (/^[A-Za-z]:[\\/]/.test(trimmed)) {
+    return trimmed;
+  }
+  if (process.platform === "win32") {
+    const match = trimmed.match(/^\/([A-Za-z])\/(.*)$/);
+    if (match) {
+      return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+    }
+  }
+  return trimmed;
 }
 
+// src/engine/bridge.ts
+import * as fs4 from "fs";
+import * as net from "net";
+import * as path4 from "path";
+import { randomBytes } from "crypto";
+import { spawn, spawnSync, execSync as execSync2 } from "child_process";
+import { fileURLToPath } from "url";
+
 // src/runtime/resolve-node.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import { execSync } from "child_process";
 function readNodeVersion(repoRoot) {
-  const nvFile = path2.join(repoRoot, ".node-version");
-  if (!fs2.existsSync(nvFile)) return null;
+  const nvFile = path3.join(repoRoot, ".node-version");
+  if (!fs3.existsSync(nvFile)) return null;
   try {
-    const raw = fs2.readFileSync(nvFile, "utf-8").trim();
+    const raw = fs3.readFileSync(nvFile, "utf-8").trim();
     return raw.length > 0 ? raw.replace(/^v/, "") : null;
   } catch {
     return null;
@@ -744,16 +811,16 @@ function fnmCandidateDirs() {
   if (process.platform === "win32") {
     return [
       process.env.FNM_DIR,
-      process.env.APPDATA ? path2.join(process.env.APPDATA, "fnm") : null,
-      process.env.LOCALAPPDATA ? path2.join(process.env.LOCALAPPDATA, "fnm") : null,
-      process.env.USERPROFILE ? path2.join(process.env.USERPROFILE, "scoop", "persist", "fnm") : null
+      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 ? path2.join(process.env.HOME, ".local", "share", "fnm") : null,
-    process.env.HOME ? path2.join(process.env.HOME, ".fnm") : null,
-    process.env.XDG_DATA_HOME ? path2.join(process.env.XDG_DATA_HOME, "fnm") : null
+    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() {
@@ -763,14 +830,14 @@ function probeFnmNode(desiredVersion) {
   const dirs = fnmCandidateDirs();
   const exe = nodeExecutableName();
   for (const baseDir of dirs) {
-    const candidate = path2.join(
+    const candidate = path3.join(
       baseDir,
       "node-versions",
       `v${desiredVersion}`,
       "installation",
       exe
     );
-    if (!fs2.existsSync(candidate)) continue;
+    if (!fs3.existsSync(candidate)) continue;
     try {
       const v = execSync(`"${candidate}" --version`, {
         encoding: "utf-8",
@@ -811,12 +878,12 @@ function checkStripTypesSupport(command) {
 }
 function findTsxFallback(repoRoot) {
   const candidates = [
-    path2.join(repoRoot, "node_modules", ".bin", "tsx.exe"),
-    path2.join(repoRoot, "node_modules", ".bin", "tsx.CMD"),
-    path2.join(repoRoot, "node_modules", ".bin", "tsx")
+    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 (fs2.existsSync(c)) return c;
+    if (fs3.existsSync(c)) return c;
   }
   return null;
 }
@@ -825,7 +892,7 @@ function getFnmBinDir(repoRoot) {
   if (!desiredVersion) return null;
   const nodePath = probeFnmNode(desiredVersion);
   if (!nodePath) return null;
-  return path2.dirname(nodePath);
+  return path3.dirname(nodePath);
 }
 function resolveNodeRuntime(configCommand, repoRoot) {
   if (configCommand === "bun" || configCommand.endsWith("bun.exe")) {
@@ -881,19 +948,35 @@ function buildRuntimeEnv(repoRoot, baseEnv = process.env) {
   const currentPath = baseEnv[pathKey] ?? baseEnv.PATH ?? "";
   return {
     ...baseEnv,
-    [pathKey]: `${fnmBin}${path2.delimiter}${currentPath}`
+    [pathKey]: `${fnmBin}${path3.delimiter}${currentPath}`
   };
 }
 
+// src/engine/bridge.ts
+var DEFAULT_APP_SERVER_URL2 = "ws://127.0.0.1:4501";
+function resolveAppServerUrl(baseUrl, port) {
+  const resolvedBase = (baseUrl ?? DEFAULT_APP_SERVER_URL2).replace(/\/$/, "");
+  if (port == null) {
+    return resolvedBase;
+  }
+  try {
+    const parsed = new URL(resolvedBase);
+    parsed.port = String(port);
+    return parsed.toString().replace(/\/$/, "");
+  } catch {
+    return resolvedBase;
+  }
+}
+
 // src/bridges/codex-bridge-runner.ts
 function findRepoRootFromRunner() {
-  let dir = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)));
+  let dir = path7.resolve(path7.dirname(fileURLToPath2(import.meta.url)));
   while (true) {
-    if (fs6.existsSync(path5.join(dir, SHARED_CONFIG_FILE))) return dir;
-    if (fs6.existsSync(path5.join(dir, LOCAL_CONFIG_FILE))) return dir;
-    if (fs6.existsSync(path5.join(dir, "scripts", "codex-app-server-bridge.ts")))
+    if (fs8.existsSync(path7.join(dir, SHARED_CONFIG_FILE))) return dir;
+    if (fs8.existsSync(path7.join(dir, LOCAL_CONFIG_FILE))) return dir;
+    if (fs8.existsSync(path7.join(dir, "scripts", "codex-app-server-bridge.ts")))
       return dir;
-    const parent = path5.dirname(dir);
+    const parent = path7.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -903,7 +986,7 @@ function maybeStartHeadlessLoop(repoRoot, commsDir, stateDir) {
   Promise.resolve().then(() => (init_headless_loop(), headless_loop_exports)).then(({ createHeadlessLoop: createHeadlessLoop2 }) => {
     const agentName = process.env.TAP_AGENT_NAME ?? process.env.CODEX_TAP_AGENT_NAME ?? "reviewer";
     const generation = process.env.TAP_REVIEW_GENERATION ?? "gen11";
-    const resolvedStateDir = stateDir ?? path5.join(repoRoot, ".tap-comms");
+    const resolvedStateDir = stateDir ?? path7.join(repoRoot, ".tap-comms");
     const loop = createHeadlessLoop2({
       commsDir,
       stateDir: resolvedStateDir,
@@ -920,23 +1003,75 @@ function maybeStartHeadlessLoop(repoRoot, commsDir, stateDir) {
     console.error("[headless-loop] Failed to start:", err);
   });
 }
+function resolveBridgeDaemonScript(repoRoot, runnerUrl = import.meta.url, fileExists = fs8.existsSync) {
+  const moduleDir = path7.dirname(fileURLToPath2(runnerUrl));
+  const candidates = [
+    // 1. Bundled standalone/npm install
+    path7.join(moduleDir, "codex-app-server-bridge.mjs"),
+    // 2. Source run from monorepo package
+    path7.join(moduleDir, "codex-app-server-bridge.ts"),
+    // 3. Built monorepo package dist
+    path7.join(
+      repoRoot,
+      "packages",
+      "tap-comms",
+      "dist",
+      "bridges",
+      "codex-app-server-bridge.mjs"
+    ),
+    // 4. Monorepo source wrapper
+    path7.join(
+      repoRoot,
+      "packages",
+      "tap-comms",
+      "src",
+      "bridges",
+      "codex-app-server-bridge.ts"
+    ),
+    // 5. Legacy monorepo root script
+    path7.join(repoRoot, "scripts", "codex-app-server-bridge.ts")
+  ];
+  for (const candidate of candidates) {
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function buildBridgeScriptArgs(scriptPath, options) {
+  const args = [
+    scriptPath,
+    `--repo-root=${options.repoRoot}`,
+    `--comms-dir=${options.commsDir}`,
+    `--app-server-url=${options.appServerUrl}`
+  ];
+  if (options.agentName) {
+    args.push(`--agent-name=${options.agentName}`);
+  }
+  if (options.gatewayTokenFile) {
+    args.push(`--gateway-token-file=${options.gatewayTokenFile}`);
+  }
+  if (options.stateDir) {
+    args.push(`--state-dir=${options.stateDir}`);
+  }
+  return args;
+}
 async function main() {
   const repoRootHint = findRepoRootFromRunner() ?? void 0;
   const { config } = resolveConfig({}, repoRootHint);
   const repoRoot = config.repoRoot;
   const commsDir = config.commsDir;
-  let appServerUrl = config.appServerUrl;
-  const instancePort = process.env.TAP_BRIDGE_PORT;
-  if (instancePort) {
-    try {
-      const url = new URL(appServerUrl);
-      url.port = instancePort;
-      appServerUrl = url.toString().replace(/\/$/, "");
-    } catch {
-    }
-  }
+  const instancePortRaw = process.env.TAP_BRIDGE_PORT;
+  const instancePort = instancePortRaw ? Number.parseInt(instancePortRaw, 10) : void 0;
+  const envAppServerUrl = process.env.CODEX_APP_SERVER_URL?.trim();
+  const gatewayTokenFile = process.env.TAP_GATEWAY_TOKEN_FILE?.trim();
+  const appServerUrl = envAppServerUrl || resolveAppServerUrl(
+    config.appServerUrl,
+    Number.isFinite(instancePort) ? instancePort : void 0
+  );
   const instanceId = process.env.TAP_BRIDGE_INSTANCE_ID;
-  const stateDir = instanceId ? path5.join(repoRoot, ".tmp", `codex-app-server-bridge-${instanceId}`) : void 0;
+  const envStateDir = process.env.TAP_STATE_DIR;
+  const stateDir = envStateDir ? envStateDir : instanceId ? path7.join(repoRoot, ".tmp", `codex-app-server-bridge-${instanceId}`) : void 0;
   const preResolved = process.env.TAP_RESOLVED_NODE;
   const resolved = preResolved ? {
     command: preResolved,
@@ -945,15 +1080,12 @@ async function main() {
     majorVersion: null
   } : resolveNodeRuntime(config.runtimeCommand, repoRoot);
   const command = resolved.command;
-  const scriptPath = path5.join(
-    repoRoot,
-    "scripts",
-    "codex-app-server-bridge.ts"
-  );
-  if (!fs6.existsSync(scriptPath)) {
+  const agentName = process.env.TAP_AGENT_NAME?.trim() || process.env.CODEX_TAP_AGENT_NAME?.trim() || void 0;
+  const scriptPath = resolveBridgeDaemonScript(repoRoot);
+  if (!scriptPath) {
     throw new Error(
-      `Bridge script not found: ${scriptPath}
-Ensure scripts/codex-app-server-bridge.ts exists in repo root.`
+      `Bridge script not found for repo root ${repoRoot}.
+Expected a packaged dist/bridges/codex-app-server-bridge.mjs or monorepo bridge script.`
     );
   }
   const args = [];
@@ -961,14 +1093,15 @@ Ensure scripts/codex-app-server-bridge.ts exists in repo root.`
     args.push("--experimental-strip-types");
   }
   args.push(
-    scriptPath,
-    `--repo-root=${repoRoot}`,
-    `--comms-dir=${commsDir}`,
-    `--app-server-url=${appServerUrl}`
+    ...buildBridgeScriptArgs(scriptPath, {
+      repoRoot,
+      commsDir,
+      appServerUrl,
+      gatewayTokenFile,
+      stateDir,
+      agentName
+    })
   );
-  if (stateDir) {
-    args.push(`--state-dir=${stateDir}`);
-  }
   const busyMode = process.env.TAP_BUSY_MODE;
   if (busyMode) args.push(`--busy-mode=${busyMode}`);
   const pollSeconds = process.env.TAP_POLL_SECONDS;
@@ -984,7 +1117,7 @@ Ensure scripts/codex-app-server-bridge.ts exists in repo root.`
   if (process.env.TAP_PROCESS_EXISTING === "true")
     args.push("--process-existing-messages");
   const runtimeEnv = buildRuntimeEnv(repoRoot);
-  const child = spawn(command, args, {
+  const child = spawn2(command, args, {
     cwd: repoRoot,
     env: runtimeEnv,
     stdio: "inherit"
@@ -1002,8 +1135,19 @@ Ensure scripts/codex-app-server-bridge.ts exists in repo root.`
     process.exit(1);
   });
 }
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
+function isDirectExecution() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return import.meta.url === pathToFileURL(path7.resolve(entry)).href;
+}
+if (isDirectExecution()) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  buildBridgeScriptArgs,
+  resolveBridgeDaemonScript
+};
 //# sourceMappingURL=codex-bridge-runner.mjs.map