farming-code 2.2.30 → 2.2.32

package/backend/npm-update-helper.cjs

@@ -0,0 +1,399 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var npm_update_helper_exports = {};
+__export(npm_update_helper_exports, {
+  isProcessRunning: () => isProcessRunning,
+  runNpmUpdate: () => runNpmUpdate,
+  stopProcess: () => stopProcess,
+  validatePayload: () => validatePayload,
+  verifyInstalledVersion: () => verifyInstalledVersion,
+  writeJsonAtomic: () => writeJsonAtomic
+});
+module.exports = __toCommonJS(npm_update_helper_exports);
+var import_server_process_identity = require("./server-process-identity.cjs");
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function errorCode(error) {
+  return isObject(error) ? String(error.code || "") : "";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function writeJsonAtomic(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.tmp`;
+  fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  fs.renameSync(temporaryPath, filePath);
+}
+function appendLog(logPath, message) {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`);
+}
+function runCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const logFd = fs.openSync(options.logPath, "a");
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", logFd, logFd]
+    });
+    child.once("error", (error) => {
+      fs.closeSync(logFd);
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      fs.closeSync(logFd);
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} exited with ${signal || code}`));
+    });
+  });
+}
+function isProcessRunning(pid) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (errorCode(error) === "EPERM" || errorCode(error) === "EACCES") return true;
+    return false;
+  }
+}
+async function stopProcess(pid, expectedIdentity, timeoutMs = 15e3) {
+  if (!isProcessRunning(pid)) return;
+  const currentIdentity = await (0, import_server_process_identity.readServerProcessIdentity)(pid);
+  if (!(0, import_server_process_identity.matchingProcessIdentity)(expectedIdentity, currentIdentity)) {
+    throw new Error(`Refusing to stop Farming server ${pid}: process identity changed`);
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch (error) {
+    if (errorCode(error) === "EPERM" || errorCode(error) === "EACCES") {
+      throw new Error(
+        `Farming cannot stop server ${pid} because the update helper lacks permission. Use the operating-system user that owns this process (or an administrator) to stop and restart Farming, then retry the update.`,
+        { cause: error }
+      );
+    }
+    if (errorCode(error) !== "ESRCH") throw error;
+  }
+  const startedAt = Date.now();
+  while ((0, import_server_process_identity.matchingProcessIdentity)(expectedIdentity, await (0, import_server_process_identity.readServerProcessIdentity)(pid))) {
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(
+        `Farming server ${pid} did not exit after SIGKILL. Stop and restart Farming manually, then retry the update.`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+function validatePayload(payload) {
+  if (!payload || typeof payload !== "object") throw new Error("Missing npm update payload");
+  const candidate = payload;
+  if (!["prepare", "apply"].includes(String(candidate.action))) throw new Error("Invalid npm update action");
+  if (!/^[A-Za-z0-9@/._-]+$/.test(String(candidate.packageName || ""))) throw new Error("Invalid npm package name");
+  if (!/^[0-9A-Za-z.+-]+$/.test(String(candidate.targetVersion || ""))) throw new Error("Invalid npm target version");
+  if (!/^[0-9A-Za-z.+-]+$/.test(String(candidate.previousVersion || ""))) throw new Error("Invalid npm previous version");
+  for (const key of ["stateFile", "logPath", "cliPath", "packageRoot", "configDir", "stagingPrefix", "stagingPackageRoot"]) {
+    if (!path.isAbsolute(String(candidate[key] || ""))) throw new Error(`Invalid npm update ${key}`);
+  }
+  if (candidate.npmPrefix && !path.isAbsolute(String(candidate.npmPrefix))) {
+    throw new Error("Invalid npm update npmPrefix");
+  }
+  if (candidate.npmFallbackRegistryUrl) {
+    let registry;
+    try {
+      registry = new URL(String(candidate.npmFallbackRegistryUrl));
+    } catch {
+      throw new Error("Invalid npm update registry");
+    }
+    if (!["http:", "https:"].includes(registry.protocol)) {
+      throw new Error("Invalid npm update registry");
+    }
+  }
+  const expectedStagingRoot = path.join(
+    String(candidate.stagingPrefix),
+    "lib",
+    "node_modules",
+    String(candidate.packageName)
+  );
+  if (path.resolve(String(candidate.stagingPackageRoot)) !== path.resolve(expectedStagingRoot)) {
+    throw new Error("Invalid npm update stagingPackageRoot");
+  }
+  if (path.resolve(String(candidate.stagingPackageRoot)) === path.resolve(String(candidate.packageRoot))) {
+    throw new Error("npm update staging root must differ from the running package root");
+  }
+  return payload;
+}
+function stateFor(payload, phase, extra = {}) {
+  return {
+    method: "npm",
+    phase,
+    version: payload.targetVersion,
+    previousVersion: payload.previousVersion,
+    packageName: payload.packageName,
+    startedAt: payload.startedAt,
+    logPath: payload.logPath,
+    stagingPrefix: payload.stagingPrefix,
+    stagingPackageRoot: payload.stagingPackageRoot,
+    ...extra
+  };
+}
+function startArguments(payload) {
+  const args = [
+    payload.cliPath,
+    "daemon",
+    "--port",
+    String(payload.port),
+    "--base-path",
+    payload.basePath,
+    "--config-dir",
+    payload.configDir
+  ];
+  if (payload.serverHome) args.push("--home", payload.serverHome);
+  if (payload.disableAuth) args.push("--no-auth");
+  return args;
+}
+function commandEnvironment() {
+  const env = { ...process.env };
+  delete env.FARMING_NPM_UPDATE_PAYLOAD;
+  delete env.FARMING_RUN_SERVER;
+  delete env.FARMING_RUN_NATIVE_PTY_HOST;
+  return env;
+}
+async function installPackage(payload, version, npmPrefix = payload.npmPrefix) {
+  const packageSpec = `${payload.packageName}@${version}`;
+  return installPackageFromRegistry(payload, packageSpec, "", npmPrefix);
+}
+function verifyInstalledVersion(payload, expectedVersion, packageRoot = payload.packageRoot) {
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  let metadata;
+  try {
+    metadata = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Installed ${payload.packageName} package metadata is unreadable: ${errorMessage(error)}`,
+      { cause: error }
+    );
+  }
+  const actualVersion = String(isObject(metadata) ? metadata.version || "" : "");
+  if (actualVersion !== expectedVersion) {
+    throw new Error(`Installed ${payload.packageName} version mismatch: expected ${expectedVersion}, found ${actualVersion || "missing"}`);
+  }
+}
+function logSize(filePath) {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function logSince(filePath, offset) {
+  try {
+    return fs.readFileSync(filePath, "utf8").slice(offset);
+  } catch {
+    return "";
+  }
+}
+async function installPackageFromRegistry(payload, packageSpec, registryUrl = "", npmPrefix = payload.npmPrefix) {
+  appendLog(payload.logPath, `Installing ${packageSpec}${registryUrl ? " from the update-status registry" : ""}`);
+  const args = ["install", "--global"];
+  if (npmPrefix) args.push("--prefix", npmPrefix);
+  if (registryUrl) args.push("--registry", registryUrl);
+  args.push(packageSpec, "--no-audit", "--no-fund");
+  const offset = logSize(payload.logPath);
+  try {
+    await runCommand(payload.npmCommand || "npm", args, {
+      cwd: payload.configDir,
+      env: commandEnvironment(),
+      logPath: payload.logPath
+    });
+  } catch (error) {
+    if (!registryUrl && payload.npmFallbackRegistryUrl && /(?:ETARGET|No matching version found)/.test(logSince(payload.logPath, offset))) {
+      appendLog(payload.logPath, `Configured npm registry has no ${packageSpec}; retrying from the update-status registry`);
+      return installPackageFromRegistry(payload, packageSpec, payload.npmFallbackRegistryUrl, npmPrefix);
+    }
+    throw error;
+  }
+}
+async function startServer(payload, version = payload.targetVersion) {
+  appendLog(payload.logPath, `Starting Farming ${version}`);
+  await runCommand(payload.nodePath, startArguments(payload), {
+    cwd: payload.configDir,
+    env: commandEnvironment(),
+    logPath: payload.logPath
+  });
+}
+async function prepareNpmUpdate(payload) {
+  try {
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "installing"));
+    fs.mkdirSync(payload.stagingPrefix, { recursive: true });
+    await installPackage(payload, payload.targetVersion, payload.stagingPrefix);
+    verifyInstalledVersion(payload, payload.targetVersion, payload.stagingPackageRoot);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "preparing-runtimes"));
+    appendLog(payload.logPath, `Preparing Farming ${payload.targetVersion} startup dependencies`);
+    await runCommand(payload.nodePath, [
+      path.join(payload.stagingPackageRoot, "bin", "farming"),
+      "runtime",
+      "prepare",
+      "--config-dir",
+      payload.configDir,
+      "--no-activate"
+    ], {
+      cwd: payload.configDir,
+      env: commandEnvironment(),
+      logPath: payload.logPath
+    });
+    const preparedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "ready-to-restart", {
+      preparedAt,
+      runtimePreparedAt: preparedAt
+    }));
+    appendLog(payload.logPath, `Farming ${payload.targetVersion} is ready to restart`);
+  } catch (error) {
+    const message = errorMessage(error);
+    appendLog(payload.logPath, `Update preparation failed: ${message}`);
+    try {
+      fs.rmSync(payload.stagingPrefix, { recursive: true, force: true });
+    } catch (cleanupError) {
+      appendLog(payload.logPath, `Update preparation cleanup failed: ${errorMessage(cleanupError)}`);
+    }
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "failed", {
+      error: message,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+}
+async function applyNpmUpdate(payload) {
+  const backupRoot = path.join(
+    path.dirname(payload.packageRoot),
+    `.${path.basename(payload.packageRoot)}.backup-${process.pid}`
+  );
+  let stoppedOldServer = false;
+  let movedOldPackage = false;
+  let movedNewPackage = false;
+  try {
+    verifyInstalledVersion(payload, payload.previousVersion, payload.packageRoot);
+    verifyInstalledVersion(payload, payload.targetVersion, payload.stagingPackageRoot);
+    if (fs.existsSync(backupRoot)) throw new Error(`npm update backup already exists: ${backupRoot}`);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "restarting", {
+      preparedAt: payload.preparedAt
+    }));
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    await stopProcess(Number(payload.serverPid), payload.serverProcessIdentity);
+    stoppedOldServer = true;
+    fs.renameSync(payload.packageRoot, backupRoot);
+    movedOldPackage = true;
+    fs.renameSync(payload.stagingPackageRoot, payload.packageRoot);
+    movedNewPackage = true;
+    await startServer(payload);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "succeeded", {
+      preparedAt: payload.preparedAt,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    appendLog(payload.logPath, `Farming updated to ${payload.targetVersion}`);
+    try {
+      fs.rmSync(backupRoot, { recursive: true, force: true });
+      fs.rmSync(payload.stagingPrefix, { recursive: true, force: true });
+    } catch (cleanupError) {
+      appendLog(payload.logPath, `Update cleanup failed: ${errorMessage(cleanupError)}`);
+    }
+  } catch (error) {
+    const message = errorMessage(error);
+    appendLog(payload.logPath, `Update apply failed: ${message}`);
+    if (stoppedOldServer || !isProcessRunning(Number(payload.serverPid))) {
+      try {
+        writeJsonAtomic(payload.stateFile, stateFor(payload, "rolling-back", {
+          preparedAt: payload.preparedAt,
+          error: message
+        }));
+        if (movedNewPackage && fs.existsSync(payload.packageRoot)) {
+          fs.mkdirSync(path.dirname(payload.stagingPackageRoot), { recursive: true });
+          fs.renameSync(payload.packageRoot, payload.stagingPackageRoot);
+        }
+        if (movedOldPackage && fs.existsSync(backupRoot)) {
+          fs.renameSync(backupRoot, payload.packageRoot);
+        }
+        verifyInstalledVersion(payload, payload.previousVersion, payload.packageRoot);
+        await startServer(payload, payload.previousVersion);
+        writeJsonAtomic(payload.stateFile, stateFor(payload, "rolled-back", {
+          version: payload.previousVersion,
+          attemptedVersion: payload.targetVersion,
+          preparedAt: payload.preparedAt,
+          error: message,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        appendLog(payload.logPath, `Rolled back to ${payload.previousVersion}`);
+        try {
+          fs.rmSync(payload.stagingPrefix, { recursive: true, force: true });
+        } catch (cleanupError) {
+          appendLog(payload.logPath, `Rollback cleanup failed: ${errorMessage(cleanupError)}`);
+        }
+        return;
+      } catch (rollbackError) {
+        const rollbackMessage = errorMessage(rollbackError);
+        writeJsonAtomic(payload.stateFile, stateFor(payload, "failed", {
+          error: `${message}; rollback failed: ${rollbackMessage}`,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        return;
+      }
+    }
+    writeJsonAtomic(payload.stateFile, stateFor(payload, "failed", {
+      preparedAt: payload.preparedAt,
+      error: message,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+}
+async function runNpmUpdate(rawPayload) {
+  const payload = validatePayload(rawPayload);
+  if (payload.action === "prepare") return prepareNpmUpdate(payload);
+  return applyNpmUpdate(payload);
+}
+if (require.main === module) {
+  let payload;
+  try {
+    payload = JSON.parse(process.env.FARMING_NPM_UPDATE_PAYLOAD || "");
+  } catch {
+    console.error("Invalid FARMING_NPM_UPDATE_PAYLOAD");
+    process.exit(1);
+  }
+  runNpmUpdate(payload).catch((error) => {
+    console.error(errorMessage(error));
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isProcessRunning,
+  runNpmUpdate,
+  stopProcess,
+  validatePayload,
+  verifyInstalledVersion,
+  writeJsonAtomic
+});

package/backend/packaged-node-pty.cjs

@@ -0,0 +1,120 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var packaged_node_pty_exports = {};
+__export(packaged_node_pty_exports, {
+  copyIfExists: () => copyIfExists,
+  copyPackagedSpawnHelper: () => copyPackagedSpawnHelper,
+  isPackagedRuntime: () => isPackagedRuntime,
+  nodePty: () => nodePty,
+  preparePackagedNodePtyRuntime: () => preparePackagedNodePtyRuntime
+});
+module.exports = __toCommonJS(packaged_node_pty_exports);
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { createRequire } = require("module");
+function isPackagedRuntime() {
+  return Boolean(process.pkg) || process.env.FARMING_PACKAGED_RUNTIME === "1";
+}
+function packagedNodePtyTargetDir() {
+  const baseDir = process.env.FARMING_CONFIG_DIR || path.join(os.homedir(), ".farming");
+  return path.join(baseDir, "runtime", "node-pty", `${process.platform}-${process.arch}`);
+}
+function copyIfExists(source, target, mode) {
+  if (!fs.existsSync(source)) return false;
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  let unchanged = false;
+  try {
+    const sourceStat = fs.statSync(source);
+    const targetStat = fs.statSync(target);
+    unchanged = sourceStat.size === targetStat.size && fs.readFileSync(source).equals(fs.readFileSync(target));
+  } catch {
+    unchanged = false;
+  }
+  if (!unchanged) {
+    const temporary = `${target}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+      fs.copyFileSync(source, temporary, fs.constants.COPYFILE_EXCL);
+      if (mode !== void 0) fs.chmodSync(temporary, mode);
+      fs.renameSync(temporary, target);
+    } finally {
+      fs.rmSync(temporary, { force: true });
+    }
+  } else if (mode !== void 0) {
+    fs.chmodSync(target, mode);
+  }
+  return true;
+}
+function nodePtyPackageRoot() {
+  if (isPackagedRuntime()) {
+    return path.join(__dirname, "..", "node_modules", "node-pty");
+  }
+  return path.dirname(createRequire(__filename).resolve("node-pty/package.json"));
+}
+function loadNativeModule(modulePath) {
+  const commonJsModule = module;
+  const runtimeRequire = commonJsModule.require ? commonJsModule.require.bind(commonJsModule) : require;
+  return runtimeRequire(modulePath);
+}
+function preparePackagedNodePtyRuntime(nativeName = "pty") {
+  if (!isPackagedRuntime()) return "";
+  const packageRoot = nodePtyPackageRoot();
+  const prebuildDir = path.join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`);
+  const targetDir = packagedNodePtyTargetDir();
+  const nativeFile = `${nativeName}.node`;
+  const nativeCopied = copyIfExists(
+    path.join(prebuildDir, nativeFile),
+    path.join(targetDir, nativeFile)
+  );
+  copyIfExists(
+    path.join(prebuildDir, "spawn-helper"),
+    path.join(targetDir, "spawn-helper"),
+    493
+  );
+  return nativeCopied ? targetDir : "";
+}
+function copyPackagedSpawnHelper() {
+  return preparePackagedNodePtyRuntime("pty");
+}
+function loadNodePty() {
+  if (isPackagedRuntime()) {
+    const utils = require("node-pty/lib/utils");
+    utils.loadNativeModule = function patchedLoadNativeModule(name) {
+      const runtimeDir = preparePackagedNodePtyRuntime(name);
+      if (runtimeDir) {
+        return {
+          dir: runtimeDir,
+          module: loadNativeModule(path.join(runtimeDir, `${name}.node`))
+        };
+      }
+      throw new Error(`Failed to load packaged node-pty native module: ${name}.node`);
+    };
+  }
+  return require("node-pty");
+}
+const nodePty = loadNodePty();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyIfExists,
+  copyPackagedSpawnHelper,
+  isPackagedRuntime,
+  nodePty,
+  preparePackagedNodePtyRuntime
+});

package/backend/preview-session-manager.cjs

@@ -0,0 +1,89 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var preview_session_manager_exports = {};
+__export(preview_session_manager_exports, {
+  DEFAULT_PREVIEW_SESSION_TTL_MS: () => DEFAULT_PREVIEW_SESSION_TTL_MS,
+  PreviewSessionManager: () => PreviewSessionManager
+});
+module.exports = __toCommonJS(preview_session_manager_exports);
+const crypto = require("crypto");
+const DEFAULT_PREVIEW_SESSION_TTL_MS = 30 * 60 * 1e3;
+const DEFAULT_MAX_PREVIEW_SESSIONS = 128;
+class PreviewSessionManager {
+  maxSessions;
+  now;
+  randomUUID;
+  sessions = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(options = {}) {
+    this.ttlMs = Math.max(1e3, Number(options.ttlMs) || DEFAULT_PREVIEW_SESSION_TTL_MS);
+    this.maxSessions = Math.max(1, Number(options.maxSessions) || DEFAULT_MAX_PREVIEW_SESSIONS);
+    this.now = options.now || (() => Date.now());
+    this.randomUUID = options.randomUUID || (() => crypto.randomUUID());
+  }
+  createStatic(input) {
+    this.cleanupExpired();
+    while (this.sessions.size >= this.maxSessions) {
+      const oldestId = this.sessions.keys().next().value;
+      if (!oldestId) break;
+      this.sessions.delete(oldestId);
+    }
+    const now = this.now();
+    const session = Object.freeze({
+      id: this.randomUUID(),
+      kind: "static",
+      rootId: input.rootId,
+      workspaceRoot: input.workspaceRoot,
+      authorizedRoot: input.authorizedRoot,
+      entryPath: input.entryPath,
+      baseDirectory: input.baseDirectory,
+      createdAt: now,
+      expiresAt: now + this.ttlMs
+    });
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  get(sessionId) {
+    const session = this.sessions.get(String(sessionId || ""));
+    if (!session) return null;
+    if (session.expiresAt <= this.now()) {
+      this.sessions.delete(session.id);
+      return null;
+    }
+    return session;
+  }
+  delete(sessionId) {
+    return this.sessions.delete(String(sessionId || ""));
+  }
+  cleanupExpired() {
+    const now = this.now();
+    for (const [sessionId, session] of this.sessions) {
+      if (session.expiresAt <= now) this.sessions.delete(sessionId);
+    }
+  }
+  dispose() {
+    this.sessions.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PREVIEW_SESSION_TTL_MS,
+  PreviewSessionManager
+});