@fml-inc/fml 0.8.6 → 0.8.7

package/dist/{chunk-YFHZJPTC.js → chunk-6BTC3S7C.js}

@@ -1,7 +1,9 @@
 import {
-  resolvePackageRoot,
   runRawSyncOnce
-} from "./chunk-V2XC7JTB.js";
+} from "./chunk-5JJQWV4G.js";
+import {
+  resolvePackageRoot
+} from "./chunk-F57IFY3K.js";
 
 // src/observer/sync-cycle.ts
 import { fork } from "child_process";

package/dist/chunk-F57IFY3K.js

@@ -0,0 +1,21 @@
+// src/package-root.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function resolvePackageRoot(startDir = path.dirname(fileURLToPath(import.meta.url))) {
+  let directory = startDir;
+  while (true) {
+    if (fs.existsSync(path.join(directory, "package.json")) && fs.existsSync(path.join(directory, "bin"))) {
+      return directory;
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) {
+      throw new Error(`Could not resolve FML package root from ${startDir}`);
+    }
+    directory = parent;
+  }
+}
+
+export {
+  resolvePackageRoot
+};

package/dist/{chunk-2DQQXBWM.js → chunk-LPSZCTTJ.js}

@@ -1,5 +1,6 @@
 import {
-  FML_HOOK_CAPTURE_DISABLED_FILE
+  FML_HOOK_CAPTURE_DISABLED_FILE,
+  FML_OBSERVER_LOG_FILE
 } from "./chunk-B3H2YWPJ.js";
 
 // src/json-file.ts
@@ -100,7 +101,42 @@ function setHookCaptureDisabled(disabled, stateFile = FML_HOOK_CAPTURE_DISABLED_
   fs2.rmSync(stateFile, { force: true });
 }
 
+// src/observer/log-file.ts
+import fs3 from "fs";
+import path3 from "path";
+var LOG_ROTATE_BYTES = 10 * 1024 * 1024;
+var LOG_ROTATE_FILES = 3;
+function rotateObserverLog() {
+  let size = 0;
+  try {
+    size = fs3.statSync(FML_OBSERVER_LOG_FILE).size;
+  } catch {
+    return;
+  }
+  if (size < LOG_ROTATE_BYTES) return;
+  try {
+    fs3.rmSync(`${FML_OBSERVER_LOG_FILE}.${LOG_ROTATE_FILES}`, { force: true });
+    for (let index = LOG_ROTATE_FILES - 1; index >= 1; index -= 1) {
+      const source = `${FML_OBSERVER_LOG_FILE}.${index}`;
+      if (fs3.existsSync(source)) {
+        fs3.renameSync(source, `${FML_OBSERVER_LOG_FILE}.${index + 1}`);
+      }
+    }
+    fs3.renameSync(FML_OBSERVER_LOG_FILE, `${FML_OBSERVER_LOG_FILE}.1`);
+  } catch {
+  }
+}
+function openObserverLog() {
+  fs3.mkdirSync(path3.dirname(FML_OBSERVER_LOG_FILE), {
+    recursive: true,
+    mode: 448
+  });
+  rotateObserverLog();
+  return fs3.openSync(FML_OBSERVER_LOG_FILE, "a", 384);
+}
+
 export {
+  openObserverLog,
   readJsonFile,
   writeTextFileAtomic,
   writeJsonFile,

package/dist/chunk-XFALHTDL.js

@@ -0,0 +1,277 @@
+import {
+  Sentry
+} from "./chunk-B3H2YWPJ.js";
+
+// src/bin-utils.ts
+import fs from "fs";
+import path from "path";
+import { execFileSync, execSync } from "child_process";
+var IS_WIN = process.platform === "win32";
+var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+function resolveBin(name) {
+  const pathDirs = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+  const hasExt = path.extname(name) !== "";
+  const exts = !IS_WIN || hasExt ? [""] : (process.env.PATHEXT ?? DEFAULT_PATHEXT).split(";").filter(Boolean);
+  for (const dir of pathDirs) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, name + ext);
+      try {
+        if (fs.statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isWinShim(bin) {
+  return IS_WIN && /\.(cmd|bat)$/i.test(bin);
+}
+function quoteWinArg(arg) {
+  if (arg.length === 0) return '""';
+  if (/^[A-Za-z0-9@\-_+=:/.,]+$/.test(arg)) return arg;
+  const crt = arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1");
+  const quoted = `"${crt}"`;
+  return quoted.replace(/([()%!^<>&|"])/g, "^$1");
+}
+function execBinSync(bin, args, opts = {}) {
+  const {
+    timeout = 1e4,
+    encoding = "utf-8",
+    stdio = "pipe",
+    env = process.env
+  } = opts;
+  if (isWinShim(bin)) {
+    const command = [bin, ...args].map(quoteWinArg).join(" ");
+    return execSync(command, { timeout, encoding, stdio, env });
+  }
+  return execFileSync(bin, args, { timeout, encoding, stdio, env });
+}
+
+// src/commands/update.ts
+var SEMVER_PATTERN = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-((?:0|[1-9][0-9]*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9][0-9]*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var PACKAGE_NAME = "@fml-inc/fml";
+var UPDATE_TIMEOUT_MS = 12e4;
+var SETUP_TIMEOUT_MS = 3e5;
+function getCurrentVersion() {
+  return true ? "0.8.7+af45d2af" : "unknown";
+}
+function parseVersion(version) {
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) return null;
+  return {
+    major: match[1],
+    minor: match[2],
+    patch: match[3],
+    prerelease: match[4]?.split(".") ?? []
+  };
+}
+function compareNumericIdentifiers(left, right) {
+  if (left.length !== right.length) return left.length - right.length;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function compareIdentifiers(left, right) {
+  const leftIsNumeric = /^[0-9]+$/u.test(left);
+  const rightIsNumeric = /^[0-9]+$/u.test(right);
+  if (leftIsNumeric && rightIsNumeric) {
+    return compareNumericIdentifiers(left, right);
+  }
+  if (leftIsNumeric) return -1;
+  if (rightIsNumeric) return 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function compareVersions(left, right) {
+  const leftVersion = parseVersion(left);
+  const rightVersion = parseVersion(right);
+  if (!leftVersion || !rightVersion) {
+    throw new Error("FML update requires valid semantic versions.");
+  }
+  for (const part of ["major", "minor", "patch"]) {
+    const difference = compareNumericIdentifiers(
+      leftVersion[part],
+      rightVersion[part]
+    );
+    if (difference) return difference;
+  }
+  if (!leftVersion.prerelease.length && !rightVersion.prerelease.length) {
+    return 0;
+  }
+  if (!leftVersion.prerelease.length) return 1;
+  if (!rightVersion.prerelease.length) return -1;
+  const length = Math.max(
+    leftVersion.prerelease.length,
+    rightVersion.prerelease.length
+  );
+  for (let index = 0; index < length; index += 1) {
+    const leftIdentifier = leftVersion.prerelease[index];
+    const rightIdentifier = rightVersion.prerelease[index];
+    if (leftIdentifier === void 0) return -1;
+    if (rightIdentifier === void 0) return 1;
+    const difference = compareIdentifiers(leftIdentifier, rightIdentifier);
+    if (difference) return difference;
+  }
+  return 0;
+}
+function isUpdatableVersion(version) {
+  if (version === "dev" || version === "unknown") return false;
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  if (parsed.prerelease.includes("dev")) return false;
+  return true;
+}
+function resolveUpdateChannel(version) {
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) return "latest";
+  const prerelease = match[4];
+  if (!prerelease) return "latest";
+  return prerelease.split(".").every((identifier) => {
+    return !(identifier.length > 1 && identifier.startsWith("0") && /^[0-9]+$/u.test(identifier));
+  }) ? "next" : "latest";
+}
+function resolveUpdateTarget(version) {
+  return `${PACKAGE_NAME}@${resolveUpdateChannel(version)}`;
+}
+function createUpdateEnvironment(env) {
+  const updateEnv = { ...env };
+  for (const key of Object.keys(updateEnv)) {
+    if (key.toLowerCase() === "npm_config_registry") {
+      delete updateEnv[key];
+    }
+  }
+  return updateEnv;
+}
+function parseAvailableVersion(output) {
+  let response;
+  try {
+    response = JSON.parse(output);
+  } catch {
+    throw new Error("Could not read the available FML version from npm.");
+  }
+  const version = Array.isArray(response) && response.length === 1 ? response[0] : response;
+  if (typeof version !== "string" || !parseVersion(version)) {
+    throw new Error("Could not read the available FML version from npm.");
+  }
+  return version;
+}
+async function checkForUpdate(dependencies) {
+  if (!isUpdatableVersion(dependencies.currentVersion)) {
+    throw new Error("FML update requires a released semantic version.");
+  }
+  const channel = resolveUpdateChannel(dependencies.currentVersion);
+  const target = resolveUpdateTarget(dependencies.currentVersion);
+  const updateEnv = createUpdateEnvironment(dependencies.env);
+  let output;
+  if (dependencies.runNpmView) {
+    output = await dependencies.runNpmView(target, updateEnv);
+  } else {
+    const npm = dependencies.resolveBin?.("npm");
+    if (!npm) throw new Error("npm was not found on PATH");
+    if (!dependencies.execBinSync) {
+      throw new Error("FML update check requires an npm view runner.");
+    }
+    output = dependencies.execBinSync(
+      npm,
+      ["view", target, "version", "--json"],
+      {
+        timeout: UPDATE_TIMEOUT_MS,
+        env: updateEnv
+      }
+    );
+  }
+  const latest = parseAvailableVersion(output);
+  return {
+    current: dependencies.currentVersion,
+    latest,
+    channel,
+    newer: compareVersions(latest, dependencies.currentVersion) > 0
+  };
+}
+function formatUpdateError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const stderr = err.stderr;
+  if (typeof stderr === "string") return stderr;
+  if (Buffer.isBuffer(stderr)) return stderr.toString();
+  return err.message;
+}
+async function handleUpdate(overrides = {}) {
+  const dependencies = {
+    currentVersion: getCurrentVersion(),
+    env: process.env,
+    resolveBin,
+    execBinSync,
+    captureException: Sentry.captureException,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+    nonInteractive: false,
+    ...overrides
+  };
+  dependencies.log(`Current version: ${dependencies.currentVersion}`);
+  if (!isUpdatableVersion(dependencies.currentVersion)) {
+    dependencies.log("This is a development build; `fml update` is disabled.");
+    return;
+  }
+  try {
+    const npm = dependencies.resolveBin("npm");
+    if (!npm) throw new Error("npm was not found on PATH");
+    const check = await checkForUpdate({
+      ...dependencies,
+      resolveBin: () => npm
+    });
+    if (!check.newer) {
+      dependencies.log(
+        `FML is already up to date (${dependencies.currentVersion}).`
+      );
+      return;
+    }
+    const updateEnv = createUpdateEnvironment(dependencies.env);
+    const availableVersion = check.latest;
+    const channel = check.channel;
+    dependencies.log(
+      `Updating FML from ${dependencies.currentVersion} to ${availableVersion} on the ${channel} channel...
+`
+    );
+    dependencies.execBinSync(
+      npm,
+      ["install", "--global", `${PACKAGE_NAME}@${availableVersion}`],
+      { timeout: UPDATE_TIMEOUT_MS, env: updateEnv }
+    );
+    dependencies.log(
+      `
+FML updated from ${dependencies.currentVersion} to ${availableVersion}. Refreshing setup...`
+    );
+    try {
+      const fml = dependencies.resolveBin("fml");
+      if (!fml) throw new Error("Updated FML was not found on PATH");
+      dependencies.execBinSync(
+        fml,
+        dependencies.nonInteractive ? ["setup", "--non-interactive"] : ["setup"],
+        { timeout: SETUP_TIMEOUT_MS, stdio: "inherit" }
+      );
+      dependencies.log("FML setup complete.");
+    } catch (err) {
+      dependencies.captureException(err);
+      dependencies.error(
+        "FML updated, but setup failed:",
+        formatUpdateError(err)
+      );
+      dependencies.error("Run `fml setup` to finish refreshing FML.");
+      dependencies.exit(1);
+    }
+  } catch (err) {
+    dependencies.captureException(err);
+    dependencies.error("Update failed:", formatUpdateError(err));
+    dependencies.exit(1);
+  }
+}
+
+export {
+  resolveBin,
+  isWinShim,
+  quoteWinArg,
+  execBinSync,
+  isUpdatableVersion,
+  checkForUpdate,
+  handleUpdate
+};