@wrenai/genbi 0.0.3 → 0.0.4

package/README.md

@@ -25,7 +25,7 @@ the rest:
 
 ## Developer preview
 
-`@wrenai/genbi` is published at `0.0.3`. Nothing here is under a compatibility
+`@wrenai/genbi` is published at `0.0.4`. Nothing here is under a compatibility
 commitment yet — commands, environment variables and interfaces move without
 notice. The Codex runtime is supported in code but has not been exercised end
 to end; Claude is the one that is. See

package/dist-server/harness/compile/resolve-binary.js

@@ -31,6 +31,16 @@ import { isWarbleSiblingCheckoutDevModeEnabled, resolveInstalledPackageBin } fro
  */
 export async function resolveWarbleBinary(explicit) {
     if (explicit !== undefined) {
+        // A value with no path separator is a command name, not a file path, and is
+        // resolved on PATH — the same reading the native-session preflight gives it.
+        // Requiring it to exist relative to the working directory made `"warble"` an
+        // explicit value that could never resolve, while the preflight found it and
+        // reported the producer healthy: one string, two answers.
+        if (!explicit.includes(path.sep) && !path.isAbsolute(explicit)) {
+            if (await isExecutableOnPath(explicit))
+                return explicit;
+            throw new WarbleBinaryNotFoundError([`explicit warbleBin "${explicit}" is not on PATH`]);
+        }
         if (!existsSync(explicit)) {
             throw new WarbleBinaryNotFoundError([`explicit warbleBin "${explicit}" does not exist`]);
         }

package/dist-server/server/bin.js

@@ -105,6 +105,7 @@ import { createApp } from "./app.js";
 import { recoverBootstrapProjectBinding } from "./bootstrap-project-binding.js";
 import { createHarnessProfileSources } from "./harness-profile-sources.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";
@@ -170,6 +171,22 @@ async function main() {
     // (server/turn.ts) and `server/spa.ts`.
     const candidateStaticDir = path.join(packageRoot, "dist");
     const staticDir = existsSync(path.join(candidateStaticDir, "index.html")) ? candidateStaticDir : undefined;
+    // Resolve the Warble binary once, here, and hand the resolved path to every
+    // consumer. Passing the bare name `"warble"` looked like a harmless default and
+    // was not: `resolveWarbleBinary` treats any value it is given as an explicit
+    // path and only searches when given nothing, so that default disabled the one
+    // lookup that finds the `@warble/cli` an install actually ships. It also made
+    // two resolvers disagree about the same string — the native preflight resolves
+    // a bare name through PATH and reported the producer healthy, while every
+    // compile failed.
+    const resolvedWarbleBin = await resolveWarbleBinary(flags.warbleBin).catch((error) => {
+        // Not fatal: the app still starts, and readiness reports the reason per
+        // vendor rather than the process dying at boot over a feature the user may
+        // not reach.
+        process.stderr.write(`warning: ${error instanceof Error ? error.message : String(error)}\n`);
+        return undefined;
+    });
+    const warbleBinOption = resolvedWarbleBin !== undefined ? { warbleBin: resolvedWarbleBin } : {};
     const profileSource = flags.profile ?? resolveDefaultProfileSource();
     // Frozen at boot: GET /api/harness accepts only a purpose and must never
     // inherit a caller-supplied RouteOptions.profileSource.
@@ -459,7 +476,7 @@ async function main() {
             binding,
             artifactRoot,
             materializationState: nativeMaterializationState,
-            materialize: () => dispatchInteractiveArtifacts({ warbleBin: flags.warbleBin ?? "warble", irPath: enrichIrPath, target, cwd: artifactRoot, boundProject: binding.path, materializationState: nativeMaterializationState }),
+            materialize: () => dispatchInteractiveArtifacts({ warbleBin: resolvedWarbleBin ?? "warble", irPath: enrichIrPath, target, cwd: artifactRoot, boundProject: binding.path, materializationState: nativeMaterializationState }),
         }, { getCurrentBinding: currentInteractiveBinding });
     }
     const nativeMcpUrl = `http://127.0.0.1:${port}/api/native-sessions/mcp`;
@@ -489,11 +506,13 @@ async function main() {
         resolveDispatchIr: async (purpose, binding) => {
             const profileSource = harnessProfileSources[purpose];
             const compiled = purpose === "setup" || binding === undefined
-                ? await compileRawProfile({ profileSource, mode: "native", warbleBin: flags.warbleBin ?? "warble" })
-                : await compileProfile({ profileSource, userProject: binding.path, mode: "native", warbleBin: flags.warbleBin ?? "warble" });
+                ? await compileRawProfile({ profileSource, mode: "native", ...warbleBinOption })
+                : await compileProfile({ profileSource, userProject: binding.path, mode: "native", ...warbleBinOption });
             return compiled.irPath;
         },
-        warbleBin: flags.warbleBin ?? "warble",
+        // 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 {

package/dist-server/server/native-sessions.js

@@ -7,6 +7,7 @@ import { execFileSync, spawn } from "node:child_process";
 import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { WarbleBinaryNotFoundError } from "../harness/compile/errors.js";
 import { InteractiveLaunchError, NO_INTERACTIVE_TERMINAL_LEASES, interactiveExecutableAvailable } from "./interactive-terminal.js";
 import { newId } from "./db.js";
 import { NATIVE_MCP_CREDENTIAL_ENV_VAR } from "./native-artifacts.js";
@@ -39,11 +40,13 @@ const CODEX_NATIVE_PERMISSION_HEADER = "[permissions.warble_native_wren.filesyst
 const PROVIDER_SESSION_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const CODEX_RESUME_HANDLE_FILE = path.join(".warble", "codex-thread-id");
 function logNativeLaunchFailure(purpose, vendor, phase, error) {
-    const category = error instanceof InteractiveLaunchError ? "rejected" : "unexpected";
-    // Keep the precise boundary server-side without logging exception text,
-    // paths, credentials, argv, or other launch material. Browser/API callers
-    // continue through nativeSessionLaunchFailure's closed public projection.
-    console.error(`[native-sessions] launch failed purpose=${purpose} vendor=${vendor} phase=${phase} category=${category}`);
+    const rejected = error instanceof InteractiveLaunchError;
+    // Exception text, paths, credentials and argv stay out of the log for an
+    // unexpected error, which may carry any of them. A rejection carries a
+    // sentence authored here, and suppressing that turned every diagnosis into a
+    // guess: an operator saw a phase and a category and no cause.
+    const detail = rejected ? ` reason=${error.message}` : "";
+    console.error(`[native-sessions] launch failed purpose=${purpose} vendor=${vendor} phase=${phase} category=${rejected ? "rejected" : "unexpected"}${detail}`);
 }
 /**
  * The producer deliberately sees only a sealed binding identity, never a caller-supplied path.
@@ -352,6 +355,16 @@ export function nativeSessionLaunchFailure(error) {
         return "native session launch artifacts are unavailable";
     if (message === "native session launch paths are unavailable" || message === "native session launch paths are outside its server-owned scope")
         return "native session launch artifacts are unavailable";
+    // Every InteractiveLaunchError message is authored in this file: a fixed
+    // sentence, a fixed profile name, or a reason readiness already publishes.
+    // None is built from a path, argv, or process output. Falling through to the
+    // generic string threw away the cause of eighteen distinct failures, which is
+    // what left "native session launch failed" as the only thing a user could see.
+    if (error instanceof InteractiveLaunchError)
+        return message;
+    // This one is NOT safe to forward: its text embeds the configured binary path.
+    if (error instanceof WarbleBinaryNotFoundError)
+        return "the Warble binary could not be resolved";
     return "native session launch failed";
 }
 const NATIVE_PRODUCER_CATEGORY = "native_session_producer_incompatible";
@@ -1310,9 +1323,20 @@ export class NativeSessionService {
         // Compile for this binding rather than dispatching the profile's golden.
         // Falls back to the configured path only where no resolver is wired (the
         // fixture-mode tests), never silently in production — see `bin.ts`.
-        const irPath = this.options.resolveDispatchIr === undefined
-            ? configuredIr
-            : await this.options.resolveDispatchIr(purpose, binding);
+        // Compiling for this binding runs before the launch try/catch below, so a
+        // failure here reached the HTTP route unlogged and unclassified — the case
+        // where the server printed nothing at all and the browser said only "native
+        // session launch failed".
+        let irPath;
+        try {
+            irPath = this.options.resolveDispatchIr === undefined
+                ? configuredIr
+                : await this.options.resolveDispatchIr(purpose, binding);
+        }
+        catch (error) {
+            logNativeLaunchFailure(purpose, dispatchDefinition.provider, "dispatch_ir", error);
+            throw error;
+        }
         const producer = this.legacyFixtureMode() ? undefined : await this.productionProducerPreflight();
         const launchProducer = producer ? producer.vendors[dispatchDefinition.provider] : undefined;
         if (producer && (!launchProducer?.available || !producer.producer)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrenai/genbi",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Wren GenBI — the web UI for WrenAI: ask questions of your data and get dashboards back",
   "license": "Apache-2.0",
   "keywords": [