@fml-inc/fml 0.0.26 → 0.0.28

package/dist/cli.js

@@ -1,9 +1,15 @@
 #!/usr/bin/env node
+import {
+  config,
+  loadUnifiedConfig,
+  saveUnifiedConfig
+} from "./chunk-NLFKYSN7.js";
 import {
   createApiClient,
   ensureNativeModules,
   getAuthenticatedClient
-} from "./chunk-WXDGVKXK.js";
+} from "./chunk-ECXIFGGY.js";
+import "./chunk-UALBZA5X.js";
 import {
   AUTH_STORE_PATH,
   CONVEX_URL,
@@ -14,33 +20,1766 @@ import {
   WORKOS_AUTH_URL,
   getActiveEnv,
   getSelectedOrg,
+  getSiteUrl,
   getValidToken,
   initSentry,
   readTokens,
   setSelectedOrg,
   writeEnvConfig,
   writeTokens
-} from "./chunk-FS55W24B.js";
+} from "./chunk-USJO3G5V.js";
 import {
   handleStart,
   handleStop,
-  panopticonExec,
   parsePanopticonRunning
-} from "./chunk-EL2WSQBR.js";
+} from "./chunk-YIWT7BWN.js";
+import {
+  panopticonExec
+} from "./chunk-ZA4RG25C.js";
 import {
   FML_DATA_DIR,
   FML_LOG_DIR
 } from "./chunk-4YEAQJPF.js";
+import "./chunk-2CRFCFE4.js";
 import "./chunk-PZ5AY32C.js";
 
-// src/cli.ts
-import { Command } from "commander";
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/doctor.ts
+import ora from "ora";
+import pc from "picocolors";
+
+// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-6NMLAGHC.js
+import os from "os";
+import path from "path";
+function urlToObject(url) {
+  return {
+    href: url.href,
+    protocol: url.protocol,
+    username: url.username,
+    password: url.password,
+    host: url.host,
+    hostname: url.hostname,
+    port: url.port,
+    pathname: url.pathname,
+    search: url.search,
+    searchParams: [...url.searchParams].map(([key, value]) => ({ key, value })),
+    hash: url.hash,
+    origin: url.origin
+  };
+}
+var prettyLogStyles = {
+  reset: [0, 0],
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  overline: [53, 55],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  blackBright: [90, 39],
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  bgBlackBright: [100, 49],
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49]
+};
+function formatTemplate(settings, template, values, hideUnsetPlaceholder = false) {
+  const templateString = String(template);
+  const ansiColorWrap = (placeholderValue, code) => `\x1B[${code[0]}m${placeholderValue}\x1B[${code[1]}m`;
+  const styleWrap = (value, style) => {
+    if (style != null && typeof style === "string") {
+      return ansiColorWrap(value, prettyLogStyles[style]);
+    } else if (style != null && Array.isArray(style)) {
+      return style.reduce((prevValue, thisStyle) => styleWrap(prevValue, thisStyle), value);
+    } else {
+      if (style != null && style[value.trim()] != null) {
+        return styleWrap(value, style[value.trim()]);
+      } else if (style != null && style["*"] != null) {
+        return styleWrap(value, style["*"]);
+      } else {
+        return value;
+      }
+    }
+  };
+  const defaultStyle = null;
+  return templateString.replace(/{{(.+?)}}/g, (_, placeholder) => {
+    const value = values[placeholder] != null ? String(values[placeholder]) : hideUnsetPlaceholder ? "" : _;
+    return settings.stylePrettyLogs ? styleWrap(value, settings?.prettyLogStyles?.[placeholder] ?? defaultStyle) + ansiColorWrap("", prettyLogStyles.reset) : value;
+  });
+}
+function formatNumberAddZeros(value, digits = 2, addNumber = 0) {
+  if (value != null && isNaN(value)) {
+    return "";
+  }
+  value = value != null ? value + addNumber : value;
+  return digits === 2 ? value == null ? "--" : value < 10 ? "0" + value : value.toString() : value == null ? "---" : value < 10 ? "00" + value : value < 100 ? "0" + value : value.toString();
+}
+function buildPrettyMeta(settings, meta) {
+  if (meta == null) {
+    return {
+      text: "",
+      template: settings.prettyLogTemplate,
+      placeholders: {}
+    };
+  }
+  let template = settings.prettyLogTemplate;
+  const placeholderValues = {};
+  if (template.includes("{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}")) {
+    template = template.replace("{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}", "{{dateIsoStr}}");
+  } else {
+    if (settings.prettyLogTimeZone === "UTC") {
+      placeholderValues["yyyy"] = meta.date?.getUTCFullYear() ?? "----";
+      placeholderValues["mm"] = formatNumberAddZeros(meta.date?.getUTCMonth(), 2, 1);
+      placeholderValues["dd"] = formatNumberAddZeros(meta.date?.getUTCDate(), 2);
+      placeholderValues["hh"] = formatNumberAddZeros(meta.date?.getUTCHours(), 2);
+      placeholderValues["MM"] = formatNumberAddZeros(meta.date?.getUTCMinutes(), 2);
+      placeholderValues["ss"] = formatNumberAddZeros(meta.date?.getUTCSeconds(), 2);
+      placeholderValues["ms"] = formatNumberAddZeros(meta.date?.getUTCMilliseconds(), 3);
+    } else {
+      placeholderValues["yyyy"] = meta.date?.getFullYear() ?? "----";
+      placeholderValues["mm"] = formatNumberAddZeros(meta.date?.getMonth(), 2, 1);
+      placeholderValues["dd"] = formatNumberAddZeros(meta.date?.getDate(), 2);
+      placeholderValues["hh"] = formatNumberAddZeros(meta.date?.getHours(), 2);
+      placeholderValues["MM"] = formatNumberAddZeros(meta.date?.getMinutes(), 2);
+      placeholderValues["ss"] = formatNumberAddZeros(meta.date?.getSeconds(), 2);
+      placeholderValues["ms"] = formatNumberAddZeros(meta.date?.getMilliseconds(), 3);
+    }
+  }
+  const dateInSettingsTimeZone = settings.prettyLogTimeZone === "UTC" ? meta.date : meta.date != null ? new Date(meta.date.getTime() - meta.date.getTimezoneOffset() * 6e4) : void 0;
+  placeholderValues["rawIsoStr"] = dateInSettingsTimeZone?.toISOString() ?? "";
+  placeholderValues["dateIsoStr"] = dateInSettingsTimeZone?.toISOString().replace("T", " ").replace("Z", "") ?? "";
+  placeholderValues["logLevelName"] = meta.logLevelName;
+  placeholderValues["fileNameWithLine"] = meta.path?.fileNameWithLine ?? "";
+  placeholderValues["filePathWithLine"] = meta.path?.filePathWithLine ?? "";
+  placeholderValues["fullFilePath"] = meta.path?.fullFilePath ?? "";
+  let parentNamesString = settings.parentNames?.join(settings.prettyErrorParentNamesSeparator);
+  parentNamesString = parentNamesString != null && meta.name != null ? parentNamesString + settings.prettyErrorParentNamesSeparator : void 0;
+  const combinedName = meta.name != null || parentNamesString != null ? `${parentNamesString ?? ""}${meta.name ?? ""}` : "";
+  placeholderValues["name"] = combinedName;
+  placeholderValues["nameWithDelimiterPrefix"] = combinedName.length > 0 ? settings.prettyErrorLoggerNameDelimiter + combinedName : "";
+  placeholderValues["nameWithDelimiterSuffix"] = combinedName.length > 0 ? combinedName + settings.prettyErrorLoggerNameDelimiter : "";
+  if (settings.overwrite?.addPlaceholders != null) {
+    settings.overwrite.addPlaceholders(meta, placeholderValues);
+  }
+  return {
+    text: formatTemplate(settings, template, placeholderValues),
+    template,
+    placeholders: placeholderValues
+  };
+}
+var DEFAULT_IGNORE_PATTERNS = [
+  /(?:^|[\\/])node_modules[\\/].*tslog/i,
+  /(?:^|[\\/])deps[\\/].*tslog/i,
+  /tslog[\\/]+src[\\/]+internal[\\/]/i,
+  /tslog[\\/]+src[\\/]BaseLogger/i,
+  /tslog[\\/]+src[\\/]index/i
+];
+function splitStackLines(error) {
+  const stack = typeof error?.stack === "string" ? error.stack : void 0;
+  if (stack == null || stack.length === 0) {
+    return [];
+  }
+  return stack.split("\n").map((line) => line.trimEnd());
+}
+function sanitizeStackLines(lines) {
+  return lines.filter((line) => line.length > 0 && !/^\s*Error\b/.test(line));
+}
+function toStackFrames(lines, parseLine) {
+  const frames = [];
+  for (const line of lines) {
+    const frame = parseLine(line);
+    if (frame != null) {
+      frames.push(frame);
+    }
+  }
+  return frames;
+}
+function findFirstExternalFrameIndex(frames, ignorePatterns = DEFAULT_IGNORE_PATTERNS) {
+  for (let index = 0; index < frames.length; index += 1) {
+    const frame = frames[index];
+    const filePathCandidate = frame.filePath ?? "";
+    const fullPathCandidate = frame.fullFilePath ?? "";
+    if (!ignorePatterns.some((pattern) => pattern.test(filePathCandidate) || pattern.test(fullPathCandidate))) {
+      return index;
+    }
+  }
+  return 0;
+}
+function getCleanStackLines(error) {
+  return sanitizeStackLines(splitStackLines(error));
+}
+function buildStackTrace(error, parseLine) {
+  return toStackFrames(getCleanStackLines(error), parseLine);
+}
+function clampIndex(index, maxExclusive) {
+  if (index < 0) {
+    return 0;
+  }
+  if (index >= maxExclusive) {
+    return Math.max(0, maxExclusive - 1);
+  }
+  return index;
+}
+function getDefaultIgnorePatterns() {
+  return [...DEFAULT_IGNORE_PATTERNS];
+}
+var DEFAULT_CAUSE_DEPTH = 5;
+function collectErrorCauses(error, options = {}) {
+  const maxDepth = options.maxDepth ?? DEFAULT_CAUSE_DEPTH;
+  const causes = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = error;
+  let depth = 0;
+  while (current != null && depth < maxDepth) {
+    const cause = current?.cause;
+    if (cause == null || visited.has(cause)) {
+      break;
+    }
+    visited.add(cause);
+    causes.push(toError(cause));
+    current = cause;
+    depth += 1;
+  }
+  return causes;
+}
+function toError(value) {
+  if (value instanceof Error) {
+    return value;
+  }
+  const error = new Error(typeof value === "string" ? value : JSON.stringify(value));
+  if (typeof value === "object" && value != null) {
+    Object.assign(error, value);
+  }
+  return error;
+}
+function jsonStringifyRecursive(obj) {
+  const cache = /* @__PURE__ */ new Set();
+  return JSON.stringify(obj, (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (cache.has(value)) {
+        return "[Circular]";
+      }
+      cache.add(value);
+    }
+    if (typeof value === "bigint") {
+      return `${value}`;
+    }
+    if (typeof value === "undefined") {
+      return "[undefined]";
+    }
+    return value;
+  });
+}
+function inspect(obj, opts) {
+  const ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  if (opts != null) {
+    _extend(ctx, opts);
+  }
+  if (isUndefined(ctx.showHidden))
+    ctx.showHidden = false;
+  if (isUndefined(ctx.depth))
+    ctx.depth = 2;
+  if (isUndefined(ctx.colors))
+    ctx.colors = true;
+  if (isUndefined(ctx.customInspect))
+    ctx.customInspect = true;
+  if (ctx.colors)
+    ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+inspect.colors = prettyLogStyles;
+inspect.styles = {
+  special: "cyan",
+  number: "yellow",
+  boolean: "yellow",
+  undefined: "grey",
+  null: "bold",
+  string: "green",
+  date: "magenta",
+  regexp: "red"
+};
+function isBoolean(arg) {
+  return typeof arg === "boolean";
+}
+function isUndefined(arg) {
+  return arg === void 0;
+}
+function stylizeNoColor(str) {
+  return str;
+}
+function stylizeWithColor(str, styleType) {
+  const style = inspect.styles[styleType];
+  if (style != null && inspect?.colors?.[style]?.[0] != null && inspect?.colors?.[style]?.[1] != null) {
+    return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+  } else {
+    return str;
+  }
+}
+function isFunction(arg) {
+  return typeof arg === "function";
+}
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+function isNull(arg) {
+  return arg === null;
+}
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === "[object RegExp]";
+}
+function isObject(arg) {
+  return typeof arg === "object" && arg !== null;
+}
+function isError(e) {
+  return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+}
+function isDate(d) {
+  return isObject(d) && objectToString(d) === "[object Date]";
+}
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+function arrayToHash(array) {
+  const hash = {};
+  array.forEach((val) => {
+    hash[val] = true;
+  });
+  return hash;
+}
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  const output = [];
+  for (let i = 0, l = value.length; i < l; ++i) {
+    if (hasOwn(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+    } else {
+      output.push("");
+    }
+  }
+  keys.forEach((key) => {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+    }
+  });
+  return output;
+}
+function formatError(value) {
+  return "[" + Error.prototype.toString.call(value) + "]";
+}
+function formatValue(ctx, value, recurseTimes = 0) {
+  if (ctx.customInspect && value != null && isFunction(value) && value?.inspect !== inspect && !(value?.constructor && value?.constructor.prototype === value)) {
+    if (typeof value.inspect !== "function" && value.toString != null) {
+      return value.toString();
+    }
+    let ret = value?.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+  const primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+  let keys = Object.keys(value);
+  const visibleKeys = arrayToHash(keys);
+  try {
+    if (ctx.showHidden && Object.getOwnPropertyNames) {
+      keys = Object.getOwnPropertyNames(value);
+    }
+  } catch {
+  }
+  if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
+    return formatError(value);
+  }
+  if (keys.length === 0) {
+    if (isFunction(ctx.stylize)) {
+      if (isFunction(value)) {
+        const name = value.name ? ": " + value.name : "";
+        return ctx.stylize("[Function" + name + "]", "special");
+      }
+      if (isRegExp(value)) {
+        return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+      }
+      if (isDate(value)) {
+        return ctx.stylize(Date.prototype.toISOString.call(value), "date");
+      }
+      if (isError(value)) {
+        return formatError(value);
+      }
+    } else {
+      return value;
+    }
+  }
+  let base = "";
+  let array = false;
+  let braces = ["{\n", "\n}"];
+  if (Array.isArray(value)) {
+    array = true;
+    braces = ["[\n", "\n]"];
+  }
+  if (isFunction(value)) {
+    const n = value.name ? ": " + value.name : "";
+    base = " [Function" + n + "]";
+  }
+  if (isRegExp(value)) {
+    base = " " + RegExp.prototype.toString.call(value);
+  }
+  if (isDate(value)) {
+    base = " " + Date.prototype.toUTCString.call(value);
+  }
+  if (isError(value)) {
+    base = " " + formatError(value);
+  }
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+    } else {
+      return ctx.stylize("[Object]", "special");
+    }
+  }
+  ctx.seen.push(value);
+  let output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map((key) => {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+  ctx.seen.pop();
+  return reduceToSingleString(output, base, braces);
+}
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  let name, str;
+  let desc = { value: void 0 };
+  try {
+    desc.value = value[key];
+  } catch {
+  }
+  try {
+    if (Object.getOwnPropertyDescriptor) {
+      desc = Object.getOwnPropertyDescriptor(value, key) || desc;
+    }
+  } catch {
+  }
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize("[Getter/Setter]", "special");
+    } else {
+      str = ctx.stylize("[Getter]", "special");
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize("[Setter]", "special");
+    }
+  }
+  if (!hasOwn(visibleKeys, key)) {
+    name = "[" + key + "]";
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, void 0);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf("\n") > -1) {
+        if (array) {
+          str = str.split("\n").map((line) => {
+            return "  " + line;
+          }).join("\n").substr(2);
+        } else {
+          str = "\n" + str.split("\n").map((line) => {
+            return "   " + line;
+          }).join("\n");
+        }
+      }
+    } else {
+      str = ctx.stylize("[Circular]", "special");
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify("" + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, "name");
+    } else {
+      name = name.replace(/'/g, "\\'").replace(/\\"/g, "\\'").replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, "string");
+    }
+  }
+  return name + ": " + str;
+}
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize("undefined", "undefined");
+  if (isString(value)) {
+    const simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, "\\'") + "'";
+    return ctx.stylize(simple, "string");
+  }
+  if (isNumber(value))
+    return ctx.stylize("" + value, "number");
+  if (isBoolean(value))
+    return ctx.stylize("" + value, "boolean");
+  if (isNull(value))
+    return ctx.stylize("null", "null");
+}
+function reduceToSingleString(output, base, braces) {
+  return braces[0] + (base === "" ? "" : base + "\n") + "  " + output.join(",\n  ") + " " + braces[1];
+}
+function _extend(origin, add) {
+  const typedOrigin = { ...origin };
+  if (!add || !isObject(add))
+    return origin;
+  const clonedAdd = { ...add };
+  const keys = Object.keys(add);
+  let i = keys.length;
+  while (i--) {
+    typedOrigin[keys[i]] = clonedAdd[keys[i]];
+  }
+  return typedOrigin;
+}
+function formatWithOptions(inspectOptions, ...args) {
+  const ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  if (inspectOptions != null) {
+    _extend(ctx, inspectOptions);
+  }
+  const first = args[0];
+  let a = 0;
+  let str = "";
+  let join = "";
+  if (typeof first === "string") {
+    if (args.length === 1) {
+      return first;
+    }
+    let tempStr;
+    let lastPos = 0;
+    for (let i = 0; i < first.length - 1; i++) {
+      if (first.charCodeAt(i) === 37) {
+        const nextChar = first.charCodeAt(++i);
+        if (a + 1 !== args.length) {
+          switch (nextChar) {
+            case 115: {
+              const tempArg = args[++a];
+              if (typeof tempArg === "number") {
+                tempStr = formatPrimitive(ctx, tempArg);
+              } else if (typeof tempArg === "bigint") {
+                tempStr = formatPrimitive(ctx, tempArg);
+              } else if (typeof tempArg !== "object" || tempArg === null) {
+                tempStr = String(tempArg);
+              } else {
+                tempStr = inspect(tempArg, {
+                  ...inspectOptions,
+                  compact: 3,
+                  colors: false,
+                  depth: 0
+                });
+              }
+              break;
+            }
+            case 106:
+              tempStr = jsonStringifyRecursive(args[++a]);
+              break;
+            case 100: {
+              const tempNum = args[++a];
+              if (typeof tempNum === "bigint") {
+                tempStr = formatPrimitive(ctx, tempNum);
+              } else if (typeof tempNum === "symbol") {
+                tempStr = "NaN";
+              } else {
+                tempStr = formatPrimitive(ctx, tempNum);
+              }
+              break;
+            }
+            case 79:
+              tempStr = inspect(args[++a], inspectOptions);
+              break;
+            case 111:
+              tempStr = inspect(args[++a], {
+                ...inspectOptions,
+                showHidden: true,
+                showProxy: true,
+                depth: 4
+              });
+              break;
+            case 105: {
+              const tempInteger = args[++a];
+              if (typeof tempInteger === "bigint") {
+                tempStr = formatPrimitive(ctx, tempInteger);
+              } else if (typeof tempInteger === "symbol") {
+                tempStr = "NaN";
+              } else {
+                tempStr = formatPrimitive(ctx, parseInt(tempStr));
+              }
+              break;
+            }
+            case 102: {
+              const tempFloat = args[++a];
+              if (typeof tempFloat === "symbol") {
+                tempStr = "NaN";
+              } else {
+                tempStr = formatPrimitive(ctx, parseInt(tempFloat));
+              }
+              break;
+            }
+            case 99:
+              a += 1;
+              tempStr = "";
+              break;
+            case 37:
+              str += first.slice(lastPos, i);
+              lastPos = i + 1;
+              continue;
+            default:
+              continue;
+          }
+          if (lastPos !== i - 1) {
+            str += first.slice(lastPos, i - 1);
+          }
+          str += tempStr;
+          lastPos = i + 1;
+        } else if (nextChar === 37) {
+          str += first.slice(lastPos, i);
+          lastPos = i + 1;
+        }
+      }
+    }
+    if (lastPos !== 0) {
+      a++;
+      join = " ";
+      if (lastPos < first.length) {
+        str += first.slice(lastPos);
+      }
+    }
+  }
+  while (a < args.length) {
+    const value = args[a];
+    str += join;
+    str += typeof value !== "string" ? inspect(value, inspectOptions) : value;
+    join = " ";
+    a++;
+  }
+  return str;
+}
+function safeGetCwd() {
+  try {
+    const nodeProcess = globalThis?.process;
+    if (typeof nodeProcess?.cwd === "function") {
+      return nodeProcess.cwd();
+    }
+  } catch {
+  }
+  try {
+    const deno = globalThis?.["Deno"];
+    if (typeof deno?.cwd === "function") {
+      return deno.cwd();
+    }
+  } catch {
+  }
+  return void 0;
+}
+function isBrowserEnvironment() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function consoleSupportsCssStyling() {
+  if (!isBrowserEnvironment()) {
+    return false;
+  }
+  const navigatorObj = globalThis?.navigator;
+  const userAgent = navigatorObj?.userAgent ?? "";
+  if (/firefox/i.test(userAgent)) {
+    return true;
+  }
+  const windowObj = globalThis;
+  if (windowObj?.CSS?.supports?.("color", "#000")) {
+    return true;
+  }
+  return /safari/i.test(userAgent) && !/chrome/i.test(userAgent);
+}
+function createLoggerEnvironment() {
+  const runtimeInfo = detectRuntimeInfo();
+  const meta = createRuntimeMeta(runtimeInfo);
+  const usesBrowserStack = runtimeInfo.name === "browser" || runtimeInfo.name === "worker";
+  const callerIgnorePatterns = usesBrowserStack ? [...getDefaultIgnorePatterns(), /node_modules[\\/].*tslog/i] : [...getDefaultIgnorePatterns(), /node:(?:internal|vm)/i, /\binternal[\\/]/i];
+  let cachedCwd;
+  const environment = {
+    getMeta(logLevelId, logLevelName, stackDepthLevel, hideLogPositionForPerformance, name, parentNames) {
+      return Object.assign({}, meta, {
+        name,
+        parentNames,
+        date: /* @__PURE__ */ new Date(),
+        logLevelId,
+        logLevelName,
+        path: !hideLogPositionForPerformance ? environment.getCallerStackFrame(stackDepthLevel) : void 0
+      });
+    },
+    getCallerStackFrame(stackDepthLevel, error = new Error()) {
+      const frames = buildStackTrace(error, (line) => parseStackLine(line));
+      if (frames.length === 0) {
+        return {};
+      }
+      const autoIndex = findFirstExternalFrameIndex(frames, callerIgnorePatterns);
+      const useManualIndex = Number.isFinite(stackDepthLevel) && stackDepthLevel >= 0;
+      const resolvedIndex = useManualIndex ? clampIndex(stackDepthLevel, frames.length) : clampIndex(autoIndex, frames.length);
+      return frames[resolvedIndex] ?? {};
+    },
+    getErrorTrace(error) {
+      return buildStackTrace(error, (line) => parseStackLine(line));
+    },
+    isError(value) {
+      return isNativeError(value);
+    },
+    isBuffer(value) {
+      return typeof Buffer !== "undefined" && typeof Buffer.isBuffer === "function" ? Buffer.isBuffer(value) : false;
+    },
+    prettyFormatLogObj(maskedArgs, settings) {
+      return maskedArgs.reduce((result, arg) => {
+        if (environment.isError(arg)) {
+          result.errors.push(environment.prettyFormatErrorObj(arg, settings));
+        } else {
+          result.args.push(arg);
+        }
+        return result;
+      }, { args: [], errors: [] });
+    },
+    prettyFormatErrorObj(error, settings) {
+      const stackLines = formatStackFrames(environment.getErrorTrace(error), settings);
+      const causeSections = collectErrorCauses(error).map((cause, index) => {
+        const header = `Caused by (${index + 1}): ${cause.name ?? "Error"}${cause.message ? `: ${cause.message}` : ""}`;
+        const frames = formatStackFrames(buildStackTrace(cause, (line) => parseStackLine(line)), settings);
+        return [header, ...frames].join("\n");
+      });
+      const placeholderValuesError = {
+        errorName: ` ${error.name} `,
+        errorMessage: formatErrorMessage(error),
+        errorStack: [...stackLines, ...causeSections].join("\n")
+      };
+      return formatTemplate(settings, settings.prettyErrorTemplate, placeholderValuesError);
+    },
+    transportFormatted(logMetaMarkup, logArgs, logErrors, logMeta, settings) {
+      const prettyLogs = settings.stylePrettyLogs !== false;
+      const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+      const sanitizedMetaMarkup = stripAnsi(logMetaMarkup);
+      const metaMarkupForText = prettyLogs ? logMetaMarkup : sanitizedMetaMarkup;
+      if (shouldUseCss(prettyLogs)) {
+        settings.prettyInspectOptions.colors = false;
+        const formattedArgs2 = formatWithOptionsSafe(settings.prettyInspectOptions, logArgs);
+        const cssMeta = logMeta != null ? buildCssMetaOutput(settings, logMeta) : { text: sanitizedMetaMarkup, styles: [] };
+        const hasCssMeta = cssMeta.text.length > 0 && cssMeta.styles.length > 0;
+        const metaOutput = hasCssMeta ? cssMeta.text : sanitizedMetaMarkup;
+        const output = metaOutput + formattedArgs2 + logErrorsStr;
+        if (hasCssMeta) {
+          console.log(output, ...cssMeta.styles);
+        } else {
+          console.log(output);
+        }
+        return;
+      }
+      settings.prettyInspectOptions.colors = prettyLogs;
+      const formattedArgs = formatWithOptionsSafe(settings.prettyInspectOptions, logArgs);
+      console.log(metaMarkupForText + formattedArgs + logErrorsStr);
+    },
+    transportJSON(json) {
+      console.log(jsonStringifyRecursive(json));
+    }
+  };
+  if (getNodeEnv() === "test") {
+    environment.__resetWorkingDirectoryCacheForTests = () => {
+      cachedCwd = void 0;
+    };
+  }
+  return environment;
+  function parseStackLine(line) {
+    return usesBrowserStack ? parseBrowserStackLine(line) : parseServerStackLine(line);
+  }
+  function parseServerStackLine(rawLine) {
+    if (typeof rawLine !== "string" || rawLine.length === 0) {
+      return void 0;
+    }
+    const trimmedLine = rawLine.trim();
+    if (!trimmedLine.includes(" at ") && !trimmedLine.startsWith("at ")) {
+      return void 0;
+    }
+    const line = trimmedLine.replace(/^at\s+/, "");
+    let method;
+    let location = line;
+    const methodMatch = line.match(/^(.*?)\s+\((.*)\)$/);
+    if (methodMatch) {
+      method = methodMatch[1];
+      location = methodMatch[2];
+    }
+    const sanitizedLocation = location.replace(/^\(/, "").replace(/\)$/, "");
+    const withoutQuery = sanitizedLocation.replace(/\?.*$/, "");
+    let fileLine;
+    let fileColumn;
+    let filePathCandidate = withoutQuery;
+    const segments = withoutQuery.split(":");
+    if (segments.length >= 3 && /^\d+$/.test(segments[segments.length - 1] ?? "")) {
+      fileColumn = segments.pop();
+      fileLine = segments.pop();
+      filePathCandidate = segments.join(":");
+    } else if (segments.length >= 2 && /^\d+$/.test(segments[segments.length - 1] ?? "")) {
+      fileLine = segments.pop();
+      filePathCandidate = segments.join(":");
+    }
+    let normalizedPath = filePathCandidate.replace(/^file:\/\//, "");
+    const cwd = getWorkingDirectory();
+    if (cwd != null && normalizedPath.startsWith(cwd)) {
+      normalizedPath = normalizedPath.slice(cwd.length);
+      normalizedPath = normalizedPath.replace(/^[\\/]/, "");
+    }
+    if (normalizedPath.length === 0) {
+      normalizedPath = filePathCandidate;
+    }
+    const normalizedPathWithoutLine = normalizeFilePath(normalizedPath);
+    const effectivePath = normalizedPathWithoutLine.length > 0 ? normalizedPathWithoutLine : normalizedPath;
+    const pathSegments = effectivePath.split(/\\|\//);
+    const fileName = pathSegments[pathSegments.length - 1];
+    const fileNameWithLine = fileName && fileLine ? `${fileName}:${fileLine}` : void 0;
+    const filePathWithLine = effectivePath && fileLine ? `${effectivePath}:${fileLine}` : void 0;
+    return {
+      fullFilePath: sanitizedLocation,
+      fileName,
+      fileNameWithLine,
+      fileColumn,
+      fileLine,
+      filePath: effectivePath,
+      filePathWithLine,
+      method
+    };
+  }
+  function parseBrowserStackLine(line) {
+    const href = globalThis.location?.origin;
+    if (line == null) {
+      return void 0;
+    }
+    const match = line.match(BROWSER_PATH_REGEX);
+    if (!match) {
+      return void 0;
+    }
+    const filePath = match[1]?.replace(/\?.*$/, "");
+    if (filePath == null) {
+      return void 0;
+    }
+    const pathParts = filePath.split("/");
+    const fileLine = match[2];
+    const fileColumn = match[3];
+    const fileName = pathParts[pathParts.length - 1];
+    return {
+      fullFilePath: href ? `${href}${filePath}` : filePath,
+      fileName,
+      fileNameWithLine: fileName && fileLine ? `${fileName}:${fileLine}` : void 0,
+      fileColumn,
+      fileLine,
+      filePath,
+      filePathWithLine: fileLine ? `${filePath}:${fileLine}` : void 0,
+      method: void 0
+    };
+  }
+  function formatStackFrames(frames, settings) {
+    return frames.map((stackFrame) => formatTemplate(settings, settings.prettyErrorStackTemplate, { ...stackFrame }, true));
+  }
+  function formatErrorMessage(error) {
+    return Object.getOwnPropertyNames(error).filter((key) => key !== "stack" && key !== "cause").reduce((result, key) => {
+      const value = error[key];
+      if (typeof value === "function") {
+        return result;
+      }
+      result.push(String(value));
+      return result;
+    }, []).join(", ");
+  }
+  function shouldUseCss(prettyLogs) {
+    return prettyLogs && (runtimeInfo.name === "browser" || runtimeInfo.name === "worker") && consoleSupportsCssStyling();
+  }
+  function stripAnsi(value) {
+    return value.replace(ANSI_REGEX, "");
+  }
+  function buildCssMetaOutput(settings, metaValue) {
+    if (metaValue == null) {
+      return { text: "", styles: [] };
+    }
+    const { template, placeholders } = buildPrettyMeta(settings, metaValue);
+    const parts = [];
+    const styles = [];
+    let lastIndex = 0;
+    const placeholderRegex = /{{(.+?)}}/g;
+    let match;
+    while ((match = placeholderRegex.exec(template)) != null) {
+      if (match.index > lastIndex) {
+        parts.push(template.slice(lastIndex, match.index));
+      }
+      const key = match[1];
+      const rawValue = placeholders[key] != null ? String(placeholders[key]) : "";
+      const tokens = collectStyleTokens(settings.prettyLogStyles?.[key], rawValue);
+      const css = tokensToCss(tokens);
+      if (css.length > 0) {
+        parts.push(`%c${rawValue}%c`);
+        styles.push(css, "");
+      } else {
+        parts.push(rawValue);
+      }
+      lastIndex = placeholderRegex.lastIndex;
+    }
+    if (lastIndex < template.length) {
+      parts.push(template.slice(lastIndex));
+    }
+    return {
+      text: parts.join(""),
+      styles
+    };
+  }
+  function collectStyleTokens(style, value) {
+    if (style == null) {
+      return [];
+    }
+    if (typeof style === "string") {
+      return [style];
+    }
+    if (Array.isArray(style)) {
+      return style.flatMap((token) => collectStyleTokens(token, value));
+    }
+    if (typeof style === "object") {
+      const normalizedValue = value.trim();
+      const nextStyle = style[normalizedValue] ?? style["*"];
+      if (nextStyle == null) {
+        return [];
+      }
+      return collectStyleTokens(nextStyle, value);
+    }
+    return [];
+  }
+  function tokensToCss(tokens) {
+    const seen = /* @__PURE__ */ new Set();
+    const cssParts = [];
+    for (const token of tokens) {
+      const css = styleTokenToCss(token);
+      if (css != null && css.length > 0 && !seen.has(css)) {
+        seen.add(css);
+        cssParts.push(css);
+      }
+    }
+    return cssParts.join("; ");
+  }
+  function styleTokenToCss(token) {
+    const color = COLOR_TOKENS[token];
+    if (color != null) {
+      return `color: ${color}`;
+    }
+    const background = BACKGROUND_TOKENS[token];
+    if (background != null) {
+      return `background-color: ${background}`;
+    }
+    switch (token) {
+      case "bold":
+        return "font-weight: bold";
+      case "dim":
+        return "opacity: 0.75";
+      case "italic":
+        return "font-style: italic";
+      case "underline":
+        return "text-decoration: underline";
+      case "overline":
+        return "text-decoration: overline";
+      case "inverse":
+        return "filter: invert(1)";
+      case "hidden":
+        return "visibility: hidden";
+      case "strikethrough":
+        return "text-decoration: line-through";
+      default:
+        return void 0;
+    }
+  }
+  function getWorkingDirectory() {
+    if (cachedCwd === void 0) {
+      cachedCwd = safeGetCwd() ?? null;
+    }
+    return cachedCwd ?? void 0;
+  }
+  function shouldCaptureHostname() {
+    return runtimeInfo.name === "node" || runtimeInfo.name === "deno" || runtimeInfo.name === "bun";
+  }
+  function shouldCaptureRuntimeVersion() {
+    return runtimeInfo.name === "node" || runtimeInfo.name === "deno" || runtimeInfo.name === "bun";
+  }
+  function createRuntimeMeta(info) {
+    if (info.name === "browser" || info.name === "worker") {
+      return {
+        runtime: info.name,
+        browser: info.userAgent
+      };
+    }
+    const metaStatic = {
+      runtime: info.name
+    };
+    if (shouldCaptureRuntimeVersion()) {
+      metaStatic.runtimeVersion = info.version ?? "unknown";
+    }
+    if (shouldCaptureHostname()) {
+      metaStatic.hostname = info.hostname ?? "unknown";
+    }
+    return metaStatic;
+  }
+  function formatWithOptionsSafe(options, args) {
+    try {
+      return formatWithOptions(options, ...args);
+    } catch {
+      return args.map(stringifyFallback).join(" ");
+    }
+  }
+  function stringifyFallback(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  function normalizeFilePath(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      return value;
+    }
+    const replaced = value.replace(/\\+/g, "\\").replace(/\\/g, "/");
+    const hasRootDoubleSlash = replaced.startsWith("//");
+    const hasLeadingSlash = replaced.startsWith("/") && !hasRootDoubleSlash;
+    const driveMatch = replaced.match(/^[A-Za-z]:/);
+    const drivePrefix = driveMatch ? driveMatch[0] : "";
+    const withoutDrive = drivePrefix ? replaced.slice(drivePrefix.length) : replaced;
+    const segments = withoutDrive.split("/");
+    const normalizedSegments = [];
+    for (const segment of segments) {
+      if (segment === "" || segment === ".") {
+        continue;
+      }
+      if (segment === "..") {
+        if (normalizedSegments.length > 0) {
+          normalizedSegments.pop();
+        }
+        continue;
+      }
+      normalizedSegments.push(segment);
+    }
+    let normalized = normalizedSegments.join("/");
+    if (hasRootDoubleSlash) {
+      normalized = `//${normalized}`;
+    } else if (hasLeadingSlash) {
+      normalized = `/${normalized}`;
+    } else if (drivePrefix !== "") {
+      normalized = `${drivePrefix}${normalized.length > 0 ? `/${normalized}` : ""}`;
+    }
+    if (normalized.length === 0) {
+      return value;
+    }
+    return normalized;
+  }
+  function detectRuntimeInfo() {
+    if (isBrowserEnvironment()) {
+      const navigatorObj = globalThis.navigator;
+      return {
+        name: "browser",
+        userAgent: navigatorObj?.userAgent
+      };
+    }
+    const globalScope = globalThis;
+    if (typeof globalScope.importScripts === "function") {
+      return {
+        name: "worker",
+        userAgent: globalScope.navigator?.userAgent
+      };
+    }
+    const globalAny = globalThis;
+    if (globalAny.Bun != null) {
+      const bunVersion = globalAny.Bun.version;
+      return {
+        name: "bun",
+        version: bunVersion != null ? `bun/${bunVersion}` : void 0,
+        hostname: getEnvironmentHostname(globalAny.process, globalAny.Deno, globalAny.Bun, globalAny.location)
+      };
+    }
+    if (globalAny.Deno != null) {
+      const denoHostname = resolveDenoHostname(globalAny.Deno);
+      const denoVersion = globalAny.Deno?.version?.deno;
+      return {
+        name: "deno",
+        version: denoVersion != null ? `deno/${denoVersion}` : void 0,
+        hostname: denoHostname ?? getEnvironmentHostname(globalAny.process, globalAny.Deno, globalAny.Bun, globalAny.location)
+      };
+    }
+    if (globalAny.process?.versions?.node != null || globalAny.process?.version != null) {
+      return {
+        name: "node",
+        version: globalAny.process?.versions?.node ?? globalAny.process?.version,
+        hostname: getEnvironmentHostname(globalAny.process, globalAny.Deno, globalAny.Bun, globalAny.location)
+      };
+    }
+    if (globalAny.process != null) {
+      return {
+        name: "node",
+        version: "unknown",
+        hostname: getEnvironmentHostname(globalAny.process, globalAny.Deno, globalAny.Bun, globalAny.location)
+      };
+    }
+    return {
+      name: "unknown"
+    };
+  }
+  function getEnvironmentHostname(nodeProcess, deno, bun, location) {
+    const processHostname = nodeProcess?.env?.HOSTNAME ?? nodeProcess?.env?.HOST ?? nodeProcess?.env?.COMPUTERNAME;
+    if (processHostname != null && processHostname.length > 0) {
+      return processHostname;
+    }
+    const bunHostname = bun?.env?.HOSTNAME ?? bun?.env?.HOST ?? bun?.env?.COMPUTERNAME;
+    if (bunHostname != null && bunHostname.length > 0) {
+      return bunHostname;
+    }
+    try {
+      const denoEnvGet = deno?.env?.get;
+      if (typeof denoEnvGet === "function") {
+        const value = denoEnvGet("HOSTNAME");
+        if (value != null && value.length > 0) {
+          return value;
+        }
+      }
+    } catch {
+    }
+    if (location?.hostname != null && location.hostname.length > 0) {
+      return location.hostname;
+    }
+    return void 0;
+  }
+  function resolveDenoHostname(deno) {
+    try {
+      if (typeof deno?.hostname === "function") {
+        const value = deno.hostname();
+        if (value != null && value.length > 0) {
+          return value;
+        }
+      }
+    } catch {
+    }
+    const locationHostname = globalThis.location?.hostname;
+    if (locationHostname != null && locationHostname.length > 0) {
+      return locationHostname;
+    }
+    return void 0;
+  }
+  function getNodeEnv() {
+    const globalProcess = globalThis?.process;
+    return globalProcess?.env?.NODE_ENV;
+  }
+  function isNativeError(value) {
+    if (value instanceof Error) {
+      return true;
+    }
+    if (value != null && typeof value === "object") {
+      const objectTag = Object.prototype.toString.call(value);
+      if (/\[object .*Error\]/.test(objectTag)) {
+        return true;
+      }
+      const name = value.name;
+      if (typeof name === "string" && name.endsWith("Error")) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+var ANSI_REGEX = /\u001b\[[0-9;]*m/g;
+var COLOR_TOKENS = {
+  black: "#000000",
+  red: "#ef5350",
+  green: "#66bb6a",
+  yellow: "#fdd835",
+  blue: "#42a5f5",
+  magenta: "#ab47bc",
+  cyan: "#26c6da",
+  white: "#fafafa",
+  blackBright: "#424242",
+  redBright: "#ff7043",
+  greenBright: "#81c784",
+  yellowBright: "#ffe082",
+  blueBright: "#64b5f6",
+  magentaBright: "#ce93d8",
+  cyanBright: "#4dd0e1",
+  whiteBright: "#ffffff"
+};
+var BACKGROUND_TOKENS = {
+  bgBlack: "#000000",
+  bgRed: "#ef5350",
+  bgGreen: "#66bb6a",
+  bgYellow: "#fdd835",
+  bgBlue: "#42a5f5",
+  bgMagenta: "#ab47bc",
+  bgCyan: "#26c6da",
+  bgWhite: "#fafafa",
+  bgBlackBright: "#424242",
+  bgRedBright: "#ff7043",
+  bgGreenBright: "#81c784",
+  bgYellowBright: "#ffe082",
+  bgBlueBright: "#64b5f6",
+  bgMagentaBright: "#ce93d8",
+  bgCyanBright: "#4dd0e1",
+  bgWhiteBright: "#ffffff"
+};
+var BROWSER_PATH_REGEX = /(?:(?:file|https?|global code|[^@]+)@)?(?:file:)?((?:\/[^:/]+){2,})(?::(\d+))?(?::(\d+))?/;
+var runtime = createLoggerEnvironment();
+var BaseLogger = class {
+  constructor(settings, logObj, stackDepthLevel = Number.NaN) {
+    this.logObj = logObj;
+    this.stackDepthLevel = stackDepthLevel;
+    this.runtime = runtime;
+    this.maxErrorCauseDepth = 5;
+    this.settings = {
+      type: settings?.type ?? "pretty",
+      name: settings?.name,
+      parentNames: settings?.parentNames,
+      minLevel: settings?.minLevel ?? 0,
+      argumentsArrayName: settings?.argumentsArrayName,
+      hideLogPositionForProduction: settings?.hideLogPositionForProduction ?? false,
+      prettyLogTemplate: settings?.prettyLogTemplate ?? "{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}	{{logLevelName}}	{{filePathWithLine}}{{nameWithDelimiterPrefix}}	",
+      prettyErrorTemplate: settings?.prettyErrorTemplate ?? "\n{{errorName}} {{errorMessage}}\nerror stack:\n{{errorStack}}",
+      prettyErrorStackTemplate: settings?.prettyErrorStackTemplate ?? "  \u2022 {{fileName}}	{{method}}\n	{{filePathWithLine}}",
+      prettyErrorParentNamesSeparator: settings?.prettyErrorParentNamesSeparator ?? ":",
+      prettyErrorLoggerNameDelimiter: settings?.prettyErrorLoggerNameDelimiter ?? "	",
+      stylePrettyLogs: settings?.stylePrettyLogs ?? true,
+      prettyLogTimeZone: settings?.prettyLogTimeZone ?? "UTC",
+      prettyLogStyles: settings?.prettyLogStyles ?? {
+        logLevelName: {
+          "*": ["bold", "black", "bgWhiteBright", "dim"],
+          SILLY: ["bold", "white"],
+          TRACE: ["bold", "whiteBright"],
+          DEBUG: ["bold", "green"],
+          INFO: ["bold", "blue"],
+          WARN: ["bold", "yellow"],
+          ERROR: ["bold", "red"],
+          FATAL: ["bold", "redBright"]
+        },
+        dateIsoStr: "white",
+        filePathWithLine: "white",
+        name: ["white", "bold"],
+        nameWithDelimiterPrefix: ["white", "bold"],
+        nameWithDelimiterSuffix: ["white", "bold"],
+        errorName: ["bold", "bgRedBright", "whiteBright"],
+        fileName: ["yellow"],
+        fileNameWithLine: "white"
+      },
+      prettyInspectOptions: settings?.prettyInspectOptions ?? {
+        colors: true,
+        compact: false,
+        depth: Infinity
+      },
+      metaProperty: settings?.metaProperty ?? "_meta",
+      maskPlaceholder: settings?.maskPlaceholder ?? "[***]",
+      maskValuesOfKeys: settings?.maskValuesOfKeys ?? ["password"],
+      maskValuesOfKeysCaseInsensitive: settings?.maskValuesOfKeysCaseInsensitive ?? false,
+      maskValuesRegEx: settings?.maskValuesRegEx,
+      prefix: [...settings?.prefix ?? []],
+      attachedTransports: [...settings?.attachedTransports ?? []],
+      overwrite: {
+        mask: settings?.overwrite?.mask,
+        toLogObj: settings?.overwrite?.toLogObj,
+        addMeta: settings?.overwrite?.addMeta,
+        addPlaceholders: settings?.overwrite?.addPlaceholders,
+        formatMeta: settings?.overwrite?.formatMeta,
+        formatLogObj: settings?.overwrite?.formatLogObj,
+        transportFormatted: settings?.overwrite?.transportFormatted,
+        transportJSON: settings?.overwrite?.transportJSON
+      }
+    };
+    this.captureStackForMeta = this._shouldCaptureStack();
+  }
+  log(logLevelId, logLevelName, ...args) {
+    if (logLevelId < this.settings.minLevel) {
+      return;
+    }
+    const resolvedArgs = this._resolveLogArguments(args);
+    const logArgs = [...this.settings.prefix, ...resolvedArgs];
+    const maskedArgs = this.settings.overwrite?.mask != null ? this.settings.overwrite?.mask(logArgs) : this.settings.maskValuesOfKeys != null && this.settings.maskValuesOfKeys.length > 0 ? this._mask(logArgs) : logArgs;
+    const thisLogObj = this.logObj != null ? this._recursiveCloneAndExecuteFunctions(this.logObj) : void 0;
+    const logObj = this.settings.overwrite?.toLogObj != null ? this.settings.overwrite?.toLogObj(maskedArgs, thisLogObj) : this._toLogObj(maskedArgs, thisLogObj);
+    const logObjWithMeta = this.settings.overwrite?.addMeta != null ? this.settings.overwrite?.addMeta(logObj, logLevelId, logLevelName) : this._addMetaToLogObj(logObj, logLevelId, logLevelName);
+    const logMeta = logObjWithMeta?.[this.settings.metaProperty];
+    let logMetaMarkup;
+    let logArgsAndErrorsMarkup = void 0;
+    if (this.settings.overwrite?.formatMeta != null) {
+      logMetaMarkup = this.settings.overwrite?.formatMeta(logObjWithMeta?.[this.settings.metaProperty]);
+    }
+    if (this.settings.overwrite?.formatLogObj != null) {
+      logArgsAndErrorsMarkup = this.settings.overwrite?.formatLogObj(maskedArgs, this.settings);
+    }
+    if (this.settings.type === "pretty") {
+      logMetaMarkup = logMetaMarkup ?? this._prettyFormatLogObjMeta(logObjWithMeta?.[this.settings.metaProperty]);
+      logArgsAndErrorsMarkup = logArgsAndErrorsMarkup ?? runtime.prettyFormatLogObj(maskedArgs, this.settings);
+    }
+    if (logMetaMarkup != null && logArgsAndErrorsMarkup != null) {
+      if (this.settings.overwrite?.transportFormatted != null) {
+        const transport = this.settings.overwrite.transportFormatted;
+        const declaredParams = transport.length;
+        if (declaredParams < 4) {
+          transport(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors);
+        } else if (declaredParams === 4) {
+          transport(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, logMeta);
+        } else {
+          transport(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, logMeta, this.settings);
+        }
+      } else {
+        runtime.transportFormatted(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, logMeta, this.settings);
+      }
+    } else {
+      if (this.settings.overwrite?.transportJSON != null) {
+        this.settings.overwrite.transportJSON(logObjWithMeta);
+      } else if (this.settings.type !== "hidden") {
+        runtime.transportJSON(logObjWithMeta);
+      }
+    }
+    if (this.settings.attachedTransports != null && this.settings.attachedTransports.length > 0) {
+      this.settings.attachedTransports.forEach((transportLogger) => {
+        transportLogger(logObjWithMeta);
+      });
+    }
+    return logObjWithMeta;
+  }
+  attachTransport(transportLogger) {
+    this.settings.attachedTransports.push(transportLogger);
+  }
+  getSubLogger(settings, logObj) {
+    const subLoggerSettings = {
+      ...this.settings,
+      ...settings,
+      parentNames: this.settings?.parentNames != null && this.settings?.name != null ? [...this.settings.parentNames, this.settings.name] : this.settings?.name != null ? [this.settings.name] : void 0,
+      prefix: [...this.settings.prefix, ...settings?.prefix ?? []]
+    };
+    const subLogger = new this.constructor(subLoggerSettings, logObj ?? this.logObj, this.stackDepthLevel);
+    return subLogger;
+  }
+  _mask(args) {
+    const maskKeys = this._getMaskKeys();
+    return args?.map((arg) => {
+      return this._recursiveCloneAndMaskValuesOfKeys(arg, maskKeys);
+    });
+  }
+  _getMaskKeys() {
+    const maskKeys = this.settings.maskValuesOfKeys ?? [];
+    const signature = maskKeys.map(String).join("|");
+    if (this.settings.maskValuesOfKeysCaseInsensitive === true) {
+      if (this.maskKeysCache?.source === maskKeys && this.maskKeysCache.caseInsensitive === true && this.maskKeysCache.signature === signature) {
+        return this.maskKeysCache.normalized;
+      }
+      const normalized = maskKeys.map((key) => typeof key === "string" ? key.toLowerCase() : String(key).toLowerCase());
+      this.maskKeysCache = {
+        source: maskKeys,
+        caseInsensitive: true,
+        normalized,
+        signature
+      };
+      return normalized;
+    }
+    this.maskKeysCache = {
+      source: maskKeys,
+      caseInsensitive: false,
+      normalized: maskKeys,
+      signature
+    };
+    return maskKeys;
+  }
+  _resolveLogArguments(args) {
+    if (args.length === 1 && typeof args[0] === "function") {
+      const candidate = args[0];
+      if (candidate.length === 0) {
+        const result = candidate();
+        return Array.isArray(result) ? result : [result];
+      }
+    }
+    return args;
+  }
+  _recursiveCloneAndMaskValuesOfKeys(source, keys, seen = []) {
+    if (seen.includes(source)) {
+      return { ...source };
+    }
+    if (typeof source === "object" && source !== null) {
+      seen.push(source);
+    }
+    if (runtime.isError(source) || runtime.isBuffer(source)) {
+      return source;
+    } else if (source instanceof Map) {
+      return new Map(source);
+    } else if (source instanceof Set) {
+      return new Set(source);
+    } else if (Array.isArray(source)) {
+      return source.map((item) => this._recursiveCloneAndMaskValuesOfKeys(item, keys, seen));
+    } else if (source instanceof Date) {
+      return new Date(source.getTime());
+    } else if (source instanceof URL) {
+      return urlToObject(source);
+    } else if (source !== null && typeof source === "object") {
+      const baseObject = runtime.isError(source) ? this._cloneError(source) : Object.create(Object.getPrototypeOf(source));
+      return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+        const lookupKey = this.settings?.maskValuesOfKeysCaseInsensitive !== true ? prop : typeof prop === "string" ? prop.toLowerCase() : String(prop).toLowerCase();
+        o[prop] = keys.includes(lookupKey) ? this.settings.maskPlaceholder : (() => {
+          try {
+            return this._recursiveCloneAndMaskValuesOfKeys(source[prop], keys, seen);
+          } catch {
+            return null;
+          }
+        })();
+        return o;
+      }, baseObject);
+    } else {
+      if (typeof source === "string") {
+        let modifiedSource = source;
+        for (const regEx of this.settings?.maskValuesRegEx || []) {
+          modifiedSource = modifiedSource.replace(regEx, this.settings?.maskPlaceholder || "");
+        }
+        return modifiedSource;
+      }
+      return source;
+    }
+  }
+  _recursiveCloneAndExecuteFunctions(source, seen = []) {
+    if (this.isObjectOrArray(source) && seen.includes(source)) {
+      return this.shallowCopy(source);
+    }
+    if (this.isObjectOrArray(source)) {
+      seen.push(source);
+    }
+    if (Array.isArray(source)) {
+      return source.map((item) => this._recursiveCloneAndExecuteFunctions(item, seen));
+    } else if (source instanceof Date) {
+      return new Date(source.getTime());
+    } else if (this.isObject(source)) {
+      return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+        const descriptor = Object.getOwnPropertyDescriptor(source, prop);
+        if (descriptor) {
+          Object.defineProperty(o, prop, descriptor);
+          const value = source[prop];
+          o[prop] = typeof value === "function" ? value() : this._recursiveCloneAndExecuteFunctions(value, seen);
+        }
+        return o;
+      }, Object.create(Object.getPrototypeOf(source)));
+    } else {
+      return source;
+    }
+  }
+  isObjectOrArray(value) {
+    return typeof value === "object" && value !== null;
+  }
+  isObject(value) {
+    return typeof value === "object" && !Array.isArray(value) && value !== null;
+  }
+  shallowCopy(source) {
+    if (Array.isArray(source)) {
+      return [...source];
+    } else {
+      return { ...source };
+    }
+  }
+  _toLogObj(args, clonedLogObj = {}) {
+    args = args?.map((arg) => runtime.isError(arg) ? this._toErrorObject(arg) : arg);
+    if (this.settings.argumentsArrayName == null) {
+      if (args.length === 1 && !Array.isArray(args[0]) && runtime.isBuffer(args[0]) !== true && !(args[0] instanceof Date)) {
+        clonedLogObj = typeof args[0] === "object" && args[0] != null ? { ...args[0], ...clonedLogObj } : { 0: args[0], ...clonedLogObj };
+      } else {
+        clonedLogObj = { ...clonedLogObj, ...args };
+      }
+    } else {
+      clonedLogObj = {
+        ...clonedLogObj,
+        [this.settings.argumentsArrayName]: args
+      };
+    }
+    return clonedLogObj;
+  }
+  _cloneError(error) {
+    const cloned = new error.constructor();
+    Object.getOwnPropertyNames(error).forEach((key) => {
+      cloned[key] = error[key];
+    });
+    return cloned;
+  }
+  _toErrorObject(error, depth = 0, seen = /* @__PURE__ */ new Set()) {
+    if (!seen.has(error)) {
+      seen.add(error);
+    }
+    const errorObject = {
+      nativeError: error,
+      name: error.name ?? "Error",
+      message: error.message,
+      stack: runtime.getErrorTrace(error)
+    };
+    if (depth >= this.maxErrorCauseDepth) {
+      return errorObject;
+    }
+    const causeValue = error.cause;
+    if (causeValue != null) {
+      const normalizedCause = toError(causeValue);
+      if (!seen.has(normalizedCause)) {
+        errorObject.cause = this._toErrorObject(normalizedCause, depth + 1, seen);
+      }
+    }
+    return errorObject;
+  }
+  _addMetaToLogObj(logObj, logLevelId, logLevelName) {
+    return {
+      ...logObj,
+      [this.settings.metaProperty]: runtime.getMeta(logLevelId, logLevelName, this.stackDepthLevel, !this.captureStackForMeta, this.settings.name, this.settings.parentNames)
+    };
+  }
+  _shouldCaptureStack() {
+    if (this.settings.hideLogPositionForProduction) {
+      return false;
+    }
+    if (this.settings.type === "json") {
+      return true;
+    }
+    const template = this.settings.prettyLogTemplate ?? "";
+    const stackPlaceholders = /{{\s*(file(Name|Path|Line|PathWithLine|NameWithLine)|fullFilePath)\s*}}/;
+    if (stackPlaceholders.test(template)) {
+      return true;
+    }
+    return false;
+  }
+  _prettyFormatLogObjMeta(logObjMeta) {
+    return buildPrettyMeta(this.settings, logObjMeta).text;
+  }
+};
+var Logger = class extends BaseLogger {
+  constructor(settings, logObj) {
+    const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+    const normalizedSettings = { ...settings ?? {} };
+    if (isBrowser) {
+      normalizedSettings.stylePrettyLogs = settings?.stylePrettyLogs ?? true;
+    }
+    super(normalizedSettings, logObj, Number.NaN);
+  }
+  log(logLevelId, logLevelName, ...args) {
+    return super.log(logLevelId, logLevelName, ...args);
+  }
+  silly(...args) {
+    return super.log(0, "SILLY", ...args);
+  }
+  trace(...args) {
+    return super.log(1, "TRACE", ...args);
+  }
+  debug(...args) {
+    return super.log(2, "DEBUG", ...args);
+  }
+  info(...args) {
+    return super.log(3, "INFO", ...args);
+  }
+  warn(...args) {
+    return super.log(4, "WARN", ...args);
+  }
+  error(...args) {
+    return super.log(5, "ERROR", ...args);
+  }
+  fatal(...args) {
+    return super.log(6, "FATAL", ...args);
+  }
+  getSubLogger(settings, logObj) {
+    return super.getSubLogger(settings, logObj);
+  }
+};
+function getLogDir() {
+  switch (process.platform) {
+    case "darwin":
+      return path.join(os.homedir(), "Library", "Logs", "panopticon");
+    case "win32":
+      return path.join(
+        process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local"),
+        "panopticon",
+        "logs"
+      );
+    default:
+      return path.join(
+        process.env.XDG_STATE_HOME ?? path.join(os.homedir(), ".local", "state"),
+        "panopticon",
+        "logs"
+      );
+  }
+}
+var LOG_DIR = getLogDir();
+var logPaths = {
+  server: path.join(LOG_DIR, "server.log"),
+  otlp: path.join(LOG_DIR, "otlp-receiver.log"),
+  mcp: path.join(LOG_DIR, "mcp-server.log"),
+  proxy: path.join(LOG_DIR, "proxy.log"),
+  hook: path.join(LOG_DIR, "hook-handler.log")
+};
+var DAEMON_NAMES = Object.keys(logPaths);
+var root = new Logger({
+  name: "panopticon",
+  type: "pretty",
+  prettyLogTimeZone: "UTC",
+  stylePrettyLogs: false,
+  prettyLogTemplate: "{{dateIsoStr}} [{{name}}] {{logLevelName}}	"
+});
+var log = {
+  server: root.getSubLogger({ name: "server" }),
+  scanner: root.getSubLogger({ name: "scanner" }),
+  sync: root.getSubLogger({ name: "sync" }),
+  proxy: root.getSubLogger({ name: "proxy" }),
+  llm: root.getSubLogger({ name: "llm" }),
+  mcp: root.getSubLogger({ name: "mcp" }),
+  otlp: root.getSubLogger({ name: "otlp" }),
+  hooks: root.getSubLogger({ name: "hooks" })
+};
+
+// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-WNBA7CY3.js
+function loadSyncConfig() {
+  const cfg = loadUnifiedConfig();
+  return { targets: cfg.sync.targets, filter: cfg.sync.filter };
+}
+function saveSyncConfig(syncCfg) {
+  const cfg = loadUnifiedConfig();
+  cfg.sync.targets = syncCfg.targets;
+  cfg.sync.filter = syncCfg.filter;
+  saveUnifiedConfig(cfg);
+}
+function addTarget(target) {
+  const cfg = loadUnifiedConfig();
+  const existing = cfg.sync.targets.findIndex((t) => t.name === target.name);
+  if (existing >= 0) {
+    cfg.sync.targets[existing] = target;
+  } else {
+    cfg.sync.targets.push(target);
+  }
+  saveUnifiedConfig(cfg);
+}
+function removeTarget(name) {
+  const cfg = loadUnifiedConfig();
+  const before = cfg.sync.targets.length;
+  cfg.sync.targets = cfg.sync.targets.filter((t) => t.name !== name);
+  if (cfg.sync.targets.length === before) return false;
+  saveUnifiedConfig(cfg);
+  return true;
+}
+function listTargets() {
+  return loadUnifiedConfig().sync.targets;
+}
+var TOKEN_CACHE_TTL_MS = 5 * 60 * 1e3;
+
+// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-CL3PWTMD.js
+import http from "http";
+function post(path4, body, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const json = JSON.stringify(body);
+    const req = http.request(
+      {
+        hostname: config.host,
+        port: config.port,
+        path: path4,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(json)
+        },
+        timeout: timeoutMs
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf-8");
+          let parsed;
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+            reject(
+              new Error(
+                `Invalid JSON response from server: ${text.slice(0, 200)}`
+              )
+            );
+            return;
+          }
+          if (res.statusCode && res.statusCode >= 400 && typeof parsed === "object" && parsed !== null && "error" in parsed) {
+            reject(new Error(parsed.error));
+            return;
+          }
+          resolve(parsed);
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (err.code === "ECONNREFUSED") {
+        reject(
+          new Error(
+            "Panopticon server is not running. Start with: panopticon start"
+          )
+        );
+        return;
+      }
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request to panopticon server timed out"));
+    });
+    req.write(json);
+    req.end();
+  });
+}
+var EXEC_TIMEOUT = 6e4;
+function callExec(command, params) {
+  return post("/api/exec", { command, params }, EXEC_TIMEOUT);
+}
+function syncReset(target) {
+  return callExec("sync-reset", target ? { target } : {});
+}
+function syncPending(target) {
+  return callExec("sync-pending", { target });
+}
 
 // src/commands/doctor.ts
-import ora from "ora";
-import pc from "picocolors";
-import { loadSyncConfig } from "@fml-inc/panopticon/sync";
-import { syncPending } from "@fml-inc/panopticon/api";
 function reportResult(result, spinner) {
   const text = `${result.label} \u2014 ${result.detail}`;
   if (spinner) {
@@ -98,7 +1837,7 @@ async function handleDoctor(opts) {
   {
     const spinner = startSpinner("panopticon");
     try {
-      const { doctor } = await import("@fml-inc/panopticon/doctor");
+      const { doctor } = await import("./doctor-YV6KQEGW.js");
       const result = await doctor();
       if (spinner) spinner.stop();
       for (const check of result.checks) {
@@ -269,11 +2008,11 @@ async function handleDoctor(opts) {
 }
 
 // src/commands/install.ts
+import { execFileSync } from "child_process";
 import fs from "fs";
-import os from "os";
-import path from "path";
+import os2 from "os";
+import path2 from "path";
 import { fileURLToPath } from "url";
-import { addTarget, listTargets } from "@fml-inc/panopticon/sync";
 
 // src/banner.ts
 import pc2 from "picocolors";
@@ -327,17 +2066,17 @@ function resolveGitHubToken() {
 }
 
 // src/commands/install.ts
-var CLAUDE_DIR = path.join(os.homedir(), ".claude");
-var CLAUDE_SETTINGS_PATH = path.join(CLAUDE_DIR, "settings.json");
-var MARKETPLACE_DIR = path.join(
-  os.homedir(),
+var CLAUDE_DIR = path2.join(os2.homedir(), ".claude");
+var CLAUDE_SETTINGS_PATH = path2.join(CLAUDE_DIR, "settings.json");
+var MARKETPLACE_DIR = path2.join(
+  os2.homedir(),
   ".local",
   "share",
   "claude-plugins"
 );
 function getPluginRoot() {
-  let dir = path.dirname(fileURLToPath(import.meta.url));
-  dir = path.resolve(dir, "..");
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  dir = path2.resolve(dir, "..");
   return dir;
 }
 function readJsonFile(filePath) {
@@ -348,45 +2087,96 @@ function readJsonFile(filePath) {
   }
 }
 function writeJsonFile(filePath, data) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.mkdirSync(path2.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
 `);
 }
 async function handleInstall() {
   const pluginRoot = getPluginRoot();
   console.log("Installing fml...\n");
-  console.log("[1/4] Running panopticon install...");
-  const result = panopticonExec("install", { timeout: 6e4 });
-  if (result.ok) {
-    for (const line of result.stdout.trim().split("\n")) {
-      console.log(`      ${line}`);
+  console.log("[1/5] Setting up panopticon...");
+  const { resolvePanopticonBin } = await import("./daemon-utils-LIG6K2MK.js");
+  let freshInstall = false;
+  const bin = resolvePanopticonBin();
+  let needsInstall = !bin;
+  if (bin) {
+    const MIN_PANOPTICON = "0.2.2";
+    const vResult = panopticonExec("--version", { timeout: 5e3 });
+    const installed = vResult.ok ? vResult.stdout.trim().split("+")[0] : "0.0.0";
+    if (installed < MIN_PANOPTICON) {
+      console.log(`      Found panopticon ${installed}, need >=${MIN_PANOPTICON}`);
+      needsInstall = true;
     }
-  } else {
-    console.error("      panopticon install failed:");
-    for (const line of result.stdout.trim().split("\n")) {
-      console.error(`      ${line}`);
+  }
+  if (needsInstall) {
+    console.log(
+      bin ? "      Upgrading @fml-inc/panopticon..." : "      Installing @fml-inc/panopticon globally..."
+    );
+    try {
+      execFileSync("npm", ["install", "-g", "@fml-inc/panopticon@latest"], {
+        encoding: "utf-8",
+        timeout: 12e4,
+        stdio: "pipe"
+      });
+      freshInstall = true;
+      console.log("      Installed @fml-inc/panopticon");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`      Failed to install panopticon: ${msg}`);
+      console.error("      Install manually: npm install -g @fml-inc/panopticon@latest");
+    }
+  }
+  if (!freshInstall) {
+    const result = panopticonExec("install", { timeout: 6e4 });
+    if (result.ok) {
+      for (const line of result.stdout.trim().split("\n")) {
+        console.log(`      ${line}`);
+      }
+    } else {
+      console.error("      panopticon install failed:");
+      for (const line of result.stdout.trim().split("\n")) {
+        console.error(`      ${line}`);
+      }
     }
   }
   console.log();
-  console.log("[2/4] Creating fml directories...");
+  console.log("[2/5] Creating fml directories...");
   for (const dir of [FML_DATA_DIR, FML_LOG_DIR]) {
     fs.mkdirSync(dir, { recursive: true });
   }
   console.log(`      ${FML_DATA_DIR}`);
   console.log(`      ${FML_LOG_DIR}
 `);
-  console.log("[3/4] Setting up fml plugin...");
-  fs.mkdirSync(path.join(MARKETPLACE_DIR, ".claude-plugin"), {
+  console.log("[3/5] Writing plugin manifest...");
+  const pkgJson = readJsonFile(path2.join(pluginRoot, "package.json"));
+  const version = pkgJson?.version ?? "0.0.0-dev";
+  const pluginManifestDir = path2.join(pluginRoot, ".claude-plugin");
+  fs.mkdirSync(pluginManifestDir, { recursive: true });
+  writeJsonFile(path2.join(pluginManifestDir, "plugin.json"), {
+    name: "fml",
+    version,
+    description: "FML agent tools for Claude Code",
+    mcpServers: {
+      fml: {
+        command: "node",
+        args: ["${CLAUDE_PLUGIN_ROOT}/bin/mcp-server"]
+      }
+    }
+  });
+  console.log(`      Version: ${version}
+`);
+  console.log("[4/5] Setting up fml plugin...");
+  fs.mkdirSync(path2.join(MARKETPLACE_DIR, ".claude-plugin"), {
     recursive: true
   });
-  const manifestPath = path.join(
+  const manifestPath = path2.join(
     MARKETPLACE_DIR,
     ".claude-plugin",
     "marketplace.json"
   );
   const manifest = readJsonFile(manifestPath) ?? {
     name: "local-plugins",
-    owner: { name: os.userInfo().username },
+    owner: { name: os2.userInfo().username },
     plugins: []
   };
   const plugins = manifest.plugins ?? [];
@@ -399,7 +2189,7 @@ async function handleInstall() {
     manifest.plugins = plugins;
   }
   writeJsonFile(manifestPath, manifest);
-  const marketplaceLink = path.join(MARKETPLACE_DIR, "fml");
+  const marketplaceLink = path2.join(MARKETPLACE_DIR, "fml");
   try {
     fs.unlinkSync(marketplaceLink);
   } catch {
@@ -416,9 +2206,25 @@ async function handleInstall() {
   settings.enabledPlugins = settings.enabledPlugins ?? {};
   settings.enabledPlugins["fml@local-plugins"] = true;
   writeJsonFile(CLAUDE_SETTINGS_PATH, settings);
-  console.log(`      Claude settings: ${CLAUDE_SETTINGS_PATH}
-`);
-  console.log("[4/4] Configuring sync target...");
+  console.log(`      Claude settings: ${CLAUDE_SETTINGS_PATH}`);
+  try {
+    try {
+      execFileSync("claude", ["plugin", "install", "fml@local-plugins"], {
+        stdio: "pipe",
+        timeout: 15e3
+      });
+    } catch {
+      execFileSync("claude", ["plugin", "update", "fml@local-plugins"], {
+        stdio: "pipe",
+        timeout: 15e3
+      });
+    }
+    console.log("      Plugin registered via Claude Code CLI");
+  } catch {
+    console.log("      warn: claude CLI not found, run 'claude plugin install fml@local-plugins' manually");
+  }
+  console.log();
+  console.log("[5/5] Configuring sync target...");
   const prodSyncUrl = DEFAULT_PROD_URL.replace(".cloud", ".site");
   const existingTargets = listTargets();
   const existingProd = existingTargets.find((t) => t.url === prodSyncUrl);
@@ -452,17 +2258,25 @@ async function handleInstall() {
 }
 
 // src/commands/uninstall.ts
+import { execFileSync as execFileSync2 } from "child_process";
 import fs2 from "fs";
-import os2 from "os";
-import path2 from "path";
-var CLAUDE_DIR2 = path2.join(os2.homedir(), ".claude");
-var CLAUDE_SETTINGS_PATH2 = path2.join(CLAUDE_DIR2, "settings.json");
-var MARKETPLACE_DIR2 = path2.join(
-  os2.homedir(),
+import os3 from "os";
+import path3 from "path";
+var CLAUDE_DIR2 = path3.join(os3.homedir(), ".claude");
+var CLAUDE_SETTINGS_PATH2 = path3.join(CLAUDE_DIR2, "settings.json");
+var MARKETPLACE_DIR2 = path3.join(
+  os3.homedir(),
   ".local",
   "share",
   "claude-plugins"
 );
+var PLUGIN_CACHE_DIR = path3.join(
+  CLAUDE_DIR2,
+  "plugins",
+  "cache",
+  "local-plugins",
+  "fml"
+);
 function readJsonFile2(filePath) {
   try {
     return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
@@ -478,9 +2292,48 @@ function handleUninstall(opts) {
   const targetSpecific = opts.target && opts.target !== "all";
   console.log("Uninstalling fml...\n");
   if (targetSpecific) {
-    console.log("[1/4] Skipping plugin settings (target-specific uninstall)");
+    console.log("[1/5] Skipping plugin uninstall (target-specific uninstall)");
+  } else {
+    console.log("[1/5] Uninstalling MCP plugin...");
+    try {
+      execFileSync2(
+        "claude",
+        ["plugin", "uninstall", "fml@local-plugins", "--scope", "user"],
+        { stdio: "pipe", timeout: 1e4 }
+      );
+      console.log("      Uninstalled (user scope)");
+    } catch {
+    }
+    const installedPluginsPath = path3.join(
+      CLAUDE_DIR2,
+      "plugins",
+      "installed_plugins.json"
+    );
+    const installedPlugins = readJsonFile2(installedPluginsPath);
+    const plugins = installedPlugins?.plugins;
+    const fmlEntries = plugins?.["fml@local-plugins"];
+    if (plugins && fmlEntries) {
+      for (const entry of fmlEntries) {
+        const e = entry;
+        if (e.scope === "project" && e.projectPath) {
+          const projSettings = path3.join(e.projectPath, ".claude", "settings.json");
+          const proj = readJsonFile2(projSettings);
+          if (proj?.enabledPlugins?.["fml@local-plugins"] != null) {
+            delete proj.enabledPlugins["fml@local-plugins"];
+            writeJsonFile2(projSettings, proj);
+            console.log(`      Cleaned ${projSettings}`);
+          }
+        }
+      }
+      delete plugins["fml@local-plugins"];
+      writeJsonFile2(installedPluginsPath, installedPlugins);
+      console.log("      Cleaned installed_plugins.json");
+    }
+  }
+  if (targetSpecific) {
+    console.log("[2/5] Skipping plugin settings (target-specific uninstall)");
   } else {
-    console.log("[1/4] Removing plugin from Claude Code settings...");
+    console.log("[2/5] Removing plugin from Claude Code settings...");
     const settings = readJsonFile2(CLAUDE_SETTINGS_PATH2);
     if (settings) {
       if (settings.enabledPlugins) {
@@ -496,17 +2349,17 @@ function handleUninstall(opts) {
     }
   }
   if (targetSpecific) {
-    console.log("[2/4] Skipping marketplace (target-specific uninstall)");
+    console.log("[3/5] Skipping marketplace (target-specific uninstall)");
   } else {
-    console.log("[2/4] Removing marketplace registration...");
-    const marketplaceLink = path2.join(MARKETPLACE_DIR2, "fml");
+    console.log("[3/5] Removing marketplace registration...");
+    const marketplaceLink = path3.join(MARKETPLACE_DIR2, "fml");
     try {
       fs2.rmSync(marketplaceLink, { recursive: true, force: true });
       console.log(`      Removed ${marketplaceLink}`);
     } catch {
       console.log("      No marketplace link found, skipping");
     }
-    const manifestPath = path2.join(
+    const manifestPath = path3.join(
       MARKETPLACE_DIR2,
       ".claude-plugin",
       "marketplace.json"
@@ -518,7 +2371,7 @@ function handleUninstall(opts) {
       console.log(`      Updated ${manifestPath}`);
     }
   }
-  console.log("[3/4] Running panopticon uninstall...");
+  console.log("[4/5] Running panopticon uninstall...");
   const panoArgs = ["uninstall"];
   if (opts.target) panoArgs.push("--target", opts.target);
   if (opts.purge) panoArgs.push("--purge");
@@ -534,9 +2387,18 @@ function handleUninstall(opts) {
     }
   }
   if (targetSpecific) {
-    console.log("[4/4] Skipping data removal (target-specific uninstall)");
-  } else if (opts.purge) {
-    console.log("[4/4] Removing fml data and logs...");
+    console.log("[5/5] Skipping data removal (target-specific uninstall)");
+  } else {
+    console.log("[5/5] Removing plugin cache...");
+    try {
+      fs2.rmSync(PLUGIN_CACHE_DIR, { recursive: true, force: true });
+      console.log(`      Removed ${PLUGIN_CACHE_DIR}`);
+    } catch {
+      console.log("      No plugin cache found");
+    }
+  }
+  if (opts.purge) {
+    console.log("Removing fml data and logs...");
     for (const dir of [FML_DATA_DIR, FML_LOG_DIR]) {
       try {
         fs2.rmSync(dir, { recursive: true, force: true });
@@ -546,7 +2408,7 @@ function handleUninstall(opts) {
       }
     }
   } else {
-    console.log("[4/4] Keeping fml data (use --purge to remove)");
+    console.log("Keeping fml data (use --purge to remove)");
   }
   console.log("\nDone! FML has been uninstalled.");
 }
@@ -554,7 +2416,7 @@ function handleUninstall(opts) {
 // src/commands/update.ts
 import { execSync as execSync2 } from "child_process";
 async function handleUpdate() {
-  const currentVersion = true ? "0.0.26+def4e37" : "unknown";
+  const currentVersion = true ? "0.0.28+44c986f" : "unknown";
   console.log(`Current: ${currentVersion}`);
   console.log("Updating via npm...\n");
   try {
@@ -576,7 +2438,7 @@ async function handleUpdate() {
 
 // src/auth/oauth.ts
 import crypto from "crypto";
-import http from "http";
+import http2 from "http";
 async function fetchWorkosClientId() {
   const { ConvexHttpClient } = await import("convex/browser");
   const client = new ConvexHttpClient(CONVEX_URL);
@@ -584,6 +2446,22 @@ async function fetchWorkosClientId() {
   const result = await client.query(ref, {});
   return result.workosClientId;
 }
+async function canOpenBrowser() {
+  if (process.env.FML_DEVICE_FLOW === "1") return false;
+  if (process.env.FML_NO_BROWSER === "1") return false;
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+    return false;
+  }
+  if (process.env.SSH_CONNECTION) return false;
+  if (process.env.CODESPACES) return false;
+  if (process.env.REMOTE_CONTAINERS) return false;
+  try {
+    const fs4 = await import("fs");
+    if (fs4.existsSync("/.dockerenv")) return false;
+  } catch {
+  }
+  return true;
+}
 async function login() {
   const clientId = await fetchWorkosClientId();
   const codeVerifier = crypto.randomBytes(32).toString("base64url");
@@ -647,7 +2525,7 @@ function startCallbackServer(expectedState) {
       resolveCode = res;
       rejectCode = rej;
     });
-    const server = http.createServer((req, res) => {
+    const server = http2.createServer((req, res) => {
       const url = new URL(req.url ?? "/", `http://localhost`);
       if (url.pathname === "/callback") {
         const code = url.searchParams.get("code");
@@ -707,6 +2585,93 @@ function startCallbackServer(expectedState) {
   });
 }
 
+// src/auth/device-flow.ts
+import { createInterface } from "readline";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr
+    // Use stderr so stdout stays clean for MCP
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function deviceLogin() {
+  const siteUrl = getSiteUrl();
+  const codeRes = await fetch(`${siteUrl}/api/auth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!codeRes.ok) {
+    const body = await codeRes.text();
+    throw new Error(`Failed to start device flow: ${body}`);
+  }
+  const codeData = await codeRes.json();
+  console.log("");
+  console.log("  Paste this URL in your browser to sign in:");
+  console.log("");
+  console.log(`  ${codeData.verificationUri}`);
+  console.log("");
+  const confirmationCode = await prompt("  Enter the code from your browser: ");
+  if (!confirmationCode) {
+    throw new Error("No confirmation code entered.");
+  }
+  const normalizedCode = confirmationCode.toUpperCase().replace(/[\s-]/g, "").replace(/^(.{4})/, "$1-");
+  console.log("  Verifying...");
+  let pollInterval = codeData.interval * 1e3;
+  while (Date.now() < codeData.expiresAt) {
+    const pollRes = await fetch(`${siteUrl}/api/auth/device/poll`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        deviceCode: codeData.deviceCode,
+        confirmationCode: normalizedCode
+      })
+    });
+    if (pollRes.status === 429) {
+      const data2 = await pollRes.json();
+      pollInterval = (data2.interval ?? codeData.interval * 2) * 1e3;
+      await sleep(pollInterval);
+      continue;
+    }
+    const data = await pollRes.json();
+    if (data.status === "pending") {
+      await sleep(pollInterval);
+      continue;
+    }
+    if (data.status === "authorized") {
+      writeTokens({
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken,
+        expiresAt: data.expiresAt,
+        user: data.user,
+        orgSlug: data.orgSlug ?? void 0,
+        tokenType: "service"
+      });
+      return { email: data.user.email, name: data.user.name };
+    }
+    if (data.status === "invalid_code") {
+      throw new Error(
+        "Invalid confirmation code. Make sure you copied the code from the browser correctly."
+      );
+    }
+    if (data.status === "expired") {
+      throw new Error("Device authorization expired. Run `fml login` again.");
+    }
+    throw new Error(`Device authorization failed: ${data.status}`);
+  }
+  throw new Error(
+    "Device authorization timed out (15 minutes). Run `fml login` again."
+  );
+}
+
 // src/commands/login.ts
 async function linkGitHubIdentity() {
   const token = resolveGitHubToken();
@@ -733,6 +2698,9 @@ async function linkGitHubIdentity() {
       console.warn("[fml] No FML token available \u2014 skipping identity link");
       return;
     }
+    if (fmlToken.startsWith("fml_st_")) {
+      return;
+    }
     if (!CONVEX_URL) {
       console.warn(
         "[fml] No Convex URL configured \u2014 skipping identity link (run fml install first)"
@@ -768,11 +2736,11 @@ async function selectOrg() {
   } catch {
   }
 }
-async function handleLogin() {
+async function handleLogin(opts) {
   const { name: envName } = getActiveEnv();
   const existingToken = await getValidToken();
   if (existingToken) {
-    const { readTokens: readTokens2 } = await import("./token-store-KQSMR6XA.js");
+    const { readTokens: readTokens2 } = await import("./token-store-Y35HF3FJ.js");
     const stored = readTokens2();
     console.log(
       `Already logged in as ${stored?.user.name} (${stored?.user.email}) on ${envName}.`
@@ -784,9 +2752,15 @@ async function handleLogin() {
   }
   console.log(`Signing in to FML (${envName})...`);
   try {
-    const { email, name } = await login();
+    const useDeviceFlow = opts?.device || !await canOpenBrowser();
+    let result;
+    if (useDeviceFlow) {
+      result = await deviceLogin();
+    } else {
+      result = await login();
+    }
     console.log(`
-Logged in as ${name} (${email})`);
+Logged in as ${result.name} (${result.email})`);
     await linkGitHubIdentity();
     await selectOrg();
     console.log("You're all set! Restart Claude Code to use FML tools.");
@@ -899,14 +2873,6 @@ async function handleStatus() {
 }
 
 // src/commands/sync.ts
-import {
-  addTarget as addTarget2,
-  removeTarget,
-  listTargets as listTargets2,
-  loadSyncConfig as loadSyncConfig2,
-  saveSyncConfig
-} from "@fml-inc/panopticon/sync";
-import { syncPending as syncPending2, syncReset } from "@fml-inc/panopticon/api";
 var FML_SYNC_URL = CONVEX_URL.replace(".cloud", ".site");
 async function handleSyncSetup() {
   console.log("FML Sync Setup\n");
@@ -918,7 +2884,7 @@ async function handleSyncSetup() {
     process.exit(1);
   }
   console.log("GitHub token: found");
-  addTarget2({
+  addTarget({
     name: DEFAULT_TARGET_NAME,
     url: FML_SYNC_URL,
     tokenCommand: "gh auth token"
@@ -931,7 +2897,7 @@ Sync target "${DEFAULT_TARGET_NAME}" configured:`);
 Restart panopticon to activate: fml stop && fml start`);
 }
 async function handleSyncList() {
-  const targets = listTargets2();
+  const targets = listTargets();
   if (targets.length === 0) {
     console.log(
       "No sync targets configured. Run `fml sync setup` or `fml sync add`."
@@ -947,14 +2913,14 @@ async function handleSyncList() {
   }
 }
 async function handleSyncAdd(name, url, opts) {
-  const existing = listTargets2();
+  const existing = listTargets();
   if (existing.some((t) => t.name === name)) {
     console.error(
       `Target "${name}" already exists. Use \`fml sync edit\` to modify it.`
     );
     process.exit(1);
   }
-  addTarget2({
+  addTarget({
     name,
     url,
     tokenCommand: opts.tokenCmd,
@@ -978,8 +2944,8 @@ async function handleSyncRemove(name) {
   }
 }
 async function handleSyncEdit(name, opts) {
-  const config2 = loadSyncConfig2();
-  const target = config2.targets.find((t) => t.name === name);
+  const config3 = loadSyncConfig();
+  const target = config3.targets.find((t) => t.name === name);
   if (!target) {
     console.error(`Target "${name}" not found.`);
     process.exit(1);
@@ -993,7 +2959,7 @@ async function handleSyncEdit(name, opts) {
     target.token = opts.token;
     delete target.tokenCommand;
   }
-  saveSyncConfig(config2);
+  saveSyncConfig(config3);
   console.log(`Sync target "${name}" updated:`);
   console.log(`  URL:  ${target.url}`);
   const auth = target.token ? "static token" : target.tokenCommand ? `command: ${target.tokenCommand}` : "none";
@@ -1001,7 +2967,7 @@ async function handleSyncEdit(name, opts) {
   console.log("\nRestart panopticon to apply: fml stop && fml start");
 }
 async function handleSyncStatus() {
-  const targets = listTargets2();
+  const targets = listTargets();
   if (targets.length === 0) {
     console.log("No sync targets configured. Run `fml sync setup` first.");
     return;
@@ -1012,7 +2978,7 @@ async function handleSyncStatus() {
     console.log(`  URL:  ${target.url}`);
     console.log(`  Auth: ${auth}`);
     try {
-      const result = await syncPending2(target.name);
+      const result = await syncPending(target.name);
       if (result.totalPending === 0) {
         console.log("  Status: up to date");
       } else {
@@ -1038,14 +3004,13 @@ async function handleSyncReset(targetName) {
 }
 
 // src/commands/env.ts
-import { listTargets as listTargets3 } from "@fml-inc/panopticon/sync";
 function handleEnvShow() {
   const { name, convexUrl } = getActiveEnv();
   console.log(`Environment: ${name}`);
   console.log(`  Convex URL: ${convexUrl}`);
 }
 async function handleEnvSwitch(target) {
-  const targets = listTargets3();
+  const targets = listTargets();
   const match = targets.find((t) => t.name === target);
   if (!match) {
     console.error(`Sync target "${target}" not found. Available targets:`);
@@ -1615,7 +3580,7 @@ if (process.argv.length <= 2 || process.argv.includes("--help") || process.argv.
   printBanner();
 }
 var program = new Command().name("fml").description("FML agent tools for Claude Code").version(
-  true ? "0.0.26+def4e37" : "dev"
+  true ? "0.0.28+44c986f" : "dev"
 );
 program.command("tools", { hidden: true }).description("List all available CLI commands (including hidden agent tools)").action(() => {
   function formatCmd(cmd, prefix = "") {
@@ -1642,7 +3607,7 @@ program.command("uninstall").description("Remove fml plugin, hooks, and optional
   "Target CLI: claude, gemini, codex, claude-desktop, all"
 ).option("--purge", "Also remove all data, logs, and auth tokens").action((opts) => handleUninstall(opts));
 program.command("update").description("Update fml to the latest version").action(() => handleUpdate());
-program.command("login").description("Sign in to your FML account").action(() => handleLogin());
+program.command("login").description("Sign in to your FML account").option("--device", "Use device authorization flow (no browser needed)").action((opts) => handleLogin(opts));
 program.command("logout").description("Sign out and clear stored credentials").action(() => handleLogout());
 program.command("org").description("Show or select organization").argument("[slug]", "Org slug to select").action((slug) => handleOrg(slug));
 program.command("status").description("Show current auth and daemon status").action(() => handleStatus());
@@ -1709,9 +3674,9 @@ messages.command("context").description("Get messages around a specific message"
 var skills = program.command("skills", { hidden: true }).description("Browse and load skills");
 skills.command("list").description("List available skills").action(() => handleSkillsList());
 skills.command("load").description("Load a skill by ID").argument("<skill-id>", "Skill ID").action((skillId) => handleSkillsLoad(skillId));
-var config = program.command("config", { hidden: true }).description("View team config snapshots");
-config.command("list").description("List config snapshots for an org").requiredOption("--org <slug>", "Organization slug").option("--repo <full-name>", "Filter by repo (owner/name)").action((opts) => handleConfigList(opts));
-config.command("detail").description("Get config snapshot detail").requiredOption("--org <slug>", "Organization slug").option("--user <username>", "GitHub username").option("--repo <full-name>", "Repository (owner/name)").action((opts) => handleConfigDetail(opts));
+var config2 = program.command("config", { hidden: true }).description("View team config snapshots");
+config2.command("list").description("List config snapshots for an org").requiredOption("--org <slug>", "Organization slug").option("--repo <full-name>", "Filter by repo (owner/name)").action((opts) => handleConfigList(opts));
+config2.command("detail").description("Get config snapshot detail").requiredOption("--org <slug>", "Organization slug").option("--user <username>", "GitHub username").option("--repo <full-name>", "Repository (owner/name)").action((opts) => handleConfigDetail(opts));
 program.parseAsync(process.argv).catch((err) => {
   Sentry.captureException(err);
   console.error(err);