@wrenai/genbi 0.0.4 → 0.0.6

package/dist-server/server/bin.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import { createCodexRuntimeComposition, readCodexBootConfiguration } from "./codex-runtime-composition.js";
+import { createCodexStructuredAdapter } from "./codex-structured-ask.js";
+import { StructuredRuntime } from "./structured-runtime.js";
+import { shutdownNativeResources } from "./native-shutdown.js";
 /**
  * The BFF's process entrypoint. This is the ONLY file
  * in `server/` that wires real production values (env vars, a real `Store`
@@ -30,15 +34,21 @@
  *                               clear 500 at dispatch time instead.
  *   WREN_HARNESS_PROFILE        profileSource; default resolveDefaultProfileSource()
  *   WREN_HARNESS_MODE           subscription|api-key|local|gateway (auth mode)
- *   WREN_HARNESS_PROVIDER       subscription provider: claude|codex
+ *   WREN_HARNESS_PROVIDER       subscription provider: claude|codex; gateway mode: pi-ai provider id
  *   WREN_HARNESS_ADAPTER        api-key adapter name
  *   WREN_HARNESS_API_KEY        api-key credential
  *   WREN_HARNESS_MODEL          model override
- *   WREN_HARNESS_ENDPOINT       local/gateway endpoint URL
+ *   WREN_HARNESS_ENDPOINT       local endpoint URL; gateway mode: optional custom base URL
+ *   GENBI_GATEWAY_API_KEY       gateway-mode credential for the selected pi-ai provider. Read by
+ *                               the BFF and passed per request; never persisted, and pi-ai's own
+ *                               provider env vars / credential files are never consulted
  *   WREN_HARNESS_WARBLE_BIN     path to the warble CLI binary
- *   WREN_HARNESS_WREN_SHIM      optional absolute server-owned Wren shim for
- *                               native Codex runtime permissions; defaults to
- *                               the fixed local installation when unset
+ *   WREN_HARNESS_CONTEXT_LOADER_BIN
+ *                               path to the wren-context-loader binary, which renders the bound
+ *                               wren project into the prepared-context document a `kind: prepared`
+ *                               binding reads. Falls back to this repo's own Rust build; resolution
+ *                               loud-fails rather than degrading to Warble's built-in MDL adapter
+ *                               (see harness/compile/context-loader.ts)
  *   WREN_HARNESS_AGENT_SDK_BIN  path to the agent-sdk CLI binary (dispatched)
  *   WREN_HARNESS_CODEX_LOCAL_BIN path to the warble-codex-local dispatcher CLI
  *   WREN_HARNESS_CODEX_BIN       optional path to the Codex CLI used by that dispatcher
@@ -95,7 +105,8 @@
  */
 import { serve } from "@hono/node-server";
 import { createRequire } from "node:module";
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { WebSocketServer } from "ws";
@@ -104,16 +115,23 @@ import { buildTierBindingFromFlags, parseChatTimeoutMs, parseSetupMaxTurns, reso
 import { createApp } from "./app.js";
 import { recoverBootstrapProjectBinding } from "./bootstrap-project-binding.js";
 import { createHarnessProfileSources } from "./harness-profile-sources.js";
+import { ProfileRegistry } from "./profile-registry.js";
+import { getWarbleIdentity } from "../harness/compile/warble-identity.js";
 import { compileProfile, compileRawProfile } from "../harness/compile/index.js";
 import { resolveWarbleBinary } from "../harness/compile/resolve-binary.js";
 import { toAuthChoiceFromRuntimeSettings } from "./auth-choice.js";
 import { Store } from "./db.js";
 import { resolveEnrichmentBinding, resolveProjectIdentity } from "./enrichment.js";
+import { hashDirectory } from "../harness/compile/fingerprint.js";
+import { openWrenComponentAccess } from "../harness/components/wren-access.js";
 import { createDispatchedEnrichmentDraftRunner } from "./enrichment-runner.js";
 import { dispatchInteractiveArtifacts, getInteractiveTerminalReadiness, InteractiveLaunchError, InteractiveTerminalManager, prepareInteractiveHandoff, unavailableInteractiveReadiness } from "./interactive-terminal.js";
 import { createProbedPtyFactory, ensureDarwinNodePtySpawnHelper } from "./node-pty-host.js";
 import { NativeSessionService } from "./native-sessions.js";
 import { NativeArtifactService } from "./native-artifacts.js";
+import { RuntimeHost } from "./runtime-host/local.js";
+import { resolveManagedWrenRuntime } from "./managed-wren-runtime.js";
+import { assertNativeExecutableIdentity, assertNativeRuntimeSpec, attestNativeExecutable, buildNativeChildEnvironment, buildNativeRuntimeSpec, resolveNativeExecutable } from "./native-runtime-spec.js";
 import { initializeNativeSessionStateBase, legacyInteractiveWorkspace, validateLegacyInteractiveWorkspace } from "./native-session-workspace.js";
 import { codexModelsForRuntime, compileUnboundProfileTierNames, effectiveTierModel, materializeRuntimeRouteOptions, } from "./runtime-binding.js";
 import { invalidateBundleAgentIdsCache } from "./turn.js";
@@ -187,6 +205,26 @@ async function main() {
         return undefined;
     });
     const warbleBinOption = resolvedWarbleBin !== undefined ? { warbleBin: resolvedWarbleBin } : {};
+    const nativeHome = realpathSync(os.homedir());
+    const nodeExecutable = attestNativeExecutable("node", process.execPath);
+    const producerExecutable = resolvedWarbleBin ? attestNativeExecutable("producer", resolvedWarbleBin) : undefined;
+    const bootPath = process.env["PATH"];
+    const claudeExecutable = resolveNativeExecutable("vendor", "claude", bootPath);
+    const codexExecutable = resolveNativeExecutable("vendor", "codex", bootPath);
+    const vendorExecutables = Object.freeze({
+        ...(claudeExecutable ? { claude: claudeExecutable } : {}),
+        ...(codexExecutable ? { codex: codexExecutable } : {}),
+    });
+    const nativeWrenExecutable = resolveNativeExecutable("wren", "wren", bootPath);
+    const nativeToolDirectories = Object.freeze([...new Set([
+            path.dirname(nodeExecutable.executable),
+            // Native auth and CLI tools need fixed OS utilities, even with a sanitized PATH.
+            ...(["darwin", "linux"].includes(process.platform) ? ["/usr/bin", "/bin", "/usr/sbin", "/sbin"].map((directory) => realpathSync(directory)) : []),
+            ...(nativeWrenExecutable ? [path.dirname(nativeWrenExecutable.executable)] : []),
+            ...Object.values(vendorExecutables).filter((value) => value !== undefined).map((value) => path.dirname(value.executable)),
+            ...(producerExecutable ? [path.dirname(producerExecutable.executable)] : []),
+        ])]);
+    const nativeHostEnvironment = buildNativeChildEnvironment({ toolDirectories: nativeToolDirectories, home: nativeHome });
     const profileSource = flags.profile ?? resolveDefaultProfileSource();
     // Frozen at boot: GET /api/harness accepts only a purpose and must never
     // inherit a caller-supplied RouteOptions.profileSource.
@@ -203,6 +241,19 @@ async function main() {
     // Initialization creates the fixed private namespaces once at startup.
     const nativeMaterializationState = initializeNativeSessionStateBase(dbPath);
     const store = new Store(dbPath);
+    // Conversation profiles a session may start inside: the shipped ones under this package's
+    // `profiles/` plus any the operator adds under the workspace. Registration compiles each one, so
+    // it runs in the background; the first `/api/profiles` request awaits the same promise.
+    const profileRegistry = new ProfileRegistry({
+        store,
+        builtinProfilesDir: path.dirname(harnessProfileSources.analysis),
+        userProfilesDir: path.join(workspaceRoot, "profiles"),
+        compileRaw: (source) => compileRawProfile({ profileSource: source, mode: "native", ...warbleBinOption }),
+        warbleIdentity: async () => (resolvedWarbleBin !== undefined ? getWarbleIdentity(resolvedWarbleBin) : "warble:unresolved"),
+    });
+    void profileRegistry.ensureReady().catch((error) => {
+        process.stderr.write(`warning: profile registry failed to initialize: ${error instanceof Error ? error.message : String(error)}\n`);
+    });
     const getCodexModels = () => codexModelsForRuntime(store.getRuntimeSettings());
     const getRuntimeTierNames = () => compileUnboundProfileTierNames({
         profileSource,
@@ -260,9 +311,11 @@ async function main() {
         boundProject = identity.path;
         const { revokedNativeSessionIds } = store.activateEnrichmentBindingAndRevokeBoundNativeSessions(identity);
         nativeSessions.revokeBindingCapabilities(revokedNativeSessionIds);
+        deps?.structuredRuntime?.revoke();
         invalidateBundleAgentIdsCache(deps);
     }
     function unbindProject() {
+        deps?.structuredRuntime?.revoke();
         boundProject = undefined;
         invalidateBundleAgentIdsCache(deps);
     }
@@ -291,6 +344,10 @@ async function main() {
     // a reset) later in the same boot. The actual logic lives in `./wren-home.js` so it's directly
     // unit-testable without going through a mocked `TurnDeps`.
     const originalWrenHome = process.env["WREN_HOME"];
+    const operatorWrenHome = originalWrenHome?.trim() || path.join(nativeHome, ".wren");
+    const nativeSourceWrenHome = () => store.getSetupMode() === "create"
+        ? path.join(workspaceRoot, ".wren")
+        : operatorWrenHome;
     const setWrenHomeForSetupMode = createSetWrenHomeForSetupMode(workspaceRoot, originalWrenHome);
     // Mutable auth-choice binding — the auth-choice mirror of boundProject above. Starts at the
     // boot-resolved `authChoice` and can be rebound later by PUT /api/config/runtime
@@ -453,7 +510,12 @@ async function main() {
             try {
                 const require = createRequire(import.meta.url);
                 ensureDarwinNodePtySpawnHelper(require.resolve("node-pty"));
-                return await createProbedPtyFactory(await import("node-pty"));
+                assertNativeExecutableIdentity(nodeExecutable);
+                return await createProbedPtyFactory(await import("node-pty"), {
+                    cwd: nativeMaterializationState.root,
+                    env: nativeHostEnvironment,
+                    probeExecutable: nodeExecutable.executable,
+                });
             }
             catch {
                 throw new InteractiveLaunchError("interactive terminal host cannot spawn local processes on this machine");
@@ -470,14 +532,24 @@ async function main() {
     async function prepareInteractiveTerminal(target, binding) {
         if (enrichIrPath === undefined)
             throw new InteractiveLaunchError("interactive enrichment artifacts are not configured");
+        if (producerExecutable === undefined)
+            throw new InteractiveLaunchError("interactive enrichment materialization failed");
         const artifactRoot = legacyInteractiveWorkspace(nativeMaterializationState, binding.path, target);
+        const dispatchEnvironment = buildNativeChildEnvironment({
+            toolDirectories: nativeToolDirectories,
+            home: nativeHome,
+            projectPath: binding.path,
+        });
         return prepareInteractiveHandoff({
             target,
             binding,
             artifactRoot,
             materializationState: nativeMaterializationState,
-            materialize: () => dispatchInteractiveArtifacts({ warbleBin: resolvedWarbleBin ?? "warble", irPath: enrichIrPath, target, cwd: artifactRoot, boundProject: binding.path, materializationState: nativeMaterializationState }),
-        }, { getCurrentBinding: currentInteractiveBinding });
+            materialize: () => dispatchInteractiveArtifacts({ producer: producerExecutable, irPath: enrichIrPath, target, cwd: artifactRoot, env: dispatchEnvironment, boundProject: binding.path, materializationState: nativeMaterializationState }),
+        }, {
+            getCurrentBinding: currentInteractiveBinding,
+            resolveExecutable: (executable) => executable === "claude" ? vendorExecutables.claude : vendorExecutables.codex,
+        });
     }
     const nativeMcpUrl = `http://127.0.0.1:${port}/api/native-sessions/mcp`;
     const nativeArtifacts = new NativeArtifactService({
@@ -486,6 +558,33 @@ async function main() {
         expectedMcpUrl: nativeMcpUrl,
         mcpUrl: process.env["WREN_HARNESS_NATIVE_MCP_URL"] ?? nativeMcpUrl,
         getBinding: currentInteractiveBinding,
+        // The session `query` tool runs through the same `wren` native sessions are given.
+        ...(nativeWrenExecutable ? {
+            openQueryAccess: async (binding, signal) => openWrenComponentAccess({
+                executable: nativeWrenExecutable.executable, project: binding.path, fingerprint: await hashDirectory(binding.path), signal,
+            }),
+        } : {}),
+    });
+    const nativeTerminalHostAvailable = async () => {
+        try {
+            await loadPty();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    // This is the sole production composition of the Phase-1 policy. Browser
+    // requests never reach this selection or its executable/policy inputs.
+    const codexConfiguration = readCodexBootConfiguration(process.env);
+    const codexComposition = createCodexRuntimeComposition({ configuration: codexConfiguration, packageRoot,
+        producerBinary: producerExecutable?.executable ?? "", profileSource: harnessProfileSources.analysis, store,
+        getBinding: currentInteractiveBinding, sourceWrenHome: nativeSourceWrenHome, artifacts: nativeArtifacts });
+    const nativeRuntimeHost = new RuntimeHost({
+        selected: codexConfiguration.selected,
+        deployment: process.env["NODE_ENV"] === "production" ? "production" : "development",
+        localAvailable: () => codexConfiguration.allowLocal ? nativeTerminalHostAvailable() : false,
+        vendorProbes: { "codex-app-server": codexComposition.probe },
     });
     const nativeSessions = new NativeSessionService({
         store,
@@ -503,32 +602,56 @@ async function main() {
         // Setup has no binding by definition, so it compiles the profile's authored
         // context with no user project composed in; its golden resolves nothing
         // either, which is why Setup never showed this symptom.
-        resolveDispatchIr: async (purpose, binding) => {
-            const profileSource = harnessProfileSources[purpose];
+        resolveDispatchIr: async (purpose, binding, selectedProfileSource) => {
+            // A selected conversation profile compiles from the registry's copy; everything else from the
+            // boot-time source for its purpose.
+            const profileSource = selectedProfileSource ?? harnessProfileSources[purpose];
             const compiled = purpose === "setup" || binding === undefined
                 ? await compileRawProfile({ profileSource, mode: "native", ...warbleBinOption })
                 : await compileProfile({ profileSource, userProject: binding.path, mode: "native", ...warbleBinOption });
             return compiled.irPath;
         },
+        resolveConversationProfile: async (id) => {
+            const { row, sourceDir } = await profileRegistry.resolveConversationProfileSource(id);
+            return { id: row.id, sourceDir, entry: row.entryKind === "agent" && row.entryVerb !== null ? { kind: "agent", verb: row.entryVerb } : { kind: "scope" } };
+        },
+        listConversationProfiles: async () => (await profileRegistry.list())
+            .filter((row) => row.role === "conversation")
+            .map((row) => ({
+            id: row.id,
+            selectable: row.admissionStatus === "admitted",
+            ...(row.admissionReason !== null ? { reason: row.admissionReason } : {}),
+            ...(row.entryKind !== null ? { entryKind: row.entryKind } : {}),
+            ...(row.entryVerb !== null ? { entryVerb: row.entryVerb } : {}),
+        })),
         // The service's option is a required string; when resolution failed the bare
         // name is what the preflight will report as unresolvable, with its reason.
-        warbleBin: resolvedWarbleBin ?? "warble",
-        ...(process.env["WREN_HARNESS_WREN_SHIM"] !== undefined ? { wrenShim: process.env["WREN_HARNESS_WREN_SHIM"] } : {}),
-        terminalHostAvailable: async () => {
-            try {
-                await loadPty();
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
+        warbleBin: producerExecutable?.executable ?? "warble",
+        terminalHostAvailable: nativeTerminalHostAvailable,
+        runtimeHost: nativeRuntimeHost,
+        directCodex: codexComposition.native,
+        resolveManagedCodexWrenRuntime: () => resolveManagedWrenRuntime({ packageRoot }),
+        nativeHome,
+        sourceWrenHome: nativeSourceWrenHome,
+        ...(baseRouteOptions.codexHome ? { codexHome: baseRouteOptions.codexHome } : {}),
+        vendorExecutables,
+        nodeExecutable,
+        childToolDirectories: nativeToolDirectories,
+        ...(bootPath !== undefined ? { pathValue: bootPath } : {}),
         artifactService: nativeArtifacts,
     });
+    // Explicit opt-in remains behind the packaged exact-version certification gate.
+    const structuredRuntime = new StructuredRuntime({
+        selected: { codex: codexConfiguration.selected, claude: "local" }, allowLocal: codexConfiguration.allowLocal, deployment,
+        adapters: { codex: createCodexStructuredAdapter(codexComposition.structured) },
+        localRoute: route, localSetupFor: (choice) => setupRunnerFor?.(choice) ?? setupRunner,
+    });
     deps = {
         store,
+        structuredRuntime,
         nativeSessions,
         nativeArtifacts,
+        profileRegistry,
         route,
         baseRouteOptions,
         describeBundle: (options) => {
@@ -540,8 +663,8 @@ async function main() {
                     : {}),
             });
         },
-        describeHarnessBundle: (purpose, options) => {
-            const profileSource = harnessProfileSources[purpose];
+        describeHarnessBundle: (purpose, options, selectedProfileSource) => {
+            const profileSource = selectedProfileSource ?? harnessProfileSources[purpose];
             const common = {
                 ...options,
                 profileSource,
@@ -570,7 +693,24 @@ async function main() {
             const { spec } = await prepareInteractiveTerminal(target, binding);
             const manager = await terminalManager();
             validateLegacyInteractiveWorkspace(nativeMaterializationState, binding.path, spec.cwd);
-            return manager.start(spec, undefined, { ...process.env, WREN_PROJECT_HOME: binding.path });
+            if (producerExecutable === undefined || spec.hostExecutable === undefined)
+                throw new InteractiveLaunchError("interactive enrichment materialization failed");
+            const runtimeSpec = buildNativeRuntimeSpec({
+                backend: "local",
+                vendor: target === "claude-code:interactive" ? "claude" : "codex",
+                executables: [
+                    nodeExecutable,
+                    producerExecutable,
+                    attestNativeExecutable("vendor", spec.hostExecutable),
+                ],
+                toolDirectories: nativeToolDirectories,
+                workspace: spec.cwd,
+                home: nativeHome,
+                binding,
+                ...(target === "codex:interactive" && baseRouteOptions.codexHome ? { codexHome: baseRouteOptions.codexHome } : {}),
+            });
+            assertNativeRuntimeSpec(runtimeSpec);
+            return manager.start(spec, undefined, runtimeSpec.childEnvironment);
         },
         prepareInteractiveTerminal: async ({ target, binding }) => {
             return (await prepareInteractiveTerminal(target, binding)).handoff;
@@ -592,6 +732,7 @@ async function main() {
                         return false;
                     }
                 },
+                resolveExecutable: (executable) => executable === "claude" ? vendorExecutables.claude : vendorExecutables.codex,
             });
         },
         workspaceRoot,
@@ -605,6 +746,25 @@ async function main() {
     const server = serve({ fetch: app.fetch, websocket: { server: websocket }, hostname: "127.0.0.1", port }, (info) => {
         process.stdout.write(`wren-harness BFF listening on http://127.0.0.1:${info.port} (db: ${dbPath})\n`);
     });
+    const shutdown = () => {
+        const deadline = setTimeout(() => process.exit(1), 12_000);
+        void shutdownNativeResources({
+            shutdownSessions: async () => {
+                const results = await Promise.allSettled([nativeSessions.shutdown(), structuredRuntime.shutdown(), codexComposition.shutdown()]);
+                if (results.some((result) => result.status === "rejected"))
+                    throw new Error("Session cleanup failed");
+            },
+            closeTerminals: () => interactiveTerminal?.closeAll(),
+            closeServer: () => { server.close(); },
+        }).then((code) => {
+            if (code)
+                process.stderr.write("error: native session cleanup did not complete\n");
+            clearTimeout(deadline);
+            process.exit(code);
+        });
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
     // Without this, a port that is already taken surfaces as an unhandled 'error' event and a raw
     // Node stack trace -- the first thing a new user is likely to hit, and the least readable.
     server.on("error", (error) => {

package/dist-server/server/codex-native-session.d.ts

@@ -0,0 +1,25 @@
+import type { CodexAppServerBackend, CodexLaunchPermit } from "./runtime-host/codex-app-server.js";
+import type { CodexSessionTools } from "./runtime-host/codex-direct-tools.js";
+import type { EnrichmentBinding } from "./enrichment.js";
+import type { NativeSessionRow } from "./db.js";
+/** Server-only provisioner. A ready probe alone never authorizes materialization. */
+export interface DirectCodexProvisioner {
+    /** Official remote CLI renderer; the host still owns the governed thread. */
+    readonly terminal?: boolean;
+    readonly terminalCertified?: (entry: string) => boolean;
+    readonly backend: Pick<CodexAppServerBackend, "prepareLaunch" | "open">;
+    /** Own and clean partial allocations on failure. Never receives browser paths or credentials. */
+    prepare(input: {
+        readonly session: NativeSessionRow;
+        readonly binding: EnrichmentBinding;
+        readonly permit: CodexLaunchPermit;
+        readonly signal: AbortSignal;
+        readonly assertActive: () => void;
+    }): Promise<{
+        readonly input: Omit<Parameters<CodexAppServerBackend["open"]>[1], "onEvent" | "tools"> & {
+            readonly tools: CodexSessionTools;
+        };
+        /** Runs after the conversation and scoped tools have closed. */
+        dispose(): Promise<void>;
+    }>;
+}

package/dist-server/server/codex-native-session.js

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

package/dist-server/server/codex-runtime-composition.d.ts

@@ -0,0 +1,34 @@
+import type { Store } from "./db.js";
+import type { EnrichmentBinding } from "./enrichment.js";
+import type { NativeArtifactService } from "./native-artifacts.js";
+import type { RuntimeBackendProbeResult } from "./runtime-host/types.js";
+import type { DirectCodexProvisioner } from "./codex-native-session.js";
+import type { CodexStructuredProvisioner } from "./codex-structured-ask.js";
+export interface CodexBootConfiguration {
+    readonly selected: "local" | "codex-app-server";
+    readonly allowLocal: boolean;
+    readonly executable?: string;
+    readonly source?: string;
+    readonly loginHome?: string;
+    readonly accountEmail?: string;
+}
+/** Read once at composition. No browser values, PATH discovery or credential copying. */
+export declare function readCodexBootConfiguration(env: NodeJS.ProcessEnv): CodexBootConfiguration;
+interface Options {
+    readonly configuration: CodexBootConfiguration;
+    readonly packageRoot: string;
+    readonly producerBinary: string;
+    readonly profileSource: string;
+    readonly store: Store;
+    readonly getBinding: () => EnrichmentBinding | undefined;
+    readonly sourceWrenHome: () => string;
+    readonly artifacts: NativeArtifactService;
+}
+/** Real composition for both entry surfaces; certification is enforced by the packaged backend. */
+export declare function createCodexRuntimeComposition(options: Options): {
+    probe: () => Promise<RuntimeBackendProbeResult<"codex-app-server">>;
+    native: DirectCodexProvisioner;
+    structured: CodexStructuredProvisioner;
+    shutdown: () => Promise<void>;
+};
+export {};