@crvouga/mockingbird-service-formbricks 3.6.0 → 3.7.0

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog — @crvouga/mockingbird-service-formbricks
 
-## 3.6.0 (2026-10-17)
+## 3.7.0 (2026-10-19)
+
+### Features
+
+- resolve the agent-reported issue queue in one batch ([25c52b6](https://github.com/crvouga/mockingbird/commit/25c52b668a53ddb80b968419601a20abf33f956b))
+
+## 3.6.0 (2026-10-16)
 
 ### Features
 

package/README.md

@@ -36,6 +36,25 @@ npx mockingbird-formbricks serve --port 8813 \
   --webhook-secret "whsec_…"
 ```
 
+Boot it with your own settings and surveys, without a wrapper process or a `PUT` after boot:
+
+```bash
+npx mockingbird-formbricks serve \
+  --settings '{"workspaces": ["cworkspace000000000000002"], "legacyEnvironmentIds": {"cenvironment0000000000002": "cworkspace000000000000002"}}' \
+  --surveys ./surveys.json
+```
+
+`--settings <json|file>` (or `MOCKINGBIRD_SETTINGS`, or a fleet entry's `settings`) takes the
+fields of `GET|PUT /__admin/settings`, checked with their types (a misspelled key is an error). They
+are every namespace's defaults, a reset returns to them, and a field you give replaces the
+built-in value whole (give `legacyEnvironmentIds` and the default environment alias is gone).
+`--workspace-id` adds to the booted `workspaces`. `--surveys <file>` (a list, or `{surveys: [...]}`)
+adds your surveys after the corpus ones for every namespace, and they survive a reset. A survey
+whose id the corpus (or an earlier row) already has is skipped, a survey with no `workspaceId` is served by
+every configured workspace, and `type`, `status` and a legacy `environmentId` are handled as
+`PUT /__admin/surveys` handles them. `--surveys-mode replace` uses the file as the whole corpus.
+In a fleet, set `options: {"surveys": "surveys.json"}`.
+
 ```ts
 import { WORKSPACE_ID } from "@crvouga/mockingbird-service-formbricks"
 import { createServer } from "@crvouga/mockingbird-service-formbricks/server"
@@ -135,7 +154,7 @@ string), `management_unauthorized`, `connection_drop`, `duplicate` (the next web
 | Export | Kind | Description |
 | --- | --- | --- |
 | `FormbricksAPI` | class | The in-process emulator: `fetch(request)`, `reset()`, `responses()`, `render(record)`, `wireSurvey(survey)`, `pipeline(event, record, survey)`, `state`. Options: `sqlite`, `now`, `namespace`, `surveys`, `settings`, `onWebhook`. |
-| `createRuntime` | function | The emulator with the full service contract (health, admin, namespaces, credentials, presets, webhooks). Options: `webhooks: {url, secret?, events?, retryDelaysMs?, fetch?}`, `surveys`, `settings`, `clock`, `seed`, `adminKey`, `onLog`, `sqlite`. |
+| `createRuntime` | function | The emulator with the full service contract (health, admin, namespaces, credentials, presets, webhooks). Options: `webhooks: {url, secret?, events?, retryDelaysMs?, fetch?}`, `surveys` (replaces the corpus; `serve --surveys` appends), `settings`, `clock`, `seed`, `adminKey`, `onLog`, `sqlite`. |
 | `FORMBRICKS_PRESETS` | object | Every named fault preset. |
 | `FORMBRICKS_NAMESPACE` | string | The service name, `"formbricks"`. |
 | `WEBHOOK_PATH` | string | A conventional receiver path for examples, `/webhooks/formbricks`. |

package/dist/{chunk-VZ55MOOA.js → chunk-M3VADEIL.js}

@@ -1,20 +1,38 @@
 import {
+  CORPUS_SURVEYS,
   DEFAULT_SETTINGS,
   createClock,
   createRuntime,
   normalizeBootControls,
   normalizeControls,
+  normalizeIdBase,
   ownedTransport,
   parseDuration,
   parseFaultHeader,
   resolveAdminPrefix,
   restoreClock
-} from "./chunk-THESW6F4.js";
+} from "./chunk-XJB56QGS.js";
+
+// src/server.ts
+import { readFileSync } from "node:fs";
 
 // ../../adapters/node/dist/cli.js
 import { readFile as readFile5 } from "node:fs/promises";
 import { parseArgs } from "node:util";
 
+// ../../adapters/node/dist/boot-settings.js
+var checkSettings = (target, settings, label) => {
+  if (!target.parseSettings)
+    throw new Error(`${label}: ${target.name} takes no boot settings`);
+  try {
+    return target.parseSettings(settings);
+  } catch (error) {
+    throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`, {
+      cause: error
+    });
+  }
+};
+
 // ../../adapters/node/dist/fleet.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
@@ -2664,6 +2682,9 @@ var fleet_config_schema_default = {
     adminControls: {
       $ref: "#/$defs/controls"
     },
+    idBase: {
+      $ref: "#/$defs/idBase"
+    },
     namespace: {
       type: "string",
       pattern: "^[A-Za-z0-9_.-]{1,64}$"
@@ -2753,6 +2774,12 @@ var fleet_config_schema_default = {
         adminControls: {
           $ref: "#/$defs/controls"
         },
+        idBase: {
+          $ref: "#/$defs/idBase"
+        },
+        settings: {
+          type: "object"
+        },
         fixtures: {
           type: "object"
         },
@@ -2799,6 +2826,18 @@ var fleet_config_schema_default = {
         }
       }
     },
+    idBase: {
+      anyOf: [
+        {
+          type: "integer",
+          minimum: 0
+        },
+        {
+          type: "string",
+          pattern: "^(boot|[0-9]+)$"
+        }
+      ]
+    },
     controls: {
       type: "object",
       additionalProperties: false,
@@ -2948,6 +2987,8 @@ async function preflightFleet(config, options) {
     throw new Error("protected archive policy requires a protected repository; configure its protector before startup");
   resolveAdminPrefix(config.adminPrefix);
   normalizeBootControls(config.adminControls);
+  if (config.idBase !== void 0)
+    normalizeIdBase(config.idBase, "idBase");
   const targets = /* @__PURE__ */ new Map();
   const ports = /* @__PURE__ */ new Set();
   for (const [name, entry] of Object.entries(config.services)) {
@@ -2979,6 +3020,13 @@ async function preflightFleet(config, options) {
             throw new Error("invalid protocol namespace selector");
         }
       }
+      if (entry.idBase !== void 0)
+        normalizeIdBase(entry.idBase, "idBase");
+      if (entry.settings !== void 0) {
+        if (protocol !== "http" || !("create" in target))
+          throw new Error("settings: only HTTP services take boot settings");
+        checkSettings(target, entry.settings, "settings");
+      }
       const port = entry.port ?? target.defaultPort;
       if (port !== 0) {
         const key = `${entry.host ?? "127.0.0.1"}:${port}`;
@@ -3014,7 +3062,7 @@ async function preflightFleet(config, options) {
             break;
         }
       }
-      targets.set(name, { ...target, packageVersion: packageVersion ?? "3.6.0" });
+      targets.set(name, { ...target, packageVersion: packageVersion ?? "3.7.0" });
     } catch (error) {
       throw new Error(`service ${name}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -3334,6 +3382,7 @@ var httpChild = async (target, entry, options, admission, generation, privateAcc
       options.onLog?.(entry2);
     },
     ...entry.adminControls !== void 0 ? { adminControls: entry.adminControls } : {},
+    ...entry.settings !== void 0 ? { settings: checkSettings(target, entry.settings, "settings") } : {},
     ...entry.fixtures !== void 0 ? { fixtures: entry.fixtures } : {},
     ...(advertisedHttpBase(entry) ?? entry.baseUrl) !== void 0 ? { baseUrl: advertisedHttpBase(entry) ?? entry.baseUrl } : {}
   });
@@ -3352,6 +3401,8 @@ var httpChild = async (target, entry, options, admission, generation, privateAcc
   ].some((method) => typeof created[method] !== "function"))
     throw new Error("HTTP target does not implement the fleet runtime protocol; build/install matching supported service versions");
   const runtime = created;
+  if (entry.idBase !== void 0)
+    runtime.setIdBase?.(entry.idBase);
   const unobserve = runtime.webhooks?.observeDeliveries(observer.delivery);
   if (options.outbound && runtime.webhooks)
     runtime.webhooks.setTransportPolicy(ownedTransport(options.outbound));
@@ -3950,6 +4001,7 @@ async function startFleet(config, options) {
           ...entry,
           adminPrefix: resolveAdminPrefix(entry.adminPrefix ?? adminPrefix),
           ...adminKey !== void 0 ? { adminKey } : {},
+          ...(entry.idBase ?? config.idBase) !== void 0 ? { idBase: entry.idBase ?? config.idBase } : {},
           // Fleet-wide controls, with the service's own keys replacing them.
           ...config.adminControls !== void 0 || entry.adminControls !== void 0 ? { adminControls: { ...config.adminControls, ...entry.adminControls } } : {}
         }, options, (namespace, request) => management?.admit(namespace, request), (namespace) => management?.generation(namespace), (namespace, request) => management?.privateRequest(namespace, request) ?? false, {
@@ -4634,6 +4686,16 @@ var COMMON_SERVE_OPTIONS = {
     value: "<seed>",
     description: "Seed for every random choice (env MOCKINGBIRD_SEED)"
   },
+  "id-base": {
+    type: "string",
+    value: "<n|boot>",
+    description: "Start generated ids at this base so a restart does not reissue the last boot's ids; boot derives one from the clock (env MOCKINGBIRD_ID_BASE; default 0, the same ids every boot)"
+  },
+  settings: {
+    type: "string",
+    value: "<json|file>",
+    description: "Service settings to boot with, as JSON or a JSON file; every namespace starts from them (env MOCKINGBIRD_SETTINGS; only for services that declare settings)"
+  },
   "admin-controls": {
     type: "string",
     value: "<json|file>",
@@ -4728,19 +4790,40 @@ var readJsonFile = async (path, label) => {
   }
 };
 var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJsonOption = async (source, label) => {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      throw new Error(`${label}: not valid JSON`);
+    }
+  }
+  return readJsonFile(source, label);
+};
+var resolveServeIdBase = (values, env = process.env) => {
+  const source = asString(values["id-base"]) ?? env.MOCKINGBIRD_ID_BASE;
+  if (source === void 0 || source.trim() === "")
+    return void 0;
+  normalizeIdBase(source.trim(), "--id-base");
+  return source.trim();
+};
+var resolveServeSettings = async (target, values, env = process.env) => {
+  const flag = asString(values.settings);
+  const source = flag ?? env.MOCKINGBIRD_SETTINGS;
+  if (source === void 0 || source.trim() === "")
+    return void 0;
+  const label = flag !== void 0 ? "--settings" : "MOCKINGBIRD_SETTINGS";
+  const parsed = await readJsonOption(source, label);
+  if (!isObject2(parsed))
+    throw new Error(`${label}: expected a JSON object`);
+  return checkSettings(target, parsed, label);
+};
 var resolveServeControls = async (values, env = process.env, base) => {
   const source = asString(values["admin-controls"]) ?? env.MOCKINGBIRD_ADMIN_CONTROLS;
   let document = isObject2(base) ? { ...base } : {};
   if (source !== void 0 && source.trim() !== "") {
-    let parsed;
-    if (source.trim().startsWith("{")) {
-      try {
-        parsed = JSON.parse(source);
-      } catch {
-        throw new Error("--admin-controls: not valid JSON");
-      }
-    } else
-      parsed = await readJsonFile(source, "--admin-controls");
+    const parsed = source.trim().startsWith("{") ? await readJsonOption(source, "--admin-controls") : await readJsonFile(source, "--admin-controls");
     if (!isObject2(parsed))
       throw new Error("--admin-controls: expected a JSON object");
     document = { ...document, ...parsed };
@@ -4790,8 +4873,11 @@ var start = async (target, values, config) => {
     adminKey: config.adminKey,
     seed: config.seed,
     onLog: formatLog(config.log),
+    ...config.settings !== void 0 ? { settings: config.settings } : {},
     ...config.adminControls !== void 0 ? { adminControls: config.adminControls } : {}
   });
+  if (config.idBase !== void 0)
+    runtime.setIdBase?.(config.idBase);
   const listening = await listen(runtime, { port: config.port, host: config.host });
   target.listening?.(listening);
   console.log(`${target.name} emulator listening on ${listening.url}`);
@@ -4837,6 +4923,11 @@ var serveCommand = (target) => ({
         const adminControls = await resolveServeControls(values, process.env, config.adminControls);
         if (adminControls !== void 0)
           config.adminControls = adminControls;
+        if (values.settings !== void 0)
+          throw new Error("--settings serves a single service; give each service its own `settings` in the config");
+        const idBase = config.idBase ?? resolveServeIdBase(values);
+        if (idBase !== void 0)
+          config.idBase = idBase;
         const fleet = await startFleet(config, {
           load: (name) => loadTarget(name, target),
           onLog: formatLog(config.log ?? log),
@@ -4866,8 +4957,12 @@ var serveCommand = (target) => ({
     let listening;
     try {
       const adminControls = await resolveServeControls(values);
+      const idBase = resolveServeIdBase(values);
+      const settings = await resolveServeSettings(target, values);
       listening = await start(target, values, {
         ...adminControls !== void 0 ? { adminControls } : {},
+        ...idBase !== void 0 ? { idBase } : {},
+        ...settings !== void 0 ? { settings } : {},
         adminPrefix: resolveAdminPrefix(asString(values["admin-prefix"]) ?? process.env.MOCKINGBIRD_ADMIN_PREFIX),
         port: port === void 0 ? target.defaultPort : Number.parseInt(port, 10),
         host: asString(values.host) ?? "127.0.0.1",
@@ -4883,6 +4978,84 @@ var serveCommand = (target) => ({
   }
 });
 
+// src/boot.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var strings = (value, where) => {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+    throw new Error(`${where} must be an array of strings`);
+  return value;
+};
+var KEYS = [
+  "workspaces",
+  "legacyEnvironmentIds",
+  "apiKeys",
+  "webhookId",
+  "contactsEnabled",
+  "validation"
+];
+var parseBootSettings = (input) => {
+  for (const key of Object.keys(input))
+    if (!KEYS.includes(key)) throw new Error(`unknown setting ${JSON.stringify(key)}`);
+  const out = {};
+  if (input.workspaces !== void 0) out.workspaces = strings(input.workspaces, "workspaces");
+  if (input.legacyEnvironmentIds !== void 0) {
+    const aliases = input.legacyEnvironmentIds;
+    if (!isRecord(aliases) || Object.values(aliases).some((id) => typeof id !== "string"))
+      throw new Error("legacyEnvironmentIds must be an object of workspace ids by environment id");
+    out.legacyEnvironmentIds = aliases;
+  }
+  if (input.apiKeys !== void 0) out.apiKeys = strings(input.apiKeys, "apiKeys");
+  if (input.webhookId !== void 0) {
+    if (typeof input.webhookId !== "string") throw new Error("webhookId must be a string");
+    out.webhookId = input.webhookId;
+  }
+  if (input.contactsEnabled !== void 0) {
+    if (typeof input.contactsEnabled !== "boolean")
+      throw new Error("contactsEnabled must be a boolean");
+    out.contactsEnabled = input.contactsEnabled;
+  }
+  if (input.validation !== void 0) {
+    if (input.validation !== "present-only" && input.validation !== "finished-validates-all")
+      throw new Error('validation must be "present-only" or "finished-validates-all"');
+    out.validation = input.validation;
+  }
+  return out;
+};
+var parseSurveysDocument = (input, legacyEnvironmentIds = {}) => {
+  const list = Array.isArray(input) ? input : isRecord(input) ? input.surveys : void 0;
+  if (!Array.isArray(list)) throw new Error("expected [survey] or {surveys: [survey]}");
+  return list.map((entry, index) => {
+    const where = `surveys[${index}]`;
+    if (!isRecord(entry)) throw new Error(`${where} must be an object`);
+    if (typeof entry.id !== "string" || entry.id === "")
+      throw new Error(`${where}.id must be a non-empty string`);
+    if (typeof entry.name !== "string") throw new Error(`${where}.name must be a string`);
+    const { environmentId, ...rest } = entry;
+    for (const key of ["workspaceId", "environmentId", "type", "status"])
+      if (entry[key] !== void 0 && entry[key] !== null && typeof entry[key] !== "string")
+        throw new Error(`${where}.${key} must be a string`);
+    const owner = entry.workspaceId ?? environmentId;
+    return {
+      ...rest,
+      id: entry.id,
+      name: entry.name,
+      type: entry.type ?? "app",
+      status: entry.status ?? "inProgress",
+      workspaceId: owner ? legacyEnvironmentIds[owner] ?? owner : null
+    };
+  });
+};
+var appendSurveys = (base, extra) => {
+  const seen = new Set(base.map((survey) => survey.id));
+  const out = [...base];
+  for (const survey of extra) {
+    if (seen.has(survey.id)) continue;
+    seen.add(survey.id);
+    out.push(survey);
+  }
+  return out;
+};
+
 // src/server.ts
 var DEFAULT_PORT = 8813;
 var createServer2 = async (options = {}) => {
@@ -4895,9 +5068,24 @@ var createServer2 = async (options = {}) => {
   return { ...listening, runtime };
 };
 var text = (value) => typeof value === "string" ? value : void 0;
+var loadSurveysFile = (path, mode = "append", legacyEnvironmentIds = DEFAULT_SETTINGS.legacyEnvironmentIds) => {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    throw new Error(`formbricks surveys not found: ${path}`);
+  }
+  try {
+    const surveys = parseSurveysDocument(JSON.parse(raw), legacyEnvironmentIds);
+    return appendSurveys(mode === "replace" ? [] : CORPUS_SURVEYS, surveys);
+  } catch (error) {
+    throw new Error(`formbricks surveys ${path}: ${error.message}`);
+  }
+};
 var serveTarget = {
   name: "formbricks",
   defaultPort: DEFAULT_PORT,
+  parseSettings: (settings) => parseBootSettings(settings),
   options: {
     "webhook-url": {
       type: "string",
@@ -4918,6 +5106,16 @@ var serveTarget = {
       type: "string",
       value: "<id>",
       description: "An extra workspace id that serves the survey corpus"
+    },
+    surveys: {
+      type: "string",
+      value: "<file.json>",
+      description: "Surveys every namespace starts with, as a list or {surveys: [...]}, added after the corpus surveys (a repeated id is skipped)"
+    },
+    "surveys-mode": {
+      type: "string",
+      value: "<append|replace>",
+      description: "With --surveys: add to the corpus (default) or use the file as the whole corpus"
     }
   },
   create: (values, common) => {
@@ -4925,10 +5123,28 @@ var serveTarget = {
     const token = text(values["webhook-token"]);
     const secret = text(values["webhook-secret"]);
     const workspace = text(values["workspace-id"]);
+    const surveysPath = text(values.surveys);
+    const mode = text(values["surveys-mode"]);
+    if (mode !== void 0 && mode !== "append" && mode !== "replace")
+      throw new Error('--surveys-mode must be "append" or "replace"');
+    if (mode !== void 0 && surveysPath === void 0)
+      throw new Error("--surveys-mode needs --surveys");
+    const boot = common.settings;
+    const settings = {
+      ...boot,
+      ...workspace ? { workspaces: [workspace, ...boot?.workspaces ?? DEFAULT_SETTINGS.workspaces] } : {}
+    };
     const target = url && token ? `${url}${url.includes("?") ? "&" : "?"}token=${encodeURIComponent(token)}` : url;
     return createRuntime({
       ...target ? { webhooks: { url: target, ...secret ? { secret } : {} } } : {},
-      ...workspace ? { settings: { workspaces: [workspace, ...DEFAULT_SETTINGS.workspaces] } } : {},
+      ...Object.keys(settings).length > 0 ? { settings } : {},
+      ...surveysPath ? {
+        surveys: loadSurveysFile(
+          surveysPath,
+          mode,
+          settings.legacyEnvironmentIds ?? DEFAULT_SETTINGS.legacyEnvironmentIds
+        )
+      } : {},
       ...common.adminPrefix !== void 0 ? { adminPrefix: common.adminPrefix } : {},
       ...common.adminKey !== void 0 ? { adminKey: common.adminKey } : {},
       ...common.adminControls !== void 0 ? { adminControls: common.adminControls } : {},
@@ -4947,6 +5163,7 @@ export {
   serveCommand,
   DEFAULT_PORT,
   createServer2 as createServer,
+  loadSurveysFile,
   serveTarget
 };
-//# sourceMappingURL=chunk-VZ55MOOA.js.map
+//# sourceMappingURL=chunk-M3VADEIL.js.map