@sendly/cli 3.34.0 → 3.36.0

package/dist/lib/config.js

@@ -140,7 +140,36 @@ function initializeConfig() {
     catch {
         // Old key also didn't work - corrupted or fresh install
     }
-    // Fresh install or corrupted - start with new key
+    // Fresh install or corrupted. If a config file exists at this point,
+    // both the new key and the old key failed to decrypt it — that means
+    // the file was written by a different machine, encrypted with a
+    // SENDLY_CONFIG_KEY that no longer matches, or got corrupted.
+    // Constructing a new Conf{} here would just re-read the same file and
+    // throw the same SyntaxError. Move it aside so the user keeps a copy
+    // (in case they recover the key later) and start clean.
+    const filePath = path.join(CONFIG_DIR, CONFIG_FILE);
+    if (fs.existsSync(filePath)) {
+        try {
+            const backupPath = `${filePath}.corrupt.${Date.now()}`;
+            fs.renameSync(filePath, backupPath);
+            // Stay quiet by default — most callers run early in the process
+            // before output helpers are wired. A debug breadcrumb is enough.
+            if (process.env.DEBUG) {
+                process.stderr.write(`[sendly] Could not decrypt ${filePath}; moved to ${backupPath} and starting fresh. Run 'sendly login' to re-authenticate.\n`);
+            }
+        }
+        catch {
+            // If we can't move the file (permissions, FS issue), our best
+            // remaining option is to delete it — losing it is strictly better
+            // than crashing every command.
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch {
+                // Give up silently and let Conf throw if it must.
+            }
+        }
+    }
     return new Conf({
         projectName: "sendly",
         cwd: CONFIG_DIR,
@@ -299,4 +328,4 @@ export function clearCurrentOrg() {
     config.delete("currentOrgSlug");
 }
 export { config };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CLI Configuration Management\n * Stores user preferences and credentials in ~/.sendly/\n *\n * Environment Variables (take precedence over config file):\n * - SENDLY_API_KEY: API key for authentication\n * - SENDLY_BASE_URL: Custom API endpoint\n * - SENDLY_OUTPUT_FORMAT: Default output format (human/json)\n * - SENDLY_NO_COLOR: Disable colored output (any value)\n * - SENDLY_TIMEOUT: Request timeout in ms (default: 30000)\n * - SENDLY_MAX_RETRIES: Max retry attempts (default: 3)\n * - SENDLY_ORG_ID: Override active organization ID\n * - SENDLY_CONFIG_KEY: Custom encryption key (for CI/CD)\n * - CI: Auto-detect CI mode (disables interactive prompts)\n */\n\nimport Conf from \"conf\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport * as os from \"node:os\";\nimport * as crypto from \"node:crypto\";\n\nexport interface SendlyConfig {\n  // Authentication\n  apiKey?: string;\n  accessToken?: string;\n  refreshToken?: string;\n  tokenExpiresAt?: number;\n  userId?: string;\n  email?: string;\n\n  // Environment\n  environment: \"test\" | \"live\";\n  baseUrl: string;\n\n  // Preferences\n  defaultFormat: \"human\" | \"json\";\n  colorEnabled: boolean;\n\n  // Network\n  timeout: number;\n  maxRetries: number;\n\n  // Organization\n  currentOrgId?: string;\n  currentOrgName?: string;\n  currentOrgSlug?: string;\n}\n\n/**\n * Check if running in CI environment\n */\nexport function isCI(): boolean {\n  return !!(\n    process.env.CI ||\n    process.env.CONTINUOUS_INTEGRATION ||\n    process.env.GITHUB_ACTIONS ||\n    process.env.GITLAB_CI ||\n    process.env.CIRCLECI ||\n    process.env.TRAVIS ||\n    process.env.BUILDKITE\n  );\n}\n\n/**\n * Check if color output is disabled\n */\nexport function isColorDisabled(): boolean {\n  return !!(\n    process.env.SENDLY_NO_COLOR ||\n    process.env.NO_COLOR ||\n    process.env.TERM === \"dumb\"\n  );\n}\n\nconst CONFIG_DIR = path.join(os.homedir(), \".sendly\");\nconst CONFIG_FILE = \"config.json\";\n\n// Old default key - used for migration only\nconst OLD_DEFAULT_KEY = \"sendly-cli-default-key-v1\";\n\n/**\n * Derive a machine-specific encryption key.\n * This ensures each installation has a unique key that can't be easily guessed.\n *\n * The key is derived from machine-specific identifiers that are:\n * - Unique per machine\n * - Stable across sessions\n * - Not publicly known\n */\nfunction deriveEncryptionKey(): string {\n  const machineId = [os.hostname(), os.userInfo().username, os.homedir()].join(\n    \":\",\n  );\n\n  return crypto\n    .createHash(\"sha256\")\n    .update(`sendly:${machineId}:v2`)\n    .digest(\"hex\");\n}\n\n/**\n * Get the encryption key to use for config.\n * Priority: SENDLY_CONFIG_KEY env var > machine-derived key\n */\nfunction getEncryptionKey(): string {\n  // Explicit key takes precedence (for CI/CD, testing, advanced users)\n  if (process.env.SENDLY_CONFIG_KEY) {\n    return process.env.SENDLY_CONFIG_KEY;\n  }\n  return deriveEncryptionKey();\n}\n\n// Ensure config directory exists with secure permissions\nif (!fs.existsSync(CONFIG_DIR)) {\n  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });\n}\n\nconst DEFAULT_CONFIG: SendlyConfig = {\n  environment: \"test\",\n  baseUrl: \"https://sendly.live\",\n  defaultFormat: \"human\",\n  colorEnabled: true,\n  timeout: 30000,\n  maxRetries: 3,\n};\n\n/**\n * Initialize config with automatic migration from old encryption key.\n * This ensures existing users don't lose their credentials.\n */\nfunction initializeConfig(): Conf<SendlyConfig> {\n  const newKey = getEncryptionKey();\n\n  // Try to initialize with new key first\n  try {\n    const newConfig = new Conf<SendlyConfig>({\n      projectName: \"sendly\",\n      cwd: CONFIG_DIR,\n      configName: \"config\",\n      defaults: DEFAULT_CONFIG,\n      encryptionKey: newKey,\n    });\n\n    // Try to read a value to verify decryption works\n    newConfig.get(\"environment\");\n    return newConfig;\n  } catch {\n    // New key didn't work - try migration from old key\n  }\n\n  // Migration: Try to read with old default key\n  try {\n    const oldConfig = new Conf<SendlyConfig>({\n      projectName: \"sendly\",\n      cwd: CONFIG_DIR,\n      configName: \"config\",\n      defaults: DEFAULT_CONFIG,\n      encryptionKey: OLD_DEFAULT_KEY,\n    });\n\n    // Read all data with old key\n    const oldData = { ...oldConfig.store };\n    const hasData = Object.keys(oldData).some(\n      (k) =>\n        !Object.keys(DEFAULT_CONFIG).includes(k) ||\n        oldData[k as keyof SendlyConfig] !==\n          DEFAULT_CONFIG[k as keyof SendlyConfig],\n    );\n\n    if (hasData) {\n      // Clear old config file\n      oldConfig.clear();\n\n      // Create new config with new key\n      const newConfig = new Conf<SendlyConfig>({\n        projectName: \"sendly\",\n        cwd: CONFIG_DIR,\n        configName: \"config\",\n        defaults: DEFAULT_CONFIG,\n        encryptionKey: newKey,\n      });\n\n      // Restore data with new encryption\n      for (const [key, value] of Object.entries(oldData)) {\n        if (value !== undefined) {\n          newConfig.set(key as keyof SendlyConfig, value);\n        }\n      }\n\n      return newConfig;\n    }\n  } catch {\n    // Old key also didn't work - corrupted or fresh install\n  }\n\n  // Fresh install or corrupted - start with new key\n  return new Conf<SendlyConfig>({\n    projectName: \"sendly\",\n    cwd: CONFIG_DIR,\n    configName: \"config\",\n    defaults: DEFAULT_CONFIG,\n    encryptionKey: newKey,\n  });\n}\n\nconst config = initializeConfig();\n\n/**\n * Get effective config value with environment variable override\n * Priority: env var > config file > default\n */\nexport function getEffectiveValue<K extends keyof SendlyConfig>(\n  key: K,\n): SendlyConfig[K] {\n  // Environment variable overrides\n  switch (key) {\n    case \"apiKey\":\n      if (process.env.SENDLY_API_KEY) {\n        return process.env.SENDLY_API_KEY as SendlyConfig[K];\n      }\n      break;\n    case \"baseUrl\":\n      if (process.env.SENDLY_BASE_URL) {\n        return process.env.SENDLY_BASE_URL as SendlyConfig[K];\n      }\n      break;\n    case \"defaultFormat\":\n      if (process.env.SENDLY_OUTPUT_FORMAT) {\n        const format = process.env.SENDLY_OUTPUT_FORMAT.toLowerCase();\n        if (format === \"json\" || format === \"human\") {\n          return format as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"colorEnabled\":\n      if (isColorDisabled()) {\n        return false as SendlyConfig[K];\n      }\n      break;\n    case \"timeout\":\n      if (process.env.SENDLY_TIMEOUT) {\n        const timeout = parseInt(process.env.SENDLY_TIMEOUT, 10);\n        if (!isNaN(timeout) && timeout > 0) {\n          return timeout as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"maxRetries\":\n      if (process.env.SENDLY_MAX_RETRIES) {\n        const retries = parseInt(process.env.SENDLY_MAX_RETRIES, 10);\n        if (!isNaN(retries) && retries >= 0) {\n          return retries as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"currentOrgId\":\n      if (process.env.SENDLY_ORG_ID) {\n        return process.env.SENDLY_ORG_ID as SendlyConfig[K];\n      }\n      break;\n  }\n\n  // Fall back to config file value\n  return config.get(key);\n}\n\nexport function getConfig(): SendlyConfig {\n  return config.store;\n}\n\nexport function setConfig<K extends keyof SendlyConfig>(\n  key: K,\n  value: SendlyConfig[K],\n): void {\n  config.set(key, value);\n}\n\nexport function getConfigValue<K extends keyof SendlyConfig>(\n  key: K,\n): SendlyConfig[K] {\n  return config.get(key);\n}\n\nexport function clearConfig(): void {\n  config.clear();\n}\n\nexport function clearAuth(): void {\n  config.delete(\"apiKey\");\n  config.delete(\"accessToken\");\n  config.delete(\"refreshToken\");\n  config.delete(\"tokenExpiresAt\");\n  config.delete(\"userId\");\n  config.delete(\"email\");\n}\n\nexport function isAuthenticated(): boolean {\n  // Check env var first\n  if (process.env.SENDLY_API_KEY) return true;\n\n  const apiKey = config.get(\"apiKey\");\n  const accessToken = config.get(\"accessToken\");\n  return !!(apiKey || accessToken);\n}\n\nexport function getAuthToken(): string | undefined {\n  // Environment variable takes highest precedence\n  if (process.env.SENDLY_API_KEY) {\n    return process.env.SENDLY_API_KEY;\n  }\n\n  // Then stored API key\n  const apiKey = config.get(\"apiKey\");\n  if (apiKey) return apiKey;\n\n  // Finally, access token (if not expired)\n  const accessToken = config.get(\"accessToken\");\n  const expiresAt = config.get(\"tokenExpiresAt\");\n\n  if (accessToken && expiresAt && Date.now() < expiresAt) {\n    return accessToken;\n  }\n\n  return undefined;\n}\n\nexport function getStoredAccessToken(): string | undefined {\n  return config.get(\"accessToken\") || undefined;\n}\n\nexport function setApiKey(apiKey: string): void {\n  // Validate API key format\n  if (!/^sk_(test|live)_v1_[a-zA-Z0-9_-]+$/.test(apiKey)) {\n    throw new Error(\n      \"Invalid API key format. Expected sk_test_v1_xxx or sk_live_v1_xxx\",\n    );\n  }\n\n  config.set(\"apiKey\", apiKey);\n\n  // Set environment based on key type\n  if (apiKey.startsWith(\"sk_test_\")) {\n    config.set(\"environment\", \"test\");\n  } else {\n    config.set(\"environment\", \"live\");\n  }\n}\n\nexport function setAuthTokens(\n  accessToken: string,\n  refreshToken: string,\n  expiresIn: number,\n  userId: string,\n  email: string,\n): void {\n  config.set(\"accessToken\", accessToken);\n  config.set(\"refreshToken\", refreshToken);\n  config.set(\"tokenExpiresAt\", Date.now() + expiresIn * 1000);\n  config.set(\"userId\", userId);\n  config.set(\"email\", email);\n}\n\nexport function getConfigPath(): string {\n  return path.join(CONFIG_DIR, CONFIG_FILE);\n}\n\nexport function getConfigDir(): string {\n  return CONFIG_DIR;\n}\n\nexport function setCurrentOrg(id: string, name: string, slug?: string): void {\n  config.set(\"currentOrgId\", id);\n  config.set(\"currentOrgName\", name);\n  if (slug) config.set(\"currentOrgSlug\", slug);\n}\n\nexport function getCurrentOrg(): {\n  id: string;\n  name: string;\n  slug?: string;\n} | null {\n  const id = getEffectiveValue(\"currentOrgId\");\n  const name = config.get(\"currentOrgName\");\n  if (!id) return null;\n  return { id, name: name || id, slug: config.get(\"currentOrgSlug\") };\n}\n\nexport function clearCurrentOrg(): void {\n  config.delete(\"currentOrgId\");\n  config.delete(\"currentOrgName\");\n  config.delete(\"currentOrgSlug\");\n}\n\nexport { config };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CLI Configuration Management\n * Stores user preferences and credentials in ~/.sendly/\n *\n * Environment Variables (take precedence over config file):\n * - SENDLY_API_KEY: API key for authentication\n * - SENDLY_BASE_URL: Custom API endpoint\n * - SENDLY_OUTPUT_FORMAT: Default output format (human/json)\n * - SENDLY_NO_COLOR: Disable colored output (any value)\n * - SENDLY_TIMEOUT: Request timeout in ms (default: 30000)\n * - SENDLY_MAX_RETRIES: Max retry attempts (default: 3)\n * - SENDLY_ORG_ID: Override active organization ID\n * - SENDLY_CONFIG_KEY: Custom encryption key (for CI/CD)\n * - CI: Auto-detect CI mode (disables interactive prompts)\n */\n\nimport Conf from \"conf\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport * as os from \"node:os\";\nimport * as crypto from \"node:crypto\";\n\nexport interface SendlyConfig {\n  // Authentication\n  apiKey?: string;\n  accessToken?: string;\n  refreshToken?: string;\n  tokenExpiresAt?: number;\n  userId?: string;\n  email?: string;\n\n  // Environment\n  environment: \"test\" | \"live\";\n  baseUrl: string;\n\n  // Preferences\n  defaultFormat: \"human\" | \"json\";\n  colorEnabled: boolean;\n\n  // Network\n  timeout: number;\n  maxRetries: number;\n\n  // Organization\n  currentOrgId?: string;\n  currentOrgName?: string;\n  currentOrgSlug?: string;\n}\n\n/**\n * Check if running in CI environment\n */\nexport function isCI(): boolean {\n  return !!(\n    process.env.CI ||\n    process.env.CONTINUOUS_INTEGRATION ||\n    process.env.GITHUB_ACTIONS ||\n    process.env.GITLAB_CI ||\n    process.env.CIRCLECI ||\n    process.env.TRAVIS ||\n    process.env.BUILDKITE\n  );\n}\n\n/**\n * Check if color output is disabled\n */\nexport function isColorDisabled(): boolean {\n  return !!(\n    process.env.SENDLY_NO_COLOR ||\n    process.env.NO_COLOR ||\n    process.env.TERM === \"dumb\"\n  );\n}\n\nconst CONFIG_DIR = path.join(os.homedir(), \".sendly\");\nconst CONFIG_FILE = \"config.json\";\n\n// Old default key - used for migration only\nconst OLD_DEFAULT_KEY = \"sendly-cli-default-key-v1\";\n\n/**\n * Derive a machine-specific encryption key.\n * This ensures each installation has a unique key that can't be easily guessed.\n *\n * The key is derived from machine-specific identifiers that are:\n * - Unique per machine\n * - Stable across sessions\n * - Not publicly known\n */\nfunction deriveEncryptionKey(): string {\n  const machineId = [os.hostname(), os.userInfo().username, os.homedir()].join(\n    \":\",\n  );\n\n  return crypto\n    .createHash(\"sha256\")\n    .update(`sendly:${machineId}:v2`)\n    .digest(\"hex\");\n}\n\n/**\n * Get the encryption key to use for config.\n * Priority: SENDLY_CONFIG_KEY env var > machine-derived key\n */\nfunction getEncryptionKey(): string {\n  // Explicit key takes precedence (for CI/CD, testing, advanced users)\n  if (process.env.SENDLY_CONFIG_KEY) {\n    return process.env.SENDLY_CONFIG_KEY;\n  }\n  return deriveEncryptionKey();\n}\n\n// Ensure config directory exists with secure permissions\nif (!fs.existsSync(CONFIG_DIR)) {\n  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });\n}\n\nconst DEFAULT_CONFIG: SendlyConfig = {\n  environment: \"test\",\n  baseUrl: \"https://sendly.live\",\n  defaultFormat: \"human\",\n  colorEnabled: true,\n  timeout: 30000,\n  maxRetries: 3,\n};\n\n/**\n * Initialize config with automatic migration from old encryption key.\n * This ensures existing users don't lose their credentials.\n */\nfunction initializeConfig(): Conf<SendlyConfig> {\n  const newKey = getEncryptionKey();\n\n  // Try to initialize with new key first\n  try {\n    const newConfig = new Conf<SendlyConfig>({\n      projectName: \"sendly\",\n      cwd: CONFIG_DIR,\n      configName: \"config\",\n      defaults: DEFAULT_CONFIG,\n      encryptionKey: newKey,\n    });\n\n    // Try to read a value to verify decryption works\n    newConfig.get(\"environment\");\n    return newConfig;\n  } catch {\n    // New key didn't work - try migration from old key\n  }\n\n  // Migration: Try to read with old default key\n  try {\n    const oldConfig = new Conf<SendlyConfig>({\n      projectName: \"sendly\",\n      cwd: CONFIG_DIR,\n      configName: \"config\",\n      defaults: DEFAULT_CONFIG,\n      encryptionKey: OLD_DEFAULT_KEY,\n    });\n\n    // Read all data with old key\n    const oldData = { ...oldConfig.store };\n    const hasData = Object.keys(oldData).some(\n      (k) =>\n        !Object.keys(DEFAULT_CONFIG).includes(k) ||\n        oldData[k as keyof SendlyConfig] !==\n          DEFAULT_CONFIG[k as keyof SendlyConfig],\n    );\n\n    if (hasData) {\n      // Clear old config file\n      oldConfig.clear();\n\n      // Create new config with new key\n      const newConfig = new Conf<SendlyConfig>({\n        projectName: \"sendly\",\n        cwd: CONFIG_DIR,\n        configName: \"config\",\n        defaults: DEFAULT_CONFIG,\n        encryptionKey: newKey,\n      });\n\n      // Restore data with new encryption\n      for (const [key, value] of Object.entries(oldData)) {\n        if (value !== undefined) {\n          newConfig.set(key as keyof SendlyConfig, value);\n        }\n      }\n\n      return newConfig;\n    }\n  } catch {\n    // Old key also didn't work - corrupted or fresh install\n  }\n\n  // Fresh install or corrupted. If a config file exists at this point,\n  // both the new key and the old key failed to decrypt it — that means\n  // the file was written by a different machine, encrypted with a\n  // SENDLY_CONFIG_KEY that no longer matches, or got corrupted.\n  // Constructing a new Conf{} here would just re-read the same file and\n  // throw the same SyntaxError. Move it aside so the user keeps a copy\n  // (in case they recover the key later) and start clean.\n  const filePath = path.join(CONFIG_DIR, CONFIG_FILE);\n  if (fs.existsSync(filePath)) {\n    try {\n      const backupPath = `${filePath}.corrupt.${Date.now()}`;\n      fs.renameSync(filePath, backupPath);\n      // Stay quiet by default — most callers run early in the process\n      // before output helpers are wired. A debug breadcrumb is enough.\n      if (process.env.DEBUG) {\n        process.stderr.write(\n          `[sendly] Could not decrypt ${filePath}; moved to ${backupPath} and starting fresh. Run 'sendly login' to re-authenticate.\\n`,\n        );\n      }\n    } catch {\n      // If we can't move the file (permissions, FS issue), our best\n      // remaining option is to delete it — losing it is strictly better\n      // than crashing every command.\n      try {\n        fs.unlinkSync(filePath);\n      } catch {\n        // Give up silently and let Conf throw if it must.\n      }\n    }\n  }\n\n  return new Conf<SendlyConfig>({\n    projectName: \"sendly\",\n    cwd: CONFIG_DIR,\n    configName: \"config\",\n    defaults: DEFAULT_CONFIG,\n    encryptionKey: newKey,\n  });\n}\n\nconst config = initializeConfig();\n\n/**\n * Get effective config value with environment variable override\n * Priority: env var > config file > default\n */\nexport function getEffectiveValue<K extends keyof SendlyConfig>(\n  key: K,\n): SendlyConfig[K] {\n  // Environment variable overrides\n  switch (key) {\n    case \"apiKey\":\n      if (process.env.SENDLY_API_KEY) {\n        return process.env.SENDLY_API_KEY as SendlyConfig[K];\n      }\n      break;\n    case \"baseUrl\":\n      if (process.env.SENDLY_BASE_URL) {\n        return process.env.SENDLY_BASE_URL as SendlyConfig[K];\n      }\n      break;\n    case \"defaultFormat\":\n      if (process.env.SENDLY_OUTPUT_FORMAT) {\n        const format = process.env.SENDLY_OUTPUT_FORMAT.toLowerCase();\n        if (format === \"json\" || format === \"human\") {\n          return format as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"colorEnabled\":\n      if (isColorDisabled()) {\n        return false as SendlyConfig[K];\n      }\n      break;\n    case \"timeout\":\n      if (process.env.SENDLY_TIMEOUT) {\n        const timeout = parseInt(process.env.SENDLY_TIMEOUT, 10);\n        if (!isNaN(timeout) && timeout > 0) {\n          return timeout as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"maxRetries\":\n      if (process.env.SENDLY_MAX_RETRIES) {\n        const retries = parseInt(process.env.SENDLY_MAX_RETRIES, 10);\n        if (!isNaN(retries) && retries >= 0) {\n          return retries as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"currentOrgId\":\n      if (process.env.SENDLY_ORG_ID) {\n        return process.env.SENDLY_ORG_ID as SendlyConfig[K];\n      }\n      break;\n  }\n\n  // Fall back to config file value\n  return config.get(key);\n}\n\nexport function getConfig(): SendlyConfig {\n  return config.store;\n}\n\nexport function setConfig<K extends keyof SendlyConfig>(\n  key: K,\n  value: SendlyConfig[K],\n): void {\n  config.set(key, value);\n}\n\nexport function getConfigValue<K extends keyof SendlyConfig>(\n  key: K,\n): SendlyConfig[K] {\n  return config.get(key);\n}\n\nexport function clearConfig(): void {\n  config.clear();\n}\n\nexport function clearAuth(): void {\n  config.delete(\"apiKey\");\n  config.delete(\"accessToken\");\n  config.delete(\"refreshToken\");\n  config.delete(\"tokenExpiresAt\");\n  config.delete(\"userId\");\n  config.delete(\"email\");\n}\n\nexport function isAuthenticated(): boolean {\n  // Check env var first\n  if (process.env.SENDLY_API_KEY) return true;\n\n  const apiKey = config.get(\"apiKey\");\n  const accessToken = config.get(\"accessToken\");\n  return !!(apiKey || accessToken);\n}\n\nexport function getAuthToken(): string | undefined {\n  // Environment variable takes highest precedence\n  if (process.env.SENDLY_API_KEY) {\n    return process.env.SENDLY_API_KEY;\n  }\n\n  // Then stored API key\n  const apiKey = config.get(\"apiKey\");\n  if (apiKey) return apiKey;\n\n  // Finally, access token (if not expired)\n  const accessToken = config.get(\"accessToken\");\n  const expiresAt = config.get(\"tokenExpiresAt\");\n\n  if (accessToken && expiresAt && Date.now() < expiresAt) {\n    return accessToken;\n  }\n\n  return undefined;\n}\n\nexport function getStoredAccessToken(): string | undefined {\n  return config.get(\"accessToken\") || undefined;\n}\n\nexport function setApiKey(apiKey: string): void {\n  // Validate API key format\n  if (!/^sk_(test|live)_v1_[a-zA-Z0-9_-]+$/.test(apiKey)) {\n    throw new Error(\n      \"Invalid API key format. Expected sk_test_v1_xxx or sk_live_v1_xxx\",\n    );\n  }\n\n  config.set(\"apiKey\", apiKey);\n\n  // Set environment based on key type\n  if (apiKey.startsWith(\"sk_test_\")) {\n    config.set(\"environment\", \"test\");\n  } else {\n    config.set(\"environment\", \"live\");\n  }\n}\n\nexport function setAuthTokens(\n  accessToken: string,\n  refreshToken: string,\n  expiresIn: number,\n  userId: string,\n  email: string,\n): void {\n  config.set(\"accessToken\", accessToken);\n  config.set(\"refreshToken\", refreshToken);\n  config.set(\"tokenExpiresAt\", Date.now() + expiresIn * 1000);\n  config.set(\"userId\", userId);\n  config.set(\"email\", email);\n}\n\nexport function getConfigPath(): string {\n  return path.join(CONFIG_DIR, CONFIG_FILE);\n}\n\nexport function getConfigDir(): string {\n  return CONFIG_DIR;\n}\n\nexport function setCurrentOrg(id: string, name: string, slug?: string): void {\n  config.set(\"currentOrgId\", id);\n  config.set(\"currentOrgName\", name);\n  if (slug) config.set(\"currentOrgSlug\", slug);\n}\n\nexport function getCurrentOrg(): {\n  id: string;\n  name: string;\n  slug?: string;\n} | null {\n  const id = getEffectiveValue(\"currentOrgId\");\n  const name = config.get(\"currentOrgName\");\n  if (!id) return null;\n  return { id, name: name || id, slug: config.get(\"currentOrgSlug\") };\n}\n\nexport function clearCurrentOrg(): void {\n  config.delete(\"currentOrgId\");\n  config.delete(\"currentOrgName\");\n  config.delete(\"currentOrgSlug\");\n}\n\nexport { config };\n"]}

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

@@ -3,15 +3,19 @@
  * 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.
+ *   - Homebrew — from the SendlyHQ/homebrew-tap formula
+ *     (`brew install sendly-live/tap/sendly`). Detected by the resolved
+ *     binary path living under a Homebrew-owned prefix.
+ *   - npm global — `npm install -g @sendly/cli`. Detected by the
+ *     resolved binary path living under `node_modules`.
+ *
+ * The `HOMEBREW_CELLAR` env var is NOT a reliable signal on its own —
+ * it's set in every shell where Homebrew is on PATH, even when the CLI
+ * was installed via npm. Path-based detection is authoritative; the env
+ * var only acts as a tiebreaker for unusual layouts.
  *
  * 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.
+ * practice; the `upgrade` command handles it by printing both options.
  */
 export type InstallPath = "homebrew" | "npm" | "unknown";
 export declare function detectInstallPath(): InstallPath;

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

@@ -1,3 +1,4 @@
+import * as fs from "node:fs";
 const HOMEBREW_PREFIX_MARKERS = [
     "/opt/homebrew/",
     "/usr/local/Cellar/",
@@ -5,21 +6,36 @@ const HOMEBREW_PREFIX_MARKERS = [
     "/Cellar/",
 ];
 export function detectInstallPath() {
-    // Strongest signal — the env var that `brew shellenv` sets.
-    if (process.env.HOMEBREW_CELLAR) {
-        return "homebrew";
+    // The resolved binary path is the only authoritative signal of how
+    // this CLI was installed. `process.argv[1]` is the entry script — npm
+    // globals live under `node_modules`, Homebrew installs live under a
+    // Cellar/brew prefix.
+    //
+    // Resolve symlinks so an `npm install -g` that drops a symlink in
+    // `~/.nvm/.../bin/sendly -> ../lib/node_modules/...` is correctly
+    // classified as "npm" via the resolved target, not "unknown" via the
+    // unresolved symlink.
+    const argv1 = process.argv[1] ?? "";
+    let binPath = argv1;
+    try {
+        if (argv1)
+            binPath = fs.realpathSync(argv1);
+    }
+    catch {
+        // realpath can fail on broken symlinks or weird FS layouts —
+        // fall back to the unresolved argv[1].
+        binPath = argv1;
     }
-    // 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";
+    // Path was inconclusive (e.g. running from a source checkout). Don't
+    // guess from `HOMEBREW_CELLAR` — its presence only proves brew exists
+    // on the machine, not that this CLI was installed by it. Return
+    // "unknown" so the upgrade command prints both options for the user.
     return "unknown";
 }
 /**
@@ -35,4 +51,4 @@ export function upgradeCommandFor(path) {
             return "npm install -g @sendly/cli@latest  # or: brew upgrade sendly";
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/keypress.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared interactive-terminal helpers: press-[c]-to-copy a URL to the
+ * clipboard and [q]/Ctrl-C to cancel while the CLI polls a remote action
+ * (browser login, hosted document upload / payment for number purchases).
+ *
+ * Both helpers were originally private to auth.ts; they now live here so
+ * the numbers buy flow can reuse the exact same UX without duplicating it.
+ */
+/**
+ * Wire up the copy-URL / cancel keybindings while polling a remote
+ * action. 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.
+ */
+export declare function attachLoginKeypressHandler(urlToCopy: string): () => void;
+/**
+ * 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.
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;

package/dist/lib/keypress.js

@@ -0,0 +1,103 @@
+/**
+ * Shared interactive-terminal helpers: press-[c]-to-copy a URL to the
+ * clipboard and [q]/Ctrl-C to cancel while the CLI polls a remote action
+ * (browser login, hosted document upload / payment for number purchases).
+ *
+ * Both helpers were originally private to auth.ts; they now live here so
+ * the numbers buy flow can reuse the exact same UX without duplicating it.
+ */
+import { colors } from "./output.js";
+/**
+ * Wire up the copy-URL / cancel keybindings while polling a remote
+ * action. 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.
+ */
+export 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  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.
+ */
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keypress.js","sourceRoot":"","sources":["../../src/lib/keypress.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Shared interactive-terminal helpers: press-[c]-to-copy a URL to the\n * clipboard and [q]/Ctrl-C to cancel while the CLI polls a remote action\n * (browser login, hosted document upload / payment for number purchases).\n *\n * Both helpers were originally private to auth.ts; they now live here so\n * the numbers buy flow can reuse the exact same UX without duplicating it.\n */\n\nimport { colors } from \"./output.js\";\n\n/**\n * Wire up the copy-URL / cancel keybindings while polling a remote\n * action. Only active on a real interactive TTY — in CI, piped stdin, or\n * when stdin.setRawMode is missing we no-op and return a cleanup that\n * 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 */\nexport function 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  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 */\nexport async 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"]}