agent-relay-server 0.119.0 → 0.119.1

package/src/server.ts

@@ -0,0 +1,433 @@
+import type { ServerWebSocket } from "bun";
+import { initDb, getOrchestrator } from "./db";
+import { matchRoute } from "./routes";
+import { emitNewMessage, emitTaskChanged } from "./sse";
+import { busHandleClose, busHandleMessage, busHandleOpen, handleBusUpgrade } from "./bus";
+import { emitRelayEvent } from "./events";
+import { reconcileAutomationRuns, runDueAutomations, type AutomationDispatchResult, type AutomationReconcileResult } from "./automations";
+import { getLifecycleManager } from "./lifecycle-manager";
+import { getCompactionWatch } from "./compaction-watch";
+import { getConfig, setConfig } from "./config-store";
+import { startConnectorStatusPoller } from "./connectors";
+import { installNotificationSubscriptionRule } from "./notification-subscription-rules";
+import { installQuotaAdvisoryHandler } from "./quota-advisory";
+import { startPlanLiveBindings } from "./services/plan-live-bindings";
+import { startRelayScheduler } from "./services/scheduler";
+import { recordWorkspaceIssueActivity } from "./services/spawn-issue-activity";
+import { onWorkspaceCreate } from "./db";
+import { resolve, sep } from "path";
+import { gzipSync, brotliCompressSync, constants as zlibConstants } from "node:zlib";
+import {
+  AUTOMATION_INTERVAL_MS,
+  IDLE_TIMEOUT_SECONDS,
+  LOG_REQUESTS,
+  VERSION,
+  relayToken,
+} from "./config";
+import { CONTRACT_VERSIONS } from "./contracts";
+import {
+  applyCors,
+  assertSafeNetworkConfig,
+  corsPreflight,
+  forbidden,
+  getComponentAuth,
+  getIntegrationAuth,
+  isAuthorized,
+  isScopedRequestAuthorized,
+  isOriginAllowed,
+  isRequestAuthorizedFor,
+  unauthorized,
+} from "./security";
+import { startMaintenanceScheduler } from "./maintenance";
+import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+
+// Restart-on-update gating (issue #341).
+//
+// A `restartOnUpdate` policy should cycle its managed agent only when the agent's
+// running runner code is now protocol-INCOMPATIBLE with the relay — i.e. on a
+// runner-protocol bump — NOT on every package version change. Gating on the package
+// version churned the always-on Telegram agent ~12×/day (one restart per patch
+// redeploy), dropping in-flight work (surfaced #340). The runner protocol
+// (CONTRACT_VERSIONS.runnerProtocol) only moves on a breaking runner change, so this
+// fires ~never during normal releases.
+//
+// `relay-version` is still tracked for observability/telemetry, but it no longer
+// triggers restarts.
+export function reconcileRelayVersion(): void {
+  const storedVersion = getConfig<string>("system", "relay-version")?.value;
+  if (storedVersion !== VERSION) setConfig("system", "relay-version", VERSION, "server-startup");
+
+  const storedProtocol = getConfig<string>("system", "runner-protocol-version")?.value;
+  const currentProtocol = String(CONTRACT_VERSIONS.runnerProtocol);
+  if (storedProtocol === currentProtocol) return;
+  // Skip the very first run (no stored protocol yet) — that's initial bootstrap, not an upgrade.
+  if (storedProtocol) getLifecycleManager().onRelayUpdated(VERSION);
+  setConfig("system", "runner-protocol-version", currentProtocol, "server-startup");
+}
+
+export function startServer(): void {
+  const PORT = Number(process.env.PORT) || 4850;
+  const HOST = process.env.HOST || "127.0.0.1";
+  const DB_PATH = process.env.DB_PATH || "agent-relay.db";
+
+  assertSafeNetworkConfig(HOST);
+  initDb(DB_PATH);
+  onWorkspaceCreate(recordWorkspaceIssueActivity);
+  installQuotaAdvisoryHandler();
+  installNotificationSubscriptionRule();
+  startPlanLiveBindings();
+  getLifecycleManager().start();
+  getCompactionWatch().start();
+  reconcileRelayVersion();
+  startConnectorStatusPoller();
+  startMaintenanceScheduler();
+  startRelayScheduler();
+
+  setInterval(() => {
+    emitAutomationReconciliations(reconcileAutomationRuns());
+    emitAutomationDispatches(runDueAutomations());
+  }, AUTOMATION_INTERVAL_MS);
+
+  Bun.serve<RelaySocketData>({
+    port: PORT,
+    hostname: HOST,
+    idleTimeout: IDLE_TIMEOUT_SECONDS,
+    fetch: createFetchHandler({ publicDir: process.env.PUBLIC_DIR, logRequests: LOG_REQUESTS }),
+    websocket: {
+      open(ws) {
+        if (ws.data?.kind === "terminal-proxy") return openTerminalProxy(ws as TerminalProxySocket);
+        return busHandleOpen(ws as any);
+      },
+      message(ws, data) {
+        if (ws.data?.kind === "terminal-proxy") return sendTerminalProxyFrame(ws as TerminalProxySocket, data);
+        return busHandleMessage(ws as any, data);
+      },
+      close(ws) {
+        if (ws.data?.kind === "terminal-proxy") return closeTerminalProxy(ws as TerminalProxySocket);
+        return busHandleClose(ws as any);
+      },
+    },
+  });
+
+  console.log(`agent-relay ${VERSION} running on http://${HOST}:${PORT}`);
+}
+
+interface TerminalProxySocketData {
+  kind: "terminal-proxy";
+  upstreamUrl: string;
+  upstreamToken?: string;
+  upstream?: WebSocket;
+  pending: Array<string | Buffer>;
+}
+
+type RelaySocketData = {
+  kind: "bus";
+  id: string;
+  componentScopes?: string[];
+} | TerminalProxySocketData;
+
+type TerminalProxySocket = ServerWebSocket<TerminalProxySocketData>;
+
+function emitAutomationDispatches(results: AutomationDispatchResult[]): void {
+  for (const result of results) {
+    if (result.command) emitAutomationCommand(result.command);
+    if (result.message) emitNewMessage(result.message);
+    if (result.task) emitTaskChanged(result.task, "task.created");
+    emitRelayEvent({
+      type: "automation.run",
+      source: "server",
+      subject: result.run.id,
+      data: { automation: result.automation, run: result.run, task: result.task },
+    });
+  }
+}
+
+function emitAutomationReconciliations(results: AutomationReconcileResult[]): void {
+  for (const result of results) {
+    if (result.command) emitAutomationCommand(result.command);
+    if (result.message) emitNewMessage(result.message);
+    if (result.task) emitTaskChanged(result.task, "task.updated");
+    emitRelayEvent({
+      type: "automation.run",
+      source: "server",
+      subject: result.run.id,
+      data: { run: result.run, task: result.task },
+    });
+  }
+}
+
+function emitAutomationCommand(command: { id: string; source: string; status: string }): void {
+  emitRelayEvent({
+    type: command.status === "pending" ? "command.requested" : `command.${command.status}`,
+    source: command.source,
+    subject: command.id,
+    data: { command },
+  });
+}
+
+function openTerminalProxy(ws: TerminalProxySocket): void {
+  const token = ws.data.upstreamToken;
+  // Bun's client WebSocket accepts a `headers` option (non-standard; absent from DOM types).
+  const upstream = token
+    ? new WebSocket(ws.data.upstreamUrl, { headers: { [RELAY_TOKEN_HEADER]: token } } as unknown as string[])
+    : new WebSocket(ws.data.upstreamUrl);
+  ws.data.upstream = upstream;
+
+  upstream.onopen = () => {
+    const pending = ws.data.pending.splice(0);
+    for (const frame of pending) upstream.send(frame);
+  };
+  upstream.onmessage = (event) => {
+    if (typeof event.data === "string" || event.data instanceof Buffer) {
+      ws.send(event.data);
+    } else if (event.data instanceof ArrayBuffer) {
+      ws.send(event.data);
+    } else if (event.data instanceof Blob) {
+      void event.data.arrayBuffer().then((buffer) => ws.send(buffer)).catch(() => {});
+    }
+  };
+  upstream.onerror = () => {
+    ws.send(JSON.stringify({ type: "error", error: "terminal stream upstream error" }));
+  };
+  upstream.onclose = () => {
+    ws.close();
+  };
+}
+
+function sendTerminalProxyFrame(ws: TerminalProxySocket, data: string | Buffer): void {
+  const upstream = ws.data.upstream;
+  if (!upstream || upstream.readyState === WebSocket.CONNECTING) {
+    ws.data.pending.push(data);
+    return;
+  }
+  if (upstream.readyState !== WebSocket.OPEN) return;
+  upstream.send(data);
+}
+
+function closeTerminalProxy(ws: TerminalProxySocket): void {
+  const upstream = ws.data.upstream;
+  ws.data.pending = [];
+  if (upstream && upstream.readyState === WebSocket.OPEN) upstream.close();
+}
+
+export function createFetchHandler(
+  opts: { publicDir?: string; logRequests?: boolean } = {},
+): {
+  (req: Request): Promise<Response>;
+  (req: Request, server: Bun.Server<RelaySocketData>): Promise<Response | undefined>;
+} {
+  const publicDir = resolve(opts.publicDir ?? resolve(import.meta.dir, "../public"));
+  const publicDirPrefix = publicDir + sep;
+  const logRequests = opts.logRequests ?? false;
+
+  return async function fetch(req: Request, server?: Bun.Server<RelaySocketData>): Promise<Response | undefined> {
+    const url = new URL(req.url);
+
+    if (url.pathname === "/bus") {
+      if (!server) return new Response("WebSocket upgrade unavailable", { status: 400 });
+      return handleBusUpgrade(req, server);
+    }
+
+    const terminalStreamMatch = url.pathname.match(/^\/api\/orchestrators\/([^/]+)\/terminal\/([^/]+)\/stream$/);
+    if (req.method === "GET" && terminalStreamMatch) {
+      if (!server) return new Response("WebSocket upgrade unavailable", { status: 400 });
+      if (!isOriginAllowed(req)) return Response.json({ error: "origin not allowed" }, { status: 403 });
+      if (!isAuthorized(req)) return unauthorized(req);
+      const orchestratorId = decodeURIComponent(terminalStreamMatch[1]!);
+      const session = decodeURIComponent(terminalStreamMatch[2]!);
+      if (!isRequestAuthorizedFor(req, { scope: "terminal:attach", resource: { orchestratorId, terminalAttach: true } })) {
+        return forbidden(req);
+      }
+      const orch = getOrchestrator(orchestratorId);
+      if (!orch) return Response.json({ error: "orchestrator not found" }, { status: 404 });
+      if (!orch.apiUrl) return Response.json({ error: "orchestrator does not expose an API" }, { status: 422 });
+      if (orch.status !== "online") return Response.json({ error: "orchestrator is offline" }, { status: 422 });
+      const upstream = new URL(`/api/terminal/${encodeURIComponent(session)}/stream`, orch.apiUrl);
+      upstream.protocol = upstream.protocol === "https:" ? "wss:" : "ws:";
+      // Pass the relay token as a header (not a query param) so it never lands in
+      // access/proxy logs (#149). The orchestrator accepts both, but headers are safer.
+      const token = relayToken();
+      const upgraded = server.upgrade(req, {
+        data: { kind: "terminal-proxy", upstreamUrl: upstream.toString(), upstreamToken: token, pending: [] },
+      });
+      if (!upgraded) return new Response("WebSocket upgrade failed", { status: 400 });
+      return undefined;
+    }
+
+    if (req.method === "OPTIONS") {
+      return corsPreflight(req);
+    }
+    if (!isOriginAllowed(req)) {
+      return Response.json({ error: "origin not allowed" }, { status: 403 });
+    }
+
+    // API routes
+    const matched = matchRoute(req.method, url.pathname);
+    if (matched) {
+      const publicPaths = ["/api/spec", "/api/docs", "/api/health"];
+      // Pre-auth allowlist (#389): the auth endpoints must be reachable unauthenticated — they ARE
+      // the way a session is obtained. Each handler self-authenticates (login verifies credentials,
+      // refresh validates the refresh token, logout revokes the presented token). Everything else
+      // still flows through the component-token gate below.
+      const publicAuthPaths = ["/api/auth/providers", "/api/auth/login", "/api/auth/refresh", "/api/auth/logout"];
+      if (!publicPaths.includes(url.pathname) && !publicAuthPaths.includes(url.pathname)) {
+        const integrationAuth = getIntegrationAuth(req);
+        const componentAuth = getComponentAuth(req);
+        const handlerOwnsScopedAuth = url.pathname === "/api/tokens/me" ||
+          url.pathname === "/api/settings" ||
+          url.pathname.startsWith("/api/settings/");
+        if (!isAuthorized(req)) {
+          if (!integrationAuth) {
+            return unauthorized(req);
+          }
+          if (!handlerOwnsScopedAuth && !isScopedRequestAuthorized(req)) return forbidden(req);
+        }
+        if (componentAuth && !handlerOwnsScopedAuth && !isScopedRequestAuthorized(req)) return forbidden(req);
+      }
+      const response = await matched.handler(req, matched.params);
+      applyCors(req, response);
+      if (logRequests && url.pathname.startsWith("/api/")) {
+        console.log(`${req.method} ${url.pathname} → ${response.status}`);
+      }
+      return response;
+    }
+
+    // Dashboard — serve static files, rejecting path traversal and directory requests
+    let requested = url.pathname === "/" ? "/index.html" : url.pathname;
+    if (requested.endsWith("/")) requested += "index.html";
+    const resolved = resolve(publicDir, `.${requested}`);
+    if (!resolved.startsWith(publicDirPrefix)) {
+      return Response.json({ error: "not found" }, { status: 404 });
+    }
+    const file = Bun.file(resolved);
+    if (await file.exists()) {
+      return await serveStaticFile(req, resolved, requested, file);
+    }
+
+    return Response.json({ error: "not found" }, { status: 404 });
+  } as {
+    (req: Request): Promise<Response>;
+    (req: Request, server: Bun.Server<RelaySocketData>): Promise<Response | undefined>;
+  };
+}
+
+// In-memory compressed-variant cache, keyed by absolute path. Invalidated when
+// the file's mtime/size changes, so a rebuilt bundle is recompressed on next
+// request. The dashboard ships as a minified, code-split bundle (#200/#201);
+// brotli/gzip on top cuts the wire size further, which is the dominant cost over
+// high-latency links. Hashed /assets/* chunks are also served immutable so
+// repeat visits skip them entirely (see staticHeaders).
+type CompressedVariant = { body: Uint8Array; encoding: "br" | "gzip" };
+const compressedCache = new Map<
+  string,
+  { mtimeMs: number; size: number; br?: Uint8Array; gzip?: Uint8Array }
+>();
+
+const COMPRESSIBLE = /\.(html|js|css|svg|json|webmanifest|map)$/;
+
+function isCompressible(pathname: string): boolean {
+  return pathname === "/" || pathname.endsWith("/") || COMPRESSIBLE.test(pathname);
+}
+
+function negotiateEncoding(req: Request): "br" | "gzip" | null {
+  const accept = req.headers.get("accept-encoding") ?? "";
+  if (/\bbr\b/.test(accept)) return "br";
+  if (/\bgzip\b/.test(accept)) return "gzip";
+  return null;
+}
+
+async function getCompressedVariant(
+  resolved: string,
+  mtimeMs: number,
+  size: number,
+  encoding: "br" | "gzip",
+  raw: () => Promise<Uint8Array>,
+): Promise<CompressedVariant> {
+  let entry = compressedCache.get(resolved);
+  if (!entry || entry.mtimeMs !== mtimeMs || entry.size !== size) {
+    entry = { mtimeMs, size };
+    compressedCache.set(resolved, entry);
+  }
+  const cached = entry[encoding];
+  if (cached) return { body: cached, encoding };
+  const data = await raw();
+  const body =
+    encoding === "br"
+      ? brotliCompressSync(data, {
+          params: {
+            // Quality 5 ~ near-gzip CPU, much better ratio; this runs once per
+            // file version then serves from cache, so cost is amortized away.
+            [zlibConstants.BROTLI_PARAM_QUALITY]: 5,
+            [zlibConstants.BROTLI_PARAM_SIZE_HINT]: data.byteLength,
+          },
+        })
+      : gzipSync(data, { level: 6 });
+  entry[encoding] = body;
+  return { body, encoding };
+}
+
+async function serveStaticFile(
+  req: Request,
+  resolved: string,
+  requested: string,
+  file: ReturnType<typeof Bun.file>,
+): Promise<Response> {
+  const stat = await file.stat();
+  const headers = staticHeaders(requested);
+  // Strong-ish validator from mtime + size; encoding-suffixed so a client never
+  // gets a 304 for a variant it didn't store.
+  const baseTag = `${stat.mtime.getTime().toString(36)}-${stat.size.toString(36)}`;
+
+  const encoding = isCompressible(requested) ? negotiateEncoding(req) : null;
+  const etag = `"${baseTag}${encoding ? `-${encoding}` : ""}"`;
+  headers.set("ETag", etag);
+  if (req.headers.get("if-none-match") === etag) {
+    return new Response(null, { status: 304, headers });
+  }
+
+  if (encoding) {
+    const { body } = await getCompressedVariant(
+      resolved,
+      stat.mtime.getTime(),
+      stat.size,
+      encoding,
+      () => file.bytes(),
+    );
+    headers.set("Content-Encoding", encoding);
+    headers.set("Vary", "Accept-Encoding");
+    headers.set("Content-Length", String(body.byteLength));
+    // Uint8Array is a valid BodyInit at runtime in Bun; the DOM lib types omit it.
+    return new Response(body as unknown as BodyInit, { headers });
+  }
+
+  return new Response(file, { headers });
+}
+
+function staticHeaders(pathname: string): Headers {
+  const headers = new Headers();
+  const contentType = staticContentType(pathname);
+  if (contentType) headers.set("Content-Type", contentType);
+  // Hashed build assets are content-addressed (a content change = a new
+  // filename), so they're safe to cache forever — the browser never needs to
+  // revalidate them. The shell + PWA control files must always revalidate
+  // instead (ETag makes that a cheap 304 when unchanged).
+  if (pathname.startsWith("/assets/")) {
+    headers.set("Cache-Control", "public, max-age=31536000, immutable");
+  } else if (pathname === "/sw.js" || pathname === "/manifest.webmanifest") {
+    headers.set("Cache-Control", "no-cache");
+  } else if (pathname === "/" || pathname.endsWith("/") || pathname.endsWith(".html")) {
+    headers.set("Cache-Control", "no-cache");
+  }
+  return headers;
+}
+
+function staticContentType(pathname: string): string | undefined {
+  if (pathname.endsWith(".webmanifest")) return "application/manifest+json; charset=utf-8";
+  if (pathname.endsWith(".js")) return "text/javascript; charset=utf-8";
+  if (pathname.endsWith(".css")) return "text/css; charset=utf-8";
+  if (pathname.endsWith(".map")) return "application/json; charset=utf-8";
+  if (pathname.endsWith(".html")) return "text/html; charset=utf-8";
+  if (pathname.endsWith(".svg")) return "image/svg+xml";
+  if (pathname.endsWith(".png")) return "image/png";
+  return undefined;
+}

package/src/spawn-targets.ts

@@ -1,6 +1,7 @@
 import { countLiveSpawnedAgents, getAgent, getOrchestrator, listOrchestrators, listProviderQuotas, ValidationError } from "./db";
 import { DEFAULT_SPAWN_PROFILE_NAME, listAgentProfiles } from "./config-store";
 import { effectiveProviderCatalogList } from "./provider-catalog-store";
+import { resolveDefaultModel } from "agent-relay-sdk/provider-catalog";
 import { renderTemplate } from "./prompt-resolver";
 import { getRoutingPolicy } from "./routing-policy-store";
 import { isPathWithinBase } from "./utils";
@@ -117,7 +118,7 @@ const DEFAULT_QUOTA_ADVISORY: SpawnQuotaAdvisory = {
 // (orchestrator/src/provider-probe.ts uses providerCatalogList(), which has no DB access), while
 // spawn VALIDATION resolves against effectiveProviderCatalogList() (static catalog + DB
 // provider_model_overrides — see resolveSpawnModelParams in spawn-command.ts). A model enabled
-// only via a DB override (e.g. a newly added `sonnet-5`) is therefore spawnable but invisible to
+// only via a DB override (e.g. a newly added model) is therefore spawnable but invisible to
 // this matrix even after an orchestrator restart, since the orchestrator's snapshot never reads
 // the DB. Merge by alias, with the DB-matrix (global) entry winning on collision, so every model
 // spawn validation would accept is discoverable here too.
@@ -149,23 +150,30 @@ function providerMatrixFor(o: Orchestrator, quotaAdvisories: Map<SpawnProvider,
   const unavailableAliasesFor = (provider: SpawnProvider): Set<string> =>
     new Set(global.find((e) => e.provider === provider)?.models.filter((m) => m.unavailable).map((m) => m.alias) ?? []);
   return o.providers.map((provider) => {
-    const cat = mergeCatalogModels(reported.find((s) => s.provider === provider), global.find((e) => e.provider === provider));
+    const globalEntry = global.find((e) => e.provider === provider);
+    const cat = mergeCatalogModels(reported.find((s) => s.provider === provider), globalEntry);
     const disabled = disabledAliasesFor(provider);
     const unavailable = unavailableAliasesFor(provider);
     const quotaAdvisory = quotaAdvisories.get(provider) ?? DEFAULT_QUOTA_ADVISORY;
+    // #932 — advertise the SAME default a bare spawn would actually resolve to. resolveDefaultModel
+    // runs against the effective (DB-override-aware) catalog — the exact source spawn validation
+    // (resolveProviderSelection) reads — so the reported default can never drift from the spawned
+    // one and can never name a disabled/unavailable model. Fall back to the merged catalog's static
+    // default only when the provider is absent from the effective list (should not happen).
+    const resolvedDefault = globalEntry ? resolveDefaultModel(globalEntry).alias : cat?.defaultModel;
     return {
       provider,
       available: true,
       ...quotaAdvisory,
       ...(cat
         ? {
-            defaultModel: cat.defaultModel,
+            defaultModel: resolvedDefault,
             models: cat.models
               .filter((m) => !m.disabled && !disabled.has(m.alias) && !m.unavailable && !unavailable.has(m.alias))
               .map((m) => ({
                 id: m.alias,
                 providerModel: m.providerModel,
-                default: cat.defaultModel === m.alias,
+                default: resolvedDefault === m.alias,
                 effortLevels: m.efforts,
                 ...(m.defaultEffort ? { defaultEffort: m.defaultEffort } : {}),
               })),