@bolt-foundry/gambit 0.8.6-rc.7 → 0.8.6

package/esm/src/server.js

@@ -1,635 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-import * as path from "../deps/jsr.io/@std/path/1.1.4/mod.js";
-import { assertSafeBuildBotRoot, randomId } from "./server_helpers.js";
-import { defaultSessionRoot } from "./cli_utils.js";
-import { makeConsoleTracer } from "./trace.js";
-import { loadDeck } from "@bolt-foundry/gambit-core";
-import { createSessionStore } from "./server_session_store.js";
-import { buildRootScenarioFallback, buildWorkspaceDeckStateFromLoadedDeck, resolveGraderDeckFromState, resolveScenarioDeckFromState, summarizeDeckState, toAvailableGraderDeck, toAvailableTestDeck, toDeckLabel, } from "./server_workspace_decks.js";
-import { createWorkspaceDeckGraphqlOperations } from "./server_workspace_graphql.js";
-import { createWorkspaceRuntime } from "./server_workspace_runtime.js";
-import { createReadCodexWorkspaceStatus, handleBuildProviderStatusRequest, normalizeBuildChatProvider, persistBuildChatProviderMeta, } from "./server_build_chat_provider.js";
-import { WORKSPACE_ROUTE_BASE, WORKSPACE_STATE_SCHEMA_VERSION, workspaceSchemaError, } from "./workspace_routes.js";
-import { appendDurableStreamEvent } from "./durable_streams.js";
-import { ensureSimulatorBundle } from "./server_simulator_ui.js";
-import { createSimulatorRequestHandler } from "./server/request_handler.js";
-import { createWorkspaceSessionService } from "./server/workspace/sessions.js";
-import { createWorkspaceReadModelService } from "./server/workspace/read_model.js";
-import { buildPersistedAssistantDeck, describeDeckInputSchemaFromPath, describeZodSchema, ensureGambitPolicyInBotRoot, GAMBIT_BOT_SOURCE_DECK_PATH, mapDeckTools, resolveDeckPath, } from "./server/workspace/schema.js";
-import { createOpenResponsesEventPersistence } from "./server/workspace/response_events.js";
-import { createWorkspaceBuildService } from "./server/workspace/build.js";
-import { createWorkspaceScenarioService } from "./server/workspace/scenarios.js";
-import { createWorkspaceGradingService } from "./server/workspace/grading.js";
-import { createWorkspaceVerifyService } from "./server/workspace/verify.js";
-import { createWorkspaceConversationSessionService } from "./server/workspace/conversation_sessions.js";
-const logger = console;
-const WORKSPACE_STREAM_ID = "gambit-workspace";
-const TEST_STREAM_ID = "gambit-test";
-const WORKSPACE_API_BASE = "/api/workspace";
-const WORKSPACES_API_BASE = "/api/workspaces";
-const VERIFY_SCENARIO_RUNS_MAX = 24;
-const VERIFY_GRADER_REPEATS_MAX = 24;
-const VERIFY_BATCH_CONCURRENCY_MAX = 6;
-const DEFAULT_VERIFY_SCENARIO_RUNS = 10;
-const DEFAULT_VERIFY_GRADER_REPEATS = 10;
-const DEFAULT_VERIFY_CONCURRENCY = 4;
-const WORKSPACE_REFRESH_DEBUG = (() => {
-    const value = (dntShim.Deno.env.get("GAMBIT_WORKSPACE_REFRESH_DEBUG") ?? "")
-        .toLowerCase()
-        .trim();
-    return value === "1" || value === "true" || value === "yes";
-})();
-const logWorkspaceRefreshDebug = (event, payload) => {
-    if (!WORKSPACE_REFRESH_DEBUG)
-        return;
-    logger.info(`[gambit-workspace-refresh-debug] ${event} ${JSON.stringify(payload)}`);
-};
-const extractMissingReadfilePath = (message) => {
-    const match = message.match(/readfile ['"]([^'"]+)['"]/);
-    return match?.[1] ?? null;
-};
-const safeJsonStringify = (value) => {
-    const stack = [];
-    return JSON.stringify(value, function (_key, candidate) {
-        if (!candidate || typeof candidate !== "object")
-            return candidate;
-        while (stack.length > 0 && stack[stack.length - 1] !== this) {
-            stack.pop();
-        }
-        if (stack.includes(candidate))
-            return "[Circular]";
-        stack.push(candidate);
-        return candidate;
-    });
-};
-const sanitizeJsonRecord = (value) => {
-    const parsed = JSON.parse(safeJsonStringify(value));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return {};
-    }
-    return parsed;
-};
-export function startWebSocketSimulator(opts) {
-    const port = opts.port ?? 8000;
-    const initialContext = opts.initialContext;
-    const hasInitialContext = opts.contextProvided ??
-        (initialContext !== undefined);
-    const buildAssistantDeckPath = GAMBIT_BOT_SOURCE_DECK_PATH
-        ? resolveDeckPath(GAMBIT_BOT_SOURCE_DECK_PATH)
-        : resolveDeckPath(opts.deckPath);
-    const consoleTracer = opts.verbose ? makeConsoleTracer() : undefined;
-    let resolvedDeckPath = resolveDeckPath(opts.deckPath);
-    const buildBotRootCache = new Map();
-    const activeWorkspaceId = opts.workspace?.id ?? null;
-    const activeWorkspaceOnboarding = Boolean(opts.workspace?.onboarding);
-    const workspaceScaffoldEnabled = Boolean(opts.workspace?.scaffoldEnabled);
-    const workspaceScaffoldRoot = opts.workspace?.scaffoldRoot
-        ? path.resolve(opts.workspace.scaffoldRoot)
-        : null;
-    const sessionsRoot = (() => {
-        const base = opts.sessionDir
-            ? path.resolve(opts.sessionDir)
-            : defaultSessionRoot(resolvedDeckPath);
-        try {
-            dntShim.Deno.mkdirSync(base, { recursive: true });
-        }
-        catch (err) {
-            logger.warn(`[sim] unable to ensure workspace state directory ${base}: ${err instanceof Error ? err.message : err}`);
-        }
-        return base;
-    })();
-    const workspaceRoot = (() => {
-        const dir = workspaceScaffoldRoot ?? sessionsRoot;
-        if (workspaceScaffoldEnabled) {
-            try {
-                dntShim.Deno.mkdirSync(dir, { recursive: true });
-            }
-            catch (err) {
-                logger.warn(`[sim] unable to ensure workspace directory ${dir}: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        return dir;
-    })();
-    const deckSlugFromPath = (p) => {
-        const baseName = path.basename(p || "deck");
-        const withoutExt = baseName.replace(/\.[^.]+$/, "");
-        const slug = withoutExt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-        return slug || "session";
-    };
-    const gambitBotSourceDir = GAMBIT_BOT_SOURCE_DECK_PATH
-        ? path.dirname(GAMBIT_BOT_SOURCE_DECK_PATH)
-        : "";
-    const resolveBuildBotRoot = async (workspaceId) => {
-        const override = dntShim.Deno.env.get("GAMBIT_SIMULATOR_BUILD_BOT_ROOT")?.trim();
-        if (override) {
-            const root = await dntShim.Deno.realPath(override);
-            const info = await dntShim.Deno.stat(root);
-            if (!info.isDirectory) {
-                throw new Error(`Build bot root is not a directory: ${root}`);
-            }
-            assertSafeBuildBotRoot(root, gambitBotSourceDir);
-            await ensureGambitPolicyInBotRoot(root);
-            return root;
-        }
-        const cacheKey = workspaceId ?? "default";
-        const cached = buildBotRootCache.get(cacheKey);
-        if (cached)
-            return cached;
-        const record = resolveWorkspaceRecord(workspaceId ?? "");
-        const candidate = record?.rootDir ?? path.dirname(resolvedDeckPath);
-        const root = await dntShim.Deno.realPath(candidate);
-        const info = await dntShim.Deno.stat(root);
-        if (!info.isDirectory) {
-            throw new Error(`Build bot root is not a directory: ${root}`);
-        }
-        assertSafeBuildBotRoot(root, gambitBotSourceDir);
-        await ensureGambitPolicyInBotRoot(root);
-        buildBotRootCache.set(cacheKey, root);
-        return root;
-    };
-    const logWorkspaceBotRoot = async (endpoint, workspaceId) => {
-        try {
-            const root = await resolveBuildBotRoot(workspaceId);
-            logger.info(`[sim] ${endpoint}: workspaceId=${workspaceId ?? "(none)"} botRoot=${root}`);
-        }
-        catch (err) {
-            logger.warn(`[sim] ${endpoint}: workspaceId=${workspaceId ?? "(none)"} botRoot=<unresolved> ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    const resolveBuildBotPath = async (root, inputPath) => {
-        if (!inputPath || typeof inputPath !== "string") {
-            throw new Error("path is required");
-        }
-        const normalizedInput = path.normalize(inputPath);
-        const segments = normalizedInput.split(/\\|\//g);
-        if (segments.includes("..")) {
-            throw new Error("path traversal is not allowed");
-        }
-        const candidate = path.isAbsolute(normalizedInput)
-            ? normalizedInput
-            : path.resolve(root, normalizedInput);
-        const relativePath = path.relative(root, candidate);
-        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-            throw new Error("path escapes bot root");
-        }
-        const stat = await dntShim.Deno.lstat(candidate);
-        if (stat.isSymlink) {
-            throw new Error("symlinks are not allowed");
-        }
-        const realCandidate = await dntShim.Deno.realPath(candidate);
-        const realRelative = path.relative(root, realCandidate);
-        if (realRelative.startsWith("..") || path.isAbsolute(realRelative)) {
-            throw new Error("path escapes bot root");
-        }
-        return { fullPath: candidate, relativePath, stat };
-    };
-    const readPreviewText = (bytes) => {
-        const limit = Math.min(bytes.length, 8192);
-        for (let i = 0; i < limit; i += 1) {
-            if (bytes[i] === 0)
-                return null;
-        }
-        const decoder = new TextDecoder("utf-8", { fatal: true });
-        try {
-            return decoder.decode(bytes);
-        }
-        catch {
-            return null;
-        }
-    };
-    let deckSlug = deckSlugFromPath(resolvedDeckPath);
-    let deckLabel = undefined;
-    let rootStartMode = undefined;
-    const enrichStateWithSession = (state) => {
-        const meta = { ...(state.meta ?? {}) };
-        const now = new Date();
-        meta.sessionUpdatedAt = now.toISOString();
-        if (typeof meta.sessionId !== "string") {
-            const stamp = now.toISOString().replace(/[:.]/g, "-");
-            meta.sessionId = `${deckSlug}-${stamp}`;
-            meta.sessionCreatedAt = now.toISOString();
-        }
-        if (typeof meta.workspaceId !== "string") {
-            meta.workspaceId = String(meta.sessionId);
-        }
-        if (typeof meta.workspaceSchemaVersion !== "string") {
-            meta.workspaceSchemaVersion = WORKSPACE_STATE_SCHEMA_VERSION;
-        }
-        if (typeof meta.deck !== "string") {
-            meta.deck = resolvedDeckPath;
-        }
-        if (typeof meta.deckSlug !== "string") {
-            meta.deckSlug = deckSlug;
-        }
-        if (typeof meta.sessionDir !== "string") {
-            meta.sessionDir = path.join(sessionsRoot, String(meta.sessionId));
-        }
-        if (typeof meta.sessionStatePath !== "string" &&
-            typeof meta.sessionDir === "string") {
-            meta.sessionStatePath = path.join(meta.sessionDir, "state.json");
-        }
-        if (typeof meta.sessionEventsPath !== "string" &&
-            typeof meta.sessionDir === "string") {
-            meta.sessionEventsPath = path.join(meta.sessionDir, "events.jsonl");
-        }
-        if (typeof meta.sessionBuildStatePath !== "string" &&
-            typeof meta.sessionDir === "string") {
-            meta.sessionBuildStatePath = path.join(meta.sessionDir, "build_state.json");
-        }
-        const dir = typeof meta.sessionDir === "string"
-            ? meta.sessionDir
-            : undefined;
-        return { state: { ...state, meta }, dir };
-    };
-    const { selectCanonicalScenarioRunSummary, appendWorkspaceEnvelope, appendOpenResponsesRunEvent, appendSessionEvent, appendGradingLog, persistSessionState, readSessionStateStrict, readSessionState, readWorkspaceDeckState, readBuildState, listOpenResponsesRunEvents, listOpenResponsesOutputItems, subscribeOpenResponsesRunEvents, writeWorkspaceDeckState, } = createSessionStore({
-        sessionsRoot,
-        randomId,
-        logger,
-        enrichStateWithSession,
-        workspaceStateSchemaVersion: WORKSPACE_STATE_SCHEMA_VERSION,
-        workspaceSchemaError,
-    });
-    const resolvePreferredDeckPath = async (candidate) => {
-        if (path.basename(candidate) === "PROMPT.md")
-            return candidate;
-        const promptPath = path.join(path.dirname(candidate), "PROMPT.md");
-        try {
-            const stat = await dntShim.Deno.stat(promptPath);
-            if (stat.isFile)
-                return promptPath;
-        }
-        catch {
-            // ignore missing PROMPT.md
-        }
-        return candidate;
-    };
-    const createDeckLoadPromise = () => resolvePreferredDeckPath(resolvedDeckPath)
-        .then((preferredPath) => {
-        resolvedDeckPath = preferredPath;
-        return loadDeck(preferredPath);
-    })
-        .then((deck) => {
-        resolvedDeckPath = deck.path;
-        buildBotRootCache.clear();
-        deckSlug = deckSlugFromPath(resolvedDeckPath);
-        rootStartMode = deck.startMode === "assistant" ||
-            deck.startMode === "user"
-            ? deck.startMode
-            : undefined;
-        deckLabel = typeof deck.label === "string"
-            ? deck.label
-            : toDeckLabel(deck.path);
-        const scenarioDecks = (deck.testDecks ?? []).map(toAvailableTestDeck);
-        const graderDecks = (deck.graderDecks ?? []).map(toAvailableGraderDeck);
-        logWorkspaceRefreshDebug("deck.reload.success", {
-            resolvedDeckPath,
-            ...summarizeDeckState({
-                scenarioDecks,
-                graderDecks,
-            }),
-        });
-        return deck;
-    })
-        .catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        logWorkspaceRefreshDebug("deck.reload.failure", {
-            resolvedDeckPath,
-            error: message,
-            missingPath: extractMissingReadfilePath(message),
-        });
-        logger.warn(`[sim] failed to load deck: ${message}`);
-        return null;
-    });
-    const createSchemaPromise = (loadPromise) => loadPromise
-        .then((deck) => {
-        if (!deck) {
-            return { error: "Deck failed to load" };
-        }
-        const desc = describeZodSchema(deck.inputSchema);
-        const tools = mapDeckTools(deck.actionDecks);
-        const next = tools ? { ...desc, tools } : desc;
-        if (hasInitialContext) {
-            return { ...next, defaults: initialContext };
-        }
-        return next;
-    })
-        .catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        logger.warn(`[sim] failed to load deck schema: ${message}`);
-        return { error: message };
-    });
-    let deckLoadPromise = createDeckLoadPromise();
-    let schemaPromise = createSchemaPromise(deckLoadPromise);
-    const reloadPrimaryDeck = () => {
-        deckLoadPromise = createDeckLoadPromise();
-        schemaPromise = createSchemaPromise(deckLoadPromise);
-    };
-    const buildDeckStateForLoadedDeck = (workspaceId, deck) => buildWorkspaceDeckStateFromLoadedDeck({
-        workspaceId,
-        deck,
-        buildPersistedAssistantDeck,
-        describeDeckInputSchemaFromPath: (deckPath) => describeDeckInputSchemaFromPath(deckPath, logger),
-    });
-    const readPrimaryDeckState = async () => {
-        const loadedDeck = await deckLoadPromise.catch(() => null);
-        if (!loadedDeck)
-            return null;
-        return await buildDeckStateForLoadedDeck(activeWorkspaceId ?? "__gambit-primary__", loadedDeck);
-    };
-    const { activateWorkspaceDeck, registerWorkspace, removeWorkspace, resolveWorkspaceRecord, stopAllWorkspaceFsWatchers, summarizeWorkspaceDeckState, } = createWorkspaceRuntime({
-        verbose: opts.verbose ?? false,
-        logger,
-        randomId,
-        resolveDeckPath,
-        readSessionState,
-        readWorkspaceDeckState,
-        writeWorkspaceDeckState,
-        buildWorkspaceDeckStateFromLoadedDeck: (args) => buildDeckStateForLoadedDeck(args.workspaceId, args.deck),
-        reloadPrimaryDeck,
-        getDeckLoadPromise: () => deckLoadPromise,
-        getResolvedDeckPath: () => resolvedDeckPath,
-        setResolvedDeckPath: (nextPath) => {
-            resolvedDeckPath = nextPath;
-        },
-        clearDefaultBuildBotRoot: () => {
-            buildBotRootCache.delete("default");
-        },
-        logWorkspaceRefreshDebug,
-        extractMissingReadfilePath,
-        emitWorkspaceGraphRefresh: (args) => {
-            appendDurableStreamEvent(WORKSPACE_STREAM_ID, {
-                type: "workspaceGraphRefresh",
-                workspaceId: args.workspaceId,
-                reason: args.reason,
-                paths: args.paths,
-                kinds: args.kinds,
-            });
-        },
-    });
-    const readWorkspaceDeckStateStrict = (workspaceId) => {
-        const deckState = readWorkspaceDeckState(workspaceId);
-        if (deckState)
-            return deckState;
-        throw new Error(`Workspace ${workspaceId} deck state is unavailable`);
-    };
-    const workspaceDeckGraphqlOperations = createWorkspaceDeckGraphqlOperations({
-        activateWorkspaceDeck,
-        readWorkspaceDeckState,
-        getResolvedDeckPath: () => resolvedDeckPath,
-        summarizeWorkspaceDeckState,
-        logWorkspaceRefreshDebug,
-    });
-    if (opts.workspace?.id && opts.workspace.rootDir && opts.workspace.rootDeckPath) {
-        registerWorkspace({
-            id: opts.workspace.id,
-            rootDir: opts.workspace.rootDir,
-            rootDeckPath: opts.workspace.rootDeckPath,
-            createdAt: new Date().toISOString(),
-        });
-    }
-    const sessionService = createWorkspaceSessionService({
-        sessionsRoot,
-        workspaceRoot,
-        workspaceScaffoldEnabled,
-        activeWorkspaceOnboarding,
-        workspaceStateSchemaVersion: WORKSPACE_STATE_SCHEMA_VERSION,
-        getResolvedDeckPath: () => resolvedDeckPath,
-        deckSlugFromPath,
-        randomId,
-        registerWorkspace,
-        resolveWorkspaceRecord,
-        readSessionState,
-        persistSessionState,
-    });
-    sessionService.ensurePreconfiguredWorkspaceSession(opts.workspace);
-    const openResponsesEventPersistence = createOpenResponsesEventPersistence({
-        sanitizeJsonRecord,
-        appendOpenResponsesRunEvent,
-    });
-    const readCodexWorkspaceStatus = createReadCodexWorkspaceStatus({
-        resolveBuildBotRoot,
-        resolveWorkspaceDeckPath: (workspaceId) => {
-            const record = workspaceId
-                ? resolveWorkspaceRecord(workspaceId)
-                : undefined;
-            return record?.rootDeckPath ?? resolvedDeckPath;
-        },
-    });
-    const wantsSourceMap = Boolean(opts.sourceMap);
-    const bundlePlatform = opts.bundlePlatform ?? "deno";
-    const autoBundle = opts.autoBundle ?? true;
-    const forceBundle = opts.forceBundle ?? false;
-    ensureSimulatorBundle({
-        autoBundle,
-        bundlePlatform,
-        forceBundle,
-        logger,
-        verbose: opts.verbose,
-        wantsSourceMap,
-    });
-    const buildService = createWorkspaceBuildService({
-        buildAssistantDeckPath,
-        initialContext,
-        hasInitialContext,
-        modelProvider: opts.modelProvider,
-        model: opts.model,
-        modelForce: opts.modelForce,
-        responsesMode: opts.responsesMode,
-        workerSandbox: opts.workerSandbox,
-        randomId,
-        readSessionState,
-        readSessionStateStrict,
-        readBuildState,
-        appendWorkspaceEnvelope,
-        appendDurableStreamEvent,
-        workspaceStreamId: WORKSPACE_STREAM_ID,
-        persistCanonicalUserInputEvent: openResponsesEventPersistence.persistCanonicalUserInputEvent,
-        persistOpenResponsesTracesFromState: openResponsesEventPersistence.persistOpenResponsesTracesFromState,
-        persistOpenResponsesTraceEvent: openResponsesEventPersistence.persistOpenResponsesTraceEvent,
-    });
-    const scenarioService = createWorkspaceScenarioService({
-        modelProvider: opts.modelProvider,
-        model: opts.model,
-        modelForce: opts.modelForce,
-        responsesMode: opts.responsesMode,
-        workerSandbox: opts.workerSandbox,
-        consoleTracer,
-        logger,
-        randomId,
-        getResolvedDeckPath: () => resolvedDeckPath,
-        getRootStartMode: () => rootStartMode,
-        getSchemaPromise: () => schemaPromise,
-        buildWorkspaceMeta: sessionService.buildWorkspaceMeta,
-        selectCanonicalScenarioRunSummary,
-        persistSessionState,
-        appendSessionEvent,
-        appendWorkspaceEnvelope: (state, _domain, payload) => {
-            appendWorkspaceEnvelope(state, "test", payload);
-        },
-        appendDurableStreamEvent,
-        workspaceStreamId: WORKSPACE_STREAM_ID,
-        testStreamId: TEST_STREAM_ID,
-        persistOpenResponsesTraceEvent: openResponsesEventPersistence.persistOpenResponsesTraceEvent,
-        persistCanonicalUserInputEvent: openResponsesEventPersistence.persistCanonicalUserInputEvent,
-        persistCanonicalStateMessages: openResponsesEventPersistence.persistCanonicalStateMessages,
-        readSessionState,
-        readSessionStateStrict,
-        activateWorkspaceDeck,
-        resolveWorkspaceRecord,
-        readWorkspaceDeckStateStrict,
-        buildRootScenarioFallback,
-        resolveScenarioDeckFromState,
-    });
-    const readModelService = createWorkspaceReadModelService({
-        readSessionState,
-        readSessionStateStrict,
-        readWorkspaceBuildRunForGraphql: buildService.readWorkspaceBuildRunForGraphql,
-        getLiveTestRunEntry: scenarioService.getLiveTestRunEntry,
-        getLiveTestRunEntryByWorkspaceId: scenarioService.getLiveTestRunEntryByWorkspaceId,
-        readPersistedTestRunStatusById: scenarioService.readPersistedTestRunStatusById,
-        syncTestBotRunFromState: scenarioService.syncTestBotRunFromState,
-        selectCanonicalScenarioRunSummary,
-        activateWorkspaceDeck,
-        readWorkspaceDeckState,
-        resolveScenarioDeckFromState,
-        listSessions: sessionService.listSessions,
-    });
-    const gradingService = createWorkspaceGradingService({
-        randomId,
-        modelProvider: opts.modelProvider,
-        responsesMode: opts.responsesMode,
-        workerSandbox: opts.workerSandbox,
-        appendDurableStreamEvent,
-        workspaceStreamId: WORKSPACE_STREAM_ID,
-        activateWorkspaceDeck,
-        readWorkspaceDeckStateStrict,
-        resolveGraderDeckFromState,
-        readSessionState,
-        readSessionStateStrict,
-        persistSessionState,
-        appendGradingLog,
-        readWorkspaceScenarioRunsForGraphql: scenarioService.readWorkspaceScenarioRunsForGraphql,
-    });
-    const verifyService = createWorkspaceVerifyService({
-        randomId,
-        verifyScenarioRunsMax: VERIFY_SCENARIO_RUNS_MAX,
-        verifyGraderRepeatsMax: VERIFY_GRADER_REPEATS_MAX,
-        verifyBatchConcurrencyMax: VERIFY_BATCH_CONCURRENCY_MAX,
-        defaultVerifyScenarioRuns: DEFAULT_VERIFY_SCENARIO_RUNS,
-        defaultVerifyGraderRepeats: DEFAULT_VERIFY_GRADER_REPEATS,
-        defaultVerifyConcurrency: DEFAULT_VERIFY_CONCURRENCY,
-        appendDurableStreamEvent,
-        workspaceStreamId: WORKSPACE_STREAM_ID,
-        activateWorkspaceDeck,
-        readWorkspaceDeckStateStrict,
-        resolveGraderDeckFromState,
-        readSessionState,
-        readSessionStateStrict,
-        persistSessionState,
-        appendGradingLog,
-        startWorkspaceScenarioRunForGraphql: scenarioService.startWorkspaceScenarioRunForGraphql,
-        readWorkspaceScenarioRunsForGraphql: scenarioService.readWorkspaceScenarioRunsForGraphql,
-        getLiveTestRunEntry: scenarioService.getLiveTestRunEntry,
-        createWorkspaceGradeRunForGraphql: gradingService.createWorkspaceGradeRunForGraphql,
-    });
-    const conversationSessions = createWorkspaceConversationSessionService({
-        readWorkspaceBuildRunForGraphql: buildService.readWorkspaceBuildRunForGraphql,
-        startWorkspaceBuildRun: buildService.startWorkspaceBuildRun,
-        stopWorkspaceBuildRun: buildService.stopWorkspaceBuildRun,
-        startWorkspaceScenarioRunForGraphql: scenarioService.startWorkspaceScenarioRunForGraphql,
-        sendWorkspaceScenarioRunForGraphql: scenarioService.sendWorkspaceScenarioRunForGraphql,
-        stopWorkspaceScenarioRunForGraphql: scenarioService.stopWorkspaceScenarioRunForGraphql,
-        readWorkspaceScenarioRunsForGraphql: scenarioService.readWorkspaceScenarioRunsForGraphql,
-        readWorkspaceGradeRunsForGraphql: gradingService.readWorkspaceGradeRunsForGraphql,
-        createWorkspaceGradeRunForGraphql: gradingService.createWorkspaceGradeRunForGraphql,
-        readWorkspaceVerifyBatchesForGraphql: verifyService.readWorkspaceVerifyBatchesForGraphql,
-        createWorkspaceVerifyBatchRunForGraphql: verifyService.createWorkspaceVerifyBatchRunForGraphql,
-        defaultVerifyScenarioRuns: DEFAULT_VERIFY_SCENARIO_RUNS,
-        defaultVerifyGraderRepeats: DEFAULT_VERIFY_GRADER_REPEATS,
-        defaultVerifyConcurrency: DEFAULT_VERIFY_CONCURRENCY,
-    });
-    const handler = createSimulatorRequestHandler({
-        modelProvider: opts.modelProvider,
-        activeWorkspaceId,
-        activeWorkspaceOnboarding,
-        workspaceApiBase: WORKSPACE_API_BASE,
-        workspacesApiBase: WORKSPACES_API_BASE,
-        workspaceStateSchemaVersion: WORKSPACE_STATE_SCHEMA_VERSION,
-        maxFilePreviewBytes: 250_000,
-        workspaceRouteBase: WORKSPACE_ROUTE_BASE,
-        getResolvedDeckPath: () => resolvedDeckPath,
-        getDeckLabel: () => deckLabel,
-        safeJsonStringify,
-        getWorkspaceIdFromQuery: sessionService.getWorkspaceIdFromQuery,
-        getWorkspaceIdFromBody: sessionService.getWorkspaceIdFromBody,
-        buildWorkspaceReadModel: readModelService.buildWorkspaceReadModel,
-        listSessions: sessionService.listSessions,
-        createWorkspaceSession: sessionService.createWorkspaceSession,
-        ensureWorkspaceSession: sessionService.ensureWorkspaceSession,
-        deleteSessionState: sessionService.deleteSessionState,
-        deleteWorkspaceRuntime: (workspaceId) => {
-            removeWorkspace(workspaceId);
-        },
-        logWorkspaceBotRoot,
-        activateWorkspaceDeck,
-        readPrimaryDeckState,
-        readWorkspaceDeckStateStrict,
-        resolveScenarioDeckFromState,
-        readSessionState,
-        readSessionStateStrict,
-        persistSessionState,
-        appendSessionEvent,
-        isFeedbackEligibleMessageRef: scenarioService.isFeedbackEligibleMessageRef,
-        isFeedbackEligiblePersistedTestRunMessageRef: scenarioService.isFeedbackEligiblePersistedTestRunMessageRef,
-        randomId,
-        syncTestBotRunFromState: scenarioService.syncTestBotRunFromState,
-        broadcastTestBot: scenarioService.broadcastTestBot,
-        getLiveTestRunEntry: scenarioService.getLiveTestRunEntry,
-        startWorkspaceScenarioRunForGraphql: scenarioService.startWorkspaceScenarioRunForGraphql,
-        sendWorkspaceScenarioRunForGraphql: scenarioService.sendWorkspaceScenarioRunForGraphql,
-        saveWorkspaceFeedbackForGraphql: async (args) => await scenarioService.saveWorkspaceFeedbackForGraphql(args),
-        stopWorkspaceScenarioRunForGraphql: scenarioService.stopWorkspaceScenarioRunForGraphql,
-        readWorkspaceScenarioRunsForGraphql: scenarioService.readWorkspaceScenarioRunsForGraphql,
-        handleBuildProviderStatusRequest: (args) => handleBuildProviderStatusRequest({
-            ...args,
-            readCodexWorkspaceStatus,
-        }),
-        readCodexWorkspaceStatus,
-        normalizeBuildChatProvider,
-        persistBuildChatProviderMeta,
-        startWorkspaceBuildRun: buildService.startWorkspaceBuildRun,
-        stopWorkspaceBuildRun: buildService.stopWorkspaceBuildRun,
-        resetWorkspaceBuild: buildService.resetWorkspaceBuild,
-        readWorkspaceBuildRunForGraphql: buildService.readWorkspaceBuildRunForGraphql,
-        getLiveBuildRunEntry: buildService.getLiveBuildRunEntry,
-        resolveBuildBotRoot,
-        resolveBuildBotPath,
-        readPreviewText,
-        schemaPromise: () => schemaPromise,
-        deckLoadPromise: () => deckLoadPromise,
-        readWorkspaceOpenResponseEvents: listOpenResponsesRunEvents,
-        readWorkspaceOpenResponseOutputItems: listOpenResponsesOutputItems,
-        subscribeWorkspaceOpenResponseEvents: subscribeOpenResponsesRunEvents,
-        readWorkspaceGradeRunsForGraphql: gradingService.readWorkspaceGradeRunsForGraphql,
-        readWorkspaceGradingFlagsForGraphql: gradingService.readWorkspaceGradingFlagsForGraphql,
-        createWorkspaceGradeRunForGraphql: gradingService.createWorkspaceGradeRunForGraphql,
-        toggleWorkspaceGradeFlagForGraphql: gradingService.toggleWorkspaceGradeFlagForGraphql,
-        updateWorkspaceGradeFlagReasonForGraphql: gradingService.updateWorkspaceGradeFlagReasonForGraphql,
-        readWorkspaceVerifyBatchesForGraphql: verifyService.readWorkspaceVerifyBatchesForGraphql,
-        createWorkspaceVerifyBatchRunForGraphql: verifyService.createWorkspaceVerifyBatchRunForGraphql,
-        listWorkspaceConversationSessionsForGraphql: conversationSessions.listWorkspaceConversationSessionsForGraphql,
-        readWorkspaceConversationSessionForGraphql: conversationSessions.readWorkspaceConversationSessionForGraphql,
-        startWorkspaceConversationSessionForGraphql: conversationSessions.startWorkspaceConversationSessionForGraphql,
-        sendWorkspaceConversationSessionForGraphql: conversationSessions.sendWorkspaceConversationSessionForGraphql,
-        stopWorkspaceConversationSessionForGraphql: conversationSessions.stopWorkspaceConversationSessionForGraphql,
-        workspaceDeckGraphqlOperations,
-        toDeckLabel,
-    });
-    const server = dntShim.Deno.serve({ port, signal: opts.signal, onListen: () => { } }, handler);
-    const listenPort = server.addr.port;
-    logger.log(`Simulator listening on http://localhost:${listenPort} (deck=${resolvedDeckPath})`);
-    server.finished.finally(() => {
-        stopAllWorkspaceFsWatchers();
-    });
-    return server;
-}

package/esm/src/server_build_chat_provider.d.ts

@@ -1,26 +0,0 @@
-import type { SavedState } from "@bolt-foundry/gambit-core";
-import { type CheckReport } from "./commands/check.js";
-export type BuildChatProvider = "codex-cli" | "claude-code-cli";
-export declare function normalizeBuildChatProvider(value: unknown): BuildChatProvider | null;
-export declare function persistBuildChatProviderMeta(state: SavedState, workspaceId: string, provider: BuildChatProvider): SavedState;
-type CodexStatusResult = {
-    trustedPath: string;
-    writeEnabled: boolean;
-    codexLoggedIn: boolean;
-    codexLoginStatus: string;
-    check?: CheckReport;
-};
-export declare function createReadCodexWorkspaceStatus(input: {
-    resolveBuildBotRoot: (workspaceId?: string | null) => Promise<string>;
-    resolveWorkspaceDeckPath: (workspaceId?: string | null) => string;
-}): (workspaceId?: string | null, online?: boolean) => Promise<CodexStatusResult>;
-export declare function handleBuildProviderStatusRequest(input: {
-    req: Request;
-    url: URL;
-    isLegacyCodexTrustEndpoint: boolean;
-    getWorkspaceIdFromQuery: (url: URL) => string | undefined;
-    logWorkspaceBotRoot: (endpoint: string, workspaceId?: string | null) => Promise<void>;
-    readCodexWorkspaceStatus: (workspaceId?: string | null, online?: boolean) => Promise<CodexStatusResult>;
-}): Promise<Response>;
-export {};
-//# sourceMappingURL=server_build_chat_provider.d.ts.map

package/esm/src/server_build_chat_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server_build_chat_provider.d.ts","sourceRoot":"","sources":["../../src/src/server_build_chat_provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,KAAK,WAAW,EAAsB,MAAM,qBAAqB,CAAC;AAG3E,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,iBAAiB,CAAC;AAEhE,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,IAAI,CAI1B;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,iBAAiB,GAC1B,UAAU,CASZ;AAED,KAAK,iBAAiB,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,mBAAmB,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtE,wBAAwB,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;CACnE,GAAG,CACF,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,EAC3B,MAAM,CAAC,EAAE,OAAO,KACb,OAAO,CAAC,iBAAiB,CAAC,CAuB9B;AAED,wBAAsB,gCAAgC,CAAC,KAAK,EAAE;IAC5D,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,0BAA0B,EAAE,OAAO,CAAC;IACpC,uBAAuB,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,SAAS,CAAC;IAC1D,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,KACxB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,wBAAwB,EAAE,CACxB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,EAC3B,MAAM,CAAC,EAAE,OAAO,KACb,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACjC,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2GpB"}