@kilnai/runtime 0.1.1

package/dist/gateway/gateway-server.js

@@ -0,0 +1,736 @@
+// Gateway: GatewayServer -- persistent Bun/Hono process hosting multiple Apps
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { createRequire } from "node:module";
+import { createBunWebSocket, serveStatic } from "hono/bun";
+import { parseGatewayYaml, parseAppYaml, AnthropicAdapter, OpenAIAdapter, DeepSeekAdapter, OllamaAdapter, KilnError, OTelExporter, SafetyPipeline, SqliteMemoryStore, } from "@kilnai/core";
+import { EventBus, McpClient, CostTracker } from "@kilnai/core";
+import { ChannelRegistry } from "../channels/channel-registry.js";
+import { WebChannel } from "../channels/web-channel.js";
+import { TriggerRegistry } from "../trigger/trigger-registry.js";
+import { resolveApps } from "./app-resolver.js";
+import { createGatewayApp } from "./gateway-routes.js";
+import { ModeBOrchestrator } from "../session/mode-b-orchestrator.js";
+import { SessionRegistry } from "../session/session-registry.js";
+import { TenantRegistry } from "../tenant/tenant-registry.js";
+import { assertValidStartupConfig } from "./config-validator.js";
+import { HealthRegistry } from "./health-registry.js";
+import { ApprovalGateRegistry } from "./approval-registry.js";
+import { DevOrchestrator } from "./dev-orchestrator.js";
+import { DevTokenStore } from "./dev-token-store.js";
+export { createGatewayApp } from "./gateway-routes.js";
+export { createDevRoutes } from "./dev-routes.js";
+export { createDevInspectorHtml } from "./dev-inspector.js";
+export { ApprovalGateRegistry } from "./approval-registry.js";
+export { DevOrchestrator } from "./dev-orchestrator.js";
+export { DevTokenStore } from "./dev-token-store.js";
+/** Build the shared portion of DevRoutesConfig from common dependencies */
+function buildSharedDevRoutesConfig(deps) {
+    const { eventBus, costTracker, approvalRegistry, devOrchestrator, tokenStore } = deps;
+    return {
+        getEventBus: () => eventBus,
+        getCostSummary: () => costTracker.summary,
+        approvePhase: (sessionId) => approvalRegistry.approve(sessionId),
+        rejectPhase: (reason, sessionId) => approvalRegistry.reject(reason, sessionId),
+        startRun: devOrchestrator
+            ? (task) => {
+                if (devOrchestrator.isRunning)
+                    return { error: "A run is already in progress" };
+                const sessionId = devOrchestrator.start(task);
+                return { sessionId };
+            }
+            : undefined,
+        getRunStatus: devOrchestrator
+            ? () => ({
+                sessionId: devOrchestrator.orchestrator.sessionId,
+                status: devOrchestrator.orchestrator.status,
+                phase: devOrchestrator.orchestrator.currentPhase,
+                task: devOrchestrator.orchestrator.task,
+            })
+            : undefined,
+        issueToken: tokenStore ? (userId) => tokenStore.issue(userId) : undefined,
+    };
+}
+function resolveStudioDist() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("@kilnai/studio/package.json");
+        const distDir = join(dirname(pkgPath), "dist");
+        if (existsSync(join(distDir, "index.html")))
+            return distDir;
+        console.warn("Studio: @kilnai/studio found but dist/ not built. Run `bun run build` in packages/studio.");
+        return undefined;
+    }
+    catch {
+        console.warn("Studio: @kilnai/studio not installed. Using inline dev inspector. Install it for the full Studio UI.");
+        return undefined;
+    }
+}
+export async function startGateway(configPath, options) {
+    let content;
+    try {
+        content = readFileSync(configPath, "utf-8");
+    }
+    catch {
+        throw new KilnError("CONFIG_INVALID", `Failed to read gateway config: ${configPath}`, {
+            context: { configPath },
+        });
+    }
+    const gatewayConfig = parseGatewayYaml(content);
+    const gatewayYamlDir = dirname(configPath);
+    const resolvedApps = resolveApps(gatewayConfig, gatewayYamlDir);
+    // Build startup config validation input from resolved apps
+    const modeBApps = [];
+    let whatsappConfig;
+    let tenantAdminConfig;
+    for (const resolved of resolvedApps) {
+        if (resolved.modeBConfig?.runtime === "provider-adapter") {
+            const providerName = resolved.modeBConfig.provider.name;
+            const apiKeyEnv = resolved.modeBConfig.provider.apiKeyEnv;
+            if (apiKeyEnv) {
+                modeBApps.push({ provider: providerName, apiKeyEnv });
+            }
+            // Check for WhatsApp channel
+            const whatsappChannel = resolved.binding.channels.find((ch) => ch.type === "whatsapp");
+            if (whatsappChannel) {
+                const verifyTokenEnv = whatsappChannel.verifyTokenEnv ?? "";
+                const accessTokenEnv = whatsappChannel.accessTokenEnv ?? "";
+                if (verifyTokenEnv && accessTokenEnv) {
+                    whatsappConfig = { verifyTokenEnv, accessTokenEnv };
+                }
+            }
+            // Check for tenant admin
+            const adminChannel = resolved.binding.channels.find((ch) => ch.adminTokenEnv);
+            const adminTokenEnv = adminChannel?.adminTokenEnv ?? "";
+            if (adminTokenEnv) {
+                tenantAdminConfig = { adminTokenEnv };
+            }
+        }
+    }
+    // Validate startup configuration before creating providers
+    assertValidStartupConfig({
+        modeBApps: modeBApps.length > 0 ? modeBApps : undefined,
+        whatsapp: whatsappConfig,
+        tenantAdmin: tenantAdminConfig,
+    });
+    // Initialize OTel exporter if observability is configured
+    // @opentelemetry/sdk-trace-base and @opentelemetry/exporter-trace-otlp-http are user-installed
+    // optional packages -- loaded via dynamic import so they're truly optional at compile time.
+    let otelExporter;
+    const obsConfig = gatewayConfig.observability;
+    if (obsConfig?.enabled) {
+        try {
+            const { trace } = await import("@opentelemetry/api");
+            let provider;
+            if (obsConfig.exporter === "console" || obsConfig.exporter === "otlp") {
+                const sdkModuleName = "@opentelemetry/sdk-trace-base";
+                const sdkBase = await import(sdkModuleName);
+                const p = new sdkBase.BasicTracerProvider();
+                if (obsConfig.exporter === "console") {
+                    p.addSpanProcessor(new sdkBase.SimpleSpanProcessor(new sdkBase.ConsoleSpanExporter()));
+                }
+                else {
+                    const otlpModuleName = "@opentelemetry/exporter-trace-otlp-http";
+                    const otlpMod = await import(otlpModuleName);
+                    p.addSpanProcessor(new sdkBase.SimpleSpanProcessor(new otlpMod.OTLPTraceExporter({ url: obsConfig.endpoint })));
+                }
+                p.register();
+                provider = p;
+            }
+            else {
+                // exporter: none -- use the global noop tracer provider
+                provider = trace.getTracerProvider();
+            }
+            otelExporter = new OTelExporter(provider, {
+                serviceName: obsConfig.serviceName,
+                attributes: obsConfig.attributes,
+            });
+            console.log(`Observability: OTel exporter "${obsConfig.exporter}" enabled for service "${obsConfig.serviceName}"`);
+        }
+        catch (err) {
+            console.warn(`Observability: failed to initialize OTel exporter -- ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // EventBus: shared across all apps for observability and dev inspector
+    const gatewayEventBus = new EventBus(100, otelExporter);
+    const costTracker = new CostTracker();
+    const loadedApps = resolvedApps.map((resolved) => {
+        const hasWebChannel = resolved.binding.channels.some((ch) => ch.type === "web");
+        return {
+            name: resolved.name,
+            app: resolved.app,
+            binding: resolved.binding,
+            registry: new ChannelRegistry(),
+            modeBRuntime: undefined,
+            tenantRuntime: undefined,
+            whatsappWebhookConfig: undefined,
+            tenantAdminConfig: undefined,
+            webChannel: hasWebChannel ? new WebChannel() : undefined,
+        };
+    });
+    // Initialize Mode B runtimes and delegation targets in a single pass
+    const sessionRegistry = new SessionRegistry();
+    const delegationTargets = new Map();
+    for (const loaded of loadedApps) {
+        const resolved = resolvedApps.find((r) => r.name === loaded.name);
+        if (!resolved?.modeBConfig || resolved.modeBConfig.runtime !== "provider-adapter")
+            continue;
+        const provider = createProviderFromConfig(resolved.modeBConfig.provider);
+        const systemPrompt = buildSystemPromptFromApp(resolved.app);
+        // Discover MCP tools if configured
+        const mcpClients = [];
+        const tools = [];
+        if (resolved.app.mcp?.servers) {
+            for (const serverConfig of resolved.app.mcp.servers) {
+                try {
+                    const client = new McpClient(serverConfig);
+                    const capabilities = await client.discoverTools();
+                    for (const cap of capabilities) {
+                        tools.push({
+                            name: cap.name,
+                            description: cap.description,
+                            inputSchema: cap.schema,
+                            tags: new Set(cap.tags),
+                        });
+                    }
+                    mcpClients.push(client);
+                    console.log(`  ${loaded.name}: discovered ${capabilities.length} tools from MCP server "${serverConfig.name}"`);
+                }
+                catch (err) {
+                    console.warn(`  ${loaded.name}: failed to connect to MCP server "${serverConfig.name}": ${err}`);
+                }
+            }
+        }
+        const orchestrator = new ModeBOrchestrator({
+            provider,
+            model: resolved.modeBConfig.provider.model,
+            tools: tools.length > 0 ? tools : undefined,
+            mcpClients: mcpClients.length > 0 ? mcpClients : undefined,
+            eventBus: gatewayEventBus,
+        });
+        // Register delegation target (reuse provider + systemPrompt)
+        delegationTargets.set(loaded.name, { appName: loaded.name, provider, systemPrompt });
+        const isMultiTenant = loaded.binding.channels.some((ch) => ch.multiTenant === true);
+        if (isMultiTenant) {
+            // Multi-tenant: use TenantRegistry + tenant routes
+            const tenantStorageDir = join(resolved.memoryBasePath, "tenants");
+            const tenantRegistry = new TenantRegistry(tenantStorageDir);
+            tenantRegistry.load();
+            loaded.tenantRuntime = {
+                appName: loaded.name,
+                orchestrator,
+                sessionRegistry,
+                tenantRegistry,
+                billing: resolved.modeBConfig.billing,
+            };
+            // WhatsApp webhook: find whatsapp channel with verifyTokenEnv
+            const whatsappChannel = loaded.binding.channels.find((ch) => ch.type === "whatsapp");
+            if (whatsappChannel) {
+                const verifyTokenEnv = whatsappChannel.verifyTokenEnv ?? "";
+                loaded.whatsappWebhookConfig = {
+                    appName: loaded.name,
+                    orchestrator,
+                    sessionRegistry,
+                    tenantRegistry,
+                    verifyToken: verifyTokenEnv ? process.env[verifyTokenEnv] ?? "" : "",
+                    memoryBasePath: resolved.memoryBasePath,
+                };
+            }
+            // Admin routes
+            const adminChannel = loaded.binding.channels.find((ch) => ch.adminTokenEnv);
+            const adminTokenEnv = adminChannel?.adminTokenEnv ?? "";
+            loaded.tenantAdminConfig = {
+                tenantRegistry,
+                appName: loaded.name,
+                adminToken: adminTokenEnv ? process.env[adminTokenEnv] ?? undefined : undefined,
+            };
+            const tenantCount = tenantRegistry.list(loaded.name).length;
+            console.log(`  ${loaded.name}: multi-tenant mode (${tenantCount} tenants loaded)`);
+        }
+        else {
+            // Standard Mode B (non-tenant)
+            loaded.modeBRuntime = {
+                appName: loaded.name,
+                orchestrator,
+                sessionRegistry,
+                billing: resolved.modeBConfig.billing,
+                systemPrompt,
+            };
+        }
+    }
+    const port = options?.port ?? gatewayConfig.port;
+    const delegationRegistry = { targets: delegationTargets };
+    // Create health registry and register subsystem checkers
+    const healthRegistry = new HealthRegistry();
+    const startTime = Date.now();
+    // Register provider health checker
+    healthRegistry.register("providers", () => {
+        const providerStatuses = {};
+        let hasError = false;
+        for (const loaded of loadedApps) {
+            const resolved = resolvedApps.find((r) => r.name === loaded.name);
+            if (resolved?.modeBConfig?.runtime === "provider-adapter") {
+                const providerName = resolved.modeBConfig.provider.name;
+                // Provider is considered ok if we have an API key configured
+                const apiKeyEnv = resolved.modeBConfig.provider.apiKeyEnv;
+                const hasKey = apiKeyEnv ? Boolean(process.env[apiKeyEnv]) : false;
+                providerStatuses[providerName] = hasKey ? "ok" : "error";
+                if (!hasKey)
+                    hasError = true;
+            }
+        }
+        return {
+            status: hasError ? "error" : "ok",
+            details: providerStatuses,
+        };
+    });
+    // Register budget health checker
+    healthRegistry.register("budget", () => {
+        // Check if any app has billing configured
+        const hasBilling = loadedApps.some((loaded) => {
+            const resolved = resolvedApps.find((r) => r.name === loaded.name);
+            return Boolean(resolved?.modeBConfig?.billing);
+        });
+        if (!hasBilling) {
+            return { status: "ok", details: { configured: false } };
+        }
+        return { status: "ok", details: { configured: true } };
+    });
+    // Initialize trigger registry for apps with triggers
+    const triggerRegistry = new TriggerRegistry({ eventBus: gatewayEventBus });
+    for (const loaded of loadedApps) {
+        const triggers = loaded.app.triggers;
+        if (triggers && triggers.length > 0) {
+            triggerRegistry.registerApp(loaded.name, triggers);
+            console.log(`  ${loaded.name}: ${triggers.length} trigger(s) registered`);
+        }
+    }
+    // Initialize safety pipelines per app
+    const safetyPipelines = new Map();
+    for (const loaded of loadedApps) {
+        if (loaded.app.safety) {
+            safetyPipelines.set(loaded.name, new SafetyPipeline(loaded.app.safety));
+            console.log(`  ${loaded.name}: safety pipeline enabled`);
+        }
+    }
+    const approvalRegistry = new ApprovalGateRegistry();
+    const devOrchestrator = options?.devMode
+        ? new DevOrchestrator({ eventBus: gatewayEventBus, approvalRegistry })
+        : undefined;
+    const studioDistPath = options?.studioDistPath ?? (options?.devMode ? resolveStudioDist() : undefined);
+    // Initialize dev-mode memory stores (one per layer)
+    let devMemoryStores;
+    if (options?.devMode) {
+        const firstResolved = resolvedApps[0];
+        if (firstResolved) {
+            const devMemoryDir = join(firstResolved.memoryBasePath, "dev");
+            mkdirSync(devMemoryDir, { recursive: true });
+            devMemoryStores = new Map();
+            for (const layer of ["user", "agent", "project"]) {
+                devMemoryStores.set(layer, new SqliteMemoryStore({
+                    dbPath: join(devMemoryDir, `${layer}.db`),
+                    layer,
+                }));
+            }
+        }
+    }
+    const tokenStore = options?.devMode ? new DevTokenStore() : undefined;
+    const { upgradeWebSocket, websocket: bunWebsocket } = createBunWebSocket();
+    const honoApp = createGatewayApp({
+        port,
+        apps: loadedApps,
+        delegationRegistry,
+        healthRegistry,
+        startTime,
+        triggerRegistry,
+        safetyPipelines,
+        upgradeWebSocket,
+        validateToken: tokenStore ? (token) => tokenStore.validate(token) : undefined,
+        devMode: options?.devMode,
+        studioDistPath,
+        devRoutesConfig: options?.devMode
+            ? {
+                ...buildSharedDevRoutesConfig({
+                    eventBus: gatewayEventBus,
+                    costTracker,
+                    approvalRegistry,
+                    devOrchestrator,
+                    tokenStore,
+                }),
+                getPhaseState: () => {
+                    const active = sessionRegistry.activeSessions();
+                    const orch = devOrchestrator?.orchestrator;
+                    return {
+                        status: orch && devOrchestrator.isRunning ? orch.status : (active.length > 0 ? "active" : "idle"),
+                        activeSessions: active.length,
+                        sessions: active.map((s) => ({
+                            id: s.id,
+                            appName: s.appName,
+                            userId: s.userId,
+                            messageCount: s.messageCount,
+                            createdAt: s.createdAt.toISOString(),
+                            lastActivityAt: s.lastActivityAt.toISOString(),
+                        })),
+                        orchestrator: orch ? {
+                            sessionId: orch.sessionId,
+                            status: orch.status,
+                            phase: orch.currentPhase,
+                            task: orch.task,
+                        } : undefined,
+                    };
+                },
+                getMemorySnapshot: () => {
+                    if (!devMemoryStores)
+                        return { entries: [] };
+                    const counts = {};
+                    for (const [layer, store] of devMemoryStores) {
+                        counts[layer] = store.count;
+                    }
+                    return { layers: counts, total: Object.values(counts).reduce((a, b) => a + b, 0) };
+                },
+                getAppNames: () => loadedApps.map((a) => a.name),
+                getSafetyMetrics: () => {
+                    if (safetyPipelines.size === 0)
+                        return { enabled: false };
+                    const apps = {};
+                    for (const [appName, pipeline] of safetyPipelines) {
+                        apps[appName] = pipeline.metrics;
+                    }
+                    return { enabled: true, apps };
+                },
+                getTriggers: () => triggerRegistry.listAll(),
+                getMemoryByScope: async (scope, q, tags) => {
+                    if (!devMemoryStores)
+                        return [];
+                    const validLayers = ["user", "agent", "project"];
+                    const layer = validLayers.includes(scope) ? scope : "project";
+                    const store = devMemoryStores.get(layer);
+                    if (!store)
+                        return [];
+                    if (q) {
+                        const results = await store.search(q, 100);
+                        return results.map((r) => ({
+                            id: r.entry.id,
+                            layer: r.entry.layer,
+                            content: r.entry.content,
+                            tags: r.entry.tags,
+                            score: r.score,
+                            snippet: r.snippet,
+                            createdAt: r.entry.createdAt.toISOString(),
+                            lastAccessedAt: r.entry.lastAccessedAt.toISOString(),
+                            accessCount: r.entry.accessCount,
+                        }));
+                    }
+                    const entries = store.listEntries({ tags });
+                    return entries.map((e) => ({
+                        id: e.id,
+                        layer: e.layer,
+                        content: e.content,
+                        tags: e.tags,
+                        createdAt: e.createdAt.toISOString(),
+                        lastAccessedAt: e.lastAccessedAt.toISOString(),
+                        accessCount: e.accessCount,
+                    }));
+                },
+                createMemoryEntry: async (entry) => {
+                    if (!devMemoryStores)
+                        return { id: "" };
+                    const validLayers = ["user", "agent", "project"];
+                    const layer = validLayers.includes(entry["layer"])
+                        ? entry["layer"]
+                        : "project";
+                    const store = devMemoryStores.get(layer);
+                    if (!store)
+                        return { id: "" };
+                    const content = typeof entry["content"] === "string" ? entry["content"] : String(entry["content"] ?? "");
+                    const rawTags = Array.isArray(entry["tags"]) ? entry["tags"] : [];
+                    const entryTags = rawTags.filter((t) => typeof t === "string");
+                    const id = await store.save({ layer, content, tags: entryTags });
+                    return { id };
+                },
+                deleteMemoryEntry: async (id) => {
+                    if (!devMemoryStores)
+                        return false;
+                    for (const store of devMemoryStores.values()) {
+                        if (store.hasEntry(id)) {
+                            await store.forget(id);
+                            return true;
+                        }
+                    }
+                    return false;
+                },
+                getAppGraph: () => {
+                    const firstLoaded = loadedApps[0];
+                    if (!firstLoaded)
+                        return undefined;
+                    return appToGraph(firstLoaded.app);
+                },
+                getYamlContent: () => {
+                    try {
+                        const firstBinding = gatewayConfig.apps[0];
+                        if (!firstBinding)
+                            return undefined;
+                        const yamlPath = join(gatewayYamlDir, firstBinding.config);
+                        return readFileSync(yamlPath, "utf-8");
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+                putYamlContent: (content) => {
+                    try {
+                        // Validate YAML before writing
+                        parseAppYaml(content);
+                        const firstBinding = gatewayConfig.apps[0];
+                        if (!firstBinding)
+                            return { ok: false, errors: ["No YAML path available"] };
+                        const yamlPath = join(gatewayYamlDir, firstBinding.config);
+                        writeFileSync(yamlPath, content, "utf-8");
+                        return { ok: true };
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        return { ok: false, errors: [msg] };
+                    }
+                },
+                getEvalExperiments: () => {
+                    const firstLoaded = loadedApps[0];
+                    if (!firstLoaded?.app.eval?.experiments)
+                        return [];
+                    return firstLoaded.app.eval.experiments.map((exp) => ({
+                        name: exp.name,
+                        dataset: exp.dataset,
+                        scorers: [...exp.scorers],
+                    }));
+                },
+            }
+            : undefined,
+    });
+    if (studioDistPath) {
+        mountStudio(honoApp, studioDistPath);
+    }
+    triggerRegistry.start();
+    const appNames = loadedApps.map((a) => a.name).join(", ");
+    console.log(`Gateway started on port ${port} with ${loadedApps.length} apps: ${appNames}`);
+    if (options?.devMode) {
+        console.log(`Studio: http://localhost:${port}/${studioDistPath ? "studio" : "dev"}/`);
+    }
+    await serveAndWait(honoApp, port, () => triggerRegistry.stop(), bunWebsocket);
+}
+/** Create a ProviderAdapter from a Mode B provider config */
+function createProviderFromConfig(config) {
+    const apiKey = config.apiKeyEnv ? process.env[config.apiKeyEnv] ?? "" : "";
+    const model = config.model;
+    switch (config.name) {
+        case "anthropic":
+            return new AnthropicAdapter({ apiKey, defaultModel: model });
+        case "openai":
+            return new OpenAIAdapter({ apiKey, defaultModel: model });
+        case "deepseek":
+            return new DeepSeekAdapter({ apiKey, defaultModel: model });
+        case "ollama":
+            return new OllamaAdapter({ defaultModel: model });
+        default:
+            throw new KilnError("CONFIG_INVALID", `Unknown provider: ${config.name}`, {
+                context: { provider: config.name },
+            });
+    }
+}
+/** Build a system prompt from an App composite using agent metadata */
+function buildSystemPromptFromApp(app) {
+    // Find the primary agent: the manager of the fallback team, or first agent
+    const fallbackTeam = app.teams[app.router.fallback];
+    let primaryAgent;
+    if (fallbackTeam) {
+        if (fallbackTeam.manager && fallbackTeam.agents[fallbackTeam.manager]) {
+            primaryAgent = fallbackTeam.agents[fallbackTeam.manager];
+        }
+        else {
+            const agents = Object.values(fallbackTeam.agents);
+            primaryAgent = agents[0];
+        }
+    }
+    if (!primaryAgent) {
+        return `You are ${app.name}. Respond helpfully.`;
+    }
+    const parts = [];
+    // Identity
+    if (primaryAgent.backstory) {
+        parts.push(primaryAgent.backstory);
+    }
+    else {
+        parts.push(`You are ${primaryAgent.name}, ${primaryAgent.role}.`);
+    }
+    // Goal
+    if (primaryAgent.goal) {
+        parts.push(`\nYour goal: ${primaryAgent.goal}`);
+    }
+    // Instructions
+    if (primaryAgent.instructions) {
+        parts.push(`\n${primaryAgent.instructions}`);
+    }
+    return parts.join("\n");
+}
+function appToGraph(app) {
+    return {
+        name: app.name,
+        teams: Object.entries(app.teams).map(([name, team]) => ({
+            name,
+            agents: Object.values(team.agents).map((a) => ({
+                name: a.name,
+                role: a.role,
+                goal: a.goal,
+                tier: a.tier,
+                tools: [...a.tools],
+                modalities: a.modalities ? [...a.modalities] : undefined,
+            })),
+            capabilities: team.capabilities.map((c) => c.name),
+            phases: [...team.workflow.phases],
+            mode: team.mode,
+        })),
+        router: {
+            rules: app.router.rules.map((r) => ({ pattern: r.match, team: r.team })),
+            fallback: app.router.fallback,
+            classifier: app.router.classifier?.name,
+        },
+        channels: [...app.channels],
+        triggers: app.triggers?.map((t) => t.name) ?? [],
+        hasKnowledge: !!app.knowledge,
+        hasEval: !!app.eval,
+        hasSafety: !!app.safety,
+    };
+}
+function mountStudio(app, distPath) {
+    app.get("/studio", (c) => c.redirect("/studio/"));
+    app.use("/studio/*", serveStatic({
+        root: distPath,
+        rewriteRequestPath: (path) => {
+            const stripped = path.replace(/^\/studio/, "");
+            return stripped === "/" || stripped === "" ? "/index.html" : stripped;
+        },
+    }));
+    app.get("/studio/*", (c) => {
+        const html = readFileSync(join(distPath, "index.html"), "utf-8");
+        return c.html(html);
+    });
+}
+async function serveAndWait(app, port, onShutdown, websocketHandler) {
+    const websocket = websocketHandler ?? createBunWebSocket().websocket;
+    let server;
+    try {
+        server = Bun.serve({ port, fetch: app.fetch, websocket });
+    }
+    catch (err) {
+        if (err instanceof Error && "code" in err && err.code === "EADDRINUSE") {
+            console.error(`Error: Port ${port} is already in use.`);
+            process.exit(1);
+        }
+        throw err;
+    }
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            console.log("\nShutting down...");
+            onShutdown?.();
+            server.stop(true);
+            resolve();
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    });
+}
+export async function startDevServer(options) {
+    const port = options?.port ?? 4800;
+    const eventBus = new EventBus(100);
+    const costTracker = new CostTracker();
+    const studioDistPath = options?.studioDistPath ?? resolveStudioDist();
+    let app;
+    const appYamlPath = options?.appYamlPath;
+    if (appYamlPath && existsSync(appYamlPath)) {
+        try {
+            app = parseAppYaml(readFileSync(appYamlPath, "utf-8"));
+        }
+        catch {
+            // Invalid YAML -- Studio will show empty graph
+        }
+    }
+    const approvalRegistry = new ApprovalGateRegistry();
+    const devOrchestrator = new DevOrchestrator({ eventBus, approvalRegistry });
+    const tokenStore = new DevTokenStore();
+    const honoApp = createGatewayApp({
+        port,
+        apps: [],
+        devMode: true,
+        studioDistPath,
+        upgradeWebSocket: undefined,
+        validateToken: (token) => tokenStore.validate(token),
+        devRoutesConfig: {
+            ...buildSharedDevRoutesConfig({
+                eventBus,
+                costTracker,
+                approvalRegistry,
+                devOrchestrator,
+                tokenStore,
+            }),
+            getPhaseState: () => {
+                const orch = devOrchestrator.orchestrator;
+                return {
+                    status: devOrchestrator.isRunning ? orch.status : "idle",
+                    orchestrator: {
+                        sessionId: orch.sessionId,
+                        status: orch.status,
+                        phase: orch.currentPhase,
+                        task: orch.task,
+                    },
+                };
+            },
+            getMemorySnapshot: () => ({ entries: [] }),
+            getSafetyMetrics: () => ({ enabled: false }),
+            getAppNames: () => app ? [app.name] : [],
+            getTriggers: () => [],
+            getAppGraph: () => app ? appToGraph(app) : undefined,
+            getYamlContent: () => {
+                if (!appYamlPath)
+                    return undefined;
+                try {
+                    return readFileSync(appYamlPath, "utf-8");
+                }
+                catch {
+                    return undefined;
+                }
+            },
+            putYamlContent: (content) => {
+                if (!appYamlPath)
+                    return { ok: false, errors: ["No app.yaml path"] };
+                try {
+                    parseAppYaml(content);
+                    writeFileSync(appYamlPath, content, "utf-8");
+                    try {
+                        app = parseAppYaml(content);
+                    }
+                    catch { /* keep previous */ }
+                    return { ok: true };
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    return { ok: false, errors: [msg] };
+                }
+            },
+            getEvalExperiments: () => {
+                if (!app?.eval?.experiments)
+                    return [];
+                return app.eval.experiments.map((exp) => ({
+                    name: exp.name,
+                    dataset: exp.dataset,
+                    scorers: [...exp.scorers],
+                }));
+            },
+        },
+    });
+    if (studioDistPath) {
+        mountStudio(honoApp, studioDistPath);
+    }
+    console.log(`Dev server started on port ${port}`);
+    console.log(`Studio: http://localhost:${port}/${studioDistPath ? "studio" : "dev"}/`);
+    await serveAndWait(honoApp, port);
+}
+//# sourceMappingURL=gateway-server.js.map