@bolt-foundry/gambit 0.8.6-rc.2 → 0.8.6-rc.4

package/esm/src/server/request_handler.js

@@ -0,0 +1,416 @@
+import * as dntShim from "../../_dnt.shims.js";
+import * as path from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { asGambitID } from "../gambit_id.js";
+import { asGambitWorkspaceRelativePath, } from "../gambit_path.js";
+import { asGambitISODateTime } from "../gambit_time.js";
+import { handleLegacyApiRoutes } from "../server_legacy_api_routes.js";
+import { handleGraphqlStreamMultiplexRequest } from "../graphql_stream_multiplex.js";
+import { handleGraphqlSubscriptionStreamRequest } from "../graphql_subscription_stream.js";
+import { GRAPHQL_STREAMS_PREFIX, handleDurableStreamRequest, } from "../durable_streams.js";
+import { gambitYoga } from "../simulator_graphql.js";
+import { handleOpenResponsesRequest } from "../server_openresponses.js";
+import { canServeReactBundle, handleSimulatorFaviconRequest, handleSimulatorPathRedirect, readReactBundle, readReactBundleSourceMap, shouldAdvertiseSourceMap, simulatorReactHtml, } from "../server_simulator_ui.js";
+import { handleUiRoutes } from "../server_ui_routes.js";
+export const createSimulatorRequestHandler = (deps) => async (req) => {
+    const url = new URL(req.url);
+    const asScenarioRunRecord = (workspaceId, run) => ({
+        ...run,
+        workspaceId,
+    });
+    const asConversationSessionRecord = (workspaceId, session) => ({
+        ...session,
+        workspaceId,
+        scenarioRun: session.scenarioRun
+            ? asScenarioRunRecord(workspaceId, session.scenarioRun)
+            : undefined,
+    });
+    const readWorkspaceFiles = async (args) => {
+        const root = await deps.resolveBuildBotRoot(args.workspaceId);
+        const fileId = typeof args.id === "string" ? args.id.trim() : "";
+        const pathPrefix = typeof args.pathPrefix === "string"
+            ? args.pathPrefix.trim()
+            : "";
+        const normalizeRelativePath = (value) => value.split(/\\|\//g).filter(Boolean).join("/");
+        const isInternalWorkspacePath = (value) => {
+            const normalized = normalizeRelativePath(value);
+            return normalized === ".gambit" ||
+                normalized.startsWith(".gambit/");
+        };
+        const readTextContent = async (fullPath) => {
+            try {
+                return await dntShim.Deno.readTextFile(fullPath);
+            }
+            catch {
+                return null;
+            }
+        };
+        const toRecord = async (fullPath, relPath, stat) => {
+            const normalizedPath = normalizeRelativePath(relPath);
+            return {
+                id: asGambitID(`workspace-file:${args.workspaceId}:${normalizedPath}`),
+                path: asGambitWorkspaceRelativePath(normalizedPath),
+                size: typeof stat.size === "number" ? stat.size : null,
+                modifiedAt: stat.mtime
+                    ? asGambitISODateTime(stat.mtime.toISOString())
+                    : null,
+                content: await readTextContent(fullPath),
+            };
+        };
+        if (fileId.length > 0) {
+            try {
+                const idPrefix = `workspace-file:${args.workspaceId}:`;
+                if (!fileId.startsWith(idPrefix))
+                    return [];
+                const idPath = fileId.slice(idPrefix.length);
+                if (idPath.length === 0)
+                    return [];
+                const resolved = await deps.resolveBuildBotPath(root, idPath);
+                if (!resolved.stat.isFile)
+                    return [];
+                if (isInternalWorkspacePath(resolved.relativePath))
+                    return [];
+                return [
+                    await toRecord(resolved.fullPath, resolved.relativePath, resolved.stat),
+                ];
+            }
+            catch {
+                return [];
+            }
+        }
+        const records = [];
+        const pending = [root];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (!current)
+                continue;
+            for await (const entry of dntShim.Deno.readDir(current)) {
+                const fullPath = path.join(current, entry.name);
+                let stat;
+                try {
+                    stat = await dntShim.Deno.lstat(fullPath);
+                }
+                catch {
+                    continue;
+                }
+                if (stat.isSymlink)
+                    continue;
+                if (stat.isDirectory) {
+                    pending.push(fullPath);
+                    continue;
+                }
+                if (!stat.isFile)
+                    continue;
+                const relativePath = normalizeRelativePath(path.relative(root, fullPath));
+                if (relativePath.length === 0)
+                    continue;
+                if (isInternalWorkspacePath(relativePath))
+                    continue;
+                if (pathPrefix.length > 0 &&
+                    !relativePath.startsWith(normalizeRelativePath(pathPrefix))) {
+                    continue;
+                }
+                records.push(await toRecord(fullPath, relativePath, stat));
+            }
+        }
+        records.sort((a, b) => a.path.localeCompare(b.path));
+        return records;
+    };
+    if (url.pathname === deps.workspacesApiBase) {
+        if (req.method !== "GET") {
+            return new Response("Method not allowed", { status: 405 });
+        }
+        return new Response(JSON.stringify({ workspaces: deps.listSessions() }), {
+            headers: { "content-type": "application/json" },
+        });
+    }
+    const workspaceTestRunGetMatch = url.pathname.match(new RegExp(`^${deps.workspacesApiBase}/([^/]+)/test/([^/]+)$`));
+    if (workspaceTestRunGetMatch) {
+        if (req.method !== "GET") {
+            return new Response("Method not allowed", { status: 405 });
+        }
+        try {
+            const workspaceId = decodeURIComponent(workspaceTestRunGetMatch[1]);
+            const requestedTestRunId = decodeURIComponent(workspaceTestRunGetMatch[2]);
+            await deps.logWorkspaceBotRoot(`${deps.workspacesApiBase}/:id/test/:runId`, workspaceId);
+            await deps.activateWorkspaceDeck(workspaceId);
+            const payload = await deps.buildWorkspaceReadModel(workspaceId, {
+                requestedTestDeckPath: url.searchParams.get("deckPath"),
+                requestedTestRunId,
+            });
+            if ("error" in payload) {
+                const record = payload;
+                return new Response(JSON.stringify({ error: record.error }), {
+                    status: record.status,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            return new Response(deps.safeJsonStringify(payload), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return new Response(JSON.stringify({ error: message }), {
+                status: 400,
+                headers: { "content-type": "application/json" },
+            });
+        }
+    }
+    const workspaceGradeRunGetMatch = url.pathname.match(new RegExp(`^${deps.workspacesApiBase}/([^/]+)/grade/([^/]+)$`));
+    if (workspaceGradeRunGetMatch) {
+        if (req.method !== "GET") {
+            return new Response("Method not allowed", { status: 405 });
+        }
+        try {
+            const workspaceId = decodeURIComponent(workspaceGradeRunGetMatch[1]);
+            const requestedGradeRunId = decodeURIComponent(workspaceGradeRunGetMatch[2]);
+            await deps.logWorkspaceBotRoot(`${deps.workspacesApiBase}/:id/grade/:runId`, workspaceId);
+            await deps.activateWorkspaceDeck(workspaceId);
+            const payload = await deps.buildWorkspaceReadModel(workspaceId, {
+                requestedTestDeckPath: url.searchParams.get("deckPath"),
+                requestedGradeRunId,
+            });
+            if ("error" in payload) {
+                const record = payload;
+                return new Response(JSON.stringify({ error: record.error }), {
+                    status: record.status,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            return new Response(deps.safeJsonStringify(payload), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return new Response(JSON.stringify({ error: message }), {
+                status: 400,
+                headers: { "content-type": "application/json" },
+            });
+        }
+    }
+    const workspaceGetMatch = url.pathname.match(new RegExp(`^${deps.workspacesApiBase}/([^/]+)$`));
+    if (workspaceGetMatch) {
+        if (req.method !== "GET") {
+            return new Response("Method not allowed", { status: 405 });
+        }
+        try {
+            const workspaceId = decodeURIComponent(workspaceGetMatch[1]);
+            await deps.logWorkspaceBotRoot(`${deps.workspacesApiBase}/:id`, workspaceId);
+            await deps.activateWorkspaceDeck(workspaceId);
+            const payload = await deps.buildWorkspaceReadModel(workspaceId, {
+                requestedTestDeckPath: url.searchParams.get("deckPath"),
+            });
+            if ("error" in payload) {
+                const record = payload;
+                return new Response(JSON.stringify({ error: record.error }), {
+                    status: record.status,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            return new Response(deps.safeJsonStringify(payload), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return new Response(JSON.stringify({ error: message }), {
+                status: 400,
+                headers: { "content-type": "application/json" },
+            });
+        }
+    }
+    const legacyApiResponse = await handleLegacyApiRoutes({
+        req,
+        url,
+        activeWorkspaceId: deps.activeWorkspaceId,
+        workspaceApiBase: deps.workspaceApiBase,
+        workspaceStateSchemaVersion: deps.workspaceStateSchemaVersion,
+        maxFilePreviewBytes: deps.maxFilePreviewBytes,
+        getWorkspaceIdFromQuery: deps.getWorkspaceIdFromQuery,
+        getWorkspaceIdFromBody: deps.getWorkspaceIdFromBody,
+        createWorkspaceSession: deps.createWorkspaceSession,
+        ensureWorkspaceSession: deps.ensureWorkspaceSession,
+        deleteSessionState: deps.deleteSessionState,
+        deleteWorkspaceRuntime: deps.deleteWorkspaceRuntime,
+        logWorkspaceBotRoot: deps.logWorkspaceBotRoot,
+        activateWorkspaceDeck: deps.activateWorkspaceDeck,
+        readPrimaryDeckState: deps.readPrimaryDeckState,
+        readWorkspaceDeckStateStrict: deps.readWorkspaceDeckStateStrict,
+        resolveScenarioDeckFromState: deps.resolveScenarioDeckFromState,
+        readSessionState: deps.readSessionState,
+        readSessionStateStrict: deps.readSessionStateStrict,
+        persistSessionState: deps.persistSessionState,
+        appendSessionEvent: deps.appendSessionEvent,
+        isFeedbackEligibleMessageRef: deps.isFeedbackEligibleMessageRef,
+        isFeedbackEligiblePersistedTestRunMessageRef: deps.isFeedbackEligiblePersistedTestRunMessageRef,
+        randomId: deps.randomId,
+        syncTestBotRunFromState: (run, state) => {
+            deps.syncTestBotRunFromState(run, state);
+        },
+        broadcastTestBot: (payload, workspaceId) => {
+            deps.broadcastTestBot(payload, workspaceId);
+        },
+        getLiveTestRunEntry: deps.getLiveTestRunEntry,
+        startWorkspaceScenarioRunForGraphql: deps.startWorkspaceScenarioRunForGraphql,
+        sendWorkspaceScenarioRunForGraphql: deps.sendWorkspaceScenarioRunForGraphql,
+        stopWorkspaceScenarioRunForGraphql: deps.stopWorkspaceScenarioRunForGraphql,
+        readWorkspaceScenarioRunsForGraphql: deps.readWorkspaceScenarioRunsForGraphql,
+        handleBuildProviderStatusRequest: deps.handleBuildProviderStatusRequest,
+        readCodexWorkspaceStatus: deps.readCodexWorkspaceStatus,
+        normalizeBuildChatProvider: deps.normalizeBuildChatProvider,
+        persistBuildChatProviderMeta: deps.persistBuildChatProviderMeta,
+        startWorkspaceBuildRun: deps.startWorkspaceBuildRun,
+        stopWorkspaceBuildRun: deps.stopWorkspaceBuildRun,
+        resetWorkspaceBuild: deps.resetWorkspaceBuild,
+        readWorkspaceBuildRunForGraphql: deps.readWorkspaceBuildRunForGraphql,
+        getLiveBuildRunEntry: deps.getLiveBuildRunEntry,
+        readWorkspaceFiles,
+        resolveBuildBotRoot: deps.resolveBuildBotRoot,
+        resolveBuildBotPath: deps.resolveBuildBotPath,
+        readPreviewText: deps.readPreviewText,
+    });
+    if (legacyApiResponse)
+        return legacyApiResponse;
+    if (url.pathname === "/graphql/streams") {
+        return handleGraphqlStreamMultiplexRequest(req);
+    }
+    if (url.pathname.startsWith(GRAPHQL_STREAMS_PREFIX)) {
+        return handleDurableStreamRequest(req);
+    }
+    const simulatorGraphqlOperations = {
+        listWorkspaces: () => Promise.resolve(deps.listSessions()),
+        createWorkspace: async () => {
+            const created = await deps.createWorkspaceSession();
+            return { workspaceId: created.id };
+        },
+        deleteWorkspace: (workspaceId) => {
+            const deleted = deps.deleteSessionState(workspaceId);
+            if (deleted) {
+                deps.deleteWorkspaceRuntime(workspaceId);
+            }
+            return Promise.resolve({ ok: deleted });
+        },
+        readWorkspaceBuildRun: (workspaceId) => Promise.resolve(deps.readWorkspaceBuildRunForGraphql(workspaceId)),
+        readWorkspaceOpenResponseEvents: (args) => Promise.resolve(deps.readWorkspaceOpenResponseEvents({
+            workspaceId: args.workspaceId,
+            runId: args.runId,
+            fromSequence: args.fromSequence,
+        })),
+        readWorkspaceOpenResponseOutputItems: (args) => Promise.resolve(deps.readWorkspaceOpenResponseOutputItems({
+            workspaceId: args.workspaceId,
+            runId: args.runId,
+        })),
+        subscribeWorkspaceOpenResponseEvents: (args) => deps.subscribeWorkspaceOpenResponseEvents({
+            workspaceId: args.workspaceId,
+            runId: args.runId,
+            fromSequence: args.fromSequence,
+            signal: args.signal,
+        }),
+        createWorkspaceBuildRun: async (workspaceId, message) => await deps.startWorkspaceBuildRun({ workspaceId, message }),
+        stopWorkspaceBuildRun: async (workspaceId, runId) => await deps.stopWorkspaceBuildRun({ workspaceId, runId }),
+        resetWorkspaceBuild: async (workspaceId) => await deps.resetWorkspaceBuild(workspaceId),
+        createWorkspaceScenarioRun: async (args) => asScenarioRunRecord(args.workspaceId, await deps.startWorkspaceScenarioRunForGraphql(args)),
+        sendWorkspaceScenarioRun: async (args) => asScenarioRunRecord(args.workspaceId, await deps.sendWorkspaceScenarioRunForGraphql(args)),
+        saveWorkspaceFeedback: async (args) => {
+            const result = await deps.saveWorkspaceFeedbackForGraphql(args);
+            return {
+                feedback: result.feedback,
+                deleted: result.deleted,
+                run: asScenarioRunRecord(args.workspaceId, result.run),
+            };
+        },
+        stopWorkspaceScenarioRun: async (args) => asScenarioRunRecord(args.workspaceId, await deps.stopWorkspaceScenarioRunForGraphql(args)),
+        readWorkspaceScenarioRuns: async (workspaceId) => (await deps.readWorkspaceScenarioRunsForGraphql(workspaceId)).map((run) => asScenarioRunRecord(workspaceId, run)),
+        readWorkspaceModelStatus: async (args) => {
+            if (args.model !== "codex") {
+                return {
+                    model: args.model,
+                    workspaceId: args.workspaceId,
+                    available: false,
+                    requiresLogin: false,
+                    loggedIn: false,
+                    statusText: "Model status is unavailable.",
+                    writeEnabled: false,
+                };
+            }
+            const status = await deps.readCodexWorkspaceStatus(args.workspaceId, args.checkOnline);
+            const statusRecord = status;
+            return {
+                model: "codex",
+                workspaceId: args.workspaceId,
+                available: statusRecord.writeEnabled && statusRecord.codexLoggedIn,
+                requiresLogin: !statusRecord.codexLoggedIn,
+                loggedIn: statusRecord.codexLoggedIn,
+                statusText: statusRecord.codexLoginStatus,
+                trustedPath: typeof statusRecord.trustedPath === "string"
+                    ? statusRecord.trustedPath
+                    : undefined,
+                writeEnabled: statusRecord.writeEnabled,
+            };
+        },
+        readWorkspaceGradeRuns: async (workspaceId) => await deps.readWorkspaceGradeRunsForGraphql(workspaceId),
+        readWorkspaceGradingFlags: async (workspaceId) => await deps.readWorkspaceGradingFlagsForGraphql(workspaceId),
+        createWorkspaceGradeRun: async (args) => await deps.createWorkspaceGradeRunForGraphql(args),
+        toggleWorkspaceGradeFlag: async (args) => await deps.toggleWorkspaceGradeFlagForGraphql(args),
+        updateWorkspaceGradeFlagReason: async (args) => await deps.updateWorkspaceGradeFlagReasonForGraphql(args),
+        readWorkspaceVerifyBatches: async (workspaceId) => await deps.readWorkspaceVerifyBatchesForGraphql(workspaceId),
+        createWorkspaceVerifyBatchRun: async (args) => await deps.createWorkspaceVerifyBatchRunForGraphql(args),
+        listWorkspaceConversationSessions: async (args) => (await deps.listWorkspaceConversationSessionsForGraphql(args)).map((session) => asConversationSessionRecord(args.workspaceId, session)),
+        readWorkspaceConversationSession: async (args) => {
+            const session = await deps.readWorkspaceConversationSessionForGraphql(args);
+            return session
+                ? asConversationSessionRecord(args.workspaceId, session)
+                : null;
+        },
+        startWorkspaceConversationSession: async (args) => asConversationSessionRecord(args.workspaceId, await deps.startWorkspaceConversationSessionForGraphql(args)),
+        sendWorkspaceConversationSession: async (args) => asConversationSessionRecord(args.workspaceId, await deps.sendWorkspaceConversationSessionForGraphql(args)),
+        stopWorkspaceConversationSession: async (args) => asConversationSessionRecord(args.workspaceId, await deps.stopWorkspaceConversationSessionForGraphql(args)),
+        ...deps.workspaceDeckGraphqlOperations,
+    };
+    if (url.pathname === "/graphql/stream") {
+        return await handleGraphqlSubscriptionStreamRequest(req, {
+            readWorkspaceFiles,
+            ...simulatorGraphqlOperations,
+        });
+    }
+    if (url.pathname === "/graphql") {
+        return await gambitYoga.fetch(req, {
+            readWorkspaceFiles,
+            ...simulatorGraphqlOperations,
+        });
+    }
+    const openResponsesResponse = await handleOpenResponsesRequest({
+        req,
+        modelProvider: deps.modelProvider,
+    });
+    if (openResponsesResponse)
+        return openResponsesResponse;
+    const faviconResponse = await handleSimulatorFaviconRequest(req);
+    if (faviconResponse)
+        return faviconResponse;
+    const pathRedirectResponse = handleSimulatorPathRedirect(url.pathname);
+    if (pathRedirectResponse)
+        return pathRedirectResponse;
+    const uiRoutesResponse = await handleUiRoutes({
+        url,
+        workspaceRouteBase: deps.workspaceRouteBase,
+        activeWorkspaceId: deps.activeWorkspaceId,
+        activeWorkspaceOnboarding: deps.activeWorkspaceOnboarding,
+        resolvedDeckPath: deps.getResolvedDeckPath(),
+        deckLabel: deps.getDeckLabel(),
+        getWorkspaceIdFromQuery: deps.getWorkspaceIdFromQuery,
+        activateWorkspaceDeck: deps.activateWorkspaceDeck,
+        schemaPromise: deps.schemaPromise(),
+        deckLoadPromise: deps.deckLoadPromise(),
+        canServeReactBundle,
+        simulatorReactHtml,
+        toDeckLabel: deps.toDeckLabel,
+        readReactBundle,
+        shouldAdvertiseSourceMap,
+        readReactBundleSourceMap,
+    });
+    if (uiRoutesResponse)
+        return uiRoutesResponse;
+    return new Response("Not found", { status: 404 });
+};

package/esm/src/server/workspace/build.d.ts

@@ -0,0 +1,57 @@
+import type { ModelProvider, SavedState, TraceEvent } from "@bolt-foundry/gambit-core";
+import type { BuildChatProvider } from "../../server_build_chat_provider.js";
+import type { BuildBotRunEntry, BuildBotRunStatus, WorkspaceRunToolInsert } from "./types.js";
+export declare const createWorkspaceBuildService: (deps: {
+    buildAssistantDeckPath: string;
+    initialContext: unknown;
+    hasInitialContext: boolean;
+    modelProvider: ModelProvider;
+    model?: string;
+    modelForce?: string;
+    responsesMode?: boolean;
+    workerSandbox?: boolean;
+    randomId: (prefix: string) => string;
+    readSessionState: (workspaceId: string) => SavedState | undefined;
+    readSessionStateStrict: (workspaceId: string, options?: {
+        withTraces?: boolean;
+    }) => SavedState | undefined;
+    readBuildState: (workspaceId: string) => {
+        run?: {
+            id?: string;
+            status: BuildBotRunStatus["status"];
+            error?: string;
+            startedAt?: string;
+            finishedAt?: string;
+            messages?: Array<BuildBotRunStatus["messages"][number]>;
+            traces?: Array<TraceEvent>;
+            toolInserts?: Array<WorkspaceRunToolInsert>;
+        };
+        state?: SavedState;
+    } | null | undefined;
+    appendWorkspaceEnvelope: (state: SavedState, domain: "build", payload: Record<string, unknown>) => void;
+    appendDurableStreamEvent: (streamId: string, payload: unknown) => void;
+    workspaceStreamId: string;
+    persistCanonicalUserInputEvent: (args: {
+        state: SavedState | null | undefined;
+        runId: string;
+        message: string;
+        source: "build" | "scenario";
+    }) => void;
+    persistOpenResponsesTracesFromState: (state: SavedState | null | undefined, fallbackRunId?: string) => void;
+    persistOpenResponsesTraceEvent: (state: SavedState | null | undefined, trace: TraceEvent, fallbackRunId?: string) => void;
+}) => {
+    startWorkspaceBuildRun: (args: {
+        workspaceId: string;
+        message: string;
+        buildChatProvider?: BuildChatProvider;
+    }) => BuildBotRunStatus;
+    stopWorkspaceBuildRun: (args: {
+        workspaceId: string;
+        runId: string;
+    }) => Promise<BuildBotRunStatus>;
+    resetWorkspaceBuild: (workspaceId: string) => Promise<BuildBotRunStatus>;
+    readWorkspaceBuildRunForGraphql: (workspaceId: string) => BuildBotRunStatus;
+    buildRunFromProjection: (workspaceId: string) => BuildBotRunStatus;
+    getLiveBuildRunEntry: (workspaceId: string) => BuildBotRunEntry | undefined;
+};
+//# sourceMappingURL=build.d.ts.map

package/esm/src/server/workspace/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/build.ts"],"names":[],"mappings":"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"}