@iowarp/clio-coder 0.3.0 → 0.3.2

package/dist/chunk-4KLWL3UC.js

@@ -0,0 +1,18 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  durableAssistantTextFromEvent
+} from "./chunk-6EJV5X2W.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/dispatch-event-text.ts
+init_esm_shims();
+function assistantTextFromEvent(event) {
+  return durableAssistantTextFromEvent(event).trim();
+}
+
+export {
+  assistantTextFromEvent
+};
+//# sourceMappingURL=chunk-4KLWL3UC.js.map

package/dist/{chunk-5LDRNKX2.js → chunk-4VP4KH3K.js}

@@ -1,17 +1,37 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  safeResourceWrite
-} from "./chunk-VPAWTYLY.js";
+  withStateFileLock,
+  withStateFileLockSync
+} from "./chunk-IKCO5N3L.js";
+import {
+  resolveDynamicConfigValue
+} from "./chunk-SST6Z5JA.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  findEngineEnvKeys,
+  getEngineEnvApiKey
+} from "./chunk-YXLYO42X.js";
 import {
   clioConfigDir
-} from "./chunk-X3NE4WVW.js";
+} from "./chunk-BNAZZHFG.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
 
 // src/engine/oauth.ts
-import { findEnvKeys as piFindEnvKeys, getEnvApiKey as piGetEnvApiKey } from "@earendil-works/pi-ai/compat";
+init_esm_shims();
 import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
 import { githubCopilotProvider } from "@earendil-works/pi-ai/providers/github-copilot";
 import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
 
 // src/engine/alcf-oauth.ts
+init_esm_shims();
 var AUTH_CLIENT_ID = "58fdd3bc-e1c3-4ce5-80ea-8d6b87cfb944";
 var GATEWAY_CLIENT_ID = "681c10cc-f684-4540-bcd7-0b4df3bc26ef";
 var GATEWAY_SCOPE = `https://auth.globus.org/scopes/${GATEWAY_CLIENT_ID}/action_all`;
@@ -99,7 +119,8 @@ function grantToCredentials(grant, previousRefresh) {
     expires: Date.now() + expiresInSeconds * 1e3 - EXPIRY_SKEW_MS
   };
 }
-async function postForm(body) {
+async function postForm(body, signal) {
+  const requestSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(3e4)]) : AbortSignal.timeout(3e4);
   const response = await fetch(TOKEN_URL, {
     method: "POST",
     headers: {
@@ -107,7 +128,7 @@ async function postForm(body) {
       Accept: "application/json"
     },
     body: new URLSearchParams(body).toString(),
-    signal: AbortSignal.timeout(3e4)
+    signal: requestSignal
   });
   const text = await response.text();
   if (!response.ok) {
@@ -122,22 +143,28 @@ async function postForm(body) {
   if (!isRecord(parsed)) throw new Error("Globus token endpoint returned a non-object response.");
   return parsed;
 }
-async function exchangeCode(code, verifier) {
-  const payload = await postForm({
-    grant_type: "authorization_code",
-    client_id: AUTH_CLIENT_ID,
-    code,
-    code_verifier: verifier,
-    redirect_uri: REDIRECT_URI
-  });
+async function exchangeCode(code, verifier, signal) {
+  const payload = await postForm(
+    {
+      grant_type: "authorization_code",
+      client_id: AUTH_CLIENT_ID,
+      code,
+      code_verifier: verifier,
+      redirect_uri: REDIRECT_URI
+    },
+    signal
+  );
   return grantToCredentials(selectGatewayGrant(payload));
 }
-async function refreshGatewayToken(refreshToken) {
-  const payload = await postForm({
-    grant_type: "refresh_token",
-    client_id: AUTH_CLIENT_ID,
-    refresh_token: refreshToken
-  });
+async function refreshGatewayToken(refreshToken, signal) {
+  const payload = await postForm(
+    {
+      grant_type: "refresh_token",
+      client_id: AUTH_CLIENT_ID,
+      refresh_token: refreshToken
+    },
+    signal
+  );
   return grantToCredentials(selectGatewayGrant(payload), refreshToken);
 }
 async function loginAlcf(callbacks) {
@@ -151,7 +178,7 @@ async function loginAlcf(callbacks) {
   const code = parseAuthorizationInput(pasted);
   if (!code) throw new Error("No authorization code was provided.");
   callbacks.onProgress?.("Exchanging authorization code for an ALCF access token...");
-  return exchangeCode(code, verifier);
+  return exchangeCode(code, verifier, callbacks.signal);
 }
 var alcfOAuthProvider = {
   id: "alcf",
@@ -160,8 +187,8 @@ var alcfOAuthProvider = {
   login(callbacks) {
     return loginAlcf(callbacks);
   },
-  refreshToken(credentials) {
-    return refreshGatewayToken(credentials.refresh);
+  refreshToken(credentials, signal) {
+    return refreshGatewayToken(credentials.refresh, signal);
   },
   async getApiKey(credentials) {
     return credentials.access;
@@ -171,6 +198,7 @@ var alcfOAuthProvider = {
 // src/engine/oauth.ts
 function interactionFromLoginCallbacks(callbacks) {
   const interaction = {
+    signal: callbacks.signal ?? new AbortController().signal,
     notify(event) {
       switch (event.type) {
         case "auth_url":
@@ -217,11 +245,10 @@ function interactionFromLoginCallbacks(callbacks) {
       }
     }
   };
-  if (callbacks.signal) interaction.signal = callbacks.signal;
   return interaction;
 }
 function fromOAuthAuth(id, auth, usesCallbackServer) {
-  if (!auth) throw new Error(`pi-ai provider "${id}" no longer exposes an OAuth flow`);
+  if (!auth) throw new Error(`provider "${id}" does not expose an OAuth flow`);
   return {
     id,
     name: auth.name,
@@ -229,8 +256,8 @@ function fromOAuthAuth(id, auth, usesCallbackServer) {
     async login(callbacks) {
       return auth.login(interactionFromLoginCallbacks(callbacks));
     },
-    async refreshToken(credentials) {
-      return auth.refresh({ ...credentials, type: "oauth" });
+    async refreshToken(credentials, signal) {
+      return auth.refresh({ ...credentials, type: "oauth" }, signal);
     },
     async getApiKey(credentials) {
       const resolved = await auth.toAuth({ ...credentials, type: "oauth" });
@@ -255,20 +282,6 @@ function registry() {
   }
   return providers;
 }
-function getEngineEnvApiKey(providerId) {
-  try {
-    return piGetEnvApiKey(providerId);
-  } catch {
-    return void 0;
-  }
-}
-function findEngineEnvKeys(providerId) {
-  try {
-    return piFindEnvKeys(providerId);
-  } catch {
-    return void 0;
-  }
-}
 function getEngineOAuthProvider(providerId) {
   return registry().get(providerId);
 }
@@ -289,10 +302,10 @@ async function loginWithEngineOAuthProvider(providerId, callbacks) {
   if (!provider) throw new Error(`unknown OAuth provider: ${providerId}`);
   return provider.login(callbacks);
 }
-async function refreshEngineOAuthCredentials(providerId, credentials) {
+async function refreshEngineOAuthCredentials(providerId, credentials, signal) {
   const provider = registry().get(providerId);
   if (!provider) throw new Error(`unknown OAuth provider: ${providerId}`);
-  return provider.refreshToken(credentials);
+  return provider.refreshToken(credentials, signal);
 }
 async function getEngineOAuthApiKey(providerId, credentials) {
   const provider = registry().get(providerId);
@@ -301,78 +314,11 @@ async function getEngineOAuthApiKey(providerId, credentials) {
 }
 
 // src/domains/providers/auth/storage.ts
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-
-// src/core/resolve-config-value.ts
-import { spawnSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join, resolve, sep } from "node:path";
-var commandResultCache = /* @__PURE__ */ new Map();
-function env(options) {
-  return options?.env ?? process.env;
-}
-function shellCommand(command) {
-  const isWindows = process.platform === "win32";
-  const shell = isWindows ? process.env.ComSpec || "cmd.exe" : process.env.SHELL || "/bin/sh";
-  const args = isWindows ? ["/d", "/s", "/c", command] : ["-lc", command];
-  const result = spawnSync(shell, args, {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-    timeout: 1e4,
-    windowsHide: true
-  });
-  if (result.error || result.status !== 0) return void 0;
-  const value = result.stdout.trim();
-  return value.length > 0 ? value : void 0;
-}
-function executeCommand(commandConfig) {
-  if (commandResultCache.has(commandConfig)) return commandResultCache.get(commandConfig);
-  const value = shellCommand(commandConfig.slice(1));
-  commandResultCache.set(commandConfig, value);
-  return value;
-}
-function warnStaticCommand(config, options) {
-  options?.onWarning?.({
-    code: "dynamic-command-in-static-resolution",
-    message: "bang-prefixed config command left literal by static config value resolver",
-    command: config.slice(1)
-  });
-}
-function expandConfigValue(value, options) {
-  const sourceEnv = env(options);
-  return value.replace(/\$(\w+)|\$\{([^}]+)\}/g, (match, bare, braced) => {
-    const key = bare ?? braced;
-    if (!key) return match;
-    return sourceEnv[key] ?? "";
-  });
-}
-function expandConfigPath(value, options) {
-  const cwd = options?.cwd ?? process.cwd();
-  const expandedEnv = expandConfigValue(value.trim(), options);
-  let expanded = expandedEnv;
-  if (expanded === "~") {
-    expanded = homedir();
-  } else if (expanded.startsWith(`~${sep}`) || expanded.startsWith("~/")) {
-    expanded = `${homedir()}${expanded.slice(1)}`;
-  } else if (expanded.startsWith("~")) {
-    expanded = join(homedir(), expanded.slice(1));
-  }
-  return resolve(cwd, expanded);
-}
-function resolveStaticConfigValue(config, options) {
-  if (config.startsWith("!")) warnStaticCommand(config, options);
-  const sourceEnv = env(options);
-  const envValue = sourceEnv[config];
-  if (envValue !== void 0 && envValue.length > 0) return envValue;
-  const expanded = expandConfigValue(config, options);
-  return expanded.length > 0 ? expanded : void 0;
-}
-function resolveDynamicConfigValue(config, options) {
-  if (config.startsWith("!")) return executeCommand(config);
-  return resolveStaticConfigValue(config, options);
-}
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
 
 // src/domains/providers/auth/api-key.ts
+init_esm_shims();
 function resolveStoredApiKey(key, providerId = "stored-api-key") {
   const trimmed = key.trim();
   if (trimmed.length === 0) return void 0;
@@ -407,6 +353,7 @@ function resolveEnvironmentApiKey(providerId, explicitEnvVar) {
 }
 
 // src/domains/providers/auth/oauth.ts
+init_esm_shims();
 function getOAuthProvider(providerId) {
   return getEngineOAuthProvider(providerId);
 }
@@ -416,8 +363,8 @@ function listOAuthProviders() {
 async function loginWithOAuthProvider(providerId, callbacks) {
   return loginWithEngineOAuthProvider(providerId, callbacks);
 }
-async function refreshOAuthCredentials(providerId, credentials) {
-  return refreshEngineOAuthCredentials(providerId, credentials);
+async function refreshOAuthCredentials(providerId, credentials, signal) {
+  return refreshEngineOAuthCredentials(providerId, credentials, signal);
 }
 function getOAuthApiKey(providerId, credentials) {
   return getEngineOAuthApiKey(providerId, credentials);
@@ -479,7 +426,7 @@ function readStorageData(content) {
   if (!content || content.trim().length === 0) return { data: emptyData(), damage: null };
   let parsed;
   try {
-    parsed = parseYaml(content);
+    parsed = (0, import_yaml.parse)(content);
   } catch (error) {
     const raw = error instanceof Error ? error.message : String(error);
     const detail = (raw.split("\n")[0] ?? raw).trim().replace(/:$/u, "");
@@ -530,7 +477,7 @@ function unreadDamage(unread) {
   return `these entries are stored in a shape this version cannot read: ${[...unread].sort().join(", ")}`;
 }
 function serializeStorageData(data) {
-  return stringifyYaml({
+  return (0, import_yaml.stringify)({
     version: 2,
     entries: data
   });
@@ -643,6 +590,22 @@ var AuthStorage = class {
     this.persist(providerId, void 0);
     delete this.data[providerId];
   }
+  renameProvider(fromProviderId, toProviderId, options = {}) {
+    this.backend.withLock((current) => {
+      const read = readStorageData(current);
+      const source = read.data[fromProviderId];
+      if (!source) {
+        if (read.damage === null) this.data = read.data;
+        return { result: void 0 };
+      }
+      if (read.damage !== null) throw new AuthStorageDamagedError(read.damage, this.backend.describe?.());
+      if (!read.data[toProviderId]) read.data[toProviderId] = source;
+      if (options.keepSource !== true) delete read.data[fromProviderId];
+      this.data = read.data;
+      this.damage = null;
+      return { result: void 0, next: serializeStorageData(read.data) };
+    });
+  }
   listStored() {
     return Object.entries(this.data).map(([providerId, credential]) => ({
       providerId,
@@ -703,14 +666,14 @@ var AuthStorage = class {
         detail: providerId
       };
     }
-    const env2 = resolveEnvironmentApiKey(providerId, opts?.explicitEnvVar);
-    if (env2.apiKey) {
+    const env = resolveEnvironmentApiKey(providerId, opts?.explicitEnvVar);
+    if (env.apiKey) {
       return {
         providerId,
         available: true,
         credentialType: "api_key",
         source: "environment",
-        detail: env2.source ?? providerId
+        detail: env.source ?? providerId
       };
     }
     if (opts?.includeFallback !== false) {
@@ -740,36 +703,42 @@ var AuthStorage = class {
     if (target.targetId) args.targetId = target.targetId;
     return this.status(target.providerId, args);
   }
-  async refreshOAuthCredentialWithLock(providerId) {
-    return this.backend.withLockAsync(async (current) => {
-      const read = readStorageData(current);
-      if (read.damage !== null) {
-        this.damage = read.damage;
-        throw new AuthStorageDamagedError(read.damage, this.backend.describe?.());
-      }
-      const currentData = read.data;
-      this.data = currentData;
-      this.damage = null;
-      const stored = currentData[providerId];
-      if (stored?.type !== "oauth") {
-        return { result: null };
-      }
-      if (Date.now() < stored.expires) {
-        return { result: { apiKey: await getOAuthApiKey(providerId, stored), credential: stored } };
-      }
-      const refreshed = await refreshOAuthCredentials(providerId, stored);
-      const next = {
-        type: "oauth",
-        ...refreshed,
-        updatedAt: nowIso()
-      };
-      const merged = { ...currentData, [providerId]: next };
-      this.data = merged;
-      return {
-        result: { apiKey: await getOAuthApiKey(providerId, next), credential: next },
-        next: serializeStorageData(merged)
-      };
-    });
+  async refreshOAuthCredentialWithLock(providerId, signal) {
+    let latestData;
+    const result = await this.backend.withLockAsync(
+      async (current) => {
+        const read = readStorageData(current);
+        if (read.damage !== null) {
+          this.damage = read.damage;
+          throw new AuthStorageDamagedError(read.damage, this.backend.describe?.());
+        }
+        const currentData = read.data;
+        latestData = currentData;
+        const stored = currentData[providerId];
+        if (stored?.type !== "oauth") {
+          return { result: null };
+        }
+        if (Date.now() < stored.expires) {
+          return { result: { apiKey: await getOAuthApiKey(providerId, stored), credential: stored } };
+        }
+        const refreshed = await refreshOAuthCredentials(providerId, stored, signal);
+        const next = {
+          type: "oauth",
+          ...refreshed,
+          updatedAt: nowIso()
+        };
+        const merged = { ...currentData, [providerId]: next };
+        latestData = merged;
+        return {
+          result: { apiKey: await getOAuthApiKey(providerId, next), credential: next },
+          next: serializeStorageData(merged)
+        };
+      },
+      { signal }
+    );
+    if (latestData) this.data = latestData;
+    this.damage = null;
+    return result;
   }
   async resolveApiKey(providerId, opts) {
     if (opts?.targetId) {
@@ -819,7 +788,10 @@ var AuthStorage = class {
         };
       }
       try {
-        const refreshed = await this.refreshOAuthCredentialWithLock(providerId);
+        const refreshed = await this.refreshOAuthCredentialWithLock(
+          providerId,
+          opts?.signal ?? new AbortController().signal
+        );
         if (refreshed) {
           return {
             providerId,
@@ -830,7 +802,8 @@ var AuthStorage = class {
             apiKey: refreshed.apiKey
           };
         }
-      } catch {
+      } catch (error) {
+        if (opts?.signal?.aborted) throw opts.signal.reason ?? error;
         this.reload();
         const updated = this.data[providerId];
         if (updated?.type === "oauth" && Date.now() < updated.expires) {
@@ -852,15 +825,15 @@ var AuthStorage = class {
         detail: providerId
       };
     }
-    const env2 = resolveEnvironmentApiKey(providerId, opts?.explicitEnvVar);
-    if (env2.apiKey) {
+    const env = resolveEnvironmentApiKey(providerId, opts?.explicitEnvVar);
+    if (env.apiKey) {
       return {
         providerId,
         available: true,
         credentialType: "api_key",
         source: "environment",
-        detail: env2.source ?? providerId,
-        apiKey: env2.apiKey
+        detail: env.source ?? providerId,
+        apiKey: env.apiKey
       };
     }
     if (opts?.includeFallback !== false) {
@@ -887,6 +860,7 @@ var AuthStorage = class {
   resolveForTarget(target, opts) {
     const args = {};
     if (opts?.includeFallback !== void 0) args.includeFallback = opts.includeFallback;
+    if (opts?.signal !== void 0) args.signal = opts.signal;
     if (target.explicitEnvVar) args.explicitEnvVar = target.explicitEnvVar;
     if (target.targetId) args.targetId = target.targetId;
     return this.resolveApiKey(target.providerId, args);
@@ -903,37 +877,20 @@ var AuthStorage = class {
   }
 };
 
+// src/domains/providers/auth/index.ts
+init_esm_shims();
+
 // src/domains/providers/auth/backend-file.ts
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync } from "node:fs";
-import { open, readFile, stat, unlink } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
-var DEFAULT_LOCK_RETRY_MS = 50;
-var DEFAULT_LOCK_STALE_MS = 3e4;
-var DEFAULT_LOCK_ATTEMPTS = 200;
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
+init_esm_shims();
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 function atomicWriteSecret(absPath, contents) {
   safeResourceWrite(absPath, contents, { encoding: "utf8", mode: 384 });
   chmodSync(absPath, 384);
 }
-function staleLock(path) {
-  try {
-    return Date.now() - statSync(path).mtimeMs > DEFAULT_LOCK_STALE_MS;
-  } catch {
-    return false;
-  }
-}
-async function staleLockAsync(path) {
-  try {
-    const info = await stat(path);
-    return Date.now() - info.mtimeMs > DEFAULT_LOCK_STALE_MS;
-  } catch {
-    return false;
-  }
-}
 function authStoragePath() {
-  return join2(clioConfigDir(), "credentials.yaml");
+  return join(clioConfigDir(), "credentials.yaml");
 }
 var FileAuthStorageBackend = class {
   constructor(path = authStoragePath()) {
@@ -943,9 +900,6 @@ var FileAuthStorageBackend = class {
   describe() {
     return this.path;
   }
-  get lockPath() {
-    return `${this.path}.lock`;
-  }
   ensureParentDir() {
     mkdirSync(dirname(this.path), { recursive: true, mode: 448 });
   }
@@ -955,109 +909,54 @@ var FileAuthStorageBackend = class {
     closeSync(fd);
     chmodSync(this.path, 384);
   }
-  releaseSync(fd) {
-    try {
-      closeSync(fd);
-    } finally {
-      try {
-        unlinkSync(this.lockPath);
-      } catch {
-      }
-    }
-  }
-  async releaseAsync(handle) {
-    try {
-      await handle.close();
-    } finally {
-      try {
-        await unlink(this.lockPath);
-      } catch {
-      }
-    }
-  }
-  acquireLockSync() {
-    for (let attempt = 0; attempt < DEFAULT_LOCK_ATTEMPTS; attempt += 1) {
-      try {
-        return openSync(this.lockPath, "wx", 384);
-      } catch (error) {
-        const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
-        if (code !== "EEXIST") throw error;
-        if (staleLock(this.lockPath)) {
-          try {
-            unlinkSync(this.lockPath);
-            continue;
-          } catch {
-          }
-        }
-        sleepSync(DEFAULT_LOCK_RETRY_MS);
-      }
-    }
-    throw new Error(`auth backend: failed to acquire lock for ${this.path}`);
-  }
-  async acquireLockAsync() {
-    for (let attempt = 0; attempt < DEFAULT_LOCK_ATTEMPTS; attempt += 1) {
-      try {
-        return await open(this.lockPath, "wx", 384);
-      } catch (error) {
-        const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
-        if (code !== "EEXIST") throw error;
-        if (await staleLockAsync(this.lockPath)) {
-          try {
-            await unlink(this.lockPath);
-            continue;
-          } catch {
-          }
-        }
-        await new Promise((resolve2) => setTimeout(resolve2, DEFAULT_LOCK_RETRY_MS));
-      }
-    }
-    throw new Error(`auth backend: failed to acquire lock for ${this.path}`);
-  }
   withLock(fn) {
     this.ensureParentDir();
     this.ensureFileExists();
-    const fd = this.acquireLockSync();
-    try {
+    return withStateFileLockSync(this.path, () => {
       const current = existsSync(this.path) ? readFileSync(this.path, "utf8") : void 0;
       const { result, next } = fn(current);
       if (next !== void 0) {
         atomicWriteSecret(this.path, next);
       }
       return result;
-    } finally {
-      this.releaseSync(fd);
-    }
+    });
   }
-  async withLockAsync(fn) {
+  async withLockAsync(fn, options) {
+    options?.signal?.throwIfAborted();
     this.ensureParentDir();
     this.ensureFileExists();
-    const handle = await this.acquireLockAsync();
-    try {
-      const current = existsSync(this.path) ? await readFile(this.path, "utf8") : void 0;
-      const { result, next } = await fn(current);
-      if (next !== void 0) {
-        atomicWriteSecret(this.path, next);
-      }
-      return result;
-    } finally {
-      await this.releaseAsync(handle);
-    }
+    return withStateFileLock(
+      this.path,
+      async () => {
+        options?.signal?.throwIfAborted();
+        const current = existsSync(this.path) ? await readFile(this.path, "utf8") : void 0;
+        const { result, next } = await fn(current);
+        options?.signal?.throwIfAborted();
+        if (next !== void 0) {
+          atomicWriteSecret(this.path, next);
+        }
+        return result;
+      },
+      options?.signal ? { signal: options.signal } : {}
+    );
   }
 };
 
+// src/domains/providers/auth/backend-memory.ts
+init_esm_shims();
+
 // src/domains/providers/auth/index.ts
 function openAuthStorage(path) {
   return new AuthStorage(new FileAuthStorageBackend(path));
 }
 
 export {
-  expandConfigPath,
-  registerClioOAuthProviders,
   authStoragePath,
+  registerClioOAuthProviders,
   resolveAuthTarget,
   resolveRuntimeAuthTarget,
   targetRequiresAuth,
   authNotRequiredStatus,
   openAuthStorage
 };
-//# sourceMappingURL=chunk-5LDRNKX2.js.map
+//# sourceMappingURL=chunk-4VP4KH3K.js.map