@hachej/boring-governance 0.1.64

package/dist/server/index.js

@@ -0,0 +1,933 @@
+// src/server/loadPolicy.ts
+import { readFile, stat } from "fs/promises";
+import { parse } from "yaml";
+import { isCoreEmailVerificationEnabled } from "@hachej/boring-core/shared";
+
+// src/server/validatePolicy.ts
+var MICROS_PER_EUR = 1e6;
+var MAX_REGEX_LENGTH = 512;
+var MAX_CONTEXT_RULES_PER_USER = 128;
+function fail(message) {
+  throw new Error(message);
+}
+function normalizePolicyEmail(value) {
+  return value.trim().toLowerCase();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value, path2) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    fail(`${path2} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function uuidString(value, path2) {
+  const id = nonEmptyString(value, path2);
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) {
+    fail(`${path2} must be a UUID workspace id`);
+  }
+  return id;
+}
+function finiteNumber(value, path2, opts) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    fail(`${path2} must be a finite number`);
+  }
+  if (opts.allowZero ? value < opts.min : value <= opts.min) {
+    fail(`${path2} must be ${opts.allowZero ? ">=" : ">"} ${opts.min}`);
+  }
+  return value;
+}
+var LITERAL_REGEX_ESCAPES = /* @__PURE__ */ new Set(["\\", "/", ".", "-", "^", "$", "+", "*", "?", "(", ")", "[", "]", "{", "}", "|"]);
+function literalPathPrefix(pattern) {
+  let prefix = "";
+  let index = "^/".length;
+  let unsafeEscape = false;
+  while (index < pattern.length) {
+    const char = pattern[index];
+    if (!char) break;
+    if (char === "\\") {
+      const escaped = pattern[index + 1];
+      if (!escaped) break;
+      if (!LITERAL_REGEX_ESCAPES.has(escaped)) {
+        unsafeEscape = true;
+        break;
+      }
+      prefix += escaped;
+      index += 2;
+      continue;
+    }
+    if ("^$.+*?()[]{}|".includes(char)) break;
+    prefix += char;
+    index += 1;
+  }
+  return { prefix, consumed: index - "^/".length, unsafeEscape };
+}
+function hasTopLevelAlternation(pattern) {
+  let escaped = false;
+  let inCharacterClass = false;
+  let groupDepth = 0;
+  for (const char of pattern) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inCharacterClass) {
+      if (char === "]") inCharacterClass = false;
+      continue;
+    }
+    if (char === "[") {
+      inCharacterClass = true;
+      continue;
+    }
+    if (char === "(") {
+      groupDepth += 1;
+      continue;
+    }
+    if (char === ")") {
+      groupDepth = Math.max(0, groupDepth - 1);
+      continue;
+    }
+    if (char === "|" && groupDepth === 0) return true;
+  }
+  return false;
+}
+function validateSegmentSafePattern(pattern, path2) {
+  const { prefix, consumed, unsafeEscape } = literalPathPrefix(pattern);
+  if (unsafeEscape) fail(`${path2} must use only literal regex escapes before the path-segment boundary`);
+  if (!prefix) {
+    const remainder2 = pattern.slice("^/".length);
+    if (remainder2.startsWith(".*") || remainder2.startsWith("$")) return;
+    fail(`${path2} must start with a literal path segment or ^/.*`);
+  }
+  const remainder = pattern.slice("^/".length + consumed);
+  if (prefix.endsWith("/")) {
+    if (/^[?*+{]/.test(remainder)) fail(`${path2} must not make the path-segment boundary slash optional`);
+    return;
+  }
+  if (remainder.startsWith("$")) return;
+  for (const guard of ["(?:/|$)", "(?:$|/)", "(/|$)", "($|/)"]) {
+    if (!remainder.startsWith(guard)) continue;
+    if (/^[?*+{]/.test(remainder.slice(guard.length))) {
+      fail(`${path2} must not make the path-segment boundary guard optional`);
+    }
+    return;
+  }
+  fail(`${path2} must make literal path-prefix grants segment-safe with /, $, or (?:/|$)`);
+}
+function validateRegexPattern(value, path2) {
+  const pattern = nonEmptyString(value, path2);
+  if (pattern.length > MAX_REGEX_LENGTH) fail(`${path2} must be at most ${MAX_REGEX_LENGTH} characters`);
+  if (!pattern.startsWith("^/")) fail(`${path2} must start with ^/`);
+  if (hasTopLevelAlternation(pattern)) fail(`${path2} must not use top-level regex alternation; add separate allow rules instead`);
+  validateSegmentSafePattern(pattern, path2);
+  if (/\([^)]*[+*][^)]*\)[+*{]/.test(pattern)) {
+    fail(`${path2} contains an unsafe nested quantifier`);
+  }
+  try {
+    new RegExp(pattern);
+  } catch (error) {
+    fail(`${path2} must compile as a JavaScript RegExp: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return pattern;
+}
+function validateModels(value, userPath, defaultMonthlyModelBudgetEur) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) fail(`${userPath}.models must be an array`);
+  return value.map((entry, index) => {
+    const path2 = `${userPath}.models[${index}]`;
+    if (!isRecord(entry)) fail(`${path2} must be an object`);
+    const provider = nonEmptyString(entry.provider, `${path2}.provider`);
+    const id = nonEmptyString(entry.id, `${path2}.id`);
+    const monthlyBudgetEur = entry.monthlyBudgetEur === void 0 ? defaultMonthlyModelBudgetEur : finiteNumber(entry.monthlyBudgetEur, `${path2}.monthlyBudgetEur`, {
+      min: 0,
+      allowZero: true
+    });
+    return {
+      provider,
+      id,
+      monthlyBudgetEur,
+      monthlyBudgetMicros: Math.round(monthlyBudgetEur * MICROS_PER_EUR)
+    };
+  });
+}
+function validateCompanyContext(value, userPath) {
+  if (value === void 0) return { allow: [] };
+  if (!isRecord(value)) fail(`${userPath}.companyContext must be an object`);
+  const allow = value.allow;
+  if (allow === void 0) return { allow: [] };
+  if (!Array.isArray(allow)) fail(`${userPath}.companyContext.allow must be an array`);
+  if (allow.length > MAX_CONTEXT_RULES_PER_USER) {
+    fail(`${userPath}.companyContext.allow must contain at most ${MAX_CONTEXT_RULES_PER_USER} rules`);
+  }
+  return {
+    allow: allow.map((pattern, index) => validateRegexPattern(pattern, `${userPath}.companyContext.allow[${index}]`))
+  };
+}
+function validateRole(value, path2) {
+  if (value !== "admin" && value !== "user") fail(`${path2} must be admin or user`);
+  return value;
+}
+function validateGovernancePolicy(input) {
+  if (!isRecord(input)) fail("policy must be an object");
+  const candidate = input;
+  if (!isRecord(candidate.tenant)) fail("tenant must be an object");
+  const tenant = candidate.tenant;
+  const tenantId = nonEmptyString(tenant.id, "tenant.id");
+  const companyContextWorkspaceId = tenant.companyContextWorkspaceId === void 0 || tenant.companyContextWorkspaceId === null ? null : uuidString(tenant.companyContextWorkspaceId, "tenant.companyContextWorkspaceId");
+  const defaultMonthlyModelBudgetEur = tenant.defaultMonthlyModelBudgetEur === void 0 ? 0 : finiteNumber(tenant.defaultMonthlyModelBudgetEur, "tenant.defaultMonthlyModelBudgetEur", { min: 0, allowZero: true });
+  const perRunHoldEur = tenant.perRunHoldEur === void 0 ? 1 : finiteNumber(tenant.perRunHoldEur, "tenant.perRunHoldEur", { min: 0, allowZero: false });
+  if (!Array.isArray(candidate.users)) fail("users must be an array");
+  const usersByEmail = /* @__PURE__ */ new Map();
+  const users = candidate.users.map((entry, index) => {
+    const path2 = `users[${index}]`;
+    if (!isRecord(entry)) fail(`${path2} must be an object`);
+    const email = normalizePolicyEmail(nonEmptyString(entry.email, `${path2}.email`));
+    if (!email.includes("@")) fail(`${path2}.email must be an email address`);
+    if (usersByEmail.has(email)) fail(`duplicate user email: ${email}`);
+    const user = {
+      email,
+      role: validateRole(entry.role, `${path2}.role`),
+      models: validateModels(entry.models, path2, defaultMonthlyModelBudgetEur),
+      companyContext: validateCompanyContext(entry.companyContext, path2)
+    };
+    usersByEmail.set(email, user);
+    return user;
+  });
+  const companyContextEnforced = users.some((user) => user.companyContext.allow.length > 0);
+  if (companyContextEnforced && !companyContextWorkspaceId) {
+    fail("tenant.companyContextWorkspaceId is required when company-context rules are configured");
+  }
+  return {
+    tenant: {
+      id: tenantId,
+      companyContextWorkspaceId,
+      defaultMonthlyModelBudgetEur,
+      perRunHoldEur,
+      perRunHoldMicros: Math.round(perRunHoldEur * MICROS_PER_EUR)
+    },
+    users,
+    usersByEmail
+  };
+}
+
+// src/server/loadPolicy.ts
+var MAX_POLICY_BYTES = 256 * 1024;
+var GOVERNANCE_POLICY_PATH_ENV = "BORING_GOVERNANCE_POLICY_PATH";
+var GOVERNANCE_DEV_EMAIL_VERIFICATION_OVERRIDE_ENV = "BORING_GOVERNANCE_ALLOW_UNVERIFIED_EMAIL_DEV";
+function invalidResult(path2, error) {
+  return {
+    enabled: true,
+    policy: null,
+    status: {
+      state: "invalid",
+      path: path2,
+      message: error instanceof Error ? error.message : String(error)
+    }
+  };
+}
+function shouldAllowDevEmailVerificationOverride(env, nodeEnv) {
+  return nodeEnv !== "production" && env[GOVERNANCE_DEV_EMAIL_VERIFICATION_OVERRIDE_ENV] === "1";
+}
+async function loadGovernancePolicy({
+  env = process.env,
+  nodeEnv = process.env["NODE_ENV"] ?? "development",
+  config
+} = {}) {
+  const configuredPath = env[GOVERNANCE_POLICY_PATH_ENV]?.trim();
+  if (!configuredPath) {
+    return {
+      enabled: false,
+      policy: null,
+      status: { state: "disabled", reason: "missing-env", path: null }
+    };
+  }
+  let fileStat;
+  try {
+    fileStat = await stat(configuredPath);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return {
+        enabled: false,
+        policy: null,
+        status: { state: "disabled", reason: "missing-file", path: configuredPath }
+      };
+    }
+    throw error;
+  }
+  if (fileStat.size > MAX_POLICY_BYTES) {
+    const result = invalidResult(configuredPath, new Error(`policy file exceeds ${MAX_POLICY_BYTES} bytes`));
+    if (nodeEnv === "production") throw new Error(result.status.state === "invalid" ? result.status.message : "invalid governance policy");
+    return result;
+  }
+  try {
+    if (config && !isCoreEmailVerificationEnabled(config) && !shouldAllowDevEmailVerificationOverride(env, nodeEnv)) {
+      throw new Error(
+        `governance requires email verification; configure mail or set ${GOVERNANCE_DEV_EMAIL_VERIFICATION_OVERRIDE_ENV}=1 outside production`
+      );
+    }
+    const raw = await readFile(configuredPath, "utf8");
+    const parsed = parse(raw);
+    const policy = validateGovernancePolicy(parsed);
+    return {
+      enabled: true,
+      policy,
+      status: {
+        state: "active",
+        path: configuredPath,
+        tenantId: policy.tenant.id,
+        userCount: policy.users.length
+      }
+    };
+  } catch (error) {
+    const result = invalidResult(configuredPath, error);
+    if (nodeEnv === "production") throw new Error(result.status.state === "invalid" ? result.status.message : "invalid governance policy");
+    return result;
+  }
+}
+
+// src/server/governanceService.ts
+var GovernancePolicyError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "GovernancePolicyError";
+  }
+  code;
+};
+var GovernanceService = class {
+  constructor(loaded) {
+    this.loaded = loaded;
+  }
+  loaded;
+  isEnabled() {
+    return this.loaded.enabled;
+  }
+  policyStatus() {
+    return this.loaded.status;
+  }
+  policy() {
+    return this.loaded.policy;
+  }
+  enabledPolicy() {
+    if (!this.loaded.enabled) return null;
+    if (!this.loaded.policy) return null;
+    return this.loaded.policy;
+  }
+  userPolicy(user) {
+    const policy = this.enabledPolicy();
+    if (!policy || !user?.email || user.emailVerified !== true) return null;
+    return policy.usersByEmail.get(normalizePolicyEmail(user.email)) ?? null;
+  }
+  roleForUser(user) {
+    return this.userPolicy(user)?.role ?? null;
+  }
+  isAdmin(user) {
+    return this.roleForUser(user) === "admin";
+  }
+  allowedModelsForUser(user, servedModels) {
+    const userPolicy = this.userPolicy(user);
+    if (!this.loaded.enabled) return [...servedModels];
+    if (!userPolicy) return [];
+    const allowed = new Set(userPolicy.models.map((model) => `${model.provider}\0${model.id}`));
+    return servedModels.filter((model) => allowed.has(`${model.provider}\0${model.id}`));
+  }
+  assertModelAllowed(user, model) {
+    if (!this.loaded.enabled) return;
+    const allowed = this.allowedModelsForUser(user, [model]);
+    if (allowed.length === 0) throw new GovernancePolicyError("model is not allowed by governance policy", "not_allowed");
+  }
+  monthlyBudgetMicros(user, model) {
+    if (!this.loaded.enabled) return null;
+    const userPolicy = this.userPolicy(user);
+    const grant = userPolicy?.models.find((entry) => entry.provider === model.provider && entry.id === model.id);
+    return grant?.monthlyBudgetMicros ?? null;
+  }
+  companyContextRules(user) {
+    if (!this.loaded.enabled) return [];
+    return this.userPolicy(user)?.companyContext.allow ?? [];
+  }
+  companyContextWorkspaceId() {
+    return this.enabledPolicy()?.tenant.companyContextWorkspaceId ?? null;
+  }
+  me(user) {
+    const role = this.roleForUser(user);
+    const admin = role === "admin";
+    const base = {
+      enabled: this.loaded.enabled,
+      role,
+      admin
+    };
+    if (!this.loaded.enabled) return base;
+    const policy = this.loaded.policy;
+    if (!policy) {
+      return { ...base, policyStatus: this.loaded.status };
+    }
+    if (!admin) return base;
+    return {
+      ...base,
+      policyStatus: this.loaded.status,
+      tenant: {
+        id: policy.tenant.id,
+        companyContextWorkspaceId: policy.tenant.companyContextWorkspaceId,
+        defaultMonthlyModelBudgetEur: policy.tenant.defaultMonthlyModelBudgetEur,
+        perRunHoldEur: policy.tenant.perRunHoldEur
+      },
+      users: policy.users.map((entry) => ({
+        email: entry.email,
+        role: entry.role,
+        modelCount: entry.models.length,
+        contextRuleCount: entry.companyContext.allow.length
+      })),
+      models: policy.users.flatMap((entry) => entry.models.map((model) => ({ ...model, email: entry.email }))),
+      companyContextRules: policy.users.flatMap((entry) => entry.companyContext.allow.map((pattern) => ({ email: entry.email, pattern })))
+    };
+  }
+};
+function createGovernanceService(result) {
+  return new GovernanceService(result);
+}
+
+// src/server/routes.ts
+function governanceRoutes(service) {
+  return async (app) => {
+    app.get("/api/v1/governance/me", async (request) => {
+      return service.me(request.user ?? null);
+    });
+  };
+}
+
+// src/server/companyContextBootstrap.ts
+import { ConfigValidationError } from "@hachej/boring-core/shared";
+var COMPANY_CONTEXT_WORKSPACE_NAME = "Company Context";
+var COMPANY_CONTEXT_WORKSPACE_MANAGED_BY = "company-context";
+var provisionInFlight = /* @__PURE__ */ new Map();
+function adminPolicies(service) {
+  const policy = service.policy();
+  if (!policy) return [];
+  return policy.users.filter((user) => user.role === "admin");
+}
+function assertCompanyContextWorkspace(workspace, workspaceId) {
+  if (workspace.managedBy === COMPANY_CONTEXT_WORKSPACE_MANAGED_BY) return;
+  throw new ConfigValidationError([
+    {
+      path: ["tenant", "companyContextWorkspaceId"],
+      message: `workspace ${workspaceId} already exists but is not marked as a managed Company Context workspace`
+    }
+  ]);
+}
+async function provisionCompanyContextWorkspace(app, workspaceId, ownerId) {
+  if (!app.provisioner) return;
+  const runtime = await app.workspaceStore.getWorkspaceRuntime(workspaceId);
+  if (runtime?.state === "ready" && runtime.volumePath) return;
+  const existingProvision = provisionInFlight.get(workspaceId);
+  if (existingProvision) {
+    await existingProvision;
+    return;
+  }
+  const provisionPromise = (async () => {
+    await app.workspaceStore.putWorkspaceRuntime(workspaceId, { state: "pending" });
+    try {
+      const result = await app.provisioner.provision({
+        workspaceId,
+        workspaceName: COMPANY_CONTEXT_WORKSPACE_NAME,
+        ownerId,
+        appId: app.config.appId
+      });
+      await app.workspaceStore.putWorkspaceRuntime(workspaceId, {
+        state: "ready",
+        volumePath: result.volumePath
+      });
+    } catch (error) {
+      await app.workspaceStore.putWorkspaceRuntime(workspaceId, {
+        state: "error",
+        lastError: error instanceof Error ? error.message : String(error),
+        lastErrorOp: "provision"
+      });
+      throw error;
+    }
+  })();
+  provisionInFlight.set(workspaceId, provisionPromise);
+  try {
+    await provisionPromise;
+  } finally {
+    if (provisionInFlight.get(workspaceId) === provisionPromise) provisionInFlight.delete(workspaceId);
+  }
+}
+async function reconcileCompanyContextWorkspace(app, service) {
+  if (!service.isEnabled()) return;
+  const governanceApp = app;
+  const workspaceId = service.companyContextWorkspaceId();
+  if (!workspaceId) return;
+  const adminUsers = [];
+  for (const policyUser of adminPolicies(service)) {
+    const user = await governanceApp.userStore.getByEmail(policyUser.email);
+    if (user?.emailVerified) adminUsers.push(user);
+  }
+  let workspace = await governanceApp.workspaceStore.get(workspaceId);
+  if (workspace) {
+    assertCompanyContextWorkspace(workspace, workspaceId);
+  } else {
+    const deletedWorkspace = await governanceApp.workspaceStore.getIncludingDeleted(workspaceId);
+    if (deletedWorkspace) {
+      assertCompanyContextWorkspace(deletedWorkspace, workspaceId);
+      workspace = await governanceApp.workspaceStore.restore(workspaceId);
+      if (!workspace) throw new Error(`Workspace ${workspaceId} could not be restored`);
+      app.log.info({ workspaceId }, "governance.company_context.restored");
+    }
+  }
+  const owner = adminUsers[0];
+  if (!workspace) {
+    if (!owner) {
+      app.log.warn({ workspaceId }, "governance.company_context.no_existing_verified_admins");
+      return;
+    }
+    workspace = await governanceApp.workspaceStore.create(owner.id, COMPANY_CONTEXT_WORKSPACE_NAME, app.config.appId, {
+      id: workspaceId,
+      isDefault: false,
+      managedBy: COMPANY_CONTEXT_WORKSPACE_MANAGED_BY
+    });
+    assertCompanyContextWorkspace(workspace, workspaceId);
+    app.log.info({ workspaceId, ownerId: owner.id }, "governance.company_context.created");
+  }
+  const adminIds = new Set(adminUsers.map((admin) => admin.id));
+  for (const admin of adminUsers) {
+    await governanceApp.workspaceStore.upsertMember(workspaceId, admin.id, "owner");
+  }
+  const existingMembers = await governanceApp.workspaceStore.listMembers(workspaceId);
+  for (const member of existingMembers) {
+    if (adminIds.has(member.userId)) continue;
+    const result = adminIds.size === 0 ? await governanceApp.workspaceStore.removeMember(workspaceId, member.userId, { allowLastOwner: true }) : await governanceApp.workspaceStore.removeMember(workspaceId, member.userId);
+    if (!result.removed) {
+      app.log.warn({ workspaceId, userId: member.userId, code: result.code }, "governance.company_context.remove_stale_member_failed");
+    }
+  }
+  if (!owner) {
+    app.log.warn({ workspaceId }, "governance.company_context.no_existing_verified_admins");
+    return;
+  }
+  await provisionCompanyContextWorkspace(app, workspaceId, owner.id);
+}
+
+// src/server/metering.ts
+import { ErrorCode } from "@hachej/boring-agent/shared";
+import * as coreServer from "@hachej/boring-core/server";
+var PostgresModelBudgetStore2 = coreServer.PostgresModelBudgetStore;
+var ModelBudgetExceededError2 = coreServer.ModelBudgetExceededError;
+var DEFAULT_HOLD_TTL_SECONDS = 60 * 60;
+function authRequiredError() {
+  return Object.assign(new Error("authentication required"), { statusCode: 401, code: ErrorCode.enum.UNAUTHORIZED });
+}
+function modelRequiredError() {
+  return Object.assign(new Error("model is required by governance policy"), { statusCode: 400, code: ErrorCode.enum.TOOL_INVALID_INPUT });
+}
+function policyDeniedError() {
+  return Object.assign(new Error("model is not allowed by governance policy"), { statusCode: 403, code: ErrorCode.enum.TOOL_INVALID_INPUT });
+}
+function budgetError(error) {
+  if (typeof ModelBudgetExceededError2 === "function" && error instanceof ModelBudgetExceededError2) return error;
+  return error instanceof Error ? error : new Error(String(error));
+}
+function runKey(input) {
+  return input.userId ? `${input.userId}\0${input.runId}` : null;
+}
+function createGovernanceMeteringSink(options) {
+  let store;
+  const getStore = () => store ??= new PostgresModelBudgetStore2(options.getDb());
+  const reservationsByRun = /* @__PURE__ */ new Map();
+  const holdTtlSeconds = options.holdTtlSeconds ?? DEFAULT_HOLD_TTL_SECONDS;
+  async function reserveGovernance(input) {
+    if (!options.service.isEnabled()) return void 0;
+    const identity = input;
+    if (!input.userId || !identity.userEmail) throw authRequiredError();
+    const user = { id: input.userId, email: identity.userEmail, emailVerified: identity.userEmailVerified === true };
+    if (!input.model?.provider || !input.model.id) throw modelRequiredError();
+    try {
+      options.service.assertModelAllowed(user, { provider: input.model.provider, id: input.model.id });
+    } catch {
+      throw policyDeniedError();
+    }
+    const budgetMicros = options.service.monthlyBudgetMicros(user, { provider: input.model.provider, id: input.model.id });
+    if (budgetMicros === null || budgetMicros <= 0) throw new ModelBudgetExceededError2(0, 0, budgetMicros ?? 0, 0);
+    const policy = options.service.policy();
+    const holdMicros = policy?.tenant.perRunHoldMicros ?? 1e6;
+    const result = await getStore().reserve({
+      userId: input.userId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      runId: input.runId,
+      provider: input.model.provider,
+      model: input.model.id,
+      budgetMicros,
+      holdMicros,
+      ttlSeconds: holdTtlSeconds
+    }).catch((error) => {
+      throw budgetError(error);
+    });
+    const key = runKey(input);
+    if (key) reservationsByRun.set(key, result.reservationId);
+    return result.reservationId;
+  }
+  async function finishGovernance(input, action) {
+    if (!options.service.isEnabled()) return;
+    const key = runKey(input);
+    const reservationId = key ? reservationsByRun.get(key) : void 0;
+    if (!reservationId && (!input.userId || !input.runId)) return;
+    if (action === "settle") await getStore().settle({ reservationId, runId: input.runId, userId: input.userId });
+    else await getStore().release({ reservationId, runId: input.runId, userId: input.userId });
+    if (key) reservationsByRun.delete(key);
+  }
+  function releaseConsumesBudget(input) {
+    return input.reason === "usage-write-failed" || input.reason === "fallback-hold-charge";
+  }
+  return {
+    isEnabled: () => options.service.isEnabled() || options.delegate.isEnabled?.() !== false,
+    async reserveRun(input) {
+      const governanceReservationId = await reserveGovernance(input);
+      try {
+        return await options.delegate.reserveRun(input);
+      } catch (error) {
+        if (governanceReservationId) await getStore().release({ reservationId: governanceReservationId }).catch(() => {
+        });
+        const key = runKey(input);
+        if (key) reservationsByRun.delete(key);
+        throw error;
+      }
+    },
+    recordUsage(input) {
+      const key = runKey(input);
+      const reservationId = key ? reservationsByRun.get(key) : void 0;
+      return options.delegate.recordUsage(reservationId ? { ...input, metadata: { ...input.metadata ?? {}, modelBudgetReservationId: reservationId } } : input);
+    },
+    async settleRun(input) {
+      try {
+        await options.delegate.settleRun(input);
+      } finally {
+        await finishGovernance(input, "release");
+      }
+    },
+    async releaseRun(input) {
+      if (releaseConsumesBudget(input)) {
+        await finishGovernance(input, "settle");
+        await options.delegate.releaseRun(input);
+        return;
+      }
+      try {
+        await options.delegate.releaseRun(input);
+      } finally {
+        await finishGovernance(input, "release");
+      }
+    }
+  };
+}
+
+// src/server/filesystemBindings.ts
+import { constants } from "fs";
+import { access, chmod, copyFile, lstat, mkdir, mkdtemp, readdir, realpath, rm, stat as stat2 } from "fs/promises";
+import os from "os";
+import path from "path";
+import { createLogger } from "@hachej/boring-agent/server";
+import { ErrorCode as ErrorCode2 } from "@hachej/boring-agent/shared";
+import {
+  COMPANY_CONTEXT_FILESYSTEM_ID,
+  ScopedFilesystemRuntimeBindingManager,
+  createReadonlyProjectionOperations
+} from "@hachej/boring-bash/server";
+var COMPANY_CONTEXT_MOUNT_PATH = "/company_context";
+var AGENT_MODE_ENV = "BORING_AGENT_MODE";
+var AGENT_WORKSPACE_ROOT_ENV = "BORING_AGENT_WORKSPACE_ROOT";
+var GOVERNANCE_COMPANY_CONTEXT_ROOT_ENV = "BORING_GOVERNANCE_COMPANY_CONTEXT_ROOT";
+var companyContextBindingCanonicalLogger = createLogger("boring-governance/company-context");
+var companyContextBindingFallbackLogger = {
+  error(fields, message) {
+    companyContextBindingCanonicalLogger.error(message, fields);
+  }
+};
+function normalizeCompanyPath(value) {
+  const normalized = value.replace(/\\/g, "/");
+  if (normalized.includes("\0")) throw new Error("invalid company path");
+  const withRoot = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  const parts = withRoot.split("/").filter(Boolean);
+  if (parts.some((part) => part === "." || part === "..")) throw new Error("company path traversal is not allowed");
+  return `/${parts.join("/")}`;
+}
+async function assertInsideRoot(root, candidate) {
+  const realRoot = await realpath(root);
+  const existing = await realpath(candidate);
+  const rel = path.relative(realRoot, existing);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) throw new Error("path escapes company context root");
+}
+async function walkFiles(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const absolutePath = path.join(current, entry.name);
+    const entryStat = await lstat(absolutePath);
+    if (entryStat.isSymbolicLink()) continue;
+    if (entry.isDirectory()) out.push(...await walkFiles(root, absolutePath));
+    else if (entry.isFile()) out.push(absolutePath);
+  }
+  return out;
+}
+async function makeProjectionReadonly(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = path.join(current, entry.name);
+    if (entry.isDirectory()) await makeProjectionReadonly(root, absolutePath);
+    else if (entry.isFile()) await chmod(absolutePath, 256);
+  }
+  await chmod(current, 320);
+}
+async function makeProjectionRemovable(current) {
+  await chmod(current, 448).catch(() => {
+  });
+  const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    const absolutePath = path.join(current, entry.name);
+    if (entry.isDirectory()) await makeProjectionRemovable(absolutePath);
+    else await chmod(absolutePath, 384).catch(() => {
+    });
+  }
+}
+function compileRules(rules) {
+  return rules.map((rule) => new RegExp(rule));
+}
+function userFromContext(ctx) {
+  const requestUser = ctx.request?.user;
+  if (requestUser?.email) {
+    return { id: requestUser.id, email: requestUser.email, emailVerified: requestUser.emailVerified === true };
+  }
+  if (!ctx.userEmail) return null;
+  return { id: ctx.userId, email: ctx.userEmail, emailVerified: ctx.userEmailVerified === true };
+}
+var RegexFilteredCompanyContextProvider = class {
+  constructor(sourceRoot, allowedRules, projectionRootParent) {
+    this.sourceRoot = sourceRoot;
+    this.allowedRules = allowedRules;
+    this.projectionRootParent = projectionRootParent;
+  }
+  sourceRoot;
+  allowedRules;
+  projectionRootParent;
+  async disposeBinding(prepared) {
+    const handle = prepared.handle;
+    if (handle.lifecycle) handle.lifecycle.active = false;
+    if (handle.projectionRoot) {
+      await makeProjectionRemovable(handle.projectionRoot);
+      await rm(handle.projectionRoot, { recursive: true, force: true });
+    }
+  }
+  async prepareBinding(_ctx, binding) {
+    if (binding.filesystem !== COMPANY_CONTEXT_FILESYSTEM_ID) throw new Error(`unsupported filesystem binding ${binding.filesystem}`);
+    if (binding.access !== "readonly" || binding.projection !== "policy-filtered") {
+      throw new Error("company_context policy mount only supports readonly policy-filtered bindings");
+    }
+    await access(this.sourceRoot, constants.R_OK);
+    const projectionRoot = await mkdtemp(path.join(this.projectionRootParent, "boring-company-context-"));
+    try {
+      const files = await walkFiles(this.sourceRoot);
+      for (const sourceFile of files) {
+        await assertInsideRoot(this.sourceRoot, sourceFile);
+        const rel = path.relative(this.sourceRoot, sourceFile).split(path.sep).join("/");
+        const companyPath = normalizeCompanyPath(rel);
+        if (!this.allowedRules.some((rule) => rule.test(companyPath))) continue;
+        const destination = path.join(projectionRoot, ...companyPath.slice(1).split("/"));
+        await mkdir(path.dirname(destination), { recursive: true });
+        await copyFile(sourceFile, destination);
+      }
+      await makeProjectionReadonly(projectionRoot);
+      return {
+        binding,
+        handle: {
+          filesystem: binding.filesystem,
+          projectionRoot,
+          lifecycle: { active: true }
+        }
+      };
+    } catch (error) {
+      await makeProjectionRemovable(projectionRoot);
+      await rm(projectionRoot, { recursive: true, force: true });
+      throw error;
+    }
+  }
+};
+function asRuntimeOperations(ops) {
+  return {
+    read: (descriptor) => ops.read(descriptor),
+    list: (descriptor) => ops.list(descriptor),
+    find: (descriptor, pattern, options) => ops.find(descriptor, pattern, options),
+    grep: (descriptor, pattern, options) => ops.grep(descriptor, pattern, options),
+    stat: (descriptor) => ops.stat(descriptor),
+    rejectMutation: (operation, descriptor) => ops.rejectMutation(operation, descriptor)
+  };
+}
+function createDefaultCompanyContextRootResolver(env = process.env) {
+  const explicitSourceRoot = env[GOVERNANCE_COMPANY_CONTEXT_ROOT_ENV]?.trim();
+  if (explicitSourceRoot) return () => path.resolve(explicitSourceRoot);
+  if (env[AGENT_MODE_ENV]?.trim() === "vercel-sandbox") return void 0;
+  const workspaceStorageRoot = env[AGENT_WORKSPACE_ROOT_ENV]?.trim() || process.cwd();
+  return (_ctx, companyContextWorkspaceId) => path.resolve(workspaceStorageRoot, companyContextWorkspaceId);
+}
+function logCompanyContextBindingError(ctx, reason, details = {}) {
+  const fields = {
+    code: ErrorCode2.enum.CONFIG_INVALID,
+    event: "governance.company_context.binding_omitted",
+    reason,
+    workspaceId: ctx.workspaceId,
+    requestId: ctx.requestId ?? ctx.request?.id,
+    ...details
+  };
+  const message = "company_context binding omitted";
+  if (ctx.request?.log) ctx.request.log.error(fields, message);
+  else companyContextBindingFallbackLogger.error(fields, message);
+}
+async function resolveCompanyContextSourceRoot(ctx, companyContextWorkspaceId, resolver) {
+  if (!resolver) {
+    logCompanyContextBindingError(ctx, "missing_explicit_source_root_resolver", { companyContextWorkspaceId });
+    return null;
+  }
+  let candidate;
+  try {
+    candidate = await resolver(ctx, companyContextWorkspaceId);
+  } catch (error) {
+    logCompanyContextBindingError(ctx, "source_root_resolver_failed", { companyContextWorkspaceId, err: error });
+    return null;
+  }
+  if (!candidate?.trim()) {
+    logCompanyContextBindingError(ctx, "missing_explicit_source_root", { companyContextWorkspaceId });
+    return null;
+  }
+  try {
+    const sourceRoot = await realpath(path.resolve(candidate));
+    const sourceStat = await stat2(sourceRoot);
+    if (!sourceStat.isDirectory()) {
+      logCompanyContextBindingError(ctx, "source_root_not_directory", { companyContextWorkspaceId, sourceRoot });
+      return null;
+    }
+    await access(sourceRoot, constants.R_OK);
+    return sourceRoot;
+  } catch (error) {
+    logCompanyContextBindingError(ctx, "source_root_unavailable", { companyContextWorkspaceId, sourceRoot: path.resolve(candidate), err: error });
+    return null;
+  }
+}
+function createGovernanceFilesystemBindings(service, options = {}) {
+  return async (ctx) => {
+    if (!service.isEnabled()) return void 0;
+    const user = userFromContext(ctx);
+    if (!user?.id) return [];
+    const rules = service.companyContextRules(user);
+    const companyContextWorkspaceId = service.companyContextWorkspaceId();
+    if (!companyContextWorkspaceId || rules.length === 0) return [];
+    if (ctx.workspaceId === companyContextWorkspaceId) return [];
+    const sourceRoot = await resolveCompanyContextSourceRoot(ctx, companyContextWorkspaceId, options.resolveCompanyContextRoot);
+    if (!sourceRoot) return [];
+    const projectionRootParent = options.projectionRootParent ?? os.tmpdir();
+    const binding = {
+      filesystem: COMPANY_CONTEXT_FILESYSTEM_ID,
+      access: "readonly",
+      mountPath: COMPANY_CONTEXT_MOUNT_PATH,
+      projection: "policy-filtered"
+    };
+    const boundCtx = {
+      humanUserId: user.id,
+      agentId: `agent:${ctx.sessionId ?? ctx.requestId ?? "request"}`,
+      sessionId: ctx.sessionId ?? ctx.requestId ?? "request",
+      workspaceId: ctx.workspaceId,
+      requestId: ctx.requestId ?? ctx.sessionId ?? "request"
+    };
+    const provider = new RegexFilteredCompanyContextProvider(sourceRoot, compileRules(rules), projectionRootParent);
+    const manager = new ScopedFilesystemRuntimeBindingManager({
+      resolver: { resolveBindings: async () => [binding] },
+      providers: { [COMPANY_CONTEXT_FILESYSTEM_ID]: provider }
+    });
+    async function withReadonlyOperations(fn) {
+      const plan = await manager.prepareRuntime(boundCtx);
+      try {
+        const prepared = plan.bindings.find((entry) => entry.binding.filesystem === COMPANY_CONTEXT_FILESYSTEM_ID);
+        if (!prepared) throw new Error("company_context binding was not prepared");
+        return await fn(createReadonlyProjectionOperations(prepared.handle));
+      } finally {
+        await manager.disposeRuntime(boundCtx);
+      }
+    }
+    const operations = {
+      read: (descriptor) => withReadonlyOperations((ops) => ops.read(descriptor)),
+      list: (descriptor) => withReadonlyOperations((ops) => ops.list(descriptor)),
+      find: (descriptor, pattern, opOptions) => withReadonlyOperations((ops) => ops.find(descriptor, pattern, opOptions)),
+      grep: (descriptor, pattern, opOptions) => withReadonlyOperations((ops) => ops.grep(descriptor, pattern, opOptions)),
+      stat: (descriptor) => withReadonlyOperations((ops) => ops.stat(descriptor)),
+      rejectMutation(operation, descriptor) {
+        return asRuntimeOperations(createReadonlyProjectionOperations({ filesystem: COMPANY_CONTEXT_FILESYSTEM_ID, projectionRoot: sourceRoot })).rejectMutation(operation, descriptor);
+      }
+    };
+    return [{ filesystem: COMPANY_CONTEXT_FILESYSTEM_ID, access: "readonly", operations }];
+  };
+}
+
+// src/server/index.ts
+async function buildGovernanceService(options = {}) {
+  return createGovernanceService(await loadGovernancePolicy(options));
+}
+async function createGovernance(config) {
+  const service = await buildGovernanceService({ config });
+  return {
+    service,
+    status: service.policyStatus(),
+    serverPlugin: createGovernanceServerPlugin(service),
+    filterModels: createGovernanceModelFilter(service),
+    createMeteringSink: (delegate, getDb) => createGovernanceMeteringSink({ service, delegate, getDb }),
+    getFilesystemBindings: (options = {}) => createGovernanceFilesystemBindings(service, {
+      resolveCompanyContextRoot: createDefaultCompanyContextRootResolver(),
+      ...options
+    }),
+    pi: { strictModelResolution: service.isEnabled() }
+  };
+}
+function governanceUserFromRequest(request) {
+  const user = request.user;
+  return user ? { id: user.id, email: user.email, emailVerified: user.emailVerified } : null;
+}
+function createGovernanceModelFilter(service) {
+  return async ({ request }, models, defaultModel) => {
+    const user = governanceUserFromRequest(request);
+    if (!service.isEnabled()) return { models, defaultModel };
+    if (!user) return { models: [] };
+    const allowedModels = service.allowedModelsForUser(user, models).filter((model) => (service.monthlyBudgetMicros(user, model) ?? 0) > 0);
+    const allowedDefault = defaultModel && allowedModels.some((model) => model.available && model.provider === defaultModel.provider && model.id === defaultModel.id) ? defaultModel : void 0;
+    return { models: allowedModels, defaultModel: allowedDefault };
+  };
+}
+function createGovernanceServerPlugin(service) {
+  return {
+    id: "full-app-governance",
+    label: "Full-app governance",
+    routes: async (app) => {
+      await app.register(governanceRoutes(service));
+      app.addHook("onReady", async () => {
+        await reconcileCompanyContextWorkspace(app, service);
+      });
+    }
+  };
+}
+export {
+  GOVERNANCE_DEV_EMAIL_VERIFICATION_OVERRIDE_ENV,
+  GOVERNANCE_POLICY_PATH_ENV,
+  GovernancePolicyError,
+  GovernanceService,
+  buildGovernanceService,
+  createDefaultCompanyContextRootResolver,
+  createGovernance,
+  createGovernanceFilesystemBindings,
+  createGovernanceMeteringSink,
+  createGovernanceModelFilter,
+  createGovernanceServerPlugin,
+  loadGovernancePolicy,
+  normalizePolicyEmail,
+  validateGovernancePolicy
+};