@sendly/cli 3.29.0 → 3.32.0

package/dist/lib/auth.js

@@ -76,6 +76,12 @@ export async function browserLogin() {
     catch {
         console.log(colors.dim("Please open the URL manually"));
     }
+    // Enable press-to-copy UX while we poll. Only wire this when we have a
+    // real interactive TTY — in CI or piped stdin there's nothing to read
+    // from and setRawMode throws. The keypress listener is detached on any
+    // exit path (success, timeout, error) so we don't leave the terminal in
+    // raw mode.
+    const keypressCleanup = attachLoginKeypressHandler(data.verificationUrl);
     console.log();
     // Poll for token
     const spin = spinner("Waiting for authorization...");
@@ -93,6 +99,7 @@ export async function browserLogin() {
             if (tokenResponse.ok) {
                 const tokens = (await tokenResponse.json());
                 spin.succeed("Authorized");
+                keypressCleanup();
                 // Store tokens
                 setAuthTokens(tokens.accessToken, tokens.refreshToken, tokens.expiresIn, tokens.userId, tokens.email);
                 // Check if new user needs quick-start (only for CLI sessions)
@@ -111,10 +118,12 @@ export async function browserLogin() {
             }
             if (errorData.error === "expired_token") {
                 spin.fail("Login request expired");
+                keypressCleanup();
                 process.exit(1);
             }
             if (errorData.error === "access_denied") {
                 spin.fail("Login was denied");
+                keypressCleanup();
                 process.exit(1);
             }
         }
@@ -123,8 +132,102 @@ export async function browserLogin() {
         }
     }
     spin.fail("Login timed out");
+    keypressCleanup();
     process.exit(1);
 }
+/**
+ * Wire up the copy-URL / cancel keybindings during the device-code
+ * polling loop. Only active on a real interactive TTY — in CI, piped
+ * stdin, or when stdin.setRawMode is missing we no-op and return a
+ * cleanup that also no-ops.
+ *
+ * Returns a cleanup function that the caller MUST invoke on every exit
+ * path (success, timeout, error) so the terminal doesn't stay in raw
+ * mode. Calling cleanup twice is safe.
+ */
+function attachLoginKeypressHandler(urlToCopy) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+        return () => { };
+    }
+    let cleaned = false;
+    const previousRawMode = stdin.isRaw;
+    console.log(colors.dim("Press [c] to copy URL to clipboard · [q] or Ctrl-C to cancel"));
+    const onData = (key) => {
+        const k = typeof key === "string" ? key : key.toString("utf8");
+        if (k === "c" || k === "C") {
+            copyToClipboard(urlToCopy)
+                .then((ok) => {
+                if (ok) {
+                    // Overwrite the hint line with a transient confirmation.
+                    process.stdout.write("\r" + " ".repeat(70) + "\r" + colors.success("  ✓ URL copied to clipboard\n"));
+                }
+                else {
+                    process.stdout.write("\r" + colors.warning("  ✗ Could not copy — copy the URL manually\n"));
+                }
+            })
+                .catch(() => { });
+            return;
+        }
+        if (k === "q" || k === "Q" || k === "\u0003") {
+            cleanup();
+            console.log(colors.warning("\n  Login cancelled."));
+            process.exit(130);
+        }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        try {
+            stdin.removeListener("data", onData);
+            stdin.setRawMode(previousRawMode);
+            stdin.pause();
+        }
+        catch {
+            /* no-op */
+        }
+    };
+    return cleanup;
+}
+/**
+ * Copy text to the system clipboard via the OS's native tool. Returns
+ * true if the write succeeded. Does not throw. Shells out rather than
+ * adding a native clipboard dep — the three commands (pbcopy / clip /
+ * xclip / wl-copy) cover every platform the CLI runs on.
+ */
+async function copyToClipboard(text) {
+    const { spawn } = await import("node:child_process");
+    const candidates = process.platform === "darwin"
+        ? [["pbcopy", []]]
+        : process.platform === "win32"
+            ? [["clip", []]]
+            : [
+                ["wl-copy", []],
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+            ];
+    for (const [cmd, args] of candidates) {
+        try {
+            const ok = await new Promise((resolve) => {
+                const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+                child.on("error", () => resolve(false));
+                child.on("exit", (code) => resolve(code === 0));
+                child.stdin.end(text);
+            });
+            if (ok)
+                return true;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return false;
+}
 /**
  * Login with an API key directly
  */
@@ -184,4 +287,4 @@ export async function getAuthInfo() {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\n\nconst USER_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a long random device code for URL (session identifier)\n * This goes in the URL and identifies which CLI session is waiting\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(16).toString(\"hex\"); // 32 chars, not guessable\n}\n\n/**\n * Generate a short human-readable user code for terminal display\n * This is what the user types to prove they have terminal access\n * Uses characters that are easy to read and type (no 0/O, 1/I/L confusion)\n */\nexport function generateUserCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(USER_CODE_LENGTH);\n  for (let i = 0; i < USER_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n *\n * Security model:\n * - deviceCode: Long random token in URL, identifies CLI session (not secret)\n * - userCode: Short code shown ONLY in terminal, proves user has terminal access\n *\n * The userCode is NEVER in the URL - this is critical for security.\n * Anyone with the URL can't authorize without also seeing the terminal.\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Generate TWO SEPARATE codes for security\n  const deviceCode = generateDeviceCode(); // Long random, goes in URL\n  const userCode = generateUserCode(); // Short readable, shown in terminal only\n\n  // Request device code registration from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode, userCode }), // Send both to server\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Format user code with hyphen for readability (e.g., \"ABCD-EFGH\")\n  const displayUserCode = `${userCode.slice(0, 4)}-${userCode.slice(4)}`;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${displayUserCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n        spin.succeed(\"Authorized\");\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        // Check if new user needs quick-start (only for CLI sessions)\n        if (tokens.accessToken.startsWith(\"cli_\")) {\n          const { shouldOfferQuickStart, offerQuickStart } =\n            await import(\"./onboarding.js\");\n\n          if (await shouldOfferQuickStart()) {\n            await offerQuickStart();\n          }\n        }\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired\");\n        process.exit(1);\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        process.exit(1);\n      }\n    } catch (error) {\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out\");\n  process.exit(1);\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\n\nconst USER_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a long random device code for URL (session identifier)\n * This goes in the URL and identifies which CLI session is waiting\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(16).toString(\"hex\"); // 32 chars, not guessable\n}\n\n/**\n * Generate a short human-readable user code for terminal display\n * This is what the user types to prove they have terminal access\n * Uses characters that are easy to read and type (no 0/O, 1/I/L confusion)\n */\nexport function generateUserCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(USER_CODE_LENGTH);\n  for (let i = 0; i < USER_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n *\n * Security model:\n * - deviceCode: Long random token in URL, identifies CLI session (not secret)\n * - userCode: Short code shown ONLY in terminal, proves user has terminal access\n *\n * The userCode is NEVER in the URL - this is critical for security.\n * Anyone with the URL can't authorize without also seeing the terminal.\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Generate TWO SEPARATE codes for security\n  const deviceCode = generateDeviceCode(); // Long random, goes in URL\n  const userCode = generateUserCode(); // Short readable, shown in terminal only\n\n  // Request device code registration from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode, userCode }), // Send both to server\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Format user code with hyphen for readability (e.g., \"ABCD-EFGH\")\n  const displayUserCode = `${userCode.slice(0, 4)}-${userCode.slice(4)}`;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${displayUserCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  // Enable press-to-copy UX while we poll. Only wire this when we have a\n  // real interactive TTY — in CI or piped stdin there's nothing to read\n  // from and setRawMode throws. The keypress listener is detached on any\n  // exit path (success, timeout, error) so we don't leave the terminal in\n  // raw mode.\n  const keypressCleanup = attachLoginKeypressHandler(data.verificationUrl);\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n        spin.succeed(\"Authorized\");\n        keypressCleanup();\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        // Check if new user needs quick-start (only for CLI sessions)\n        if (tokens.accessToken.startsWith(\"cli_\")) {\n          const { shouldOfferQuickStart, offerQuickStart } =\n            await import(\"./onboarding.js\");\n\n          if (await shouldOfferQuickStart()) {\n            await offerQuickStart();\n          }\n        }\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired\");\n        keypressCleanup();\n        process.exit(1);\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        keypressCleanup();\n        process.exit(1);\n      }\n    } catch (error) {\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out\");\n  keypressCleanup();\n  process.exit(1);\n}\n\n/**\n * Wire up the copy-URL / cancel keybindings during the device-code\n * polling loop. Only active on a real interactive TTY — in CI, piped\n * stdin, or when stdin.setRawMode is missing we no-op and return a\n * cleanup that also no-ops.\n *\n * Returns a cleanup function that the caller MUST invoke on every exit\n * path (success, timeout, error) so the terminal doesn't stay in raw\n * mode. Calling cleanup twice is safe.\n */\nfunction attachLoginKeypressHandler(urlToCopy: string): () => void {\n  const stdin = process.stdin;\n  if (!stdin.isTTY || typeof stdin.setRawMode !== \"function\") {\n    return () => {};\n  }\n\n  let cleaned = false;\n  const previousRawMode = stdin.isRaw;\n\n  console.log(\n    colors.dim(\n      \"Press [c] to copy URL to clipboard · [q] or Ctrl-C to cancel\",\n    ),\n  );\n\n  const onData = (key: Buffer | string): void => {\n    const k = typeof key === \"string\" ? key : key.toString(\"utf8\");\n    if (k === \"c\" || k === \"C\") {\n      copyToClipboard(urlToCopy)\n        .then((ok) => {\n          if (ok) {\n            // Overwrite the hint line with a transient confirmation.\n            process.stdout.write(\n              \"\\r\" + \" \".repeat(70) + \"\\r\" + colors.success(\"  ✓ URL copied to clipboard\\n\"),\n            );\n          } else {\n            process.stdout.write(\n              \"\\r\" + colors.warning(\"  ✗ Could not copy — copy the URL manually\\n\"),\n            );\n          }\n        })\n        .catch(() => {});\n      return;\n    }\n    if (k === \"q\" || k === \"Q\" || k === \"\\u0003\") {\n      cleanup();\n      console.log(colors.warning(\"\\n  Login cancelled.\"));\n      process.exit(130);\n    }\n  };\n\n  stdin.setRawMode(true);\n  stdin.resume();\n  stdin.setEncoding(\"utf8\");\n  stdin.on(\"data\", onData);\n\n  const cleanup = (): void => {\n    if (cleaned) return;\n    cleaned = true;\n    try {\n      stdin.removeListener(\"data\", onData);\n      stdin.setRawMode(previousRawMode);\n      stdin.pause();\n    } catch {\n      /* no-op */\n    }\n  };\n\n  return cleanup;\n}\n\n/**\n * Copy text to the system clipboard via the OS's native tool. Returns\n * true if the write succeeded. Does not throw. Shells out rather than\n * adding a native clipboard dep — the three commands (pbcopy / clip /\n * xclip / wl-copy) cover every platform the CLI runs on.\n */\nasync function copyToClipboard(text: string): Promise<boolean> {\n  const { spawn } = await import(\"node:child_process\");\n  const candidates: Array<[string, string[]]> =\n    process.platform === \"darwin\"\n      ? [[\"pbcopy\", []]]\n      : process.platform === \"win32\"\n        ? [[\"clip\", []]]\n        : [\n            [\"wl-copy\", []],\n            [\"xclip\", [\"-selection\", \"clipboard\"]],\n            [\"xsel\", [\"--clipboard\", \"--input\"]],\n          ];\n\n  for (const [cmd, args] of candidates) {\n    try {\n      const ok = await new Promise<boolean>((resolve) => {\n        const child = spawn(cmd, args, { stdio: [\"pipe\", \"ignore\", \"ignore\"] });\n        child.on(\"error\", () => resolve(false));\n        child.on(\"exit\", (code) => resolve(code === 0));\n        child.stdin.end(text);\n      });\n      if (ok) return true;\n    } catch {\n      // try next candidate\n    }\n  }\n  return false;\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}

package/dist/lib/detect-install-path.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Detect how the `@sendly/cli` binary was installed so `sendly upgrade`
+ * can shell out to the correct package manager.
+ *
+ * We support two install paths explicitly:
+ *   - Homebrew — from the SendlyHQ/homebrew-tap formula (`brew install sendly`).
+ *     Detected via the `HOMEBREW_CELLAR` env var (set by every brew-managed
+ *     shell) OR by the binary path living under a Homebrew-owned prefix.
+ *   - npm global — `npm install -g @sendly/cli`. This is the default and
+ *     what we fall back to when we can't identify Homebrew.
+ *
+ * Returns `"unknown"` only when we can't determine either. That's rare in
+ * practice (npm installs into predictable paths) but we handle it
+ * gracefully in the `upgrade` command by printing both options.
+ */
+export type InstallPath = "homebrew" | "npm" | "unknown";
+export declare function detectInstallPath(): InstallPath;
+/**
+ * Human-readable upgrade command for the detected install path.
+ */
+export declare function upgradeCommandFor(path: InstallPath): string;

package/dist/lib/detect-install-path.js

@@ -0,0 +1,38 @@
+const HOMEBREW_PREFIX_MARKERS = [
+    "/opt/homebrew/",
+    "/usr/local/Cellar/",
+    "/home/linuxbrew/",
+    "/Cellar/",
+];
+export function detectInstallPath() {
+    // Strongest signal — the env var that `brew shellenv` sets.
+    if (process.env.HOMEBREW_CELLAR) {
+        return "homebrew";
+    }
+    // Fallback — look at the bin path. `process.argv[1]` is the entry
+    // script; for Homebrew installs it lives under Cellar/libexec. For npm
+    // globals it lives under the npm prefix (e.g. /usr/local/lib/node_modules).
+    const binPath = process.argv[1] ?? "";
+    for (const marker of HOMEBREW_PREFIX_MARKERS) {
+        if (binPath.includes(marker))
+            return "homebrew";
+    }
+    // `node_modules` is the tell-tale for any npm install (global or local).
+    if (binPath.includes("/node_modules/"))
+        return "npm";
+    return "unknown";
+}
+/**
+ * Human-readable upgrade command for the detected install path.
+ */
+export function upgradeCommandFor(path) {
+    switch (path) {
+        case "homebrew":
+            return "brew upgrade sendly";
+        case "npm":
+            return "npm install -g @sendly/cli@latest";
+        default:
+            return "npm install -g @sendly/cli@latest  # or: brew upgrade sendly";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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