dsh-plugin-compat-check 0.1.3 → 0.1.5

package/kernel/lib/owned-process.mjs

@@ -0,0 +1,287 @@
+/** Owned process-group lifecycle. No argv, environment or global process listing
+ * is retained; ps is a bounded failure diagnostic, filtered to this group. */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { privateDiagnostic } from "../plugin/lib/host-resources.js";
+export function failureDiagnostic(error) {
+  return error?.diagnostics?.length
+    ? error.diagnostics
+    : error?.diagnostic
+      ? [error.diagnostic]
+      : [];
+}
+export function publishDiagnostic(diagnostic, privateDetails) {
+  const dir = process.env.DSC_EXECUTION_DIAGNOSTICS;
+  if (dir) {
+    const redact = (value) =>
+      String(value)
+        .slice(-8192)
+        .replace(/https?:\/\/[^\s"'<>]+/gi, "<url>")
+        .replace(
+          /(authorization\s*[:=]\s*)(?:Bearer\s+)?[^\s,;]+/gi,
+          "$1[redacted]",
+        )
+        .replace(
+          /((?:api[_-]?key|access[_-]?token|password)\s*[:=]\s*)[^\s,;]+/gi,
+          "$1[redacted]",
+        );
+    const data = {
+      ...diagnostic,
+      ...(privateDetails
+        ? {
+            privateDetails: Object.fromEntries(
+              Object.entries(privateDetails).map(([key, value]) => [
+                key,
+                redact(value),
+              ]),
+            ),
+          }
+        : {}),
+    };
+    const written = privateDiagnostic(
+      path.join(dir, `${diagnostic.component}-${randomUUID()}.json`),
+      data,
+    );
+    diagnostic.persistence = { requested: true, written };
+  }
+  return diagnostic;
+}
+export function groupSnapshot(pgid) {
+  if (process.platform === "win32")
+    return { available: false, reason: "unsupported-platform" };
+  const args =
+    process.platform === "darwin"
+      ? ["-g", String(pgid), "-o", "pid=,ppid=,pgid=,uid=,stat="]
+      : ["-axo", "pid=,ppid=,pgid=,uid=,stat="];
+  const r = spawnSync("/bin/ps", args, {
+    encoding: "utf8",
+    timeout: 1000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  if (
+    process.platform === "darwin" &&
+    r.status === 1 &&
+    !r.error &&
+    !r.stdout.trim() &&
+    !r.stderr.trim()
+  )
+    return { available: true, members: [], truncated: false };
+  if (r.status !== 0 || r.error)
+    return { available: false, reason: r.error?.code || "ps-failed" };
+  const lines = r.stdout.trim().split("\n");
+  const members = [];
+  for (const line of lines) {
+    const m = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
+    if (!m) return { available: false, reason: "invalid-ps-output" };
+    if (Number(m[3]) === pgid)
+      members.push({
+        pid: Number(m[1]),
+        ppid: Number(m[2]),
+        pgid: Number(m[3]),
+        uid: Number(m[4]),
+        state: m[5],
+      });
+  }
+  return {
+    available: true,
+    members: members.slice(0, 64),
+    truncated: members.length > 64,
+  };
+}
+const stopping = new WeakMap();
+export function stopOwnedChild(child) {
+  if (!child?.pid)
+    return Promise.resolve({ stopped: true, status: "not-started" });
+  if (stopping.has(child)) return stopping.get(child);
+  const pending = (async () => {
+    if (!Number.isSafeInteger(child.pid) || child.pid <= 1)
+      throw new Error("Invalid owned child pid");
+    const done = () => child.exitCode !== null || child.signalCode !== null;
+    let exitListener;
+    const exited = done()
+      ? Promise.resolve()
+      : new Promise((resolve) => {
+          exitListener = resolve;
+          child.once("exit", resolve);
+        });
+    const signals = [];
+    let phase = "SIGTERM";
+    const state = () => ({
+      schemaVersion: 1,
+      kind: "plugin-compat-check/execution-diagnostic",
+      component: "owned-process",
+      phase,
+      pid: child.pid,
+      pgid: process.platform === "win32" ? null : child.pid,
+      parentPid: process.pid,
+      uid: process.getuid?.() ?? null,
+      leaderExited: done(),
+      exitCode: child.exitCode,
+      signalCode: child.signalCode,
+      signals,
+    });
+    const waitExit = async () => {
+      let timer;
+      try {
+        await Promise.race([
+          exited,
+          new Promise((resolve) => {
+            timer = setTimeout(resolve, 2000);
+          }),
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+    const signal = async (sig) => {
+      phase = sig;
+      try {
+        if (process.platform !== "win32") process.kill(-child.pid, sig);
+        else if (!done()) child.kill(sig);
+        signals.push({ signal: sig, result: "sent" });
+      } catch (error) {
+        signals.push({ signal: sig, result: error.code || "error" });
+        if (error.code === "ESRCH") return;
+        let group = groupSnapshot(child.pid);
+        if (
+          process.platform === "darwin" &&
+          error.code === "EPERM" &&
+          !done() &&
+          group.available &&
+          !group.truncated &&
+          group.members.every((m) => m.uid === process.getuid?.()) &&
+          (sig === "SIGKILL" ||
+            group.members.every(
+              (m) => m.state.startsWith("Z") || m.state.includes("E"),
+            ))
+        ) {
+          await waitExit();
+          group = groupSnapshot(child.pid);
+        }
+        // Darwin filters zombies out of killpg and can return EPERM when only
+        // zombies remain. Never infer this from EPERM alone or a failed ps.
+        const zombieOnly =
+          process.platform === "darwin" &&
+          error.code === "EPERM" &&
+          group.available &&
+          (done() ||
+            group.members.some(
+              (m) => m.pid === child.pid && m.state.startsWith("Z"),
+            )) &&
+          !group.truncated &&
+          (group.members.length > 0 || done()) &&
+          group.members.every(
+            (m) => m.uid === process.getuid?.() && m.state.startsWith("Z"),
+          );
+        if (zombieOnly) {
+          signals[signals.length - 1].result = group.members.length
+            ? "verified-zombie-only"
+            : "verified-exited-group";
+          signals[signals.length - 1].group = group;
+          return;
+        }
+        const failure = new Error(
+          `Owned process cleanup failed: ${sig} ${error.code || "error"}`,
+          { cause: error },
+        );
+        failure.code = "OWNED_PROCESS_CLEANUP_FAILED";
+        failure.diagnostic = publishDiagnostic({
+          ...state(),
+          code: failure.code,
+          signalError: {
+            code: error.code || null,
+            syscall: error.syscall || null,
+            stack: String(error.stack || "")
+              .split("\n")
+              .slice(1, 10)
+              .map((line) =>
+                line
+                  .replace(/\((?:file:\/\/)?\/.*\/([^/]+:\d+:\d+)\)/g, "($1)")
+                  .replace(/at (?:file:\/\/)?\/.*\/([^/]+:\d+:\d+)/g, "at $1"),
+              ),
+          },
+          group,
+        });
+        throw failure;
+      }
+    };
+    try {
+      await signal("SIGTERM");
+      await new Promise((r) => setTimeout(r, 100));
+      await signal("SIGKILL");
+      phase = "exit";
+      let timer;
+      try {
+        await Promise.race([
+          exited,
+          new Promise((_, reject) => {
+            timer = setTimeout(
+              () =>
+                reject(
+                  Object.assign(
+                    new Error("Owned process did not exit after SIGKILL"),
+                    {
+                      code: "OWNED_PROCESS_EXIT_TIMEOUT",
+                      diagnostic: publishDiagnostic({
+                        ...state(),
+                        code: "OWNED_PROCESS_EXIT_TIMEOUT",
+                        group: groupSnapshot(child.pid),
+                      }),
+                    },
+                  ),
+                ),
+              2000,
+            );
+          }),
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+      return {
+        stopped: true,
+        status: signals.some((s) => s.result === "verified-zombie-only")
+          ? "zombie-only"
+          : "stopped",
+        ...state(),
+      };
+    } catch (error) {
+      child.unref?.();
+      throw error;
+    } finally {
+      if (exitListener) child.off("exit", exitListener);
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+    }
+  })();
+  stopping.set(child, pending);
+  return pending;
+}
+
+/** Attempt each owned cleanup even when another resource fails. */
+export async function cleanupOwned(tasks) {
+  const settled = await Promise.allSettled(
+    tasks.map((task) => Promise.resolve().then(task)),
+  );
+  const failures = settled
+    .filter((r) => r.status === "rejected")
+    .map((r) => r.reason);
+  if (failures.length) {
+    const error = new AggregateError(failures, "Owned resource cleanup failed");
+    error.code = "OWNED_RESOURCE_CLEANUP_FAILED";
+    error.diagnostics = failures.flatMap(failureDiagnostic);
+    throw error;
+  }
+}
+export function combineFailure(primary, cleanup) {
+  if (!primary) return cleanup;
+  const error = new Error(primary.message + "; " + cleanup.message, {
+    cause: primary,
+  });
+  error.code = primary.code || "EXECUTION_FAILED";
+  error.diagnostics = [
+    ...failureDiagnostic(primary),
+    ...failureDiagnostic(cleanup),
+  ];
+  return error;
+}

package/kernel/lib/report-identity-worker.mjs

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { parentPort, workerData } from "node:worker_threads";
+const hash = createHash("sha256");
+const add = (value) => hash.update(JSON.stringify(value) + "\n");
+let remaining = 50000,
+  directories = 10000;
+const services = new Set(),
+  manifests = [];
+function metadata(file) {
+  if (--remaining < 0) throw Error("缓存身份文件预算超限，等待后续刷新");
+  const stat = fs.statSync(file);
+  add([
+    file,
+    fs.realpathSync(file),
+    stat.size,
+    stat.mtimeMs,
+    stat.ctimeMs,
+    stat.ino,
+    stat.mode,
+  ]);
+  return stat;
+}
+function smallFile(file, limit = 1024 * 1024) {
+  let fd;
+  try {
+    metadata(file);
+    // Open nonblocking before inspecting the same descriptor. A swapped
+    // symlink or FIFO cannot turn the following bounded read into a host hang.
+    fd = fs.openSync(
+      file,
+      fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK || 0),
+    );
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > limit)
+      throw Error("缓存身份输入不是预算内普通文件");
+    const buffer = Buffer.alloc(limit + 1),
+      length = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    if (length > limit) throw Error("缓存身份输入超过读取预算");
+    const bytes = buffer.subarray(0, length);
+    add(bytes.toString("base64"));
+    return bytes;
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      add([file, "missing"]);
+      return null;
+    }
+    throw error;
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+function walk(root) {
+  const seen = new Set(),
+    queue = [root],
+    canonical = fs.realpathSync(root);
+  while (queue.length) {
+    if (--directories < 0) throw Error("缓存身份目录预算超限，等待后续刷新");
+    const dir = queue.pop(),
+      real = fs.realpathSync(dir);
+    if (
+      seen.has(real) ||
+      (real !== canonical && !real.startsWith(canonical + path.sep))
+    )
+      continue;
+    seen.add(real);
+    for (const entry of fs.readdirSync(dir).sort()) {
+      const file = path.join(dir, entry);
+      let stat;
+      try {
+        stat = metadata(file);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          add([file, "missing"]);
+          continue;
+        }
+        throw error;
+      }
+      if (stat.isDirectory()) queue.push(file);
+    }
+  }
+}
+try {
+  const { nodeModules, files = [], context = {} } = workerData;
+  add(context);
+  metadata(nodeModules);
+  for (const name of fs.readdirSync(nodeModules).sort()) {
+    const bases = name.startsWith("@")
+      ? fs
+          .readdirSync(path.join(nodeModules, name))
+          .sort()
+          .map((n) => path.join(name, n))
+      : [name];
+    for (const base of bases) {
+      const root = path.join(nodeModules, base);
+      let bytes;
+      try {
+        bytes = smallFile(path.join(root, "package.json"), 65536);
+      } catch (error) {
+        if (remaining < 0) throw error;
+        add([root, "unreadable-manifest", error.code || error.message]);
+        continue;
+      }
+      if (!bytes) continue;
+      let manifest;
+      try {
+        manifest = JSON.parse(bytes);
+      } catch {
+        continue;
+      }
+      if (
+        !manifest ||
+        typeof manifest !== "object" ||
+        Array.isArray(manifest) ||
+        !("dsh" in manifest) ||
+        String(manifest.name || "").startsWith("@deepseek-ai/")
+      )
+        continue;
+      manifests.push({ name: manifest.name });
+      const inject = manifest.inject;
+      for (const name of Array.isArray(inject)
+        ? inject
+        : inject && typeof inject === "object"
+          ? [
+              ...(Array.isArray(inject.required) ? inject.required : []),
+              ...(Array.isArray(inject.optional) ? inject.optional : []),
+            ]
+          : [])
+        if (typeof name === "string") services.add(name);
+      walk(root);
+    }
+  }
+  for (const file of files.filter(Boolean)) {
+    const bytes = smallFile(file, 8 * 1024 * 1024);
+    if (bytes && path.basename(file).startsWith("dsh-api-catalog"))
+      try {
+        for (const name of Object.keys(JSON.parse(bytes).host || {}))
+          services.add(name);
+      } catch {}
+  }
+  parentPort.postMessage({
+    ok: true,
+    value: {
+      digest: hash.digest("hex"),
+      services: [...services].sort(),
+      manifests,
+    },
+  });
+} catch (error) {
+  parentPort.postMessage({ ok: false, error: error.message });
+}

package/kernel/lib/report-identity.mjs

@@ -0,0 +1,15 @@
+import { runWorkerTask } from "./worker-analysis.mjs";
+/** Bounded metadata walk runs off the host thread and never imports plugin code. */
+export function reportIdentity(inputs) {
+  return runWorkerTask(
+    new URL("./report-identity-worker.mjs", import.meta.url),
+    inputs,
+    {
+      timeoutMs: 5000,
+      resourceLimits: {
+        maxOldGenerationSizeMb: 128,
+        maxYoungGenerationSizeMb: 16,
+      },
+    },
+  );
+}

package/kernel/lib/report-service.mjs

@@ -1,10 +1,16 @@
-/** Single flight per target; retain the last valid report on failed refresh. */
+/** Single flight per canonical target; keep valid reports while inputs refresh. */
 export class ReportService {
-  constructor(compute, { ttlMs = 300000, clock = Date.now } = {}) {
+  constructor(
+    compute,
+    { ttlMs = 300000, clock = Date.now, identity = null, watchMs = 5000 } = {},
+  ) {
     this.compute = compute;
     this.ttlMs = ttlMs;
     this.clock = clock;
+    this.identity = identity;
+    this.watchMs = watchMs;
     this.states = new Map();
+    this.disposed = false;
   }
   state(key) {
     if (!this.states.has(key))
@@ -13,43 +19,222 @@ export class ReportService {
         at: 0,
         inflight: null,
         error: null,
+        generation: 0,
+        stale: false,
+        identity: undefined,
+        checking: null,
+        options: {},
+        timer: null,
       });
     return this.states.get(key);
   }
+  invalidate(key, reason = "报告输入已变化，等待刷新") {
+    if (this.disposed) return;
+    const state = this.state(key);
+    state.generation++;
+    state.stale = true;
+    state.reason = reason;
+    state.error = null;
+    if (!state.inflight) void this.start(state, state.options);
+  }
+  notify() {
+    if (this.disposed || this.notifying) return;
+    this.notifying = Promise.resolve()
+      .then(async () => {
+        for (const state of this.states.values()) {
+          try {
+            await this.observe(state);
+            if (!this.disposed && state.stale)
+              void this.start(state, state.options);
+          } catch {
+            /* Keep the valid report and let the watchdog retry. */
+          }
+        }
+      })
+      .finally(() => {
+        this.notifying = null;
+      });
+  }
+  async observe(state) {
+    if (!this.identity || this.disposed) return;
+    if (state.checking) return state.checking;
+    state.checking = Promise.resolve()
+      .then(() => this.identity(state.options))
+      .then((identity) => {
+        if (this.disposed) return;
+        if (state.identity !== undefined && state.identity !== identity) {
+          state.generation++;
+          state.stale = true;
+          state.reason = "报告输入已变化，等待刷新";
+          state.error = null;
+        }
+        state.identity = identity;
+      })
+      .catch((error) => {
+        if (!this.disposed) {
+          state.generation++;
+          state.stale = true;
+          state.error = error.message;
+        }
+        throw error;
+      })
+      .finally(() => {
+        state.checking = null;
+      });
+    return state.checking;
+  }
+  watch(state) {
+    if (!this.identity || state.watching || this.disposed) return;
+    state.watching = true;
+    const schedule = () => {
+      if (this.disposed) return;
+      state.timer = setTimeout(async () => {
+        state.timer = null;
+        try {
+          await this.observe(state);
+          if (
+            !this.disposed &&
+            (state.stale || this.clock() - state.at > this.ttlMs)
+          )
+            void this.start(state, state.options);
+        } catch {
+          /* Expose observation errors and retry at the next bounded tick. */
+        }
+        schedule();
+      }, this.watchMs);
+      state.timer.unref?.();
+    };
+    schedule();
+  }
   start(state, options) {
+    if (this.disposed)
+      return Promise.resolve({
+        ok: false,
+        error: "Plugin generation disposed / 已卸载",
+      });
     if (state.inflight) return state.inflight;
+    state.options = options;
+    let generation;
     state.inflight = Promise.resolve()
-      .then(() => this.compute(options))
-      .then((out) => {
+      .then(async () => {
+        if (this.identity) await this.observe(state);
+        generation = state.generation;
+        let commit;
+        const guard = {
+          commit: (fn) => {
+            commit = fn;
+          },
+          isCurrent: async () => {
+            if (this.disposed || generation !== state.generation) return false;
+            // A watchdog observation may have sampled before computation
+            // finished. Drain it, then start a fresh check for this commit.
+            if (state.checking) await state.checking;
+            if (this.disposed || generation !== state.generation) return false;
+            await this.observe(state);
+            return !this.disposed && generation === state.generation;
+          },
+        };
+        const out = await this.compute(options, guard);
+        if (!(await guard.isCurrent()))
+          return {
+            ok: false,
+            invalidated: true,
+            error: "报告输入已变化，正在重新检查",
+          };
         if (out?.ok === true) {
+          commit?.();
           state.report = out;
+          state.publishedIdentity = state.identity;
           state.at = this.clock();
           state.error = null;
-        } else state.error = out?.error || "体检未产生有效报告";
+          state.stale = false;
+          state.reason = null;
+        } else {
+          state.error = out?.error || "体检未产生有效报告";
+          state.stale = true;
+        }
         return out;
       })
       .catch((error) => {
-        state.error = error.message;
-        return { ok: false, error: state.error };
+        if (!this.disposed) {
+          state.error = error.message;
+          state.stale = true;
+        }
+        return { ok: false, error: error.message };
       })
       .finally(() => {
         state.inflight = null;
+        if (
+          !this.disposed &&
+          generation !== undefined &&
+          generation !== state.generation &&
+          !state.error
+        )
+          void this.start(state, state.options);
       });
     return state.inflight;
   }
   async get(key, options = {}, force = false) {
-    const state = this.state(key),
-      age = this.clock() - state.at;
-    if (force || !state.report) return this.start(state, options);
-    if (age > this.ttlMs) this.start(state, options);
+    if (this.disposed)
+      return { ok: false, error: "Plugin generation disposed / 已卸载" };
+    const state = this.state(key);
+    state.options = options;
+    this.watch(state);
+    const age = this.clock() - state.at;
+    if (force || !state.report) {
+      // A force request can join a background flight which was superseded
+      // while extracting. Wait for the replacement generation, with a bound
+      // for continuously changing inputs rather than publishing old success.
+      let out;
+      for (let attempt = 0; attempt < 3; attempt++) {
+        out = await this.start(state, options);
+        if (!out?.invalidated || this.disposed) return out;
+      }
+      return { ok: false, error: "报告输入持续变化，请稍后重试" };
+    }
+    if ((state.stale && !state.error) || age > this.ttlMs)
+      void this.start(state, options);
     return {
       ...state.report,
       cache: {
         hit: true,
         ageMs: age,
         refreshing: !!state.inflight,
+        stale: state.stale,
         refreshError: state.error,
+        reason: state.reason || null,
       },
     };
   }
+  /** The immutable identity observed for this published report, including retained stale reports. */
+  identityForReport(key, report) {
+    const state = this.states.get(key);
+    return state?.report?.report === report
+      ? state.publishedIdentity
+      : undefined;
+  }
+  /** Validate a sidecar edit against the published report without recomputing or advancing its baseline. */
+  async isCurrent(key, report) {
+    const state = this.states.get(key);
+    const matches = () =>
+      !this.disposed &&
+      state &&
+      !state.stale &&
+      !state.error &&
+      state.report?.report === report;
+    if (!matches()) return false;
+    const generation = state.generation;
+    if (state.checking) await state.checking;
+    if (!matches() || generation !== state.generation) return false;
+    await this.observe(state);
+    return matches() && generation === state.generation;
+  }
+  dispose() {
+    this.disposed = true;
+    for (const state of this.states.values()) {
+      clearTimeout(state.timer);
+      state.timer = null;
+      state.generation++;
+    }
+  }
 }