tianshu-harness 3.23.0

package/dist/chain-7MAMFXZ3.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  runBackendChain
+} from "./chunk-EBJTVRQN.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  runBackendChain
+};

package/dist/checkpoint-MND4DUIX.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  addToCheckpointIndex,
+  checkpointFileForSession,
+  createCheckpoint,
+  getRollbackPreview,
+  listCheckpoints,
+  loadCheckpointIndex,
+  makeOwnershipGuard,
+  pruneOrphanCheckpoints,
+  recordAgentTouchedFile,
+  recordBashSideEffects,
+  removeFromCheckpointIndex,
+  rollbackToCheckpoint
+} from "./chunk-HV4YGVMS.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  addToCheckpointIndex,
+  checkpointFileForSession,
+  createCheckpoint,
+  getRollbackPreview,
+  listCheckpoints,
+  loadCheckpointIndex,
+  makeOwnershipGuard,
+  pruneOrphanCheckpoints,
+  recordAgentTouchedFile,
+  recordBashSideEffects,
+  removeFromCheckpointIndex,
+  rollbackToCheckpoint
+};

package/dist/chunk-2E6CK2RC.js

@@ -0,0 +1,392 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  assessImpactedTestCoverage,
+  getEffectiveVerifications
+} from "./chunk-ZO3I3A7O.js";
+import {
+  spawnGitSync
+} from "./chunk-THKDVSEC.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/delivery-gate-v2.ts
+init_esm_shims();
+
+// src/agent/ownership-health.ts
+init_esm_shims();
+function summarizeOwnershipHealth(input) {
+  const owned = new Set(input.ownedFiles);
+  const coOwned = new Set(input.coOwnedFiles);
+  const external = new Set(input.externalFiles);
+  const dirty = new Set(input.dirtyFiles);
+  const untrackedDirtyOwned = input.dirtyFiles.filter((f) => owned.has(f)).sort();
+  const dirtyCoOwned = input.dirtyFiles.filter((f) => coOwned.has(f)).sort();
+  const dirtyExternal = input.dirtyFiles.filter((f) => external.has(f)).sort();
+  const cleanOwned = input.ownedFiles.filter((f) => !dirty.has(f)).sort();
+  const warningLines = [];
+  const infoLines = [];
+  for (const f of input.dirtyFiles) {
+    if (!owned.has(f) && !coOwned.has(f) && !external.has(f)) {
+      warningLines.push(`Dirty file has no ownership classification: ${f}`);
+    }
+  }
+  if (dirtyCoOwned.length > 0) {
+    infoLines.push(`${dirtyCoOwned.length} co-owned file(s) present. These files are shared with other sessions and require extra caution when committing.`);
+  }
+  if (untrackedDirtyOwned.length === 0 && dirtyExternal.length > 0 && warningLines.length === 0 && dirtyCoOwned.length === 0) {
+    infoLines.push("No current owned dirty files. External dirty files are present and excluded from delivery scope.");
+  }
+  return { untrackedDirtyOwned, dirtyCoOwned, dirtyExternal, cleanOwned, warningLines, infoLines };
+}
+
+// src/agent/delivery-gate-v2.ts
+var JUNK_PATH_PREFIXES = [
+  ".test-tmp/",
+  ".rivet/",
+  "node_modules/",
+  ".git/",
+  "dist/",
+  "build/",
+  "coverage/",
+  "tmp/"
+];
+function isJunkExternalPath(file) {
+  return JUNK_PATH_PREFIXES.some((prefix) => file.startsWith(prefix));
+}
+function gitIgnoredSubset(files, cwd) {
+  if (files.length === 0) return /* @__PURE__ */ new Set();
+  try {
+    const r = spawnGitSync(["check-ignore", "--stdin"], {
+      cwd,
+      input: files.join("\n"),
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    if (r.status !== 0 && r.status !== 1) return /* @__PURE__ */ new Set();
+    return new Set(r.stdout.split("\n").filter(Boolean));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function filterExternalNoise(files, cwd) {
+  const prefixKept = files.filter((f) => !isJunkExternalPath(f));
+  const ignored = cwd ? gitIgnoredSubset(prefixKept, cwd) : /* @__PURE__ */ new Set();
+  const kept = prefixKept.filter((f) => !ignored.has(f));
+  return { files: kept, noiseCount: files.length - kept.length };
+}
+function buildGateConvergenceHint(gate, depthLayer) {
+  const depthSuffix = depthLayer && depthLayer !== "unit" ? `
+[depth=${depthLayer}] \u9A8C\u8BC1\u5FC5\u987B\u8986\u76D6\u8DE8\u6A21\u5757\u8FB9\u754C\uFF0C\u4E0D\u4EC5\u4EC5\u662F\u5355\u51FD\u6570\u884C\u4E3A\u3002` : "";
+  if (gate.state === "GREEN") {
+    return "\u4EA4\u4ED8\u95E8\u7981 GREEN\uFF1A\u6240\u6709 owned \u6587\u4EF6\u5DF2\u9A8C\u8BC1\u3002\u8BF7\u8F93\u51FA\u6700\u7EC8\u6458\u8981\u5E76\u7ED3\u675F\u56DE\u5408\uFF0C\u4E0D\u518D\u8C03\u7528\u5DE5\u5177\u3002" + depthSuffix;
+  }
+  if (gate.state === "RED") {
+    const lines = [`\u4EA4\u4ED8\u95E8\u7981 RED\uFF1A${gate.blockingReason ?? gate.reason ?? "owned \u6587\u4EF6\u5B58\u5728\u672A\u9A8C\u8BC1\u6216\u5931\u8D25\u9879\u3002"}`];
+    lines.push("\u8BF7\u5148\u89E3\u51B3\u963B\u65AD\u9879\u518D\u7EE7\u7EED\uFF1B\u82E5\u65E0\u6CD5\u89E3\u51B3\uFF0C\u660E\u786E\u62A5\u544A\u963B\u65AD\u539F\u56E0\u540E\u7ED3\u675F\u56DE\u5408\u3002");
+    if (gate.shortestNextStep) lines.push(`\u65B9\u5411\uFF1A${gate.shortestNextStep}`);
+    return lines.join("\n") + depthSuffix;
+  }
+  if (gate.attributionClass === "module_unverified") {
+    return `\u4EA4\u4ED8\u95E8\u7981 YELLOW\uFF08\u6CE2\u53CA\u9762\u672A\u9A8C\u8BC1\uFF09\uFF1A${gate.reason ?? "\u6539\u52A8\u6CE2\u53CA\u7684\u6D4B\u8BD5\u4ECE\u672A\u88AB\u4EFB\u4F55 passed \u9A8C\u8BC1\u8986\u76D6\u3002"}
+\u5F15\u5165\u56DE\u5F52\u662F\u6700\u5E38\u89C1\u7684\u4EA4\u4ED8\u5931\u8D25\u2014\u2014\u8BF7\u8FD0\u884C\u4E0A\u8FF0\u53D7\u6CE2\u53CA\u6D4B\u8BD5\uFF08\u6216\u4E00\u6B21 full-scope \u9A8C\u8BC1\uFF09\u540E\u518D\u4EA4\u4ED8\uFF1Bcommit=true \u4F1A\u88AB\u786C\u62E6\u3002` + depthSuffix;
+  }
+  if (gate.attributionClass === "no_test_infra") {
+    return `\u4EA4\u4ED8\u95E8\u7981 YELLOW\uFF08\u6D4B\u8BD5\u57FA\u7840\u8BBE\u65BD\u7F3A\u5931\uFF09\uFF1A${gate.reason ?? "\u9879\u76EE\u65E0\u53EF\u81EA\u52A8\u68C0\u6D4B\u7684\u6D4B\u8BD5\u6846\u67B6\u3002"}
+
+\u4E0D\u8981\u53CD\u590D\u91CD\u8BD5 run_tests\u2014\u2014\u5B83\u6BCF\u6B21\u90FD\u4F1A\u4EE5\u540C\u6837\u539F\u56E0\u53D7\u963B\u3002\u5E94\u5411\u7528\u6237\u62A5\u544A\u5177\u4F53\u7F3A\u5931\u9879\uFF0C\u5E76\u8BE2\u95EE\u662F\u5426\u9700\u8981\u534F\u52A9\u642D\u5EFA\u6D4B\u8BD5\u6846\u67B6\uFF0C\u6216\u7528 bash \u8FD0\u884C\u66FF\u4EE3\u9A8C\u8BC1\u540E\u4EA4\u4ED8\u3002` + depthSuffix;
+  }
+  return `\u4EA4\u4ED8\u95E8\u7981 YELLOW\uFF1A${gate.reason ?? "\u5B58\u5728\u5916\u90E8\u963B\u585E\uFF0Cowned \u6587\u4EF6\u5DF2\u9A8C\u8BC1\u3002"}
+\u53EF\u5E26\u6761\u4EF6\u4EA4\u4ED8\uFF1A\u8F93\u51FA\u6700\u7EC8\u6458\u8981\u5E76\u660E\u786E\u6807\u6CE8 caveat\uFF0C\u7136\u540E\u7ED3\u675F\u56DE\u5408\u3002${depthSuffix}`;
+}
+function createDeliveryGateV2(opts) {
+  const { taskLedger, ownership, attribution } = opts;
+  const emptyDiagnostics = {
+    supersededFailures: 0,
+    staleFailureCandidates: 0,
+    staleSnapshotDropped: 0,
+    toolInvocationFailureCandidates: []
+  };
+  function isToolInvocationFailure(v) {
+    return v.failureKind === "tool_invocation_failure" || v.status === "failed" && v.exitCode !== 0 && v.passed === 0 && v.failed === 0 && v.skipped === 0;
+  }
+  function verificationDiagnostics(verifications, supersededFailures, staleSnapshotDropped) {
+    const invocationFailures = verifications.filter(isToolInvocationFailure);
+    const shortestNextStep = invocationFailures.map((v) => v.recommendedCommand ?? v.resolvedCommand).find((cmd) => typeof cmd === "string" && cmd.length > 0);
+    return {
+      supersededFailures,
+      staleFailureCandidates: supersededFailures,
+      staleSnapshotDropped,
+      toolInvocationFailureCandidates: invocationFailures.map((v) => v.command),
+      ...shortestNextStep ? { shortestNextStep } : {}
+    };
+  }
+  function getGateFiles(currentDirtyFiles) {
+    const allOwnedFiles = ownership.getOwnedFiles();
+    const allCoOwnedFiles = ownership.getCoOwnedFiles();
+    const allExternalFiles = ownership.getExternalFiles(currentDirtyFiles);
+    if (!currentDirtyFiles) {
+      return {
+        ownedFilesForGate: allOwnedFiles,
+        coOwnedFiles: allCoOwnedFiles,
+        historicalOwnedFiles: [],
+        externalFiles: allExternalFiles
+      };
+    }
+    const currentDirty = new Set(currentDirtyFiles);
+    const ownedFilesForGate = allOwnedFiles.filter((f) => currentDirty.has(f)).sort();
+    const coOwnedFiles = allCoOwnedFiles.filter((f) => currentDirty.has(f)).sort();
+    const historicalOwnedFiles = allOwnedFiles.filter((f) => !currentDirty.has(f)).sort();
+    const externalFiles = allExternalFiles.filter((f) => currentDirty.has(f)).sort();
+    return { ownedFilesForGate, coOwnedFiles, historicalOwnedFiles, externalFiles };
+  }
+  function assess(externalVerifications, currentDirtyFiles, currentSnapshotRef, moduleCoverage) {
+    const { ownedFilesForGate: ownedFiles, coOwnedFiles, externalFiles } = getGateFiles(currentDirtyFiles);
+    if (currentDirtyFiles) {
+      const health = summarizeOwnershipHealth({
+        ownedFiles,
+        coOwnedFiles,
+        externalFiles,
+        dirtyFiles: currentDirtyFiles
+      });
+      if (health.warningLines.length > 0) {
+        return {
+          state: "YELLOW",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `${health.warningLines.length} dirty file(s) have no ownership classification. Deliverable with caveat.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: externalVerifications.length,
+          ...emptyDiagnostics
+        };
+      }
+    }
+    const rawVerifications = taskLedger.getVerifications();
+    const { effective: ownedVerifications, supersededFailures, staleSnapshotDropped } = getEffectiveVerifications(rawVerifications, currentSnapshotRef);
+    const allVerifications = [
+      ...ownedVerifications,
+      ...externalVerifications
+    ];
+    const diagnostics = verificationDiagnostics(allVerifications, supersededFailures, staleSnapshotDropped);
+    const _lv = allVerifications.length > 0 ? allVerifications[allVerifications.length - 1] : void 0;
+    const latestVerificationTotals = _lv ? { passed: _lv.passed ?? 0, failed: _lv.failed ?? 0, skipped: _lv.skipped ?? 0, command: _lv.command } : void 0;
+    if (ownedFiles.length === 0) {
+      const hasExternals = externalFiles.length > 0;
+      return {
+        state: "GREEN",
+        canDeliver: true,
+        isBlocked: false,
+        reason: hasExternals ? `No owned files modified. ${externalFiles.length} external dirty file(s) present but excluded from delivery scope.` : "No file modifications.",
+        ownedFileCount: 0,
+        externalFileCount: externalFiles.length,
+        verificationCount: allVerifications.length,
+        ...diagnostics,
+        latestVerificationTotals
+      };
+    }
+    const aggregate = attribution.getAggregateAttribution(allVerifications);
+    switch (aggregate.attribution) {
+      case "verified": {
+        if (moduleCoverage && moduleCoverage.impactedTests.length > 0) {
+          const coverage = assessImpactedTestCoverage(
+            moduleCoverage.impactedTests,
+            allVerifications,
+            moduleCoverage.testExists
+          );
+          if (coverage.uncovered.length > 0) {
+            const sample = coverage.uncovered.slice(0, 5);
+            return {
+              state: "YELLOW",
+              canDeliver: true,
+              isBlocked: false,
+              reason: `${ownedFiles.length} owned file(s) have passed verifications, but ${coverage.uncovered.length} impacted test file(s) (Meridian blast radius) were never covered by any passed run: ${sample.join(", ")}${coverage.uncovered.length > sample.length ? ` (+${coverage.uncovered.length - sample.length} more)` : ""}. Regression risk \u2014 run these tests or a full-scope verification.`,
+              ownedFileCount: ownedFiles.length,
+              externalFileCount: externalFiles.length,
+              verificationCount: allVerifications.length,
+              ...diagnostics,
+              latestVerificationTotals,
+              attributionClass: "module_unverified",
+              uncoveredImpactedTests: coverage.uncovered,
+              ...coverage.uncoverable.length > 0 ? { uncoverableImpactedTests: coverage.uncoverable } : {}
+            };
+          }
+          if (coverage.uncoverable.length > 0) {
+            return {
+              state: "GREEN",
+              canDeliver: true,
+              isBlocked: false,
+              reason: `${ownedFiles.length} owned file(s) verified. Ready to deliver. (${coverage.uncoverable.length} impacted test path(s) no longer exist \u2014 deleted/renamed, excluded from coverage check.)`,
+              ownedFileCount: ownedFiles.length,
+              externalFileCount: externalFiles.length,
+              verificationCount: allVerifications.length,
+              ...diagnostics,
+              latestVerificationTotals,
+              uncoverableImpactedTests: coverage.uncoverable
+            };
+          }
+        }
+        return {
+          state: "GREEN",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `${ownedFiles.length} owned file(s) verified. Ready to deliver.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals
+        };
+      }
+      case "external_blocked":
+        return {
+          state: "YELLOW",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `${ownedFiles.length} owned file(s) verified, but external verification blocked: ${aggregate.reason}. Deliverable with caveat.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals
+        };
+      case "no_test_infra":
+        return {
+          state: "YELLOW",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `\u6D4B\u8BD5\u57FA\u7840\u8BBE\u65BD\u7F3A\u5931\uFF1A${aggregate.reason}
+
+\u8BE5\u9879\u76EE\u65E0\u53EF\u81EA\u52A8\u68C0\u6D4B\u7684\u6D4B\u8BD5\u6846\u67B6\u6216\u6D4B\u8BD5\u6587\u4EF6\u3002run_tests \u4E0D\u4F1A\u81EA\u52A8\u751F\u6548\uFF0C\u7EE7\u7EED\u91CD\u8BD5\u4E0D\u4F1A\u6539\u53D8\u7ED3\u679C\u3002\u8BF7\u5411\u7528\u6237\u8BF4\u660E\u5177\u4F53\u7F3A\u5931\u9879\u548C\u4E0B\u4E00\u6B65\u3002`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals,
+          attributionClass: "no_test_infra"
+        };
+      case "owned_failure":
+        return {
+          state: "RED",
+          canDeliver: false,
+          isBlocked: true,
+          reason: aggregate.reason,
+          blockingReason: `Owned verification failed. Fix failures before delivery.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals,
+          currentBlockingFailure: aggregate.reason,
+          attributionClass: "owned_failure"
+        };
+      case "tool_invocation_failure":
+        return {
+          state: "YELLOW",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `${aggregate.reason}
+
+This is a tool invocation issue (timeout, crash) \u2014 not a code failure. Re-run with the recommended command. You may still deliver if you have independently verified correctness.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals
+        };
+      case "unattributed_failure":
+        return {
+          state: "YELLOW",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `${ownedFiles.length} owned file(s) are not directly implicated, but verification has unresolved full-suite failure: ${aggregate.reason}. Deliverable with caveat.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals
+        };
+      case "integration_conflict":
+        return {
+          state: "YELLOW",
+          canDeliver: true,
+          isBlocked: false,
+          reason: `${ownedFiles.length} owned file(s) verified in isolation, but integration on current HEAD conflicts: ${aggregate.reason}`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals
+        };
+      case "unverified":
+        return {
+          state: "RED",
+          canDeliver: false,
+          isBlocked: true,
+          reason: `${ownedFiles.length} owned file(s) modified but unverified.`,
+          blockingReason: `Run verification before delivery.`,
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals,
+          currentBlockingFailure: `${ownedFiles.length} owned file(s) modified but unverified.`,
+          attributionClass: "unverified"
+        };
+      default:
+        return {
+          state: "RED",
+          canDeliver: false,
+          isBlocked: true,
+          reason: "Unknown verification state.",
+          ownedFileCount: ownedFiles.length,
+          externalFileCount: externalFiles.length,
+          verificationCount: allVerifications.length,
+          ...diagnostics,
+          latestVerificationTotals,
+          currentBlockingFailure: "Unknown verification state.",
+          attributionClass: "unverified"
+        };
+    }
+  }
+  function getReport(externalVerifications, currentDirtyFiles, currentSnapshotRef, moduleCoverage) {
+    const result = assess(externalVerifications, currentDirtyFiles, currentSnapshotRef, moduleCoverage);
+    const { ownedFilesForGate, coOwnedFiles, historicalOwnedFiles, externalFiles } = getGateFiles(currentDirtyFiles);
+    return {
+      taskId: taskLedger.getTaskId(),
+      state: result.state,
+      canDeliver: result.canDeliver,
+      ownedFiles: ownedFilesForGate,
+      ownedFileCount: result.ownedFileCount,
+      coOwnedFiles,
+      coOwnedFileCount: coOwnedFiles.length,
+      historicalOwnedFiles,
+      historicalOwnedFileCount: historicalOwnedFiles.length,
+      externalFiles,
+      externalFileCount: result.externalFileCount,
+      verificationCount: result.verificationCount,
+      supersededFailures: result.supersededFailures,
+      staleSnapshotDropped: result.staleSnapshotDropped,
+      latestVerificationTotals: result.latestVerificationTotals,
+      staleFailureCandidates: result.staleFailureCandidates,
+      toolInvocationFailureCandidates: result.toolInvocationFailureCandidates,
+      currentBlockingFailure: result.currentBlockingFailure,
+      shortestNextStep: result.shortestNextStep,
+      blockingReason: result.blockingReason,
+      attributionClass: result.attributionClass,
+      uncoveredImpactedTests: result.uncoveredImpactedTests,
+      uncoverableImpactedTests: result.uncoverableImpactedTests,
+      attributionSummary: result.reason ?? "No attribution available."
+    };
+  }
+  return { assess, getReport };
+}
+
+export {
+  summarizeOwnershipHealth,
+  isJunkExternalPath,
+  filterExternalNoise,
+  buildGateConvergenceHint,
+  createDeliveryGateV2
+};

package/dist/chunk-2EBWGAXD.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/mcp/oauth/providers.ts
+init_esm_shims();
+var MCP_OAUTH_PROVIDERS = [
+  {
+    id: "github",
+    name: "GitHub",
+    authorizeUrl: "https://github.com/login/oauth/authorize",
+    tokenEndpoint: "https://github.com/login/oauth/access_token",
+    defaultScopes: ["repo", "read:org"],
+    clientIdHelp: "GitHub Settings \u2192 Developer settings \u2192 OAuth Apps \u2192 New OAuth App. Redirect URL: http://localhost:1456/auth/callback"
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    authorizeUrl: "https://slack.com/oauth/v2/authorize",
+    tokenEndpoint: "https://slack.com/api/oauth.v2.access",
+    defaultScopes: ["channels:read", "chat:write", "channels:history"],
+    clientIdHelp: "Slack API \u2192 Your Apps \u2192 Create New App \u2192 OAuth & Permissions. Redirect URL: http://localhost:1456/auth/callback"
+  },
+  {
+    id: "notion",
+    name: "Notion",
+    authorizeUrl: "https://api.notion.com/v1/oauth/authorize",
+    tokenEndpoint: "https://api.notion.com/v1/oauth/token",
+    defaultScopes: [],
+    clientIdHelp: "Notion Integrations \u2192 View integration \u2192 OAuth Domain & URIs. Redirect URL: http://localhost:1456/auth/callback"
+  },
+  {
+    id: "linear",
+    name: "Linear",
+    authorizeUrl: "https://linear.app/oauth/authorize",
+    tokenEndpoint: "https://api.linear.app/oauth/token",
+    defaultScopes: ["read", "write"],
+    clientIdHelp: "Linear Settings \u2192 API \u2192 OAuth applications \u2192 Create. Redirect URL: http://localhost:1456/auth/callback"
+  }
+];
+function findMcpOAuthProvider(id) {
+  const lower = id.toLowerCase();
+  return MCP_OAUTH_PROVIDERS.find((p) => p.id.toLowerCase() === lower);
+}
+
+export {
+  MCP_OAUTH_PROVIDERS,
+  findMcpOAuthProvider
+};

package/dist/chunk-2HDP7RMR.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/net/proxy-resolver.ts
+init_esm_shims();
+import { execSync } from "child_process";
+function envCaseInsensitive(key) {
+  return process.env[key] ?? process.env[key.toLowerCase()];
+}
+function readWindowsSystemProxy() {
+  if (process.platform !== "win32") return void 0;
+  try {
+    const enable = execSync(
+      'reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable 2>nul',
+      { encoding: "utf8", timeout: 3e3, windowsHide: true }
+    );
+    if (!/0x1/.test(enable)) return void 0;
+    const stdout = execSync(
+      'reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyServer 2>nul',
+      { encoding: "utf8", timeout: 3e3, windowsHide: true }
+    );
+    return parseWindowsProxyOutput(enable, stdout);
+  } catch {
+  }
+  return void 0;
+}
+function readMacosSystemProxy() {
+  if (process.platform !== "darwin") return void 0;
+  try {
+    const stdout = execSync("scutil --proxy", {
+      encoding: "utf8",
+      timeout: 3e3,
+      windowsHide: true
+    });
+    return parseScutilProxy(stdout);
+  } catch {
+  }
+  return void 0;
+}
+function parseScutilProxy(stdout) {
+  const get = (key) => {
+    const m = stdout.match(new RegExp(`^\\s*${key}\\s*:\\s*(\\S+)`, "m"));
+    return m?.[1];
+  };
+  const httpsHost = get("HTTPSProxy");
+  const httpsPort = get("HTTPSPort");
+  const httpsEnable = get("HTTPSEnable");
+  if (httpsEnable === "1" && httpsHost && httpsPort) {
+    return `http://${httpsHost}:${httpsPort}`;
+  }
+  const httpHost = get("HTTPProxy");
+  const httpPort = get("HTTPPort");
+  const httpEnable = get("HTTPEnable");
+  if (httpEnable === "1" && httpHost && httpPort) {
+    return `http://${httpHost}:${httpPort}`;
+  }
+  return void 0;
+}
+function parseWindowsProxyOutput(enableStdout, serverStdout) {
+  if (!/0x1/.test(enableStdout)) return void 0;
+  const match = serverStdout.match(/REG_SZ\s+(.+)/);
+  if (match?.[1]) return normalizeProxyUrl(match[1].trim());
+  return void 0;
+}
+function normalizeProxyUrl(raw) {
+  if (raw.includes("=")) {
+    const parts = raw.split(";");
+    for (const want of ["https", "http"]) {
+      for (const part of parts) {
+        const m = part.match(/^(https?)=(.+)/i);
+        if (m && m[1].toLowerCase() === want) return normalizeProxyUrl(m[2].trim());
+      }
+    }
+    return void 0;
+  }
+  if (/^https?:\/\//i.test(raw)) return raw;
+  return `http://${raw}`;
+}
+function shouldBypassProxy(hostname, noProxy) {
+  const raw = noProxy ?? envCaseInsensitive("NO_PROXY");
+  if (!raw) return false;
+  const h = hostname.toLowerCase();
+  for (const entry of raw.split(",")) {
+    const p = entry.trim().toLowerCase();
+    if (!p) continue;
+    if (p === "*") return true;
+    if (h === p) return true;
+    if (p.startsWith(".") && (h.endsWith(p) || h === p.slice(1))) return true;
+  }
+  return false;
+}
+function resolveProxyForUrl(url, opts) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return void 0;
+  }
+  if (shouldBypassProxy(parsed.hostname, opts?.noProxy)) return void 0;
+  if (opts?.proxyUrl) return opts.proxyUrl;
+  const systemProxy = () => process.env.RIVET_NO_SYSTEM_PROXY === "1" ? void 0 : readWindowsSystemProxy() ?? readMacosSystemProxy();
+  if (parsed.protocol === "https:") {
+    return envCaseInsensitive("HTTPS_PROXY") ?? envCaseInsensitive("HTTP_PROXY") ?? systemProxy();
+  }
+  if (parsed.protocol === "http:") {
+    return envCaseInsensitive("HTTP_PROXY") ?? envCaseInsensitive("HTTPS_PROXY") ?? systemProxy();
+  }
+  return systemProxy();
+}
+
+export {
+  parseScutilProxy,
+  parseWindowsProxyOutput,
+  shouldBypassProxy,
+  resolveProxyForUrl
+};