@spotpatch/shared 1.10.0 → 1.11.0

package/dist/index.js

@@ -46,13 +46,13 @@ import {
   sourceContextRequestSchema,
   spotAnnotationRequestSchema,
   spotTargetContextRequestSchema
-} from "./chunk-MOGITGPP.js";
+} from "./chunk-JU5HIWX7.js";
 import {
   SPOTPATCH_API_BASE,
   SPOTPATCH_ENDPOINTS,
   SPOTPATCH_TOKEN_HEADER,
   getAgentJobEndpoint
-} from "./chunk-ZCG3DLSW.js";
+} from "./chunk-JGOIBOFI.js";
 import {
   EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
   EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
@@ -683,37 +683,269 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
-// src/protocol/agent-schemas.ts
+// src/protocol/external-agent-control.ts
 import { z as z3 } from "zod";
-var profileIdSchema2 = z3.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString = (maximum) => z3.string().max(maximum);
-var errorCodeSchema = z3.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = z3.strictObject({
+var EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION = 1;
+var EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS = Object.freeze(["codex"]);
+var EXTERNAL_AGENT_MODES = Object.freeze(["inbox", "managed"]);
+var EXTERNAL_AGENT_CONNECTION_STATES = Object.freeze([
+  "disconnected",
+  "diagnosing",
+  "awaiting-consent",
+  "connecting",
+  "ready",
+  "busy",
+  "degraded",
+  "error",
+  "disconnecting"
+]);
+var EXTERNAL_AGENT_AUTH_READINESS = Object.freeze([
+  "authenticated",
+  "auth-not-required",
+  "signed-out",
+  "unknown"
+]);
+var EXTERNAL_AGENT_GRANT_STATES = Object.freeze([
+  "missing",
+  "valid",
+  "invalid"
+]);
+var EXTERNAL_AGENT_DELIVERY_STATUSES = Object.freeze([
+  "queued",
+  "dispatching",
+  "accepted",
+  "unknown"
+]);
+var EXTERNAL_AGENT_EXECUTION_STATUSES = Object.freeze([
+  "not-observable",
+  "started",
+  "terminal-succeeded",
+  "terminal-failed",
+  "interrupted",
+  "unknown"
+]);
+var EXTERNAL_AGENT_MANAGED_PHASES = Object.freeze([
+  "preparing",
+  "running",
+  "auditing",
+  "validating",
+  "applying",
+  "completed",
+  "review-required",
+  "failed",
+  "cancelled",
+  "cleanup-warning"
+]);
+var EXTERNAL_AGENT_VALIDATION_OUTCOMES = Object.freeze([
+  "passed",
+  "failed",
+  "not-configured",
+  "unavailable"
+]);
+var EXTERNAL_AGENT_CHECK_OUTCOMES = Object.freeze([
+  "passed",
+  "failed",
+  "unavailable"
+]);
+var EXTERNAL_AGENT_ERROR_STAGES = Object.freeze([
+  "integration",
+  "binary",
+  "handshake",
+  "auth",
+  "model",
+  "protocol",
+  "snapshot",
+  "audit",
+  "validation",
+  "apply",
+  "cleanup"
+]);
+var EXTERNAL_AGENT_ERROR_RECOVERABILITY = Object.freeze([
+  "retry",
+  "user-action",
+  "reconfigure",
+  "none"
+]);
+var EXTERNAL_AGENT_ERROR_CODES = Object.freeze([
+  "AGENT_BINARY_NOT_FOUND",
+  "AGENT_BINARY_UNTRUSTED",
+  "AGENT_VERSION_UNSUPPORTED",
+  "APP_SERVER_HANDSHAKE_FAILED",
+  "AGENT_AUTH_REQUIRED",
+  "AGENT_MODEL_UNAVAILABLE",
+  "AGENT_PROTOCOL_INCOMPATIBLE",
+  "CODEX_CONFIG_ISOLATION_UNSUPPORTED",
+  "MANAGED_GRANT_INVALID",
+  "MANAGED_PLATFORM_UNSUPPORTED",
+  "MANAGED_GIT_REQUIRED",
+  "MANAGED_SNAPSHOT_FAILED",
+  "MANAGED_SCOPE_VIOLATION",
+  "MANAGED_CHANGE_LIMIT_EXCEEDED",
+  "MANAGED_VALIDATION_FAILED",
+  "MANAGED_WORKSPACE_CONFLICT",
+  "MANAGED_APPLY_FAILED",
+  "MANAGED_CLEANUP_INCOMPLETE"
+]);
+var EXTERNAL_AGENT_ACTIONS = Object.freeze([
+  "install-agent",
+  "use-supported-version",
+  "sign-in",
+  "choose-available-model",
+  "use-inbox",
+  "confirm-managed-access",
+  "review-candidate-diff",
+  "review-workspace-conflict",
+  "retry",
+  "inspect-cleanup-warning"
+]);
+var EXTERNAL_AGENT_MANAGED_PROFILE = "managed-apply-v1";
+var EXTERNAL_AGENT_CONTROL_LIMITS = Object.freeze({
+  maximumEventSubscribers: 4,
+  eventHeartbeatMs: 15e3,
+  eventReconnectMinimumMs: 500,
+  eventReconnectMaximumMs: 1e4,
+  maximumChangedFiles: DEFAULT_AGENT_LIMITS.maxChangedFiles,
+  maximumChecks: 64,
+  maximumEventLineBytes: 64 * 1024,
+  maximumResultDiffBytes: DEFAULT_AGENT_LIMITS.maxDiffBytes
+});
+var isoTimestampSchema = z3.iso.datetime();
+var requestIdSchema = z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var safeRelativePathSchema = z3.string().min(1).max(4096).superRefine((value, context) => {
+  const segments = value.split("/");
+  if (value.startsWith("/") || value.includes("\\") || segments.some(
+    (segment) => segment.length === 0 || segment === "." || segment === ".."
+  )) {
+    context.addIssue({ code: "custom", message: "Expected a safe relative path." });
+  }
+});
+var externalAgentErrorSchema = z3.strictObject({
+  code: z3.enum(EXTERNAL_AGENT_ERROR_CODES),
+  stage: z3.enum(EXTERNAL_AGENT_ERROR_STAGES),
+  recoverability: z3.enum(EXTERNAL_AGENT_ERROR_RECOVERABILITY),
+  action: z3.enum(EXTERNAL_AGENT_ACTIONS)
+});
+var managedFileSummarySchema = z3.strictObject({
+  path: safeRelativePathSchema,
+  additions: z3.number().int().nonnegative(),
+  deletions: z3.number().int().nonnegative()
+});
+var managedCheckSummarySchema = z3.strictObject({
+  id: z3.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/u),
+  outcome: z3.enum(EXTERNAL_AGENT_CHECK_OUTCOMES),
+  durationMs: z3.number().int().nonnegative(),
+  exitCode: z3.number().int().optional()
+});
+var managedTimingSummarySchema = z3.strictObject({
+  preparing: z3.number().int().nonnegative().optional(),
+  agent: z3.number().int().nonnegative().optional(),
+  auditing: z3.number().int().nonnegative().optional(),
+  validating: z3.number().int().nonnegative().optional(),
+  applying: z3.number().int().nonnegative().optional(),
+  total: z3.number().int().nonnegative().optional()
+});
+var managedTaskStatusSchema = z3.strictObject({
+  revision: z3.number().int().positive(),
+  deliveryStatus: z3.enum(EXTERNAL_AGENT_DELIVERY_STATUSES),
+  executionStatus: z3.enum(EXTERNAL_AGENT_EXECUTION_STATUSES),
+  managedPhase: z3.enum(EXTERNAL_AGENT_MANAGED_PHASES),
+  validationOutcome: z3.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES).optional(),
+  files: z3.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: z3.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  resultExpiresAt: isoTimestampSchema.optional()
+});
+var externalAgentControlStatusSchema = z3.strictObject({
+  schemaVersion: z3.literal(EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION),
+  sequence: z3.number().int().nonnegative(),
+  mode: z3.enum(EXTERNAL_AGENT_MODES),
+  adapter: z3.strictObject({
+    kind: z3.enum(EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS),
+    maturity: z3.literal("experimental"),
+    availability: z3.enum(["available", "unavailable"])
+  }),
+  connectionState: z3.enum(EXTERNAL_AGENT_CONNECTION_STATES),
+  authReadiness: z3.enum(EXTERNAL_AGENT_AUTH_READINESS),
+  grantState: z3.enum(EXTERNAL_AGENT_GRANT_STATES),
+  requestedModel: z3.string().min(1).max(128).optional(),
+  effectiveModel: z3.string().min(1).max(128).optional(),
+  task: managedTaskStatusSchema.optional(),
+  error: externalAgentErrorSchema.optional(),
+  updatedAt: isoTimestampSchema
+});
+var externalAgentControlStatusRequestSchema = z3.strictObject({});
+var externalAgentControlConnectRequestSchema = z3.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: z3.literal("codex"),
+  profile: z3.literal(EXTERNAL_AGENT_MANAGED_PROFILE)
+});
+var externalAgentControlDisconnectRequestSchema = z3.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: z3.literal("codex"),
+  revokeGrant: z3.boolean()
+});
+var externalAgentControlCancelRequestSchema = z3.strictObject({
+  requestId: requestIdSchema,
+  revision: z3.number().int().positive()
+});
+var externalAgentEventsRequestSchema = z3.strictObject({
+  afterSequence: z3.number().int().nonnegative().optional()
+});
+var externalAgentEventSchema = z3.discriminatedUnion("type", [
+  z3.strictObject({
+    type: z3.literal("status"),
+    data: externalAgentControlStatusSchema
+  }),
+  z3.strictObject({
+    type: z3.literal("heartbeat"),
+    sequence: z3.number().int().nonnegative(),
+    emittedAt: isoTimestampSchema
+  })
+]);
+var externalAgentResultRequestSchema = z3.strictObject({
+  revision: z3.number().int().positive()
+});
+var externalAgentManagedResultSchema = z3.strictObject({
+  revision: z3.number().int().positive(),
+  diff: z3.string().max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumResultDiffBytes),
+  files: z3.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: z3.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  validationOutcome: z3.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES),
+  expiresAt: isoTimestampSchema
+});
+
+// src/protocol/agent-schemas.ts
+import { z as z4 } from "zod";
+var profileIdSchema2 = z4.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (maximum) => z4.string().max(maximum);
+var errorCodeSchema = z4.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = z4.strictObject({
   providerProfileId: profileIdSchema2,
   providerLabel: boundedString(100),
   modelProfileId: profileIdSchema2,
   modelLabel: boundedString(100),
-  protocol: z3.enum(["responses", "chat-completions"]),
-  state: z3.enum(AGENT_CAPABILITY_STATES),
-  authenticated: z3.boolean(),
-  modelAvailable: z3.boolean(),
-  toolCalling: z3.boolean(),
-  toolResultContinuation: z3.boolean(),
-  streaming: z3.boolean(),
-  checkedAt: z3.iso.datetime().optional(),
+  protocol: z4.enum(["responses", "chat-completions"]),
+  state: z4.enum(AGENT_CAPABILITY_STATES),
+  authenticated: z4.boolean(),
+  modelAvailable: z4.boolean(),
+  toolCalling: z4.boolean(),
+  toolResultContinuation: z4.boolean(),
+  streaming: z4.boolean(),
+  checkedAt: z4.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = z3.strictObject({
-  state: z3.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: z3.iso.datetime(),
-  changes: z3.strictObject({
-    staged: z3.number().int().nonnegative(),
-    unstaged: z3.number().int().nonnegative(),
-    untracked: z3.number().int().nonnegative(),
-    conflicted: z3.number().int().nonnegative(),
-    total: z3.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = z4.strictObject({
+  state: z4.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: z4.iso.datetime(),
+  changes: z4.strictObject({
+    staged: z4.number().int().nonnegative(),
+    unstaged: z4.number().int().nonnegative(),
+    untracked: z4.number().int().nonnegative(),
+    conflicted: z4.number().int().nonnegative(),
+    total: z4.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: z3.boolean(),
+  canIncludeLocalChanges: z4.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -731,42 +963,42 @@ var agentWorkspaceHealthSnapshotSchema = z3.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = z3.strictObject({
+var agentChangedFileSchema = z4.strictObject({
   relativePath: boundedString(1024),
-  kind: z3.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: z3.number().int().nonnegative(),
-  deletions: z3.number().int().nonnegative()
+  kind: z4.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: z4.number().int().nonnegative(),
+  deletions: z4.number().int().nonnegative()
 });
-var agentCheckResultSchema = z3.strictObject({
+var agentCheckResultSchema = z4.strictObject({
   checkId: profileIdSchema2,
   label: boundedString(100),
-  status: z3.enum(AGENT_CHECK_STATUSES),
-  durationMs: z3.number().int().nonnegative(),
+  status: z4.enum(AGENT_CHECK_STATUSES),
+  durationMs: z4.number().int().nonnegative(),
   output: boundedString(8e4)
 });
-var agentJobSnapshotSchema = z3.strictObject({
-  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: z3.enum(AGENT_JOB_STATUSES),
+var agentJobSnapshotSchema = z4.strictObject({
+  jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: z4.enum(AGENT_JOB_STATUSES),
   providerProfileId: profileIdSchema2,
   providerLabel: boundedString(100),
   modelProfileId: profileIdSchema2,
   modelLabel: boundedString(100),
   phaseMessage: boundedString(1024),
-  createdAt: z3.iso.datetime(),
-  updatedAt: z3.iso.datetime(),
-  canCancel: z3.boolean(),
-  canApply: z3.boolean(),
-  canRevert: z3.boolean(),
+  createdAt: z4.iso.datetime(),
+  updatedAt: z4.iso.datetime(),
+  canCancel: z4.boolean(),
+  canApply: z4.boolean(),
+  canRevert: z4.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = z3.strictObject({
-  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = z4.strictObject({
+  jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString(8e4),
   diff: boundedString(1e6),
-  files: z3.array(agentChangedFileSchema).max(100),
-  checks: z3.array(agentCheckResultSchema).max(100)
+  files: z4.array(agentChangedFileSchema).max(100),
+  checks: z4.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = z3.strictObject({
+var agentJobResultResponseSchema = z4.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -778,44 +1010,44 @@ var agentJobResultResponseSchema = z3.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = z3.strictObject({
-  schemaVersion: z3.literal(2),
-  sequence: z3.number().int().positive(),
-  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: z3.enum(AGENT_JOB_STATUSES),
-  timestamp: z3.iso.datetime()
+var agentJobEventBaseSchema = z4.strictObject({
+  schemaVersion: z4.literal(2),
+  sequence: z4.number().int().positive(),
+  jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: z4.enum(AGENT_JOB_STATUSES),
+  timestamp: z4.iso.datetime()
 });
-var agentJobEventSchema = z3.discriminatedUnion("type", [
+var agentJobEventSchema = z4.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: z3.literal("snapshot"),
-    data: z3.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: z4.literal("snapshot"),
+    data: z4.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: z3.literal("phase"),
-    data: z3.strictObject({ message: boundedString(1024) })
+    type: z4.literal("phase"),
+    data: z4.strictObject({ message: boundedString(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: z3.literal("tool"),
-    data: z3.strictObject({
-      turn: z3.number().int().positive(),
+    type: z4.literal("tool"),
+    data: z4.strictObject({
+      turn: z4.number().int().positive(),
       toolCallId: boundedString(256),
       toolName: boundedString(100),
-      state: z3.enum(["started", "succeeded", "failed"]),
+      state: z4.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString(1024).optional(),
       checkLabel: boundedString(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: z3.literal("check"),
-    data: z3.strictObject({ result: agentCheckResultSchema })
+    type: z4.literal("check"),
+    data: z4.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: z3.literal("result-ready"),
-    data: z3.strictObject({ hasResult: z3.literal(true) })
+    type: z4.literal("result-ready"),
+    data: z4.strictObject({ hasResult: z4.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: z3.literal("error"),
-    data: z3.strictObject({
+    type: z4.literal("error"),
+    data: z4.strictObject({
       code: errorCodeSchema,
       message: boundedString(1024)
     })
@@ -868,6 +1100,22 @@ export {
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES,
   ERROR_CODE_VALUES,
+  EXTERNAL_AGENT_ACTIONS,
+  EXTERNAL_AGENT_AUTH_READINESS,
+  EXTERNAL_AGENT_CONNECTION_STATES,
+  EXTERNAL_AGENT_CONTROL_LIMITS,
+  EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+  EXTERNAL_AGENT_DELIVERY_STATUSES,
+  EXTERNAL_AGENT_ERROR_CODES,
+  EXTERNAL_AGENT_ERROR_RECOVERABILITY,
+  EXTERNAL_AGENT_ERROR_STAGES,
+  EXTERNAL_AGENT_EXECUTION_STATUSES,
+  EXTERNAL_AGENT_GRANT_STATES,
+  EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS,
+  EXTERNAL_AGENT_MANAGED_PHASES,
+  EXTERNAL_AGENT_MANAGED_PROFILE,
+  EXTERNAL_AGENT_MODES,
+  EXTERNAL_AGENT_VALIDATION_OUTCOMES,
   EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
   EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
   EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION,
@@ -909,6 +1157,16 @@ export {
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
   dispatchSummarySchema,
+  externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema,
+  externalAgentErrorSchema,
+  externalAgentEventSchema,
+  externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema,
   externalHandoffCapabilityRequestSchema,
   externalHandoffCapabilitySchema,
   externalHandoffPublishDeliverySchema,
@@ -925,6 +1183,10 @@ export {
   isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
+  managedCheckSummarySchema,
+  managedFileSummarySchema,
+  managedTaskStatusSchema,
+  managedTimingSummarySchema,
   networkObservationSchema,
   openEditorRequestSchema,
   pageDataFlowReportSchema,