@oscharko-dev/keiko-server 0.2.0

package/dist/deps.js

@@ -0,0 +1,457 @@
+// Wave 2 BFF handler dependencies (ADR-0011 D5/D8/D9). The Wave 1 skeleton's `UiServerDeps` carried
+// only the static-serving + CSP + port fields; the JSON/SSE handlers additionally need the resolved
+// gateway config (for the config inspector and for building a ModelPort), an evidence store, a live
+// redactor, the process env, and the in-memory run registry. Every field here is OPTIONAL so the
+// 3-arg `createUiServer({ staticRoot, csp, port })` form still compiles and the Wave 1 server tests
+// pass unchanged; the handlers degrade gracefully (no config → 400 NO_MODEL on a run, null config on
+// the inspector; no store → an empty evidence list).
+import { createDefaultChatCapability, loadConfigFromFile, loadEgressConfigFromFile, parseGatewayConfig, resolveOutboundHttpEgressConfig, } from "@oscharko-dev/keiko-model-gateway";
+import { GatewayError, Gateway } from "@oscharko-dev/keiko-model-gateway";
+import { GatewayModelPort } from "@oscharko-dev/keiko-harness";
+import { createAuditRedactor } from "@oscharko-dev/keiko-evidence";
+import { resolveCostClass } from "@oscharko-dev/keiko-model-gateway";
+import { writeSideFile } from "@oscharko-dev/keiko-evidence";
+import { deepRedactStrings } from "@oscharko-dev/keiko-evidence";
+import { keikoApiKeySecretValues } from "@oscharko-dev/keiko-security";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { createNodeEvidenceStore, resolveEvidenceDir } from "@oscharko-dev/keiko-evidence";
+import { dirname, join } from "node:path";
+import { createRunRegistry } from "./runs.js";
+import { assertUiDbOutsideProject, buildUiStoreOverDatabase, openNodeUiDatabase, resolveUiDbPath, validateProjectPath, } from "./store/index.js";
+import { createTerminalExecutionManager } from "./terminal.js";
+import { createBrowserSessionManager } from "@oscharko-dev/keiko-tools";
+import {} from "@oscharko-dev/keiko-memory-vault";
+import { createBffMemoryVault } from "./memory-handlers.js";
+import { createMemoryAuditHandler } from "./memory-audit-handler.js";
+import { createConsolidationJobRegistry, } from "./memory-consolidation-registry.js";
+import { createRelationshipStorePort, } from "./relationship-handlers.js";
+import { resolveGroundingLimits, } from "@oscharko-dev/keiko-contracts/bff-wire";
+import { createProviderSecretResolver } from "./credentialVault.js";
+import { createLocalKnowledgeKeyProvider } from "./localKnowledgeKeyProvider.js";
+import { migrateLocalConfigCredentials } from "./credentialPersistence.js";
+import { enforceQiRetentionAtStartup, } from "./qualityIntelligence/retentionEnforcement.js";
+function envModelToken(modelId) {
+    return modelId.replace(/[^A-Za-z0-9]/g, "_").toUpperCase();
+}
+function envModelIdFromApiKeyName(name) {
+    const prefix = "KEIKO_MODEL_";
+    const suffix = "_API_KEY";
+    if (!name.startsWith(prefix) || !name.endsWith(suffix)) {
+        return undefined;
+    }
+    const token = name.slice(prefix.length, -suffix.length);
+    return token.length === 0 ? undefined : token.toLowerCase().replace(/_/g, "-");
+}
+function hasEnvProvider(modelId, env) {
+    const token = envModelToken(modelId);
+    const baseUrl = env[`KEIKO_MODEL_${token}_BASE_URL`];
+    const apiKey = env[`KEIKO_MODEL_${token}_API_KEY`];
+    return baseUrl !== undefined && baseUrl.length > 0 && apiKey !== undefined && apiKey.length > 0;
+}
+function envModelIds(env) {
+    const modelIds = [];
+    for (const key of Object.keys(env)) {
+        const modelId = envModelIdFromApiKeyName(key);
+        if (modelId !== undefined && hasEnvProvider(modelId, env)) {
+            modelIds.push(modelId);
+        }
+    }
+    return Array.from(new Set(modelIds));
+}
+function resolveEnvOnlyConfig(env) {
+    const providers = envModelIds(env).map((modelId) => ({
+        modelId,
+        baseUrl: "",
+        apiKey: "",
+        capability: createDefaultChatCapability(modelId),
+    }));
+    if (providers.length === 0) {
+        return undefined;
+    }
+    try {
+        return parseGatewayConfig({ providers }, env);
+    }
+    catch (error) {
+        if (error instanceof GatewayError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function localGatewayConfigPath(uiDbPath) {
+    return join(dirname(uiDbPath), "keiko.config.json");
+}
+// Loads the config without leaking the path or any secret on failure: a missing/invalid config file
+// falls back to KEIKO_MODEL_* env wiring when present, otherwise it is a normal "no config" state.
+function resolveConfig(configPath, env, localConfigPath, secretResolver) {
+    if (configPath === undefined) {
+        let config;
+        try {
+            config = loadConfigFromFile(localConfigPath, env, { secretResolver });
+        }
+        catch (error) {
+            if (error instanceof GatewayError) {
+                config = resolveEnvOnlyConfig(env);
+            }
+            else {
+                throw error;
+            }
+        }
+        return { config, configPresent: config !== undefined };
+    }
+    try {
+        return { config: loadConfigFromFile(configPath, env, { secretResolver }), configPresent: true };
+    }
+    catch (error) {
+        if (error instanceof GatewayError) {
+            const config = resolveEnvOnlyConfig(env);
+            return { config, configPresent: config !== undefined };
+        }
+        throw error;
+    }
+}
+function resolveConfiguredEgress(configPath, env, localConfigPath) {
+    try {
+        return loadEgressConfigFromFile(configPath ?? localConfigPath, env);
+    }
+    catch (error) {
+        if (error instanceof GatewayError) {
+            return resolveOutboundHttpEgressConfig(undefined, env);
+        }
+        throw error;
+    }
+}
+function createRuntimeGatewayConfig(initial, initialPresent, storagePath) {
+    let config = initial;
+    let present = initialPresent;
+    return {
+        storagePath,
+        current: () => config,
+        present: () => present,
+        set(next, nextPresent) {
+            config = next;
+            present = nextPresent;
+        },
+    };
+}
+export function currentGatewayConfig(deps) {
+    return deps.gatewayConfig?.current() ?? deps.config;
+}
+export function currentGatewayConfigPresent(deps) {
+    return deps.gatewayConfig?.present() ?? deps.configPresent;
+}
+export function currentGatewayEgressConfig(deps) {
+    return (deps.gatewayConfig?.current()?.egress ??
+        deps.egress ??
+        deps.config?.egress ??
+        resolveOutboundHttpEgressConfig(undefined, deps.env));
+}
+// Module-level: read KEIKO_GROUNDING_* env overrides ONCE at load (mirrors KEIKO_MODEL_* env
+// reads). Each value is parsed as a positive integer; unparseable values are silently ignored so
+// misconfigured env does not prevent the server from starting.
+function parseEnvPositiveInt(raw) {
+    if (raw === undefined)
+        return undefined;
+    // GRD-037: strict parse so a typo'd value is genuinely ignored (as the comment promises) rather
+    // than silently coerced — Number.parseInt("16abc")→16 and ("4.9")→4. Mirrors the loud
+    // config-file validator's all-digits rule, but here a bad env var falls back to the default.
+    const trimmed = raw.trim();
+    if (!/^\d+$/.test(trimmed))
+        return undefined;
+    const n = Number.parseInt(trimmed, 10);
+    return Number.isFinite(n) && n >= 1 ? n : undefined;
+}
+const ENV_GROUNDING_OVERRIDES = (() => {
+    const env = process.env;
+    const partial = {};
+    const maxConnectedSources = parseEnvPositiveInt(env.KEIKO_GROUNDING_MAX_CONNECTED_SOURCES);
+    if (maxConnectedSources !== undefined)
+        partial.maxConnectedSources = maxConnectedSources;
+    const maxLocalKnowledgeSources = parseEnvPositiveInt(env.KEIKO_GROUNDING_MAX_LOCAL_KNOWLEDGE_SOURCES);
+    if (maxLocalKnowledgeSources !== undefined)
+        partial.maxLocalKnowledgeSources = maxLocalKnowledgeSources;
+    const maxPromptReferences = parseEnvPositiveInt(env.KEIKO_GROUNDING_MAX_PROMPT_REFERENCES);
+    if (maxPromptReferences !== undefined)
+        partial.maxPromptReferences = maxPromptReferences;
+    const maxExcerptChars = parseEnvPositiveInt(env.KEIKO_GROUNDING_MAX_EXCERPT_CHARS);
+    if (maxExcerptChars !== undefined)
+        partial.maxExcerptChars = maxExcerptChars;
+    const referenceBudget = parseEnvPositiveInt(env.KEIKO_GROUNDING_REFERENCE_BUDGET);
+    if (referenceBudget !== undefined)
+        partial.referenceBudget = referenceBudget;
+    const hybridMaxCandidates = parseEnvPositiveInt(env.KEIKO_GROUNDING_HYBRID_MAX_CANDIDATES);
+    if (hybridMaxCandidates !== undefined)
+        partial.hybridMaxCandidates = hybridMaxCandidates;
+    const hybridMaxExcerptBytes = parseEnvPositiveInt(env.KEIKO_GROUNDING_HYBRID_MAX_EXCERPT_BYTES);
+    if (hybridMaxExcerptBytes !== undefined)
+        partial.hybridMaxExcerptBytes = hybridMaxExcerptBytes;
+    return partial;
+})();
+// Resolves the effective grounding limits at call time: file config → env overrides → ceilings.
+// Env overrides win over file config. Re-reads currentGatewayConfig each call so runtime config
+// updates (e.g. first-run UI onboarding) are honored immediately. Never stored as a frozen field.
+export function currentGroundingLimits(deps) {
+    const fileGrounding = currentGatewayConfig(deps)?.grounding;
+    return resolveGroundingLimits({ ...fileGrounding, ...ENV_GROUNDING_OVERRIDES });
+}
+function configTopologyValues(config) {
+    // Epic #177 audit: redact provider URLs and egress settings because backend topology gives an
+    // attacker a place to direct probes. Credentials are collected separately as opaque secrets for
+    // evidence hashing.
+    if (config === undefined)
+        return [];
+    const out = [];
+    const addEgressTopology = (egress) => {
+        if (egress === undefined)
+            return;
+        if (egress.httpProxy !== undefined)
+            out.push(egress.httpProxy);
+        if (egress.httpsProxy !== undefined)
+            out.push(egress.httpsProxy);
+        if (egress.caBundlePath !== undefined)
+            out.push(egress.caBundlePath);
+    };
+    addEgressTopology(config.egress);
+    for (const provider of config.providers) {
+        out.push(provider.baseUrl);
+        addEgressTopology(provider.egress);
+    }
+    return out;
+}
+function configOpaqueSecretValues(config) {
+    if (config === undefined)
+        return [];
+    const out = [];
+    if (config.figma?.accessToken !== undefined) {
+        out.push(config.figma.accessToken);
+    }
+    for (const provider of config.providers) {
+        out.push(provider.apiKey);
+    }
+    return out;
+}
+function configSecretValues(config) {
+    return [...configTopologyValues(config), ...configOpaqueSecretValues(config)];
+}
+function figmaEnvSecretValues(env) {
+    const token = env.FIGMA_ACCESS_TOKEN;
+    return token !== undefined && token.length > 0 ? [token] : [];
+}
+function egressSecretValues(egress) {
+    if (egress === undefined)
+        return [];
+    return [egress.httpProxy, egress.httpsProxy, egress.caBundlePath].filter((value) => value !== undefined);
+}
+// The Figma PAT is redacted via its config (`config.figma.accessToken`) and env
+// (`FIGMA_ACCESS_TOKEN`) literals. The decrypted ENCRYPTED-VAULT token (#758) is intentionally NOT
+// added here: it never reaches a redactable payload — it is confined to the outbound `X-Figma-Token`
+// request header by construction (figmaConnector.ts) and is never returned, logged, or serialized.
+// Adding it would require decrypting the vault at redactor-build time, widening exposure for no gain.
+function redactionSecrets(env, config, egress = config?.egress) {
+    return Array.from(new Set([
+        ...keikoApiKeySecretValues(env),
+        ...figmaEnvSecretValues(env),
+        ...configSecretValues(config),
+        ...egressSecretValues(egress),
+    ]));
+}
+function runtimeRedactionSecrets(env, runtimeConfig, egress) {
+    const config = runtimeConfig.current();
+    return redactionSecrets(env, config, config?.egress ?? egress);
+}
+function runtimeRedactString(env, runtimeConfig, egress) {
+    return (value) => createAuditRedactor({ additionalSecrets: runtimeRedactionSecrets(env, runtimeConfig, egress) }, env)(value);
+}
+// Builds the live-payload redactor from the configured redaction settings + env. No new regex: this
+// reuses `createAuditRedactor` (escaped literals + audited gateway patterns) wrapped by
+// `deepRedactStrings` so every string leaf of a serialized payload is scrubbed.
+export function buildRedactor(env, config) {
+    const egress = config?.egress ?? resolveOutboundHttpEgressConfig(undefined, env);
+    const redactString = createAuditRedactor({
+        additionalSecrets: redactionSecrets(env, config, egress),
+    }, env);
+    return (value) => deepRedactStrings(value, redactString);
+}
+export function currentRedactionSecrets(deps) {
+    return redactionSecrets(deps.env, currentGatewayConfig(deps), currentGatewayEgressConfig(deps));
+}
+export function currentEvidenceTopologyRedactionSecrets(deps) {
+    return Array.from(new Set([
+        ...configTopologyValues(currentGatewayConfig(deps)),
+        ...egressSecretValues(currentGatewayEgressConfig(deps)),
+    ]));
+}
+export function currentEvidenceRequiresFullStringRedaction(deps) {
+    return (keikoApiKeySecretValues(deps.env).length > 0 ||
+        figmaEnvSecretValues(deps.env).length > 0 ||
+        configOpaqueSecretValues(currentGatewayConfig(deps)).length > 0);
+}
+// The production ModelPort factory: a GatewayModelPort over a Gateway built from the resolved
+// config (mirrors the CLI's `new GatewayModelPort(new Gateway(config))`). Returns undefined when no
+// config was resolved so the run route answers 400 NO_MODEL rather than constructing a broken port.
+function defaultModelPortFactory(runtimeConfig) {
+    return () => {
+        const config = runtimeConfig.current();
+        if (config === undefined) {
+            return undefined;
+        }
+        return new GatewayModelPort(new Gateway(config));
+    };
+}
+function buildTerminalManager(options) {
+    return createTerminalExecutionManager({
+        store: options.store,
+        evidenceStore: options.evidenceStore,
+        processEnv: options.env,
+        redactor: (value) => {
+            const redacted = options.liveRedactor(value);
+            return typeof redacted === "string" ? redacted : value;
+        },
+    });
+}
+// ADR-0019 direction rule 3c: the tools package cannot import src/audit. The BFF injects the
+// cost-class resolver and a side-file writer that closes over the resolved evidenceDir + the
+// nodeWorkspaceFs realpath-containment port, so the browser session manager stays self-contained
+// against contracts + security + workspace only.
+function buildBrowserManager(options) {
+    return createBrowserSessionManager({
+        evidenceDir: options.evidenceDir,
+        evidenceStore: options.evidenceStore,
+        redactor: options.redactor,
+        costClassResolver: resolveCostClass,
+        sideFileWriter: (basename, bytes, runId) => writeSideFile(options.evidenceDir, runId, basename, bytes, { fs: nodeWorkspaceFs }),
+    });
+}
+function buildMemoryVault(redactString, evidenceStore, env) {
+    return createBffMemoryVault(redactString, 
+    // #214 — wire every successful vault mutation into the audit ledger. The handler
+    // shares the same redactString closure as the live-payload redactor so audit
+    // summaries inherit the same secret-shape scrubbing as wire traffic.
+    createMemoryAuditHandler({ evidenceStore, redactString }), env);
+}
+// Issue #539: the relationship engine runs server-authoritative scope checks on every route.
+// In the loopback `keiko ui` BFF there is exactly one workspace per process; the resolver
+// returns that workspace identifier from `KEIKO_WORKSPACE_ID` (set), or a stable default
+// otherwise. The constant matches the empty-but-non-zero-length contract of `scope()` so
+// every route resolves a workspaceId instead of returning 403.
+const DEFAULT_LOOPBACK_WORKSPACE_ID = "local";
+function resolveLoopbackWorkspaceId(env) {
+    const explicit = env.KEIKO_WORKSPACE_ID;
+    if (typeof explicit === "string" && explicit.length > 0)
+        return explicit;
+    return DEFAULT_LOOPBACK_WORKSPACE_ID;
+}
+// When no UiStore is injected, open one DatabaseSync against the resolved UI-DB and share it
+// with the relationship-engine store so V5 sibling tables share the UI-store transaction model
+// (issue #539, storage.md §3.1). When tests inject a UiStore we leave `relationship` undefined;
+// relationship-engine tests inject their own deps.
+function composePersistence(injected, resolvedUiDbPath, redactString, env) {
+    if (injected !== undefined)
+        return { store: injected, relationship: undefined };
+    const db = openNodeUiDatabase(resolvedUiDbPath);
+    const store = buildUiStoreOverDatabase(db, { redactString });
+    const relationship = {
+        scopeResolver: () => ({
+            workspaceId: resolveLoopbackWorkspaceId(env),
+        }),
+        store: createRelationshipStorePort({ db, redactString }),
+    };
+    return { store, relationship };
+}
+function seedInitialProject(store, uiDbPath, initialProjectPath) {
+    if (initialProjectPath === undefined || initialProjectPath.trim().length === 0) {
+        return undefined;
+    }
+    const normalizedPath = validateProjectPath(initialProjectPath, { mustExist: true });
+    assertUiDbOutsideProject(uiDbPath, normalizedPath);
+    return store.createProject(normalizedPath).path;
+}
+function buildPeripherals(options, uiStore, evidenceStore, redactString, liveRedactor) {
+    return {
+        terminal: buildTerminalManager({
+            store: uiStore,
+            evidenceStore,
+            env: options.env,
+            liveRedactor,
+        }),
+        browser: buildBrowserManager({
+            evidenceDir: resolveEvidenceDir(options.evidenceDir, options.env),
+            evidenceStore,
+            redactor: liveRedactor,
+        }),
+        memoryVault: buildMemoryVault(redactString, evidenceStore, options.env),
+    };
+}
+// Assembles the handler deps for the real `keiko ui` process, mirroring the CLI config/evidence
+// wiring (loadConfigFromFile / resolveEvidenceDir / createNodeEvidenceStore). The UI store is
+// created at the resolved UI-DB path (explicit → KEIKO_UI_DATA_DIR → ~/.keiko/keiko-ui.db) unless
+// an injected store is supplied (tests).
+// One-time, idempotent migration of any pre-existing plaintext credentials in the local config
+// (Issue #1320), then resolution of the (now reference-only) config through a vault-backed resolver.
+// Migration is best-effort and crash-aware: it never throws into bootstrap, so a partial state simply
+// re-runs next start and is surfaced by `keiko repair`. It runs before the config is read so the
+// resolver turns the rewritten secret references back into live credentials.
+function loadRuntimeGatewayConfig(options, runtimeConfigPath, resolvedEvidenceDir) {
+    const effectiveConfigPath = options.configPath ?? runtimeConfigPath;
+    migrateLocalConfigCredentials({
+        configPath: effectiveConfigPath,
+        env: options.env,
+        evidenceDir: resolvedEvidenceDir,
+    });
+    const secretResolver = createProviderSecretResolver({
+        configPath: effectiveConfigPath,
+        env: options.env,
+    });
+    const resolved = resolveConfig(options.configPath, options.env, runtimeConfigPath, secretResolver);
+    return { ...resolved, storagePath: effectiveConfigPath };
+}
+// Resolve the evidence dir AND run QI run-retention ONCE per server instance at bootstrap (Issue
+// #1323 AC4). Lazy, no timer (a setInterval would race the filesystem-backed store). Best-effort:
+// retention never throws into construction (mirrors migrateLocalConfigCredentials). Short-lived runs
+// past their retention policy are purged deterministically rather than the policy id staying passive.
+function resolveEvidenceDirAndEnforceRetention(options) {
+    const evidenceDir = resolveEvidenceDir(options.evidenceDir, options.env);
+    enforceQiRetentionAtStartup({
+        evidenceDir,
+        now: options.qiRetentionNow,
+        auditSink: options.qiRetentionAuditSink,
+    });
+    return evidenceDir;
+}
+export function buildUiHandlerDeps(options) {
+    const resolvedUiDbPath = resolveUiDbPath(options.uiDbPath, options.env);
+    const runtimeConfigPath = localGatewayConfigPath(resolvedUiDbPath);
+    const resolvedEvidenceDir = resolveEvidenceDirAndEnforceRetention(options);
+    const { config, configPresent, storagePath } = loadRuntimeGatewayConfig(options, runtimeConfigPath, resolvedEvidenceDir);
+    const egress = resolveConfiguredEgress(options.configPath, options.env, runtimeConfigPath);
+    const runtimeConfig = createRuntimeGatewayConfig(config, configPresent, storagePath);
+    const evidenceStore = createNodeEvidenceStore(resolvedEvidenceDir);
+    const redactString = runtimeRedactString(options.env, runtimeConfig, egress);
+    const liveRedactor = (value) => deepRedactStrings(value, redactString);
+    const { store: uiStore, relationship } = composePersistence(options.store, resolvedUiDbPath, redactString, options.env);
+    const preferredProjectPath = seedInitialProject(uiStore, resolvedUiDbPath, options.initialProjectPath);
+    const peripherals = buildPeripherals(options, uiStore, evidenceStore, redactString, liveRedactor);
+    return {
+        config,
+        configPresent,
+        evidenceStore,
+        evidenceDir: resolvedEvidenceDir,
+        env: options.env,
+        egress,
+        redactor: liveRedactor,
+        registry: options.registry ?? createRunRegistry(),
+        modelPortFactory: options.modelPortFactory ?? defaultModelPortFactory(runtimeConfig),
+        redactionSecrets: runtimeRedactionSecrets(options.env, runtimeConfig, egress),
+        store: uiStore,
+        uiDbPath: resolvedUiDbPath,
+        preferredProjectPath,
+        gatewayConfig: runtimeConfig,
+        gatewaySetupTester: options.gatewaySetupTester,
+        gatewayModelDiscovery: options.gatewayModelDiscovery,
+        figmaCredentialTester: options.figmaCredentialTester,
+        localKnowledgeKeyProvider: createLocalKnowledgeKeyProvider({ env: options.env }),
+        ...peripherals,
+        consolidationJobs: createConsolidationJobRegistry(),
+        ...(relationship === undefined ? {} : { relationship }),
+    };
+}

package/dist/editor/agentRoutes.d.ts

@@ -0,0 +1,7 @@
+import { type HandlerOutcome, type RouteContext, type RouteResult } from "../routes.js";
+export declare function handleEditorAgentSessions(): RouteResult;
+export declare function handleEditorAgentSnapshot(ctx: RouteContext): Promise<RouteResult>;
+export declare function handleEditorAgentActions(ctx: RouteContext): Promise<RouteResult>;
+export declare function handleEditorAgentEvents(ctx: RouteContext): HandlerOutcome;
+export declare function _resetEditorAgentStateForTests(): void;
+//# sourceMappingURL=agentRoutes.d.ts.map

package/dist/editor/agentRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentRoutes.d.ts","sourceRoot":"","sources":["../../src/editor/agentRoutes.ts"],"names":[],"mappings":"AAYA,OAAO,EAAwB,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAiJ9G,wBAAgB,yBAAyB,IAAI,WAAW,CAEvD;AAED,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAsBvF;AAED,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAsCtF;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,cAAc,CAMzE;AAeD,wBAAgB,8BAA8B,IAAI,IAAI,CAKrD"}

package/dist/editor/agentRoutes.js

@@ -0,0 +1,197 @@
+import { EDITOR_AGENT_SCHEMA_VERSION, isEditorAgentAction, parseEditorAgentActionsPostBody, parseEditorAgentSnapshotRequest, } from "@oscharko-dev/keiko-contracts";
+import { errorBody, STREAMING } from "../routes.js";
+import { SSE_HEADERS, readyMessage } from "../sse.js";
+import { readJsonObject } from "../files.js";
+const MAX_AGENT_BODY_BYTES = 1_048_576;
+const DEFAULT_SNAPSHOT_TEXT_BUDGET_BYTES = 64 * 1024;
+const sessions = new Map();
+const idempotency = new Map();
+const subscribers = new Set();
+let eventSeq = 0;
+function isRouteResult(value) {
+    return typeof value === "object" && value !== null && "status" in value && "body" in value;
+}
+function nextEventId() {
+    eventSeq += 1;
+    return `editor-agent-${String(eventSeq)}`;
+}
+function emit(event) {
+    const envelope = {
+        schemaVersion: EDITOR_AGENT_SCHEMA_VERSION,
+        eventId: nextEventId(),
+        ...event,
+    };
+    for (const subscriber of subscribers)
+        subscriber(envelope);
+}
+function utf8Prefix(text, maxBytes) {
+    let bytes = 0;
+    let end = 0;
+    for (const char of text) {
+        const nextBytes = Buffer.byteLength(char, "utf8");
+        if (bytes + nextBytes > maxBytes)
+            return { text: text.slice(0, end), truncated: true };
+        bytes += nextBytes;
+        end += char.length;
+    }
+    return { text, truncated: false };
+}
+function shapeSnapshot(snapshot, textMode, maxBytes) {
+    if (textMode === "none" || snapshot.text === undefined) {
+        const { text, textTruncated, ...rest } = snapshot;
+        void text;
+        void textTruncated;
+        return { ...rest, textMode };
+    }
+    const bounded = utf8Prefix(snapshot.text, maxBytes);
+    return {
+        ...snapshot,
+        textMode,
+        text: bounded.text,
+        textTruncated: snapshot.textTruncated === true || bounded.truncated,
+    };
+}
+function dirtyBufferConflict(action, snapshot) {
+    const file = targetFile(action, snapshot);
+    if (file !== null && snapshot.dirtyFiles.includes(file) && action.type !== "save") {
+        return conflict(action, "DIRTY", "The target buffer has unsaved changes.");
+    }
+    return null;
+}
+function documentVersionConflict(action, snapshot) {
+    if (action.expectedDocumentVersion === undefined || snapshot.documentVersion === undefined)
+        return null;
+    return action.expectedDocumentVersion.contentHash === snapshot.documentVersion.contentHash
+        ? null
+        : conflict(action, "VERSION_MISMATCH", "The active document version no longer matches.");
+}
+function contentHashConflict(action, snapshot) {
+    if (action.expectedContentHash === undefined || snapshot.activeFileContentHash === undefined)
+        return null;
+    return action.expectedContentHash === snapshot.activeFileContentHash
+        ? null
+        : conflict(action, "CONTENT_HASH_MISMATCH", "The active document content hash no longer matches.");
+}
+function targetFile(action, snapshot) {
+    return action.target?.file ?? snapshot.activeFile;
+}
+function writeAction(action) {
+    return (action.type === "format" ||
+        action.type === "save" ||
+        action.type === "applyTextEdits" ||
+        action.type === "applyPatch");
+}
+function conflict(action, code, message) {
+    return {
+        schemaVersion: EDITOR_AGENT_SCHEMA_VERSION,
+        actionId: action.actionId,
+        sessionId: action.sessionId,
+        status: "conflict",
+        message,
+        conflict: { code, message },
+    };
+}
+function preflight(action) {
+    const snapshot = sessions.get(action.sessionId);
+    if (snapshot === undefined) {
+        return conflict(action, "NO_ACTIVE_SESSION", "No active browser bridge is registered.");
+    }
+    if (!writeAction(action))
+        return null;
+    return (dirtyBufferConflict(action, snapshot) ??
+        documentVersionConflict(action, snapshot) ??
+        contentHashConflict(action, snapshot));
+}
+export function handleEditorAgentSessions() {
+    return { status: 200, body: { sessions: [...sessions.values()] } };
+}
+export async function handleEditorAgentSnapshot(ctx) {
+    const body = await readJsonObject(ctx.req, MAX_AGENT_BODY_BYTES);
+    if (isRouteResult(body))
+        return body;
+    const parsed = parseEditorAgentSnapshotRequest(body);
+    if (!parsed.ok) {
+        return { status: 400, body: errorBody("INVALID_REQUEST", parsed.errors.join("; ")) };
+    }
+    if ("kind" in parsed.value) {
+        sessions.set(parsed.value.snapshot.sessionId, parsed.value.snapshot);
+        emit({ type: "session", snapshot: parsed.value.snapshot });
+        return { status: 200, body: { snapshot: parsed.value.snapshot } };
+    }
+    const selected = parsed.value.sessionId === undefined
+        ? [...sessions.values()][0]
+        : sessions.get(parsed.value.sessionId);
+    if (selected === undefined)
+        return { status: 200, body: { snapshot: null } };
+    const maxBytes = parsed.value.maxBytes ?? DEFAULT_SNAPSHOT_TEXT_BUDGET_BYTES;
+    return {
+        status: 200,
+        body: { snapshot: shapeSnapshot(selected, parsed.value.textMode, maxBytes) },
+    };
+}
+export async function handleEditorAgentActions(ctx) {
+    const body = await readJsonObject(ctx.req, MAX_AGENT_BODY_BYTES);
+    if (isRouteResult(body))
+        return body;
+    const parsed = parseEditorAgentActionsPostBody(body);
+    if (!parsed.ok) {
+        return { status: 400, body: errorBody("INVALID_REQUEST", parsed.errors.join("; ")) };
+    }
+    if (!isEditorAgentAction(parsed.value)) {
+        const result = parsed.value.result;
+        emit({ type: "result", result });
+        return { status: 200, body: { result } };
+    }
+    const action = parsed.value;
+    const requestBody = JSON.stringify(action);
+    const replay = idempotency.get(action.idempotencyKey);
+    if (replay !== undefined) {
+        if (replay.requestBody !== requestBody) {
+            return {
+                status: 409,
+                body: errorBody("IDEMPOTENCY_CONFLICT", "Idempotency-Key was reused with a different action."),
+            };
+        }
+        return { status: 200, body: { result: replay.result } };
+    }
+    const failed = preflight(action);
+    if (failed !== null) {
+        idempotency.set(action.idempotencyKey, { requestBody, result: failed });
+        return { status: 409, body: { result: failed } };
+    }
+    const result = {
+        schemaVersion: EDITOR_AGENT_SCHEMA_VERSION,
+        actionId: action.actionId,
+        sessionId: action.sessionId,
+        status: "queued",
+    };
+    idempotency.set(action.idempotencyKey, { requestBody, result });
+    emit({ type: "action", action });
+    return { status: 202, body: { result } };
+}
+export function handleEditorAgentEvents(ctx) {
+    openAgentSseStream(ctx.res);
+    ctx.req.on("close", () => {
+        ctx.res.end();
+    });
+    return STREAMING;
+}
+function openAgentSseStream(res) {
+    res.writeHead(200, SSE_HEADERS);
+    const subscriber = (event) => {
+        const frame = `id: ${event.eventId}\nevent: editor-agent:${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+        if (!res.write(frame))
+            res.destroy();
+    };
+    subscribers.add(subscriber);
+    res.write(readyMessage());
+    res.on("close", () => {
+        subscribers.delete(subscriber);
+    });
+}
+export function _resetEditorAgentStateForTests() {
+    sessions.clear();
+    idempotency.clear();
+    subscribers.clear();
+    eventSeq = 0;
+}