c64bridge 1.0.5 → 1.0.7

package/dist/mcp-server.js

@@ -18,6 +18,7 @@ import { unknownErrorResult } from "./tools/errors.js";
 import { createPromptRegistry } from "./prompts/registry.js";
 import { describePlatformCapabilities, getPlatformStatus, setPlatform } from "./platform.js";
 import axios from "axios";
+import { redactValue, registerSecret } from "./redact.js";
 import { loggerFor, payloadByteLength, formatPayloadForDebug, formatErrorMessage } from "./logger.js";
 import { getDiagnosticsSessionInfo, installProcessDiagnostics, withDiagnosticSpan, writeDiagnosticEvent } from "./diagnostics.js";
 const __filename = fileURLToPath(import.meta.url);
@@ -449,7 +450,7 @@ async function main() {
         writeDiagnosticEvent("mcp_transport_connected", { mode: "stdio" });
         console.error("c64bridge MCP server running on stdio");
     }
-    await logConnectivity(client, baseUrl);
+    await logConnectivity(client, baseUrl, config.networkPassword);
     writeDiagnosticEvent("server_ready", {
         diagnosticsFile: diagnostics.filePath,
     });
@@ -524,7 +525,11 @@ export async function renderPlatformStatusMarkdown(client) {
     lines.push("> Use `c64_select_backend` to switch to another available backend without restarting the MCP server.");
     return lines.join("\n");
 }
-async function logConnectivity(client, baseUrl) {
+/** URL of the Ultimate's /v1/info route, keeping any path prefix of the base URL (reverse proxy). */
+export function connectivityProbeUrl(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/v1/info`;
+}
+async function logConnectivity(client, baseUrl, networkPassword) {
     const backendType = await client.getBackendType();
     if (backendType === "vice") {
         writeDiagnosticEvent("connectivity_probe_skipped", { baseUrl, reason: "vice_backend" });
@@ -550,10 +555,15 @@ async function logConnectivity(client, baseUrl) {
     }
     const c64Logger = loggerFor("c64u");
     const startedAt = Date.now();
-    const infoUrl = new URL("/v1/info", baseUrl).toString();
+    const infoUrl = connectivityProbeUrl(baseUrl);
     let response = null;
     try {
-        const probeResponse = await axios.get(infoUrl, { timeout: 2000 });
+        // Send the network password like every other request, or a protected device answers 403.
+        registerSecret(networkPassword);
+        const probeResponse = await axios.get(infoUrl, {
+            timeout: 2000,
+            ...(networkPassword ? { headers: { "X-Password": networkPassword } } : {}),
+        });
         response = probeResponse;
         const latency = Date.now() - startedAt;
         const bytes = payloadByteLength(probeResponse.data);
@@ -598,13 +608,13 @@ async function logConnectivity(client, baseUrl) {
         console.error(`Zero-page probe skipped or failed (may be unsupported on current backend): ${message}`);
     }
 }
-function toCallToolResult(result) {
-    const base = { content: result.content };
+export function toCallToolResult(result) {
+    const base = { content: redactValue(result.content) };
     if (result.structuredContent !== undefined) {
-        base.structuredContent = result.structuredContent;
+        base.structuredContent = redactValue(result.structuredContent);
     }
     if (result.metadata !== undefined) {
-        base.metadata = result.metadata;
+        base.metadata = redactValue(result.metadata);
     }
     if (result.isError !== undefined) {
         base.isError = result.isError;
@@ -635,7 +645,7 @@ if (process.env.C64BRIDGE_SKIP_AUTO_START !== "1") {
             diagnosticsFile: getDiagnosticsSessionInfo()?.filePath,
             error,
         });
-        console.error("Fatal error in MCP server:", error);
+        console.error("Fatal error in MCP server:", redactValue(error));
         process.exit(1);
     });
 }

package/dist/petscii.js

@@ -137,11 +137,6 @@ const NAMED_CHARS = Object.freeze({
     "leftarrow": 95,
     "pi": 222,
 });
-export function listNamedPetscii() {
-    return Object.entries(NAMED_CHARS)
-        .sort((a, b) => a[0].localeCompare(b[0]))
-        .map(([name, code]) => ({ name, code, hex: `$${code.toString(16).toUpperCase().padStart(2, "0")}` }));
-}
 export function lookupNamedPetscii(name) {
     const key = name.trim().toLowerCase().replace(/\s+/g, "_");
     // Own keys only, so names like "constructor" don't resolve to Object.prototype members.

package/dist/redact.js

@@ -0,0 +1,166 @@
+/**
+ * Shared redaction for the Ultimate network password and other credentials.
+ *
+ * The password is meant to leave the process only as the `X-Password` request
+ * header. Every sink that can carry arbitrary values (console logging,
+ * diagnostics files, MCP tool results) passes its content through this module.
+ *
+ * Two mechanisms are combined:
+ * - values registered with `registerSecret` are replaced wherever they appear
+ *   inside a string, including error messages and stack traces;
+ * - properties whose name is a credential header are replaced regardless of value.
+ */
+const REDACTED = "***";
+const SENSITIVE_KEY = /^(x-password|authorization|proxy-authorization|cookie|set-cookie|x-api-key)$/i;
+const MIN_SECRET_LENGTH = 1;
+const secrets = new Set();
+export function registerSecret(value) {
+    if (typeof value === "string" && value.length >= MIN_SECRET_LENGTH) {
+        secrets.add(value);
+    }
+}
+/** Test hook: forget all registered secrets. */
+export function clearRegisteredSecrets() {
+    secrets.clear();
+}
+export function isSensitiveKey(key) {
+    return SENSITIVE_KEY.test(key);
+}
+export function redactText(text) {
+    let result = text;
+    // Longest first, so a secret that contains another one is replaced as a whole.
+    for (const secret of [...secrets].sort((a, b) => b.length - a.length)) {
+        if (result.includes(secret)) {
+            result = result.split(secret).join(REDACTED);
+        }
+    }
+    return result;
+}
+function isPlainObject(value) {
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Returns a copy of `value` that is safe to log, persist or return to a client.
+ * Errors (including Axios errors) are reduced to name, message, stack, code and
+ * HTTP status, so their request configuration is never copied.
+ */
+export function redactValue(value, seen = new WeakSet()) {
+    if (typeof value === "string") {
+        return redactText(value);
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (seen.has(value)) {
+        return "[Circular]";
+    }
+    if (value instanceof Error) {
+        seen.add(value);
+        const extra = value;
+        return {
+            name: value.name,
+            message: redactText(value.message),
+            ...(value.stack ? { stack: redactText(value.stack) } : {}),
+            ...(extra.code !== undefined ? { code: redactValue(extra.code, seen) } : {}),
+            ...(extra.response?.status !== undefined ? { status: extra.response.status } : {}),
+            ...(extra.cause !== undefined ? { cause: redactValue(extra.cause, seen) } : {}),
+        };
+    }
+    if (Array.isArray(value)) {
+        seen.add(value);
+        return value.map((entry) => redactValue(entry, seen));
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    seen.add(value);
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        redactText(key),
+        isSensitiveKey(key) ? REDACTED : redactValue(entry, seen),
+    ]));
+}
+function scrubHeaders(headers) {
+    if (!headers || typeof headers !== "object")
+        return;
+    for (const key of Object.keys(headers)) {
+        if (isSensitiveKey(key)) {
+            headers[key] = REDACTED;
+        }
+    }
+}
+function scrubRequestHolder(holder) {
+    if (!holder || typeof holder !== "object")
+        return;
+    const target = holder;
+    scrubHeaders(target.config?.headers);
+    // The raw ClientRequest keeps the serialized header block, including X-Password.
+    if (target.request !== undefined) {
+        target.request = undefined;
+    }
+}
+/**
+ * Removes credentials from a rejected Axios error in place and returns it, so
+ * callers that inspect, log or serialize the error cannot expose them.
+ * Status, code, message and response data stay available.
+ */
+export function scrubRequestError(error) {
+    if (!error || typeof error !== "object")
+        return error;
+    scrubRequestHolder(error);
+    const response = error.response;
+    scrubRequestHolder(response);
+    // A device that echoes the rejected password in its error body.
+    if (response && typeof response.data === "string") {
+        response.data = redactText(response.data);
+    }
+    return error;
+}
+/**
+ * Firmware configuration items that hold credentials. The Ultimate config API
+ * lists items by display name (for example "Network Password" in the
+ * "Network settings" category), so matching is by item name: passwords,
+ * passphrases and pre-shared keys, plus a bare "key" item in a Wi-Fi category.
+ */
+const SENSITIVE_CONFIG_ITEM = /pass(word|wd|phrase|code)?\b|\bpsk\b|secret/i;
+const WIFI_CATEGORY = /wi-?fi|wlan|wireless/i;
+const BARE_KEY_ITEM = /^(wifi |wlan )?(key|wpa key|network key)$/i;
+export function isSensitiveConfigItem(category, item) {
+    if (!item)
+        return false;
+    if (SENSITIVE_CONFIG_ITEM.test(item))
+        return true;
+    return BARE_KEY_ITEM.test(item.trim()) && (item.toLowerCase().includes("wifi") || WIFI_CATEGORY.test(category ?? ""));
+}
+/**
+ * Returns a copy of a firmware configuration response in which the value of
+ * every credential item is replaced with `***`. Item names stay, so a client can
+ * see that the item exists. `category` and `item` describe the request: when an
+ * item was requested and the response is its bare value, the value is replaced.
+ */
+export function redactConfigValue(value, category, item) {
+    if (item && isSensitiveConfigItem(category, item)) {
+        return value !== null && typeof value === "object" ? redactConfigTree(value, category) : REDACTED;
+    }
+    return redactConfigTree(value, category);
+}
+function redactConfigTree(value, category) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => redactConfigTree(entry, category));
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (isSensitiveConfigItem(category, key) && entry !== null && entry !== undefined) {
+            out[key] = REDACTED;
+        }
+        else {
+            // Keys at the top level of a response are category names.
+            out[key] = redactConfigTree(entry, entry !== null && typeof entry === "object" && !Array.isArray(entry) ? key : category);
+        }
+    }
+    return out;
+}
+export const REDACTED_PLACEHOLDER = REDACTED;