@fireemu/win32-x64 0.1.0

package/bin/runner-node/log-context.mjs

@@ -0,0 +1,128 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { format } from "node:util";
+
+const CONSOLE_LEVELS = Object.freeze({
+  log: "info",
+  info: "info",
+  debug: "debug",
+  warn: "error",
+  error: "error",
+});
+
+const TRUNCATION_MARKER = "... [truncated]";
+const STRUCTURED_SEVERITIES = new Set([
+  "DEBUG",
+  "INFO",
+  "NOTICE",
+  "WARNING",
+  "ERROR",
+  "CRITICAL",
+  "ALERT",
+  "EMERGENCY",
+]);
+const MAX_STRUCTURED_LOG_DEPTH = 64;
+
+// Cloud Logging documents an approximate 256 KiB limit for the whole LogEntry. Applying that
+// value conservatively to the message also leaves ample room below the 16 MiB protocol limit.
+export const MAX_LOG_MESSAGE_BYTES = 256 * 1024;
+
+export function boundLogMessage(value, maxBytes = MAX_LOG_MESSAGE_BYTES) {
+  const bytes = Buffer.from(String(value), "utf8");
+  // A UTF-8 round trip replaces lone UTF-16 surrogates while preserving valid pairs. Without
+  // this, JSON.stringify emits an escape that serde_json correctly refuses on the protocol side.
+  const message = bytes.toString("utf8");
+  if (bytes.length <= maxBytes) return message;
+  const marker = Buffer.from(TRUNCATION_MARKER, "utf8");
+  if (maxBytes <= marker.length) return marker.subarray(0, maxBytes).toString("utf8");
+  let end = maxBytes - marker.length;
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) end -= 1;
+  return `${bytes.subarray(0, end).toString("utf8")}${TRUNCATION_MARKER}`;
+}
+
+function hasUnpairedSurrogate(text) {
+  for (let index = 0; index < text.length; index += 1) {
+    const unit = text.charCodeAt(index);
+    if (unit >= 0xd800 && unit <= 0xdbff) {
+      const next = text.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) return true;
+      index += 1;
+    } else if (unit >= 0xdc00 && unit <= 0xdfff) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isSafeStructuredValue(root) {
+  const pending = [{ value: root, depth: 1 }];
+  while (pending.length > 0) {
+    const { value, depth } = pending.pop();
+    if (depth > MAX_STRUCTURED_LOG_DEPTH) return false;
+    if (typeof value === "string" && hasUnpairedSurrogate(value)) return false;
+    if (value && typeof value === "object") {
+      for (const [key, child] of Object.entries(value)) {
+        if (hasUnpairedSurrogate(key)) return false;
+        pending.push({ value: child, depth: depth + 1 });
+      }
+    }
+  }
+  return true;
+}
+
+function structuredEntry(message, fallbackLevel) {
+  try {
+    const parsed = JSON.parse(message);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { level: fallbackLevel, message };
+    }
+    const severity = typeof parsed?.severity === "string" ? parsed.severity.toUpperCase() : "";
+    if (!STRUCTURED_SEVERITIES.has(severity) || !isSafeStructuredValue(parsed)) {
+      return { level: fallbackLevel, message };
+    }
+    const { severity: _severity, message: structuredMessage, ...fields } = parsed;
+    return {
+      level: severity.toLowerCase(),
+      message: typeof structuredMessage === "string" ? structuredMessage : "",
+      fields,
+    };
+  } catch {
+    // Plain console output is not structured logging.
+  }
+  return { level: fallbackLevel, message };
+}
+
+export function createInvocationLogger(emit) {
+  const context = new AsyncLocalStorage();
+
+  return {
+    run(metadata, task) {
+      return context.run(metadata, task);
+    },
+    install(target = console) {
+      const originals = new Map();
+      for (const [method, level] of Object.entries(CONSOLE_LEVELS)) {
+        const original = target[method].bind(target);
+        originals.set(method, original);
+        target[method] = (...values) => {
+          const active = context.getStore();
+          if (!active?.functionName) {
+            original(...values);
+            return;
+          }
+          const message = boundLogMessage(format(...values));
+          const entry =
+            values.length === 1 ? structuredEntry(message, level) : { level, message };
+          emit({
+            ...entry,
+            functionName: active.functionName,
+            invocationId: active.invocationId,
+            user: true,
+          });
+        };
+      }
+      return () => {
+        for (const [method, original] of originals) target[method] = original;
+      };
+    },
+  };
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@fireemu/win32-x64",
+  "version": "0.1.0",
+  "description": "The fireemu daemon for win32-x64",
+  "homepage": "https://github.com/t-k/fireemu#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/t-k/fireemu.git"
+  },
+  "license": "Apache-2.0",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_LICENSES.txt"
+  ],
+  "preferUnplugged": true
+}