@spotpatch/shared 1.9.0 → 1.10.0

package/dist/external-agent-node.cjs

@@ -0,0 +1,692 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/external-agent-node.ts
+var external_agent_node_exports = {};
+__export(external_agent_node_exports, {
+  EXTERNAL_HANDOFF_PROJECT_KEY_SALT: () => EXTERNAL_HANDOFF_PROJECT_KEY_SALT,
+  SPOTPATCH_BRIDGE_PATHS: () => SPOTPATCH_BRIDGE_PATHS,
+  SPOTPATCH_BRIDGE_TOKEN_HEADER: () => SPOTPATCH_BRIDGE_TOKEN_HEADER,
+  bridgeAckRequestSchema: () => bridgeAckRequestSchema,
+  bridgeAckResultSchema: () => bridgeAckResultSchema,
+  bridgeActiveClaimRequestSchema: () => bridgeActiveClaimRequestSchema,
+  bridgeActiveClaimResultSchema: () => bridgeActiveClaimResultSchema,
+  bridgeActiveHeartbeatRequestSchema: () => bridgeActiveHeartbeatRequestSchema,
+  bridgeActiveHeartbeatResultSchema: () => bridgeActiveHeartbeatResultSchema,
+  bridgeActiveReleaseRequestSchema: () => bridgeActiveReleaseRequestSchema,
+  bridgeActiveReleaseResultSchema: () => bridgeActiveReleaseResultSchema,
+  bridgeActiveReportRequestSchema: () => bridgeActiveReportRequestSchema,
+  bridgeActiveReportResultSchema: () => bridgeActiveReportResultSchema,
+  bridgeActiveStateResultSchema: () => bridgeActiveStateResultSchema,
+  bridgeCurrentRequestSchema: () => bridgeCurrentRequestSchema,
+  bridgeCurrentResultSchema: () => bridgeCurrentResultSchema,
+  bridgeStatusRequestSchema: () => bridgeStatusRequestSchema,
+  bridgeStatusSchema: () => bridgeStatusSchema,
+  bridgeWaitRequestSchema: () => bridgeWaitRequestSchema,
+  bridgeWaitResultSchema: () => bridgeWaitResultSchema,
+  computeExternalHandoffProjectKey: () => computeExternalHandoffProjectKey,
+  externalHandoffDescriptorSchema: () => externalHandoffDescriptorSchema,
+  resolveExternalHandoffRuntimeDirectory: () => resolveExternalHandoffRuntimeDirectory
+});
+module.exports = __toCommonJS(external_agent_node_exports);
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_zod3 = require("zod");
+
+// src/protocol/external-handoff.ts
+var import_zod2 = require("zod");
+
+// src/protocol/requests.ts
+var import_zod = require("zod");
+
+// src/model/annotation.ts
+var MAX_ANNOTATION_TARGETS = 20;
+var MAX_TARGET_INSTRUCTION_CHARACTERS = 2e3;
+var MAX_ANNOTATION_INSTRUCTION_CHARACTERS = 4e3;
+var SPOTPATCH_LOCALES = Object.freeze(["en-US", "zh-CN"]);
+var SPOTPATCH_LOCALE_PREFERENCES = Object.freeze([
+  "auto",
+  ...SPOTPATCH_LOCALES
+]);
+
+// src/model/agent.ts
+var AGENT_APPLY_MODES = Object.freeze([
+  "review",
+  "auto",
+  "trusted-auto"
+]);
+var DEFAULT_AGENT_LIMITS = Object.freeze({
+  maxTurns: 20,
+  maxToolCalls: 80,
+  maxChangedFiles: 20,
+  maxDiffBytes: 512e3,
+  maxReadBytesPerFile: 256e3,
+  maxToolOutputCharacters: 4e4,
+  maxProviderResponseBytes: 2e6,
+  providerConnectTimeoutMs: 15e3,
+  providerFirstByteTimeoutMs: 3e4,
+  providerIdleTimeoutMs: 6e4,
+  checkTimeoutMs: 12e4,
+  jobTimeoutMs: 6e5
+});
+var AGENT_JOB_STATUSES = Object.freeze([
+  "queued",
+  "preparing",
+  "running",
+  "validating",
+  "awaiting-review",
+  "applying",
+  "applied",
+  "completed",
+  "cancelling",
+  "cancelled",
+  "reverting",
+  "reverted",
+  "failed"
+]);
+var AGENT_CAPABILITY_STATES = Object.freeze([
+  "unknown",
+  "probing",
+  "agent-ready",
+  "prompt-only",
+  "unavailable"
+]);
+var AGENT_WORKSPACE_STATES = Object.freeze([
+  "ready",
+  "consent-required",
+  "blocked"
+]);
+var AGENT_WORKSPACE_SNAPSHOT_LIMITS = Object.freeze({
+  maxUntrackedFiles: 1e3,
+  maxUntrackedBytes: 20 * 1024 * 1024
+});
+var AGENT_FILE_CHANGE_KINDS = Object.freeze([
+  "added",
+  "modified",
+  "deleted"
+]);
+var AGENT_CHECK_STATUSES = Object.freeze([
+  "passed",
+  "failed",
+  "cancelled",
+  "timed-out"
+]);
+
+// src/protocol/requests.ts
+var runtimeBootstrapRequestSchema = import_zod.z.strictObject({});
+var sourceCoordinatesSchema = import_zod.z.strictObject({
+  fileId: import_zod.z.string().min(1).max(128),
+  line: import_zod.z.number().int().positive(),
+  column: import_zod.z.number().int().positive()
+});
+var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
+  maxLines: import_zod.z.number().int().positive()
+}).strict();
+var openEditorRequestSchema = sourceCoordinatesSchema.strict();
+var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
+  schemaVersion: import_zod.z.literal(1),
+  sourceVersion: import_zod.z.string().min(1).max(128).optional()
+}).strict();
+var dataFlowComponentIdentityRequestSchema = import_zod.z.strictObject({
+  schemaVersion: import_zod.z.literal(1),
+  componentSourceId: import_zod.z.string().min(1).max(128),
+  sourceVersion: import_zod.z.string().min(1).max(128)
+});
+var dataFlowComponentReportRequestSchema = import_zod.z.union([
+  dataFlowSourceCoordinatesRequestSchema,
+  dataFlowComponentIdentityRequestSchema
+]);
+var dataFlowPageReportRequestSchema = import_zod.z.strictObject({
+  schemaVersion: import_zod.z.literal(1),
+  targets: import_zod.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
+});
+var profileIdSchema = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (maximum) => import_zod.z.string().max(maximum);
+var sourceRefSchema = import_zod.z.strictObject({
+  fileId: boundedString(128).optional(),
+  relativePath: boundedString(1024).optional(),
+  line: import_zod.z.number().int().positive().optional(),
+  column: import_zod.z.number().int().positive().optional(),
+  origin: import_zod.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: import_zod.z.enum(["exact", "probable", "approximate", "unknown"])
+});
+var matchedStyleRuleSchema = import_zod.z.strictObject({
+  selector: boundedString(2048),
+  declarations: boundedString(8192),
+  source: boundedString(1024).optional(),
+  media: boundedString(1024).optional()
+});
+var codeContextSchema = import_zod.z.strictObject({
+  relativePath: boundedString(1024),
+  language: import_zod.z.enum(["tsx", "jsx"]),
+  startLine: import_zod.z.number().int().positive(),
+  endLine: import_zod.z.number().int().positive(),
+  excerpt: boundedString(16e3),
+  boundary: import_zod.z.enum(["component", "nearby-lines"])
+});
+var pageContextSchema = import_zod.z.strictObject({
+  url: boundedString(2048),
+  pathname: boundedString(2048),
+  title: boundedString(1024),
+  viewportWidth: import_zod.z.number().nonnegative(),
+  viewportHeight: import_zod.z.number().nonnegative(),
+  devicePixelRatio: import_zod.z.number().positive()
+});
+var spotTargetContextRequestSchema = import_zod.z.strictObject({
+  instruction: import_zod.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+  page: pageContextSchema.optional(),
+  source: sourceRefSchema,
+  react: import_zod.z.strictObject({
+    supported: import_zod.z.boolean(),
+    version: boundedString(64).optional(),
+    componentName: boundedString(256).optional(),
+    componentSourceId: boundedString(128).optional(),
+    sourceVersion: boundedString(128).optional(),
+    componentStack: import_zod.z.array(boundedString(256)).max(64),
+    source: sourceRefSchema.optional()
+  }),
+  element: import_zod.z.strictObject({
+    tagName: boundedString(128),
+    selector: boundedString(2048),
+    sanitizedHtml: boundedString(8192),
+    textPreview: boundedString(2048).optional(),
+    role: boundedString(256).optional(),
+    rect: import_zod.z.strictObject({
+      x: import_zod.z.number(),
+      y: import_zod.z.number(),
+      width: import_zod.z.number().nonnegative(),
+      height: import_zod.z.number().nonnegative()
+    })
+  }),
+  styles: import_zod.z.strictObject({
+    classNames: import_zod.z.array(boundedString(512)).max(256),
+    inlineStyle: boundedString(8192).optional(),
+    matchedRules: import_zod.z.array(matchedStyleRuleSchema).max(256),
+    computed: import_zod.z.record(boundedString(256), boundedString(2048)),
+    warnings: import_zod.z.array(boundedString(1024)).max(64)
+  }),
+  code: codeContextSchema.optional(),
+  warnings: import_zod.z.array(boundedString(1024)).max(64)
+});
+var spotAnnotationRequestSchema = import_zod.z.strictObject({
+  schemaVersion: import_zod.z.literal(3),
+  id: boundedString(128),
+  locale: import_zod.z.enum(SPOTPATCH_LOCALES),
+  page: pageContextSchema,
+  targets: import_zod.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: import_zod.z.iso.datetime()
+}).superRefine((annotation, context) => {
+  const total = annotation.targets.reduce(
+    (characters, target) => characters + target.instruction.length,
+    0
+  );
+  if (total > MAX_ANNOTATION_INSTRUCTION_CHARACTERS) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined target instructions exceed the annotation limit.",
+      path: ["targets"]
+    });
+  }
+});
+var agentCapabilityRequestSchema = import_zod.z.strictObject({
+  providerProfileId: profileIdSchema,
+  modelProfileId: profileIdSchema
+});
+var agentWorkspaceHealthRequestSchema = import_zod.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod.z.strictObject({
+  annotation: spotAnnotationRequestSchema,
+  applyMode: import_zod.z.enum(AGENT_APPLY_MODES).optional(),
+  providerProfileId: profileIdSchema,
+  modelProfileId: profileIdSchema,
+  providerDataConsent: import_zod.z.literal(true),
+  trustedFastModeConsent: import_zod.z.literal(true).optional(),
+  workingTreeMode: import_zod.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+});
+var agentJobActionRequestSchema = import_zod.z.strictObject({});
+
+// src/protocol/external-handoff-constants.ts
+var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
+var EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION = 2;
+var EXTERNAL_HANDOFF_STATES = Object.freeze([
+  "available",
+  "expired",
+  "superseded"
+]);
+var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze(["vite", "next"]);
+var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS = Object.freeze([
+  "claude-channel",
+  "codex-app-server"
+]);
+var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES = Object.freeze([
+  "ready",
+  "busy",
+  "blocked"
+]);
+var EXTERNAL_HANDOFF_DISPATCH_PHASES = Object.freeze([
+  "queued",
+  "dispatching",
+  "dispatched",
+  "working",
+  "completed",
+  "failed",
+  "delivery-unknown"
+]);
+var EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES = Object.freeze([
+  "dispatching",
+  "dispatched",
+  "working",
+  "completed",
+  "failed",
+  "delivery-unknown"
+]);
+var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
+  maximumSnapshotBytes: 256 * 1024,
+  maximumPublishBodyBytes: 256 * 1024,
+  maximumBrokerRequestBytes: 8 * 1024,
+  maximumDescriptorBytes: 8 * 1024,
+  maximumHistorySummaries: 8,
+  maximumConnectorReceipts: 64,
+  handoffTtlMs: 15 * 60 * 1e3,
+  defaultWaitMs: 2e4,
+  maximumWaitMs: 25e3,
+  maximumWaiters: 8,
+  maximumDescriptorsPerScan: 32,
+  maximumProjectAncestors: 64,
+  maximumBrokerHeaderBytes: 8 * 1024,
+  maximumBrokerSockets: 32,
+  brokerDiscoveryTimeoutMs: 750,
+  brokerRequestTimeoutMs: 2e3,
+  brokerWaitGraceMs: 2e3,
+  maximumSetupConfigBytes: 1024 * 1024,
+  maximumRequestIdRecords: 16,
+  requestIdTtlMs: 15 * 60 * 1e3,
+  activeHeartbeatIntervalMs: 3e3,
+  activeLeaseDurationMs: 1e4,
+  activeTransportWriteTimeoutMs: 5e3,
+  activeDispatchTimeoutMs: 30 * 60 * 1e3,
+  activeStatusPollMs: 1e3
+});
+
+// src/protocol/external-handoff.ts
+var opaqueIdSchema = import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema = import_zod2.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod2.z.enum(
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES
+);
+var externalHandoffPageSummarySchema = import_zod2.z.strictObject({
+  origin: import_zod2.z.string().min(1).max(2048),
+  pathname: import_zod2.z.string().min(1).max(2048)
+});
+var externalHandoffSummarySchema = import_zod2.z.strictObject({
+  sessionId: opaqueIdSchema,
+  framework: import_zod2.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod2.z.number().int().positive(),
+  cursor: opaqueIdSchema,
+  targetCount: import_zod2.z.number().int().positive(),
+  page: externalHandoffPageSummarySchema,
+  publishedAt: isoTimestampSchema,
+  expiresAt: isoTimestampSchema,
+  state: import_zod2.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod2.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  pickedUpAt: isoTimestampSchema.optional()
+});
+var externalHandoffSnapshotSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  cursor: opaqueIdSchema,
+  session: import_zod2.z.strictObject({
+    id: opaqueIdSchema,
+    framework: import_zod2.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+  }),
+  revision: import_zod2.z.number().int().positive(),
+  publishedAt: isoTimestampSchema,
+  expiresAt: isoTimestampSchema,
+  annotation: spotAnnotationRequestSchema
+});
+var activeAdapterSummarySchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod2.z.boolean(),
+  connectedAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+}).superRefine((value, context) => {
+  if (value.canDispatch !== (value.state === "ready")) {
+    context.addIssue({
+      code: "custom",
+      message: "canDispatch must match the ready state.",
+      path: ["canDispatch"]
+    });
+  }
+});
+var dispatchSummarySchema = import_zod2.z.strictObject({
+  adapterKind: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod2.z.number().int().positive(),
+  phase: import_zod2.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+  updatedAt: isoTimestampSchema
+});
+var externalHandoffCapabilityRequestSchema = import_zod2.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod2.z.strictObject({
+  requestId: opaqueIdSchema,
+  annotation: spotAnnotationRequestSchema
+});
+var externalHandoffStatusRequestSchema = import_zod2.z.strictObject({
+  cursor: opaqueIdSchema.optional()
+});
+var externalHandoffResolveDeliveryRequestSchema = import_zod2.z.strictObject({
+  cursor: opaqueIdSchema,
+  confirmation: import_zod2.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod2.z.strictObject({
+  enabled: import_zod2.z.literal(true),
+  brokerReady: import_zod2.z.boolean(),
+  activeWaitCount: import_zod2.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
+});
+var externalHandoffPublishDeliverySchema = import_zod2.z.discriminatedUnion("mode", [
+  import_zod2.z.strictObject({ mode: import_zod2.z.literal("inbox") }),
+  import_zod2.z.strictObject({
+    mode: import_zod2.z.literal("active"),
+    adapter: activeAdapterSummarySchema,
+    dispatch: dispatchSummarySchema
+  })
+]);
+var externalHandoffPublishResultSchema = import_zod2.z.strictObject({
+  handoff: externalHandoffSummarySchema,
+  delivery: externalHandoffPublishDeliverySchema,
+  replayed: import_zod2.z.boolean()
+});
+var externalHandoffStatusResultSchema = import_zod2.z.strictObject({
+  handoff: externalHandoffSummarySchema,
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
+});
+
+// src/errors/error-code.ts
+var ERROR_CODES = {
+  INVALID_REQUEST: "INVALID_REQUEST",
+  INVALID_TOKEN: "INVALID_TOKEN",
+  ORIGIN_NOT_ALLOWED: "ORIGIN_NOT_ALLOWED",
+  SOURCE_NOT_FOUND: "SOURCE_NOT_FOUND",
+  SOURCE_OUTSIDE_ROOT: "SOURCE_OUTSIDE_ROOT",
+  SOURCE_TOO_LARGE: "SOURCE_TOO_LARGE",
+  EDITOR_OPEN_FAILED: "EDITOR_OPEN_FAILED",
+  DATA_FLOW_DISABLED: "DATA_FLOW_DISABLED",
+  DATA_FLOW_SOURCE_STALE: "DATA_FLOW_SOURCE_STALE",
+  DATA_FLOW_ANALYSIS_CANCELLED: "DATA_FLOW_ANALYSIS_CANCELLED",
+  AI_DISABLED: "AI_DISABLED",
+  PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_PROTOCOL_UNSUPPORTED: "PROVIDER_PROTOCOL_UNSUPPORTED",
+  MODEL_NOT_ALLOWED: "MODEL_NOT_ALLOWED",
+  MODEL_TOOL_CALL_UNSUPPORTED: "MODEL_TOOL_CALL_UNSUPPORTED",
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  AGENT_BUSY: "AGENT_BUSY",
+  AGENT_LIMIT_EXCEEDED: "AGENT_LIMIT_EXCEEDED",
+  AGENT_CANCELLED: "AGENT_CANCELLED",
+  EXTERNAL_HANDOFF_DISABLED: "EXTERNAL_HANDOFF_DISABLED",
+  EXTERNAL_HANDOFF_UNAVAILABLE: "EXTERNAL_HANDOFF_UNAVAILABLE",
+  HANDOFF_VALIDATION_FAILED: "HANDOFF_VALIDATION_FAILED",
+  HANDOFF_SOURCE_STALE: "HANDOFF_SOURCE_STALE",
+  HANDOFF_NOT_FOUND: "HANDOFF_NOT_FOUND",
+  HANDOFF_EXPIRED: "HANDOFF_EXPIRED",
+  HANDOFF_CURSOR_INVALID: "HANDOFF_CURSOR_INVALID",
+  HANDOFF_RESPONSE_TOO_LARGE: "HANDOFF_RESPONSE_TOO_LARGE",
+  BRIDGE_UNAUTHORIZED: "BRIDGE_UNAUTHORIZED",
+  BRIDGE_PROTOCOL_MISMATCH: "BRIDGE_PROTOCOL_MISMATCH",
+  BRIDGE_BUSY: "BRIDGE_BUSY",
+  EXTERNAL_AGENT_BUSY: "EXTERNAL_AGENT_BUSY",
+  ACTIVE_ADAPTER_CONFLICT: "ACTIVE_ADAPTER_CONFLICT",
+  ACTIVE_ADAPTER_LEASE_INVALID: "ACTIVE_ADAPTER_LEASE_INVALID",
+  ACTIVE_DISPATCH_INVALID: "ACTIVE_DISPATCH_INVALID",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_AMBIGUOUS: "SESSION_AMBIGUOUS",
+  SESSION_CLOSED: "SESSION_CLOSED",
+  WORKTREE_DIRTY: "WORKTREE_DIRTY",
+  WORKTREE_NOT_REPOSITORY: "WORKTREE_NOT_REPOSITORY",
+  WORKTREE_OPERATION_IN_PROGRESS: "WORKTREE_OPERATION_IN_PROGRESS",
+  WORKTREE_CONFLICTED: "WORKTREE_CONFLICTED",
+  WORKTREE_LOCAL_CHANGES_TOO_LARGE: "WORKTREE_LOCAL_CHANGES_TOO_LARGE",
+  WORKTREE_UNTRACKED_UNSUPPORTED: "WORKTREE_UNTRACKED_UNSUPPORTED",
+  WORKTREE_LOCAL_CHANGES_UNSUPPORTED: "WORKTREE_LOCAL_CHANGES_UNSUPPORTED",
+  TOOL_DENIED: "TOOL_DENIED",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  TOOL_ARGUMENTS_INVALID: "TOOL_ARGUMENTS_INVALID",
+  TOOL_CALL_ID_CONFLICT: "TOOL_CALL_ID_CONFLICT",
+  TOOL_PATH_DENIED: "TOOL_PATH_DENIED",
+  PATCH_REJECTED: "PATCH_REJECTED",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  APPLY_CONFLICT: "APPLY_CONFLICT",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
+
+// src/errors/spotpatch-error.ts
+var SpotPatchError = class extends Error {
+  code;
+  constructor(code, message = code, options) {
+    super(message, options);
+    this.name = "SpotPatchError";
+    this.code = code;
+  }
+};
+
+// src/external-agent-node.ts
+var SPOTPATCH_BRIDGE_TOKEN_HEADER = "X-SpotPatch-Bridge-Token";
+var SPOTPATCH_BRIDGE_PATHS = Object.freeze({
+  status: "/bridge/v1/status",
+  current: "/bridge/v1/handoff/current",
+  wait: "/bridge/v1/handoff/wait",
+  ack: "/bridge/v1/handoff/ack",
+  activeClaim: "/bridge/v1/active/claim",
+  activeHeartbeat: "/bridge/v1/active/heartbeat",
+  activeReport: "/bridge/v1/active/report",
+  activeRelease: "/bridge/v1/active/release"
+});
+var EXTERNAL_HANDOFF_PROJECT_KEY_SALT = "spotpatch-external-agent-project-v1";
+var opaqueIdSchema2 = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var projectKeySchema = import_zod3.z.string().length(64).regex(/^[a-f0-9]+$/u);
+var loopbackEndpointSchema = import_zod3.z.url().refine((value) => {
+  const match = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/u.exec(value);
+  if (match?.[1] === void 0) {
+    return false;
+  }
+  const port = Number(match[1]);
+  return Number.isSafeInteger(port) && port <= 65535;
+});
+var externalHandoffDescriptorSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(1),
+  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  projectKey: projectKeySchema,
+  sessionId: opaqueIdSchema2,
+  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  endpoint: loopbackEndpointSchema,
+  bridgeToken: import_zod3.z.string().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  pid: import_zod3.z.number().int().positive(),
+  createdAt: import_zod3.z.iso.datetime()
+});
+var bridgeStatusRequestSchema = import_zod3.z.strictObject({});
+var bridgeCurrentRequestSchema = import_zod3.z.strictObject({
+  cursor: opaqueIdSchema2.optional()
+});
+var bridgeWaitRequestSchema = import_zod3.z.strictObject({
+  afterCursor: opaqueIdSchema2.optional(),
+  timeoutMs: import_zod3.z.number().int().positive().max(EXTERNAL_HANDOFF_LIMITS.maximumWaitMs).default(EXTERNAL_HANDOFF_LIMITS.defaultWaitMs)
+});
+var bridgeAckRequestSchema = import_zod3.z.strictObject({
+  cursor: opaqueIdSchema2,
+  connectorInstanceId: opaqueIdSchema2
+});
+var bridgeActiveClaimRequestSchema = import_zod3.z.strictObject({
+  adapterKind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  connectorInstanceId: opaqueIdSchema2
+});
+var bridgeActiveHeartbeatRequestSchema = import_zod3.z.strictObject({
+  leaseToken: opaqueIdSchema2
+});
+var bridgeActiveReportRequestSchema = import_zod3.z.strictObject({
+  leaseToken: opaqueIdSchema2,
+  cursor: opaqueIdSchema2,
+  phase: externalHandoffReportableDispatchPhaseSchema
+});
+var bridgeActiveReleaseRequestSchema = import_zod3.z.strictObject({
+  leaseToken: opaqueIdSchema2
+});
+var bridgeStatusSchema = import_zod3.z.strictObject({
+  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  projectKey: projectKeySchema,
+  sessionId: opaqueIdSchema2,
+  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  current: externalHandoffSummarySchema.nullable()
+});
+var bridgeCurrentResultSchema = import_zod3.z.strictObject({
+  outcome: import_zod3.z.literal("handoff"),
+  snapshot: externalHandoffSnapshotSchema
+});
+var bridgeWaitResultSchema = import_zod3.z.discriminatedUnion("outcome", [
+  bridgeCurrentResultSchema,
+  import_zod3.z.strictObject({ outcome: import_zod3.z.literal("timeout") })
+]);
+var bridgeAckResultSchema = import_zod3.z.strictObject({
+  summary: externalHandoffSummarySchema
+});
+var bridgeActiveClaimResultSchema = import_zod3.z.strictObject({
+  leaseToken: opaqueIdSchema2,
+  heartbeatIntervalMs: import_zod3.z.literal(EXTERNAL_HANDOFF_LIMITS.activeHeartbeatIntervalMs),
+  baselineCursor: opaqueIdSchema2.nullable(),
+  activeAdapter: activeAdapterSummarySchema
+});
+var bridgeActiveStateResultSchema = import_zod3.z.strictObject({
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
+});
+var bridgeActiveHeartbeatResultSchema = bridgeActiveStateResultSchema;
+var bridgeActiveReportResultSchema = bridgeActiveStateResultSchema;
+var bridgeActiveReleaseResultSchema = bridgeActiveStateResultSchema;
+function currentUid() {
+  const uid = process.getuid?.();
+  if (uid === void 0) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
+  return uid;
+}
+async function assertPrivateDirectory(directory, uid) {
+  const status = await (0, import_promises.lstat)(directory);
+  if (!status.isDirectory() || status.isSymbolicLink() || status.uid !== uid || (status.mode & 63) !== 0) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
+}
+async function ensurePrivateSubdirectory(base, uid, create) {
+  const directory = import_node_path.default.join(base, "spotpatch");
+  if (create) {
+    try {
+      await (0, import_promises.mkdir)(directory, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+  await assertPrivateDirectory(directory, uid);
+  return directory;
+}
+async function resolveExternalHandoffRuntimeDirectory(create) {
+  if (process.platform === "win32") {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
+  const uid = currentUid();
+  const xdgRuntimeDirectory = process.env.XDG_RUNTIME_DIR;
+  if (xdgRuntimeDirectory !== void 0 && !import_node_path.default.isAbsolute(xdgRuntimeDirectory)) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
+  if (xdgRuntimeDirectory !== void 0) {
+    try {
+      await assertPrivateDirectory(xdgRuntimeDirectory, uid);
+      return await ensurePrivateSubdirectory(xdgRuntimeDirectory, uid, create);
+    } catch (error) {
+      if (!create && error.code === "ENOENT") {
+        throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
+      }
+      throw error;
+    }
+  }
+  const fallback = import_node_path.default.join(import_node_os.default.tmpdir(), `spotpatch-${String(uid)}`);
+  if (create) {
+    try {
+      await (0, import_promises.mkdir)(fallback, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+  try {
+    await assertPrivateDirectory(fallback, uid);
+  } catch (error) {
+    if (!create && error.code === "ENOENT") {
+      throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
+    }
+    throw error;
+  }
+  return fallback;
+}
+async function computeExternalHandoffProjectKey(root) {
+  const canonicalRoot = await (0, import_promises.realpath)(root);
+  return (0, import_node_crypto.createHash)("sha256").update(`${EXTERNAL_HANDOFF_PROJECT_KEY_SALT}\0${canonicalRoot}`).digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXTERNAL_HANDOFF_PROJECT_KEY_SALT,
+  SPOTPATCH_BRIDGE_PATHS,
+  SPOTPATCH_BRIDGE_TOKEN_HEADER,
+  bridgeAckRequestSchema,
+  bridgeAckResultSchema,
+  bridgeActiveClaimRequestSchema,
+  bridgeActiveClaimResultSchema,
+  bridgeActiveHeartbeatRequestSchema,
+  bridgeActiveHeartbeatResultSchema,
+  bridgeActiveReleaseRequestSchema,
+  bridgeActiveReleaseResultSchema,
+  bridgeActiveReportRequestSchema,
+  bridgeActiveReportResultSchema,
+  bridgeActiveStateResultSchema,
+  bridgeCurrentRequestSchema,
+  bridgeCurrentResultSchema,
+  bridgeStatusRequestSchema,
+  bridgeStatusSchema,
+  bridgeWaitRequestSchema,
+  bridgeWaitResultSchema,
+  computeExternalHandoffProjectKey,
+  externalHandoffDescriptorSchema,
+  resolveExternalHandoffRuntimeDirectory
+});
+//# sourceMappingURL=external-agent-node.cjs.map