dsh-log 0.2.0

package/dist/host.js

@@ -0,0 +1,55 @@
+// AUTO-GENERATED by node packages/dsh-log/build.mjs — DO NOT EDIT. Source: packages/dsh-log/src/host.ts
+import {
+  buildPhoneNames
+} from "./config.js";
+import { createLogStore } from "./store.js";
+import { buildPhoneName, buildPhoneNames as buildPhoneNames2, resolveHostLogConfig } from "./config.js";
+import { parseEventListManifest, checkEventFields, checkEventCounts } from "./config.js";
+import {
+  LOG_DEBOUNCE_MS,
+  LOG_DIR_NAME,
+  LOG_SWITCH_FILE,
+  formatDailyFileName,
+  formatLogFileName,
+  createLogStore as createLogStore2
+} from "./store.js";
+function createHostLog(deps, configInput) {
+  const store = createLogStore(deps, configInput);
+  const phoneNames = buildPhoneNames(store.config.prefix);
+  return { store, phoneNames };
+}
+function registerHostLogPhones(registry, hostLog) {
+  const store = hostLog.store;
+  const handlers = {
+    logBatch: (args) => store.handleLogBatch(args),
+    logExport: (args) => store.handleLogExport(args),
+    logClear: (args) => store.handleLogClear(args),
+    logGetSwitch: () => store.handleLogGetSwitch(),
+    logSetSwitch: (args) => store.handleLogSetSwitch(args)
+  };
+  const actions = ["logBatch", "logExport", "logClear", "logGetSwitch", "logSetSwitch"];
+  for (const action of actions) {
+    const name = hostLog.phoneNames[action];
+    if (registry.has(name)) {
+      throw new Error("[dsh-log] \u7535\u8BDD\u540D\u5DF2\u88AB\u6CE8\u518C\uFF0C\u4E0D\u8986\u76D6\u65E7\u7684\uFF1A" + name);
+    }
+    registry.set(name, handlers[action]);
+  }
+  return hostLog.phoneNames;
+}
+export {
+  LOG_DEBOUNCE_MS,
+  LOG_DIR_NAME,
+  LOG_SWITCH_FILE,
+  buildPhoneName,
+  buildPhoneNames2 as buildPhoneNames,
+  checkEventCounts,
+  checkEventFields,
+  createHostLog,
+  createLogStore2 as createLogStore,
+  formatDailyFileName,
+  formatLogFileName,
+  parseEventListManifest,
+  registerHostLogPhones,
+  resolveHostLogConfig
+};

package/dist/node.js

@@ -0,0 +1,124 @@
+// AUTO-GENERATED by node packages/dsh-log/build.mjs — DO NOT EDIT. Source: packages/dsh-log/src/node.ts
+import { readFile, readdir, mkdir, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createHostLog } from "./host.js";
+import { logFileNamePattern } from "./config.js";
+function resolvePath(pathStr) {
+  return Promise.resolve({ path: String(pathStr) });
+}
+function targetPath(target) {
+  if (target && typeof target === "object" && typeof target.path === "string") {
+    return target.path;
+  }
+  return String(target);
+}
+function createNodeFileService() {
+  return {
+    resolve: resolvePath,
+    async readText(target) {
+      try {
+        return await readFile(targetPath(target), "utf8");
+      } catch (e) {
+        if (e && e.code === "ENOENT") return "";
+        throw e;
+      }
+    },
+    async writeText(target, text) {
+      const target2 = targetPath(target);
+      await mkdir(dirname(target2), { recursive: true });
+      await writeFile(target2, text, "utf8");
+    },
+    async mkdir(dir) {
+      await mkdir(String(dir), { recursive: true });
+    },
+    async unlink(target) {
+      try {
+        await unlink(targetPath(target));
+      } catch (e) {
+        if (e && e.code === "ENOENT") return;
+        throw e;
+      }
+    },
+    async listDir(target) {
+      try {
+        return await readdir(targetPath(target));
+      } catch (e) {
+        if (e && e.code === "ENOENT") return [];
+        throw e;
+      }
+    }
+  };
+}
+function createNodeTimer() {
+  return {
+    timeout: (fn, ms) => setTimeout(fn, ms)
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+async function markerLanded(store, cacheDir, marker) {
+  try {
+    const logDir = join(cacheDir, store.config.logDirName);
+    const pattern = logFileNamePattern(store.config);
+    const names = await readdir(logDir);
+    for (const name of names) {
+      if (!pattern.test(name)) continue;
+      const text = await readFile(join(logDir, name), "utf8");
+      if (text.includes(`"event":"${marker}"`)) return true;
+    }
+    return false;
+  } catch (e) {
+    void e;
+    return false;
+  }
+}
+async function createNodeHostLog(deps, configInput) {
+  if (!deps || typeof deps.cacheDir !== "string" || deps.cacheDir === "") {
+    throw new Error("[dsh-log] \u5EFA Node \u65E5\u5FD7\u5E93\u5FC5\u987B\u7ED9 cacheDir\uFF1A\u65E5\u5FD7\u5199\u5230\u54EA\u7531\u8C03\u7528\u65B9\u51B3\u5B9A\uFF0C\u672C\u5165\u53E3\u4E0D\u731C\u4F4D\u7F6E");
+  }
+  const cacheDir = deps.cacheDir;
+  const fs = deps.fs ?? createNodeFileService();
+  const timer = deps.timer ?? createNodeTimer();
+  const joinPath = deps.joinPath ?? ((...parts) => join(...parts));
+  await mkdir(cacheDir, { recursive: true });
+  const hostLog = createHostLog(
+    { fs, timer, getCacheDir: () => cacheDir, DEFAULT_CWD: cacheDir },
+    configInput
+  );
+  const store = hostLog.store;
+  try {
+    await store.loadSwitch();
+  } catch (e) {
+    void e;
+  }
+  const ready = (async () => {
+    const marker = "log.flush.marker";
+    let flushed = false;
+    try {
+      store.log("debug", marker, {});
+      flushed = true;
+    } catch (e) {
+      void e;
+    }
+    for (let pass = 0; pass < 6; pass++) {
+      try {
+        if (typeof store.flushNow === "function") await store.flushNow();
+        else store.flush();
+      } catch (e) {
+        void e;
+      }
+      if (!flushed) return;
+      if (await markerLanded(hostLog.store, cacheDir, marker)) return;
+      await delay(10);
+    }
+  })();
+  return { store: hostLog.store, phoneNames: hostLog.phoneNames, ready };
+}
+export {
+  createNodeFileService,
+  createNodeHostLog,
+  createNodeTimer
+};

package/dist/phones.js

@@ -0,0 +1,266 @@
+// AUTO-GENERATED by node packages/dsh-log/build.mjs — DO NOT EDIT. Source: packages/dsh-log/src/phones.ts
+import {
+  formatDailyFileName,
+  resolveLogFileName,
+  matchExportFileName,
+  logFileNamePattern
+} from "./config.js";
+function hash8(s) {
+  try {
+    const t = String(s || "");
+    let h = 5381;
+    for (let i = 0; i < t.length; i++) h = (h << 5) + h + t.charCodeAt(i) >>> 0;
+    return ("0000000" + h.toString(16)).slice(-8);
+  } catch (e) {
+    void e;
+    return "00000000";
+  }
+}
+function targetToPath(t, fb) {
+  if (typeof t === "string") return t;
+  if (t && typeof t === "object") {
+    const c = t.displayPath || t.path;
+    if (typeof c === "string" && c) return c;
+  }
+  return typeof fb === "string" && fb ? fb : "";
+}
+async function listFileNames(ctx, logDir) {
+  const { fs, getPlatform, resolveTarget } = ctx;
+  try {
+    const platform = typeof getPlatform === "function" ? await getPlatform() : null;
+    const listFn = platform && platform.fs && typeof platform.fs.listDir === "function" ? platform.fs.listDir.bind(platform.fs) : fs && typeof fs.listDir === "function" ? fs.listDir.bind(fs) : null;
+    if (!listFn) return [];
+    const dirTarget = await resolveTarget(logDir);
+    const entries = await listFn(dirTarget);
+    if (!Array.isArray(entries)) return [];
+    return entries.map((x) => typeof x === "string" ? x : x && typeof x.name === "string" ? x.name : "");
+  } catch (e) {
+    void e;
+    return [];
+  }
+}
+function createLogPhones(ctx) {
+  const config = ctx.config;
+  const filePattern = logFileNamePattern(config);
+  const pidOf = () => {
+    try {
+      if (typeof ctx.getPid === "function") return ctx.getPid();
+      const header = typeof ctx.getHeaderInfo === "function" ? ctx.getHeaderInfo() : null;
+      if (header && typeof header.pid === "number") return header.pid;
+      const g = globalThis;
+      return (g.process && typeof g.process.pid === "number" ? g.process.pid : 0) || 0;
+    } catch (e) {
+      void e;
+      return 0;
+    }
+  };
+  const startedAtOf = () => {
+    try {
+      if (typeof ctx.getStartedAt === "function") return ctx.getStartedAt();
+      const header = typeof ctx.getHeaderInfo === "function" ? ctx.getHeaderInfo() : null;
+      return header && header.startedAt || "";
+    } catch (e) {
+      void e;
+      return "";
+    }
+  };
+  async function handleLogExport(args) {
+    const headerInfo = typeof ctx.getHeaderInfo === "function" ? ctx.getHeaderInfo() : null;
+    const now = /* @__PURE__ */ new Date();
+    const fallbackFileName = resolveLogFileName(config, now, pidOf(), startedAtOf());
+    const want = args && args.date ? String(args.date) : formatDailyFileName(now).replace(/\.log$/, "");
+    void (args && args.format);
+    try {
+      const dir = typeof ctx.getCacheDir === "function" ? await ctx.getCacheDir() : null;
+      if (!dir) {
+        try {
+          ctx.log("warn", "host.call.fail", { method: config.prefix + ".logExport", kind: "export", errorHash: hash8("no-dir") });
+        } catch (eL) {
+          void eL;
+        }
+      }
+      const baseDir = dir || headerInfo && headerInfo.dir || ctx.DEFAULT_CWD || "";
+      const logDir = baseDir ? await ctx.joinLogPath(baseDir, config.logDirName) : "";
+      let fileName = fallbackFileName;
+      if (config.fileNamePolicy === "four-segment" && /^\d{4}-\d{2}-\d{2}$/.test(want) && logDir) {
+        const candidates = await listFileNames(ctx, logDir);
+        fileName = matchExportFileName(config, candidates, want, fallbackFileName);
+      } else if (config.fileNamePolicy !== "four-segment") {
+        fileName = /^\d{4}-\d{2}-\d{2}$/.test(want) ? want + ".log" : fallbackFileName;
+      }
+      let text = "";
+      try {
+        const target = await ctx.resolveTarget(await ctx.joinLogPath(logDir, fileName));
+        text = await ctx.readTarget(target);
+      } catch (e) {
+        void e;
+        text = "";
+      }
+      let osName = "";
+      try {
+        const platform = typeof ctx.getPlatform === "function" ? await ctx.getPlatform() : null;
+        const g = globalThis;
+        osName = platform && platform.os || (typeof g.process !== "undefined" ? String(g.process.platform) : "") || "";
+      } catch (e2) {
+        void e2;
+      }
+      let cwdNow = ctx.DEFAULT_CWD || "";
+      try {
+        const g = globalThis;
+        cwdNow = g.process && g.process.cwd ? g.process.cwd() : ctx.DEFAULT_CWD || "";
+      } catch (e3) {
+        void e3;
+      }
+      const summary = {
+        pluginVersion: "unknown",
+        os: osName,
+        cwd: cwdNow,
+        logSwitch: ctx.getSwitchState(),
+        header: headerInfo
+      };
+      let dirOut = logDir;
+      let pathOut = "";
+      try {
+        dirOut = targetToPath(await ctx.resolveTarget(logDir), logDir);
+        pathOut = targetToPath(await ctx.resolveTarget(await ctx.joinLogPath(logDir, fileName)), ctx.joinPath(logDir, fileName));
+      } catch (e4) {
+        void e4;
+        try {
+          pathOut = ctx.joinPath(logDir, fileName);
+        } catch (e5) {
+          void e5;
+          pathOut = "";
+        }
+      }
+      if (!dirOut && !pathOut && baseDir) {
+        try {
+          dirOut = ctx.joinPath(baseDir, config.logDirName);
+          pathOut = ctx.joinPath(dirOut, fileName);
+        } catch (e6) {
+          void e6;
+        }
+      }
+      return {
+        ok: true,
+        fileName,
+        bytes: String(text || "").length,
+        fallback: true,
+        text: String(text || ""),
+        summary,
+        dir: dirOut,
+        path: pathOut
+      };
+    } catch (e) {
+      try {
+        ctx.log("warn", "host.call.fail", {
+          method: config.prefix + ".logExport",
+          kind: "export",
+          errorHash: hash8(String(e && e.message || e))
+        });
+      } catch (eL) {
+        void eL;
+      }
+      return { ok: false, fileName: fallbackFileName, bytes: 0, fallback: true };
+    }
+  }
+  async function handleLogClear(args) {
+    const want = args && args.date ? String(args.date) : "";
+    try {
+      const dir = typeof ctx.getCacheDir === "function" ? await ctx.getCacheDir() : null;
+      if (!dir) return { ok: true, removed: 0 };
+      const logDir = await ctx.joinLogPath(dir, config.logDirName);
+      if (want === "all") {
+        let removedAll = 0;
+        const names = await listFileNames(ctx, logDir);
+        for (let i = 0; i < names.length; i++) {
+          if (!filePattern.test(names[i])) continue;
+          if (await deleteOneFile(logDir, names[i])) removedAll += 1;
+        }
+        return { ok: true, removed: removedAll };
+      }
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(want)) {
+        try {
+          ctx.log("warn", "host.call.fail", { method: config.prefix + ".logClear", kind: "clear", errorHash: hash8("bad-date") });
+        } catch (eL) {
+          void eL;
+        }
+        return { ok: false, removed: 0 };
+      }
+      if (config.fileNamePolicy === "four-segment") {
+        const names = await listFileNames(ctx, logDir);
+        const hits = names.filter((name) => filePattern.test(name) && name.indexOf(want + ".") === 0).sort();
+        let removed = 0;
+        for (const name of hits) {
+          if (await deleteOneFile(logDir, name)) removed += 1;
+        }
+        return { ok: true, removed };
+      }
+      const done = await deleteOneFile(logDir, want + ".log");
+      return { ok: true, removed: done ? 1 : 0 };
+    } catch (e) {
+      try {
+        ctx.log("warn", "host.call.fail", {
+          method: config.prefix + ".logClear",
+          kind: "clear",
+          errorHash: hash8(String(e && e.message || e))
+        });
+      } catch (eL) {
+        void eL;
+      }
+      return { ok: false, removed: 0 };
+    }
+  }
+  async function deleteOneFile(logDir, name) {
+    const { fs, getPlatform } = ctx;
+    try {
+      const target = await ctx.resolveTarget(await ctx.joinLogPath(logDir, name));
+      try {
+        if (fs && typeof fs.unlink === "function") {
+          await fs.unlink(target);
+          return true;
+        }
+      } catch (e) {
+        void e;
+      }
+      try {
+        const platform = typeof getPlatform === "function" ? await getPlatform() : null;
+        if (platform && platform.fs && typeof platform.fs.unlink === "function") {
+          await platform.fs.unlink(target);
+          return true;
+        }
+      } catch (e2) {
+        void e2;
+      }
+      try {
+        await ctx.writeTarget(target, "");
+        return true;
+      } catch (e3) {
+        void e3;
+        return false;
+      }
+    } catch (e) {
+      void e;
+      return false;
+    }
+  }
+  async function handleLogGetSwitch() {
+    const state = await ctx.loadSwitch();
+    return { ok: true, enabled: state.enabled, sampleRate: state.sampleRate };
+  }
+  async function handleLogSetSwitch(args) {
+    const enabled = !!(args && args.enabled);
+    const fallbackRate = typeof ctx.getSwitchState === "function" ? ctx.getSwitchState().sampleRate : void 0;
+    const sampleRate = args && typeof args.sampleRate === "number" ? args.sampleRate : fallbackRate;
+    const state = await ctx.setSwitch(enabled, sampleRate);
+    return { ok: true, enabled: state.enabled };
+  }
+  return {
+    handleLogExport,
+    handleLogClear,
+    handleLogGetSwitch,
+    handleLogSetSwitch
+  };
+}
+export {
+  createLogPhones
+};