@spotpatch/shared 1.13.0 → 1.14.1

package/dist/{external-agent-control-CRBbjDDk.d.ts → external-agent-control-DKxQACUv.d.ts}

@@ -16,6 +16,8 @@ declare const EXTERNAL_AGENT_ERROR_CODES: readonly ["AGENT_BINARY_NOT_FOUND", "A
 declare const EXTERNAL_AGENT_ACTIONS: readonly ["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"];
 declare const EXTERNAL_AGENT_MANAGED_PROFILE: "managed-apply-v1";
 declare const EXTERNAL_AGENT_CONTROL_LIMITS: Readonly<{
+    readonly maximumModels: 128;
+    readonly maximumModelCharacters: 128;
     readonly maximumEventSubscribers: 4;
     readonly eventHeartbeatMs: 15000;
     readonly eventReconnectMinimumMs: 500;
@@ -47,13 +49,13 @@ declare const externalAgentErrorSchema: z.ZodObject<{
         MANAGED_CLEANUP_INCOMPLETE: "MANAGED_CLEANUP_INCOMPLETE";
     }>;
     stage: z.ZodEnum<{
+        model: "model";
         snapshot: "snapshot";
         apply: "apply";
         binary: "binary";
         integration: "integration";
         handshake: "handshake";
         auth: "auth";
-        model: "model";
         protocol: "protocol";
         audit: "audit";
         validation: "validation";
@@ -201,6 +203,7 @@ declare const externalAgentControlStatusSchema: z.ZodObject<{
     }>;
     requestedModel: z.ZodOptional<z.ZodString>;
     effectiveModel: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     task: z.ZodOptional<z.ZodObject<{
         revision: z.ZodNumber;
         deliveryStatus: z.ZodEnum<{
@@ -282,13 +285,13 @@ declare const externalAgentControlStatusSchema: z.ZodObject<{
             MANAGED_CLEANUP_INCOMPLETE: "MANAGED_CLEANUP_INCOMPLETE";
         }>;
         stage: z.ZodEnum<{
+            model: "model";
             snapshot: "snapshot";
             apply: "apply";
             binary: "binary";
             integration: "integration";
             handshake: "handshake";
             auth: "auth";
-            model: "model";
             protocol: "protocol";
             audit: "audit";
             validation: "validation";
@@ -320,6 +323,7 @@ declare const externalAgentControlConnectRequestSchema: z.ZodObject<{
     requestId: z.ZodString;
     adapterKind: z.ZodLiteral<"codex">;
     profile: z.ZodLiteral<"managed-apply-v1">;
+    model: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 declare const externalAgentControlDisconnectRequestSchema: z.ZodObject<{
     requestId: z.ZodString;
@@ -376,6 +380,7 @@ declare const externalAgentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         requestedModel: z.ZodOptional<z.ZodString>;
         effectiveModel: z.ZodOptional<z.ZodString>;
+        models: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         task: z.ZodOptional<z.ZodObject<{
             revision: z.ZodNumber;
             deliveryStatus: z.ZodEnum<{
@@ -457,13 +462,13 @@ declare const externalAgentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 MANAGED_CLEANUP_INCOMPLETE: "MANAGED_CLEANUP_INCOMPLETE";
             }>;
             stage: z.ZodEnum<{
+                model: "model";
                 snapshot: "snapshot";
                 apply: "apply";
                 binary: "binary";
                 integration: "integration";
                 handshake: "handshake";
                 auth: "auth";
-                model: "model";
                 protocol: "protocol";
                 audit: "audit";
                 validation: "validation";

package/dist/external-agent-node.cjs

@@ -33,6 +33,7 @@ __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,
+  assertPrivateExternalHandoffPath: () => assertPrivateExternalHandoffPath,
   bridgeAckRequestSchema: () => bridgeAckRequestSchema,
   bridgeAckResultSchema: () => bridgeAckResultSchema,
   bridgeActiveClaimRequestSchema: () => bridgeActiveClaimRequestSchema,
@@ -52,13 +53,16 @@ __export(external_agent_node_exports, {
   bridgeWaitResultSchema: () => bridgeWaitResultSchema,
   computeExternalHandoffProjectKey: () => computeExternalHandoffProjectKey,
   externalHandoffDescriptorSchema: () => externalHandoffDescriptorSchema,
+  initializePrivateExternalHandoffFile: () => initializePrivateExternalHandoffFile,
   resolveExternalHandoffRuntimeDirectory: () => resolveExternalHandoffRuntimeDirectory
 });
 module.exports = __toCommonJS(external_agent_node_exports);
 var import_node_crypto = require("crypto");
+var import_node_child_process = require("child_process");
 var import_promises = require("fs/promises");
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
+var import_node_util = require("util");
 var import_zod4 = require("zod");
 
 // src/protocol/external-handoff.ts
@@ -148,7 +152,7 @@ var sourceRefSchema = import_zod.z.strictObject({
   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"]),
+  origin: import_zod.z.enum(["jsx-host", "astro-host", "react-fiber", "dom-ancestor", "none"]),
   confidence: import_zod.z.enum(["exact", "probable", "approximate", "unknown"])
 });
 var matchedStyleRuleSchema = import_zod.z.strictObject({
@@ -159,7 +163,7 @@ var matchedStyleRuleSchema = import_zod.z.strictObject({
 });
 var codeContextSchema = import_zod.z.strictObject({
   relativePath: boundedString(1024),
-  language: import_zod.z.enum(["tsx", "jsx"]),
+  language: import_zod.z.enum(["tsx", "jsx", "astro"]),
   startLine: import_zod.z.number().int().positive(),
   endLine: import_zod.z.number().int().positive(),
   excerpt: boundedString(16e3),
@@ -283,7 +287,11 @@ var EXTERNAL_HANDOFF_STATES = Object.freeze([
   "expired",
   "superseded"
 ]);
-var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze(["vite", "next"]);
+var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze([
+  "vite",
+  "next",
+  "astro"
+]);
 var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS = Object.freeze([
   "claude-channel",
   "codex-app-server"
@@ -534,6 +542,75 @@ var SPOTPATCH_BRIDGE_PATHS = Object.freeze({
   activeRelease: "/bridge/v1/active/release"
 });
 var EXTERNAL_HANDOFF_PROJECT_KEY_SALT = "spotpatch-external-agent-project-v1";
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var WINDOWS_ACL_SCRIPT = String.raw`
+$ErrorActionPreference = 'Stop'
+$target = $env:SPOTPATCH_ACL_TARGET
+$kind = $env:SPOTPATCH_ACL_KIND
+$operation = $env:SPOTPATCH_ACL_OPERATION
+$identity = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$allowed = @($identity.Value, 'S-1-5-18', 'S-1-5-32-544')
+if ($kind -eq 'directory') {
+  $item = [System.IO.DirectoryInfo]::new($target)
+  if ($operation -eq 'initialize') {
+    $security = [System.Security.AccessControl.DirectorySecurity]::new()
+    $security.SetOwner($identity)
+    foreach ($sidValue in $allowed) {
+      $sid = [System.Security.Principal.SecurityIdentifier]::new($sidValue)
+      $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+        $sid,
+        [System.Security.AccessControl.FileSystemRights]::FullControl,
+        [System.Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit',
+        [System.Security.AccessControl.PropagationFlags]::None,
+        [System.Security.AccessControl.AccessControlType]::Allow
+      )
+      [void]$security.AddAccessRule($rule)
+    }
+    $security.SetAccessRuleProtection($true, $false)
+    $item.SetAccessControl($security)
+  }
+  $acl = $item.GetAccessControl(
+    [System.Security.AccessControl.AccessControlSections]'Access, Owner'
+  )
+} elseif ($kind -eq 'file') {
+  $item = [System.IO.FileInfo]::new($target)
+  if ($operation -eq 'initialize') {
+    $security = [System.Security.AccessControl.FileSecurity]::new()
+    $security.SetOwner($identity)
+    foreach ($sidValue in $allowed) {
+      $sid = [System.Security.Principal.SecurityIdentifier]::new($sidValue)
+      $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+        $sid,
+        [System.Security.AccessControl.FileSystemRights]::FullControl,
+        [System.Security.AccessControl.AccessControlType]::Allow
+      )
+      [void]$security.AddAccessRule($rule)
+    }
+    $security.SetAccessRuleProtection($true, $false)
+    $item.SetAccessControl($security)
+  }
+  $acl = $item.GetAccessControl(
+    [System.Security.AccessControl.AccessControlSections]'Access, Owner'
+  )
+} else {
+  exit 10
+}
+if ($acl.GetOwner([System.Security.Principal.SecurityIdentifier]).Value -ne $identity.Value) {
+  exit 11
+}
+foreach ($rule in $acl.GetAccessRules(
+  $true,
+  $true,
+  [System.Security.Principal.SecurityIdentifier]
+)) {
+  if (
+    $rule.AccessControlType -eq [System.Security.AccessControl.AccessControlType]::Allow -and
+    $allowed -notcontains $rule.IdentityReference.Value
+  ) {
+    exit 12
+  }
+}
+`;
 var opaqueIdSchema2 = import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
 var projectKeySchema = import_zod4.z.string().length(64).regex(/^[a-f0-9]+$/u);
 var loopbackEndpointSchema = import_zod4.z.url().refine((value) => {
@@ -613,46 +690,121 @@ var bridgeActiveStateResultSchema = import_zod4.z.strictObject({
 var bridgeActiveHeartbeatResultSchema = bridgeActiveStateResultSchema;
 var bridgeActiveReportResultSchema = bridgeActiveStateResultSchema;
 var bridgeActiveReleaseResultSchema = bridgeActiveStateResultSchema;
-function currentUid() {
-  const uid = process.getuid?.();
-  if (uid === void 0) {
+function windowsPowerShellExecutable() {
+  const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
+  if (systemRoot === void 0 || !import_node_path.default.win32.isAbsolute(systemRoot)) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
-  return uid;
+  return import_node_path.default.win32.join(
+    systemRoot,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe"
+  );
 }
-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) {
+async function verifyWindowsAcl(candidate, kind, initialize) {
+  try {
+    await execFileAsync(
+      windowsPowerShellExecutable(),
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", WINDOWS_ACL_SCRIPT],
+      {
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          SPOTPATCH_ACL_KIND: kind,
+          SPOTPATCH_ACL_OPERATION: initialize ? "initialize" : "verify",
+          SPOTPATCH_ACL_TARGET: candidate
+        },
+        timeout: 1e4,
+        windowsHide: true
+      }
+    );
+  } catch (error) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED, void 0, {
+      cause: error
+    });
+  }
+}
+async function assertPrivateExternalHandoffPath(candidate, kind) {
+  const status = await (0, import_promises.lstat)(candidate);
+  const correctKind = kind === "directory" ? status.isDirectory() : status.isFile();
+  if (!correctKind || status.isSymbolicLink()) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
+  if (process.platform === "win32") {
+    await verifyWindowsAcl(candidate, kind, false);
+    return status;
+  }
+  const uid = process.getuid?.();
+  if (uid === void 0 || status.uid !== uid || (status.mode & 63) !== 0) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
+  return status;
 }
-async function ensurePrivateSubdirectory(base, uid, create) {
+async function initializePrivateExternalHandoffFile(candidate) {
+  if (process.platform === "win32") {
+    await verifyWindowsAcl(candidate, "file", true);
+  }
+}
+async function initializeWindowsDirectory(directory) {
+  if (process.platform === "win32") {
+    await verifyWindowsAcl(directory, "directory", true);
+  }
+}
+async function ensurePrivateSubdirectory(base, create) {
   const directory = import_node_path.default.join(base, "spotpatch");
+  let created = false;
   if (create) {
     try {
       await (0, import_promises.mkdir)(directory, { mode: 448 });
+      created = true;
     } catch (error) {
       if (error.code !== "EEXIST") {
         throw error;
       }
     }
   }
-  await assertPrivateDirectory(directory, uid);
-  return directory;
+  if (created) await initializeWindowsDirectory(directory);
+  await assertPrivateExternalHandoffPath(directory, "directory");
+  return (0, import_promises.realpath)(directory);
 }
-async function resolveExternalHandoffRuntimeDirectory(create) {
-  if (process.platform === "win32") {
+async function resolveWindowsRuntimeDirectory(create) {
+  const configuredBase = process.env.LOCALAPPDATA;
+  if (configuredBase !== void 0 && !import_node_path.default.isAbsolute(configuredBase)) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
-  const uid = currentUid();
+  const base = configuredBase ?? import_node_path.default.join(import_node_os.default.homedir(), "AppData", "Local");
+  const directory = import_node_path.default.join(base, "SpotPatch", "external-agent-runtime-v1");
+  let created = false;
+  if (create) {
+    created = await (0, import_promises.mkdir)(directory, { mode: 448, recursive: true }) !== void 0;
+  }
+  if (created) await initializeWindowsDirectory(directory);
+  await assertPrivateExternalHandoffPath(directory, "directory");
+  return (0, import_promises.realpath)(directory);
+}
+async function resolveExternalHandoffRuntimeDirectory(create) {
   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);
+      if (process.platform !== "win32") {
+        await assertPrivateExternalHandoffPath(xdgRuntimeDirectory, "directory");
+      }
+      return await ensurePrivateSubdirectory(xdgRuntimeDirectory, create);
+    } catch (error) {
+      if (!create && error.code === "ENOENT") {
+        throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
+      }
+      throw error;
+    }
+  }
+  if (process.platform === "win32") {
+    try {
+      return await resolveWindowsRuntimeDirectory(create);
     } catch (error) {
       if (!create && error.code === "ENOENT") {
         throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
@@ -660,6 +812,10 @@ async function resolveExternalHandoffRuntimeDirectory(create) {
       throw error;
     }
   }
+  const uid = process.getuid?.();
+  if (uid === void 0) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
   const fallback = import_node_path.default.join(import_node_os.default.tmpdir(), `spotpatch-${String(uid)}`);
   if (create) {
     try {
@@ -671,14 +827,14 @@ async function resolveExternalHandoffRuntimeDirectory(create) {
     }
   }
   try {
-    await assertPrivateDirectory(fallback, uid);
+    await assertPrivateExternalHandoffPath(fallback, "directory");
   } catch (error) {
     if (!create && error.code === "ENOENT") {
       throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
     }
     throw error;
   }
-  return fallback;
+  return (0, import_promises.realpath)(fallback);
 }
 async function computeExternalHandoffProjectKey(root) {
   const canonicalRoot = await (0, import_promises.realpath)(root);
@@ -689,6 +845,7 @@ async function computeExternalHandoffProjectKey(root) {
   EXTERNAL_HANDOFF_PROJECT_KEY_SALT,
   SPOTPATCH_BRIDGE_PATHS,
   SPOTPATCH_BRIDGE_TOKEN_HEADER,
+  assertPrivateExternalHandoffPath,
   bridgeAckRequestSchema,
   bridgeAckResultSchema,
   bridgeActiveClaimRequestSchema,
@@ -708,6 +865,7 @@ async function computeExternalHandoffProjectKey(root) {
   bridgeWaitResultSchema,
   computeExternalHandoffProjectKey,
   externalHandoffDescriptorSchema,
+  initializePrivateExternalHandoffFile,
   resolveExternalHandoffRuntimeDirectory
 });
 //# sourceMappingURL=external-agent-node.cjs.map