c64bridge 1.0.6 → 1.1.0

package/dist/logger.js

@@ -1,4 +1,5 @@
 import { Buffer } from "node:buffer";
+import { redactText, redactValue } from "./redact.js";
 const LEVEL_ORDER = {
     debug: 0,
     info: 1,
@@ -24,9 +25,9 @@ function createPrefixedLogger(prefix) {
             return;
         }
         const consoleMethod = selectConsole(level);
-        const label = `[${prefix}] ${message}`;
+        const label = `[${prefix}] ${redactText(message)}`;
         if (details && Object.keys(details).length > 0) {
-            consoleMethod(label, details);
+            consoleMethod(label, redactValue(details));
         }
         else {
             consoleMethod(label);

package/dist/loggingHttpClient.js

@@ -1,4 +1,5 @@
 import { HttpClient } from "../generated/c64/index.js";
+import { registerSecret, scrubRequestError } from "./redact.js";
 import { formatErrorMessage, formatPayloadForDebug, loggerFor, payloadByteLength } from "./logger.js";
 /** Headers are useful in diagnostics, but credentials must never leave the
  * transport layer.  Axios normalises some keys and preserves others, so do a
@@ -12,8 +13,55 @@ function redactHeaders(headers) {
         sensitive.test(key) ? "***" : value,
     ]));
 }
-export function createLoggingHttpClient(config, logger = loggerFor("c64u")) {
+/**
+ * First-in first-out gate that lets one operation run at a time. The Ultimate
+ * firmware serves REST requests on a single thread, so every request to one
+ * device goes through one queue. A failed operation releases the gate like a
+ * successful one, so the queue cannot deadlock.
+ */
+export class RequestQueue {
+    constructor() {
+        this.tail = Promise.resolve();
+    }
+    /** The shared queue for one device base URL, so every client of that device (backends, fallback clients) waits in the same line. */
+    static forDevice(baseUrl) {
+        const key = baseUrl.replace(/\/+$/, "").toLowerCase();
+        let queue = RequestQueue.byDevice.get(key);
+        if (!queue) {
+            queue = new RequestQueue();
+            RequestQueue.byDevice.set(key, queue);
+        }
+        return queue;
+    }
+    /** Resolves when all earlier holders have released; call the returned function exactly once. */
+    async acquire() {
+        let release;
+        const held = new Promise((resolve) => { release = resolve; });
+        const previous = this.tail;
+        this.tail = previous.then(() => held);
+        await previous;
+        let released = false;
+        return () => {
+            if (!released) {
+                released = true;
+                release();
+            }
+        };
+    }
+    async run(operation) {
+        const release = await this.acquire();
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+}
+RequestQueue.byDevice = new Map();
+export function createLoggingHttpClient(config, logger = loggerFor("c64u"), queue) {
     const http = new HttpClient(config);
+    registerSecret(readPasswordHeader(config?.headers));
     http.instance.interceptors.request.use((request) => {
         const method = (request.method ?? "get").toUpperCase();
         const path = resolvePath(request);
@@ -28,15 +76,36 @@ export function createLoggingHttpClient(config, logger = loggerFor("c64u")) {
         request.__c64Meta = meta;
         return request;
     });
+    if (queue) {
+        // The generated client sends every request through `instance.request`, so
+        // the gate is taken around that call. Interceptors, request transforms and
+        // the adapter all run inside it: the start time is recorded after the wait,
+        // the request timeout (started by the adapter) does not include the wait,
+        // and the gate is released however the request settles, including a
+        // failure before the adapter is called (for example a body that cannot be
+        // serialised).
+        const instance = http.instance;
+        const sendRequest = instance.request.bind(instance);
+        instance.request = ((requestConfig) => queue.run(() => sendRequest(requestConfig)));
+    }
     http.instance.interceptors.response.use((response) => {
         handleResponse(response, logger);
         return response;
     }, (error) => {
         handleError(error, logger);
-        return Promise.reject(error);
+        return Promise.reject(scrubRequestError(error));
     });
     return http;
 }
+function readPasswordHeader(headers) {
+    if (!headers || typeof headers !== "object")
+        return undefined;
+    for (const [key, value] of Object.entries(headers)) {
+        if (/^x-password$/i.test(key) && typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
 function handleResponse(response, logger) {
     const meta = extractMeta(response.config);
     const latency = meta ? Date.now() - meta.startedAt : 0;