@hasna/recordings 0.3.2 → 0.3.9

package/dist/server/index.js

@@ -17,8 +17,125 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "@hasna/recordings",
+    version: "0.3.9",
+    type: "module",
+    description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/hasna/apps"
+    },
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
+    bin: {
+      recordings: "dist/cli/index.js",
+      "recordings-mcp": "dist/mcp/index.js",
+      "recordings-serve": "dist/server/index.js"
+    },
+    exports: {
+      ".": {
+        import: "./dist/index.js",
+        types: "./dist/index.d.ts"
+      },
+      "./storage": {
+        import: "./dist/storage.js",
+        types: "./dist/storage.d.ts"
+      },
+      "./sdk": {
+        import: "./dist/sdk/index.js",
+        types: "./dist/sdk/index.d.ts"
+      }
+    },
+    engines: {
+      bun: ">=1.0.0"
+    },
+    scripts: {
+      clean: "rm -rf dist",
+      build: "bun run clean && bun run build:cli && bun run build:mcp && bun run build:serve && bun run build:lib && tsc --emitDeclarationOnly --outDir dist",
+      "build:cli": "bun build src/cli/index.ts --target=bun --outfile=dist/cli/index.js --external=commander --external=chalk --external=openai",
+      "build:mcp": "bun build src/mcp/index.ts --target=bun --outfile=dist/mcp/index.js --external=@modelcontextprotocol/sdk --external=openai",
+      "build:serve": "bun build src/server/index.ts --target=bun --outfile=dist/server/index.js --external=@modelcontextprotocol/sdk --external=@hasna/contracts --external=openai --external=pg",
+      "build:lib": "bun build src/index.ts src/storage.ts src/sdk/index.ts --target=bun --outdir=dist --external=openai",
+      "build:native-fs-guard": "/bin/bash scripts/build_native_fs_guard.sh",
+      "generate:sdk": "bun run scripts/generate-sdk.ts",
+      migrate: "bun run scripts/migrate.ts",
+      typecheck: "tsc --noEmit",
+      "typecheck:tcc-contract": "tsc --noEmit -p tsconfig.tcc-contract.json",
+      test: "bun test",
+      "verify:ci-suite": "bun scripts/ci-linux-suite.ts --check",
+      "verify:ci-suite:run": "bun scripts/ci-linux-suite.ts --verify-run",
+      "verify:ci-native": "bun scripts/ci-native-build.ts",
+      "test:gated": 'bun scripts/ci-linux-suite.ts --check && RECORDINGS_TEST_TIMEOUT_MS="${RECORDINGS_TEST_TIMEOUT_MS:-120000}" bun test --timeout "$RECORDINGS_TEST_TIMEOUT_MS" $(bun scripts/ci-linux-suite.ts --gated)',
+      "test:vacuity-battery": 'bun scripts/vacuity-manifest-gen.ts > "${TMPDIR:-/tmp}/vacuity-corrupt-sites.tsv" && bun scripts/vacuity-mutation-battery.ts "${TMPDIR:-/tmp}/vacuity-corrupt-sites.tsv"',
+      "test:vacuity-battery:source": "bun scripts/vacuity-mutation-battery.ts scripts/vacuity-manifests/source-side.tsv",
+      "test:vacuity-battery:chain": "bun scripts/vacuity-mutation-battery.ts scripts/vacuity-manifests/install-chain.tsv",
+      "test:vacuity-battery:vars": "bun scripts/vacuity-mutation-battery.ts scripts/vacuity-manifests/variable-operands.tsv",
+      "test:vacuity-battery:reorder": "bun scripts/vacuity-mutation-battery.ts scripts/vacuity-manifests/reorder.tsv",
+      "test:coverage": "bun test --coverage",
+      "dev:cli": "bun run src/cli/index.ts",
+      "desktop:snapshot": "bun run src/cli/index.ts app snapshot",
+      "dev:mcp": "bun run src/mcp/index.ts",
+      "verify:release": "bun run scripts/release-guard.ts",
+      "scan:artifact": "bun run scripts/scan-artifact.ts",
+      "version:set": "bun run scripts/set-version.ts",
+      "version:check": "bun run scripts/set-version.ts --check",
+      prepack: "bun run prepack:platform-gate && bun run version:check && bun run build && bun run verify:release && bun run scan:artifact",
+      "prepack:platform-gate": `bash -c 'if [ "$(uname -s)" = Darwin ]; then bun run build:native-fs-guard; else echo "WARN: native fs-guard build skipped on $(uname -s) \u2014 dry-run/CI pack; publish recordings from macOS"; fi'`,
+      prepublishOnly: "bun run typecheck && bun run release-suite-gate",
+      "release-suite-gate": "bun run scripts/release-suite-gate.ts",
+      "typecheck:shortcut-contract": "tsc --noEmit -p tsconfig.test.json"
+    },
+    files: [
+      "dist/",
+      "scripts/",
+      "Dockerfile.package",
+      "bun.lock",
+      "src/native/Recordings/App/",
+      "src/native/Recordings/RecordingsLib/",
+      "src/native/Recordings/RecordingsTests/",
+      "src/native/Recordings/Updater/",
+      "src/native/Recordings/Package.swift",
+      "src/native/Recordings/Package.resolved",
+      "src/native/Recordings/build.sh",
+      "packaging/macos/",
+      "README.md",
+      "LICENSE"
+    ],
+    dependencies: {
+      "@hasna/contracts": "0.13.4",
+      "@hasna/events": "0.1.11",
+      "@modelcontextprotocol/sdk": "^1.12.1",
+      chalk: "^5.4.1",
+      commander: "^13.1.0",
+      openai: "^5.1.0",
+      pg: "^8.13.3",
+      zod: "^3.24.2"
+    },
+    devDependencies: {
+      "@types/bun": "^1.2.5",
+      "@types/pg": "^8.11.11",
+      "node-api-headers": "1.9.0",
+      typescript: "^5.8.2"
+    },
+    publishConfig: {
+      registry: "https://registry.npmjs.org",
+      access: "public"
+    },
+    license: "Apache-2.0",
+    author: "Hasna <andrei@hasna.com>"
+  };
+});
+
 // src/version.ts
-var VERSION = "0.3.2";
+var VERSION;
+var init_version = __esm(() => {
+  init_package();
+  VERSION = package_default.version;
+});
 
 // src/db/remote-storage.ts
 import pg from "pg";
@@ -82,59 +199,12 @@ class PgAdapterAsync {
 }
 var init_remote_storage = () => {};
 
-// src/lib/retired-deployment-modes.ts
-function normalizeModeToken(value) {
-  return value.trim().toLowerCase().replace(/-/g, "_");
-}
-function asRetiredDeploymentMode(value) {
-  const token = normalizeModeToken(value);
-  return RETIRED_DEPLOYMENT_MODES.includes(token) ? token : null;
-}
-function retiredDeploymentModeError(rawValue, sourceEnvKey, replacement) {
-  const mode = asRetiredDeploymentMode(rawValue);
-  const value = mode === "local" ? replacement.onBox : replacement.offBox;
-  return new Error(`${sourceEnvKey}=${rawValue} names a deployment mode, and deployment modes are removed: ` + `${RETIRED_DEPLOYMENT_MODES.join(" | ")} no longer select anything. ` + `Set ${replacement.envKey}=${value} instead ` + `(${replacement.envKey} takes ${replacement.onBox} or ${replacement.offBox}).`);
-}
-var RETIRED_DEPLOYMENT_MODES;
-var init_retired_deployment_modes = __esm(() => {
-  RETIRED_DEPLOYMENT_MODES = [
-    "local",
-    "self_hosted",
-    "cloud",
-    "remote",
-    "hybrid"
-  ];
-});
-
 // src/server/cloud-config.ts
-function backendReplacement() {
-  return { envKey: DATA_BACKEND_ENV_KEYS[0], onBox: "sqlite", offBox: "postgresql" };
-}
-function resolveCloudDatabaseUrl(env = process.env) {
+function resolveDatabaseUrl(env = process.env) {
   return env.HASNA_RECORDINGS_DATABASE_URL || env.RECORDINGS_DATABASE_URL || env.DATABASE_URL || undefined;
 }
-function configuredDataBackend(env = process.env) {
-  for (const key of DATA_BACKEND_ENV_KEYS) {
-    const raw = env[key]?.trim();
-    if (!raw)
-      continue;
-    const token = normalizeModeToken(raw);
-    if (token === "sqlite")
-      return { backend: "sqlite", source: key };
-    if (token === "postgresql" || token === "postgres")
-      return { backend: "postgresql", source: key };
-    if (asRetiredDeploymentMode(raw)) {
-      throw retiredDeploymentModeError(raw, key, backendReplacement());
-    }
-    throw new Error(`${key}=${raw} is not a data backend. Use ${DATA_BACKEND_ENV_KEYS[0]}=sqlite or ` + `${DATA_BACKEND_ENV_KEYS[0]}=postgresql.`);
-  }
-  return null;
-}
 function resolveDataBackend(env = process.env) {
-  const configured = configuredDataBackend(env);
-  if (configured)
-    return configured.backend;
-  return resolveCloudDatabaseUrl(env) ? "postgresql" : "sqlite";
+  return resolveDatabaseUrl(env) ? "postgresql" : "sqlite";
 }
 function isPostgresBackendEnabled(env = process.env) {
   return resolveDataBackend(env) === "postgresql";
@@ -152,14 +222,6 @@ function requireSigningSecret(env = process.env) {
   }
   return signingSecret;
 }
-var DATA_BACKEND_ENV_KEYS;
-var init_cloud_config = __esm(() => {
-  init_retired_deployment_modes();
-  DATA_BACKEND_ENV_KEYS = [
-    "HASNA_RECORDINGS_STORAGE_MODE",
-    "RECORDINGS_STORAGE_MODE"
-  ];
-});
 
 // src/server/cloud-readiness.ts
 var exports_cloud_readiness = {};
@@ -221,7 +283,7 @@ async function assertCloudSchemaContract(pg2) {
                   ON attribute_row.attrelid = constraint_row.conrelid
                  AND attribute_row.attnum = key_row.attnum
                ORDER BY key_row.position
-            ) AS columns,
+            )::text[] AS columns,
             referenced_namespace.nspname AS referenced_schema,
             referenced_table.relname AS referenced_table,
             CASE WHEN constraint_row.confrelid = 0 THEN ARRAY[]::text[] ELSE ARRAY(
@@ -231,7 +293,7 @@ async function assertCloudSchemaContract(pg2) {
                   ON attribute_row.attrelid = constraint_row.confrelid
                  AND attribute_row.attnum = key_row.attnum
                ORDER BY key_row.position
-            ) END AS referenced_columns,
+            )::text[] END AS referenced_columns,
             NULLIF(constraint_row.confdeltype::text, ' ') AS delete_action,
             NULLIF(constraint_row.confupdtype::text, ' ') AS update_action,
             NULLIF(constraint_row.confmatchtype::text, ' ') AS match_type
@@ -265,7 +327,7 @@ async function assertCloudSchemaContract(pg2) {
                  AND attribute_row.attnum = key_row.attnum
                WHERE key_row.position <= index_row.indnkeyatts
                ORDER BY key_row.position
-            ) AS columns
+            )::text[] AS columns
        FROM pg_index index_row
        JOIN pg_class table_row ON table_row.oid = index_row.indrelid
        JOIN pg_namespace namespace_row ON namespace_row.oid = table_row.relnamespace
@@ -671,8 +733,8 @@ var init_migrate_command = __esm(() => {
 var exports_cloud = {};
 __export(exports_cloud, {
   resolveSigningSecret: () => resolveSigningSecret,
+  resolveDatabaseUrl: () => resolveDatabaseUrl,
   resolveDataBackend: () => resolveDataBackend,
-  resolveCloudDatabaseUrl: () => resolveCloudDatabaseUrl,
   requireSigningSecret: () => requireSigningSecret,
   pingCloudConnectivity: () => pingCloudConnectivity2,
   pingCloud: () => pingCloud,
@@ -682,7 +744,6 @@ __export(exports_cloud, {
   getCloudPg: () => getCloudPg,
   getApiKeyStore: () => getApiKeyStore,
   ensureCloudSchema: () => ensureCloudSchema,
-  configuredDataBackend: () => configuredDataBackend,
   closeCloud: () => closeCloud,
   RECORDINGS_APP_SLUG: () => RECORDINGS_APP_SLUG
 });
@@ -691,7 +752,7 @@ import { ApiKeyStore } from "@hasna/contracts/auth";
 function getCloudPg() {
   if (cachedPg)
     return cachedPg;
-  const url = resolveCloudDatabaseUrl();
+  const url = resolveDatabaseUrl();
   if (!url) {
     throw new Error("The /v1 API requires a PostgreSQL database URL (HASNA_RECORDINGS_DATABASE_URL / RECORDINGS_DATABASE_URL / DATABASE_URL).");
   }
@@ -759,10 +820,8 @@ async function closeCloud() {
 var RECORDINGS_APP_SLUG = "recordings", cachedPg = null, cachedStore = null, cachedVerifier = null, schemaEnsured = null;
 var init_cloud = __esm(() => {
   init_remote_storage();
-  init_cloud_config();
   init_cloud_readiness();
   init_migrate_command();
-  init_cloud_config();
 });
 
 // src/db/errors.ts
@@ -1672,6 +1731,7 @@ function buildV1OpenApiDocument(version = VERSION) {
 }
 var recordingSchema, agentSchema, projectSchema;
 var init_openapi = __esm(() => {
+  init_version();
   recordingSchema = {
     type: "object",
     properties: {
@@ -6727,38 +6787,34 @@ function saveFeedback2(input) {
 }
 var init_feedback = __esm(() => {
   init_database();
+  init_version();
 });
 
 // src/http/client.ts
+import { createClientTransport } from "@hasna/contracts/client";
+import {
+  createHasnaStorageClient,
+  resolveStorageClient
+} from "@hasna/contracts/client/storage";
 function envToken(name) {
   return name.toUpperCase().replace(/-/g, "_");
 }
-function clientStoreReplacement(envKey) {
-  return { envKey, onBox: "sqlite", offBox: "http" };
+function envKeys(name) {
+  const token = envToken(name);
+  return {
+    storeKeys: [`HASNA_${token}_CLIENT_STORE`, `${token}_CLIENT_STORE`],
+    apiUrlKeys: [`HASNA_${token}_API_URL`],
+    apiKeyKeys: [`HASNA_${token}_API_KEY`]
+  };
 }
-function normalizeClientStore(value, sourceEnvKey, replacementEnvKey) {
-  const normalized = normalizeModeToken(value);
+function normalizeClientStore(value) {
+  const normalized = value.trim().toLowerCase();
   if (normalized === "sqlite")
     return "sqlite";
   if (normalized === "http" || normalized === "https")
     return "http";
-  if (asRetiredDeploymentMode(value)) {
-    throw retiredDeploymentModeError(value, sourceEnvKey, clientStoreReplacement(replacementEnvKey));
-  }
   throw new Error(`Unknown client store: ${value}. Use sqlite or http.`);
 }
-function defaultApiBaseUrl(name) {
-  return `http://localhost:8874`;
-}
-function envKeys(name) {
-  const token = envToken(name);
-  return {
-    storeKeys: [`HASNA_${token}_CLIENT_STORE`, `${token}_CLIENT_STORE`],
-    retiredModeKeys: [`HASNA_${token}_STORAGE_MODE`, `HASNA_${token}_MODE`, `${token}_STORAGE_MODE`, `${token}_MODE`],
-    apiUrlKeys: [`HASNA_${token}_API_URL`, `${token}_API_URL`],
-    apiKeyKeys: [`HASNA_${token}_API_KEY`, `${token}_API_KEY`]
-  };
-}
 function firstEnv(env, keys) {
   for (const key of keys) {
     const value = env[key]?.trim();
@@ -6767,20 +6823,6 @@ function firstEnv(env, keys) {
   }
   return null;
 }
-function assertNoRetiredMode(env, keys) {
-  for (const key of keys.retiredModeKeys) {
-    const value = env[key]?.trim();
-    if (!value)
-      continue;
-    const normalized = normalizeModeToken(value);
-    if (SERVER_BACKEND_VALUES.includes(normalized))
-      continue;
-    if (asRetiredDeploymentMode(value)) {
-      throw retiredDeploymentModeError(value, key, clientStoreReplacement(keys.storeKeys[0]));
-    }
-    throw new Error(`${key}=${value} is not a client store. ${key} no longer selects one; ` + `set ${keys.storeKeys[0]}=sqlite or ${keys.storeKeys[0]}=http instead.`);
-  }
-}
 function toV1BaseUrl(apiUrl) {
   const url = new URL(apiUrl);
   if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -6796,22 +6838,44 @@ function toV1BaseUrl(apiUrl) {
 }
 function resolveTransport(name, env = process.env) {
   const keys = envKeys(name);
-  assertNoRetiredMode(env, keys);
   const storeHit = firstEnv(env, keys.storeKeys);
   const urlHit = firstEnv(env, keys.apiUrlKeys);
   const keyHit = firstEnv(env, keys.apiKeyKeys);
   let requested = "sqlite";
   let modeSource = "default";
   if (storeHit) {
-    requested = normalizeClientStore(storeHit.value, storeHit.key, keys.storeKeys[0]);
+    requested = normalizeClientStore(storeHit.value);
     modeSource = storeHit.key;
   } else if (urlHit && keyHit) {
     requested = "http";
     modeSource = "auto:api-url+api-key";
+  } else if (urlHit || keyHit) {
+    const missing = urlHit ? keys.apiKeyKeys[0] : keys.apiUrlKeys[0];
+    const present = urlHit ? keys.apiUrlKeys[0] : keys.apiKeyKeys[0];
+    return {
+      transport: "sqlite",
+      requested,
+      modeSource,
+      baseUrl: null,
+      apiKeyPresent: Boolean(keyHit),
+      misconfigured: true,
+      warning: `${present} is set but ${missing} is not: the hosted API is only ` + `selected when BOTH are present. Set ${missing}, or unset ${present} to ` + `use the on-box store.`
+    };
   }
   if (requested === "sqlite") {
     return { transport: "sqlite", requested, modeSource, baseUrl: null, apiKeyPresent: Boolean(keyHit), misconfigured: false, warning: null };
   }
+  if (!urlHit) {
+    return {
+      transport: "sqlite",
+      requested,
+      modeSource,
+      baseUrl: null,
+      apiKeyPresent: Boolean(keyHit),
+      misconfigured: true,
+      warning: `${modeSource}=http but no API URL is set (${keys.apiUrlKeys[0]}). Refusing to route to the API.`
+    };
+  }
   if (!keyHit) {
     return {
       transport: "sqlite",
@@ -6823,7 +6887,7 @@ function resolveTransport(name, env = process.env) {
       warning: `${modeSource}=http but no API key is set (${keys.apiKeyKeys[0]}). Refusing to route to the API.`
     };
   }
-  const rawUrl = urlHit?.value ?? defaultApiBaseUrl(name);
+  const rawUrl = urlHit.value;
   let baseUrl;
   try {
     baseUrl = toV1BaseUrl(rawUrl);
@@ -6833,201 +6897,38 @@ function resolveTransport(name, env = process.env) {
   }
   return { transport: "http", requested, modeSource, baseUrl, apiKeyPresent: true, misconfigured: false, warning: null };
 }
-function appendQuery(path, query) {
-  if (!query)
-    return path;
-  const params = new URLSearchParams;
-  for (const [key, value] of Object.entries(query)) {
-    if (value === null || value === undefined)
-      continue;
-    if (Array.isArray(value))
-      for (const v of value)
-        params.append(key, String(v));
-    else
-      params.append(key, String(value));
-  }
-  const qs = params.toString();
-  return qs ? `${path}${path.includes("?") ? "&" : "?"}${qs}` : path;
-}
-function createHttpTransport(options) {
-  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
-  const base = options.baseUrl.replace(/\/+$/, "");
-  const timeoutMs = options.timeoutMs ?? 30000;
-  const sleep = options.sleepImpl ?? defaultSleep;
-  async function once(method, rel, url, body, opts) {
-    const headers = {
-      "x-api-key": options.apiKey,
-      Authorization: `Bearer ${options.apiKey}`,
-      Accept: "application/json",
-      ...opts.headers ?? {}
-    };
-    if (opts.idempotencyKey)
-      headers["Idempotency-Key"] = opts.idempotencyKey;
-    const init = { method, headers };
-    if (body !== undefined) {
-      headers["Content-Type"] = "application/json";
-      init.body = JSON.stringify(body);
-    }
-    const controller = new AbortController;
-    const onAbort = () => controller.abort();
-    if (opts.signal) {
-      if (opts.signal.aborted)
-        controller.abort();
-      else
-        opts.signal.addEventListener("abort", onAbort, { once: true });
-    }
-    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
-    init.signal = controller.signal;
-    let response;
-    try {
-      response = await fetchImpl(url, init);
-    } catch (error2) {
-      const err = error2 instanceof Error ? error2 : new Error(String(error2));
-      if (opts.signal?.aborted)
-        return { ok: false, retryable: false, error: err };
-      return { ok: false, retryable: true, error: err };
-    } finally {
-      clearTimeout(timer);
-      if (opts.signal)
-        opts.signal.removeEventListener("abort", onAbort);
-    }
-    const text = await response.text();
-    let parsed = undefined;
-    if (text.length > 0) {
-      try {
-        parsed = JSON.parse(text);
-      } catch {
-        parsed = text;
-      }
-    }
-    if (!response.ok) {
-      return { ok: false, retryable: RETRY_STATUSES.has(response.status), error: new HasnaHttpError(method, rel, response.status, parsed) };
-    }
-    return { ok: true, value: parsed };
-  }
-  async function request(method, path, body, opts = {}) {
-    const upper = method.toUpperCase();
-    const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
-    const url = `${base}${rel}`;
-    const methodRetryable = IDEMPOTENT.has(upper) || Boolean(opts.idempotencyKey);
-    const maxRetries = opts.retries ?? 2;
-    const maxAttempts = methodRetryable ? maxRetries + 1 : 1;
-    let last = null;
-    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-      const result = await once(upper, rel, url, body, opts);
-      if (result.ok)
-        return result.value;
-      last = result;
-      const canRetry = methodRetryable && result.retryable && attempt < maxAttempts;
-      if (!canRetry)
-        break;
-      const backoff = Math.min(2000, 200 * 2 ** (attempt - 1));
-      const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
-      await sleep(backoff + jitter);
-    }
-    if (last === null)
-      throw new Error(`Request to ${rel} completed without a result`);
-    throw last.error;
-  }
-  return {
-    baseUrl: base,
-    request,
-    get: (path, opts) => request("GET", path, undefined, opts),
-    post: (path, body, opts) => request("POST", path, body, opts),
-    patch: (path, body, opts) => request("PATCH", path, body, opts),
-    put: (path, body, opts) => request("PUT", path, body, opts),
-    del: (path, body, opts) => request("DELETE", path, body, opts)
-  };
-}
-function newIdempotencyKey() {
-  const g = globalThis;
-  if (g.crypto?.randomUUID)
-    return g.crypto.randomUUID();
-  return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
-}
-function extractItems(raw, extraKeys = []) {
-  if (Array.isArray(raw))
-    return raw;
-  if (raw && typeof raw === "object") {
-    const obj = raw;
-    for (const key of [...extraKeys, "items", "data", "results", "rows", "records"]) {
-      if (Array.isArray(obj[key]))
-        return obj[key];
-    }
-  }
-  return [];
-}
-function createStorageClient(name, transport) {
-  const rp = (r) => `/${r.replace(/^\/+|\/+$/g, "")}`;
-  const ep = (r, id) => `${rp(r)}/${encodeURIComponent(String(id))}`;
-  return {
-    name,
-    baseUrl: transport.baseUrl,
-    transport,
-    async list(resource, query) {
-      const raw = await transport.get(rp(resource), { query });
-      return { items: extractItems(raw, [resource]), raw };
-    },
-    async get(resource, id) {
-      try {
-        return await transport.get(ep(resource, id));
-      } catch (error2) {
-        if (error2 instanceof HasnaHttpError && error2.status === 404)
-          return null;
-        throw error2;
-      }
-    },
-    async create(resource, body, idempotencyKey) {
-      return transport.post(rp(resource), body, { idempotencyKey: idempotencyKey ?? newIdempotencyKey() });
-    },
-    async update(resource, id, patch, method = "PATCH") {
-      const call = method === "PUT" ? transport.put : transport.patch;
-      return call(ep(resource, id), patch);
-    },
-    async delete(resource, id) {
-      try {
-        await transport.del(ep(resource, id));
-      } catch (error2) {
-        if (error2 instanceof HasnaHttpError && error2.status === 404)
-          return;
-        throw error2;
-      }
-    }
-  };
-}
-function resolveStorageClient(name, env = process.env, fetchImpl) {
+function resolveStoreClient(name, env = process.env) {
   const resolution = resolveTransport(name, env);
   if (resolution.misconfigured) {
+    const wired2 = createClientTransport(name, env);
+    if (wired2.transport === "http") {
+      return {
+        transport: "http",
+        client: createHasnaStorageClient(name, wired2.client),
+        resolution: {
+          transport: "http",
+          requested: "http",
+          modeSource: resolution.modeSource === "default" ? "auto:api-url+seam-credential" : resolution.modeSource,
+          baseUrl: wired2.resolution.baseUrl,
+          apiKeyPresent: true,
+          misconfigured: false,
+          warning: null
+        }
+      };
+    }
     throw new Error(resolution.warning ?? `Client for '${name}' is misconfigured for the /v1 API.`);
   }
   if (resolution.transport === "sqlite" || !resolution.baseUrl) {
     return { transport: "sqlite", client: null, resolution };
   }
-  const keys = envKeys(name);
-  const apiKey = firstEnv(env, keys.apiKeyKeys)?.value;
-  if (!apiKey)
+  const wired = createClientTransport(name, env);
+  if (wired.transport !== "http") {
     throw new Error(`Client for '${name}' resolved to the /v1 API without an API key.`);
-  const transport = createHttpTransport({ name, baseUrl: resolution.baseUrl, apiKey, ...fetchImpl ? { fetchImpl } : {} });
-  return { transport: "http", client: createStorageClient(name, transport), resolution };
+  }
+  return { transport: "http", client: createHasnaStorageClient(name, wired.client), resolution };
 }
-var SERVER_BACKEND_VALUES, HasnaHttpError, RETRY_STATUSES, IDEMPOTENT, defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var RETRY_STATUSES, IDEMPOTENT;
 var init_client = __esm(() => {
-  init_retired_deployment_modes();
-  SERVER_BACKEND_VALUES = ["sqlite", "postgresql", "postgres"];
-  HasnaHttpError = class HasnaHttpError extends Error {
-    status;
-    method;
-    path;
-    body;
-    constructor(method, path, status, body) {
-      super(`Hasna request failed: ${method} ${path} -> ${status}`);
-      this.name = "HasnaHttpError";
-      this.status = status;
-      this.method = method;
-      this.path = path;
-      this.body = body;
-    }
-  };
   RETRY_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
   IDEMPOTENT = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
 });
@@ -7059,6 +6960,22 @@ function unwrap(res, key) {
   }
   return res;
 }
+async function listResource(client, resource, query) {
+  const raw = await client.transport.get(`/${resource}`, query ? { query } : undefined);
+  return { items: extractEnvelopeItems(raw, resource), raw };
+}
+function extractEnvelopeItems(raw, resource) {
+  if (Array.isArray(raw))
+    return raw;
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of [resource, "items", "data", "results", "rows", "records"]) {
+      if (Array.isArray(obj[key]))
+        return obj[key];
+    }
+  }
+  return [];
+}
 function apiStore(client) {
   return {
     mode: "http",
@@ -7066,7 +6983,7 @@ function apiStore(client) {
     async createRecording(input, idempotencyKey) {
       const keyCandidate = idempotencyKey === undefined && (input.id === undefined || input.id === null) ? randomUUID2() : idempotencyKey;
       const identity = recordingCreateIdentity(input, keyCandidate, { bindIdempotencyKeyToId: false });
-      const res = await client.create("recordings", identity.input, identity.idempotencyKey);
+      const res = await client.create("recordings", identity.input, { idempotencyKey: identity.idempotencyKey });
       return unwrap(res, "recording");
     },
     async getRecording(id) {
@@ -7074,7 +6991,7 @@ function apiStore(client) {
       return res ? unwrap(res, "recording") : null;
     },
     async listRecordings(filter) {
-      const { items } = await client.list("recordings", listQuery(filter));
+      const { items } = await listResource(client, "recordings", listQuery(filter));
       return items;
     },
     async countRecordings(filter) {
@@ -7085,7 +7002,7 @@ function apiStore(client) {
       const seenPageKeys = new Set;
       while (pageRequests < maxPageRequests) {
         pageRequests += 1;
-        const { items, raw } = await client.list("recordings", {
+        const { items, raw } = await listResource(client, "recordings", {
           ...listQuery(filter),
           limit: pageLimit,
           offset
@@ -7108,7 +7025,7 @@ function apiStore(client) {
       throw new Error(`Recordings API exceeded ${maxPageRequests} pages while counting legacy results`);
     },
     async searchRecordings(query, filter) {
-      const { items } = await client.list("recordings", listQuery({ ...filter ?? {}, search: query }));
+      const { items } = await listResource(client, "recordings", listQuery({ ...filter ?? {}, search: query }));
       return items;
     },
     async deleteRecording(id) {
@@ -7140,7 +7057,7 @@ function apiStore(client) {
       return res ? unwrap(res, "agent") : null;
     },
     async listAgents() {
-      const { items } = await client.list("agents");
+      const { items } = await listResource(client, "agents");
       return items;
     },
     async heartbeatAgent(idOrName) {
@@ -7180,7 +7097,7 @@ function apiStore(client) {
       return res ? unwrap(res, "project") : null;
     },
     async listProjects() {
-      const { items } = await client.list("projects");
+      const { items } = await listResource(client, "projects");
       return items;
     },
     async saveFeedback(input) {
@@ -7227,7 +7144,7 @@ async function countStoreRecordings(store, filter) {
 function getStore(env = process.env) {
   if (env === process.env && cached)
     return cached;
-  const resolved = resolveStorageClient(APP, env);
+  const resolved = resolveStoreClient(APP, env);
   const store = resolved.transport === "http" ? apiStore(resolved.client) : localStore;
   if (env === process.env)
     cached = store;
@@ -8229,6 +8146,7 @@ var init_mcp = __esm(async () => {
   init_store();
   init_transcriber();
   init_enhancer();
+  init_version();
   init_machine();
   config = loadConfig();
   ensureDataDir(config);
@@ -8371,7 +8289,7 @@ async function startServer(port, options) {
 }
 var SECURITY_HEADERS, rateLimitMap, RATE_LIMIT_WINDOW_MS = 60000, RATE_LIMIT_MAX;
 var init_serve = __esm(() => {
-  init_cloud_config();
+  init_version();
   init_v1();
   init_openapi();
   SECURITY_HEADERS = {
@@ -8385,6 +8303,7 @@ var init_serve = __esm(() => {
 });
 
 // src/server/index.ts
+init_version();
 var DEFAULT_PORT = 8874;
 function parsePort() {
   const arg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
@@ -8421,8 +8340,7 @@ Commands:
   migrate         Apply the PostgreSQL schema, then exit. Idempotent.
 
 Environment:
-  HASNA_RECORDINGS_STORAGE_MODE     Data backend: sqlite | postgresql
-  HASNA_RECORDINGS_DATABASE_URL     PostgreSQL DSN (implies postgresql)
+  HASNA_RECORDINGS_DATABASE_URL     PostgreSQL DSN (present -> postgresql backend, else sqlite)
   HASNA_RECORDINGS_API_SIGNING_KEY  HMAC signing secret for API-key auth`);
 }
 async function runMigrate() {
@@ -8431,11 +8349,11 @@ async function runMigrate() {
     getCloudPg: getCloudPg2,
     migrateCloudSchema: migrateCloudSchema2,
     pingCloudConnectivity: pingCloudConnectivity3,
-    resolveCloudDatabaseUrl: resolveCloudDatabaseUrl2
+    resolveDatabaseUrl: resolveDatabaseUrl2
   } = await Promise.resolve().then(() => (init_cloud(), exports_cloud));
   const { assertCloudSchemaContract: assertCloudSchemaContract2 } = await Promise.resolve().then(() => (init_cloud_readiness(), exports_cloud_readiness));
   const { runCloudMigration: runCloudMigration2 } = await Promise.resolve().then(() => (init_migrate_command(), exports_migrate_command));
-  if (!resolveCloudDatabaseUrl2()) {
+  if (!resolveDatabaseUrl2()) {
     console.error("migrate: no database URL (HASNA_RECORDINGS_DATABASE_URL / RECORDINGS_DATABASE_URL / DATABASE_URL)");
     process.exit(2);
   }