@hachej/boring-core 0.1.54 → 0.1.55

package/dist/app/server/index.d.ts

@@ -1,6 +1,6 @@
 import { RuntimeProvisioningContribution, RegisterAgentRoutesOptions } from '@hachej/boring-agent/server';
 import { DirPluginEntry, CreateWorkspaceAgentServerOptions } from '@hachej/boring-workspace/app/server';
-import { WorkspaceServerPlugin } from '@hachej/boring-workspace/server';
+import { WorkspaceServerPlugin, WorkspaceBridgeOperationDefinition, WorkspaceBridgeHandler, WorkspaceBridgeRuntimeEnvOptions, WorkspaceBridgeCallRequest, WorkspaceBridgeCallResponse } from '@hachej/boring-workspace/server';
 import { FastifyInstance } from 'fastify';
 import { C as CoreConfig } from '../../types-Bb7I-83I.js';
 import { T as TelemetrySink } from '../../telemetry-DR18MeI0.js';
@@ -28,6 +28,16 @@ type CoreWorkspaceDirPluginEntry = Omit<DirPluginEntry, 'hotReload'> & {
     hotReload?: false;
 };
 type CoreWorkspacePluginEntry = CoreWorkspaceAgentServerPlugin | CoreWorkspaceDirPluginEntry;
+type CoreWorkspaceBridgeExtraTool = NonNullable<RegisterAgentRoutesOptions['extraTools']>[number];
+interface CoreWorkspaceBridgeExtraToolsContext {
+    workspaceId: string;
+    workspaceRoot: string;
+    callAsRuntime<TOutput = unknown>(request: WorkspaceBridgeCallRequest, options?: {
+        sessionId?: string;
+        signal?: AbortSignal;
+    }): Promise<WorkspaceBridgeCallResponse<TOutput>>;
+}
+type CoreWorkspaceBridgePiContext = CoreWorkspaceBridgeExtraToolsContext;
 interface CreateCoreWorkspaceAgentServerOptions extends Omit<RegisterAgentRoutesOptions, 'extraTools'> {
     appRoot?: string;
     config?: CoreConfig;
@@ -35,6 +45,17 @@ interface CreateCoreWorkspaceAgentServerOptions extends Omit<RegisterAgentRoutes
     plugins?: CoreWorkspacePluginEntry[];
     excludeDefaults?: CreateWorkspaceAgentServerOptions['excludeDefaults'];
     defaultPluginPackages?: CreateWorkspaceAgentServerOptions['defaultPluginPackages'];
+    workspaceBridge?: {
+        handlers?: Array<{
+            definition: WorkspaceBridgeOperationDefinition;
+            handler: WorkspaceBridgeHandler;
+        }>;
+        runtimeTokenSecret?: string;
+        runtimeRefreshTokenSecret?: string;
+        runtimeEnv?: WorkspaceBridgeRuntimeEnvOptions;
+    };
+    getWorkspaceBridgeExtraTools?: (ctx: CoreWorkspaceBridgeExtraToolsContext) => CoreWorkspaceBridgeExtraTool[] | Promise<CoreWorkspaceBridgeExtraTool[]>;
+    getWorkspaceBridgePi?: (ctx: CoreWorkspaceBridgePiContext) => AgentPiOptions | Promise<AgentPiOptions | undefined>;
     /**
      * Enable workspace plugin-authoring tooling/prompt for this app.
      * Defaults to false for full-app/core production composition; set true only
@@ -50,6 +71,7 @@ interface CreateCoreWorkspaceAgentServerOptions extends Omit<RegisterAgentRoutes
     /** Optional best-effort telemetry sink. Defaults to core's DB-backed env helper. */
     telemetry?: TelemetrySink;
 }
+type AgentPiOptions = RegisterAgentRoutesOptions['pi'];
 declare function createCoreWorkspaceAgentServer(options?: CreateCoreWorkspaceAgentServerOptions): Promise<CoreWorkspaceAgentServer>;
 
 interface StartCoreWorkspaceAgentDevServerOptions {

package/dist/app/server/index.js

@@ -37,6 +37,7 @@ import {
   registerAgentRoutes
 } from "@hachej/boring-agent/server";
 import {
+  assertWorkspaceBridgeHandlersTrusted,
   collectWorkspaceAgentServerPlugins,
   hasDirServerPlugin,
   omitPluginAuthoringProvisioning,
@@ -46,11 +47,156 @@ import {
   resolveOnePluginEntry
 } from "@hachej/boring-workspace/app/server";
 import {
-  createInMemoryBridge,
   createWorkspaceUiTools,
   uiRoutes
 } from "@hachej/boring-workspace/server";
 
+// src/app/server/coreWorkspaceBridge.ts
+import {
+  createBrowserBridgeAuthPolicy,
+  createInMemoryBridge,
+  createWorkspaceBridgeRuntimeCore,
+  createWorkspaceBridgeRuntimeEnvContribution,
+  InMemoryWorkspaceBridgeIdempotencyStore,
+  InMemoryWorkspaceBridgeRuntimeRefreshTokenStore,
+  runWithWorkspaceBridgeIdempotency,
+  verifyWorkspaceBridgeRuntimeToken,
+  workspaceBridgeHttpRoutes
+} from "@hachej/boring-workspace/server";
+var MAX_SESSION_OWNER_CACHE = 5e3;
+function createCoreWorkspaceBridge(options) {
+  const { resolveWorkspaceId, workspaceStore, validateWorkspaceId, agentSessionId } = options;
+  const bridges = /* @__PURE__ */ new Map();
+  const getBridge = (workspaceId) => {
+    const safeWorkspaceId = validateWorkspaceId(workspaceId);
+    let bridge = bridges.get(safeWorkspaceId);
+    if (!bridge) {
+      bridge = createInMemoryBridge();
+      bridges.set(safeWorkspaceId, bridge);
+    }
+    return bridge;
+  };
+  const runtimes = /* @__PURE__ */ new Map();
+  const getRuntime = (workspaceId) => {
+    const safeWorkspaceId = validateWorkspaceId(workspaceId);
+    let runtime = runtimes.get(safeWorkspaceId);
+    if (!runtime) {
+      const sessionOwners = /* @__PURE__ */ new Map();
+      const core = createWorkspaceBridgeRuntimeCore({
+        handlers: options.workspaceBridge?.handlers,
+        ownerWorkspaceId: safeWorkspaceId
+      });
+      runtime = {
+        registry: core.registry,
+        idempotencyStore: new InMemoryWorkspaceBridgeIdempotencyStore(),
+        refreshTokenStore: new InMemoryWorkspaceBridgeRuntimeRefreshTokenStore(),
+        sessionOwners
+      };
+      runtimes.set(safeWorkspaceId, runtime);
+    }
+    return runtime;
+  };
+  const resolveBridgeWorkspaceId = async (request) => {
+    const authHeader = request.headers.authorization;
+    if (options.workspaceBridge?.runtimeTokenSecret && typeof authHeader === "string" && authHeader.startsWith("Bearer ")) {
+      return verifyWorkspaceBridgeRuntimeToken(authHeader.slice("Bearer ".length), {
+        secret: options.workspaceBridge.runtimeTokenSecret
+      }).authContext.workspaceId;
+    }
+    return await resolveWorkspaceId(request);
+  };
+  const rememberSessionOwner = async (request) => {
+    const user = request.user;
+    if (!user?.id) return;
+    const sessionId = agentSessionId(request);
+    if (!sessionId) return;
+    const workspaceId = await resolveWorkspaceId(request);
+    const runtime = getRuntime(workspaceId);
+    runtime.sessionOwners.delete(sessionId);
+    runtime.sessionOwners.set(sessionId, user.id);
+    while (runtime.sessionOwners.size > MAX_SESSION_OWNER_CACHE) {
+      const oldest = runtime.sessionOwners.keys().next().value;
+      if (oldest === void 0) break;
+      runtime.sessionOwners.delete(oldest);
+    }
+  };
+  const callAsRuntime = async (workspaceId, request, callOptions) => {
+    const runtime = getRuntime(workspaceId);
+    const definition = runtime.registry.getDefinition(request.op);
+    if (!definition) {
+      return await runtime.registry.call(request, {
+        callerClass: "runtime",
+        workspaceId,
+        sessionId: callOptions?.sessionId,
+        capabilities: [],
+        actor: {
+          actorKind: "agent",
+          performedBy: { label: "agent-runtime" },
+          onBehalfOf: callOptions?.sessionId ? { label: `session:${callOptions.sessionId}` } : { label: `workspace:${workspaceId}` }
+        },
+        signal: callOptions?.signal,
+        emitUiEffect: (cmd) => getBridge(workspaceId).emitUiEffect(cmd)
+      });
+    }
+    const ownerPrincipalId = callOptions?.sessionId ? runtime.sessionOwners.get(callOptions.sessionId) : void 0;
+    const authContext = {
+      callerClass: "runtime",
+      workspaceId,
+      sessionId: callOptions?.sessionId,
+      capabilities: [...definition.requiredCapabilities],
+      actor: {
+        actorKind: "agent",
+        performedBy: { label: "agent-runtime" },
+        onBehalfOf: ownerPrincipalId ? { id: ownerPrincipalId, label: `user:${ownerPrincipalId}` } : callOptions?.sessionId ? { label: `session:${callOptions.sessionId}` } : { label: `workspace:${workspaceId}` }
+      },
+      signal: callOptions?.signal,
+      emitUiEffect: (cmd) => getBridge(workspaceId).emitUiEffect(cmd)
+    };
+    return await runWithWorkspaceBridgeIdempotency(runtime.idempotencyStore, {
+      definition,
+      request,
+      auth: authContext
+    }, async () => await runtime.registry.call(request, authContext));
+  };
+  const runtimeEnvContribution = options.workspaceBridge?.runtimeTokenSecret || options.workspaceBridge?.runtimeEnv ? {
+    id: "workspace-bridge-runtime-env",
+    getEnv: async (ctx) => {
+      const contribution = createWorkspaceBridgeRuntimeEnvContribution({
+        workspaceId: ctx.workspaceId,
+        runtimeMode: ctx.runtimeMode,
+        registry: getRuntime(ctx.workspaceId).registry,
+        runtimeTokenSecret: options.workspaceBridge?.runtimeTokenSecret,
+        runtimeRefreshTokenSecret: options.workspaceBridge?.runtimeRefreshTokenSecret,
+        runtimeEnv: options.workspaceBridge?.runtimeEnv
+      });
+      return contribution ? await contribution.getEnv(ctx) : {};
+    }
+  } : void 0;
+  const registerHttpRoutes = async (app) => {
+    await app.register(workspaceBridgeHttpRoutes, {
+      getRegistry: async (request) => getRuntime(await resolveBridgeWorkspaceId(request)).registry,
+      getIdempotencyStore: async (request) => getRuntime(await resolveBridgeWorkspaceId(request)).idempotencyStore,
+      runtimeTokenSecret: options.workspaceBridge?.runtimeTokenSecret,
+      runtimeRefreshTokenSecret: options.workspaceBridge?.runtimeRefreshTokenSecret,
+      getRuntimeRefreshTokenStore: (_request, claims) => getRuntime(claims.workspaceId).refreshTokenStore,
+      getOwnerWorkspaceId: async (request) => await resolveBridgeWorkspaceId(request),
+      browserAuthPolicy: createBrowserBridgeAuthPolicy({
+        getPrincipal: (input) => {
+          const user = input.request?.user;
+          return user?.id ? { userId: user.id, email: user.email ?? void 0 } : null;
+        },
+        authorizeWorkspace: async ({ principal, workspaceId, definition }) => ({
+          allowed: await workspaceStore.isMember(workspaceId, principal.userId),
+          capabilities: definition.requiredCapabilities
+        }),
+        allowedOrigins: options.corsOrigins,
+        requireCsrfHeader: true
+      })
+    });
+  };
+  return { getBridge, callAsRuntime, rememberSessionOwner, runtimeEnvContribution, registerHttpRoutes };
+}
+
 // src/server/telemetry/db.ts
 var EVENT_NAME_PATTERN = /^[a-z][a-z0-9_-]*(?:\.[a-z][a-z0-9_-]*){0,8}$/;
 var SAFE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
@@ -271,13 +417,14 @@ function mergePiOptions(base, override) {
 function createUnavailableCorePluginBridge() {
   const fail = () => {
     throw new Error(
-      "Core static server plugins do not receive a workspace-scoped UiBridge yet. Use request-scoped UI tools/routes in core, or createWorkspaceAgentServer for standalone plugin bridge support."
+      "Core static server plugins do not receive a workspace-scoped WorkspaceBridge yet. Use request-scoped UI tools/routes in core, or createWorkspaceAgentServer for standalone plugin bridge support."
     );
   };
   return {
     getState: fail,
     setState: fail,
     postCommand: fail,
+    emitUiEffect: fail,
     subscribeCommands: fail,
     drainCommands: fail
   };
@@ -313,6 +460,19 @@ async function pathIsFile(filePath) {
     return false;
   }
 }
+function agentSessionIdFromRequest(request) {
+  const url = request.url.split("?")[0] ?? request.url;
+  if (request.method === "POST" && url === "/api/v1/agent/chat") {
+    const body = request.body;
+    return typeof body?.sessionId === "string" && body.sessionId.trim() ? body.sessionId : void 0;
+  }
+  if (request.method === "POST" && url.endsWith("/followup") && url.startsWith("/api/v1/agent/chat/")) {
+    const params = request.params;
+    const sessionId = params?.sessionId ?? params?.id;
+    return typeof sessionId === "string" && sessionId.trim() ? sessionId : void 0;
+  }
+  return void 0;
+}
 function toHeaders(source) {
   const headers = new Headers();
   for (const [key, value] of Object.entries(source)) {
@@ -591,30 +751,24 @@ async function createCoreWorkspaceAgentServer(options = {}) {
   const defaultPackageRuntimePlugins = readWorkspacePluginPackageRuntimePlugins(defaultPluginPackagePaths);
   const { systemPromptAppend: defaultPackageSystemPromptAppend, ...defaultPackagePiOptions } = defaultPackagePiSnapshot;
   const staticSystemPromptAppend = [options.systemPromptAppend, defaultPackageSystemPromptAppend].filter(Boolean).join("\n\n") || void 0;
-  const defaultPluginDirEntries = defaultPluginPackagePaths.map((dir) => ({ dir, hotReload: false })).filter((entry) => hasDirServerPlugin(entry));
+  const defaultPluginDirEntries = defaultPluginPackagePaths.map((dir) => ({ dir, hotReload: false, trust: "internal" })).filter((entry) => hasDirServerPlugin(entry));
   const pluginEntries = [
     ...defaultPluginDirEntries,
     ...options.plugins ?? []
   ];
-  const bridges = /* @__PURE__ */ new Map();
-  const getUiBridge = (workspaceId) => {
-    const safeWorkspaceId = validateWorkspaceIdSegment(workspaceId);
-    let bridge = bridges.get(safeWorkspaceId);
-    if (!bridge) {
-      bridge = createInMemoryBridge();
-      bridges.set(safeWorkspaceId, bridge);
-    }
-    return bridge;
-  };
   const pluginResolveContext = {
     workspaceRoot: pluginWorkspaceRoot,
     bridge: createUnavailableCorePluginBridge()
   };
   const resolvedPlugins = await Promise.all(
-    pluginEntries.map((entry) => resolveOnePluginEntry(
-      entry,
-      pluginResolveContext
-    ))
+    pluginEntries.map(async (entry) => {
+      const plugin = await resolveOnePluginEntry(
+        entry,
+        pluginResolveContext
+      );
+      assertWorkspaceBridgeHandlersTrusted(plugin, entry);
+      return plugin;
+    })
   );
   const externalPluginsEnabled = options.externalPlugins !== false;
   const installPluginAuthoring = externalPluginsEnabled && options.installPluginAuthoring === true;
@@ -631,6 +785,23 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     const root = options.getWorkspaceRoot ? await options.getWorkspaceRoot(workspaceId, request) : await resolveWorkspaceRoot(workspaceRoot, workspaceId);
     return root;
   };
+  const coreBridge = createCoreWorkspaceBridge({
+    workspaceBridge: {
+      ...options.workspaceBridge,
+      handlers: [
+        ...options.workspaceBridge?.handlers ?? [],
+        ...pluginCollection.workspaceBridgeHandlers ?? []
+      ]
+    },
+    resolveWorkspaceId,
+    workspaceStore,
+    corsOrigins: app.config.cors.origins,
+    validateWorkspaceId: validateWorkspaceIdSegment,
+    agentSessionId: agentSessionIdFromRequest
+  });
+  app.addHook("preHandler", async (request) => {
+    await coreBridge.rememberSessionOwner(request);
+  });
   const workerBaseUrl = process.env.BORING_WORKER_BASE_URL?.trim();
   const remoteWorkerModeAdapter = workerBaseUrl ? createRemoteWorkerModeAdapter({ baseUrl: workerBaseUrl }) : void 0;
   const piOptionsByRoot = /* @__PURE__ */ new Map();
@@ -655,8 +826,13 @@ async function createCoreWorkspaceAgentServer(options = {}) {
   };
   const resolvePiOptions = async (ctx) => {
     const pluginOptions = remoteWorkerModeAdapter ? pluginCollection.agentOptions.pi : getPluginPiOptions(ctx.workspaceRoot);
+    const bridgePiOptions = options.getWorkspaceBridgePi ? await options.getWorkspaceBridgePi({
+      workspaceId: ctx.workspaceId,
+      workspaceRoot: ctx.workspaceRoot,
+      callAsRuntime: async (request, callOptions) => await coreBridge.callAsRuntime(ctx.workspaceId, request, callOptions)
+    }) : void 0;
     const callerOptions = options.getPi ? await options.getPi(ctx) : void 0;
-    return mergePiOptions(pluginOptions, callerOptions);
+    return mergePiOptions(mergePiOptions(pluginOptions, bridgePiOptions), callerOptions);
   };
   app.get("/api/v1/workspace/meta", async (request, reply) => {
     try {
@@ -696,9 +872,15 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     getSessionNamespace: resolveSessionNamespace,
     getExtraTools: async (ctx) => {
       const callerTools = options.getExtraTools ? await options.getExtraTools(ctx) : [];
+      const bridgeTools = options.getWorkspaceBridgeExtraTools ? await options.getWorkspaceBridgeExtraTools({
+        workspaceId: ctx.workspaceId,
+        workspaceRoot: ctx.workspaceRoot,
+        callAsRuntime: async (request, callOptions) => await coreBridge.callAsRuntime(ctx.workspaceId, request, callOptions)
+      }) : [];
       return [
         ...callerTools,
-        ...createWorkspaceUiTools(getUiBridge(ctx.workspaceId), {
+        ...bridgeTools,
+        ...createWorkspaceUiTools(coreBridge.getBridge(ctx.workspaceId), {
           workspaceRoot: ctx.workspaceFsCapability === "strong" ? ctx.workspaceRoot : void 0
         })
       ];
@@ -727,13 +909,18 @@ async function createCoreWorkspaceAgentServer(options = {}) {
     provisionWorkspace: options.provisionWorkspace,
     registerHealthRoute: options.registerHealthRoute ?? false,
     telemetry,
-    metering: options.metering
+    metering: options.metering,
+    runtimeEnvContributions: [
+      ...options.runtimeEnvContributions ?? [],
+      ...coreBridge.runtimeEnvContribution ? [coreBridge.runtimeEnvContribution] : []
+    ]
   });
   await app.register(uiRoutes, {
     getWorkspaceId: resolveWorkspaceId,
-    getBridge: async (request) => getUiBridge(await resolveWorkspaceId(request)),
+    getBridge: async (request) => coreBridge.getBridge(await resolveWorkspaceId(request)),
     preserveStateKeys: pluginCollection.preservedUiStateKeys
   });
+  await coreBridge.registerHttpRoutes(app);
   for (const { routes } of pluginCollection.routeContributions) {
     await app.register(routes);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-core",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "type": "module",
   "license": "MIT",
   "description": "Foundation package for boring-ui-v2 apps: DB, auth, config, HTTP app factory, and frontend app shell.",
@@ -79,9 +79,9 @@
     "react-router-dom": "^7.14.2",
     "smol-toml": "^1.6.1",
     "zod": "^3.25.76",
-    "@hachej/boring-ui-kit": "0.1.54",
-    "@hachej/boring-workspace": "0.1.54",
-    "@hachej/boring-agent": "0.1.54"
+    "@hachej/boring-agent": "0.1.55",
+    "@hachej/boring-workspace": "0.1.55",
+    "@hachej/boring-ui-kit": "0.1.55"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",