@get-bb/plugin-sdk 0.6.16 → 0.6.23

package/dist/provider-bridge-testing.js

@@ -178,11 +178,15 @@ var promptInputSchema = z3.discriminatedUnion("type", [
   z3.object({
     type: z3.literal("localImage"),
     path: z3.string(),
+    sourceProjectId: z3.string().min(1).optional(),
+    hostId: z3.string().min(1).optional(),
     ...promptInputVisibilityFields
   }),
   z3.object({
     type: z3.literal("localFile"),
     path: z3.string(),
+    sourceProjectId: z3.string().min(1).optional(),
+    hostId: z3.string().min(1).optional(),
     name: z3.string().optional(),
     sizeBytes: z3.number().int().nonnegative().optional(),
     mimeType: z3.string().optional(),
@@ -6536,6 +6540,26 @@ var PARITY_INITIALIZE_ID = "parity-initialize";
 function sleep(ms) {
   return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
 }
+var REPLAY_STARTUP_CONCURRENCY = 4;
+var replayStartupQueue = [];
+var startingReplays = 0;
+async function acquireReplayStartup() {
+  if (startingReplays < REPLAY_STARTUP_CONCURRENCY) {
+    startingReplays += 1;
+  } else {
+    await new Promise(
+      (resolveSlot) => replayStartupQueue.push(resolveSlot)
+    );
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const next = replayStartupQueue.shift();
+    if (next === void 0) startingReplays -= 1;
+    else next();
+  };
+}
 async function replayRecording(options) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const orderTimeoutMs = options.orderTimeoutMs ?? 5e3;
@@ -6578,275 +6602,313 @@ async function replayRecording(options) {
   );
   profile.prepareState?.({ recording, stateDir, workspaceDir });
   const launch = options.bridge;
-  const child = spawn(launch.command, launch.args, {
-    cwd: launch.cwd,
-    env: {
-      ...process.env,
-      ...launch.env,
-      ...profile.env({ replayCommand, wrapperPath, stateDir })
-    },
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  const recordedCwd = recordedWorkspaceDir(recording);
-  const jsonText = (value) => JSON.stringify(value).slice(1, -1);
-  const restoreRecordedWorkspace = (line) => recordedCwd === null || recordedCwd === workspaceDir ? line : line.split(jsonText(workspaceDir)).join(jsonText(recordedCwd));
-  const initializeId = PARITY_INITIALIZE_ID;
-  const startedAt = Date.now();
-  const lines = [];
-  const lineTimes = [];
-  const lineAfter = [];
-  let lastSentRuntimeEntry = null;
-  const events = [];
-  const grammarViolations = [];
-  const stalls = [];
-  let stderr = "";
-  const grammar = new ThreadEventGrammar();
-  const liveAssembler = options.createAssembler(providerId);
-  const planAssembler = (options.createPlanAssembler ?? options.createAssembler)(providerId);
-  const exactPlan = options.planFromCurrentLane === true;
-  const planRecording = exactPlan ? withCurrentBridgeLane(recording) : recording;
-  const steps = planRuntimeSteps(planRecording, planAssembler);
-  const plannedEventCount = exactPlan ? assembleRecordedEvents(
-    planRecording,
-    options.createPlanAssembler ?? options.createAssembler,
-    providerId
-  ).events.length : null;
-  const answeredIds = /* @__PURE__ */ new Set();
-  const pendingBridgeRequests = [];
-  const recordedAnswers = /* @__PURE__ */ new Map();
-  for (const step of steps) {
-    if (step.message !== null && isResponse(step.message)) {
-      const method = methodOfRecordedBridgeRequest(
-        recording,
-        step.entry,
-        step.message.id
-      ) ?? "?";
-      const queue = recordedAnswers.get(method) ?? [];
-      queue.push(step.message);
-      recordedAnswers.set(method, queue);
-    }
-  }
-  let lastOutputAt = Date.now();
-  const exited = new Promise((resolveExit) => {
-    child.on("exit", (code) => resolveExit(code));
-  });
-  child.stderr?.setEncoding("utf8").on("data", (chunk) => {
-    stderr += chunk;
-    options.onStderr?.(chunk);
-  });
-  function write(line) {
-    if (child.stdin?.writable) {
-      child.stdin.write(`${line}
+  const releaseStartup = await acquireReplayStartup();
+  let spawnedChild;
+  let childEnded;
+  try {
+    let write2 = function(line) {
+      if (child.stdin?.writable) {
+        child.stdin.write(`${line}
 `);
-    }
-  }
-  function answerBridgeRequest(message) {
-    const method = message.method ?? "?";
-    const queue = recordedAnswers.get(method);
-    const recorded = queue?.shift();
-    if (recorded === void 0) {
-      stalls.push(
-        `no recorded answer for bridge request ${method} (${String(message.id)})`
-      );
-      write(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          id: message.id,
-          error: { code: -32e3, message: "parity replay: no recorded answer" }
-        })
-      );
-      return;
-    }
-    write(JSON.stringify({ ...recorded, id: message.id }));
-  }
-  readBoundedLines({
-    input: child.stdout,
-    onLine: (rawLine) => {
-      const line = restoreRecordedWorkspace(rawLine);
-      lastOutputAt = Date.now();
-      lines.push(line);
-      lineTimes.push(lastOutputAt - startedAt);
-      lineAfter.push(lastSentRuntimeEntry);
-      const message = parseWire(line);
-      if (message === null) return;
-      if (isResponse(message)) {
-        answeredIds.add(String(message.id));
-        return;
       }
-      if (isRequest(message)) {
-        pendingBridgeRequests.push({
-          id: message.id,
-          method: message.method
-        });
-        answerBridgeRequest(message);
+    }, answerBridgeRequest2 = function(message) {
+      const method = message.method ?? "?";
+      const queue = recordedAnswers.get(method);
+      const recorded = queue?.shift();
+      if (recorded === void 0) {
+        stalls.push(
+          `no recorded answer for bridge request ${method} (${String(message.id)})`
+        );
+        write2(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: message.id,
+            error: {
+              code: -32e3,
+              message: "parity replay: no recorded answer"
+            }
+          })
+        );
         return;
       }
-      if (message.method === THREAD_DELTA_NOTIFICATION_METHOD) {
-        let assembled;
-        try {
-          assembled = liveAssembler.assembleMessage(message);
-        } catch (error) {
-          stalls.push(
-            `invalid thread/delta: ${error instanceof Error ? error.message : String(error)}`
-          );
+      write2(JSON.stringify({ ...recorded, id: message.id }));
+    };
+    var write = write2, answerBridgeRequest = answerBridgeRequest2;
+    const child = spawn(launch.command, launch.args, {
+      cwd: launch.cwd,
+      env: {
+        ...process.env,
+        ...launch.env,
+        ...profile.env({ replayCommand, wrapperPath, stateDir })
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    spawnedChild = child;
+    childEnded = new Promise((resolveEnded) => {
+      const onEnded = () => {
+        releaseStartup();
+        resolveEnded();
+      };
+      child.once("exit", onEnded);
+      child.once("error", onEnded);
+    });
+    const recordedCwd = recordedWorkspaceDir(recording);
+    const jsonText = (value) => JSON.stringify(value).slice(1, -1);
+    const restoreRecordedWorkspace = (line) => recordedCwd === null || recordedCwd === workspaceDir ? line : line.split(jsonText(workspaceDir)).join(jsonText(recordedCwd));
+    const initializeId = PARITY_INITIALIZE_ID;
+    const startedAt = Date.now();
+    const lines = [];
+    const lineTimes = [];
+    const lineAfter = [];
+    let lastSentRuntimeEntry = null;
+    const events = [];
+    const grammarViolations = [];
+    const stalls = [];
+    let stderr = "";
+    const grammar = new ThreadEventGrammar();
+    const liveAssembler = options.createAssembler(providerId);
+    const planAssembler = (options.createPlanAssembler ?? options.createAssembler)(providerId);
+    const exactPlan = options.planFromCurrentLane === true;
+    const planRecording = exactPlan ? withCurrentBridgeLane(recording) : recording;
+    const steps = planRuntimeSteps(planRecording, planAssembler);
+    const plannedEventCount = exactPlan ? assembleRecordedEvents(
+      planRecording,
+      options.createPlanAssembler ?? options.createAssembler,
+      providerId
+    ).events.length : null;
+    const answeredIds = /* @__PURE__ */ new Set();
+    const pendingBridgeRequests = [];
+    const recordedAnswers = /* @__PURE__ */ new Map();
+    for (const step of steps) {
+      if (step.message !== null && isResponse(step.message)) {
+        const method = methodOfRecordedBridgeRequest(
+          recording,
+          step.entry,
+          step.message.id
+        ) ?? "?";
+        const queue = recordedAnswers.get(method) ?? [];
+        queue.push(step.message);
+        recordedAnswers.set(method, queue);
+      }
+    }
+    let lastOutputAt = Date.now();
+    const exited = new Promise((resolveExit) => {
+      child.on("exit", (code) => resolveExit(code));
+      child.on("error", (error) => {
+        stalls.push(`bridge spawn failed: ${error.message}`);
+        resolveExit(null);
+      });
+    });
+    child.stderr?.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+      options.onStderr?.(chunk);
+    });
+    readBoundedLines({
+      input: child.stdout,
+      onLine: (rawLine) => {
+        const line = restoreRecordedWorkspace(rawLine);
+        lastOutputAt = Date.now();
+        lines.push(line);
+        lineTimes.push(lastOutputAt - startedAt);
+        lineAfter.push(lastSentRuntimeEntry);
+        const message = parseWire(line);
+        if (message === null) return;
+        if (isResponse(message)) {
+          answeredIds.add(String(message.id));
           return;
         }
-        for (const event of assembled) {
-          const result2 = grammar.observe(event);
-          if (result2.kind === "violation") {
-            grammarViolations.push({
-              rule: result2.rule,
-              reason: result2.reason,
-              eventType: event.type
-            });
-            continue;
+        if (isRequest(message)) {
+          pendingBridgeRequests.push({
+            id: message.id,
+            method: message.method
+          });
+          answerBridgeRequest2(message);
+          return;
+        }
+        if (message.method === THREAD_DELTA_NOTIFICATION_METHOD) {
+          let assembled;
+          try {
+            assembled = liveAssembler.assembleMessage(message);
+          } catch (error) {
+            stalls.push(
+              `invalid thread/delta: ${error instanceof Error ? error.message : String(error)}`
+            );
+            return;
+          }
+          for (const event of assembled) {
+            const result2 = grammar.observe(event);
+            if (result2.kind === "violation") {
+              grammarViolations.push({
+                rule: result2.rule,
+                reason: result2.reason,
+                eventType: event.type
+              });
+              continue;
+            }
+            events.push(event);
           }
-          events.push(event);
         }
+      },
+      onOverflow: (bytes) => {
+        stalls.push(`oversized bridge line (${bytes} bytes)`);
       }
-    },
-    onOverflow: (bytes) => {
-      stalls.push(`oversized bridge line (${bytes} bytes)`);
-    }
-  });
-  async function waitFor(label, predicate, limitMs = timeoutMs, reportStall = true) {
-    const deadline = Date.now() + limitMs;
-    while (!predicate()) {
-      if (child.exitCode !== null) {
-        stalls.push(`bridge exited while waiting for ${label}`);
-        return;
-      }
-      if (Date.now() > deadline) {
-        if (reportStall) stalls.push(`timed out waiting for ${label}`);
-        return;
+    });
+    async function waitFor(label, predicate, limitMs = timeoutMs, reportStall = true) {
+      const deadline = Date.now() + limitMs;
+      while (!predicate()) {
+        if (child.exitCode !== null || child.signalCode !== null || child.pid === void 0) {
+          stalls.push(`bridge exited while waiting for ${label}`);
+          return;
+        }
+        if (Date.now() > deadline) {
+          if (reportStall) stalls.push(`timed out waiting for ${label}`);
+          return;
+        }
+        await sleep(10);
       }
-      await sleep(10);
     }
-  }
-  const firstStep = steps.find(
-    (step) => step.message !== null && isRequest(step.message)
-  );
-  setCursor(
-    firstStep === void 0 ? "end" : { run: firstStep.entry.run, seq: firstStep.entry.seq }
-  );
-  write(
-    JSON.stringify({
-      jsonrpc: "2.0",
-      id: initializeId,
-      method: "initialize",
-      params: {
-        protocolVersion: PROVIDER_BRIDGE_PROTOCOL_VERSION,
-        client: { name: "bb-parity", version: "0" }
+    const firstStep = steps.find(
+      (step) => step.message !== null && isRequest(step.message)
+    );
+    setCursor(
+      firstStep === void 0 ? "end" : { run: firstStep.entry.run, seq: firstStep.entry.seq }
+    );
+    write2(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: initializeId,
+        method: "initialize",
+        params: {
+          protocolVersion: PROVIDER_BRIDGE_PROTOCOL_VERSION,
+          client: { name: "bb-parity", version: "0" }
+        }
+      })
+    );
+    await waitFor("initialize response", () => answeredIds.has(initializeId));
+    const initialized = answeredIds.has(initializeId);
+    if (!initialized) {
+      if (child.pid !== void 0 && child.exitCode === null && child.signalCode === null)
+        child.kill("SIGKILL");
+      await childEnded;
+    }
+    releaseStartup();
+    const sentRequestIds = [];
+    for (const step of initialized ? steps : []) {
+      if (step.message === null || !isRequest(step.message)) {
+        if (step.message !== null && !isResponse(step.message)) {
+          lastSentRuntimeEntry = {
+            run: step.entry.run,
+            seq: step.entry.seq,
+            ts: step.entry.ts
+          };
+          write2(step.entry.line);
+        }
+        continue;
       }
-    })
-  );
-  await waitFor("initialize response", () => answeredIds.has(initializeId));
-  const sentRequestIds = [];
-  for (const step of steps) {
-    if (step.message === null || !isRequest(step.message)) {
-      if (step.message !== null && !isResponse(step.message)) {
-        lastSentRuntimeEntry = {
-          run: step.entry.run,
-          seq: step.entry.seq,
-          ts: step.entry.ts
-        };
-        write(step.entry.line);
+      const request = step.message;
+      const method = request.method;
+      await waitFor(
+        `earlier requests before ${method}`,
+        () => sentRequestIds.every((id) => answeredIds.has(id))
+      );
+      await waitFor(
+        `${step.gate.started} turn/started and ${step.gate.completed} turn/completed before ${method}`,
+        () => {
+          const live = countTurns(events);
+          return live.started >= step.gate.started && live.completed >= step.gate.completed;
+        }
+      );
+      await waitFor(
+        `${step.eventsBefore} events before ${method}`,
+        () => events.length >= step.eventsBefore || !exactPlan && Date.now() - lastOutputAt >= orderTimeoutMs,
+        timeoutMs,
+        exactPlan
+      );
+      await waitFor(
+        `the stream to drain before ${method}`,
+        () => Date.now() - lastOutputAt >= drainMs,
+        timeoutMs,
+        false
+      );
+      if (child.exitCode !== null) break;
+      if (method === "thread/stop" && typeof request.params === "object" && request.params !== null && request.params.intent === "release") {
+        const threadId = request.params.threadId;
+        if (typeof threadId === "string") grammar.clearThread(threadId);
       }
-      continue;
+      const rewritten = rewriteRecordedMachineFacts(
+        step.entry.line,
+        workspaceDir
+      );
+      const line = profile.rewriteRuntimeLine === void 0 ? rewritten : profile.rewriteRuntimeLine(rewritten, { replayCommand });
+      lastSentRuntimeEntry = {
+        run: step.entry.run,
+        seq: step.entry.seq,
+        ts: step.entry.ts
+      };
+      write2(line);
+      sentRequestIds.push(String(request.id));
+      const nextStep = steps.slice(steps.indexOf(step) + 1).find(
+        (candidate) => candidate.message !== null && isRequest(candidate.message)
+      );
+      setCursor(
+        nextStep === void 0 ? "end" : { run: nextStep.entry.run, seq: nextStep.entry.seq }
+      );
     }
-    const request = step.message;
-    const method = request.method;
+    setCursor("end");
     await waitFor(
-      `earlier requests before ${method}`,
+      "the last responses",
       () => sentRequestIds.every((id) => answeredIds.has(id))
     );
-    await waitFor(
-      `${step.gate.started} turn/started and ${step.gate.completed} turn/completed before ${method}`,
-      () => {
-        const live = countTurns(events);
-        return live.started >= step.gate.started && live.completed >= step.gate.completed;
-      }
-    );
-    await waitFor(
-      `${step.eventsBefore} events before ${method}`,
-      () => events.length >= step.eventsBefore || !exactPlan && Date.now() - lastOutputAt >= orderTimeoutMs,
-      timeoutMs,
-      exactPlan
-    );
-    await waitFor(
-      `the stream to drain before ${method}`,
-      () => Date.now() - lastOutputAt >= drainMs,
-      timeoutMs,
-      false
-    );
-    if (child.exitCode !== null) break;
-    if (method === "thread/stop" && typeof request.params === "object" && request.params !== null && request.params.intent === "release") {
-      const threadId = request.params.threadId;
-      if (typeof threadId === "string") grammar.clearThread(threadId);
+    if (plannedEventCount !== null) {
+      await waitFor(
+        `all ${plannedEventCount} planned events before closing the bridge`,
+        () => events.length >= plannedEventCount
+      );
     }
-    const rewritten = rewriteRecordedMachineFacts(
-      step.entry.line,
-      workspaceDir
-    );
-    const line = profile.rewriteRuntimeLine === void 0 ? rewritten : profile.rewriteRuntimeLine(rewritten, { replayCommand });
-    lastSentRuntimeEntry = {
-      run: step.entry.run,
-      seq: step.entry.seq,
-      ts: step.entry.ts
-    };
-    write(line);
-    sentRequestIds.push(String(request.id));
-    const nextStep = steps.slice(steps.indexOf(step) + 1).find(
-      (candidate) => candidate.message !== null && isRequest(candidate.message)
-    );
-    setCursor(
-      nextStep === void 0 ? "end" : { run: nextStep.entry.run, seq: nextStep.entry.seq }
-    );
-  }
-  setCursor("end");
-  await waitFor(
-    "the last responses",
-    () => sentRequestIds.every((id) => answeredIds.has(id))
-  );
-  if (plannedEventCount !== null) {
     await waitFor(
-      `all ${plannedEventCount} planned events before closing the bridge`,
-      () => events.length >= plannedEventCount
+      "the stream to settle",
+      () => Date.now() - lastOutputAt >= settleMs
     );
+    child.stdin?.end();
+    let shutdownTimer;
+    const exitCode = await Promise.race([
+      exited,
+      new Promise((resolveTimeout) => {
+        shutdownTimer = setTimeout(() => {
+          stalls.push("bridge did not exit after stdin closed; killed");
+          child.kill("SIGKILL");
+          resolveTimeout(null);
+        }, timeoutMs);
+      })
+    ]);
+    clearTimeout(shutdownTimer);
+    return {
+      providerId,
+      recordingDir: options.recordingDir,
+      lines,
+      lineTimes,
+      lineAfter,
+      events,
+      grammarViolations,
+      stalls,
+      stderr,
+      exitCode
+    };
+  } finally {
+    if (spawnedChild !== void 0 && spawnedChild.pid !== void 0 && spawnedChild.exitCode === null && spawnedChild.signalCode === null) {
+      spawnedChild.kill("SIGKILL");
+      await childEnded;
+    }
+    releaseStartup();
+    for (const directory of [stateDir, workspaceDir]) {
+      await rm(directory, {
+        force: true,
+        maxRetries: REPLAY_CLEANUP_RETRIES,
+        recursive: true,
+        retryDelay: REPLAY_CLEANUP_RETRY_DELAY_MS
+      });
+    }
   }
-  await waitFor(
-    "the stream to settle",
-    () => Date.now() - lastOutputAt >= settleMs
-  );
-  child.stdin?.end();
-  const exitCode = await Promise.race([
-    exited,
-    sleep(timeoutMs).then(() => {
-      stalls.push("bridge did not exit after stdin closed; killed");
-      child.kill("SIGKILL");
-      return null;
-    })
-  ]);
-  for (const directory of [stateDir, workspaceDir]) {
-    await rm(directory, {
-      force: true,
-      maxRetries: REPLAY_CLEANUP_RETRIES,
-      recursive: true,
-      retryDelay: REPLAY_CLEANUP_RETRY_DELAY_MS
-    });
-  }
-  return {
-    providerId,
-    recordingDir: options.recordingDir,
-    lines,
-    lineTimes,
-    lineAfter,
-    events,
-    grammarViolations,
-    stalls,
-    stderr,
-    exitCode
-  };
 }
 function assembleRecordedEvents(recording, createAssembler, providerId) {
   const assembler = createAssembler(providerId);

package/dist/provider-bridge-worker-entry.mjs

@@ -563,6 +563,11 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 
+// ../process-utils/src/performance-diagnostics.ts
+import { Session } from "node:inspector/promises";
+var PROFILE_RETENTION_MS = 12 * 60 * 60 * 1e3;
+var MAX_PROFILE_BYTES = 12 * 1024 * 1024;
+
 // ../provider-bridge-protocol/src/bridge-kit/bounded-line-reader.ts
 import { StringDecoder } from "node:string_decoder";
 var MAX_JSON_RPC_LINE_BYTES = 64 * 1024 * 1024;

package/dist/provider-bridge.js

@@ -1236,11 +1236,15 @@ var promptInputSchema = z5.discriminatedUnion("type", [
   z5.object({
     type: z5.literal("localImage"),
     path: z5.string(),
+    sourceProjectId: z5.string().min(1).optional(),
+    hostId: z5.string().min(1).optional(),
     ...promptInputVisibilityFields
   }),
   z5.object({
     type: z5.literal("localFile"),
     path: z5.string(),
+    sourceProjectId: z5.string().min(1).optional(),
+    hostId: z5.string().min(1).optional(),
     name: z5.string().optional(),
     sizeBytes: z5.number().int().nonnegative().optional(),
     mimeType: z5.string().optional(),
@@ -11066,6 +11070,11 @@ import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync = promisify3(execFile2);
 
+// ../process-utils/src/performance-diagnostics.ts
+import { Session } from "node:inspector/promises";
+var PROFILE_RETENTION_MS = 12 * 60 * 60 * 1e3;
+var MAX_PROFILE_BYTES = 12 * 1024 * 1024;
+
 // ../provider-bridge-protocol/src/bridge-kit/provider-maintenance-kit.ts
 var import_compare = __toESM(require_compare(), 1);
 var import_valid = __toESM(require_valid(), 1);