@swmansion/argent 0.16.1 → 0.16.2-next.1

package/dist/cli-cmds.mjs

@@ -204,7 +204,7 @@ function generateAuthToken() {
   return generateToken();
 }
 function findFreePort() {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -215,7 +215,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve6(port);
+        else resolve7(port);
       });
     });
     srv.on("error", reject);
@@ -316,7 +316,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -353,7 +353,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve6({ port: actualPort, pid }));
+        settle(() => resolve7({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -742,8 +742,8 @@ function parseLinkTarget(input) {
   const host = u3.hostname.startsWith("[") ? u3.hostname.slice(1, -1) : u3.hostname;
   if (!host) throw new Error(`URL "${input}" is missing a host.`);
   const port = u3.port ? Number(u3.port) : u3.protocol === "https:" ? 443 : 80;
-  const path14 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
-  const url = `${u3.protocol}//${u3.host}${path14}`;
+  const path15 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
+  const url = `${u3.protocol}//${u3.host}${path15}`;
   const token = u3.username ? decodeURIComponent(u3.username) : void 0;
   return { url, host, port, ...token ? { token } : {} };
 }
@@ -879,9 +879,9 @@ async function tarball(sourcePath) {
   return tarPath;
 }
 function sha256File(filePath) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const hash = createHash2("sha256");
-    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve6(hash.digest("hex"))).on("error", reject);
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve7(hash.digest("hex"))).on("error", reject);
   });
 }
 async function uploadTar(tarPath, endpoint) {
@@ -1254,8 +1254,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname4(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path14) {
-  return path14.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path15) {
+  return path15.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -2889,13 +2889,13 @@ var DEFAULT_EXCEPTION_STEPS_CONFIG = {
   enabled: true,
   max_bytes: 32768
 };
-function resolveExceptionStepsConfig(config) {
-  if (!config) return {
+function resolveExceptionStepsConfig(config2) {
+  if (!config2) return {
     ...DEFAULT_EXCEPTION_STEPS_CONFIG
   };
   return {
-    enabled: config.enabled ?? DEFAULT_EXCEPTION_STEPS_CONFIG.enabled,
-    max_bytes: normalizePositiveInteger(config.max_bytes, DEFAULT_EXCEPTION_STEPS_CONFIG.max_bytes)
+    enabled: config2.enabled ?? DEFAULT_EXCEPTION_STEPS_CONFIG.enabled,
+    max_bytes: normalizePositiveInteger(config2.max_bytes, DEFAULT_EXCEPTION_STEPS_CONFIG.max_bytes)
   };
 }
 function stripReservedExceptionStepFields(properties) {
@@ -2918,13 +2918,13 @@ function stripReservedExceptionStepFields(properties) {
   };
 }
 var ExceptionStepsBuffer = class {
-  constructor(config) {
+  constructor(config2) {
     this._entries = [];
     this._totalBytes = 0;
-    this._config = resolveExceptionStepsConfig(config);
+    this._config = resolveExceptionStepsConfig(config2);
   }
-  setConfig(config) {
-    this._config = resolveExceptionStepsConfig(config);
+  setConfig(config2) {
+    this._config = resolveExceptionStepsConfig(config2);
     this._trimToMaxBytes();
   }
   add(step) {
@@ -3807,15 +3807,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path14, ranges, output) {
-  return new Promise((resolve6) => {
-    const stream = createReadStream2(path14);
+function getContextLinesFromFile(path15, ranges, output) {
+  return new Promise((resolve7) => {
+    const stream = createReadStream2(path15);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve6();
+      resolve7();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -3824,7 +3824,7 @@ function getContextLinesFromFile(path14, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path14, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path15, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -3885,8 +3885,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path14) {
-  return path14.startsWith("node:") || path14.endsWith(".min.js") || path14.endsWith(".min.cjs") || path14.endsWith(".min.mjs") || path14.startsWith("data:");
+function shouldSkipContextLinesForFile(path15) {
+  return path15.startsWith("node:") || path15.endsWith(".min.js") || path15.endsWith(".min.cjs") || path15.endsWith(".min.mjs") || path15.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -5112,9 +5112,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve6;
+      let resolve7;
       const promise = new Promise((r2) => {
-        resolve6 = r2;
+        resolve7 = r2;
       });
       try {
         waitUntil(promise);
@@ -5122,7 +5122,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve6,
+        resolve: resolve7,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -5146,12 +5146,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve6 = this._consumeWaitUntilCycle();
+    const resolve7 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve6?.();
+      resolve7?.();
     }
   }
   getPersistedProperty(key) {
@@ -5272,15 +5272,15 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
     if (this.isLocalEvaluationReady()) return true;
     if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve6(false);
+        resolve7(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve6(count > 0);
+        resolve7(count > 0);
       });
     });
   }
@@ -5735,14 +5735,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve6 = this._consumeWaitUntilCycle();
+    const resolve7 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
       this.distinctIdHasSentFlagCalls = {};
-      resolve6?.();
+      resolve7?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -6090,8 +6090,8 @@ function resolveConfig() {
 var client;
 function getClient() {
   if (client !== void 0) return client;
-  const config = resolveConfig();
-  if (!config.isUsable) {
+  const config2 = resolveConfig();
+  if (!config2.isUsable) {
     client = null;
     return null;
   }
@@ -6104,7 +6104,7 @@ function getClient() {
     fetchRetryCount: 0
   };
   try {
-    client = new PostHog(config.key, opts);
+    client = new PostHog(config2.key, opts);
   } catch {
     client = null;
     return null;
@@ -6711,9 +6711,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path14) {
+function safeExists(fileExists, path15) {
   try {
-    return fileExists(path14);
+    return fileExists(path15);
   } catch {
     return false;
   }
@@ -7200,18 +7200,20 @@ function getFlagDefinition(name, registry = FLAG_REGISTRY) {
   return registry.find((def) => def.name === name);
 }
 var PROJECT_MARKERS = [".argent", ".git", "package.json"];
-function resolveProjectRoot(startDir) {
-  const initial = path4.resolve(startDir);
-  let current = initial;
+function findProjectRoot(startDir) {
+  let current = path4.resolve(startDir);
   while (true) {
     for (const marker of PROJECT_MARKERS) {
       if (fs2.existsSync(path4.join(current, marker))) return current;
     }
     const parent = path4.dirname(current);
-    if (parent === current) return initial;
+    if (parent === current) return null;
     current = parent;
   }
 }
+function resolveProjectRoot(startDir) {
+  return findProjectRoot(startDir) ?? path4.resolve(startDir);
+}
 function getFlagsPath(scope, options = {}) {
   const home = options.homeDir ?? homedir3();
   if (scope === "global") {
@@ -7296,33 +7298,91 @@ function argentHomeDir() {
   const home = process.platform === "win32" ? nonEmpty(process.env.USERPROFILE) ?? os.homedir() : nonEmpty(process.env.HOME) ?? os.homedir();
   return path5.join(home, ".argent");
 }
-function configFilePath() {
-  return path5.join(argentHomeDir(), "config.json");
+function configDir(scope = "global", options = {}) {
+  if (scope === "global") {
+    return options.homeDir ? path5.join(options.homeDir, ".argent") : argentHomeDir();
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path5.join(resolveProjectRoot(cwd), ".argent");
+}
+function configFilePath(scope = "global", options = {}) {
+  return path5.join(configDir(scope, options), "config.json");
 }
 
 // ../configuration-core/src/config.ts
 import * as crypto from "node:crypto";
 import * as fs3 from "node:fs";
 import * as path6 from "node:path";
-function readConfigObject() {
+function readConfigObject(scope = "global", options = {}) {
   try {
-    const raw = fs3.readFileSync(configFilePath(), "utf8");
+    const raw = fs3.readFileSync(configFilePath(scope, options), "utf8");
     const json = JSON.parse(raw);
-    if (json && typeof json === "object") {
+    if (json && typeof json === "object" && !Array.isArray(json)) {
       return json;
     }
   } catch {
   }
   return {};
 }
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function splitKey(dottedKey) {
+  const parts = dottedKey.split(".");
+  if (parts.length === 0 || parts.some((p) => p === "")) {
+    throw new Error(`Invalid config key "${dottedKey}": empty path segment`);
+  }
+  for (const p of parts) {
+    if (FORBIDDEN_SEGMENTS.has(p)) {
+      throw new Error(`Invalid config key "${dottedKey}": forbidden segment "${p}"`);
+    }
+  }
+  return parts;
+}
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getAtPath(obj, dottedKey) {
+  const parts = splitKey(dottedKey);
+  let cur = obj;
+  for (const part of parts) {
+    if (!isPlainObject2(cur)) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setAtPath(obj, dottedKey, value) {
+  const parts = splitKey(dottedKey);
+  let cur = obj;
+  for (let i2 = 0; i2 < parts.length - 1; i2++) {
+    const part = parts[i2];
+    const next = cur[part];
+    if (!isPlainObject2(next)) {
+      cur[part] = {};
+    }
+    cur = cur[part];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+function deleteAtPath(obj, dottedKey) {
+  const parts = splitKey(dottedKey);
+  let cur = obj;
+  for (let i2 = 0; i2 < parts.length - 1; i2++) {
+    const next = cur[parts[i2]];
+    if (!isPlainObject2(next)) return false;
+    cur = next;
+  }
+  const leaf = parts[parts.length - 1];
+  if (!Object.hasOwn(cur, leaf)) return false;
+  delete cur[leaf];
+  return true;
+}
 var LOCK_STALE_MS2 = 1e4;
 var LOCK_MAX_WAIT_MS = 2e3;
 var LOCK_RETRY_MS = 25;
 function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function acquireConfigLock() {
-  const lockPath = configFilePath() + ".lock";
+function acquireConfigLock(finalPath) {
+  const lockPath = finalPath + ".lock";
   const deadline = Date.now() + LOCK_MAX_WAIT_MS;
   for (; ; ) {
     try {
@@ -7357,14 +7417,15 @@ function releaseConfigLock(lock) {
   } catch {
   }
 }
-function updateConfig(mutate) {
-  fs3.mkdirSync(argentHomeDir(), { recursive: true });
-  const lock = acquireConfigLock();
+function updateConfig(mutate, scope = "global", options = {}) {
+  const dir = configDir(scope, options);
+  fs3.mkdirSync(dir, { recursive: true });
+  const finalPath = configFilePath(scope, options);
+  const lock = acquireConfigLock(finalPath);
   try {
-    const next = readConfigObject();
+    const next = readConfigObject(scope, options);
     mutate(next);
-    const finalPath = configFilePath();
-    const tmpPath = path6.join(argentHomeDir(), `.config.tmp.${process.pid}.${crypto.randomUUID()}`);
+    const tmpPath = path6.join(dir, `.config.tmp.${process.pid}.${crypto.randomUUID()}`);
     const fd = fs3.openSync(tmpPath, "wx", 384);
     try {
       fs3.writeSync(fd, JSON.stringify(next, null, 2) + "\n");
@@ -7385,27 +7446,215 @@ function updateConfig(mutate) {
     if (lock) releaseConfigLock(lock);
   }
 }
-function readLensConfig() {
-  const lens2 = readConfigObject().lens;
-  return lens2 && typeof lens2 === "object" ? lens2 : {};
+
+// ../configuration-core/src/merge.ts
+function mergeRestrictive(local, global2) {
+  if (local === void 0) return global2;
+  if (global2 === void 0) return local;
+  if (typeof local === "boolean" && typeof global2 === "boolean") {
+    return local && global2;
+  }
+  if (typeof local === "number" && typeof global2 === "number") {
+    return Math.min(local, global2);
+  }
+  return local;
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+function mergeUnion(local, global2) {
+  const l2 = toArray(local);
+  const g = toArray(global2);
+  if (l2 === null && g === null) return local ?? global2;
+  const merged = [...g ?? [], ...l2 ?? []];
+  return Array.from(new Set(merged));
+}
+function mergeIntersection(local, global2) {
+  const l2 = toArray(local);
+  const g = toArray(global2);
+  if (l2 === null && g === null) return local ?? global2;
+  if (l2 === null) return global2;
+  if (g === null) return local;
+  const globalSet = new Set(g);
+  return l2.filter((item) => globalSet.has(item));
+}
+function applyMergePolicy(policy, local, global2) {
+  if (typeof policy === "function") return policy({ local, global: global2 });
+  switch (policy) {
+    case "prioritize-local":
+      return local ?? global2;
+    case "prioritize-global":
+      return global2 ?? local;
+    case "prioritize-restrictive":
+      return mergeRestrictive(local, global2);
+    case "union":
+      return mergeUnion(local, global2);
+    case "intersection":
+      return mergeIntersection(local, global2);
+    default: {
+      const _exhaustive = policy;
+      return _exhaustive;
+    }
+  }
+}
+
+// ../configuration-core/src/config-schema.ts
+function asBoolean(raw) {
+  return typeof raw === "boolean" ? raw : void 0;
+}
+function asString(raw) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  return trimmed === "" ? void 0 : trimmed;
 }
-function getRememberedAgent() {
-  const agent = readLensConfig().agent;
-  return typeof agent === "string" && agent.trim() ? agent : null;
+var CONFIG_SCHEMA = [
+  {
+    key: "telemetry.enabled",
+    description: "Whether anonymous opt-out telemetry is enabled (on by default; environment opt-outs like DO_NOT_TRACK are not reflected here \u2014 `argent telemetry status` shows effective consent).",
+    scopes: ["global"],
+    parse: asBoolean,
+    // A committed project file must never re-enable telemetry a user disabled
+    // globally, so the more-restrictive (opt-out) value always wins.
+    merge: "prioritize-restrictive",
+    // Telemetry is opt-out: with nothing stored, consent.ts treats it as
+    // enabled, and the config surface must report the same instead of "(unset)".
+    default: true,
+    // Read-only under `argent config`: opt-in/out goes through the dedicated
+    // command so the live client is drained/reset, not just the file rewritten.
+    manageCommand: "argent telemetry"
+  },
+  {
+    key: "lens.agent",
+    description: "Coding-agent id remembered by `argent lens` to skip the picker.",
+    scopes: ["project", "global"],
+    parse: asString,
+    // A repo can pin the agent its screenshots should use; falls back to the
+    // user's global remembered choice.
+    merge: "prioritize-local",
+    example: "claude"
+  }
+];
+function getConfigDefinition(key, registry = CONFIG_SCHEMA) {
+  return registry.find((def) => def.key === key);
 }
-function setRememberedAgent(agentId) {
-  updateConfig((config) => {
-    const lens2 = config.lens && typeof config.lens === "object" ? config.lens : {};
-    lens2.agent = agentId;
-    config.lens = lens2;
-  });
+
+// ../configuration-core/src/config-access.ts
+function readScopeValue(def, scope, options) {
+  if (!def.scopes.includes(scope)) return void 0;
+  const raw = getAtPath(readConfigObject(scope, options), def.key);
+  return raw === void 0 ? void 0 : def.parse(raw);
 }
-function clearRememberedAgent() {
-  updateConfig((config) => {
-    if (config.lens && typeof config.lens === "object") {
-      delete config.lens.agent;
-    }
-  });
+function getConfigValue(def, options = {}) {
+  const local = readScopeValue(def, "project", options);
+  const global2 = readScopeValue(def, "global", options);
+  const merged = applyMergePolicy(def.merge, local, global2);
+  return merged ?? def.default;
+}
+function getConfigValueAtScope(key, scope, options = {}, registry = CONFIG_SCHEMA) {
+  const def = requireDefinition(key, registry);
+  return readScopeValue(def, scope, options);
+}
+function getConfigValueByKey(key, options = {}, registry = CONFIG_SCHEMA) {
+  const def = requireDefinition(key, registry);
+  return getConfigValue(def, options);
+}
+function requireDefinition(key, registry = CONFIG_SCHEMA) {
+  const def = getConfigDefinition(key, registry);
+  if (!def) {
+    throw new UnknownConfigKeyError(key);
+  }
+  return def;
+}
+var UnknownConfigKeyError = class extends Error {
+  constructor(key) {
+    super(`Unknown configuration key "${key}".`);
+    this.key = key;
+    this.name = "UnknownConfigKeyError";
+  }
+  key;
+};
+var ConfigScopeError = class extends Error {
+  constructor(key, scope, allowed) {
+    super(`Config key "${key}" cannot be set at ${scope} scope (allowed: ${allowed.join(", ")}).`);
+    this.key = key;
+    this.scope = scope;
+    this.allowed = allowed;
+    this.name = "ConfigScopeError";
+  }
+  key;
+  scope;
+  allowed;
+};
+var ConfigValidationError = class extends Error {
+  constructor(key) {
+    super(`Invalid value for config key "${key}".`);
+    this.key = key;
+    this.name = "ConfigValidationError";
+  }
+  key;
+};
+var ConfigManagedElsewhereError = class extends Error {
+  constructor(key, command) {
+    super(`Config key "${key}" is managed by \`${command}\`.`);
+    this.key = key;
+    this.command = command;
+    this.name = "ConfigManagedElsewhereError";
+  }
+  key;
+  command;
+};
+function setConfigValue(key, rawValue, scope = "global", options = {}, registry = CONFIG_SCHEMA) {
+  const def = requireDefinition(key, registry);
+  if (def.manageCommand) throw new ConfigManagedElsewhereError(key, def.manageCommand);
+  if (!def.scopes.includes(scope)) throw new ConfigScopeError(key, scope, def.scopes);
+  const parsed = def.parse(rawValue);
+  if (parsed === void 0) throw new ConfigValidationError(key);
+  updateConfig((config2) => setAtPath(config2, key, parsed), scope, options);
+  return parsed;
+}
+function unsetConfigValue(key, scope = "global", options = {}, registry = CONFIG_SCHEMA) {
+  const def = requireDefinition(key, registry);
+  if (def.manageCommand) throw new ConfigManagedElsewhereError(key, def.manageCommand);
+  if (!def.scopes.includes(scope)) throw new ConfigScopeError(key, scope, def.scopes);
+  if (getAtPath(readConfigObject(scope, options), key) === void 0) return false;
+  let removed = false;
+  updateConfig(
+    (config2) => {
+      removed = deleteAtPath(config2, key);
+    },
+    scope,
+    options
+  );
+  return removed;
+}
+function listConfig(options = {}, registry = CONFIG_SCHEMA) {
+  return registry.map((def) => ({
+    key: def.key,
+    description: def.description,
+    scopes: def.scopes,
+    ...def.manageCommand ? { manageCommand: def.manageCommand } : {},
+    effective: getConfigValue(def, options),
+    project: readScopeValue(def, "project", options),
+    global: readScopeValue(def, "global", options)
+  }));
+}
+function coerceCliValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+var LENS_AGENT_KEY = "lens.agent";
+function getRememberedAgent(options = {}) {
+  const value = getConfigValueByKey(LENS_AGENT_KEY, options);
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function setRememberedAgent(agentId, options = {}) {
+  setConfigValue(LENS_AGENT_KEY, agentId, "global", options);
+}
+function clearRememberedAgent(options = {}) {
+  unsetConfigValue(LENS_AGENT_KEY, "global", options);
 }
 
 // ../telemetry/src/paths.ts
@@ -7652,16 +7901,20 @@ function hostPlatformKey() {
   }
   return process.platform;
 }
+function simulatorServerBinaryName() {
+  return process.platform === "win32" ? "simulator-server.exe" : "simulator-server";
+}
 function platformBinDir() {
   return path9.join(BIN_DIR, hostPlatformKey());
 }
 function simulatorServerBinaryPath() {
-  const p = path9.join(platformBinDir(), "simulator-server");
+  const binaryName = simulatorServerBinaryName();
+  const p = path9.join(platformBinDir(), binaryName);
   if (!fs5.existsSync(p)) {
-    const flat = path9.join(BIN_DIR, "simulator-server");
+    const flat = path9.join(BIN_DIR, binaryName);
     const migrationHint = fs5.existsSync(flat) ? ` Found a binary at the old flat path ${flat}; move it to ${p} or update ARGENT_SIMULATOR_SERVER_DIR to point at the parent of the platform subdirectory.` : "";
     throw new Error(
-      `simulator-server binary not found for platform "${hostPlatformKey()}" at ${p}. Supported hosts today: darwin, linux (x86_64 and arm64).${migrationHint}`
+      `simulator-server binary not found for platform "${hostPlatformKey()}" at ${p}. Supported hosts today: darwin, linux (x86_64 and arm64), win32.${migrationHint}`
     );
   }
   return p;
@@ -7692,12 +7945,12 @@ function resolveHostFingerprint() {
   }
 }
 function resolveHostFingerprintAsync() {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let binary;
     try {
       binary = simulatorServerBinaryPath();
     } catch {
-      resolve6(null);
+      resolve7(null);
       return;
     }
     let settled = false;
@@ -7710,7 +7963,7 @@ function resolveHostFingerprintAsync() {
         child?.kill("SIGKILL");
       } catch {
       }
-      resolve6(value);
+      resolve7(value);
     };
     const watchdog = setTimeout(() => finish(null), FINGERPRINT_TIMEOUT_MS);
     watchdog.unref?.();
@@ -7822,9 +8075,9 @@ function isEnabled(env = process.env) {
   return getConsentState(env).enabled;
 }
 function writeConsentFlag(enabled) {
-  updateConfig((config) => {
-    const telemetryBlock = typeof config.telemetry === "object" && config.telemetry ? config.telemetry : {};
-    config.telemetry = { ...telemetryBlock, enabled };
+  updateConfig((config2) => {
+    const telemetryBlock = typeof config2.telemetry === "object" && config2.telemetry ? config2.telemetry : {};
+    config2.telemetry = { ...telemetryBlock, enabled };
   });
   cache.current = null;
 }
@@ -7952,7 +8205,7 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
   try {
     await Promise.race([
       client2.shutdown(timeoutMs),
-      new Promise((resolve6) => setTimeout(resolve6, timeoutMs + 250).unref())
+      new Promise((resolve7) => setTimeout(resolve7, timeoutMs + 250).unref())
     ]);
   } catch (err) {
     emitDebugError("shutdown failed", err);
@@ -7972,7 +8225,7 @@ async function markDisabled() {
       try {
         await Promise.race([
           client2.shutdown(SHORT_FLUSH_TIMEOUT_MS),
-          new Promise((resolve6) => setTimeout(resolve6, SHORT_FLUSH_TIMEOUT_MS).unref())
+          new Promise((resolve7) => setTimeout(resolve7, SHORT_FLUSH_TIMEOUT_MS).unref())
         ]);
       } catch {
       }
@@ -7988,14 +8241,14 @@ function status() {
   const anonId = peekAnonId();
   const hasAnonIdOnDisk = anonId !== null;
   const anonIdPrefix = anonId ? anonId.slice(0, 8) : null;
-  const config = resolveConfig();
+  const config2 = resolveConfig();
   return {
     enabled: consent.enabled,
     source: consent.source,
     anonIdPrefix,
     hasAnonIdOnDisk,
     host: POSTHOG_HOST,
-    isKeyConfigured: config.isUsable
+    isKeyConfigured: config2.isUsable
   };
 }
 
@@ -8214,13 +8467,13 @@ function splitOptions(argv) {
   return { json, outPath, argvForFlags: rest };
 }
 async function readStdin() {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve6(data));
+    process.stdin.on("end", () => resolve7(data));
     process.stdin.on("error", reject);
   });
 }
@@ -8582,7 +8835,7 @@ function resolveArtifactDisplayPaths(report) {
 }
 function exitAfterFlush(code, streams = [process.stdout, process.stderr]) {
   return Promise.all(
-    streams.map((s) => new Promise((resolve6) => s.write("", () => resolve6())))
+    streams.map((s) => new Promise((resolve7) => s.write("", () => resolve7())))
   ).then(() => process.exit(code));
 }
 function renderReport(report) {
@@ -9467,7 +9720,7 @@ function ptyInjectBeats(text2) {
   ];
 }
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
@@ -9688,7 +9941,7 @@ var SPAWN_GRACE_MS = 8e3;
 var DEATH_CONFIRMATIONS = 3;
 var SSE_RECONNECT_MS = 1e3;
 function sleep2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 var TRUST_PROMPT_RE = /trust this folder|do you trust|yes,? i trust|trust the files in this/i;
 async function dismissTrustPrompt(session) {
@@ -10334,8 +10587,8 @@ Options:
     console.log("Feature flags (project overrides global):");
     const maxName = registryView.reduce((m, f) => Math.max(m, f.name.length), 0);
     for (const f of registryView) {
-      const scopeLabel = f.scope ? ` (${f.scope})` : "";
-      console.log(`  ${f.name.padEnd(maxName, " ")}  ${colorState(f.enabled)}${scopeLabel}`);
+      const scopeLabel2 = f.scope ? ` (${f.scope})` : "";
+      console.log(`  ${f.name.padEnd(maxName, " ")}  ${colorState(f.enabled)}${scopeLabel2}`);
       console.log(`  ${" ".repeat(maxName)}  ${f.description}`);
     }
   }
@@ -10351,6 +10604,254 @@ Options:
   console.log(`  Project: ${getFlagsPath("project")}`);
 }
 
+// ../argent-cli/src/config.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import * as path14 from "node:path";
+function config(argv) {
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    printUsage();
+    return;
+  }
+  const [sub, ...rest] = argv;
+  switch (sub) {
+    case "list":
+      return cmdList(rest);
+    case "get":
+      return cmdGet(rest);
+    case "set":
+      return cmdSet(rest);
+    case "unset":
+      return cmdUnset(rest);
+    default:
+      console.error(`Error: unknown subcommand "config ${sub}". Try \`argent config --help\`.`);
+      process.exit(2);
+  }
+}
+function cmdList(argv) {
+  if (wantsHelp(argv)) {
+    console.log(`Usage: argent config list [--json]
+
+Show every recognized configuration value, its effective (merged) value, and
+the raw value stored at each scope.`);
+    return;
+  }
+  const json = argv.includes("--json");
+  const entries = listConfig();
+  if (json) {
+    console.log(JSON.stringify({ config: entries }, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    console.log("No configurations are defined.");
+    return;
+  }
+  console.log("Configuration (project overrides global unless noted):\n");
+  const maxKey = entries.reduce((m, e) => Math.max(m, e.key.length), 0);
+  for (const e of entries) {
+    const managed = e.manageCommand ? import_picocolors2.default.dim(`  [managed by \`${e.manageCommand}\`]`) : "";
+    console.log(`  ${e.key.padEnd(maxKey)}  ${formatValue(e.effective)}${managed}`);
+    console.log(`  ${" ".repeat(maxKey)}  ${import_picocolors2.default.dim(e.description)}`);
+    console.log(`  ${" ".repeat(maxKey)}  ${import_picocolors2.default.dim(scopeDetail(e))}`);
+  }
+}
+function scopeDetail(e) {
+  const parts = [`scopes: ${e.scopes.join(", ")}`];
+  if (e.project !== void 0) parts.push(`project=${formatValuePlain(e.project)}`);
+  if (e.global !== void 0) parts.push(`global=${formatValuePlain(e.global)}`);
+  return parts.join("  \xB7  ");
+}
+function cmdGet(argv) {
+  if (wantsHelp(argv)) {
+    console.log(`Usage: argent config get <key> [--scope global|project] [--json]
+
+Print a configuration value. Without --scope, prints the effective value after
+merging project and global. With --scope, prints only that scope's stored value.`);
+    return;
+  }
+  const { positionals, scope, json } = parseArgs2(argv);
+  const key = positionals[0];
+  if (!key) {
+    console.error("Error: `argent config get` requires a <key>.");
+    process.exit(2);
+  }
+  if (positionals.length > 1) {
+    console.error(`Error: unexpected extra argument "${positionals[1]}".`);
+    process.exit(2);
+  }
+  try {
+    const value = scope ? getConfigValueAtScope(key, scope) : getConfigValueByKey(key);
+    if (json) {
+      console.log(
+        JSON.stringify({ key, scope: scope ?? "effective", value: value ?? null }, null, 2)
+      );
+    } else if (value === void 0) {
+      console.log("(unset)");
+    } else {
+      console.log(formatValuePlain(value));
+    }
+  } catch (err) {
+    reportError(err);
+  }
+}
+function cmdSet(argv) {
+  if (wantsHelp(argv)) {
+    console.log(`Usage: argent config set <key> <value> [--scope global|project]
+
+Set a configuration value. Default scope is global; pass --scope project to
+write <project-root>/.argent/config.json. Booleans, numbers, and JSON arrays are
+parsed (e.g. \`true\`, \`42\`, \`["a","b"]\`); anything else is stored as a string.`);
+    return;
+  }
+  const { positionals, scope } = parseArgs2(argv);
+  const key = positionals[0];
+  const rawValue = positionals[1];
+  if (!key || rawValue === void 0) {
+    console.error("Error: `argent config set` requires a <key> and a <value>.");
+    process.exit(2);
+  }
+  if (positionals.length > 2) {
+    console.error(`Error: unexpected extra argument "${positionals[2]}".`);
+    process.exit(2);
+  }
+  const targetScope = scope ?? "global";
+  const warning = degenerateProjectScopeWarning(targetScope);
+  try {
+    const stored = setConfigValue(key, coerceCliValue(rawValue), targetScope);
+    if (warning) console.error(import_picocolors2.default.yellow(warning));
+    console.log(`Set ${import_picocolors2.default.bold(key)} = ${formatValuePlain(stored)} (${scopeLabel(targetScope)}).`);
+  } catch (err) {
+    reportError(err);
+  }
+}
+function cmdUnset(argv) {
+  if (wantsHelp(argv)) {
+    console.log(`Usage: argent config unset <key> [--scope global|project]
+
+Remove a configuration value at a scope (default global). Falls back to the
+other scope / the default on the next read.`);
+    return;
+  }
+  const { positionals, scope } = parseArgs2(argv);
+  const key = positionals[0];
+  if (!key) {
+    console.error("Error: `argent config unset` requires a <key>.");
+    process.exit(2);
+  }
+  if (positionals.length > 1) {
+    console.error(`Error: unexpected extra argument "${positionals[1]}".`);
+    process.exit(2);
+  }
+  const targetScope = scope ?? "global";
+  const warning = degenerateProjectScopeWarning(targetScope);
+  try {
+    const removed = unsetConfigValue(key, targetScope);
+    if (removed && warning) console.error(import_picocolors2.default.yellow(warning));
+    console.log(
+      removed ? `Unset ${import_picocolors2.default.bold(key)} (${scopeLabel(targetScope)}).` : import_picocolors2.default.dim(`${key} was not set at ${targetScope} scope.`)
+    );
+  } catch (err) {
+    reportError(err);
+  }
+}
+function parseArgs2(argv) {
+  const positionals = [];
+  let scope = null;
+  let json = false;
+  for (let i2 = 0; i2 < argv.length; i2++) {
+    const tok = argv[i2];
+    if (tok === "--json") {
+      json = true;
+      continue;
+    }
+    if (tok === "--scope") {
+      scope = parseScope2(argv[++i2]);
+      continue;
+    }
+    if (tok.startsWith("--scope=")) {
+      scope = parseScope2(tok.slice("--scope=".length));
+      continue;
+    }
+    if (tok.startsWith("--")) {
+      console.error(`Error: unknown flag "${tok}".`);
+      process.exit(2);
+    }
+    positionals.push(tok);
+  }
+  return { positionals, scope, json };
+}
+function parseScope2(raw) {
+  if (raw === "global" || raw === "project") return raw;
+  console.error(`Error: --scope must be "global" or "project"${raw ? `, got "${raw}"` : ""}.`);
+  process.exit(2);
+}
+function wantsHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h");
+}
+function scopeLabel(scope) {
+  if (scope === "global") return "global";
+  return `project: ${path14.dirname(configDir("project"))}`;
+}
+function degenerateProjectScopeWarning(scope) {
+  if (scope !== "project") return null;
+  const projDir = configDir("project");
+  if (path14.resolve(projDir) === path14.resolve(configDir("global"))) {
+    return `WARNING: no project found between ${process.cwd()} and your home directory \u2014 "project" scope resolved to the home directory, so this writes the GLOBAL config file (${path14.join(projDir, "config.json")}).`;
+  }
+  if (findProjectRoot(process.cwd()) === null) {
+    return `WARNING: no project markers (.argent, .git, package.json) found above ${process.cwd()} \u2014 treating it as the project root and creating ${path14.join(projDir, "config.json")}.`;
+  }
+  return null;
+}
+function formatValuePlain(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function formatValue(value) {
+  if (value === void 0) return import_picocolors2.default.dim("(unset)");
+  if (typeof value === "boolean" && process.stdout.isTTY) {
+    return value ? import_picocolors2.default.green("true") : import_picocolors2.default.red("false");
+  }
+  return formatValuePlain(value);
+}
+function reportError(err) {
+  if (err instanceof ConfigManagedElsewhereError) {
+    console.error(`Error: ${err.message} Use \`${err.command}\` instead.`);
+  } else if (err instanceof UnknownConfigKeyError || err instanceof ConfigScopeError || err instanceof ConfigValidationError) {
+    console.error(`Error: ${err.message}`);
+    if (err instanceof UnknownConfigKeyError) {
+      console.error(`Run \`argent config list\` to see available keys.`);
+    }
+  } else {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  process.exit(2);
+}
+function printUsage() {
+  const keys = CONFIG_SCHEMA.map((d) => d.key);
+  const maxKey = keys.reduce((m, k) => Math.max(m, k.length), 0);
+  const keyLines = CONFIG_SCHEMA.map((d) => {
+    const managed = d.manageCommand ? import_picocolors2.default.dim(` [managed by \`${d.manageCommand}\`]`) : "";
+    return `  ${d.key.padEnd(maxKey)}  ${d.description}${managed}`;
+  });
+  console.log(`Usage: argent config <command> [options]
+
+Manage argent configuration. Values are stored at two scopes and merged per the
+configuration's policy:
+  ~/.argent/config.json                 (global, default)
+  <project-root>/.argent/config.json    (project, with --scope project)
+
+Commands:
+  list                 Show all configurations and their values
+  get <key>            Print a value (effective, or --scope <scope>)
+  set <key> <value>    Set a value (--scope global|project, default global)
+  unset <key>          Remove a value at a scope (default global)
+
+Recognized keys:
+${keyLines.join("\n")}
+
+Run \`argent config <command> --help\` for command-specific help.`);
+}
+
 // ../../node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
 import { stdout, stdin } from "node:process";
@@ -11071,7 +11572,7 @@ import { styleText as styleText2, stripVTControlCharacters } from "node:util";
 import process$1 from "node:process";
 var import_sisteransi2 = __toESM(require_src(), 1);
 import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname8, join as join16 } from "node:path";
+import { dirname as dirname9, join as join17 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -11508,7 +12009,7 @@ ${r2}
 }).prompt();
 
 // ../argent-cli/src/link.ts
-var import_picocolors2 = __toESM(require_picocolors(), 1);
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 var WILDCARD_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "::", "::0", ""]);
 function isLoopback2(host) {
   return host === "127.0.0.1" || host === "localhost" || host === "::1";
@@ -11766,7 +12267,7 @@ async function preflightHealth(url, token) {
 }
 function printRestartHint() {
   console.log(
-    import_picocolors2.default.dim("Restart your editor to apply the change to any running `argent mcp` session.")
+    import_picocolors3.default.dim("Restart your editor to apply the change to any running `argent mcp` session.")
   );
 }
 function printSecurityCaveat(host, token, url) {
@@ -11775,7 +12276,7 @@ function printSecurityCaveat(host, token, url) {
   if (tls) {
     if (!token) {
       process.stderr.write(
-        import_picocolors2.default.yellow(
+        import_picocolors3.default.yellow(
           `WARNING: ${host} is reached over HTTPS but with NO token \u2014 anyone who can reach the URL can drive the server. Pair with a token.
 `
         )
@@ -11785,7 +12286,7 @@ function printSecurityCaveat(host, token, url) {
   }
   if (token) {
     process.stderr.write(
-      import_picocolors2.default.dim(
+      import_picocolors3.default.dim(
         `Note: ${host} is reached over plain HTTP (bearer-token auth, no TLS). Keep this link to a trusted network or VPN, or front it with an https:// tunnel.
 `
       )
@@ -11793,7 +12294,7 @@ function printSecurityCaveat(host, token, url) {
     return;
   }
   process.stderr.write(
-    import_picocolors2.default.yellow(
+    import_picocolors3.default.yellow(
       `WARNING: linked target ${host} is non-loopback and has NO token \u2014 tool calls travel over plain HTTP with no auth. Treat this link as trusted-network-only, or pair with a token (start the server without --no-auth).
 `
     )
@@ -11826,9 +12327,9 @@ async function link(argv) {
   if (flags2.host !== null) {
     host = flags2.host;
   } else {
-    intro(import_picocolors2.default.bgCyan(import_picocolors2.default.black(" argent link ")));
+    intro(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" argent link ")));
     if (existing) {
-      log.info(`Current link: ${import_picocolors2.default.cyan(existing.url)} (${existing.createdAt})`);
+      log.info(`Current link: ${import_picocolors3.default.cyan(existing.url)} (${existing.createdAt})`);
     }
     host = await promptHost(existing);
   }
@@ -11844,12 +12345,12 @@ async function link(argv) {
   let url = flags2.url ?? formatUrl(host, port);
   if (!flags2.yes && existing) {
     if (existing.url === url) {
-      log.info(`Already linked to ${import_picocolors2.default.cyan(url)}.`);
+      log.info(`Already linked to ${import_picocolors3.default.cyan(url)}.`);
       outro("No changes.");
       return;
     }
     const overwrite = await confirm({
-      message: `Replace existing link ${import_picocolors2.default.dim(existing.url)} with ${import_picocolors2.default.cyan(url)}?`,
+      message: `Replace existing link ${import_picocolors3.default.dim(existing.url)} with ${import_picocolors3.default.cyan(url)}?`,
       initialValue: true
     });
     if (isCancel(overwrite) || !overwrite) {
@@ -11867,10 +12368,10 @@ async function link(argv) {
       }
       const result = await preflightHealth(url, token);
       if (result.ok) {
-        if (spinner2) spinner2.stop(import_picocolors2.default.green("Tool-server reachable."));
+        if (spinner2) spinner2.stop(import_picocolors3.default.green("Tool-server reachable."));
         break;
       }
-      if (spinner2) spinner2.stop(import_picocolors2.default.red("Verification failed."));
+      if (spinner2) spinner2.stop(import_picocolors3.default.red("Verification failed."));
       const detail = result.error ? ` (${result.error})` : "";
       if (flags2.yes) {
         console.error(
@@ -11910,15 +12411,15 @@ async function link(argv) {
   };
   await writeLinkConfig(cfg);
   if (existing && existing.url !== url) {
-    console.log(`${import_picocolors2.default.green("\u2713")} Link updated: ${import_picocolors2.default.dim(existing.url)} \u2192 ${import_picocolors2.default.cyan(url)}`);
+    console.log(`${import_picocolors3.default.green("\u2713")} Link updated: ${import_picocolors3.default.dim(existing.url)} \u2192 ${import_picocolors3.default.cyan(url)}`);
   } else {
-    console.log(`${import_picocolors2.default.green("\u2713")} Linked: ${import_picocolors2.default.cyan(url)}`);
+    console.log(`${import_picocolors3.default.green("\u2713")} Linked: ${import_picocolors3.default.cyan(url)}`);
   }
-  if (token) console.log(import_picocolors2.default.dim("  auth: token stored in ~/.argent/link.json (0600)"));
+  if (token) console.log(import_picocolors3.default.dim("  auth: token stored in ~/.argent/link.json (0600)"));
   printSecurityCaveat(host, token, url);
   if (process.env.ARGENT_TOOLS_URL) {
     console.log(
-      import_picocolors2.default.yellow(
+      import_picocolors3.default.yellow(
         `Note: ARGENT_TOOLS_URL=${process.env.ARGENT_TOOLS_URL} is set in your environment and takes precedence over the link.`
       )
     );
@@ -11949,7 +12450,7 @@ async function unlink3(argv) {
   }
   if (!flags2.yes) {
     const confirmed = await confirm({
-      message: `Remove link to ${import_picocolors2.default.cyan(existing.url)}?`,
+      message: `Remove link to ${import_picocolors3.default.cyan(existing.url)}?`,
       initialValue: true
     });
     if (isCancel(confirmed) || !confirmed) {
@@ -11958,10 +12459,10 @@ async function unlink3(argv) {
     }
   }
   await clearLinkConfig();
-  console.log(`${import_picocolors2.default.green("\u2713")} Unlinked from ${import_picocolors2.default.dim(existing.url)}.`);
+  console.log(`${import_picocolors3.default.green("\u2713")} Unlinked from ${import_picocolors3.default.dim(existing.url)}.`);
   if (process.env.ARGENT_TOOLS_URL) {
     console.log(
-      import_picocolors2.default.yellow(
+      import_picocolors3.default.yellow(
         `The env var ARGENT_TOOLS_URL is also set in your shell (=${process.env.ARGENT_TOOLS_URL}) and takes precedence \u2014 unset it manually if you want fully local behaviour.`
       )
     );
@@ -11970,13 +12471,13 @@ async function unlink3(argv) {
 }
 
 // ../argent-cli/src/telemetry.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors4 = __toESM(require_picocolors(), 1);
 async function telemetry(args) {
   const sub = args[0];
   init("cli");
   switch (sub) {
     case void 0:
-      printUsage();
+      printUsage2();
       await shutdown();
       return;
     case "status":
@@ -11991,7 +12492,7 @@ async function telemetry(args) {
       return;
     case "--help":
     case "-h":
-      printUsage();
+      printUsage2();
       await shutdown();
       return;
     default:
@@ -12000,7 +12501,7 @@ async function telemetry(args) {
       process.exit(1);
   }
 }
-function printUsage() {
+function printUsage2() {
   console.log(`Usage:
   argent telemetry status    Show telemetry state and device id
   argent telemetry enable    Enable telemetry
@@ -12018,25 +12519,26 @@ async function cmdEnable() {
   const wasEnabled = isEnabled();
   markEnabled();
   if (wasEnabled) {
-    console.log(import_picocolors3.default.dim("Telemetry was already enabled."));
+    console.log(import_picocolors4.default.dim("Telemetry was already enabled."));
   } else {
-    console.log(import_picocolors3.default.green("Telemetry enabled."));
+    console.log(import_picocolors4.default.green("Telemetry enabled."));
   }
   await shutdown();
 }
 async function cmdDisable() {
   const wasEnabled = isEnabled();
   if (!wasEnabled) {
-    console.log(import_picocolors3.default.dim("Telemetry was already disabled."));
+    console.log(import_picocolors4.default.dim("Telemetry was already disabled."));
     await shutdown();
     return;
   }
   await markDisabled();
-  console.log(import_picocolors3.default.red("Telemetry disabled."));
+  console.log(import_picocolors4.default.red("Telemetry disabled."));
   await shutdown();
 }
 export {
   FLAG_REGISTRY,
+  config,
   disable,
   enable,
   flags,