@wrenai/genbi 0.0.4 → 0.0.6

package/dist-server/server/interactive-terminal.d.ts

@@ -1,10 +1,11 @@
 import type { EnrichmentBinding } from "./enrichment.js";
 export { InteractiveLaunchError, legacyInteractiveWorkspace } from "./native-session-workspace.js";
 import type { NativeSessionStateBase } from "./native-session-workspace.js";
+import type { NativeChildEnvironment, NativeExecutableIdentity } from "./native-runtime-spec.js";
 export declare const INTERACTIVE_TARGETS: readonly ["claude-code:interactive", "codex:interactive"];
 export type InteractiveTarget = (typeof INTERACTIVE_TARGETS)[number];
 export interface InteractiveLaunchSpec {
-    readonly version: "1" | "2" | "3" | "4";
+    readonly version: "1" | "2" | "3" | "4" | "5";
     readonly target: InteractiveTarget;
     readonly executable: "claude" | "codex";
     readonly argv: readonly string[];
@@ -35,7 +36,7 @@ export interface PtyFactory {
         cwd: string;
         cols: number;
         rows: number;
-        env?: NodeJS.ProcessEnv;
+        env?: NativeChildEnvironment;
     }): PtyProcess;
 }
 /**
@@ -48,12 +49,12 @@ export interface PtyFactory {
  * advertised xterm ANSI palette silently optional and allow a caller to
  * weaken the native-terminal contract.
  */
-export declare function nativeTerminalEnvironment(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function nativeTerminalEnvironment(base?: NodeJS.ProcessEnv | NativeChildEnvironment): NativeChildEnvironment;
 /**
  * Mirrors the PATH lookup a shell-free PTY launch relies on. A shell alias or
  * function is deliberately not accepted: node-pty cannot execute either.
  */
-export declare function interactiveExecutableAvailable(executable: "claude" | "codex", pathValue?: string | undefined): boolean;
+export declare function interactiveExecutableAvailable(executable: "claude" | "codex", pathValue?: string): boolean;
 export interface InteractiveTerminalSession {
     readonly id: string;
     readonly capability: string;
@@ -115,10 +116,11 @@ export declare function launchFallbackCommand(spec: Pick<InteractiveLaunchSpec,
 /** Parse exactly the public v1 producer contract; unknown fields fail closed. */
 export declare function readInteractiveLaunchSpec(boundProject: string, requestedTarget: InteractiveTarget, materializationRoot?: string, materializationState?: NativeSessionStateBase): InteractiveLaunchSpec;
 export declare function dispatchInteractiveArtifacts(input: {
-    readonly warbleBin: string;
+    readonly producer: NativeExecutableIdentity;
     readonly irPath: string;
     readonly target: InteractiveTarget;
     readonly cwd: string;
+    readonly env: NativeChildEnvironment;
     readonly boundProject?: string;
     readonly materializationState?: NativeSessionStateBase;
 }): Promise<void>;
@@ -134,6 +136,7 @@ export interface InteractivePreparationInput {
 export interface InteractivePreparationDeps {
     readonly getCurrentBinding: () => EnrichmentBinding | undefined;
     readonly executableAvailable?: (executable: "claude" | "codex") => boolean;
+    readonly resolveExecutable?: (executable: "claude" | "codex") => NativeExecutableIdentity | undefined;
 }
 /**
  * Materializes and validates the clipboard/launch contract without loading a
@@ -158,6 +161,7 @@ export declare function getInteractiveTerminalReadiness(input: {
     readonly getCurrentBinding: () => EnrichmentBinding | undefined;
     readonly terminalHostAvailable: () => Promise<boolean>;
     readonly executableAvailable?: (executable: "claude" | "codex") => boolean;
+    readonly resolveExecutable?: (executable: "claude" | "codex") => NativeExecutableIdentity | undefined;
     /** BFF-owned base; validation is non-mutating and never reads the project root. */
     readonly materializationState?: NativeSessionStateBase;
 }): Promise<Record<InteractiveTarget, InteractiveTargetReadiness>>;
@@ -168,7 +172,7 @@ export declare class InteractiveTerminalManager {
     start(spec: InteractiveLaunchSpec, identity?: {
         readonly id: string;
         readonly capability: string;
-    }, env?: NodeJS.ProcessEnv, leasePolicy?: InteractiveTerminalLeasePolicy): InteractiveTerminalSession;
+    }, env?: NodeJS.ProcessEnv | NativeChildEnvironment, leasePolicy?: InteractiveTerminalLeasePolicy): InteractiveTerminalSession;
     get(id: string): InteractiveTerminalSession | undefined;
     /** Runtime changes revoke every non-durable compatibility terminal immediately. */
     closeAll(): void;

package/dist-server/server/interactive-terminal.js

@@ -7,9 +7,11 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, realpathSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
+import os from "node:os";
 import { spawn as spawnProcess } from "node:child_process";
 export { InteractiveLaunchError, legacyInteractiveWorkspace } from "./native-session-workspace.js";
 import { InteractiveLaunchError, nativeSessionStateBaseAvailable, validateLegacyInteractiveWorkspace } from "./native-session-workspace.js";
+import { assertNativeExecutableIdentity, buildNativeChildEnvironment, nativeProcessEnvironment } from "./native-runtime-spec.js";
 export const INTERACTIVE_TARGETS = ["claude-code:interactive", "codex:interactive"];
 const EXECUTABLE = {
     "claude-code:interactive": "claude",
@@ -25,15 +27,33 @@ const EXECUTABLE = {
  * advertised xterm ANSI palette silently optional and allow a caller to
  * weaken the native-terminal contract.
  */
-export function nativeTerminalEnvironment(base = process.env) {
-    const { NO_COLOR: _noColor, ...inherited } = base;
-    return { ...inherited, TERM: "xterm-256color", COLORTERM: "truecolor" };
+export function nativeTerminalEnvironment(base) {
+    const environment = base ?? buildNativeChildEnvironment({
+        toolDirectories: [path.dirname(process.execPath)],
+        home: os.homedir(),
+    });
+    const pathValue = environment.PATH ?? path.dirname(process.execPath);
+    const home = environment.HOME ?? os.homedir();
+    return Object.freeze({
+        PATH: pathValue,
+        HOME: home,
+        ...(process.platform === "darwin" ? { USER: os.userInfo().username, LOGNAME: os.userInfo().username } : {}),
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+        ...(environment.WREN_PROJECT_HOME ? { WREN_PROJECT_HOME: environment.WREN_PROJECT_HOME } : {}),
+        ...(environment.WREN_HOME ? { WREN_HOME: environment.WREN_HOME } : {}),
+        ...(environment.CODEX_HOME ? { CODEX_HOME: environment.CODEX_HOME } : {}),
+        ...(environment.WARBLE_MCP_CONNECTION_CREDENTIAL ? { WARBLE_MCP_CONNECTION_CREDENTIAL: environment.WARBLE_MCP_CONNECTION_CREDENTIAL } : {}),
+        ...(environment.WARBLE_SETUP_BOOTSTRAP_ROOT ? { WARBLE_SETUP_BOOTSTRAP_ROOT: environment.WARBLE_SETUP_BOOTSTRAP_ROOT } : {}),
+        ...(environment.PYTHONNOUSERSITE ? { PYTHONNOUSERSITE: "1" } : {}),
+        ...(environment.PYTHONUTF8 ? { PYTHONUTF8: "1" } : {}),
+    });
 }
 /**
  * Mirrors the PATH lookup a shell-free PTY launch relies on. A shell alias or
  * function is deliberately not accepted: node-pty cannot execute either.
  */
-export function interactiveExecutableAvailable(executable, pathValue = process.env["PATH"]) {
+export function interactiveExecutableAvailable(executable, pathValue) {
     if (!pathValue)
         return false;
     return pathValue.split(path.delimiter).some((directory) => {
@@ -131,8 +151,9 @@ export async function dispatchInteractiveArtifacts(input) {
         throw new InteractiveLaunchError("interactive enrichment materialization failed");
     if (input.boundProject && input.materializationState)
         validateLegacyInteractiveWorkspace(input.materializationState, input.boundProject, input.cwd);
+    assertNativeExecutableIdentity(input.producer);
     await new Promise((resolve, reject) => {
-        const child = spawnProcess(input.warbleBin, ["dispatch", input.irPath, "--target", input.target, "--out", input.cwd], { cwd: input.cwd, shell: false, stdio: "ignore" });
+        const child = spawnProcess(input.producer.executable, ["dispatch", input.irPath, "--target", input.target, "--out", input.cwd], { cwd: input.cwd, env: nativeProcessEnvironment(input.env), shell: false, stdio: "ignore" });
         child.once("error", () => reject(new InteractiveLaunchError("interactive enrichment materialization failed")));
         child.once("exit", (code) => code === 0 ? resolve() : reject(new InteractiveLaunchError("interactive enrichment materialization failed")));
     });
@@ -144,15 +165,19 @@ export async function dispatchInteractiveArtifacts(input) {
  */
 export async function prepareInteractiveHandoff(input, deps) {
     const executableAvailable = deps.executableAvailable ?? interactiveExecutableAvailable;
-    if (!executableAvailable(EXECUTABLE[input.target])) {
+    const executable = deps.resolveExecutable?.(EXECUTABLE[input.target]);
+    if (!(executable ?? executableAvailable(EXECUTABLE[input.target]))) {
         throw new InteractiveLaunchError(`the ${EXECUTABLE[input.target]} interactive CLI is not available on this machine`);
     }
+    if (executable)
+        assertNativeExecutableIdentity(executable);
     await input.materialize();
     const current = deps.getCurrentBinding();
     if (!current || current.path !== input.binding.path || current.identity !== input.binding.identity || current.generation !== input.binding.generation || current.revision !== input.binding.revision) {
         throw new InteractiveLaunchError("interactive enrichment is stale because the bound project changed");
     }
-    const spec = readInteractiveLaunchSpec(input.binding.path, input.target, input.artifactRoot, input.materializationState);
+    const parsed = readInteractiveLaunchSpec(input.binding.path, input.target, input.artifactRoot, input.materializationState);
+    const spec = executable ? { ...parsed, hostExecutable: executable.executable } : parsed;
     return { spec, handoff: { target: spec.target, fallbackCommand: launchFallbackCommand(spec) } };
 }
 /**
@@ -175,7 +200,7 @@ export async function getInteractiveTerminalReadiness(input) {
     const executableAvailable = input.executableAvailable ?? interactiveExecutableAvailable;
     const result = {};
     for (const target of INTERACTIVE_TARGETS) {
-        if (!executableAvailable(EXECUTABLE[target])) {
+        if (!(input.resolveExecutable?.(EXECUTABLE[target]) ?? executableAvailable(EXECUTABLE[target]))) {
             const reason = `the ${EXECUTABLE[target]} interactive CLI is not available on this machine`;
             result[target] = { copyAvailable: false, embeddedTerminalAvailable: false, copyReason: reason, embeddedTerminalReason: reason };
             continue;

package/dist-server/server/managed-wren-runtime.d.ts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import type { NativeWrenRuntime } from "./native-wren-runtime.js";
+declare const managedWrenManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<1>;
+    activation: z.ZodEnum<{
+        approved: "approved";
+        staged: "staged";
+    }>;
+    platform: z.ZodLiteral<"darwin-arm64">;
+    compatibility: z.ZodObject<{
+        genbi: z.ZodString;
+        profile: z.ZodLiteral<"genbi-native-v4">;
+        wren: z.ZodString;
+    }, z.core.$strict>;
+    python: z.ZodObject<{
+        implementation: z.ZodLiteral<"cpython">;
+        version: z.ZodString;
+        upstream: z.ZodObject<{
+            release: z.ZodString;
+            url: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>;
+        mirror: z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>;
+        interpreterPath: z.ZodString;
+    }, z.core.$strict>;
+    wheels: z.ZodArray<z.ZodObject<{
+        distribution: z.ZodString;
+        version: z.ZodString;
+        filename: z.ZodString;
+        url: z.ZodString;
+        sourceUrl: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+    runtime: z.ZodObject<{
+        pythonArchivePath: z.ZodString;
+        venvInterpreterPath: z.ZodString;
+        launcherPath: z.ZodString;
+        module: z.ZodLiteral<"wren.cli:app">;
+        packagePath: z.ZodString;
+        sitePackagesPath: z.ZodString;
+        pythonTreeSha256: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"staged">]>;
+        packageTreeSha256: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"staged">]>;
+        sitePackagesTreeSha256: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"staged">]>;
+        closureSha256: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"staged">]>;
+    }, z.core.$strict>;
+    licenseApproval: z.ZodObject<{
+        state: z.ZodEnum<{
+            approved: "approved";
+            pending: "pending";
+        }>;
+        evidence: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    approvedManifest: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ManagedWrenManifest = Readonly<z.infer<typeof managedWrenManifestSchema>>;
+export declare class ManagedWrenRuntimeError extends Error {
+    readonly code: ManagedWrenFailureCode;
+    constructor(code: ManagedWrenFailureCode, message?: ManagedWrenFailureCode);
+}
+export type ManagedWrenFailureCode = "codex_wren_manifest_missing" | "codex_wren_manifest_invalid" | "codex_wren_platform_unsupported" | "codex_wren_runtime_unprovisioned" | "codex_wren_provision_failed" | "codex_wren_interpreter_mismatch" | "codex_wren_launcher_mismatch" | "codex_wren_package_mismatch" | "codex_wren_closure_mismatch";
+export interface ManagedWrenRuntimeRecord extends NativeWrenRuntime {
+    readonly manifest_digest: string;
+    readonly generation_root: string;
+    readonly closure_digest: string;
+    readonly package_digest: string;
+}
+export declare function defaultManagedWrenRoot(): string;
+export declare function managedWrenManifestPath(root?: string): string;
+export declare function readManagedWrenManifest(root?: string): ManagedWrenManifest;
+export declare function manifestDigest(manifest: ManagedWrenManifest): string;
+export declare const managedWrenTreeDigest: (root: string) => string;
+/**
+ * Remove only records that were previously returned by this module and that
+ * the caller has established are neither active nor required for rollback.
+ *
+ * Generation selection belongs to the host/session lifecycle, not to a
+ * directory sweep: accepting arbitrary paths here would make cleanup an
+ * unsafe deletion primitive.  A concurrent provisioner conservatively blocks
+ * cleanup altogether; it can retry after the writer releases its lock.
+ */
+export declare function cleanupManagedWrenGenerations(options: {
+    readonly runtimeRoot?: string;
+    readonly candidates: readonly ManagedWrenRuntimeRecord[];
+    readonly retainManifestDigests: readonly string[];
+}): readonly string[];
+/** Revalidate a record before every native Codex launch. */
+export declare function resolveManagedWrenRuntime(options?: {
+    readonly packageRoot?: string;
+    readonly runtimeRoot?: string;
+}): ManagedWrenRuntimeRecord;
+/**
+ * Readiness is deliberately resolve-only: checking any RuntimeHost backend
+ * must neither create the GenBI runtime root nor fetch/install managed bytes.
+ * An explicit future first-use path may call the exported provisioner below.
+ */
+export declare function managedWrenReadinessFailure(options?: {
+    readonly packageRoot?: string;
+    readonly runtimeRoot?: string;
+}): ManagedWrenFailureCode | undefined;
+/**
+ * Provision is intentionally unavailable for a staged manifest. A release can
+ * only turn this on after the protected licence approval job writes an approved
+ * manifest with release-attested digests.
+ */
+export declare function provisionManagedWrenRuntime(options?: {
+    readonly packageRoot?: string;
+    readonly runtimeRoot?: string;
+}): Promise<ManagedWrenRuntimeRecord>;
+export declare function managedWrenClosureDigest(manifest: ManagedWrenManifest): string;
+export {};