toolcraft-openapi 0.0.23 → 0.0.25

package/README.md

@@ -19,12 +19,11 @@ const auth = bearerTokenAuth({
 ## Generator CLI
 
 `toolcraft-openapi-generate` reads an OpenAPI document from disk or a URL, writes generated
-command files, and stores the current spec hash in `openapi.lock`.
+command files.
 
 - `--input <path-or-url>` — OpenAPI document to read. Defaults to `openapi.json`.
 - `--output <dir>` — directory for generated files. Defaults to `src/generated`.
-- `--lock <path>` — lock file path. Defaults to `openapi.lock`.
-- `--check` — exits non-zero when generated files or `openapi.lock` would change.
+- `--check` — exits non-zero when generated files would change.
 
 ### CI drift check
 

package/dist/auth/bearer-token-auth.js

@@ -24,22 +24,26 @@ export function bearerTokenAuth(options) {
             account: KEYCHAIN_ACCOUNT,
         },
     });
+    let lastResolvedToken = null;
     async function resolveToken() {
         const envToken = normalizeToken(process.env[options.envVar]);
         if (envToken) {
-            return {
+            lastResolvedToken = {
                 token: envToken,
                 tokenSource: `env (${options.envVar})`,
             };
+            return lastResolvedToken;
         }
         const storedToken = normalizeToken(await store.get());
         if (!storedToken) {
+            lastResolvedToken = null;
             return null;
         }
-        return {
+        lastResolvedToken = {
             token: storedToken,
             tokenSource: backend,
         };
+        return lastResolvedToken;
     }
     const loginCommand = defineCommand({
         name: "login",
@@ -122,7 +126,12 @@ export function bearerTokenAuth(options) {
             }
             throw new UserError(`Run '${commandPrefix} login' first.`);
         },
-        async invalidate() {
+        async invalidate(token) {
+            if (token !== undefined &&
+                lastResolvedToken?.token === token &&
+                lastResolvedToken.tokenSource.startsWith("env (")) {
+                return;
+            }
             await store.delete();
         },
         commands: [defineGroup({

package/dist/auth/types.d.ts

@@ -1,7 +1,7 @@
 import type { CommandNode } from "toolcraft";
 export interface TokenSource {
     getToken(): Promise<string>;
-    invalidate?(): Promise<void>;
+    invalidate?(token?: string): Promise<void>;
 }
 export interface CommandContributor {
     commands: CommandNode<any>[];

package/dist/bin/generate.d.ts

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 interface GenerateCliFileSystem {
+    lstat(targetPath: string): Promise<{
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+    }>;
     mkdir(directoryPath: string, options?: {
         recursive?: boolean;
     }): Promise<unknown>;
@@ -8,9 +12,7 @@ interface GenerateCliFileSystem {
     rm(targetPath: string, options?: {
         force?: boolean;
     }): Promise<void>;
-    stat(targetPath: string): Promise<{
-        isDirectory(): boolean;
-    }>;
+    realpath(targetPath: string): Promise<string>;
     writeFile(filePath: string, contents: string, encoding: BufferEncoding): Promise<void>;
 }
 interface GenerateCliWriter {
@@ -26,7 +28,6 @@ interface GenerateCliServices {
 interface GenerateCliOptions {
     check: boolean;
     input: string;
-    lockPath: string;
     outputDir: string;
 }
 interface SyncGeneratedClientResult {

package/dist/bin/generate.js

@@ -6,12 +6,10 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { UserError } from "toolcraft";
 import { generate } from "../generate.js";
-import { readOpenApiLock, writeOpenApiLock } from "../lock.js";
 import { parseOpenApiDocument, readOpenApiSourceText } from "../spec-source.js";
 const DEFAULT_OPTIONS = {
     check: false,
     input: "openapi.json",
-    lockPath: "openapi.lock",
     outputDir: "src/generated"
 };
 const HELP_TEXT = `Usage: toolcraft-openapi-generate [options]
@@ -19,8 +17,7 @@ const HELP_TEXT = `Usage: toolcraft-openapi-generate [options]
 Options:
   --input <path-or-url>  OpenAPI document to read (default: openapi.json)
   --output <dir>         Directory for generated command files (default: src/generated)
-  --lock <path>          Lock file path (default: openapi.lock)
-  --check                Exit non-zero if generated output or lock file would change
+  --check                Exit non-zero if generated output would change
   -h, --help             Show this help text
 `;
 export async function runGenerateCli(argv = process.argv, services = {
@@ -73,8 +70,6 @@ export async function syncGeneratedClient(options, services) {
     const document = parseOpenApiDocument(sourceText, options.input);
     const generatedFiles = generate(document, { specSha });
     const outputDir = path.resolve(services.cwd, options.outputDir);
-    const lockPath = path.resolve(services.cwd, options.lockPath);
-    const currentLock = await readOpenApiLock(services.fs, lockPath);
     const currentFiles = await readGeneratedFiles(services.fs, outputDir);
     const desiredFiles = new Map([
         ...generatedFiles.map((file) => [path.resolve(outputDir, file.path), file.contents]),
@@ -82,11 +77,16 @@ export async function syncGeneratedClient(options, services) {
     ]);
     const updatedFiles = collectUpdatedFiles(currentFiles, desiredFiles);
     const deletedFiles = collectDeletedFiles(currentFiles, desiredFiles);
-    const drifted = currentLock?.specSha !== specSha || updatedFiles.length > 0 || deletedFiles.length > 0;
+    const drifted = updatedFiles.length > 0 || deletedFiles.length > 0;
     if (!options.check && drifted) {
-        await writeGeneratedFiles(services.fs, updatedFiles);
-        await deleteGeneratedFiles(services.fs, deletedFiles);
-        await writeOpenApiLock(services.fs, lockPath, { specSha });
+        try {
+            await writeGeneratedFiles(services.fs, outputDir, updatedFiles);
+            await deleteGeneratedFiles(services.fs, outputDir, deletedFiles);
+        }
+        catch (error) {
+            await restoreGeneratedFiles(services.fs, outputDir, currentFiles, updatedFiles, deletedFiles);
+            throw error;
+        }
     }
     return {
         drifted,
@@ -106,7 +106,7 @@ function parseGenerateCliArgs(argv) {
             options.check = true;
             continue;
         }
-        if (argument === "--input" || argument === "--output" || argument === "--lock") {
+        if (argument === "--input" || argument === "--output") {
             const value = argv[index + 1];
             if (value === undefined) {
                 throw new UserError(`Missing value for ${JSON.stringify(argument)}.`);
@@ -123,10 +123,6 @@ function parseGenerateCliArgs(argv) {
             assignOptionValue(options, "--output", argument.slice("--output=".length));
             continue;
         }
-        if (argument.startsWith("--lock=")) {
-            assignOptionValue(options, "--lock", argument.slice("--lock=".length));
-            continue;
-        }
         throw new UserError(`Unknown argument ${JSON.stringify(argument)}.`);
     }
     return options;
@@ -139,11 +135,7 @@ function assignOptionValue(options, argument, value) {
         options.input = value;
         return;
     }
-    if (argument === "--output") {
-        options.outputDir = value;
-        return;
-    }
-    options.lockPath = value;
+    options.outputDir = value;
 }
 function createSpecSha(sourceText) {
     return `sha256:${createHash("sha256").update(sourceText).digest("hex")}`;
@@ -178,10 +170,17 @@ function tryParseUrl(input) {
 async function readGeneratedFiles(fs, directoryPath) {
     const files = new Map();
     try {
+        const directoryStats = await fs.lstat(directoryPath);
+        if (directoryStats.isSymbolicLink()) {
+            throw new Error("Generated output must remain inside the output directory.");
+        }
         const entries = await fs.readdir(directoryPath);
         for (const entry of entries) {
             const entryPath = path.resolve(directoryPath, entry);
-            const stats = await fs.stat(entryPath);
+            const stats = await fs.lstat(entryPath);
+            if (stats.isSymbolicLink()) {
+                throw new Error("Generated output must remain inside the output directory.");
+            }
             if (stats.isDirectory()) {
                 for (const [nestedPath, nestedContents] of await readGeneratedFiles(fs, entryPath)) {
                     files.set(nestedPath, nestedContents);
@@ -218,17 +217,52 @@ function collectDeletedFiles(currentFiles, desiredFiles) {
     }
     return deletedFiles;
 }
-async function writeGeneratedFiles(fs, filesToWrite) {
+async function writeGeneratedFiles(fs, outputDir, filesToWrite) {
     for (const file of filesToWrite) {
         await fs.mkdir(path.dirname(file.path), { recursive: true });
+        await assertSafeOutputPath(fs, outputDir, file.path);
         await fs.writeFile(file.path, file.contents, "utf8");
     }
 }
-async function deleteGeneratedFiles(fs, filePaths) {
+async function assertSafeOutputPath(fs, outputDir, filePath) {
+    const canonicalOutputDir = await fs.realpath(outputDir);
+    const canonicalFileParent = await fs.realpath(path.dirname(filePath));
+    const relativeParentPath = path.relative(canonicalOutputDir, canonicalFileParent);
+    if (relativeParentPath === ".." ||
+        relativeParentPath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeParentPath) ||
+        canonicalOutputDir !== path.resolve(outputDir)) {
+        throw new Error("Generated output must remain inside the output directory.");
+    }
+}
+async function deleteGeneratedFiles(fs, outputDir, filePaths) {
     for (const filePath of filePaths) {
+        await assertSafeOutputPath(fs, outputDir, filePath);
         await fs.rm(filePath, { force: true });
     }
 }
+async function restoreGeneratedFiles(fs, outputDir, currentFiles, updatedFiles, deletedFiles) {
+    for (const file of updatedFiles) {
+        const previousContents = currentFiles.get(file.path);
+        if (previousContents === undefined) {
+            await assertSafeOutputPath(fs, outputDir, file.path);
+            await fs.rm(file.path, { force: true });
+            continue;
+        }
+        await fs.mkdir(path.dirname(file.path), { recursive: true });
+        await assertSafeOutputPath(fs, outputDir, file.path);
+        await fs.writeFile(file.path, previousContents, "utf8");
+    }
+    for (const filePath of deletedFiles) {
+        const previousContents = currentFiles.get(filePath);
+        if (previousContents === undefined) {
+            continue;
+        }
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await assertSafeOutputPath(fs, outputDir, filePath);
+        await fs.writeFile(filePath, previousContents, "utf8");
+    }
+}
 function isNotFoundError(error) {
     return (typeof error === "object" &&
         error !== null &&

package/dist/generate.js

@@ -751,7 +751,7 @@ function isEnumPrimitiveValue(value) {
     return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
 function isOpenApiScalarType(type) {
-    return typeof type === "string" && type in SCHEMA_TYPE_TO_KIND;
+    return typeof type === "string" && Object.prototype.hasOwnProperty.call(SCHEMA_TYPE_TO_KIND, type);
 }
 function expectRequestBody(document, requestBody, operationId, context, refChain = []) {
     if (!isReferenceObject(requestBody)) {
@@ -931,7 +931,8 @@ function getOperationAuthMode(document, operation, operationId) {
     const definedSchemes = document.components?.securitySchemes;
     for (const requirement of security ?? []) {
         for (const schemeName of Object.keys(requirement)) {
-            if (definedSchemes !== undefined && schemeName in definedSchemes) {
+            if (definedSchemes !== undefined &&
+                Object.prototype.hasOwnProperty.call(definedSchemes, schemeName)) {
                 continue;
             }
             throw new UserError(`Operation ${JSON.stringify(operationId)} references undefined security scheme ${JSON.stringify(schemeName)} in ${securityScope} security. Expected components.securitySchemes to define it.`);
@@ -1001,6 +1002,9 @@ function renderConstArray(values) {
     return `${JSON.stringify(values)} as const`;
 }
 function renderObjectKey(name) {
+    if (name === "__proto__") {
+        return `[${JSON.stringify(name)}]`;
+    }
     if (name === normalizeParamName(name) && isIdentifierName(name)) {
         return name;
     }

package/dist/http.js

@@ -1,6 +1,7 @@
 import { text as designText } from "@poe-code/design-system";
 import { UserError } from "toolcraft";
 import { classifyNetworkError } from "./network-error.js";
+import { redactHeaders, redactHeaderValue, redactSensitiveQueryValues } from "./redaction.js";
 const TRANSCRIPT_BODY_BYTE_LIMIT = 4 * 1024;
 export class HttpError extends Error {
     status;
@@ -29,7 +30,7 @@ export async function requestJson(options) {
     const headers = createHeaders(token, hasBody);
     const writeStdout = options.writeStdout ?? process.stdout.write.bind(process.stdout);
     const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
-    const requestLine = `${method} ${url}`;
+    const requestLine = `${method} ${redactSensitiveQueryValues(url)}`;
     if (options.dryRun) {
         writeStdout(formatDryRunOutput(requestLine, headers, options.body));
         return undefined;
@@ -52,7 +53,7 @@ export async function requestJson(options) {
     const text = await response.text();
     const contentType = response.headers.get("content-type");
     const request = createHttpErrorRequest(method, url, headers, options.body);
-    const responseHeaders = serializeHeaders(response.headers);
+    const responseHeaders = redactHeaders(serializeHeaders(response.headers));
     if (response.ok) {
         if (text.length === 0) {
             if (options.verbose) {
@@ -75,14 +76,32 @@ export async function requestJson(options) {
                 message: `Expected a JSON response body but received content-type ${JSON.stringify(contentType ?? "<missing>")}.`
             });
         }
-        const body = JSON.parse(text);
+        let body;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            if (options.verbose) {
+                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
+            }
+            throw new HttpError({
+                request,
+                response: {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: responseHeaders,
+                    body: text
+                },
+                message: "Expected a valid JSON response body but received malformed JSON."
+            });
+        }
         if (options.verbose) {
             writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
         }
         return body;
     }
-    if (response.status === 401) {
-        await options.tokenSource.invalidate?.();
+    if (response.status === 401 && options.auth === "required") {
+        await options.tokenSource.invalidate?.(token).catch(() => undefined);
     }
     const body = parseResponseBody(text, contentType);
     if (options.verbose) {
@@ -113,7 +132,9 @@ function buildRequestUrl(options) {
 }
 function substitutePathParams(path, pathParams) {
     const resolvedPath = path.replace(/\{([^}]+)\}/g, (_match, key) => {
-        const value = pathParams?.[key];
+        const value = pathParams !== undefined && Object.prototype.hasOwnProperty.call(pathParams, key)
+            ? pathParams[key]
+            : undefined;
         if (value === undefined) {
             throw new UserError(`Missing path parameter "${key}".`);
         }
@@ -142,7 +163,7 @@ function createHeaders(token, hasBody) {
 function createHttpErrorRequest(method, url, headers, body) {
     return {
         method,
-        url,
+        url: redactSensitiveQueryValues(url),
         headers: redactHeaders(headers),
         ...(body === undefined ? {} : { body })
     };
@@ -150,15 +171,6 @@ function createHttpErrorRequest(method, url, headers, body) {
 function serializeHeaders(headers) {
     return Object.fromEntries(headers.entries());
 }
-function redactHeaders(headers) {
-    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, redactHeaderValue(key, value)]));
-}
-function redactHeaderValue(key, value) {
-    if (key.toLowerCase() === "authorization" && value.startsWith("Bearer ")) {
-        return "Bearer ****";
-    }
-    return value;
-}
 function formatDryRunOutput(requestLine, headers, body) {
     const lines = [
         requestLine,
@@ -175,7 +187,7 @@ function formatDryRunOutput(requestLine, headers, body) {
 }
 function formatVerboseRequestTranscript(method, url, headers, body) {
     const lines = [
-        `→ ${method} ${url}`,
+        `→ ${method} ${redactSensitiveQueryValues(url)}`,
         ...Object.entries(headers).map(([key, value]) => {
             const headerValue = redactHeaderValue(key, value);
             return `    ${key}: ${headerValue}`;

package/dist/interpreter.js

@@ -8,7 +8,7 @@ const QUERY_ARRAY_SERIALIZATION_SEPARATORS = {
 const VALUE_REFERENCE_OPERATIONS = {
     param: {
         render: (reference) => renderParamAccess(reference.paramName),
-        evaluate: (reference, context) => context.params[reference.paramName]
+        evaluate: (reference, context) => readOwnParam(context.params, reference.paramName)
     },
     resolved: {
         render: (reference) => reference.resolvedName,
@@ -168,7 +168,7 @@ const REQUEST_SECTION_OPERATIONS = {
             if (!optional) {
                 return [
                     `      ${section.key}: {`,
-                    ...sectionFields.map((field) => `        ${JSON.stringify(field.wireName)}: ${renderValueExpression(field.value)},`),
+                    ...sectionFields.map((field) => `        ${renderWireName(field.wireName)}: ${renderValueExpression(field.value)},`),
                     "      },"
                 ];
             }
@@ -177,7 +177,7 @@ const REQUEST_SECTION_OPERATIONS = {
                 "        ? {}",
                 "        : {",
                 `            ${section.key}: {`,
-                ...sectionFields.map((field) => `              ${JSON.stringify(field.wireName)}: ${renderValueExpression(field.value)},`),
+                ...sectionFields.map((field) => `              ${renderWireName(field.wireName)}: ${renderValueExpression(field.value)},`),
                 "            },",
                 "          }),"
             ];
@@ -285,5 +285,14 @@ function renderOmitWhenUndefinedExpression(reference) {
     return `${renderValueReference(reference)} === undefined`;
 }
 function renderParamAccess(name) {
+    if (Object.prototype.hasOwnProperty.call(Object.prototype, name)) {
+        return `(Object.prototype.hasOwnProperty.call(params, ${JSON.stringify(name)}) ? params[${JSON.stringify(name)}] : undefined)`;
+    }
     return isIdentifierName(name) ? `params.${name}` : `params[${JSON.stringify(name)}]`;
 }
+function renderWireName(name) {
+    return name === "__proto__" ? `[${JSON.stringify(name)}]` : JSON.stringify(name);
+}
+function readOwnParam(params, name) {
+    return Object.prototype.hasOwnProperty.call(params, name) ? params[name] : undefined;
+}

package/dist/mock/fetch.js

@@ -302,17 +302,26 @@ function validateAgainstSchema(value, schema, document, pointer) {
         return errors;
     }
     if (types.includes("object") && typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const objectValue = value;
         for (const required of resolved.required ?? []) {
-            if (!(required in value)) {
+            if (!Object.prototype.hasOwnProperty.call(objectValue, required)) {
                 errors.push(`${pointer}/${required}: required`);
             }
         }
         if (resolved.properties !== undefined) {
-            for (const [key, propValue] of Object.entries(value)) {
+            for (const [key, propValue] of Object.entries(objectValue)) {
                 const propSchema = resolved.properties[key];
                 if (propSchema !== undefined) {
                     errors.push(...validateAgainstSchema(propValue, propSchema, document, `${pointer}/${key}`));
                 }
+                else if (resolved.additionalProperties === false) {
+                    errors.push(`${pointer}/${key}: additional property not allowed`);
+                }
+            }
+        }
+        else if (resolved.additionalProperties === false && Object.keys(objectValue).length > 0) {
+            for (const key of Object.keys(objectValue)) {
+                errors.push(`${pointer}/${key}: additional property not allowed`);
             }
         }
     }
@@ -393,20 +402,28 @@ function appendHeaders(target, source) {
     }
     if (source instanceof Headers) {
         source.forEach((value, key) => {
-            target[key.toLowerCase()] = value;
+            setHeader(target, key, value);
         });
         return;
     }
     if (Array.isArray(source)) {
         for (const [key, value] of source) {
-            target[key.toLowerCase()] = value;
+            setHeader(target, key, value);
         }
         return;
     }
     for (const [key, value] of Object.entries(source)) {
-        target[key.toLowerCase()] = String(value);
+        setHeader(target, key, String(value));
     }
 }
+function setHeader(target, key, value) {
+    Object.defineProperty(target, key.toLowerCase(), {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value
+    });
+}
 async function readRequestBody(input, init) {
     if (init?.body !== undefined && init.body !== null) {
         return typeof init.body === "string" ? init.body : await new Response(init.body).text();

package/dist/network-error.js

@@ -1,13 +1,15 @@
 import { UserError } from "toolcraft";
+import { redactSensitiveQueryValues } from "./redaction.js";
 export function classifyNetworkError(error, url) {
     const networkError = findNetworkError(error);
     const urlParts = new URL(url);
     const host = getHost(networkError, urlParts);
+    const redactedUrl = redactSensitiveQueryValues(url);
     switch (networkError?.code) {
         case "ECONNREFUSED":
             return new UserError(`Connection refused: ${host}:${getPort(networkError, urlParts)}. Is the server running?`, { cause: error });
         case "ETIMEDOUT":
-            return new UserError(`Request timed out after ${getTimeoutMs(networkError)}ms: ${url}.`, {
+            return new UserError(`Request timed out after ${getTimeoutMs(networkError)}ms: ${redactedUrl}.`, {
                 cause: error
             });
         case "ENOTFOUND":
@@ -24,10 +26,10 @@ export function classifyNetworkError(error, url) {
             });
     }
     if (findAbortError(error) !== null) {
-        return new UserError(`Request aborted: ${url}.`, { cause: error });
+        return new UserError(`Request aborted: ${redactedUrl}.`, { cause: error });
     }
     if (error instanceof TypeError && error.message === "fetch failed" && !hasCause(error)) {
-        return new UserError(`Network request failed: ${url}.`, { cause: error });
+        return new UserError(`Network request failed: ${redactedUrl}.`, { cause: error });
     }
     return null;
 }

package/dist/redaction.d.ts

@@ -0,0 +1,3 @@
+export declare function redactHeaders(headers: Record<string, string>): Record<string, string>;
+export declare function redactHeaderValue(key: string, value: string): string;
+export declare function redactSensitiveQueryValues(url: string): string;

package/dist/redaction.js

@@ -0,0 +1,38 @@
+const SENSITIVE_QUERY_KEYS = new Set([
+    "apikey",
+    "accesstoken",
+    "authtoken",
+    "clientsecret",
+    "key",
+    "password",
+    "secret",
+    "sig",
+    "signature",
+    "token"
+]);
+const SENSITIVE_HEADER_NAMES = new Set(["cookie", "proxy-authorization", "set-cookie"]);
+export function redactHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, redactHeaderValue(key, value)]));
+}
+export function redactHeaderValue(key, value) {
+    const normalizedKey = key.toLowerCase();
+    if (normalizedKey === "authorization") {
+        return value.startsWith("Bearer ") ? "Bearer ****" : "****";
+    }
+    if (SENSITIVE_HEADER_NAMES.has(normalizedKey)) {
+        return "****";
+    }
+    return value;
+}
+export function redactSensitiveQueryValues(url) {
+    const redactedUrl = new URL(url);
+    for (const key of redactedUrl.searchParams.keys()) {
+        if (SENSITIVE_QUERY_KEYS.has(normalizeQueryKey(key))) {
+            redactedUrl.searchParams.set(key, "****");
+        }
+    }
+    return redactedUrl.toString();
+}
+function normalizeQueryKey(key) {
+    return key.toLowerCase().replaceAll("_", "").replaceAll("-", "");
+}

package/node_modules/@poe-code/design-system/dist/acp/components.js

@@ -18,7 +18,9 @@ const KIND_COLORS = {
     other: (text) => color.dim(text)
 };
 function colorForKind(kind) {
-    return KIND_COLORS[kind] ?? ((text) => color.dim(text));
+    return Object.prototype.hasOwnProperty.call(KIND_COLORS, kind)
+        ? KIND_COLORS[kind]
+        : (text) => color.dim(text);
 }
 function writeLine(line) {
     getAcpWriter()(line);

package/node_modules/@poe-code/design-system/dist/components/browser.d.ts

@@ -1,6 +1,6 @@
 interface BrowserProcess {
     once(event: "error", listener: (error: Error) => void): this;
-    once(event: "spawn", listener: () => void): this;
+    once(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
     unref(): void;
 }
 type SpawnBrowserProcess = (command: string, args: string[], options: {

package/node_modules/@poe-code/design-system/dist/components/browser.js

@@ -18,7 +18,12 @@ function launchBrowser(command, args, spawnProcess) {
     return new Promise((resolve, reject) => {
         const child = spawnProcess(command, args, { detached: true, stdio: "ignore" });
         child.once("error", reject);
-        child.once("spawn", () => {
+        child.once("close", (code, signal) => {
+            if (code !== 0) {
+                const reason = code === null ? `signal ${signal ?? "unknown"}` : `code ${code}`;
+                reject(new Error(`Browser launcher exited with ${reason}`));
+                return;
+            }
             child.unref();
             resolve();
         });

package/node_modules/@poe-code/design-system/dist/components/color.js

@@ -48,6 +48,10 @@ function hexChannel(value, offset) {
 }
 function normalizeHex(value) {
     const normalized = value.startsWith("#") ? value.slice(1) : value;
+    if ((normalized.length !== 3 && normalized.length !== 6) ||
+        Array.from(normalized).some((char) => !"0123456789abcdefABCDEF".includes(char))) {
+        throw new Error(`Invalid hexadecimal color: ${value}`);
+    }
     if (normalized.length === 3) {
         const red = normalized[0];
         const green = normalized[1];
@@ -58,14 +62,11 @@ function normalizeHex(value) {
             Number.parseInt(`${blue}${blue}`, 16)
         ];
     }
-    if (normalized.length === 6) {
-        return [
-            hexChannel(normalized, 0),
-            hexChannel(normalized, 2),
-            hexChannel(normalized, 4)
-        ];
-    }
-    return [0, 0, 0];
+    return [
+        hexChannel(normalized, 0),
+        hexChannel(normalized, 2),
+        hexChannel(normalized, 4)
+    ];
 }
 function rgbStyle(red, green, blue) {
     return {

package/node_modules/@poe-code/design-system/dist/components/command-errors.js

@@ -1,8 +1,9 @@
 import { typography } from "../tokens/typography.js";
 import { text } from "./text.js";
 export function formatCommandNotFound(input) {
-    const unknown = input.unknownCommand.length > 0
-        ? input.unknownCommand
+    const unknownInput = input.unknownCommand.replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+    const unknown = unknownInput.length > 0
+        ? unknownInput
         : "<command>";
     return {
         label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,