business-stack 0.1.6 → 0.1.9

package/frontend/web/package.json

@@ -2,64 +2,9 @@
   "name": "@business-stack/web",
   "version": "0.1.0",
   "private": true,
-  "packageManager": "bun@1.3.1",
   "scripts": {
-    "dev": "next dev",
-    "build": "next build",
-    "start": "next start",
-    "lint": "biome check .",
-    "lint:fix": "biome check --write .",
-    "format": "biome format --write",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "clean": "bun x rimraf@6 .next"
-  },
-  "dependencies": {
-    "@captchafox/react": "^1.11.0",
-    "@daveyplate/better-auth-ui": "^3.4.0",
-    "@hookform/resolvers": "^5.2.2",
-    "@hugeicons/core-free-icons": "^4.1.1",
-    "@hugeicons/react": "^1.1.6",
-    "@marsidev/react-turnstile": "^1.5.0",
-    "@radix-ui/react-avatar": "^1.1.11",
-    "@radix-ui/react-checkbox": "^1.3.3",
-    "@radix-ui/react-context": "^1.1.3",
-    "@radix-ui/react-dialog": "^1.1.15",
-    "@radix-ui/react-dropdown-menu": "^2.1.16",
-    "@radix-ui/react-label": "^2.1.8",
-    "@radix-ui/react-primitive": "^2.1.4",
-    "@radix-ui/react-select": "^2.2.6",
-    "@radix-ui/react-separator": "^1.1.8",
-    "@radix-ui/react-slot": "^1.2.4",
-    "@radix-ui/react-tabs": "^1.1.13",
-    "@radix-ui/react-tooltip": "^1.2.8",
-    "@radix-ui/react-use-callback-ref": "^1.1.1",
-    "@radix-ui/react-use-layout-effect": "^1.1.1",
-    "@tanstack/react-query": "^5.96.2",
-    "better-auth": "^1.5.6",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "input-otp": "^1.4.2",
-    "lucide-react": "^1.7.0",
-    "next": "16.2.2",
-    "radix-ui": "^1.4.3",
-    "react": "19.2.4",
-    "react-dom": "19.2.4",
-    "react-hook-form": "^7.72.1",
-    "server-only": "^0.0.1",
-    "shadcn": "^4.1.2",
-    "sonner": "^2.0.7",
-    "tailwind-merge": "^3.5.0",
-    "tw-animate-css": "^1.4.0"
-  },
-  "devDependencies": {
-    "@tailwindcss/postcss": "^4",
-    "@types/node": "^20",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "babel-plugin-react-compiler": "1.0.0",
-    "tailwindcss": "^4",
-    "typescript": "^5",
-    "vitest": "^3.2.4"
+    "dev": "node -e \"console.error('Development is not included in the npm package; clone the monorepo.'); process.exit(1)\"",
+    "start": "node .next/standalone/frontend/web/server.js",
+    "build": "node -e \"process.exit(0)\""
   }
 }

package/gateway/dist/auth.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auth = void 0;
+const better_auth_1 = require("better-auth");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const stack_secrets_1 = require("./stack-secrets");
+(0, stack_secrets_1.loadStackSecretsIntoEnv)();
+const dbPath = process.env.BETTER_AUTH_DATABASE_PATH ?? "auth.sqlite";
+const sqlite = new better_sqlite3_1.default(dbPath);
+function parseTrustedOrigins() {
+    const raw = process.env.BETTER_AUTH_TRUSTED_ORIGINS;
+    if (raw?.trim()) {
+        return raw
+            .split(",")
+            .map((o) => o.trim())
+            .filter(Boolean);
+    }
+    return ["http://localhost:3000", "http://127.0.0.1:3000"];
+}
+/** Public origin where clients call /api/auth (Next dev server); gateway is proxied behind it. */
+const baseURL = process.env.BETTER_AUTH_URL?.replace(/\/$/, "") || "http://localhost:3000";
+exports.auth = (0, better_auth_1.betterAuth)({
+    baseURL,
+    database: sqlite,
+    emailAndPassword: { enabled: true },
+    rateLimit: {
+        enabled: true,
+        storage: "database",
+    },
+    session: {
+        cookieCache: {
+            enabled: true,
+            maxAge: 60 * 5,
+            strategy: "compact",
+        },
+    },
+    account: {
+        encryptOAuthTokens: true,
+    },
+    trustedOrigins: parseTrustedOrigins(),
+    advanced: {
+        ipAddress: {
+            ipAddressHeaders: ["x-forwarded-for", "x-real-ip"],
+        },
+    },
+});

package/gateway/dist/index.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_server_1 = require("@hono/node-server");
+const hono_1 = require("hono");
+const cors_1 = require("hono/cors");
+const proxy_1 = require("hono/proxy");
+const auth_1 = require("./auth");
+const handlers_1 = require("./integrations/handlers");
+const corsOrigin = process.env.CORS_ORIGIN?.trim() || "http://localhost:3000";
+const backendOrigin = (process.env.BACKEND_ORIGIN?.trim() || "http://127.0.0.1:8000").replace(/\/$/, "");
+const apiGatewayPrefix = process.env.API_GATEWAY_PREFIX?.trim() || "/api/backend";
+const app = new hono_1.Hono();
+app.use("*", (0, cors_1.cors)({
+    origin: corsOrigin,
+    allowHeaders: ["Content-Type", "Authorization"],
+    allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    exposeHeaders: ["Content-Length"],
+    maxAge: 600,
+    credentials: true,
+}));
+app.use("*", async (c, next) => {
+    const session = await auth_1.auth.api.getSession({ headers: c.req.raw.headers });
+    if (!session) {
+        c.set("user", null);
+        c.set("session", null);
+        await next();
+        return;
+    }
+    c.set("user", session.user);
+    c.set("session", session.session);
+    await next();
+});
+app.on(["POST", "GET"], "/api/auth/*", (c) => auth_1.auth.handler(c.req.raw));
+app.get("/internal/integrations", handlers_1.handleInternalIntegrationsGet);
+const integrationsApi = new hono_1.Hono();
+integrationsApi.get("/settings", handlers_1.handleGetIntegrationSettings);
+integrationsApi.put("/settings", handlers_1.handlePutIntegrationSettings);
+app.route("/api/integrations", integrationsApi);
+const backendProxy = new hono_1.Hono();
+backendProxy.all("*", async (c) => {
+    const user = c.get("user");
+    if (!user) {
+        return c.json({ error: "Unauthorized" }, 401);
+    }
+    const pathname = new URL(c.req.url).pathname;
+    const prefixNorm = apiGatewayPrefix.replace(/\/$/, "");
+    let path;
+    if (pathname === prefixNorm || pathname === `${prefixNorm}/`) {
+        path = "/";
+    }
+    else if (pathname.startsWith(`${prefixNorm}/`)) {
+        path = pathname.slice(prefixNorm.length);
+    }
+    else {
+        path = pathname;
+    }
+    if (!path || path === "") {
+        path = "/";
+    }
+    if (!path.startsWith("/")) {
+        path = `/${path}`;
+    }
+    const upstream = new URL(backendOrigin);
+    upstream.pathname = path;
+    upstream.search = new URL(c.req.url).search;
+    const proto = new URL(c.req.url).protocol.replace(":", "");
+    const host = c.req.header("host") ?? "";
+    const forwardedFor = c.req.header("x-forwarded-for");
+    const gatewaySecret = process.env.BACKEND_GATEWAY_SECRET?.trim();
+    return (0, proxy_1.proxy)(upstream.toString(), {
+        ...c.req,
+        headers: {
+            ...c.req.header(),
+            ...(forwardedFor ? { "X-Forwarded-For": forwardedFor } : {}),
+            "X-Forwarded-Host": host,
+            "X-Forwarded-Proto": proto,
+            // FastAPI Swagger/ReDoc use this as ASGI root_path so /openapi.json matches the gateway prefix.
+            "X-Forwarded-Prefix": prefixNorm,
+            ...(gatewaySecret ? { "X-Gateway-Secret": gatewaySecret } : {}),
+            "X-User-Id": user.id,
+            ...(user.email != null && user.email !== ""
+                ? { "X-User-Email": user.email }
+                : {}),
+        },
+    });
+});
+app.route(apiGatewayPrefix, backendProxy);
+app.get("/", (c) => {
+    return c.text("Hello Hono!");
+});
+app.get("/session", (c) => {
+    const session = c.get("session");
+    const user = c.get("user");
+    if (!user) {
+        return c.body(null, 401);
+    }
+    return c.json({ session, user });
+});
+const port = Number(process.env.PORT ?? 3001);
+const hostname = process.env.HOST?.trim() || "127.0.0.1";
+(0, node_server_1.serve)({
+    fetch: app.fetch,
+    port,
+    hostname,
+});
+console.log(`Gateway listening on http://${hostname}:${port} (backend ${backendOrigin}, prefix ${apiGatewayPrefix})`);

package/gateway/dist/integrations/admin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIntegrationSettingsAdmin = isIntegrationSettingsAdmin;
+/** Returns true if this user may change integration settings. */
+function isIntegrationSettingsAdmin(email) {
+    const raw = process.env.INTEGRATION_SETTINGS_ADMIN_EMAILS?.trim();
+    if (!raw) {
+        return true;
+    }
+    if (!email?.trim()) {
+        return false;
+    }
+    const allow = new Set(raw
+        .split(",")
+        .map((e) => e.trim().toLowerCase())
+        .filter(Boolean));
+    return allow.has(email.trim().toLowerCase());
+}

package/gateway/dist/integrations/crypto.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptIntegrationValue = encryptIntegrationValue;
+exports.decryptIntegrationValue = decryptIntegrationValue;
+const node_crypto_1 = require("node:crypto");
+const ALGO = "aes-256-gcm";
+const IV_LENGTH = 12;
+const AUTH_TAG_LENGTH = 16;
+function integrationKeyMaterial() {
+    const raw = process.env.INTEGRATIONS_ENCRYPTION_KEY?.trim();
+    if (!raw) {
+        throw new Error("INTEGRATIONS_ENCRYPTION_KEY is not set");
+    }
+    if (/^[0-9a-fA-F]{64}$/.test(raw)) {
+        return Buffer.from(raw, "hex");
+    }
+    return (0, node_crypto_1.createHash)("sha256").update(raw, "utf8").digest();
+}
+/** Returns base64(iv || ciphertext+tag) for storage. */
+function encryptIntegrationValue(plaintext) {
+    const key = integrationKeyMaterial();
+    const iv = (0, node_crypto_1.randomBytes)(IV_LENGTH);
+    const cipher = (0, node_crypto_1.createCipheriv)(ALGO, key, iv, {
+        authTagLength: AUTH_TAG_LENGTH,
+    });
+    const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const combined = Buffer.concat([iv, tag, enc]);
+    return combined.toString("base64");
+}
+function decryptIntegrationValue(payloadB64) {
+    const key = integrationKeyMaterial();
+    const buf = Buffer.from(payloadB64, "base64");
+    if (buf.length < IV_LENGTH + AUTH_TAG_LENGTH + 1) {
+        throw new Error("invalid ciphertext");
+    }
+    const iv = buf.subarray(0, IV_LENGTH);
+    const tag = buf.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
+    const data = buf.subarray(IV_LENGTH + AUTH_TAG_LENGTH);
+    const decipher = (0, node_crypto_1.createDecipheriv)(ALGO, key, iv, {
+        authTagLength: AUTH_TAG_LENGTH,
+    });
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(data), decipher.final()]).toString("utf8");
+}

package/gateway/dist/integrations/handlers.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetIntegrationSettings = handleGetIntegrationSettings;
+exports.handlePutIntegrationSettings = handlePutIntegrationSettings;
+exports.handleInternalIntegrationsGet = handleInternalIntegrationsGet;
+const admin_1 = require("./admin");
+const store_1 = require("./store");
+function maskIfSet(isSet) {
+    return isSet ? "********" : null;
+}
+/** GET /api/integrations/settings — session required; secrets plaintext for integration admins only. */
+async function handleGetIntegrationSettings(c) {
+    const user = c.get("user");
+    if (!user) {
+        return c.json({ error: "Unauthorized" }, 401);
+    }
+    const snap = (0, store_1.readFullSnapshot)();
+    const reveal = (0, admin_1.isIntegrationSettingsAdmin)(user.email);
+    return c.json({
+        alphaWebhookSecret: reveal
+            ? snap.alphaWebhookSecret && snap.alphaWebhookSecret !== ""
+                ? snap.alphaWebhookSecret
+                : null
+            : maskIfSet(snap.alphaWebhookSecret != null && snap.alphaWebhookSecret !== ""),
+        wabridgeBaseUrl: snap.wabridgeBaseUrl ?? null,
+        wabridgePhone: reveal
+            ? snap.wabridgePhone && snap.wabridgePhone !== ""
+                ? snap.wabridgePhone
+                : null
+            : maskIfSet(snap.wabridgePhone != null && snap.wabridgePhone !== ""),
+        wabridgeEnabled: snap.wabridgeEnabled === "true"
+            ? true
+            : snap.wabridgeEnabled === "false"
+                ? false
+                : null,
+        geminiApiKey: reveal
+            ? snap.geminiApiKey && snap.geminiApiKey !== ""
+                ? snap.geminiApiKey
+                : null
+            : maskIfSet(snap.geminiApiKey != null && snap.geminiApiKey !== ""),
+    });
+}
+/** PUT /api/integrations/settings — session + admin allowlist. */
+async function handlePutIntegrationSettings(c) {
+    const user = c.get("user");
+    if (!user) {
+        return c.json({ error: "Unauthorized" }, 401);
+    }
+    if (!(0, admin_1.isIntegrationSettingsAdmin)(user.email)) {
+        return c.json({ error: "Forbidden" }, 403);
+    }
+    if (!process.env.INTEGRATIONS_ENCRYPTION_KEY?.trim()) {
+        return c.json({ error: "INTEGRATIONS_ENCRYPTION_KEY is not configured on the gateway" }, 503);
+    }
+    let body;
+    try {
+        body = (await c.req.json());
+    }
+    catch {
+        return c.json({ error: "Invalid JSON" }, 400);
+    }
+    try {
+        (0, store_1.upsertFromBody)(body);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : "update failed";
+        return c.json({ error: msg }, 400);
+    }
+    return c.json({ ok: true });
+}
+/** GET /internal/integrations — Bearer INTEGRATIONS_INTERNAL_SECRET; plaintext for Next server. */
+async function handleInternalIntegrationsGet(c) {
+    const expected = process.env.INTEGRATIONS_INTERNAL_SECRET?.trim();
+    if (!expected) {
+        return c.json({ error: "INTEGRATIONS_INTERNAL_SECRET is not configured" }, 503);
+    }
+    const authz = c.req.header("authorization")?.trim() ?? "";
+    const token = authz.toLowerCase().startsWith("bearer ")
+        ? authz.slice(7).trim()
+        : null;
+    if (!token || token !== expected) {
+        return c.json({ error: "Unauthorized" }, 401);
+    }
+    if (!process.env.INTEGRATIONS_ENCRYPTION_KEY?.trim()) {
+        return c.json({ error: "INTEGRATIONS_ENCRYPTION_KEY is not configured" }, 503);
+    }
+    const snap = (0, store_1.readFullSnapshot)();
+    return c.json({
+        alphaWebhookSecret: snap.alphaWebhookSecret,
+        wabridgeBaseUrl: snap.wabridgeBaseUrl,
+        wabridgePhone: snap.wabridgePhone,
+        wabridgeEnabled: snap.wabridgeEnabled,
+        geminiApiKey: snap.geminiApiKey,
+    });
+}

package/gateway/dist/integrations/keys.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTEGRATION_DB_KEYS = void 0;
+/** SQLite row keys (stable identifiers). */
+exports.INTEGRATION_DB_KEYS = {
+    alphaWebhookSecret: "alpha_webhook_secret",
+    wabridgeBaseUrl: "wabridge_base_url",
+    wabridgePhone: "wabridge_phone",
+    wabridgeEnabled: "wabridge_enabled",
+    /** Used by the FastAPI backend (embed + /query) when GEMINI_API_KEY is unset. */
+    geminiApiKey: "gemini_api_key",
+};

package/gateway/dist/integrations/store.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEncryptedRow = getEncryptedRow;
+exports.setEncryptedRow = setEncryptedRow;
+exports.deleteRow = deleteRow;
+exports.getPlaintext = getPlaintext;
+exports.readFullSnapshot = readFullSnapshot;
+exports.upsertFromBody = upsertFromBody;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const crypto_1 = require("./crypto");
+const keys_1 = require("./keys");
+const dbPath = process.env.BETTER_AUTH_DATABASE_PATH ?? "auth.sqlite";
+let _db = null;
+function getDb() {
+    if (!_db) {
+        _db = new better_sqlite3_1.default(dbPath);
+        _db.exec(`
+      CREATE TABLE IF NOT EXISTS integration_settings (
+        key TEXT PRIMARY KEY NOT NULL,
+        ciphertext TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+    }
+    return _db;
+}
+function getEncryptedRow(key) {
+    const row = getDb()
+        .prepare("SELECT ciphertext FROM integration_settings WHERE key = ?")
+        .get(key);
+    return row?.ciphertext ?? null;
+}
+function setEncryptedRow(key, plaintext) {
+    const ciphertext = (0, crypto_1.encryptIntegrationValue)(plaintext);
+    const updatedAt = new Date().toISOString();
+    getDb()
+        .prepare(`INSERT INTO integration_settings (key, ciphertext, updated_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET ciphertext = excluded.ciphertext, updated_at = excluded.updated_at`)
+        .run(key, ciphertext, updatedAt);
+}
+function deleteRow(key) {
+    getDb().prepare("DELETE FROM integration_settings WHERE key = ?").run(key);
+}
+function getPlaintext(key) {
+    const row = getEncryptedRow(key);
+    if (!row)
+        return null;
+    try {
+        return (0, crypto_1.decryptIntegrationValue)(row);
+    }
+    catch {
+        return null;
+    }
+}
+function readFullSnapshot() {
+    return {
+        alphaWebhookSecret: getPlaintext(keys_1.INTEGRATION_DB_KEYS.alphaWebhookSecret),
+        wabridgeBaseUrl: getPlaintext(keys_1.INTEGRATION_DB_KEYS.wabridgeBaseUrl),
+        wabridgePhone: getPlaintext(keys_1.INTEGRATION_DB_KEYS.wabridgePhone),
+        wabridgeEnabled: getPlaintext(keys_1.INTEGRATION_DB_KEYS.wabridgeEnabled),
+        geminiApiKey: getPlaintext(keys_1.INTEGRATION_DB_KEYS.geminiApiKey),
+    };
+}
+function upsertFromBody(body) {
+    const setIfString = (k, v) => {
+        if (v === undefined)
+            return;
+        if (v === null || v === "") {
+            deleteRow(k);
+            return;
+        }
+        if (typeof v !== "string") {
+            throw new Error(`invalid type for ${k}`);
+        }
+        setEncryptedRow(k, v);
+    };
+    const setBool = (k, v) => {
+        if (v === undefined)
+            return;
+        if (v === null) {
+            deleteRow(k);
+            return;
+        }
+        if (typeof v !== "boolean") {
+            throw new Error(`invalid type for ${k}`);
+        }
+        setEncryptedRow(k, v ? "true" : "false");
+    };
+    setIfString(keys_1.INTEGRATION_DB_KEYS.alphaWebhookSecret, body.alphaWebhookSecret);
+    setIfString(keys_1.INTEGRATION_DB_KEYS.wabridgeBaseUrl, body.wabridgeBaseUrl);
+    setIfString(keys_1.INTEGRATION_DB_KEYS.wabridgePhone, body.wabridgePhone);
+    setBool(keys_1.INTEGRATION_DB_KEYS.wabridgeEnabled, body.wabridgeEnabled);
+    setIfString(keys_1.INTEGRATION_DB_KEYS.geminiApiKey, body.geminiApiKey);
+}

package/gateway/dist/stack-secrets.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadStackSecretsIntoEnv = loadStackSecretsIntoEnv;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+/**
+ * If an env var is unset or whitespace-only, fill it from `stack_secrets` in the auth DB.
+ * Call before Better Auth and integration crypto read secrets from `process.env`.
+ */
+function loadStackSecretsIntoEnv() {
+    const dbPath = process.env.BETTER_AUTH_DATABASE_PATH ?? "auth.sqlite";
+    let db;
+    try {
+        db = new better_sqlite3_1.default(dbPath);
+    }
+    catch {
+        return;
+    }
+    try {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS stack_secrets (
+        key TEXT PRIMARY KEY NOT NULL,
+        value TEXT NOT NULL
+      )
+    `);
+        const rows = db.prepare("SELECT key, value FROM stack_secrets").all();
+        for (const { key, value } of rows) {
+            const cur = process.env[key]?.trim();
+            if (!cur && value.trim()) {
+                process.env[key] = value;
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/gateway/package.json

@@ -1,16 +1,12 @@
 {
   "name": "@business-stack/gateway",
+  "version": "0.0.0",
   "private": true,
   "scripts": {
-    "dev": "tsx watch src/index.ts",
-    "start": "tsx src/index.ts",
-    "migrate": "npx @better-auth/cli@latest migrate --yes",
-    "build": "node -e \"require('fs').mkdirSync('dist',{recursive:true}); require('fs').writeFileSync('dist/.buildstamp','')\"",
-    "lint": "biome check .",
-    "lint:fix": "biome check --write .",
-    "typecheck": "tsc --noEmit",
-    "test": "node -e \"process.exit(0)\"",
-    "clean": "npx rimraf@6 dist"
+    "dev": "node -e \"console.error('Development is not included in the npm package; clone the monorepo.'); process.exit(1)\"",
+    "start": "node dist/index.js",
+    "build": "node -e \"process.exit(0)\"",
+    "migrate": "npx @better-auth/cli@latest migrate --yes"
   },
   "dependencies": {
     "@hono/node-server": "^1.19.9",
@@ -18,10 +14,5 @@
     "better-sqlite3": "^11.7.0",
     "hono": "^4.12.10",
     "tsx": "^4.19.3"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.12",
-    "@types/node": "^20",
-    "typescript": "^5.8.3"
   }
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "business-stack",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Next.js + Hono gateway + FastAPI monorepo",
   "license": "UNLICENSED",
   "workspaces": ["frontend/web", "gateway", "backend"],
   "scripts": {
-    "prepublishOnly": "node ../scripts/sync-npm-package.cjs",
+    "prepublishOnly": "node ../scripts/prepare-npm-package.cjs",
     "dev": "turbo dev --filter=@business-stack/web --filter=@business-stack/gateway --filter=@business-stack/backend",
     "start": "turbo run start --filter=@business-stack/web --filter=@business-stack/gateway --filter=@business-stack/backend",
     "build": "turbo run build --filter=@business-stack/web --filter=@business-stack/gateway --filter=@business-stack/backend"
@@ -15,6 +15,7 @@
   },
   "files": [
     "README.md",
+    ".npmrc",
     "bin",
     "turbo.json",
     ".python-version",

package/backend/tests/conftest.py

@@ -1,40 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-from alembic.config import Config
-from fastapi.testclient import TestClient
-
-from alembic import command
-from app.config import clear_settings_cache
-from app.main import create_app
-
-BACKEND_ROOT = Path(__file__).resolve().parents[1]
-
-
-def _alembic_upgrade_head() -> None:
-    prev = os.getcwd()
-    os.chdir(BACKEND_ROOT)
-    try:
-        cfg = Config(str(BACKEND_ROOT / "alembic.ini"))
-        command.upgrade(cfg, "head")
-    finally:
-        os.chdir(prev)
-
-
-@pytest.fixture
-def client(tmp_path, monkeypatch) -> TestClient:
-    monkeypatch.setenv("DATA_DIR", str(tmp_path))
-    clear_settings_cache()
-    with TestClient(create_app()) as test_client:
-        yield test_client
-
-
-@pytest.fixture
-def migrated_client(tmp_path, monkeypatch) -> TestClient:
-    monkeypatch.setenv("DATA_DIR", str(tmp_path))
-    clear_settings_cache()
-    _alembic_upgrade_head()
-    clear_settings_cache()
-    with TestClient(create_app()) as test_client:
-        yield test_client