@powerhousedao/switchboard 6.0.0-dev.20 → 6.0.0-dev.200

package/README.md

@@ -50,6 +50,7 @@ docker compose -f packages/reactor/docker-compose.yml up -d
 ```
 
 This starts:
+
 - PostgreSQL on port `5433` (mapped from container port 5432)
 - Adminer (database UI) on port `8080`
 
@@ -94,22 +95,21 @@ pnpm add -g @powerhousedao/switchboard
 
 ## 🏃‍♂️ Quick Start
 
-
 ## ⚙️ Configuration
 
 ### Environment Variables
 
-| Variable                     | Description                        | Default               |
-| ---------------------------- | ---------------------------------- | --------------------- |
-| `PORT`                       | Server port                        | `4001`                |
-| `DATABASE_URL`               | Database connection string         | `./.ph/drive-storage` |
-| `PH_REACTOR_DATABASE_URL`    | PostgreSQL URL (takes precedence)  | -                     |
-| `REDIS_URL`                  | Redis connection URL               | -                     |
-| `REDIS_TLS_URL`              | Redis TLS connection URL           | -                     |
-| `SENTRY_DSN`                 | Sentry DSN for error tracking      | -                     |
-| `SENTRY_ENV`                 | Sentry environment                 | -                     |
-| `PYROSCOPE_SERVER_ADDRESS`   | Pyroscope server address           | -                     |
-| `FEATURE_REACTORV2_ENABLED`  | Enable Reactor v2 subgraph feature | `false`               |
+| Variable                    | Description                        | Default               |
+| --------------------------- | ---------------------------------- | --------------------- |
+| `PORT`                      | Server port                        | `4001`                |
+| `DATABASE_URL`              | Database connection string         | `./.ph/drive-storage` |
+| `PH_REACTOR_DATABASE_URL`   | PostgreSQL URL (takes precedence)  | -                     |
+| `REDIS_URL`                 | Redis connection URL               | -                     |
+| `REDIS_TLS_URL`             | Redis TLS connection URL           | -                     |
+| `SENTRY_DSN`                | Sentry DSN for error tracking      | -                     |
+| `SENTRY_ENV`                | Sentry environment                 | -                     |
+| `PYROSCOPE_SERVER_ADDRESS`  | Pyroscope server address           | -                     |
+| `FEATURE_REACTORV2_ENABLED` | Enable Reactor v2 subgraph feature | `false`               |
 
 ### Authentication Configuration
 
@@ -245,6 +245,7 @@ ph switchboard --db-path postgresql://user:pass@localhost:5432/db --migrate-stat
 #### Environment Variables for Migrations
 
 The migration commands check for a PostgreSQL URL in this order:
+
 1. `PH_REACTOR_DATABASE_URL`
 2. `DATABASE_URL`
 3. Config file (`powerhouse.config.json` -> `switchboard.database.url`)

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { n as startSwitchboard } from "./server-BMtyzhoR.mjs";
+import "./utils-DFl0ezBT.mjs";
+import * as Sentry from "@sentry/node";
+import { childLogger } from "document-model";
+import dotenv from "dotenv";
+import { getConfig } from "@powerhousedao/config/node";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+//#region src/config.ts
+dotenv.config();
+const { switchboard } = getConfig();
+const config = {
+	database: { url: process.env.PH_SWITCHBOARD_DATABASE_URL ?? switchboard?.database?.url ?? "dev.db" },
+	port: process.env.PH_SWITCHBOARD_PORT && !isNaN(Number(process.env.PH_SWITCHBOARD_PORT)) ? Number(process.env.PH_SWITCHBOARD_PORT) : switchboard?.port ?? 4001,
+	mcp: true,
+	drive: {
+		id: "powerhouse",
+		slug: "powerhouse",
+		global: {
+			name: "Powerhouse",
+			icon: "https://ipfs.io/ipfs/QmcaTDBYn8X2psGaXe7iQ6qd8q6oqHLgxvMX9yXf7f9uP7"
+		},
+		local: {
+			availableOffline: true,
+			listeners: [],
+			sharingType: "public",
+			triggers: []
+		}
+	}
+};
+//#endregion
+//#region src/metrics.ts
+const logger$1 = childLogger(["switchboard", "metrics"]);
+function createMeterProviderFromEnv(env) {
+	const endpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (!endpoint) return void 0;
+	const parsed = parseInt(env.OTEL_METRIC_EXPORT_INTERVAL ?? "", 10);
+	const exportIntervalMillis = Number.isFinite(parsed) && parsed > 0 ? parsed : 5e3;
+	const base = endpoint.replace(/\/$/, "");
+	const exporterUrl = base.endsWith("/v1/metrics") ? base : `${base}/v1/metrics`;
+	logger$1.info(`Initializing OpenTelemetry metrics exporter at: ${endpoint}`);
+	const meterProvider = new MeterProvider({
+		resource: new Resource({ "service.name": env.OTEL_SERVICE_NAME ?? "switchboard" }),
+		readers: [new PeriodicExportingMetricReader({
+			exporter: new OTLPMetricExporter({ url: exporterUrl }),
+			exportIntervalMillis,
+			exportTimeoutMillis: Math.max(exportIntervalMillis - 250, 1)
+		})]
+	});
+	logger$1.info(`Metrics export enabled (interval: ${exportIntervalMillis}ms)`);
+	return meterProvider;
+}
+//#endregion
+//#region src/profiler.ts
+async function initProfilerFromEnv(env) {
+	const { PYROSCOPE_SERVER_ADDRESS: serverAddress, PYROSCOPE_APPLICATION_NAME: appName, PYROSCOPE_USER: basicAuthUser, PYROSCOPE_PASSWORD: basicAuthPassword, PYROSCOPE_WALL_ENABLED: wallEnabled, PYROSCOPE_HEAP_ENABLED: heapEnabled } = env;
+	return initProfiler({
+		serverAddress,
+		appName,
+		basicAuthUser,
+		basicAuthPassword,
+		wall: {
+			samplingDurationMs: 1e4,
+			samplingIntervalMicros: 1e4,
+			collectCpuTime: true
+		},
+		heap: {
+			samplingIntervalBytes: 512 * 1024,
+			stackDepth: 64
+		}
+	}, {
+		wallEnabled: wallEnabled !== "false",
+		heapEnabled: heapEnabled === "true"
+	});
+}
+async function initProfiler(options, flags = {
+	wallEnabled: true,
+	heapEnabled: false
+}) {
+	console.log("Initializing Pyroscope profiler at:", options?.serverAddress);
+	console.log("  Wall profiling:", flags.wallEnabled ? "enabled" : "disabled");
+	console.log("  Heap profiling:", flags.heapEnabled ? "enabled" : "disabled");
+	const { default: Pyroscope } = await import("@pyroscope/nodejs");
+	Pyroscope.init(options);
+	if (flags.wallEnabled) Pyroscope.startWallProfiling();
+	Pyroscope.startCpuProfiling();
+	if (flags.heapEnabled) Pyroscope.startHeapProfiling();
+}
+//#endregion
+//#region src/index.mts
+const logger = childLogger(["switchboard"]);
+function ensureNodeVersion(minVersion = "24") {
+	const version = process.versions.node;
+	if (!version) return;
+	if (version < minVersion) {
+		console.error(`Node version ${minVersion} or higher is required. Current version: ${version}`);
+		process.exit(1);
+	}
+}
+ensureNodeVersion("24");
+process.setMaxListeners(0);
+const meterProvider = createMeterProviderFromEnv({
+	OTEL_EXPORTER_OTLP_ENDPOINT: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+	OTEL_METRIC_EXPORT_INTERVAL: process.env.OTEL_METRIC_EXPORT_INTERVAL,
+	OTEL_SERVICE_NAME: process.env.OTEL_SERVICE_NAME
+});
+async function shutdown() {
+	console.log("\nShutting down...");
+	await Promise.race([meterProvider?.shutdown().catch(() => void 0), new Promise((resolve) => setTimeout(resolve, 5e3))]);
+	process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+if (process.env.PYROSCOPE_SERVER_ADDRESS) try {
+	await initProfilerFromEnv(process.env);
+} catch (e) {
+	Sentry.captureException(e);
+	logger.error("Error starting profiler: @error", e);
+}
+startSwitchboard({
+	...config,
+	meterProvider
+}).catch(console.error);
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["logger"],"sources":["../src/config.ts","../src/metrics.ts","../src/profiler.ts","../src/index.mts"],"sourcesContent":["import dotenv from \"dotenv\";\ndotenv.config();\n\nimport { getConfig } from \"@powerhousedao/config/node\";\nimport type { DriveInput } from \"@powerhousedao/shared/document-drive\";\nconst phConfig = getConfig();\nconst { switchboard } = phConfig;\ninterface Config {\n  database: {\n    url: string;\n  };\n  port: number;\n  mcp: boolean;\n  drive: DriveInput;\n}\nexport const config: Config = {\n  database: {\n    // url: process.env.PH_SWITCHBOARD_DATABASE_URL ?? switchboard?.database?.url ?? \"dev.db\",\n    url:\n      process.env.PH_SWITCHBOARD_DATABASE_URL ??\n      switchboard?.database?.url ??\n      \"dev.db\",\n  },\n  port:\n    process.env.PH_SWITCHBOARD_PORT &&\n    !isNaN(Number(process.env.PH_SWITCHBOARD_PORT))\n      ? Number(process.env.PH_SWITCHBOARD_PORT)\n      : (switchboard?.port ?? 4001),\n  mcp: true,\n  drive: {\n    id: \"powerhouse\",\n    slug: \"powerhouse\",\n    global: {\n      name: \"Powerhouse\",\n      icon: \"https://ipfs.io/ipfs/QmcaTDBYn8X2psGaXe7iQ6qd8q6oqHLgxvMX9yXf7f9uP7\",\n    },\n    local: {\n      availableOffline: true,\n      listeners: [],\n      sharingType: \"public\",\n      triggers: [],\n    },\n  },\n};\n","import { OTLPMetricExporter } from \"@opentelemetry/exporter-metrics-otlp-http\";\nimport { Resource } from \"@opentelemetry/resources\";\nimport {\n  MeterProvider,\n  PeriodicExportingMetricReader,\n} from \"@opentelemetry/sdk-metrics\";\nimport { childLogger } from \"document-model\";\n\nconst logger = childLogger([\"switchboard\", \"metrics\"]);\n\nexport function createMeterProviderFromEnv(env: {\n  OTEL_EXPORTER_OTLP_ENDPOINT?: string;\n  OTEL_METRIC_EXPORT_INTERVAL?: string;\n  OTEL_SERVICE_NAME?: string;\n}): MeterProvider | undefined {\n  const endpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT;\n  if (!endpoint) return undefined;\n\n  const parsed = parseInt(env.OTEL_METRIC_EXPORT_INTERVAL ?? \"\", 10);\n  const exportIntervalMillis =\n    Number.isFinite(parsed) && parsed > 0 ? parsed : 5_000;\n\n  const base = endpoint.replace(/\\/$/, \"\");\n  const exporterUrl = base.endsWith(\"/v1/metrics\")\n    ? base\n    : `${base}/v1/metrics`;\n\n  logger.info(`Initializing OpenTelemetry metrics exporter at: ${endpoint}`);\n  const meterProvider = new MeterProvider({\n    resource: new Resource({\n      \"service.name\": env.OTEL_SERVICE_NAME ?? \"switchboard\",\n    }),\n    readers: [\n      new PeriodicExportingMetricReader({\n        exporter: new OTLPMetricExporter({\n          url: exporterUrl,\n        }),\n        exportIntervalMillis,\n        exportTimeoutMillis: Math.max(exportIntervalMillis - 250, 1),\n      }),\n    ],\n  });\n  logger.info(`Metrics export enabled (interval: ${exportIntervalMillis}ms)`);\n  return meterProvider;\n}\n","import type { PyroscopeConfig } from \"@pyroscope/nodejs\";\n\nexport async function initProfilerFromEnv(env: typeof process.env) {\n  const {\n    PYROSCOPE_SERVER_ADDRESS: serverAddress,\n    PYROSCOPE_APPLICATION_NAME: appName,\n    PYROSCOPE_USER: basicAuthUser,\n    PYROSCOPE_PASSWORD: basicAuthPassword,\n    PYROSCOPE_WALL_ENABLED: wallEnabled,\n    PYROSCOPE_HEAP_ENABLED: heapEnabled,\n  } = env;\n\n  const options: PyroscopeConfig = {\n    serverAddress,\n    appName,\n    basicAuthUser,\n    basicAuthPassword,\n    // Wall profiling captures wall-clock time (includes async I/O waits)\n    // This shows GraphQL resolvers even when waiting for database\n    wall: {\n      samplingDurationMs: 10000, // 10 second sampling windows\n      samplingIntervalMicros: 10000, // 10ms sampling interval (100 samples/sec)\n      collectCpuTime: true, // Also collect CPU time alongside wall time\n    },\n    // Heap profiling for memory allocation tracking\n    heap: {\n      samplingIntervalBytes: 512 * 1024, // Sample every 512KB allocated\n      stackDepth: 64, // Capture deeper stacks for better context\n    },\n  };\n  return initProfiler(options, {\n    wallEnabled: wallEnabled !== \"false\",\n    heapEnabled: heapEnabled === \"true\",\n  });\n}\n\ninterface ProfilerFlags {\n  wallEnabled?: boolean;\n  heapEnabled?: boolean;\n}\n\nexport async function initProfiler(\n  options?: PyroscopeConfig,\n  flags: ProfilerFlags = { wallEnabled: true, heapEnabled: false },\n) {\n  console.log(\"Initializing Pyroscope profiler at:\", options?.serverAddress);\n  console.log(\"  Wall profiling:\", flags.wallEnabled ? \"enabled\" : \"disabled\");\n  console.log(\"  Heap profiling:\", flags.heapEnabled ? \"enabled\" : \"disabled\");\n\n  const { default: Pyroscope } = await import(\"@pyroscope/nodejs\");\n  Pyroscope.init(options);\n\n  // Start wall profiling (captures async I/O time - shows resolvers)\n  if (flags.wallEnabled) {\n    Pyroscope.startWallProfiling();\n  }\n\n  // Start CPU profiling (captures CPU-bound work)\n  Pyroscope.startCpuProfiling();\n\n  // Optionally start heap profiling (memory allocations)\n  if (flags.heapEnabled) {\n    Pyroscope.startHeapProfiling();\n  }\n}\n","#!/usr/bin/env node\nimport * as Sentry from \"@sentry/node\";\nimport { childLogger } from \"document-model\";\nimport { config } from \"./config.js\";\nimport { createMeterProviderFromEnv } from \"./metrics.js\";\nimport { initProfilerFromEnv } from \"./profiler.js\";\nimport { startSwitchboard } from \"./server.mjs\";\n\nconst logger = childLogger([\"switchboard\"]);\n\nfunction ensureNodeVersion(minVersion = \"24\") {\n  const version = process.versions.node;\n  if (!version) {\n    return;\n  }\n\n  if (version < minVersion) {\n    console.error(\n      `Node version ${minVersion} or higher is required. Current version: ${version}`,\n    );\n    process.exit(1);\n  }\n}\n// Ensure minimum Node.js version\nensureNodeVersion(\"24\");\n\n// Each subgraph registers its own SIGINT/SIGTERM listeners, and the count\n// scales with dynamically-loaded document models beyond the default cap of 10.\nprocess.setMaxListeners(0);\n\nconst meterProvider = createMeterProviderFromEnv({\n  OTEL_EXPORTER_OTLP_ENDPOINT: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,\n  OTEL_METRIC_EXPORT_INTERVAL: process.env.OTEL_METRIC_EXPORT_INTERVAL,\n  OTEL_SERVICE_NAME: process.env.OTEL_SERVICE_NAME,\n});\n\nasync function shutdown() {\n  console.log(\"\\nShutting down...\");\n  // Flush final metrics before exit. Races against a 5s deadline so an\n  // unresponsive OTLP endpoint cannot exhaust terminationGracePeriodSeconds.\n  await Promise.race([\n    meterProvider?.shutdown().catch(() => undefined),\n    new Promise<void>((resolve) => setTimeout(resolve, 5_000)),\n  ]);\n  process.exit(0);\n}\n\n// SIGINT: Ctrl-C in development; SIGTERM: graceful shutdown in Docker/Kubernetes\nprocess.on(\"SIGINT\", shutdown);\nprocess.on(\"SIGTERM\", shutdown);\n\nif (process.env.PYROSCOPE_SERVER_ADDRESS) {\n  try {\n    await initProfilerFromEnv(process.env);\n  } catch (e) {\n    Sentry.captureException(e);\n    logger.error(\"Error starting profiler: @error\", e);\n  }\n}\n\nstartSwitchboard({ ...config, meterProvider }).catch(console.error);\n"],"mappings":"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"}

package/dist/install-packages.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/install-packages.mjs

@@ -0,0 +1,31 @@
+import path from "path";
+import { execSync } from "child_process";
+import fs from "fs";
+//#region src/install-packages.mts
+const pkgs = process.env.PH_PACKAGES?.split(",") || [];
+if (pkgs.length === 0 || pkgs.length === 1 && pkgs[0] === "") process.exit(0);
+try {
+	const packageJsonPath = path.join(process.cwd(), "package.json");
+	const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+	const packageJson = JSON.parse(packageJsonContent);
+	const installedDependencies = {
+		...packageJson.dependencies || {},
+		...packageJson.devDependencies || {}
+	};
+	for (const pkg of pkgs) {
+		if (pkg === "") continue;
+		if (installedDependencies[pkg]) {
+			console.log(`> Package ${pkg} is already installed, skipping`);
+			continue;
+		}
+		console.log(`> Installing ${pkg}`);
+		execSync(`pnpm add ${pkg}@latest`, { stdio: "inherit" });
+	}
+} catch (error) {
+	console.error("Error in package installation:", error);
+	process.exit(1);
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=install-packages.mjs.map

package/dist/install-packages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-packages.mjs","names":[],"sources":["../src/install-packages.mts"],"sourcesContent":["import { execSync } from \"child_process\";\nimport fs from \"fs\";\nimport path from \"path\";\n\n// Define interface for package.json\ninterface PackageJson {\n  dependencies?: Record<string, string>;\n  devDependencies?: Record<string, string>;\n}\n\n// Get the list of packages to install from the environment variable\nconst pkgs = process.env.PH_PACKAGES?.split(\",\") || [];\n\n// Skip if no packages to install\nif (pkgs.length === 0 || (pkgs.length === 1 && pkgs[0] === \"\")) {\n  process.exit(0);\n}\n\ntry {\n  // Read the package.json file to check existing dependencies\n  const packageJsonPath = path.join(process.cwd(), \"package.json\");\n  const packageJsonContent = fs.readFileSync(packageJsonPath, \"utf-8\");\n  const packageJson = JSON.parse(packageJsonContent) as PackageJson;\n\n  // Get all installed dependencies\n  const installedDependencies: Record<string, string> = {\n    ...(packageJson.dependencies || {}),\n    ...(packageJson.devDependencies || {}),\n  };\n\n  for (const pkg of pkgs) {\n    if (pkg === \"\") continue;\n\n    // Check if the package is already installed\n    if (installedDependencies[pkg]) {\n      console.log(`> Package ${pkg} is already installed, skipping`);\n      continue;\n    }\n\n    console.log(`> Installing ${pkg}`);\n    execSync(`pnpm add ${pkg}@latest`, { stdio: \"inherit\" });\n  }\n} catch (error) {\n  console.error(\"Error in package installation:\", error);\n  process.exit(1);\n}\n"],"mappings":";;;;AAWA,MAAM,OAAO,QAAQ,IAAI,aAAa,MAAM,IAAI,IAAI,EAAE;AAGtD,IAAI,KAAK,WAAW,KAAM,KAAK,WAAW,KAAK,KAAK,OAAO,GACzD,SAAQ,KAAK,EAAE;AAGjB,IAAI;CAEF,MAAM,kBAAkB,KAAK,KAAK,QAAQ,KAAK,EAAE,eAAe;CAChE,MAAM,qBAAqB,GAAG,aAAa,iBAAiB,QAAQ;CACpE,MAAM,cAAc,KAAK,MAAM,mBAAmB;CAGlD,MAAM,wBAAgD;EACpD,GAAI,YAAY,gBAAgB,EAAE;EAClC,GAAI,YAAY,mBAAmB,EAAE;EACtC;AAED,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,QAAQ,GAAI;AAGhB,MAAI,sBAAsB,MAAM;AAC9B,WAAQ,IAAI,aAAa,IAAI,iCAAiC;AAC9D;;AAGF,UAAQ,IAAI,gBAAgB,MAAM;AAClC,WAAS,YAAY,IAAI,UAAU,EAAE,OAAO,WAAW,CAAC;;SAEnD,OAAO;AACd,SAAQ,MAAM,kCAAkC,MAAM;AACtD,SAAQ,KAAK,EAAE"}

package/dist/migrate.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/migrate.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { getConfig } from "@powerhousedao/config/node";
+import { REACTOR_SCHEMA, getMigrationStatus, runMigrations } from "@powerhousedao/reactor";
+import { Kysely, PostgresDialect } from "kysely";
+import { Pool } from "pg";
+//#region src/migrate.mts
+function isPostgresUrl(url) {
+	return url.startsWith("postgresql://") || url.startsWith("postgres://");
+}
+async function main() {
+	const command = process.argv[2];
+	const config = getConfig();
+	const dbPath = process.env.PH_REACTOR_DATABASE_URL ?? process.env.DATABASE_URL ?? config.switchboard?.database?.url;
+	if (!dbPath || !isPostgresUrl(dbPath)) {
+		console.log("No PostgreSQL URL configured. Skipping migrations.");
+		console.log("(PGlite migrations are handled automatically on startup)");
+		return;
+	}
+	console.log(`Database: ${dbPath}`);
+	const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({ connectionString: dbPath }) }) });
+	try {
+		if (command === "status") {
+			console.log("\nChecking migration status...");
+			const migrations = await getMigrationStatus(db, REACTOR_SCHEMA);
+			console.log("\nMigration Status:");
+			console.log("=================");
+			for (const migration of migrations) {
+				const status = migration.executedAt ? `[OK] Executed at ${migration.executedAt.toISOString()}` : "[--] Pending";
+				console.log(`${status} - ${migration.name}`);
+			}
+		} else {
+			console.log("\nRunning migrations...");
+			const result = await runMigrations(db, REACTOR_SCHEMA);
+			if (!result.success) {
+				console.error("Migration failed:", result.error?.message);
+				process.exit(1);
+			}
+			if (result.migrationsExecuted.length === 0) console.log("No migrations to run - database is up to date");
+			else {
+				console.log(`Successfully executed ${result.migrationsExecuted.length} migration(s):`);
+				for (const name of result.migrationsExecuted) console.log(`  - ${name}`);
+			}
+		}
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	} finally {
+		await db.destroy();
+	}
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=migrate.mjs.map

package/dist/migrate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.mjs","names":[],"sources":["../src/migrate.mts"],"sourcesContent":["#!/usr/bin/env node\nimport { Kysely, PostgresDialect } from \"kysely\";\nimport { Pool } from \"pg\";\nimport {\n  runMigrations,\n  getMigrationStatus,\n  REACTOR_SCHEMA,\n} from \"@powerhousedao/reactor\";\nimport { getConfig } from \"@powerhousedao/config/node\";\n\nfunction isPostgresUrl(url: string): boolean {\n  return url.startsWith(\"postgresql://\") || url.startsWith(\"postgres://\");\n}\n\nasync function main() {\n  const command = process.argv[2];\n  const config = getConfig();\n\n  const dbPath =\n    process.env.PH_REACTOR_DATABASE_URL ??\n    process.env.DATABASE_URL ??\n    config.switchboard?.database?.url;\n\n  if (!dbPath || !isPostgresUrl(dbPath)) {\n    console.log(\"No PostgreSQL URL configured. Skipping migrations.\");\n    console.log(\"(PGlite migrations are handled automatically on startup)\");\n    return;\n  }\n\n  console.log(`Database: ${dbPath}`);\n\n  const pool = new Pool({ connectionString: dbPath });\n\n  const db = new Kysely<any>({\n    dialect: new PostgresDialect({ pool }),\n  });\n\n  try {\n    if (command === \"status\") {\n      console.log(\"\\nChecking migration status...\");\n      const migrations = await getMigrationStatus(db, REACTOR_SCHEMA);\n\n      console.log(\"\\nMigration Status:\");\n      console.log(\"=================\");\n\n      for (const migration of migrations) {\n        const status = migration.executedAt\n          ? `[OK] Executed at ${migration.executedAt.toISOString()}`\n          : \"[--] Pending\";\n        console.log(`${status} - ${migration.name}`);\n      }\n    } else {\n      console.log(\"\\nRunning migrations...\");\n      const result = await runMigrations(db, REACTOR_SCHEMA);\n\n      if (!result.success) {\n        console.error(\"Migration failed:\", result.error?.message);\n        process.exit(1);\n      }\n\n      if (result.migrationsExecuted.length === 0) {\n        console.log(\"No migrations to run - database is up to date\");\n      } else {\n        console.log(\n          `Successfully executed ${result.migrationsExecuted.length} migration(s):`,\n        );\n        for (const name of result.migrationsExecuted) {\n          console.log(`  - ${name}`);\n        }\n      }\n    }\n  } catch (error) {\n    console.error(\n      \"Error:\",\n      error instanceof Error ? error.message : String(error),\n    );\n    process.exit(1);\n  } finally {\n    await db.destroy();\n  }\n}\n\nvoid main();\n"],"mappings":";;;;;;AAUA,SAAS,cAAc,KAAsB;AAC3C,QAAO,IAAI,WAAW,gBAAgB,IAAI,IAAI,WAAW,cAAc;;AAGzE,eAAe,OAAO;CACpB,MAAM,UAAU,QAAQ,KAAK;CAC7B,MAAM,SAAS,WAAW;CAE1B,MAAM,SACJ,QAAQ,IAAI,2BACZ,QAAQ,IAAI,gBACZ,OAAO,aAAa,UAAU;AAEhC,KAAI,CAAC,UAAU,CAAC,cAAc,OAAO,EAAE;AACrC,UAAQ,IAAI,qDAAqD;AACjE,UAAQ,IAAI,2DAA2D;AACvE;;AAGF,SAAQ,IAAI,aAAa,SAAS;CAIlC,MAAM,KAAK,IAAI,OAAY,EACzB,SAAS,IAAI,gBAAgB,EAAE,MAHpB,IAAI,KAAK,EAAE,kBAAkB,QAAQ,CAAC,EAGZ,CAAC,EACvC,CAAC;AAEF,KAAI;AACF,MAAI,YAAY,UAAU;AACxB,WAAQ,IAAI,iCAAiC;GAC7C,MAAM,aAAa,MAAM,mBAAmB,IAAI,eAAe;AAE/D,WAAQ,IAAI,sBAAsB;AAClC,WAAQ,IAAI,oBAAoB;AAEhC,QAAK,MAAM,aAAa,YAAY;IAClC,MAAM,SAAS,UAAU,aACrB,oBAAoB,UAAU,WAAW,aAAa,KACtD;AACJ,YAAQ,IAAI,GAAG,OAAO,KAAK,UAAU,OAAO;;SAEzC;AACL,WAAQ,IAAI,0BAA0B;GACtC,MAAM,SAAS,MAAM,cAAc,IAAI,eAAe;AAEtD,OAAI,CAAC,OAAO,SAAS;AACnB,YAAQ,MAAM,qBAAqB,OAAO,OAAO,QAAQ;AACzD,YAAQ,KAAK,EAAE;;AAGjB,OAAI,OAAO,mBAAmB,WAAW,EACvC,SAAQ,IAAI,gDAAgD;QACvD;AACL,YAAQ,IACN,yBAAyB,OAAO,mBAAmB,OAAO,gBAC3D;AACD,SAAK,MAAM,QAAQ,OAAO,mBACxB,SAAQ,IAAI,OAAO,OAAO;;;UAIzB,OAAO;AACd,UAAQ,MACN,UACA,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,CACvD;AACD,UAAQ,KAAK,EAAE;WACP;AACR,QAAM,GAAG,SAAS;;;AAIjB,MAAM"}

package/dist/server-BMtyzhoR.mjs

@@ -0,0 +1,291 @@
+import { n as isPostgresUrl, t as addDefaultDrive } from "./utils-DFl0ezBT.mjs";
+import { register } from "node:module";
+import * as Sentry from "@sentry/node";
+import { childLogger, documentModelDocumentModelModule, setLogLevel } from "document-model";
+import dotenv from "dotenv";
+import { getConfig } from "@powerhousedao/config/node";
+import { PGlite } from "@electric-sql/pglite";
+import { metrics } from "@opentelemetry/api";
+import { ReactorInstrumentation } from "@powerhousedao/opentelemetry-instrumentation-reactor";
+import { ChannelScheme, EventBus, ReactorBuilder, ReactorClientBuilder, driveCollectionId, parseDriveUrl } from "@powerhousedao/reactor";
+import { HttpPackageLoader, ImportPackageLoader, PackageManagementService, PackagesSubgraph, getUniqueDocumentModels, initializeAndStartAPI } from "@powerhousedao/reactor-api";
+import { httpsHooksPath } from "@powerhousedao/reactor-api/https-hooks";
+import { VitePackageLoader, createViteLogger, startViteServer } from "@powerhousedao/reactor-api/vite";
+import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
+import { documentModels } from "@powerhousedao/vetra";
+import { processorFactory } from "@powerhousedao/vetra/processors";
+import { Kysely, PostgresDialect } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import net from "node:net";
+import path from "path";
+import { Pool } from "pg";
+import { EnvVarProvider } from "@openfeature/env-var-provider";
+import { OpenFeature } from "@openfeature/server-sdk";
+import { DEFAULT_RENOWN_URL, NodeKeyStorage, RenownBuilder, RenownCryptoBuilder, createSignatureVerifier } from "@renown/sdk/node";
+//#region src/feature-flags.ts
+async function initFeatureFlags() {
+	const provider = new EnvVarProvider();
+	await OpenFeature.setProviderAndWait(provider);
+	return OpenFeature.getClient();
+}
+//#endregion
+//#region src/renown.ts
+const logger = childLogger(["switchboard", "renown"]);
+/**
+* Initialize Renown for the Switchboard instance.
+* This allows Switchboard to authenticate with remote services
+* using the same identity established during `ph login`.
+*/
+async function initRenown(options = {}) {
+	const { keypairPath, requireExisting = false, baseUrl = DEFAULT_RENOWN_URL } = options;
+	const keyStorage = new NodeKeyStorage(keypairPath, { logger });
+	const existingKeyPair = await keyStorage.loadKeyPair();
+	if (!existingKeyPair && requireExisting) throw new Error("No existing keypair found and requireExisting is true. Run \"ph login\" to create one.");
+	if (!existingKeyPair) logger.info("No existing keypair found. A new one will be generated.");
+	const renownCrypto = await new RenownCryptoBuilder().withKeyPairStorage(keyStorage).build();
+	const renown = await new RenownBuilder("switchboard", {}).withCrypto(renownCrypto).withBaseUrl(baseUrl).build();
+	logger.info("Switchboard identity initialized: @did", renownCrypto.did);
+	return renown;
+}
+/**
+* Get the signer config for the given renown instance.
+*
+* @param renown - The renown instance
+* @param requireSignature - If true, unsigned actions are rejected
+*/
+function getRenownSignerConfig(renown, requireSignature) {
+	return {
+		signer: renown.signer,
+		verifier: createSignatureVerifier(requireSignature)
+	};
+}
+//#endregion
+//#region src/server.mts
+const defaultLogger = childLogger(["switchboard"]);
+const LogLevel = process.env.LOG_LEVEL || "info";
+setLogLevel(LogLevel);
+dotenv.config();
+const DOCUMENT_MODEL_SUBGRAPHS_ENABLED = "DOCUMENT_MODEL_SUBGRAPHS_ENABLED";
+const DOCUMENT_MODEL_SUBGRAPHS_ENABLED_DEFAULT = true;
+const REQUIRE_SIGNATURES = "REQUIRE_SIGNATURES";
+const REQUIRE_SIGNATURES_DEFAULT = false;
+if (process.env.SENTRY_DSN) {
+	defaultLogger.info("Initialized Sentry with env: @env", process.env.SENTRY_ENV);
+	Sentry.init({
+		dsn: process.env.SENTRY_DSN,
+		environment: process.env.SENTRY_ENV,
+		release: process.env.SENTRY_RELEASE || (process.env.npm_package_version ? `v${process.env.npm_package_version}` : void 0)
+	});
+}
+const DEFAULT_PORT = process.env.PORT ? Number(process.env.PORT) : 4001;
+const PORT_FALLBACK_ATTEMPTS = 20;
+/**
+* Attempt to bind a throwaway TCP server to the given port. Resolves true if
+* the port is free, false if the OS reports it in use. Any other error is
+* surfaced so we don't silently mask real issues (permissions, bad host, …).
+*/
+function isPortAvailable(port) {
+	return new Promise((resolve, reject) => {
+		const tester = net.createServer();
+		tester.once("error", (err) => {
+			if (err.code === "EADDRINUSE" || err.code === "EACCES") resolve(false);
+			else reject(err);
+		});
+		tester.once("listening", () => {
+			tester.close(() => resolve(true));
+		});
+		tester.listen({
+			port,
+			host: "::"
+		});
+	});
+}
+async function resolveServerPort(requested, strictPort, logger) {
+	if (strictPort) return requested;
+	for (let i = 0; i < PORT_FALLBACK_ATTEMPTS; i++) {
+		const candidate = requested + i;
+		if (await isPortAvailable(candidate)) {
+			if (candidate !== requested) logger.info(`Port ${requested} is in use. Falling back to port ${candidate}.`);
+			return candidate;
+		}
+	}
+	return requested;
+}
+async function initServer(serverPort, options, renown) {
+	if (options.meterProvider) metrics.setGlobalMeterProvider(options.meterProvider);
+	const { dev, packages = [], remoteDrives = [], logger = defaultLogger } = options;
+	logger.level = LogLevel;
+	const readModelPath = (options.dbPath ?? process.env.DATABASE_URL) || ".ph/read-storage";
+	const config = getConfig(options.configFile ?? path.join(process.cwd(), "powerhouse.config.json"));
+	const registryUrl = process.env.PH_REGISTRY_URL ?? config.packageRegistryUrl;
+	const registryPackages = process.env.PH_REGISTRY_PACKAGES;
+	const dynamicModelLoading = options.dynamicModelLoading ?? process.env.DYNAMIC_MODEL_LOADING === "true";
+	let httpLoader;
+	if (registryUrl) {
+		register(httpsHooksPath, import.meta.url);
+		httpLoader = new HttpPackageLoader({ registryUrl });
+		registryPackages?.split(",").forEach((p) => {
+			const name = p.trim();
+			if (!packages.includes(name)) packages.push(name);
+		});
+	}
+	const reactorLogger = logger.child(["reactor"]);
+	const initializeClient = async (documentModels$1) => {
+		const eventBus = new EventBus();
+		const builder = new ReactorBuilder().withEventBus(eventBus).withDocumentModels(getUniqueDocumentModels([
+			documentModelDocumentModelModule,
+			driveDocumentModelModule,
+			...documentModels,
+			...documentModels$1
+		])).withChannelScheme(ChannelScheme.SWITCHBOARD).withSignalHandlers().withLogger(reactorLogger);
+		const maxSkipThreshold = parseInt(process.env.MAX_SKIP_THRESHOLD ?? "", 10);
+		if (!isNaN(maxSkipThreshold) && maxSkipThreshold > 0) {
+			builder.withExecutorConfig({ maxSkipThreshold });
+			logger.info(`Reactor maxSkipThreshold set to ${maxSkipThreshold}`);
+		}
+		const reactorDbUrl = process.env.PH_REACTOR_DATABASE_URL;
+		if (reactorDbUrl && isPostgresUrl(reactorDbUrl)) {
+			const kysely = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({ connectionString: reactorDbUrl.includes("?") ? reactorDbUrl : `${reactorDbUrl}?sslmode=disable` }) }) });
+			builder.withKysely(kysely);
+			logger.info("Using PostgreSQL for reactor storage");
+		} else {
+			const kysely = new Kysely({ dialect: new PGliteDialect(new PGlite("./.ph/reactor-storage")) });
+			builder.withKysely(kysely);
+			logger.info("Using PGlite for reactor storage");
+		}
+		if (httpLoader && dynamicModelLoading) builder.withDocumentModelLoader(httpLoader.documentModelLoader);
+		const clientBuilder = new ReactorClientBuilder().withReactorBuilder(builder);
+		if (renown) {
+			const signerConfig = getRenownSignerConfig(renown, options.identity?.requireSignatures);
+			clientBuilder.withSigner(signerConfig);
+		}
+		const module = await clientBuilder.buildModule();
+		if (module.reactorModule) {
+			new ReactorInstrumentation(module.reactorModule).start();
+			reactorLogger.info("Reactor metrics instrumentation started");
+		}
+		return module;
+	};
+	let defaultDriveUrl = void 0;
+	const basePath = process.cwd();
+	const viteLogger = createViteLogger(logger);
+	const vite = dev ? await startViteServer(process.cwd(), viteLogger) : void 0;
+	if (!options.disableLocalPackages) packages.push(basePath);
+	const packageLoaders = [];
+	if (vite) packageLoaders.push(VitePackageLoader.build(vite));
+	else packageLoaders.push(new ImportPackageLoader());
+	if (httpLoader) {
+		packageLoaders.push(httpLoader);
+		registryPackages?.split(",").forEach((p) => {
+			const name = p.trim();
+			if (!packages.includes(name)) packages.push(name);
+		});
+	}
+	const apiLogger = logger.child(["reactor-api"]);
+	const api = await initializeAndStartAPI(initializeClient, {
+		port: serverPort,
+		dbPath: readModelPath,
+		https: options.https,
+		packageLoaders: packageLoaders.length > 0 ? packageLoaders : void 0,
+		packages,
+		processorConfig: options.processorConfig,
+		processors: { "@powerhousedao/vetra": [processorFactory] },
+		configFile: options.configFile ?? path.join(process.cwd(), "powerhouse.config.json"),
+		mcp: options.mcp ?? true,
+		logger: apiLogger,
+		enableDocumentModelSubgraphs: options.enableDocumentModelSubgraphs
+	}, "switchboard");
+	if (process.env.SENTRY_DSN) api.httpAdapter.setupSentryErrorHandler(Sentry);
+	const { client, graphqlManager, documentModelRegistry } = api;
+	if (httpLoader) {
+		const packageManagementService = new PackageManagementService({
+			defaultRegistryUrl: registryUrl,
+			httpLoader,
+			documentModelRegistry
+		});
+		packageManagementService.setOnModelsChanged(() => {
+			graphqlManager.regenerateDocumentModelSubgraphs().catch(logger.error);
+		});
+		const packagesSubgraph = new PackagesSubgraph({
+			relationalDb: void 0,
+			analyticsStore: void 0,
+			reactorClient: client,
+			graphqlManager,
+			syncManager: api.syncManager,
+			path: graphqlManager.getBasePath(),
+			packageManagementService
+		});
+		graphqlManager.registerSubgraphInstance(packagesSubgraph, "graphql", false).then(() => graphqlManager.updateRouter()).catch((error) => {
+			logger.error("Failed to register packages subgraph: @error", error);
+		});
+	}
+	if (options.drive) {
+		if (!renown) throw new Error("Cannot create default drive without Renown identity");
+		defaultDriveUrl = await addDefaultDrive(client, options.drive, serverPort);
+	}
+	if (vite) api.httpAdapter.mountRawMiddleware(vite.middlewares);
+	if (remoteDrives.length > 0) for (const remoteDriveUrl of remoteDrives) {
+		let driveId;
+		try {
+			const { syncManager } = api;
+			const parsed = parseDriveUrl(remoteDriveUrl);
+			driveId = parsed.driveId;
+			const remoteName = `remote-drive-${driveId}-${crypto.randomUUID()}`;
+			await syncManager.add(remoteName, driveCollectionId("main", driveId), {
+				type: "gql",
+				parameters: { url: parsed.graphqlEndpoint }
+			});
+			logger.debug("Remote drive @remoteDriveUrl synced", remoteDriveUrl);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("already exists")) {
+				logger.debug("Remote drive already added: @remoteDriveUrl", remoteDriveUrl);
+				driveId = remoteDriveUrl.split("/").pop();
+			} else logger.error("Failed to connect to remote drive @remoteDriveUrl: @error", remoteDriveUrl, error);
+		} finally {
+			if (!defaultDriveUrl && driveId) defaultDriveUrl = `${options.https ? "https" : "http"}://localhost:${serverPort}/d/${driveId}`;
+		}
+	}
+	return {
+		defaultDriveUrl,
+		api,
+		reactor: client,
+		renown,
+		port: serverPort
+	};
+}
+const startSwitchboard = async (options = {}) => {
+	const requestedPort = options.port ?? DEFAULT_PORT;
+	const logger = options.logger ?? defaultLogger;
+	const serverPort = await resolveServerPort(requestedPort, options.strictPort ?? false, logger);
+	const featureFlags = await initFeatureFlags();
+	const enableDocumentModelSubgraphs = await featureFlags.getBooleanValue(DOCUMENT_MODEL_SUBGRAPHS_ENABLED, options.enableDocumentModelSubgraphs ?? DOCUMENT_MODEL_SUBGRAPHS_ENABLED_DEFAULT);
+	options.enableDocumentModelSubgraphs = enableDocumentModelSubgraphs;
+	const requireSignatures = options.identity?.requireSignatures ?? await featureFlags.getBooleanValue(REQUIRE_SIGNATURES, REQUIRE_SIGNATURES_DEFAULT);
+	options.identity = {
+		...options.identity,
+		requireSignatures
+	};
+	logger.info("Feature flags: @flags", JSON.stringify({
+		DOCUMENT_MODEL_SUBGRAPHS_ENABLED: enableDocumentModelSubgraphs,
+		REQUIRE_SIGNATURES: requireSignatures
+	}, null, 2));
+	let renown = null;
+	try {
+		renown = await initRenown(options.identity);
+	} catch (e) {
+		logger.warn("Failed to initialize ConnectCrypto: @error", e);
+		if (options.identity?.requireExisting) throw new Error("Identity required but failed to initialize. Run \"ph login\" first.");
+	}
+	try {
+		return await initServer(serverPort, options, renown);
+	} catch (e) {
+		Sentry.captureException(e);
+		logger.error("App crashed: @error", e);
+		throw e;
+	}
+};
+if (import.meta.main) await startSwitchboard();
+//#endregion
+export { startSwitchboard as n, isPortAvailable as t };
+
+//# sourceMappingURL=server-BMtyzhoR.mjs.map