@standardagents/builder 0.37.8 → 0.38.1

package/dist/plugin.js

@@ -689,6 +689,27 @@ declare module 'virtual:@standardagents/builder' {
     validateSession(tokenHash: string): Promise<{ user_id: string; expires_at: number } | null>;
     cleanupSessions(): Promise<number>;
     deleteSession(tokenHash: string): Promise<void>;
+    createSuperAdminSession(params: {
+      token_hash: string;
+      expires_at: number;
+    }): Promise<void>;
+    validateSuperAdminSession(tokenHash: string): Promise<boolean>;
+    deleteSuperAdminSession(tokenHash: string): Promise<void>;
+    createWebSocketTicket(params: {
+      ticket_hash: string;
+      pathname: string;
+      auth_json: string;
+      expires_at: number;
+    }): Promise<void>;
+    consumeWebSocketTicket(params: {
+      ticket_hash: string;
+      pathname: string;
+    }): Promise<string | null>;
+    consumeAuthRateLimit(params: {
+      key: string;
+      limit: number;
+      window_seconds: number;
+    }): Promise<{ allowed: boolean; retry_after: number; remaining: number }>;
 
     // API key methods
     createApiKey(params: {
@@ -1289,6 +1310,7 @@ function resolveLocalBootstrapCookie(projectRoot, routePath, cookieHeader) {
   if (hasSessionCookie(cookieHeader)) return null;
   return findLocalBootstrapSession(projectRoot)?.session.session_cookie ?? null;
 }
+var SESSION_COOKIE_NAME = "agtuser_session";
 
 // src/sdk/generators/generateModelFile.ts
 function generateModelFile(data, options) {
@@ -1355,7 +1377,7 @@ function generateModelFile(data, options) {
   return lines.join("\n");
 }
 function escapeString(str) {
-  return str.replace(/'/g, "\\'").replace(/\\/g, "\\\\");
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
 
 // src/sdk/generators/jsonSchemaToZod.ts
@@ -1886,7 +1908,7 @@ function formatSideConfig(config) {
   return parts.join("\n");
 }
 function escapeString3(str) {
-  return str.replace(/'/g, "\\'").replace(/\\/g, "\\\\");
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
 function formatSessionBinding(binding) {
   if (typeof binding === "string") {
@@ -6695,7 +6717,7 @@ function isProviderIconRoute(routePath) {
   return /^\/api\/providers\/[^/]+\/icon$/.test(routePath);
 }
 function isHostedInstance(env) {
-  const value = env?.STANDARD_AGENTS_HOSTED;
+  const value = env && typeof env === "object" ? Reflect.get(env, "STANDARD_AGENTS_HOSTED") : void 0;
   if (typeof value === "string") {
     const normalized = value.trim().toLowerCase();
     return normalized !== "" && normalized !== "0" && normalized !== "false";
@@ -6713,6 +6735,7 @@ function isTrustedLocalDevelopmentRequest(request, env) {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local");
 }
 function isAdminOnlyApiRoute(routePath, method = "GET") {
+  if (routePath === "/api/hooks") return true;
   if (routePath === "/api/skills" || routePath.startsWith("/api/skills/")) return true;
   if (routePath === "/api/pack" || routePath.startsWith("/api/pack/")) return true;
   if (routePath === "/api/unpack" || routePath.startsWith("/api/unpack/")) return true;
@@ -6731,6 +6754,9 @@ function isAdminOnlyApiRoute(routePath, method = "GET") {
 }
 
 // src/plugin/dev-middleware.ts
+function isEncryptedSocket(socket) {
+  return "encrypted" in socket && socket.encrypted === true;
+}
 function readRawRequestBody(req) {
   return new Promise((resolve3, reject) => {
     const chunks = [];
@@ -6755,6 +6781,36 @@ function resolveContainedFile(baseDir, requestPath) {
     return null;
   }
 }
+function firstHeader(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function isSameOriginDevRequest(req) {
+  const fetchSite = firstHeader(req.headers["sec-fetch-site"])?.trim().toLowerCase();
+  if (fetchSite && fetchSite !== "same-origin" && fetchSite !== "none") {
+    return false;
+  }
+  const origin = firstHeader(req.headers.origin)?.trim();
+  if (!origin) return true;
+  if (origin === "null") return false;
+  try {
+    const forwardedProtocol = firstHeader(req.headers["x-forwarded-proto"])?.split(",")[0]?.trim().toLowerCase();
+    const protocol = forwardedProtocol === "https" || forwardedProtocol === "http" ? forwardedProtocol : isEncryptedSocket(req.socket) ? "https" : "http";
+    const requestOrigin = new URL(`${protocol}://${String(req.headers.host || "").trim()}`).origin;
+    return new URL(origin).origin === requestOrigin;
+  } catch {
+    return false;
+  }
+}
+function hasDevAuthoringCredential(req) {
+  const cookie = firstHeader(req.headers.cookie) || "";
+  const hasSession = cookie.split(";").some((part) => {
+    const separator = part.indexOf("=");
+    return separator !== -1 && part.slice(0, separator).trim() === SESSION_COOKIE_NAME && part.slice(separator + 1).trim() !== "";
+  });
+  if (hasSession) return true;
+  const authorization = firstHeader(req.headers.authorization)?.trim() || "";
+  return /^Bearer\s+\S+$/.test(authorization);
+}
 function injectUiConfigIntoHtml(htmlContent) {
   const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { devMode: true };</script>`;
   return htmlContent.replace(/\/agents\//g, "/").replace("</head>", `${configScript}</head>`);
@@ -6809,11 +6865,21 @@ function createDevMiddleware(server, context) {
       );
     } catch {
     }
-    if (isAdminOnlyApiRoute(routePath, method) && !trustedLocalHost) {
-      res.statusCode = 403;
-      res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({ error: "Authoring APIs are available only from local development hosts" }));
-      return;
+    if (isAdminOnlyApiRoute(routePath, method)) {
+      if (!trustedLocalHost || !isSameOriginDevRequest(req)) {
+        res.statusCode = 403;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(JSON.stringify({ error: "Authoring APIs require a same-origin local request" }));
+        return;
+      }
+      if (!hasDevAuthoringCredential(req)) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(JSON.stringify({ error: "Authoring APIs require an authenticated local session" }));
+        return;
+      }
     }
     if (await handleConfigApiRequest({
       req,
@@ -7462,14 +7528,21 @@ import { prompts, promptNames } from "virtual:@standardagents-prompts";
 import { agents, agentNames } from "virtual:@standardagents-agents";
 import { registry } from "virtual:@standardagents-registry";
 import {
+  authenticate,
   requireAuth,
   createThreadEndpointHandler,
   canAccessThread,
+  endpointCallerFromAuth,
   isHostedInstance,
+  isTrustedLocalDevelopmentRequest,
+  isSameOriginBrowserRequest,
   isPublicApiRoute,
   isAdminOnlyApiRoute,
+  applyRuntimeCors,
+  runtimeCorsHeaders,
+  runtimePreflightResponse,
 } from "@standardagents/builder/runtime";
-import { isThreadEndpoint } from "@standardagents/spec";
+import { isThreadEndpoint, getEndpointAccess } from "@standardagents/spec";
 
 function platformEndpoint(env) {
   const configured =
@@ -7524,71 +7597,34 @@ function isHtmlNavigationRequest(request) {
   return (accept === '' || accept === '*/*') && isUiNavigationPath(pathname);
 }
 
-// CORS headers for API responses
-const CORS_HEADERS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With",
-  "Access-Control-Max-Age": "86400",
-};
-
 // Helper to create headers with CORS
-function corsHeaders(contentType) {
+function corsHeaders(contentType, request, env) {
   return {
     "Content-Type": contentType,
-    ...CORS_HEADERS,
+    ...runtimeCorsHeaders(request, env),
   };
 }
 
-// Helper to add CORS headers to any Response without touching the body
-function addCorsHeaders(response) {
-  // Skip WebSocket upgrade responses - they can't be wrapped
-  if (response.status === 101) {
-    return response;
-  }
-
-  // Skip if already has CORS headers
-  if (response.headers.has("Access-Control-Allow-Origin")) {
-    return response;
-  }
-
-  // Prefer mutating the original Response headers. Rebuilding a Response from
-  // response.headers can drop special headers such as Set-Cookie in Worker
-  // runtimes, even when the header is not visible through Headers.has().
-  try {
-    for (const [key, value] of Object.entries(CORS_HEADERS)) {
-      response.headers.set(key, value);
-    }
-    return response;
-  } catch {
-    // Some Responses, especially fetched upstream responses, have immutable
-    // headers. Fall back to wrapping those responses.
-  }
-
-  // Create new headers with CORS added
-  const newHeaders = new Headers(response.headers);
-  for (const [key, value] of Object.entries(CORS_HEADERS)) {
-    newHeaders.set(key, value);
-  }
-
-  // Return new Response with same body stream (not cloned, just transferred)
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: newHeaders,
-  });
-}
-
 export async function router(request, env) {
   const url = new URL(request.url);
   const pathname = url.pathname;
 
   // Handle CORS preflight requests
   if (request.method === "OPTIONS") {
-    return new Response(null, {
-      status: 204,
-      headers: CORS_HEADERS,
-    });
+    return runtimePreflightResponse(request, env);
+  }
+
+  // WebSockets do not use CORS. Reject foreign browser provenance before
+  // route dispatch so a malicious page cannot open a local stream/bridge even
+  // if a browser were to attach ambient cookies to the handshake.
+  if (
+    isTrustedLocalDevelopmentRequest(request, env) &&
+    !isSameOriginBrowserRequest(request)
+  ) {
+    return Response.json(
+      { error: "Cross-origin access is disabled for local development" },
+      { status: 403, headers: { "Cache-Control": "no-store" } }
+    );
   }
 
   const routePath = pathname || "/";
@@ -7612,8 +7648,16 @@ ${packedThreadRouteCode}
   );
 
   if (routeMatch) {
+    let controller = await routeMatch.data();
+
+    // Endpoint-declared access (spec: EndpointAccess). A 'public' declaration
+    // opts that one endpoint out of the router's authentication gate; the
+    // handler still receives the resolved caller identity when the request
+    // presents verifiable credentials.
+    const declaredPublic = getEndpointAccess(controller) === 'public';
+
     // Check if authentication is required for this route
-    const publicRoute = isPublicApiRoute(routePath, request, env);
+    const publicRoute = declaredPublic || isPublicApiRoute(routePath, request, env);
     const isApiRoute = routePath.startsWith('/api/');
 
     let authContext = null;
@@ -7628,13 +7672,13 @@ ${packedThreadRouteCode}
 
       // If requireAuth returns a Response, it's an error (401)
       if (authResult instanceof Response) {
-        return addCorsHeaders(authResult);
+        return applyRuntimeCors(authResult, request, env);
       }
 
       authContext = authResult;
 
       if (isAdminOnlyApiRoute(routePath, request.method) && authContext.user.role !== 'admin') {
-        return addCorsHeaders(Response.json({ error: 'Forbidden: Admin access required' }, { status: 403 }));
+        return applyRuntimeCors(Response.json({ error: 'Forbidden: Admin access required' }, { status: 403 }), request, env);
       }
 
       if (routePath.startsWith('/api/threads/')) {
@@ -7648,18 +7692,32 @@ ${packedThreadRouteCode}
           const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
           const thread = await agentBuilder.getThread(threadId);
           if (!thread) {
-            return addCorsHeaders(Response.json({ error: \`Thread not found: \${threadId}\` }, { status: 404 }));
+            return applyRuntimeCors(Response.json({ error: \`Thread not found: \${threadId}\` }, { status: 404 }), request, env);
           }
           if (!canAccessThread(authContext, thread)) {
-            return addCorsHeaders(Response.json({ error: "Forbidden: You don't have access to this thread" }, { status: 403 }));
+            return applyRuntimeCors(Response.json({ error: "Forbidden: You don't have access to this thread" }, { status: 403 }), request, env);
           }
           threadAccess = { threadId, thread };
         }
       }
+    } else if (isApiRoute && declaredPublic) {
+      // Optional caller resolution for endpoint-declared public routes:
+      // verifiable credentials attribute the request, anything else stays
+      // anonymous instead of being rejected (spec ThreadEndpointAuth).
+      authContext = await authenticate(request, env);
+      if (authContext && routePath.startsWith('/api/threads/')) {
+        const threadId = routeMatch.params?.threadId || routeMatch.params?.id;
+        if (threadId) {
+          const agentBuilderId = env.AGENT_BUILDER.idFromName('singleton');
+          const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+          const thread = await agentBuilder.getThread(threadId);
+          if (thread && canAccessThread(authContext, thread)) {
+            threadAccess = { threadId, thread };
+          }
+        }
+      }
     }
 
-    let controller = await routeMatch.data();
-
     // Check if this is a thread endpoint (marked by defineThreadEndpoint)
     // If so, wrap it with createThreadEndpointHandler to provide ThreadState
     if (isThreadEndpoint(controller)) {
@@ -7674,21 +7732,22 @@ ${packedThreadRouteCode}
       config,
       tools,
       auth: authContext, // Add auth context to controller context
+      caller: endpointCallerFromAuth(authContext), // Spec ControllerContext.caller
       threadAccess, // Router's thread authorization, bound to the exact id
     };
     const result = await controller(context);
 
     if (result instanceof Response) {
-      return addCorsHeaders(result);
+      return applyRuntimeCors(result, request, env);
     }
     if (typeof result === "string") {
       return new Response(result, {
-        headers: corsHeaders("text/plain"),
+        headers: corsHeaders("text/plain", request, env),
       });
     }
     // JSON responses get CORS headers
     return new Response(JSON.stringify(result), {
-      headers: corsHeaders("application/json"),
+      headers: corsHeaders("application/json", request, env),
     });
   }