jinzd-ai-cli 0.4.306 → 0.4.308

package/dist/{chunk-W6PLV3EY.js → chunk-JJNUASMJ.js}

@@ -1,16 +1,195 @@
 #!/usr/bin/env node
 import {
   TEST_TIMEOUT
-} from "./chunk-T6WQEQI4.js";
+} from "./chunk-2MNUMLN4.js";
+import {
+  getExecutionConfigDir,
+  getExecutionSignal
+} from "./chunk-SXIJLSVF.js";
+
+// src/tools/builtin/run-tests.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/core/interrupt.ts
+var controller = new AbortController();
+var interrupted = false;
+function currentAbortSignal() {
+  return getExecutionSignal() ?? controller.signal;
+}
+function isInterrupted() {
+  return interrupted;
+}
+function requestInterrupt() {
+  interrupted = true;
+  if (!controller.signal.aborted) {
+    controller.abort(new DOMException("User interrupted (Ctrl+C)", "AbortError"));
+  }
+}
+function resetInterrupt() {
+  controller = new AbortController();
+  interrupted = false;
+}
+
+// src/tools/win-shell.ts
+import { platform } from "os";
+import { spawn } from "child_process";
+var IS_WINDOWS = platform() === "win32";
+var WIN_UTF8_PREAMBLE = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; $OutputEncoding = [System.Text.Encoding]::UTF8; ";
+function shellInvocation(command) {
+  if (IS_WINDOWS) {
+    return {
+      shell: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-Command", WIN_UTF8_PREAMBLE + command]
+    };
+  }
+  return { shell: process.env["SHELL"] ?? "/bin/bash", args: ["-c", command] };
+}
+function decodeWindowsBuffer(buf) {
+  const utf8 = buf.toString("utf-8");
+  if (!utf8.includes("\uFFFD")) return utf8;
+  try {
+    return new TextDecoder("gbk").decode(buf);
+  } catch {
+    return utf8;
+  }
+}
+var GBK_MOJIBAKE_FINGERPRINTS = [
+  "\uFFFD",
+  "\u9215",
+  "\u951B",
+  "\u9983",
+  "\u9241",
+  "\u6D93",
+  "\u935B",
+  "\u9428",
+  "\u7EFE",
+  "\u95AB",
+  "\u9593",
+  "\u95BF",
+  "\u68E3",
+  "\u95B4",
+  "\u5A11",
+  "\u95B8",
+  "\u95BB",
+  "\u7F01",
+  "\u95C1"
+];
+var gbkReverse = null;
+function gbkReverseMap() {
+  if (gbkReverse) return gbkReverse;
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const dec = new TextDecoder("gbk");
+    for (let hi = 129; hi <= 254; hi++) {
+      for (let lo = 64; lo <= 254; lo++) {
+        if (lo === 127) continue;
+        const ch = dec.decode(new Uint8Array([hi, lo]));
+        if (ch.length === 1 && ch !== "\uFFFD" && !map.has(ch)) map.set(ch, [hi, lo]);
+      }
+    }
+  } catch {
+  }
+  gbkReverse = map;
+  return map;
+}
+function decodeRunAsChinese(bytes) {
+  for (let start = 0; start <= 2 && start < bytes.length; start++) {
+    for (let end = 0; end <= 2 && bytes.length - end > start; end++) {
+      const slice = bytes.slice(start, bytes.length - end);
+      if (slice.length < 6) continue;
+      try {
+        const out = new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(slice));
+        if (/[一-鿿]/.test(out)) return out;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function recoverGbkMojibake(text) {
+  if (!text) return null;
+  const map = gbkReverseMap();
+  if (map.size === 0) return null;
+  let run = [];
+  let best = null;
+  const flush = () => {
+    if (run.length >= 4) {
+      const bytes = [];
+      for (const p of run) bytes.push(p[0], p[1]);
+      const out = decodeRunAsChinese(bytes);
+      if (out && (!best || out.length > best.length)) best = out;
+    }
+    run = [];
+  };
+  for (const ch of text) {
+    const pair = ch.codePointAt(0) < 128 ? void 0 : map.get(ch);
+    if (pair) run.push(pair);
+    else flush();
+  }
+  flush();
+  return best;
+}
+function looksLikeGbkMojibake(text) {
+  if (recoverGbkMojibake(text) !== null) return true;
+  let hits = 0;
+  for (const ch of GBK_MOJIBAKE_FINGERPRINTS) {
+    if (text.includes(ch) && ++hits >= 2) return true;
+  }
+  return false;
+}
+function killProcessTree(proc, processGroup = false) {
+  if (proc.killed || proc.exitCode !== null) return;
+  if (IS_WINDOWS && proc.pid) {
+    try {
+      const tk = spawn("taskkill", ["/PID", String(proc.pid), "/T", "/F"], {
+        windowsHide: true,
+        stdio: "ignore"
+      });
+      tk.on("exit", () => {
+        try {
+          proc.kill();
+        } catch {
+        }
+      });
+      tk.on("error", () => {
+        try {
+          proc.kill();
+        } catch {
+        }
+      });
+    } catch {
+      try {
+        proc.kill();
+      } catch {
+      }
+    }
+    return;
+  }
+  const signal = (value) => {
+    if (processGroup && proc.pid) process.kill(-proc.pid, value);
+    else proc.kill(value);
+  };
+  try {
+    signal("SIGTERM");
+  } catch {
+  }
+  setTimeout(() => {
+    if (processGroup || proc.exitCode === null) {
+      try {
+        signal("SIGKILL");
+      } catch {
+      }
+    }
+  }, 500).unref();
+}
 
 // src/tools/builtin/run-tests.ts
-import { execSync, spawnSync } from "child_process";
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
-import { platform } from "os";
+import { platform as platform2 } from "os";
 import chalk from "chalk";
-var FILTER_WHITELIST = /^[\w.\-/:#\s*?()\[\]@+]{1,200}$/;
-var IS_WINDOWS = platform() === "win32";
+var FILTER_WHITELIST = /^[\w.\-/:# *?\[\]@+]{1,200}$/;
+var IS_WINDOWS2 = platform2() === "win32";
 function detectNodeTestFramework(cwd, pkg) {
   const devDeps = pkg.devDependencies ?? {};
   const deps = pkg.dependencies ?? {};
@@ -80,11 +259,11 @@ function safeReadPackageJson(cwd) {
 }
 function detectProject(cwd) {
   if (existsSync(join(cwd, "pom.xml"))) {
-    return { type: "java", framework: "Maven (JUnit)", command: IS_WINDOWS ? "mvn.cmd test" : "mvn test" };
+    return { type: "java", framework: "Maven (JUnit)", command: IS_WINDOWS2 ? "mvn.cmd test" : "mvn test" };
   }
   if (existsSync(join(cwd, "build.gradle")) || existsSync(join(cwd, "build.gradle.kts"))) {
-    const wrapper = IS_WINDOWS ? "gradlew.bat" : "./gradlew";
-    const cmd = existsSync(join(cwd, IS_WINDOWS ? "gradlew.bat" : "gradlew")) ? `${wrapper} test` : "gradle test";
+    const wrapper = IS_WINDOWS2 ? "gradlew.bat" : "./gradlew";
+    const cmd = existsSync(join(cwd, IS_WINDOWS2 ? "gradlew.bat" : "gradlew")) ? `${wrapper} test` : "gradle test";
     return { type: "java", framework: "Gradle (JUnit)", command: cmd };
   }
   if (existsSync(join(cwd, "package.json"))) {
@@ -240,7 +419,7 @@ function renderColorReport(summary, framework) {
   console.log();
 }
 function needsWindowsShell(file) {
-  if (!IS_WINDOWS) return false;
+  if (!IS_WINDOWS2) return false;
   const lower = file.toLowerCase();
   return lower.endsWith(".cmd") || lower.endsWith(".bat") || lower === "mvn" || lower === "gradle" || lower === "npm" || lower === "npx";
 }
@@ -307,51 +486,9 @@ Got: ${filter.slice(0, 60)}${filter.length > 60 ? "..." : ""}`;
     framework = detected.framework;
     argv = buildArgv(detected, filter);
   }
-  let output;
-  let exitCode = 0;
-  if (argv) {
-    const r = spawnSync(argv.file, argv.args, {
-      cwd,
-      timeout: TEST_TIMEOUT,
-      stdio: ["pipe", "pipe", "pipe"],
-      // shell:false is the default for spawnSync; on Windows .cmd/.bat
-      // requires shell:true, so we opt-in only for known wrapper names.
-      shell: needsWindowsShell(argv.file),
-      env: {
-        ...process.env,
-        ...IS_WINDOWS ? {} : { FORCE_COLOR: "0" }
-      },
-      encoding: "utf-8",
-      maxBuffer: 64 * 1024 * 1024
-    });
-    if (r.error) {
-      output = `Failed to launch test runner: ${r.error.message}`;
-      exitCode = 1;
-    } else {
-      exitCode = r.status ?? 1;
-      output = (r.stdout ?? "") + (r.stderr ? "\n" + r.stderr : "");
-    }
-  } else {
-    try {
-      const buf = execSync(command, {
-        cwd,
-        timeout: TEST_TIMEOUT,
-        encoding: "buffer",
-        stdio: ["pipe", "pipe", "pipe"],
-        env: {
-          ...process.env,
-          ...IS_WINDOWS ? {} : { FORCE_COLOR: "0" }
-        }
-      });
-      output = buf.toString("utf-8");
-    } catch (err) {
-      const e = err;
-      exitCode = e.status ?? 1;
-      const stdout = e.stdout?.toString("utf-8") ?? "";
-      const stderr = e.stderr?.toString("utf-8") ?? "";
-      output = stdout + (stderr ? "\n" + stderr : "");
-    }
-  }
+  const result = await runTestProcess(argv, command, cwd, currentAbortSignal());
+  const output = result.output;
+  const exitCode = result.exitCode;
   let summary = {
     tests: 0,
     passed: 0,
@@ -390,6 +527,7 @@ Got: ${filter.slice(0, 60)}${filter.length > 60 ? "..." : ""}`;
       }
     }
   }
+  if (exitCode !== 0 && summary.failures + summary.errors === 0) summary.errors = 1;
   renderColorReport(summary, framework);
   return formatReport(summary, framework, output, exitCode);
 }
@@ -414,8 +552,78 @@ var runTestsTool = {
     return executeTests(args);
   }
 };
+var MAX_TEST_OUTPUT_BYTES = 4 * 1024 * 1024;
+var activeTestProcesses = 0;
+var activeTestsByOwner = /* @__PURE__ */ new Map();
+async function runTestProcess(argv, command, cwd, signal) {
+  if (signal.aborted) throw new Error("Test run cancelled");
+  const owner = getExecutionConfigDir();
+  if ((activeTestsByOwner.get(owner) ?? 0) >= 2) throw new Error("Test runner capacity reached (2 per user).");
+  if (activeTestProcesses >= 4) throw new Error("Test runner capacity reached (4). Try again after a run finishes.");
+  activeTestProcesses++;
+  activeTestsByOwner.set(owner, (activeTestsByOwner.get(owner) ?? 0) + 1);
+  try {
+    return await new Promise((resolve, reject) => {
+      const child = argv ? spawn2(argv.file, argv.args, { cwd, shell: needsWindowsShell(argv.file), windowsHide: true, detached: !IS_WINDOWS2, stdio: ["ignore", "pipe", "pipe"] }) : spawn2(command, { cwd, shell: true, windowsHide: true, detached: !IS_WINDOWS2, stdio: ["ignore", "pipe", "pipe"] });
+      const chunks = [];
+      let bytes = 0;
+      let stopped = "";
+      let settled = false;
+      const stop = (reason) => {
+        if (stopped) return;
+        stopped = reason;
+        killProcessTree(child, true);
+      };
+      const onAbort = () => stop("Test run cancelled");
+      const timer = setTimeout(() => stop("Test run timed out"), TEST_TIMEOUT);
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) onAbort();
+      const append = (chunk) => {
+        const take = Math.min(chunk.length, MAX_TEST_OUTPUT_BYTES - bytes);
+        if (take > 0) chunks.push(chunk.subarray(0, take));
+        bytes += take;
+        if (bytes >= MAX_TEST_OUTPUT_BYTES) stop("Test output exceeded 4 MiB limit");
+      };
+      child.stdout?.on("data", append);
+      child.stderr?.on("data", append);
+      const clean = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+      };
+      child.once("error", (error) => {
+        if (settled) return;
+        settled = true;
+        clean();
+        reject(error);
+      });
+      child.once("close", (code) => {
+        if (settled) return;
+        settled = true;
+        clean();
+        resolve({ output: Buffer.concat(chunks).toString("utf8") + (stopped ? "\n" + stopped : ""), exitCode: stopped ? 1 : code ?? 1 });
+      });
+    });
+  } finally {
+    activeTestProcesses--;
+    const remaining = (activeTestsByOwner.get(owner) ?? 1) - 1;
+    if (remaining) activeTestsByOwner.set(owner, remaining);
+    else activeTestsByOwner.delete(owner);
+  }
+}
 
 export {
+  IS_WINDOWS,
+  WIN_UTF8_PREAMBLE,
+  shellInvocation,
+  decodeWindowsBuffer,
+  recoverGbkMojibake,
+  looksLikeGbkMojibake,
+  killProcessTree,
+  currentAbortSignal,
+  isInterrupted,
+  requestInterrupt,
+  resetInterrupt,
   executeTests,
-  runTestsTool
+  runTestsTool,
+  runTestProcess
 };

package/dist/{chunk-NYNSYLFY.js → chunk-JL44HGZC.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
 
 // src/session/session-index.ts
 import { existsSync, readFileSync as readFileSync2, readdirSync, statSync } from "fs";

package/dist/{chunk-NUJTNH76.js → chunk-LBWKMTT3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   SessionManager
-} from "./chunk-IUVDZVZ4.js";
+} from "./chunk-AXTLYOA7.js";
 
 // src/hub/persist.ts
 import { join } from "path";

package/dist/{chunk-LAP7TPPK.js → chunk-LR3TGZWQ.js}

@@ -8,12 +8,12 @@ import {
 } from "./chunk-HOSJZMQS.js";
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
 import {
   MEMORY_FILE_NAME,
   MEMORY_MAX_CHARS,
   MEMORY_STORE_FILE_NAME
-} from "./chunk-T6WQEQI4.js";
+} from "./chunk-2MNUMLN4.js";
 
 // src/memory/persistent-memory.ts
 import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync } from "fs";

package/dist/{chunk-WQ3OMEC4.js → chunk-M6HLYG33.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   atomicWriteFileSync
-} from "./chunk-IW3Q7AE5.js";
+} from "./chunk-BMLQPSHP.js";
 
 // src/symbols/store.ts
 import fs from "fs";

package/dist/{chunk-I4GQRMFV.js → chunk-M6YV5KSS.js}

@@ -8,12 +8,14 @@ import {
 } from "./chunk-FSC6KEWU.js";
 import {
   atomicWriteFileSync
-} from "./chunk-6BUTA5VW.js";
+} from "./chunk-2XMUCC42.js";
+import {
+  getExecutionConfigDir
+} from "./chunk-QMFMST2T.js";
 
 // src/memory/chat-index.ts
 import fs from "fs";
 import path from "path";
-import os from "os";
 import crypto from "crypto";
 
 // src/session/session-index.ts
@@ -311,7 +313,7 @@ var VEC_MAGIC = 1094929750;
 var VEC_VERSION = 1;
 var VEC_HEADER_BYTES = 16;
 function memoryIndexDir() {
-  return path.join(os.homedir(), ".aicli", MEMORY_DIR_NAME);
+  return path.join(getExecutionConfigDir(), MEMORY_DIR_NAME);
 }
 function chunksPath() {
   return path.join(memoryIndexDir(), CHUNKS_FILE);
@@ -320,7 +322,7 @@ function vectorsPath() {
   return path.join(memoryIndexDir(), VECTORS_FILE);
 }
 function historyDir() {
-  return path.join(os.homedir(), ".aicli", "history");
+  return path.join(getExecutionConfigDir(), "history");
 }
 var MAX_CHUNK_CHARS = 1200;
 var MIN_CHUNK_CHARS = 40;

package/dist/{chunk-K5SDDTN7.js → chunk-NLK45GUS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   VERSION
-} from "./chunk-T6WQEQI4.js";
+} from "./chunk-2MNUMLN4.js";
 
 // src/cli/ci-format.ts
 var DEFAULT_CI_THRESHOLDS = {

package/dist/{chunk-KBDKKHXB.js → chunk-O6CGOVD4.js}

@@ -2,7 +2,7 @@ import {
   loadVectorStore,
   saveVectorStore,
   searchVectorStore
-} from "./chunk-OAXLMF3U.js";
+} from "./chunk-3YVNDYOY.js";
 import {
   EMBEDDING_DIM,
   embed,
@@ -11,7 +11,7 @@ import {
 import {
   loadIndex,
   symbolFingerprint
-} from "./chunk-45UVJXFQ.js";
+} from "./chunk-W2UOVGRC.js";
 
 // src/symbols/semantic.ts
 function pathTokens(absFile, root) {

package/dist/chunk-QMFMST2T.js

@@ -0,0 +1,39 @@
+// src/tools/session-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { homedir } from "os";
+import { join } from "path";
+var als = new AsyncLocalStorage();
+var defaultState = /* @__PURE__ */ new Map();
+function getExecutionConfigDir() {
+  return als.getStore()?.configDir ?? join(homedir(), ".aicli");
+}
+function getExecutionSignal() {
+  return als.getStore()?.signal;
+}
+function scopedState(key, create) {
+  const state = als.getStore()?.state ?? defaultState;
+  if (!state.has(key)) state.set(key, create());
+  return state.get(key);
+}
+function runWithExecutionContext(context, fn) {
+  return als.run({ sessionKey: DEFAULT_SESSION_KEY, ...als.getStore(), ...context }, fn);
+}
+var DEFAULT_SESSION_KEY = "__default__";
+function getCurrentSessionKey() {
+  const ctx = als.getStore();
+  if (!ctx || !ctx.sessionKey) return DEFAULT_SESSION_KEY;
+  return ctx.sessionKey;
+}
+function runWithSessionKey(sessionKey, fn) {
+  const key = sessionKey && sessionKey.length > 0 ? sessionKey : DEFAULT_SESSION_KEY;
+  return als.run({ ...als.getStore(), sessionKey: key }, fn);
+}
+
+export {
+  getExecutionConfigDir,
+  getExecutionSignal,
+  scopedState,
+  runWithExecutionContext,
+  getCurrentSessionKey,
+  runWithSessionKey
+};

package/dist/{chunk-MI4SFZGX.js → chunk-RMEJR3AW.js}

@@ -1146,6 +1146,7 @@ function getDangerLevel(toolName, args) {
   }
   if (toolName === "bash") {
     const cmd = String(args["command"] ?? "");
+    if (/\bgit\s+(?:clean\b|reset\s+--hard\b|push\b[^\n]*(?:--force\b|\s-f\b))/i.test(cmd)) return "destructive";
     if (/\brm\s+[^\n]*(?:-\w*[rRfF]\w*|--recursive|--force)\b/.test(cmd)) return "destructive";
     if (/\brm\s+\S/.test(cmd)) return "destructive";
     if (/\brmdir\b|\bformat\b|\bmkfs\b|\bdd\s+if=|\bshred\b|\bfdisk\b|\bparted\b/.test(cmd)) return "destructive";
@@ -1161,8 +1162,10 @@ function getDangerLevel(toolName, args) {
     if (/\bSet-Content\b|\bOut-File\b|\bAdd-Content\b|\bCopy-Item\b|\bMove-Item\b|\bSet-ItemProperty\b|\bNew-ItemProperty\b/i.test(cmd)) return "write";
     if (/\b(python3?|node|deno|bun|perl|ruby|php|bash|sh|zsh|pwsh|powershell)(\.exe)?\b[^\n]*?\s-(?:Command|EncodedCommand|c|e|p|r)\b/i.test(cmd)) return "write";
     if (/\bcmd(\.exe)?\s+\/[ck]\b/i.test(cmd)) return "write";
-    return "safe";
+    if (!/[;&|`$<>\n\r(){}]/.test(cmd) && (/^(?:pwd|ls|cat|head|tail|wc|Get-ChildItem|Get-Location|Get-Content)(?:\s+[\w ./\\:*?=,@'"-]+)?\s*$/i.test(cmd.trim()) || /^echo(?:\s+[\w .,'"-]+)?\s*$/.test(cmd.trim()) || /^(?:node|python3?)\s+(?:-v|--version)\s*$/.test(cmd.trim()) || /^git\s+(?:status|log)(?:\s+(?:--short|--porcelain|--oneline|-\d+))*\s*$/.test(cmd.trim()))) return "safe";
+    return "write";
   }
+  if (toolName === "run_tests") return "write";
   if (toolName === "write_file") return "write";
   if (toolName === "edit_file") return "write";
   if (toolName === "save_last_response") return "write";
@@ -1177,7 +1180,7 @@ function getDangerLevel(toolName, args) {
   if (toolName === "git_commit") return "write";
   if (toolName === "git_status" || toolName === "git_diff" || toolName === "git_log") return "safe";
   if (toolName === "notebook_edit") return "write";
-  if (toolName === "read_file" || toolName === "list_dir" || toolName === "grep_files" || toolName === "glob_files" || toolName === "web_fetch" || toolName === "save_memory" || toolName === "ask_user" || toolName === "write_todos" || toolName === "google_search" || toolName === "spawn_agent" || toolName === "run_tests") return "safe";
+  if (toolName === "read_file" || toolName === "list_dir" || toolName === "grep_files" || toolName === "glob_files" || toolName === "web_fetch" || toolName === "save_memory" || toolName === "ask_user" || toolName === "write_todos" || toolName === "google_search" || toolName === "spawn_agent") return "safe";
   return "write";
 }
 function schemaToJsonSchema(schema) {

package/dist/{chunk-UFW4S3RU.js → chunk-RVMCY6DP.js}

@@ -5,7 +5,7 @@ import {
   removeFile,
   saveIndex,
   upsertFileSymbols
-} from "./chunk-45UVJXFQ.js";
+} from "./chunk-W2UOVGRC.js";
 
 // src/symbols/indexer.ts
 import fs2 from "fs";

package/dist/{chunk-LF67HWWR.js → chunk-RWRZVQCB.js}

@@ -6,7 +6,7 @@ import {
   removeFile,
   saveIndex,
   upsertFileSymbols
-} from "./chunk-WQ3OMEC4.js";
+} from "./chunk-M6HLYG33.js";
 
 // src/symbols/indexer.ts
 import fs2 from "fs";

package/dist/chunk-SXIJLSVF.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// src/tools/session-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { homedir } from "os";
+import { join } from "path";
+var als = new AsyncLocalStorage();
+var defaultState = /* @__PURE__ */ new Map();
+function getExecutionConfigDir() {
+  return als.getStore()?.configDir ?? join(homedir(), ".aicli");
+}
+function getExecutionSignal() {
+  return als.getStore()?.signal;
+}
+function scopedState(key, create) {
+  const state = als.getStore()?.state ?? defaultState;
+  if (!state.has(key)) state.set(key, create());
+  return state.get(key);
+}
+function runWithExecutionContext(context, fn) {
+  return als.run({ sessionKey: DEFAULT_SESSION_KEY, ...als.getStore(), ...context }, fn);
+}
+var DEFAULT_SESSION_KEY = "__default__";
+function getCurrentSessionKey() {
+  const ctx = als.getStore();
+  if (!ctx || !ctx.sessionKey) return DEFAULT_SESSION_KEY;
+  return ctx.sessionKey;
+}
+function runWithSessionKey(sessionKey, fn) {
+  const key = sessionKey && sessionKey.length > 0 ? sessionKey : DEFAULT_SESSION_KEY;
+  return als.run({ ...als.getStore(), sessionKey: key }, fn);
+}
+
+export {
+  getExecutionConfigDir,
+  getExecutionSignal,
+  scopedState,
+  runWithExecutionContext,
+  getCurrentSessionKey,
+  runWithSessionKey
+};

package/dist/chunk-TDQW2YHK.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+// src/web/access.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+import { networkInterfaces } from "os";
+function equalToken(a, b) {
+  if (typeof a !== "string" || a.length > 4096) return false;
+  const left = Buffer.from(a), right = Buffer.from(b);
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+var WebAccess = class {
+  constructor(host, externalOrigin) {
+    this.externalOrigin = externalOrigin;
+    if (!["0.0.0.0", "::"].includes(host)) this.hosts.add(host.includes(":") ? `[${host}]` : host.toLowerCase());
+    else for (const interfaces of Object.values(networkInterfaces())) for (const entry of interfaces ?? []) {
+      this.hosts.add(entry.address.includes(":") ? `[${entry.address}]` : entry.address);
+    }
+    if (externalOrigin && new URL(externalOrigin).origin !== externalOrigin) throw new Error("External origin must be an exact http(s) origin");
+    if (externalOrigin && !/^https?:\/\//.test(externalOrigin)) throw new Error("External origin must use HTTP(S)");
+  }
+  externalOrigin;
+  localToken = randomBytes(32).toString("base64url");
+  hosts = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+  accepts(req) {
+    const host = req.headers.host;
+    if (!host) return false;
+    try {
+      const url = new URL(`http://${host}`);
+      const internal = this.hosts.has(url.hostname.toLowerCase()) && Number(url.port || 80) === req.socket.localPort;
+      const external = this.externalOrigin && new URL(this.externalOrigin).host === host;
+      if (!internal && !external) return false;
+      const origin = req.headers.origin;
+      return !origin || origin === (external ? this.externalOrigin : `http://${host}`);
+    } catch {
+      return false;
+    }
+  }
+};
+var AuthRateLimiter = class {
+  ips = /* @__PURE__ */ new Map();
+  start = 0;
+  count = 0;
+  take(ip) {
+    const now = Date.now();
+    if (now - this.start >= 6e4) {
+      this.start = now;
+      this.count = 0;
+    }
+    if (++this.count > 120) return false;
+    for (const [key, value] of this.ips) if (now - value.start >= 6e4) this.ips.delete(key);
+    let bucket = this.ips.get(ip);
+    if (!bucket) {
+      if (this.ips.size >= 2048) return false;
+      bucket = { start: now, count: 0 };
+      this.ips.set(ip, bucket);
+    }
+    return ++bucket.count <= 30;
+  }
+};
+
+export {
+  equalToken,
+  WebAccess,
+  AuthRateLimiter
+};