@allwright.dev/core 0.0.40 → 0.0.42

package/dist/bootstrap.js

@@ -12,7 +12,7 @@ const ALLWRIGHT_HOME_ENV_VAR = "ALLWRIGHT_HOME";
 const ALLWRIGHT_REPOSITORY_ENV_VAR = "ALLWRIGHT_REPOSITORY";
 const ALLWRIGHT_VERSION_ENV_VAR = "ALLWRIGHT_VERSION";
 const DEFAULT_RELEASE_REPOSITORY = "allwright-dev/allwright";
-const DEFAULT_RELEASE_VERSION = "0.0.40";
+const DEFAULT_RELEASE_VERSION = "0.0.42";
 const STARTUP_TIMEOUT_MS = 20_000;
 const PING_TIMEOUT_MS = 1_000;
 const PROTO_ROOT = fileURLToPath(new URL("../proto/", import.meta.url));
@@ -20,6 +20,9 @@ const ENGINE_PROTO_PATH = fileURLToPath(new URL("../proto/engine/v1/engine.proto
 let managedServer = null;
 let managedServerAddr = null;
 let managedServerBaseAddr = null;
+let managedServerStdout = "";
+let managedServerStderr = "";
+let managedServerSpawnError = null;
 export async function ensureRuntimeReady(serverAddr) {
     const expectedVersion = expectedRuntimeVersion();
     const status = await pingServer(serverAddr);
@@ -42,6 +45,9 @@ export async function ensureRuntimeReady(serverAddr) {
         managedServer = null;
         managedServerAddr = null;
         managedServerBaseAddr = null;
+        managedServerStdout = "";
+        managedServerStderr = "";
+        managedServerSpawnError = null;
     }
     const cliPath = await ensureCliAvailable(expectedVersion);
     ensureWebPlugin(cliPath, expectedVersion);
@@ -50,7 +56,19 @@ export async function ensureRuntimeReady(serverAddr) {
         resolvedServerAddr = await allocateManagedServerAddr(serverAddr);
     }
     managedServer = spawn(cliPath, ["serve", "--listen-addr", cliListenAddr(resolvedServerAddr)], {
-        stdio: "ignore",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    managedServerStdout = "";
+    managedServerStderr = "";
+    managedServerSpawnError = null;
+    managedServer.stdout?.on("data", (chunk) => {
+        managedServerStdout = appendManagedServerOutput(managedServerStdout, chunk);
+    });
+    managedServer.stderr?.on("data", (chunk) => {
+        managedServerStderr = appendManagedServerOutput(managedServerStderr, chunk);
+    });
+    managedServer.on("error", (error) => {
+        managedServerSpawnError = error.message;
     });
     managedServerAddr = resolvedServerAddr;
     managedServerBaseAddr = serverAddr;
@@ -63,18 +81,32 @@ export async function shutdownManagedServer() {
     managedServer = null;
     managedServerAddr = null;
     managedServerBaseAddr = null;
+    managedServerStdout = "";
+    managedServerStderr = "";
+    managedServerSpawnError = null;
 }
 async function waitForServer(serverAddr, expectedVersion) {
     const deadline = Date.now() + STARTUP_TIMEOUT_MS;
     while (Date.now() < deadline) {
+        if (managedServer && managedServer.exitCode !== null) {
+            const details = formatManagedServerFailure(managedServer.exitCode, managedServer.signalCode);
+            await shutdownManagedServer();
+            throw new Error(`allwright server exited before becoming ready at ${serverAddr}${details}`);
+        }
+        if (managedServerSpawnError) {
+            const details = formatManagedServerFailure(null, null);
+            await shutdownManagedServer();
+            throw new Error(`failed to start allwright server at ${serverAddr}${details}`);
+        }
         const status = await pingServer(serverAddr);
         if (status?.version === expectedVersion) {
             return serverAddr;
         }
         await new Promise((resolve) => setTimeout(resolve, 250));
     }
+    const details = formatManagedServerFailure(managedServer?.exitCode ?? null, managedServer?.signalCode ?? null);
     await shutdownManagedServer();
-    throw new Error(`timed out waiting for allwright server at ${serverAddr} to become ready with version ${expectedVersion}`);
+    throw new Error(`timed out waiting for allwright server at ${serverAddr} to become ready with version ${expectedVersion}${details}`);
 }
 async function pingServer(serverAddr) {
     const loaded = protoLoader.loadSync(ENGINE_PROTO_PATH, {
@@ -143,10 +175,20 @@ function ensureWebPlugin(cliPath, expectedVersion) {
         return;
     }
     const result = spawnSync(cliPath, ["plugin", "install", "web", "--version", expectedVersion], {
-        stdio: "ignore",
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
     });
+    if (result.error) {
+        throw new Error(`failed to install allwright web plugin with ${cliPath}: ${result.error.message}`);
+    }
     if (result.status !== 0 || !isFile(pluginPath)) {
-        throw new Error("allwright attempted to install the `web` plugin automatically, but the install did not complete successfully");
+        const details = [result.stdout, result.stderr]
+            .map((value) => value?.trim())
+            .filter((value) => !!value)
+            .join("\n");
+        throw new Error(details
+            ? `allwright attempted to install the \`web\` plugin automatically, but the install did not complete successfully:\n${details}`
+            : "allwright attempted to install the `web` plugin automatically, but the install did not complete successfully");
     }
     if (installedPluginVersion("web") !== expectedVersion) {
         throw new Error(`allwright attempted to install the \`web\` plugin automatically, but version ${expectedVersion} is still not active`);
@@ -170,33 +212,53 @@ async function resolveReleaseTag() {
     return payload.tag_name;
 }
 function extractCliArchive(archivePath, cliPath) {
+    const extractRoot = fs.mkdtempSync(path.join(os.tmpdir(), "allwright-cli-"));
     if (archivePath.endsWith(".zip")) {
         const result = spawnSync("powershell", [
             "-NoProfile",
             "-Command",
-            `Expand-Archive -Path '${archivePath.replaceAll("'", "''")}' -DestinationPath '${path.dirname(cliPath).replaceAll("'", "''")}' -Force`,
-        ], { stdio: "ignore" });
+            `Expand-Archive -Path '${archivePath.replaceAll("'", "''")}' -DestinationPath '${extractRoot.replaceAll("'", "''")}' -Force`,
+        ], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        if (result.error) {
+            fs.rmSync(extractRoot, { recursive: true, force: true });
+            throw new Error(`failed to extract allwright CLI zip archive: ${result.error.message}`);
+        }
         if (result.status !== 0) {
-            throw new Error("failed to extract allwright CLI zip archive");
+            const details = [result.stdout, result.stderr].map((value) => value?.trim()).filter(Boolean).join("\n");
+            fs.rmSync(extractRoot, { recursive: true, force: true });
+            throw new Error(details ? `failed to extract allwright CLI zip archive:\n${details}` : "failed to extract allwright CLI zip archive");
+        }
+        const extracted = findExtractedCli(extractRoot);
+        if (!extracted) {
+            fs.rmSync(extractRoot, { recursive: true, force: true });
+            throw new Error(`allwright CLI zip archive did not contain bin/${cliFilename()}`);
         }
-        const extracted = path.join(path.dirname(cliPath), "bin", cliFilename());
         fs.copyFileSync(extracted, cliPath);
-        fs.rmSync(path.join(path.dirname(cliPath), "bin"), { recursive: true, force: true });
+        fs.rmSync(extractRoot, { recursive: true, force: true });
         return;
     }
     const result = spawnSync("tar", [
         "-xzf",
         archivePath,
         "-C",
-        path.dirname(cliPath),
-        `bin/${cliFilename()}`,
-    ], { stdio: "ignore" });
+        extractRoot,
+    ], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    if (result.error) {
+        fs.rmSync(extractRoot, { recursive: true, force: true });
+        throw new Error(`failed to extract allwright CLI tar archive: ${result.error.message}`);
+    }
     if (result.status !== 0) {
-        throw new Error("failed to extract allwright CLI tar archive");
+        const details = [result.stdout, result.stderr].map((value) => value?.trim()).filter(Boolean).join("\n");
+        fs.rmSync(extractRoot, { recursive: true, force: true });
+        throw new Error(details ? `failed to extract allwright CLI tar archive:\n${details}` : "failed to extract allwright CLI tar archive");
+    }
+    const extracted = findExtractedCli(extractRoot);
+    if (!extracted) {
+        fs.rmSync(extractRoot, { recursive: true, force: true });
+        throw new Error(`allwright CLI archive did not contain bin/${cliFilename()}`);
     }
-    const extracted = path.join(path.dirname(cliPath), "bin", cliFilename());
     fs.copyFileSync(extracted, cliPath);
-    fs.rmSync(path.join(path.dirname(cliPath), "bin"), { recursive: true, force: true });
+    fs.rmSync(extractRoot, { recursive: true, force: true });
 }
 function cliAssetName(versionTag) {
     const targets = new Map([
@@ -269,7 +331,7 @@ async function allocateManagedServerAddr(serverAddr) {
             });
         });
     });
-    return host.includes(":") ? `http://[${host}]:${port}` : `http://${host}:${port}`;
+    return host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
 }
 function localBindingHost(serverAddr) {
     const host = parseServerHost(serverAddr);
@@ -316,6 +378,49 @@ function allwrightHome() {
 function cliFilename() {
     return process.platform === "win32" ? "allwright.exe" : "allwright";
 }
+function appendManagedServerOutput(current, chunk) {
+    const next = `${current}${typeof chunk === "string" ? chunk : chunk.toString("utf8")}`;
+    return next.length > 8_000 ? next.slice(-8_000) : next;
+}
+function formatManagedServerFailure(exitCode, signalCode) {
+    const parts = [];
+    if (managedServerSpawnError) {
+        parts.push(`spawn error: ${managedServerSpawnError}`);
+    }
+    if (exitCode !== null) {
+        parts.push(`exit code: ${exitCode}`);
+    }
+    if (signalCode) {
+        parts.push(`signal: ${signalCode}`);
+    }
+    if (managedServerStdout.trim()) {
+        parts.push(`stdout:\n${managedServerStdout.trim()}`);
+    }
+    if (managedServerStderr.trim()) {
+        parts.push(`stderr:\n${managedServerStderr.trim()}`);
+    }
+    return parts.length > 0 ? `\n${parts.join("\n")}` : "";
+}
+function findExtractedCli(extractRoot) {
+    const queue = [extractRoot];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(entryPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name === cliFilename() && path.basename(path.dirname(entryPath)) === "bin") {
+                return entryPath;
+            }
+        }
+    }
+    return null;
+}
 function webPluginFilename() {
     if (process.platform === "darwin") {
         return "liballwright_surface_web.dylib";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allwright.dev/core",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "High-level TypeScript client for the allwright automation engine.",
   "license": "MIT",
   "type": "module",