@sanity/cli 5.9.0-next.8 → 6.0.0-alpha.11

package/dist/actions/auth/authServer.js

@@ -0,0 +1,153 @@
+import { createServer } from 'node:http';
+import os from 'node:os';
+import { subdebug } from '@sanity/cli-core';
+const debug = subdebug('auth');
+const callbackPorts = [
+    4321,
+    4000,
+    3003,
+    1234,
+    8080,
+    13_333
+];
+const callbackEndpoint = '/callback';
+const platformNames = {
+    aix: 'AIX',
+    android: 'Android',
+    darwin: 'MacOS',
+    freebsd: 'FreeBSD',
+    linux: 'Linux',
+    openbsd: 'OpenBSD',
+    sunos: 'SunOS',
+    win32: 'Windows'
+};
+/**
+ * Start a local HTTP server and wait for a request to the auth callback endpoint.
+ * This happens by the user being sent to a login page with a callback URL that points to
+ * this local server. This request includes a short-lived "SID" (session ID) that we then
+ * do a request to the `/auth/fetch` endpoint with to get the actual auth token,
+ * invalidating the SID in the process.
+ *
+ * If we fail to bind to the first port, we retry with the next port in the list.
+ *
+ * @param options - Options for the server
+ * @returns Resolves with HTTP server instance, a login URL to send user to, and a `token` promise
+ * @internal
+ */ export function startServerForTokenCallback(options) {
+    const { client, providerUrl } = options;
+    const { apiHost } = client.config();
+    const domain = apiHost.includes('.sanity.work') ? 'www.sanity.work' : 'www.sanity.io';
+    const attemptPorts = [
+        ...callbackPorts
+    ];
+    let callbackPort = attemptPorts.shift();
+    // note: replace with `Promise.withResolvers()` when minimum Node.js is 22+
+    let resolveToken;
+    let rejectToken;
+    const tokenPromise = new Promise((resolve, reject)=>{
+        resolveToken = resolve;
+        rejectToken = reject;
+    });
+    return new Promise((resolve, reject)=>{
+        const server = createServer(async function onCallbackServerRequest(req, res) {
+            function failLoginRequest(code = '') {
+                res.writeHead(303, 'See Other', {
+                    Location: `https://${domain}/login/error${code ? `?error=${code}` : ''}`
+                });
+                res.end();
+                server.close();
+            }
+            const url = new URL(req.url || '/', `http://localhost:${callbackPort}`);
+            if (url.pathname !== callbackEndpoint) {
+                res.writeHead(404, 'Not Found', {
+                    'Content-Type': 'text/plain'
+                });
+                res.write('404 Not Found');
+                res.end();
+                return;
+            }
+            const absoluteTokenUrl = url.searchParams.get('url');
+            if (!absoluteTokenUrl) {
+                failLoginRequest();
+                return;
+            }
+            const tokenUrl = new URL(absoluteTokenUrl);
+            if (!tokenUrl.searchParams.has('sid')) {
+                failLoginRequest('NO_SESSION_ID');
+                return;
+            }
+            let token;
+            try {
+                token = await client.request({
+                    uri: `/auth/fetch${tokenUrl.search}`
+                });
+            } catch (err) {
+                failLoginRequest('UNRESOLVED_SESSION');
+                rejectToken(err instanceof Error ? err : new Error(`Unknown error: ${err}`));
+                return;
+            }
+            res.writeHead(303, 'See Other', {
+                Location: `https://${domain}/login/success`
+            });
+            res.end();
+            server.close();
+            resolveToken(token);
+        });
+        server.on('listening', function onCallbackListen() {
+            // Once the server is successfully listening on a port, we can return the promise.
+            // We'll then await the _token promise_, while the server is running in the background.
+            const loginUrl = getLoginUrl(server, providerUrl);
+            resolve({
+                loginUrl,
+                server,
+                token: tokenPromise
+            });
+        });
+        server.on('error', function onCallbackServerError(err) {
+            if ('code' in err && err.code === 'EADDRINUSE') {
+                callbackPort = attemptPorts.shift();
+                if (!callbackPort) {
+                    reject(new Error('Failed to find port number to bind auth callback server to'));
+                    return;
+                }
+                debug('Port busy, trying %d', callbackPort);
+                server.listen(callbackPort);
+            } else {
+                reject(err);
+            }
+        });
+        debug('Starting callback server on port %d', callbackPort);
+        server.listen(callbackPort);
+    });
+}
+/**
+ * Get the login URL to send the user to for the given local auth token server.
+ *
+ * The generated URL will include a label for the session that includes the
+ * hostname and platform of the current computer, to help identify the session.
+ *
+ * @param server - The local auth token server
+ * @param providerUrl - The URL of the login provider
+ * @returns The login URL
+ * @internal
+ */ function getLoginUrl(server, providerUrl) {
+    const serverUrl = server.address();
+    if (!serverUrl || typeof serverUrl === 'string') {
+        // Note: `serverUrl` is string only when binding to unix sockets,
+        // thus we can safely assume Something Is Wrong™ if it's a string
+        throw new Error('Failed to start auth callback server');
+    }
+    // Build a login URL that redirects back back to OAuth flow on success
+    const loginUrl = new URL(providerUrl);
+    // Prefer `MacOS` over `darwin` etc
+    const platformName = os.platform();
+    const platform = platformName in platformNames ? platformNames[platformName] : platformName;
+    // Prefer `espens-macbook` over `espens-macbook.local`
+    const hostname = os.hostname().replaceAll(/\.(local|lan)$/g, '');
+    loginUrl.searchParams.set('type', 'token');
+    loginUrl.searchParams.set('label', `${hostname} / ${platform}`);
+    loginUrl.searchParams.set('origin', `http://localhost:${serverUrl.port}${callbackEndpoint}`);
+    return loginUrl;
+}
+
+//# sourceMappingURL=authServer.js.map

package/dist/actions/auth/authServer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/auth/authServer.ts"],"sourcesContent":["import {createServer, type Server} from 'node:http'\nimport os from 'node:os'\n\nimport {subdebug} from '@sanity/cli-core'\nimport {type SanityClient} from '@sanity/client'\n\nconst debug = subdebug('auth')\nconst callbackPorts = [4321, 4000, 3003, 1234, 8080, 13_333]\nconst callbackEndpoint = '/callback'\n\nconst platformNames: Record<string, string | undefined> = {\n  aix: 'AIX',\n  android: 'Android',\n  darwin: 'MacOS',\n  freebsd: 'FreeBSD',\n  linux: 'Linux',\n  openbsd: 'OpenBSD',\n  sunos: 'SunOS',\n  win32: 'Windows',\n}\n\n/**\n * The response shape from /auth/fetch\n *\n * @internal\n */\ninterface TokenDetails {\n  label: string\n  token: string\n}\n\n/**\n * Start a local HTTP server and wait for a request to the auth callback endpoint.\n * This happens by the user being sent to a login page with a callback URL that points to\n * this local server. This request includes a short-lived \"SID\" (session ID) that we then\n * do a request to the `/auth/fetch` endpoint with to get the actual auth token,\n * invalidating the SID in the process.\n *\n * If we fail to bind to the first port, we retry with the next port in the list.\n *\n * @param options - Options for the server\n * @returns Resolves with HTTP server instance, a login URL to send user to, and a `token` promise\n * @internal\n */\nexport function startServerForTokenCallback(options: {\n  client: SanityClient\n  providerUrl: string\n}): Promise<{loginUrl: URL; server: Server; token: Promise<TokenDetails>}> {\n  const {client, providerUrl} = options\n  const {apiHost} = client.config()\n  const domain = apiHost.includes('.sanity.work') ? 'www.sanity.work' : 'www.sanity.io'\n\n  const attemptPorts = [...callbackPorts]\n  let callbackPort = attemptPorts.shift()\n\n  // note: replace with `Promise.withResolvers()` when minimum Node.js is 22+\n  let resolveToken: (resolvedToken: PromiseLike<TokenDetails> | TokenDetails) => void\n  let rejectToken: (reason: Error) => void\n  const tokenPromise = new Promise<TokenDetails>((resolve, reject) => {\n    resolveToken = resolve\n    rejectToken = reject\n  })\n\n  return new Promise((resolve, reject) => {\n    const server = createServer(async function onCallbackServerRequest(req, res) {\n      function failLoginRequest(code = '') {\n        res.writeHead(303, 'See Other', {\n          Location: `https://${domain}/login/error${code ? `?error=${code}` : ''}`,\n        })\n        res.end()\n        server.close()\n      }\n\n      const url = new URL(req.url || '/', `http://localhost:${callbackPort}`)\n      if (url.pathname !== callbackEndpoint) {\n        res.writeHead(404, 'Not Found', {'Content-Type': 'text/plain'})\n        res.write('404 Not Found')\n        res.end()\n        return\n      }\n\n      const absoluteTokenUrl = url.searchParams.get('url')\n      if (!absoluteTokenUrl) {\n        failLoginRequest()\n        return\n      }\n\n      const tokenUrl = new URL(absoluteTokenUrl)\n      if (!tokenUrl.searchParams.has('sid')) {\n        failLoginRequest('NO_SESSION_ID')\n        return\n      }\n\n      let token: TokenDetails\n      try {\n        token = await client.request({uri: `/auth/fetch${tokenUrl.search}`})\n      } catch (err) {\n        failLoginRequest('UNRESOLVED_SESSION')\n        rejectToken(err instanceof Error ? err : new Error(`Unknown error: ${err}`))\n        return\n      }\n\n      res.writeHead(303, 'See Other', {Location: `https://${domain}/login/success`})\n      res.end()\n      server.close()\n      resolveToken(token)\n    })\n\n    server.on('listening', function onCallbackListen() {\n      // Once the server is successfully listening on a port, we can return the promise.\n      // We'll then await the _token promise_, while the server is running in the background.\n      const loginUrl = getLoginUrl(server, providerUrl)\n      resolve({loginUrl, server, token: tokenPromise})\n    })\n\n    server.on('error', function onCallbackServerError(err) {\n      if ('code' in err && err.code === 'EADDRINUSE') {\n        callbackPort = attemptPorts.shift()\n        if (!callbackPort) {\n          reject(new Error('Failed to find port number to bind auth callback server to'))\n          return\n        }\n\n        debug('Port busy, trying %d', callbackPort)\n        server.listen(callbackPort)\n      } else {\n        reject(err)\n      }\n    })\n\n    debug('Starting callback server on port %d', callbackPort)\n    server.listen(callbackPort)\n  })\n}\n\n/**\n * Get the login URL to send the user to for the given local auth token server.\n *\n * The generated URL will include a label for the session that includes the\n * hostname and platform of the current computer, to help identify the session.\n *\n * @param server - The local auth token server\n * @param providerUrl - The URL of the login provider\n * @returns The login URL\n * @internal\n */\nfunction getLoginUrl(server: Server, providerUrl: string): URL {\n  const serverUrl = server.address()\n  if (!serverUrl || typeof serverUrl === 'string') {\n    // Note: `serverUrl` is string only when binding to unix sockets,\n    // thus we can safely assume Something Is Wrong™ if it's a string\n    throw new Error('Failed to start auth callback server')\n  }\n\n  // Build a login URL that redirects back back to OAuth flow on success\n  const loginUrl = new URL(providerUrl)\n\n  // Prefer `MacOS` over `darwin` etc\n  const platformName = os.platform()\n  const platform = platformName in platformNames ? platformNames[platformName] : platformName\n\n  // Prefer `espens-macbook` over `espens-macbook.local`\n  const hostname = os.hostname().replaceAll(/\\.(local|lan)$/g, '')\n\n  loginUrl.searchParams.set('type', 'token')\n  loginUrl.searchParams.set('label', `${hostname} / ${platform}`)\n  loginUrl.searchParams.set('origin', `http://localhost:${serverUrl.port}${callbackEndpoint}`)\n\n  return loginUrl\n}\n"],"names":["createServer","os","subdebug","debug","callbackPorts","callbackEndpoint","platformNames","aix","android","darwin","freebsd","linux","openbsd","sunos","win32","startServerForTokenCallback","options","client","providerUrl","apiHost","config","domain","includes","attemptPorts","callbackPort","shift","resolveToken","rejectToken","tokenPromise","Promise","resolve","reject","server","onCallbackServerRequest","req","res","failLoginRequest","code","writeHead","Location","end","close","url","URL","pathname","write","absoluteTokenUrl","searchParams","get","tokenUrl","has","token","request","uri","search","err","Error","on","onCallbackListen","loginUrl","getLoginUrl","onCallbackServerError","listen","serverUrl","address","platformName","platform","hostname","replaceAll","set","port"],"mappings":"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"}

package/dist/actions/auth/getProviderName.js

@@ -0,0 +1,15 @@
+/**
+ * Try to get a (prettier) name for a provider by ID.
+ *
+ * @param provider - The provider ID, e.g., 'google', 'github', 'sanity', or 'saml-<name>'.
+ * @returns The display name for the provider.
+ * @internal
+ */ export function getProviderName(provider) {
+    if (provider === 'google') return 'Google';
+    if (provider === 'github') return 'GitHub';
+    if (provider === 'sanity') return 'Email';
+    if (provider.startsWith('saml-')) return 'SAML';
+    return provider.charAt(0).toUpperCase() + provider.slice(1);
+}
+
+//# sourceMappingURL=getProviderName.js.map

package/dist/actions/auth/getProviderName.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/auth/getProviderName.ts"],"sourcesContent":["/**\n * Try to get a (prettier) name for a provider by ID.\n *\n * @param provider - The provider ID, e.g., 'google', 'github', 'sanity', or 'saml-<name>'.\n * @returns The display name for the provider.\n * @internal\n */\nexport function getProviderName(provider: string): string {\n  if (provider === 'google') return 'Google'\n  if (provider === 'github') return 'GitHub'\n  if (provider === 'sanity') return 'Email'\n  if (provider.startsWith('saml-')) return 'SAML'\n  return provider.charAt(0).toUpperCase() + provider.slice(1)\n}\n"],"names":["getProviderName","provider","startsWith","charAt","toUpperCase","slice"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,gBAAgBC,QAAgB;IAC9C,IAAIA,aAAa,UAAU,OAAO;IAClC,IAAIA,aAAa,UAAU,OAAO;IAClC,IAAIA,aAAa,UAAU,OAAO;IAClC,IAAIA,SAASC,UAAU,CAAC,UAAU,OAAO;IACzC,OAAOD,SAASE,MAAM,CAAC,GAAGC,WAAW,KAAKH,SAASI,KAAK,CAAC;AAC3D"}

package/dist/actions/auth/login/getProvider.js

@@ -0,0 +1,54 @@
+import { input, spinner } from '@sanity/cli-core/ux';
+import { getSSOProvider } from './getSSOProvider.js';
+import { promptProviders } from './promptProviders.js';
+/**
+ * Prompt the user to select a login provider, or use the specified provider if given.
+ *
+ * @param options - Options for the provider resolve operation
+ * @returns Promise that resolves to the selected login provider
+ * @internal
+ */ export async function getProvider({ client, experimental, orgSlug, specifiedProvider }) {
+    if (orgSlug) {
+        return getSSOProvider({
+            client,
+            orgSlug
+        });
+    }
+    // Fetch and prompt for login provider to use
+    const spin = spinner('Fetching providers...').start();
+    let { providers } = await client.request({
+        uri: '/auth/providers'
+    });
+    if (experimental) {
+        providers = [
+            ...providers,
+            {
+                name: 'sso',
+                title: 'SSO',
+                url: '_not_used_'
+            }
+        ];
+    }
+    spin.stop();
+    const providerNames = providers.map((prov)=>prov.name);
+    if (specifiedProvider && providerNames.includes(specifiedProvider)) {
+        const provider = providers.find((prov)=>prov.name === specifiedProvider);
+        if (!provider) {
+            throw new Error(`Cannot find login provider with name "${specifiedProvider}"`);
+        }
+        return provider;
+    }
+    const provider = await promptProviders(providers);
+    if (provider.name === 'sso') {
+        const orgSlug = await input({
+            message: 'Organization slug:'
+        });
+        return getSSOProvider({
+            client,
+            orgSlug
+        });
+    }
+    return provider;
+}
+
+//# sourceMappingURL=getProvider.js.map

package/dist/actions/auth/login/getProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/auth/login/getProvider.ts"],"sourcesContent":["import {input, spinner} from '@sanity/cli-core/ux'\nimport {type SanityClient} from '@sanity/client'\n\nimport {type LoginProvider, type ProvidersResponse} from '../types.js'\nimport {getSSOProvider} from './getSSOProvider.js'\nimport {promptProviders} from './promptProviders.js'\n\n/**\n * Prompt the user to select a login provider, or use the specified provider if given.\n *\n * @param options - Options for the provider resolve operation\n * @returns Promise that resolves to the selected login provider\n * @internal\n */\nexport async function getProvider({\n  client,\n  experimental,\n  orgSlug,\n  specifiedProvider,\n}: {\n  client: SanityClient\n  experimental: boolean | undefined\n  orgSlug: string | undefined\n  specifiedProvider: string | undefined\n}): Promise<LoginProvider | undefined> {\n  if (orgSlug) {\n    return getSSOProvider({client, orgSlug})\n  }\n\n  // Fetch and prompt for login provider to use\n  const spin = spinner('Fetching providers...').start()\n  let {providers} = await client.request<ProvidersResponse>({uri: '/auth/providers'})\n  if (experimental) {\n    providers = [...providers, {name: 'sso', title: 'SSO', url: '_not_used_'}]\n  }\n  spin.stop()\n\n  const providerNames = providers.map((prov) => prov.name)\n\n  if (specifiedProvider && providerNames.includes(specifiedProvider)) {\n    const provider = providers.find((prov) => prov.name === specifiedProvider)\n\n    if (!provider) {\n      throw new Error(`Cannot find login provider with name \"${specifiedProvider}\"`)\n    }\n\n    return provider\n  }\n\n  const provider = await promptProviders(providers)\n  if (provider.name === 'sso') {\n    const orgSlug = await input({message: 'Organization slug:'})\n    return getSSOProvider({client, orgSlug})\n  }\n\n  return provider\n}\n"],"names":["input","spinner","getSSOProvider","promptProviders","getProvider","client","experimental","orgSlug","specifiedProvider","spin","start","providers","request","uri","name","title","url","stop","providerNames","map","prov","includes","provider","find","Error","message"],"mappings":"AAAA,SAAQA,KAAK,EAAEC,OAAO,QAAO,sBAAqB;AAIlD,SAAQC,cAAc,QAAO,sBAAqB;AAClD,SAAQC,eAAe,QAAO,uBAAsB;AAEpD;;;;;;CAMC,GACD,OAAO,eAAeC,YAAY,EAChCC,MAAM,EACNC,YAAY,EACZC,OAAO,EACPC,iBAAiB,EAMlB;IACC,IAAID,SAAS;QACX,OAAOL,eAAe;YAACG;YAAQE;QAAO;IACxC;IAEA,6CAA6C;IAC7C,MAAME,OAAOR,QAAQ,yBAAyBS,KAAK;IACnD,IAAI,EAACC,SAAS,EAAC,GAAG,MAAMN,OAAOO,OAAO,CAAoB;QAACC,KAAK;IAAiB;IACjF,IAAIP,cAAc;QAChBK,YAAY;eAAIA;YAAW;gBAACG,MAAM;gBAAOC,OAAO;gBAAOC,KAAK;YAAY;SAAE;IAC5E;IACAP,KAAKQ,IAAI;IAET,MAAMC,gBAAgBP,UAAUQ,GAAG,CAAC,CAACC,OAASA,KAAKN,IAAI;IAEvD,IAAIN,qBAAqBU,cAAcG,QAAQ,CAACb,oBAAoB;QAClE,MAAMc,WAAWX,UAAUY,IAAI,CAAC,CAACH,OAASA,KAAKN,IAAI,KAAKN;QAExD,IAAI,CAACc,UAAU;YACb,MAAM,IAAIE,MAAM,CAAC,sCAAsC,EAAEhB,kBAAkB,CAAC,CAAC;QAC/E;QAEA,OAAOc;IACT;IAEA,MAAMA,WAAW,MAAMnB,gBAAgBQ;IACvC,IAAIW,SAASR,IAAI,KAAK,OAAO;QAC3B,MAAMP,UAAU,MAAMP,MAAM;YAACyB,SAAS;QAAoB;QAC1D,OAAOvB,eAAe;YAACG;YAAQE;QAAO;IACxC;IAEA,OAAOe;AACT"}

package/dist/actions/auth/login/getSSOProvider.js

@@ -0,0 +1,30 @@
+import { select } from '@sanity/cli-core/ux';
+import { samlProviderToLoginProvider } from './samlProviderToLoginProvider.js';
+/**
+ * Get the SSO provider for the given slug
+ *
+ * @param options - Options for the provider resolve operation
+ * @returns Promise that resolves to the SSO provider
+ * @internal
+ */ export async function getSSOProvider({ client, orgSlug }) {
+    const providers = await client.request({
+        uri: `/auth/organizations/by-slug/${orgSlug}/providers`
+    });
+    const enabledProviders = providers.filter((candidate)=>!candidate.disabled);
+    if (enabledProviders.length === 0) {
+        return undefined;
+    }
+    if (enabledProviders.length === 1) {
+        return samlProviderToLoginProvider(enabledProviders[0]);
+    }
+    const selectedProvider = await select({
+        choices: enabledProviders.map((provider)=>({
+                name: provider.name,
+                value: provider
+            })),
+        message: 'Select SSO provider'
+    });
+    return selectedProvider ? samlProviderToLoginProvider(selectedProvider) : undefined;
+}
+
+//# sourceMappingURL=getSSOProvider.js.map

package/dist/actions/auth/login/getSSOProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/auth/login/getSSOProvider.ts"],"sourcesContent":["import {select} from '@sanity/cli-core/ux'\nimport {type SanityClient} from '@sanity/client'\n\nimport {type LoginProvider, type SamlLoginProvider} from '../types.js'\nimport {samlProviderToLoginProvider} from './samlProviderToLoginProvider.js'\n\n/**\n * Get the SSO provider for the given slug\n *\n * @param options - Options for the provider resolve operation\n * @returns Promise that resolves to the SSO provider\n * @internal\n */\nexport async function getSSOProvider({\n  client,\n  orgSlug,\n}: {\n  client: SanityClient\n  orgSlug: string\n}): Promise<LoginProvider | undefined> {\n  const providers = await client.request<SamlLoginProvider[]>({\n    uri: `/auth/organizations/by-slug/${orgSlug}/providers`,\n  })\n\n  const enabledProviders = providers.filter((candidate) => !candidate.disabled)\n  if (enabledProviders.length === 0) {\n    return undefined\n  }\n\n  if (enabledProviders.length === 1) {\n    return samlProviderToLoginProvider(enabledProviders[0])\n  }\n\n  const selectedProvider = await select({\n    choices: enabledProviders.map((provider) => ({name: provider.name, value: provider})),\n    message: 'Select SSO provider',\n  })\n\n  return selectedProvider ? samlProviderToLoginProvider(selectedProvider) : undefined\n}\n"],"names":["select","samlProviderToLoginProvider","getSSOProvider","client","orgSlug","providers","request","uri","enabledProviders","filter","candidate","disabled","length","undefined","selectedProvider","choices","map","provider","name","value","message"],"mappings":"AAAA,SAAQA,MAAM,QAAO,sBAAqB;AAI1C,SAAQC,2BAA2B,QAAO,mCAAkC;AAE5E;;;;;;CAMC,GACD,OAAO,eAAeC,eAAe,EACnCC,MAAM,EACNC,OAAO,EAIR;IACC,MAAMC,YAAY,MAAMF,OAAOG,OAAO,CAAsB;QAC1DC,KAAK,CAAC,4BAA4B,EAAEH,QAAQ,UAAU,CAAC;IACzD;IAEA,MAAMI,mBAAmBH,UAAUI,MAAM,CAAC,CAACC,YAAc,CAACA,UAAUC,QAAQ;IAC5E,IAAIH,iBAAiBI,MAAM,KAAK,GAAG;QACjC,OAAOC;IACT;IAEA,IAAIL,iBAAiBI,MAAM,KAAK,GAAG;QACjC,OAAOX,4BAA4BO,gBAAgB,CAAC,EAAE;IACxD;IAEA,MAAMM,mBAAmB,MAAMd,OAAO;QACpCe,SAASP,iBAAiBQ,GAAG,CAAC,CAACC,WAAc,CAAA;gBAACC,MAAMD,SAASC,IAAI;gBAAEC,OAAOF;YAAQ,CAAA;QAClFG,SAAS;IACX;IAEA,OAAON,mBAAmBb,4BAA4Ba,oBAAoBD;AAC5E"}

package/dist/actions/auth/login/login.js

@@ -0,0 +1,101 @@
+import { getCliToken, getGlobalCliClient, setConfig } from '@sanity/cli-core';
+import { spinner } from '@sanity/cli-core/ux';
+import open from 'open';
+import { LoginTrace } from '../../../telemetry/login.telemetry.js';
+import { canLaunchBrowser } from '../../../util/canLaunchBrowser.js';
+import { startServerForTokenCallback } from '../authServer.js';
+import { getProvider } from './getProvider.js';
+const LOGIN_API_VERSION = '2024-02-01';
+/**
+ * Trigger the authentication flow for the CLI.
+ *
+ * NOTE: This uses terminal prompts and will not work for non-interactive/programmatic uses.
+ *
+ * @param options - Options for the login operation
+ * @returns Promise that resolves when the login operation is complete
+ * @throws Will throw if login fails or is cancelled
+ * @internal
+ */ export async function login(options) {
+    const { output, telemetry } = options;
+    const previousToken = await getCliToken();
+    const hasExistingToken = Boolean(previousToken);
+    const trace = telemetry.trace(LoginTrace);
+    trace.start();
+    // We explicitly want to use an unauthenticated client here, even if we already logged in
+    const globalClient = await getGlobalCliClient({
+        apiVersion: LOGIN_API_VERSION
+    });
+    const client = globalClient.withConfig({
+        token: undefined
+    });
+    const provider = await getProvider({
+        client,
+        experimental: options.experimental,
+        orgSlug: options.sso,
+        specifiedProvider: options.provider
+    });
+    trace.log({
+        provider: provider?.name,
+        step: 'selectProvider'
+    });
+    if (provider === undefined) {
+        throw new Error('No authentication providers found');
+    }
+    const { loginUrl, server, token: tokenPromise } = await startServerForTokenCallback({
+        client,
+        providerUrl: provider.url
+    });
+    trace.log({
+        step: 'waitForToken'
+    });
+    const serverUrl = server.address();
+    if (!serverUrl || typeof serverUrl === 'string') {
+        // Note: `serverUrl` is string only when binding to unix sockets,
+        // thus we can safely assume Something Is Wrong™ if it's a string
+        throw new Error('Failed to start auth callback server');
+    }
+    // Open a browser on the login page (or tell the user to)
+    const shouldLaunchBrowser = canLaunchBrowser() && options.open !== false;
+    const actionText = shouldLaunchBrowser ? 'Opening browser at' : 'Please open a browser at';
+    output.log(`\n${actionText} ${loginUrl.href}\n`);
+    const spin = spinner('Waiting for browser login to complete... Press Ctrl + C to cancel').start();
+    if (shouldLaunchBrowser) {
+        open(loginUrl.href);
+    }
+    // Wait for a success/error on the HTTP callback server
+    let authToken;
+    try {
+        authToken = (await tokenPromise).token;
+        spin.stop();
+    } catch (err) {
+        spin.stop();
+        trace.error(err);
+        throw err instanceof Error ? new Error(`Login failed: ${err.message}`, {
+            cause: err
+        }) : new Error(`${err}`);
+    } finally{
+        server.close();
+        server.unref();
+    }
+    // Store the token
+    await setConfig('authToken', authToken);
+    // Clear cached telemetry consent
+    await setConfig('telemetryConsent', undefined);
+    // If we had a session previously, attempt to clear it
+    if (hasExistingToken) {
+        await globalClient.withConfig({
+            token: previousToken
+        }).request({
+            method: 'POST',
+            uri: '/auth/logout'
+        }).catch((err)=>{
+            const statusCode = err && err.response && err.response.statusCode;
+            if (statusCode !== 401) {
+                output.warn('Failed to invalidate previous session');
+            }
+        });
+    }
+    trace.complete();
+}
+
+//# sourceMappingURL=login.js.map

package/dist/actions/auth/login/login.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/auth/login/login.ts"],"sourcesContent":["import {\n  type CLITelemetryStore,\n  getCliToken,\n  getGlobalCliClient,\n  type Output,\n  setConfig,\n} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\nimport open from 'open'\n\nimport {LoginTrace} from '../../../telemetry/login.telemetry.js'\nimport {canLaunchBrowser} from '../../../util/canLaunchBrowser.js'\nimport {startServerForTokenCallback} from '../authServer.js'\nimport {getProvider} from './getProvider.js'\n\nconst LOGIN_API_VERSION = '2024-02-01'\n\ninterface LoginOptions {\n  output: Output\n\n  telemetry: CLITelemetryStore\n\n  experimental?: boolean\n  open?: boolean\n  provider?: string\n  sso?: string\n}\n\n/**\n * Trigger the authentication flow for the CLI.\n *\n * NOTE: This uses terminal prompts and will not work for non-interactive/programmatic uses.\n *\n * @param options - Options for the login operation\n * @returns Promise that resolves when the login operation is complete\n * @throws Will throw if login fails or is cancelled\n * @internal\n */\nexport async function login(options: LoginOptions) {\n  const {output, telemetry} = options\n  const previousToken = await getCliToken()\n  const hasExistingToken = Boolean(previousToken)\n\n  const trace = telemetry.trace(LoginTrace)\n  trace.start()\n\n  // We explicitly want to use an unauthenticated client here, even if we already logged in\n  const globalClient = await getGlobalCliClient({apiVersion: LOGIN_API_VERSION})\n  const client = globalClient.withConfig({token: undefined})\n\n  const provider = await getProvider({\n    client,\n    experimental: options.experimental,\n    orgSlug: options.sso,\n    specifiedProvider: options.provider,\n  })\n\n  trace.log({provider: provider?.name, step: 'selectProvider'})\n\n  if (provider === undefined) {\n    throw new Error('No authentication providers found')\n  }\n\n  const {\n    loginUrl,\n    server,\n    token: tokenPromise,\n  } = await startServerForTokenCallback({client, providerUrl: provider.url})\n\n  trace.log({step: 'waitForToken'})\n\n  const serverUrl = server.address()\n  if (!serverUrl || typeof serverUrl === 'string') {\n    // Note: `serverUrl` is string only when binding to unix sockets,\n    // thus we can safely assume Something Is Wrong™ if it's a string\n    throw new Error('Failed to start auth callback server')\n  }\n\n  // Open a browser on the login page (or tell the user to)\n  const shouldLaunchBrowser = canLaunchBrowser() && options.open !== false\n  const actionText = shouldLaunchBrowser ? 'Opening browser at' : 'Please open a browser at'\n\n  output.log(`\\n${actionText} ${loginUrl.href}\\n`)\n\n  const spin = spinner('Waiting for browser login to complete... Press Ctrl + C to cancel').start()\n\n  if (shouldLaunchBrowser) {\n    open(loginUrl.href)\n  }\n\n  // Wait for a success/error on the HTTP callback server\n  let authToken: string\n  try {\n    authToken = (await tokenPromise).token\n    spin.stop()\n  } catch (err: unknown) {\n    spin.stop()\n    trace.error(err as Error)\n    throw err instanceof Error\n      ? new Error(`Login failed: ${err.message}`, {cause: err})\n      : new Error(`${err}`)\n  } finally {\n    server.close()\n    server.unref()\n  }\n\n  // Store the token\n  await setConfig('authToken', authToken)\n\n  // Clear cached telemetry consent\n  await setConfig('telemetryConsent', undefined)\n\n  // If we had a session previously, attempt to clear it\n  if (hasExistingToken) {\n    await globalClient\n      .withConfig({token: previousToken})\n      .request({method: 'POST', uri: '/auth/logout'})\n      .catch((err) => {\n        const statusCode = err && err.response && err.response.statusCode\n        if (statusCode !== 401) {\n          output.warn('Failed to invalidate previous session')\n        }\n      })\n  }\n\n  trace.complete()\n}\n"],"names":["getCliToken","getGlobalCliClient","setConfig","spinner","open","LoginTrace","canLaunchBrowser","startServerForTokenCallback","getProvider","LOGIN_API_VERSION","login","options","output","telemetry","previousToken","hasExistingToken","Boolean","trace","start","globalClient","apiVersion","client","withConfig","token","undefined","provider","experimental","orgSlug","sso","specifiedProvider","log","name","step","Error","loginUrl","server","tokenPromise","providerUrl","url","serverUrl","address","shouldLaunchBrowser","actionText","href","spin","authToken","stop","err","error","message","cause","close","unref","request","method","uri","catch","statusCode","response","warn","complete"],"mappings":"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"}

package/dist/actions/auth/login/promptProviders.js

@@ -0,0 +1,23 @@
+import { select } from '@sanity/cli-core/ux';
+/**
+ * Prompts the user to select a provider from the given list of providers,
+ * or if only one provider is available, returns that provider.
+ *
+ * @param providers - The list of login providers
+ * @returns The selected login provider
+ * @internal
+ */ export async function promptProviders(providers) {
+    if (providers.length === 1) {
+        return providers[0];
+    }
+    const provider = await select({
+        choices: providers.map((choice)=>({
+                name: choice.title,
+                value: choice
+            })),
+        message: 'Please log in or create a new account'
+    });
+    return provider || providers[0];
+}
+
+//# sourceMappingURL=promptProviders.js.map

package/dist/actions/auth/login/promptProviders.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/auth/login/promptProviders.ts"],"sourcesContent":["import {select} from '@sanity/cli-core/ux'\n\nimport {type LoginProvider} from '../types.js'\n\n/**\n * Prompts the user to select a provider from the given list of providers,\n * or if only one provider is available, returns that provider.\n *\n * @param providers - The list of login providers\n * @returns The selected login provider\n * @internal\n */\nexport async function promptProviders(providers: LoginProvider[]): Promise<LoginProvider> {\n  if (providers.length === 1) {\n    return providers[0]\n  }\n\n  const provider = await select({\n    choices: providers.map((choice) => ({name: choice.title, value: choice})),\n    message: 'Please log in or create a new account',\n  })\n\n  return provider || providers[0]\n}\n"],"names":["select","promptProviders","providers","length","provider","choices","map","choice","name","title","value","message"],"mappings":"AAAA,SAAQA,MAAM,QAAO,sBAAqB;AAI1C;;;;;;;CAOC,GACD,OAAO,eAAeC,gBAAgBC,SAA0B;IAC9D,IAAIA,UAAUC,MAAM,KAAK,GAAG;QAC1B,OAAOD,SAAS,CAAC,EAAE;IACrB;IAEA,MAAME,WAAW,MAAMJ,OAAO;QAC5BK,SAASH,UAAUI,GAAG,CAAC,CAACC,SAAY,CAAA;gBAACC,MAAMD,OAAOE,KAAK;gBAAEC,OAAOH;YAAM,CAAA;QACtEI,SAAS;IACX;IAEA,OAAOP,YAAYF,SAAS,CAAC,EAAE;AACjC"}

package/dist/actions/auth/login/samlProviderToLoginProvider.js

@@ -0,0 +1,15 @@
+/**
+ * Converts a SAML login provider shape to a login provider shape
+ *
+ * @param saml - The SAML login provider
+ * @returns The login provider
+ * @internal
+ */ export function samlProviderToLoginProvider(saml) {
+    return {
+        name: saml.name,
+        title: saml.name,
+        url: saml.loginUrl
+    };
+}
+
+//# sourceMappingURL=samlProviderToLoginProvider.js.map

package/dist/actions/auth/login/samlProviderToLoginProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/auth/login/samlProviderToLoginProvider.ts"],"sourcesContent":["import {type LoginProvider, type SamlLoginProvider} from '../types.js'\n\n/**\n * Converts a SAML login provider shape to a login provider shape\n *\n * @param saml - The SAML login provider\n * @returns The login provider\n * @internal\n */\nexport function samlProviderToLoginProvider(saml: SamlLoginProvider): LoginProvider {\n  return {\n    name: saml.name,\n    title: saml.name,\n    url: saml.loginUrl,\n  }\n}\n"],"names":["samlProviderToLoginProvider","saml","name","title","url","loginUrl"],"mappings":"AAEA;;;;;;CAMC,GACD,OAAO,SAASA,4BAA4BC,IAAuB;IACjE,OAAO;QACLC,MAAMD,KAAKC,IAAI;QACfC,OAAOF,KAAKC,IAAI;QAChBE,KAAKH,KAAKI,QAAQ;IACpB;AACF"}

package/dist/actions/auth/types.js

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */ /**
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/actions/auth/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/auth/types.ts"],"sourcesContent":["/**\n * @internal\n */\nexport interface LoginProvider {\n  name: string\n  title: string\n  url: string\n}\n\n/**\n * @internal\n */\nexport interface SamlLoginProvider {\n  callbackUrl: string\n  disabled: boolean\n  id: string\n  loginUrl: string\n  name: string\n  organizationId: string\n  type: 'saml'\n}\n\n/**\n * @internal\n */\nexport interface ProvidersResponse {\n  providers: LoginProvider[]\n}\n"],"names":[],"mappings":"AAAA;;CAEC,GAoBD;;CAEC,GACD,WAEC"}

package/dist/actions/backup/archiveDir.js

@@ -0,0 +1,43 @@
+import { createWriteStream } from 'node:fs';
+import { createGzip } from 'node:zlib';
+import { pack } from 'tar-fs';
+import { backupDownloadDebug } from './backupDownloadDebug.js';
+/**
+ * Creates a compressed tarball of the given directory and writes it to the specified file path
+ *
+ * @param tmpOutDir - The directory to archive
+ * @param outFilePath - The output file path for the compressed tarball
+ * @param progressCb - Callback function called with the number of bytes processed
+ */ export function archiveDir(tmpOutDir, outFilePath, progressCb) {
+    return new Promise((resolve, reject)=>{
+        const archiveDestination = createWriteStream(outFilePath);
+        const gzipStream = createGzip();
+        let processedBytes = 0;
+        archiveDestination.on('error', (err)=>{
+            backupDownloadDebug('Archive destination error: %s', err.message);
+            reject(err);
+        });
+        archiveDestination.on('close', ()=>{
+            backupDownloadDebug('Archive completed successfully');
+            resolve();
+        });
+        gzipStream.on('error', (err)=>{
+            backupDownloadDebug('Gzip stream error: %s', err.message);
+            reject(err);
+        });
+        const tarStream = pack(tmpOutDir);
+        tarStream.on('error', (err)=>{
+            backupDownloadDebug('Tar stream error: %s', err.message);
+            reject(err);
+        });
+        // Track progress by listening to data events
+        tarStream.on('data', (chunk)=>{
+            processedBytes += chunk.length;
+            progressCb(processedBytes);
+        });
+        // Pipe tar -> gzip -> file
+        tarStream.pipe(gzipStream).pipe(archiveDestination);
+    });
+}
+
+//# sourceMappingURL=archiveDir.js.map

package/dist/actions/backup/archiveDir.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/backup/archiveDir.ts"],"sourcesContent":["import {createWriteStream} from 'node:fs'\nimport {createGzip} from 'node:zlib'\n\nimport {pack} from 'tar-fs'\n\nimport {backupDownloadDebug} from './backupDownloadDebug.js'\n\n// ProgressCb is a callback that is called with the number of bytes processed so far.\ntype ProgressCb = (processedBytes: number) => void\n\n/**\n * Creates a compressed tarball of the given directory and writes it to the specified file path\n *\n * @param tmpOutDir - The directory to archive\n * @param outFilePath - The output file path for the compressed tarball\n * @param progressCb - Callback function called with the number of bytes processed\n */\nexport function archiveDir(\n  tmpOutDir: string,\n  outFilePath: string,\n  progressCb: ProgressCb,\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const archiveDestination = createWriteStream(outFilePath)\n    const gzipStream = createGzip()\n    let processedBytes = 0\n\n    archiveDestination.on('error', (err: Error) => {\n      backupDownloadDebug('Archive destination error: %s', err.message)\n      reject(err)\n    })\n\n    archiveDestination.on('close', () => {\n      backupDownloadDebug('Archive completed successfully')\n      resolve()\n    })\n\n    gzipStream.on('error', (err: Error) => {\n      backupDownloadDebug('Gzip stream error: %s', err.message)\n      reject(err)\n    })\n\n    const tarStream = pack(tmpOutDir)\n\n    tarStream.on('error', (err: Error) => {\n      backupDownloadDebug('Tar stream error: %s', err.message)\n      reject(err)\n    })\n\n    // Track progress by listening to data events\n    tarStream.on('data', (chunk: Buffer) => {\n      processedBytes += chunk.length\n      progressCb(processedBytes)\n    })\n\n    // Pipe tar -> gzip -> file\n    tarStream.pipe(gzipStream).pipe(archiveDestination)\n  })\n}\n"],"names":["createWriteStream","createGzip","pack","backupDownloadDebug","archiveDir","tmpOutDir","outFilePath","progressCb","Promise","resolve","reject","archiveDestination","gzipStream","processedBytes","on","err","message","tarStream","chunk","length","pipe"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,UAAS;AACzC,SAAQC,UAAU,QAAO,YAAW;AAEpC,SAAQC,IAAI,QAAO,SAAQ;AAE3B,SAAQC,mBAAmB,QAAO,2BAA0B;AAK5D;;;;;;CAMC,GACD,OAAO,SAASC,WACdC,SAAiB,EACjBC,WAAmB,EACnBC,UAAsB;IAEtB,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC3B,MAAMC,qBAAqBX,kBAAkBM;QAC7C,MAAMM,aAAaX;QACnB,IAAIY,iBAAiB;QAErBF,mBAAmBG,EAAE,CAAC,SAAS,CAACC;YAC9BZ,oBAAoB,iCAAiCY,IAAIC,OAAO;YAChEN,OAAOK;QACT;QAEAJ,mBAAmBG,EAAE,CAAC,SAAS;YAC7BX,oBAAoB;YACpBM;QACF;QAEAG,WAAWE,EAAE,CAAC,SAAS,CAACC;YACtBZ,oBAAoB,yBAAyBY,IAAIC,OAAO;YACxDN,OAAOK;QACT;QAEA,MAAME,YAAYf,KAAKG;QAEvBY,UAAUH,EAAE,CAAC,SAAS,CAACC;YACrBZ,oBAAoB,wBAAwBY,IAAIC,OAAO;YACvDN,OAAOK;QACT;QAEA,6CAA6C;QAC7CE,UAAUH,EAAE,CAAC,QAAQ,CAACI;YACpBL,kBAAkBK,MAAMC,MAAM;YAC9BZ,WAAWM;QACb;QAEA,2BAA2B;QAC3BI,UAAUG,IAAI,CAACR,YAAYQ,IAAI,CAACT;IAClC;AACF"}

package/dist/actions/backup/assertDatasetExist.js

@@ -0,0 +1,16 @@
+import { ux } from '@oclif/core';
+/**
+ * Asserts that a dataset exists in a list of datasets, exits if not found
+ *
+ * @param datasets - The list of datasets to check
+ * @param datasetName - The name of the dataset to check for
+ */ export function assertDatasetExists(datasets, datasetName) {
+    const exists = datasets.some((d)=>d.name === datasetName);
+    if (!exists) {
+        ux.error(`Dataset '${datasetName}' not found in this project. Available datasets: ${datasets.map((d)=>d.name).join(', ')}`, {
+            exit: 1
+        });
+    }
+}
+
+//# sourceMappingURL=assertDatasetExist.js.map

package/dist/actions/backup/assertDatasetExist.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/backup/assertDatasetExist.ts"],"sourcesContent":["import {ux} from '@oclif/core'\nimport {type DatasetsResponse} from '@sanity/client'\n\n/**\n * Asserts that a dataset exists in a list of datasets, exits if not found\n *\n * @param datasets - The list of datasets to check\n * @param datasetName - The name of the dataset to check for\n */\nexport function assertDatasetExists(datasets: DatasetsResponse, datasetName: string): void {\n  const exists = datasets.some((d) => d.name === datasetName)\n  if (!exists) {\n    ux.error(\n      `Dataset '${datasetName}' not found in this project. Available datasets: ${datasets.map((d) => d.name).join(', ')}`,\n      {exit: 1},\n    )\n  }\n}\n"],"names":["ux","assertDatasetExists","datasets","datasetName","exists","some","d","name","error","map","join","exit"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAa;AAG9B;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,QAA0B,EAAEC,WAAmB;IACjF,MAAMC,SAASF,SAASG,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKJ;IAC/C,IAAI,CAACC,QAAQ;QACXJ,GAAGQ,KAAK,CACN,CAAC,SAAS,EAAEL,YAAY,iDAAiD,EAAED,SAASO,GAAG,CAAC,CAACH,IAAMA,EAAEC,IAAI,EAAEG,IAAI,CAAC,OAAO,EACnH;YAACC,MAAM;QAAC;IAEZ;AACF"}

package/dist/actions/backup/backupDownloadDebug.js

@@ -0,0 +1,4 @@
+import { subdebug } from '@sanity/cli-core';
+export const backupDownloadDebug = subdebug('backup:download');
+
+//# sourceMappingURL=backupDownloadDebug.js.map

package/dist/actions/backup/backupDownloadDebug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/backup/backupDownloadDebug.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\nexport const backupDownloadDebug = subdebug('backup:download')\n"],"names":["subdebug","backupDownloadDebug"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,OAAO,MAAMC,sBAAsBD,SAAS,mBAAkB"}

package/dist/actions/backup/cleanupTmpDir.js

@@ -0,0 +1,19 @@
+import { rm } from 'node:fs/promises';
+import { backupDownloadDebug } from './backupDownloadDebug.js';
+/**
+ * Removes the temporary directory and all its contents
+ *
+ * @param tmpDir - Path to the temporary directory to clean up
+ */ export async function cleanupTmpDir(tmpDir) {
+    try {
+        await rm(tmpDir, {
+            force: true,
+            recursive: true
+        });
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        backupDownloadDebug(`Error cleaning up temporary files: ${message}`);
+    }
+}
+
+//# sourceMappingURL=cleanupTmpDir.js.map

package/dist/actions/backup/cleanupTmpDir.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/backup/cleanupTmpDir.ts"],"sourcesContent":["import {rm} from 'node:fs/promises'\n\nimport {backupDownloadDebug} from './backupDownloadDebug.js'\n\n/**\n * Removes the temporary directory and all its contents\n *\n * @param tmpDir - Path to the temporary directory to clean up\n */\nexport async function cleanupTmpDir(tmpDir: string): Promise<void> {\n  try {\n    await rm(tmpDir, {force: true, recursive: true})\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err)\n    backupDownloadDebug(`Error cleaning up temporary files: ${message}`)\n  }\n}\n"],"names":["rm","backupDownloadDebug","cleanupTmpDir","tmpDir","force","recursive","err","message","Error","String"],"mappings":"AAAA,SAAQA,EAAE,QAAO,mBAAkB;AAEnC,SAAQC,mBAAmB,QAAO,2BAA0B;AAE5D;;;;CAIC,GACD,OAAO,eAAeC,cAAcC,MAAc;IAChD,IAAI;QACF,MAAMH,GAAGG,QAAQ;YAACC,OAAO;YAAMC,WAAW;QAAI;IAChD,EAAE,OAAOC,KAAK;QACZ,MAAMC,UAAUD,eAAeE,QAAQF,IAAIC,OAAO,GAAGE,OAAOH;QAC5DL,oBAAoB,CAAC,mCAAmC,EAAEM,SAAS;IACrE;AACF"}

package/dist/actions/backup/constants.js

@@ -0,0 +1,3 @@
+export const BACKUP_API_VERSION = 'v2025-08-29';
+
+//# sourceMappingURL=constants.js.map

package/dist/actions/backup/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/backup/constants.ts"],"sourcesContent":["export const BACKUP_API_VERSION = 'v2025-08-29'\n"],"names":["BACKUP_API_VERSION"],"mappings":"AAAA,OAAO,MAAMA,qBAAqB,cAAa"}