@bragduck/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1212 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+import { config } from "dotenv";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, join } from "path";
+var __filename, __dirname, APP_NAME, DEFAULT_CONFIG, OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = dirname(__filename);
+    config({ path: join(__dirname, "..", "..", ".env") });
+    APP_NAME = "bragduck";
+    DEFAULT_CONFIG = {
+      apiBaseUrl: process.env.API_BASE_URL || "https://api.bragduck.com",
+      defaultCommitDays: 30,
+      autoVersionCheck: true
+    };
+    OAUTH_CONFIG = {
+      CLIENT_ID: "bragduck-cli",
+      CALLBACK_PATH: "/callback",
+      TIMEOUT_MS: 12e4,
+      // 2 minutes
+      MIN_PORT: 8e3,
+      MAX_PORT: 9e3
+    };
+    API_ENDPOINTS = {
+      AUTH: {
+        INITIATE: "/v1/auth/cli/initiate",
+        TOKEN: "/v1/auth/cli/token"
+      },
+      COMMITS: {
+        REFINE: "/v1/commits/refine"
+      },
+      BRAGS: {
+        CREATE: "/v1/brags",
+        LIST: "/v1/brags"
+      },
+      VERSION: "/v1/cli/version"
+    };
+    ENCRYPTION_CONFIG = {
+      ALGORITHM: "aes-256-gcm",
+      KEY_LENGTH: 32,
+      IV_LENGTH: 16,
+      AUTH_TAG_LENGTH: 16,
+      SALT_LENGTH: 32
+    };
+    STORAGE_PATHS = {
+      CREDENTIALS_DIR: ".bragduck",
+      CREDENTIALS_FILE: "credentials.enc",
+      CONFIG_FILE: "config.json"
+    };
+    HTTP_STATUS = {
+      OK: 200,
+      CREATED: 201,
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      INTERNAL_SERVER_ERROR: 500
+    };
+  }
+});
+
+// src/services/storage.service.ts
+import Conf from "conf";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var StorageService, storageService;
+var init_storage_service = __esm({
+  "src/services/storage.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    StorageService = class {
+      config;
+      storageBackend;
+      credentialsDir;
+      credentialsFilePath;
+      constructor() {
+        this.config = new Conf({
+          projectName: APP_NAME,
+          defaults: DEFAULT_CONFIG
+        });
+        this.credentialsDir = join2(homedir(), STORAGE_PATHS.CREDENTIALS_DIR);
+        this.credentialsFilePath = join2(this.credentialsDir, STORAGE_PATHS.CREDENTIALS_FILE);
+        this.storageBackend = "file";
+        this.ensureCredentialsDir();
+      }
+      /**
+       * Ensure credentials directory exists
+       */
+      ensureCredentialsDir() {
+        if (!existsSync(this.credentialsDir)) {
+          mkdirSync(this.credentialsDir, { recursive: true, mode: 448 });
+        }
+      }
+      /**
+       * Encrypt data for file storage
+       */
+      encrypt(data, key) {
+        const iv = randomBytes(ENCRYPTION_CONFIG.IV_LENGTH);
+        const cipher = createCipheriv(ENCRYPTION_CONFIG.ALGORITHM, key, iv, {
+          authTagLength: ENCRYPTION_CONFIG.AUTH_TAG_LENGTH
+        });
+        let encrypted = cipher.update(data, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        const authTag = cipher.getAuthTag();
+        return {
+          encrypted,
+          iv: iv.toString("hex"),
+          authTag: authTag.toString("hex"),
+          salt: ""
+          // Salt is stored separately
+        };
+      }
+      /**
+       * Decrypt data from file storage
+       */
+      decrypt(encryptedData, key) {
+        const decipher = createDecipheriv(
+          ENCRYPTION_CONFIG.ALGORITHM,
+          key,
+          Buffer.from(encryptedData.iv, "hex"),
+          {
+            authTagLength: ENCRYPTION_CONFIG.AUTH_TAG_LENGTH
+          }
+        );
+        decipher.setAuthTag(Buffer.from(encryptedData.authTag, "hex"));
+        let decrypted = decipher.update(encryptedData.encrypted, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+      }
+      /**
+       * Derive encryption key from machine-specific data
+       */
+      deriveEncryptionKey(salt) {
+        const password = `${APP_NAME}-${homedir()}-${process.platform}`;
+        return scryptSync(password, salt, ENCRYPTION_CONFIG.KEY_LENGTH);
+      }
+      /**
+       * Store credentials using encrypted file storage
+       */
+      async setCredentials(credentials) {
+        const data = JSON.stringify(credentials);
+        const salt = randomBytes(ENCRYPTION_CONFIG.SALT_LENGTH);
+        const key = this.deriveEncryptionKey(salt);
+        const encrypted = this.encrypt(data, key);
+        encrypted.salt = salt.toString("hex");
+        writeFileSync(this.credentialsFilePath, JSON.stringify(encrypted), {
+          mode: 384,
+          encoding: "utf8"
+        });
+      }
+      /**
+       * Retrieve credentials from encrypted file storage
+       */
+      async getCredentials() {
+        if (!existsSync(this.credentialsFilePath)) {
+          return null;
+        }
+        try {
+          const encryptedData = JSON.parse(
+            readFileSync(this.credentialsFilePath, "utf8")
+          );
+          const salt = Buffer.from(encryptedData.salt, "hex");
+          const key = this.deriveEncryptionKey(salt);
+          const decrypted = this.decrypt(encryptedData, key);
+          return JSON.parse(decrypted);
+        } catch (error) {
+          console.error("Failed to decrypt credentials:", error);
+          return null;
+        }
+      }
+      /**
+       * Delete credentials from file storage
+       */
+      async deleteCredentials() {
+        if (existsSync(this.credentialsFilePath)) {
+          try {
+            unlinkSync(this.credentialsFilePath);
+          } catch (error) {
+            console.error("Failed to delete credentials file:", error);
+          }
+        }
+      }
+      /**
+       * Check if user is authenticated
+       */
+      async isAuthenticated() {
+        const credentials = await this.getCredentials();
+        if (!credentials || !credentials.accessToken) {
+          return false;
+        }
+        if (credentials.expiresAt && credentials.expiresAt < Date.now()) {
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Store user information
+       */
+      setUserInfo(userInfo) {
+        this.config.set("userInfo", userInfo);
+      }
+      /**
+       * Get user information
+       */
+      getUserInfo() {
+        return this.config.get("userInfo") || null;
+      }
+      /**
+       * Delete user information
+       */
+      deleteUserInfo() {
+        this.config.delete("userInfo");
+      }
+      /**
+       * Store OAuth state for CSRF protection
+       */
+      setOAuthState(state) {
+        this.config.set("oauthState", state);
+      }
+      /**
+       * Get OAuth state
+       */
+      getOAuthState() {
+        return this.config.get("oauthState") || null;
+      }
+      /**
+       * Delete OAuth state
+       */
+      deleteOAuthState() {
+        this.config.delete("oauthState");
+      }
+      /**
+       * Get configuration value
+       */
+      getConfig(key) {
+        return this.config.get(key);
+      }
+      /**
+       * Set configuration value
+       */
+      setConfig(key, value) {
+        this.config.set(key, value);
+      }
+      /**
+       * Get all configuration
+       */
+      getAllConfig() {
+        return this.config.store;
+      }
+      /**
+       * Reset configuration to defaults
+       */
+      resetConfig() {
+        this.config.clear();
+        Object.entries(DEFAULT_CONFIG).forEach(([key, value]) => {
+          this.config.set(key, value);
+        });
+      }
+      /**
+       * Get current storage backend
+       */
+      getStorageBackend() {
+        return this.storageBackend;
+      }
+      /**
+       * Clear all stored data (credentials + config)
+       */
+      async clearAll() {
+        await this.deleteCredentials();
+        this.deleteUserInfo();
+        this.deleteOAuthState();
+        this.resetConfig();
+      }
+    };
+    storageService = new StorageService();
+  }
+});
+
+// src/utils/errors.ts
+var BragduckError, AuthenticationError, ApiError, NetworkError, OAuthError, TokenExpiredError;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    BragduckError = class extends Error {
+      constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "BragduckError";
+        Error.captureStackTrace(this, this.constructor);
+      }
+    };
+    AuthenticationError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "AUTH_ERROR", details);
+        this.name = "AuthenticationError";
+      }
+    };
+    ApiError = class extends BragduckError {
+      constructor(message, statusCode, details) {
+        super(message, "API_ERROR", details);
+        this.statusCode = statusCode;
+        this.name = "ApiError";
+      }
+    };
+    NetworkError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "NETWORK_ERROR", details);
+        this.name = "NetworkError";
+      }
+    };
+    OAuthError = class extends AuthenticationError {
+      constructor(message, details) {
+        super(message, details);
+        this.name = "OAuthError";
+      }
+    };
+    TokenExpiredError = class extends AuthenticationError {
+      constructor(message = "Authentication token has expired") {
+        super(message);
+        this.name = "TokenExpiredError";
+        this.code = "TOKEN_EXPIRED";
+      }
+    };
+  }
+});
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger = {
+      /**
+       * Debug message (only shown when DEBUG env var is set)
+       */
+      debug: (message, ...args) => {
+        if (process.env.DEBUG) {
+          console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+        }
+      },
+      /**
+       * Info message
+       */
+      info: (message) => {
+        console.log(chalk.blue(`\u2139 ${message}`));
+      },
+      /**
+       * Success message
+       */
+      success: (message) => {
+        console.log(chalk.green(`\u2713 ${message}`));
+      },
+      /**
+       * Warning message
+       */
+      warning: (message) => {
+        console.warn(chalk.yellow(`\u26A0 ${message}`));
+      },
+      /**
+       * Error message
+       */
+      error: (message) => {
+        console.error(chalk.red(`\u2717 ${message}`));
+      },
+      /**
+       * Plain log without formatting
+       */
+      log: (message) => {
+        console.log(message);
+      }
+    };
+  }
+});
+
+// src/utils/oauth-server.ts
+import { createServer } from "http";
+import { parse } from "url";
+async function findAvailablePort() {
+  const { MIN_PORT, MAX_PORT } = OAUTH_CONFIG;
+  for (let port = MIN_PORT; port <= MAX_PORT; port++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const testServer = createServer();
+        testServer.once("error", reject);
+        testServer.once("listening", () => {
+          testServer.close(() => resolve());
+        });
+        testServer.listen(port, "127.0.0.1");
+      });
+      return port;
+    } catch (error) {
+      continue;
+    }
+  }
+  throw new OAuthError(`No available ports found in range ${MIN_PORT}-${MAX_PORT}`);
+}
+async function startOAuthCallbackServer(expectedState) {
+  const port = await findAvailablePort();
+  const timeout = OAUTH_CONFIG.TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let server = null;
+    let timeoutId;
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (server) {
+        if (typeof server.closeAllConnections === "function") {
+          server.closeAllConnections();
+        }
+        server.close(() => {
+          logger.debug("OAuth server closed");
+        });
+        server.unref();
+      }
+    };
+    const handleRequest = (req, res) => {
+      const parsedUrl = parse(req.url || "", true);
+      logger.debug(`OAuth callback received: ${req.url}`);
+      if (parsedUrl.pathname === OAUTH_CONFIG.CALLBACK_PATH) {
+        const { code, state, error, error_description } = parsedUrl.query;
+        if (error) {
+          const errorMsg = error_description || error;
+          logger.debug(`OAuth error: ${errorMsg}`);
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(ERROR_HTML(String(errorMsg)));
+          cleanup();
+          reject(new OAuthError(`OAuth error: ${errorMsg}`));
+          return;
+        }
+        if (!code || !state) {
+          const errorMsg = "Missing code or state parameter";
+          logger.debug(errorMsg);
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(ERROR_HTML(errorMsg));
+          cleanup();
+          reject(new OAuthError(errorMsg));
+          return;
+        }
+        if (state !== expectedState) {
+          const errorMsg = "Invalid state parameter (possible CSRF attack)";
+          logger.debug(errorMsg);
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(ERROR_HTML(errorMsg));
+          cleanup();
+          reject(new OAuthError(errorMsg));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(SUCCESS_HTML);
+        setTimeout(() => {
+          cleanup();
+          resolve({
+            code: String(code),
+            state: String(state),
+            port
+          });
+        }, 100);
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    };
+    server = createServer(handleRequest);
+    server.on("error", (error) => {
+      logger.debug(`OAuth server error: ${error.message}`);
+      cleanup();
+      reject(new OAuthError(`OAuth server error: ${error.message}`));
+    });
+    server.listen(port, "127.0.0.1", () => {
+      logger.debug(`OAuth callback server listening on http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`);
+    });
+    timeoutId = setTimeout(() => {
+      logger.debug("OAuth callback timeout");
+      cleanup();
+      reject(new OAuthError("Authentication timeout - no callback received within 2 minutes"));
+    }, timeout);
+  });
+}
+async function getCallbackUrl() {
+  const port = await findAvailablePort();
+  return `http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`;
+}
+var SUCCESS_HTML, ERROR_HTML;
+var init_oauth_server = __esm({
+  "src/utils/oauth-server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_errors();
+    init_logger();
+    SUCCESS_HTML = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bragduck - Authentication Successful</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 1rem;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+      max-width: 500px;
+    }
+    h1 {
+      font-size: 2.5rem;
+      margin: 0 0 1rem 0;
+    }
+    .checkmark {
+      font-size: 4rem;
+      animation: scale-in 0.3s ease-out;
+    }
+    p {
+      font-size: 1.2rem;
+      margin: 1rem 0;
+      opacity: 0.9;
+    }
+    @keyframes scale-in {
+      from { transform: scale(0); }
+      to { transform: scale(1); }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="checkmark">\u2713</div>
+    <h1>Authentication Successful!</h1>
+    <p>You can now close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>
+`;
+    ERROR_HTML = (error) => `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bragduck - Authentication Failed</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 1rem;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+      max-width: 500px;
+    }
+    h1 {
+      font-size: 2.5rem;
+      margin: 0 0 1rem 0;
+    }
+    .error-icon {
+      font-size: 4rem;
+    }
+    p {
+      font-size: 1.2rem;
+      margin: 1rem 0;
+      opacity: 0.9;
+    }
+    .error-details {
+      background: rgba(0, 0, 0, 0.2);
+      padding: 1rem;
+      border-radius: 0.5rem;
+      font-family: monospace;
+      font-size: 0.9rem;
+      margin-top: 1rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="error-icon">\u2717</div>
+    <h1>Authentication Failed</h1>
+    <p>Please return to your terminal and try again.</p>
+    <div class="error-details">${error}</div>
+  </div>
+</body>
+</html>
+`;
+  }
+});
+
+// src/utils/browser.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+async function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  switch (platform) {
+    case "darwin":
+      command = `open "${url}"`;
+      break;
+    case "win32":
+      command = `start "" "${url}"`;
+      break;
+    default:
+      command = `xdg-open "${url}"`;
+      break;
+  }
+  try {
+    logger.debug(`Opening browser with command: ${command}`);
+    await execAsync(command);
+    logger.debug("Browser opened successfully");
+  } catch (error) {
+    logger.debug(`Failed to open browser: ${error}`);
+    throw new Error(
+      `Failed to open browser automatically. Please open this URL manually:
+${url}`
+    );
+  }
+}
+var execAsync;
+var init_browser = __esm({
+  "src/utils/browser.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    execAsync = promisify(exec);
+  }
+});
+
+// src/services/auth.service.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { ofetch } from "ofetch";
+var AuthService, authService;
+var init_auth_service = __esm({
+  "src/services/auth.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_storage_service();
+    init_oauth_server();
+    init_browser();
+    init_errors();
+    init_logger();
+    AuthService = class {
+      apiBaseUrl;
+      constructor() {
+        this.apiBaseUrl = process.env.API_BASE_URL || storageService.getConfig("apiBaseUrl") || "https://api.bragduck.com";
+      }
+      /**
+       * Generate a random state string for CSRF protection
+       */
+      generateState() {
+        return randomBytes2(32).toString("hex");
+      }
+      /**
+       * Build the OAuth authorization URL
+       */
+      async buildAuthUrl(state, callbackUrl) {
+        const params = new URLSearchParams({
+          client_id: OAUTH_CONFIG.CLIENT_ID,
+          redirect_uri: callbackUrl,
+          state
+        });
+        return `${this.apiBaseUrl}${API_ENDPOINTS.AUTH.INITIATE}?${params.toString()}`;
+      }
+      /**
+       * Exchange authorization code for access token
+       */
+      async exchangeCodeForToken(code, callbackUrl) {
+        try {
+          logger.debug("Exchanging authorization code for token");
+          const response = await ofetch(
+            `${this.apiBaseUrl}${API_ENDPOINTS.AUTH.TOKEN}`,
+            {
+              method: "POST",
+              body: {
+                code,
+                redirect_uri: callbackUrl,
+                client_id: OAUTH_CONFIG.CLIENT_ID,
+                grant_type: "authorization_code"
+              },
+              headers: {
+                "Content-Type": "application/json"
+              }
+            }
+          );
+          logger.debug("Token exchange successful");
+          return response;
+        } catch (error) {
+          logger.debug(`Token exchange failed: ${error.message}`);
+          if (error.response) {
+            throw new AuthenticationError(
+              `Token exchange failed: ${error.response.statusText || "Unknown error"}`,
+              {
+                statusCode: error.response.status,
+                body: error.response._data
+              }
+            );
+          }
+          throw new NetworkError("Failed to connect to authentication server", {
+            originalError: error.message
+          });
+        }
+      }
+      /**
+       * Complete OAuth flow: start server, open browser, wait for callback, exchange token
+       */
+      async login() {
+        logger.debug("Starting OAuth login flow");
+        const state = this.generateState();
+        const callbackUrl = await getCallbackUrl();
+        storageService.setOAuthState({
+          state,
+          createdAt: Date.now()
+        });
+        logger.debug(`OAuth state: ${state}`);
+        logger.debug(`Callback URL: ${callbackUrl}`);
+        const authUrl = await this.buildAuthUrl(state, callbackUrl);
+        logger.debug(`Authorization URL: ${authUrl}`);
+        const serverPromise = startOAuthCallbackServer(state);
+        try {
+          await openBrowser(authUrl);
+        } catch (error) {
+          logger.warning("Could not open browser automatically");
+          logger.info(`Please open this URL in your browser:`);
+          logger.log(authUrl);
+        }
+        let callbackResult;
+        try {
+          callbackResult = await serverPromise;
+        } catch (error) {
+          storageService.deleteOAuthState();
+          throw error;
+        }
+        storageService.deleteOAuthState();
+        const tokenResponse = await this.exchangeCodeForToken(callbackResult.code, callbackUrl);
+        const expiresAt = tokenResponse.expires_in ? Date.now() + tokenResponse.expires_in * 1e3 : void 0;
+        const credentials = {
+          accessToken: tokenResponse.access_token,
+          refreshToken: tokenResponse.refresh_token,
+          expiresAt
+        };
+        await storageService.setCredentials(credentials);
+        if (tokenResponse.user) {
+          storageService.setUserInfo(tokenResponse.user);
+        }
+        logger.debug("Login successful");
+        return tokenResponse.user || { id: "unknown", email: "unknown", name: "Unknown User" };
+      }
+      /**
+       * Logout: clear all stored credentials and user info
+       */
+      async logout() {
+        logger.debug("Logging out");
+        await storageService.deleteCredentials();
+        storageService.deleteUserInfo();
+        storageService.deleteOAuthState();
+        logger.debug("Logout complete");
+      }
+      /**
+       * Check if user is authenticated
+       */
+      async isAuthenticated() {
+        return storageService.isAuthenticated();
+      }
+      /**
+       * Get current access token
+       */
+      async getAccessToken() {
+        const credentials = await storageService.getCredentials();
+        return credentials?.accessToken || null;
+      }
+      /**
+       * Get current user info
+       */
+      getUserInfo() {
+        return storageService.getUserInfo();
+      }
+      /**
+       * Refresh access token using refresh token
+       */
+      async refreshToken() {
+        logger.debug("Refreshing access token");
+        const credentials = await storageService.getCredentials();
+        if (!credentials?.refreshToken) {
+          throw new AuthenticationError("No refresh token available");
+        }
+        try {
+          const response = await ofetch(
+            `${this.apiBaseUrl}${API_ENDPOINTS.AUTH.TOKEN}`,
+            {
+              method: "POST",
+              body: {
+                refresh_token: credentials.refreshToken,
+                client_id: OAUTH_CONFIG.CLIENT_ID,
+                grant_type: "refresh_token"
+              },
+              headers: {
+                "Content-Type": "application/json"
+              }
+            }
+          );
+          const expiresAt = response.expires_in ? Date.now() + response.expires_in * 1e3 : void 0;
+          const newCredentials = {
+            accessToken: response.access_token,
+            refreshToken: response.refresh_token || credentials.refreshToken,
+            expiresAt
+          };
+          await storageService.setCredentials(newCredentials);
+          logger.debug("Token refresh successful");
+        } catch (error) {
+          logger.debug(`Token refresh failed: ${error.message}`);
+          await this.logout();
+          throw new AuthenticationError("Token refresh failed. Please log in again.");
+        }
+      }
+    };
+    authService = new AuthService();
+  }
+});
+
+// src/services/api.service.ts
+import { ofetch as ofetch2 } from "ofetch";
+var ApiService, apiService;
+var init_api_service = __esm({
+  "src/services/api.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_storage_service();
+    init_auth_service();
+    init_constants();
+    init_errors();
+    init_logger();
+    ApiService = class {
+      baseURL;
+      client;
+      constructor() {
+        this.baseURL = process.env.API_BASE_URL || storageService.getConfig("apiBaseUrl");
+        this.client = ofetch2.create({
+          baseURL: this.baseURL,
+          // Request interceptor
+          onRequest: async ({ options }) => {
+            logger.debug(`API Request: ${options.method} ${options.baseURL}${options.url}`);
+            const token = await authService.getAccessToken();
+            if (token) {
+              options.headers = {
+                ...options.headers,
+                Authorization: `Bearer ${token}`
+              };
+            }
+            if (options.method && ["POST", "PUT", "PATCH"].includes(options.method)) {
+              options.headers = {
+                ...options.headers,
+                "Content-Type": "application/json"
+              };
+            }
+          },
+          // Response interceptor for success
+          onResponse: ({ response }) => {
+            logger.debug(`API Response: ${response.status} ${response.statusText}`);
+          },
+          // Response interceptor for errors
+          onResponseError: async ({ response, options }) => {
+            const status = response.status;
+            const url = `${options.baseURL}${options.url}`;
+            logger.debug(`API Error: ${status} ${response.statusText} - ${url}`);
+            if (status === HTTP_STATUS.UNAUTHORIZED) {
+              logger.debug("Token expired, attempting refresh");
+              try {
+                await authService.refreshToken();
+                logger.debug("Token refreshed, retrying request");
+                throw new Error("RETRY_WITH_NEW_TOKEN");
+              } catch (error) {
+                if (error.message === "RETRY_WITH_NEW_TOKEN") {
+                  throw error;
+                }
+                throw new TokenExpiredError('Your session has expired. Please run "bragduck init" to login again.');
+              }
+            }
+            let errorMessage = "An unexpected error occurred";
+            let errorDetails;
+            try {
+              const errorData = response._data;
+              if (errorData && errorData.message) {
+                errorMessage = errorData.message;
+                errorDetails = errorData.details;
+              }
+            } catch {
+              errorMessage = response.statusText || errorMessage;
+            }
+            throw new ApiError(errorMessage, status, errorDetails);
+          },
+          // Retry configuration
+          retry: 2,
+          retryDelay: 1e3,
+          retryStatusCodes: [408, 409, 425, 429, 500, 502, 503, 504],
+          // Timeout
+          timeout: 3e4
+          // 30 seconds
+        });
+      }
+      /**
+       * Make API request with retry for token refresh
+       */
+      async makeRequest(url, options = {}) {
+        try {
+          return await this.client(url, options);
+        } catch (error) {
+          if (error.message === "RETRY_WITH_NEW_TOKEN") {
+            logger.debug("Retrying request with refreshed token");
+            return await this.client(url, options);
+          }
+          if (error.name === "FetchError" || error.code === "ECONNREFUSED") {
+            throw new NetworkError("Failed to connect to Bragduck API", {
+              originalError: error.message,
+              baseURL: this.baseURL
+            });
+          }
+          throw error;
+        }
+      }
+      /**
+       * Refine commits using AI
+       */
+      async refineCommits(request) {
+        logger.debug(`Refining ${request.commits.length} commits`);
+        try {
+          const response = await this.makeRequest(
+            API_ENDPOINTS.COMMITS.REFINE,
+            {
+              method: "POST",
+              body: request
+            }
+          );
+          logger.debug(`Successfully refined ${response.refined_commits.length} commits`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to refine commits");
+          throw error;
+        }
+      }
+      /**
+       * Create brags from refined commits
+       */
+      async createBrags(request) {
+        logger.debug(`Creating ${request.brags.length} brags`);
+        try {
+          const response = await this.makeRequest(
+            API_ENDPOINTS.BRAGS.CREATE,
+            {
+              method: "POST",
+              body: request
+            }
+          );
+          logger.debug(`Successfully created ${response.created} brags`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to create brags");
+          throw error;
+        }
+      }
+      /**
+       * List existing brags
+       */
+      async listBrags(params = {}) {
+        const { limit = 50, offset = 0, tags, search } = params;
+        logger.debug(`Listing brags: limit=${limit}, offset=${offset}`);
+        try {
+          const queryParams = new URLSearchParams({
+            limit: limit.toString(),
+            offset: offset.toString()
+          });
+          if (search) {
+            queryParams.append("search", search);
+          }
+          if (tags && tags.length > 0) {
+            tags.forEach((tag) => queryParams.append("tags[]", tag));
+          }
+          const url = `${API_ENDPOINTS.BRAGS.LIST}?${queryParams.toString()}`;
+          const response = await this.makeRequest(url, {
+            method: "GET"
+          });
+          logger.debug(`Successfully fetched ${response.brags.length} brags (total: ${response.total})`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to list brags");
+          throw error;
+        }
+      }
+      /**
+       * Check for CLI updates
+       */
+      async checkVersion() {
+        logger.debug("Checking for CLI updates");
+        try {
+          const response = await this.makeRequest(
+            API_ENDPOINTS.VERSION,
+            {
+              method: "GET"
+            }
+          );
+          logger.debug(`Latest version: ${response.latest_version}`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to check version");
+          const { version: version2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+          return {
+            latest_version: version2,
+            critical_update: false
+          };
+        }
+      }
+      /**
+       * Test API connectivity
+       */
+      async testConnection() {
+        try {
+          await this.checkVersion();
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * Update base URL
+       */
+      setBaseURL(url) {
+        this.baseURL = url;
+        storageService.setConfig("apiBaseUrl", url);
+        this.client = ofetch2.create({
+          baseURL: url
+        });
+      }
+      /**
+       * Get current base URL
+       */
+      getBaseURL() {
+        return this.baseURL;
+      }
+    };
+    apiService = new ApiService();
+  }
+});
+
+// src/utils/version.ts
+var version_exports = {};
+__export(version_exports, {
+  checkForUpdates: () => checkForUpdates,
+  compareVersions: () => compareVersions,
+  formatVersion: () => formatVersion,
+  getCurrentVersion: () => getCurrentVersion,
+  version: () => version
+});
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join3 } from "path";
+import chalk2 from "chalk";
+import boxen from "boxen";
+function getCurrentVersion() {
+  try {
+    const packageJsonPath = join3(__dirname3, "../../package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    return packageJson.version;
+  } catch (error) {
+    logger.debug("Failed to read package.json version");
+    return "1.0.0";
+  }
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map((p) => parseInt(p, 10));
+  const parts2 = v2.split(".").map((p) => parseInt(p, 10));
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 > part2) return 1;
+    if (part1 < part2) return -1;
+  }
+  return 0;
+}
+async function checkForUpdates(options = {}) {
+  const { silent = false, force = false } = options;
+  try {
+    if (!force) {
+      const autoVersionCheck = storageService.getConfig("autoVersionCheck");
+      if (!autoVersionCheck) {
+        logger.debug("Version check disabled in config");
+        return {
+          updateAvailable: false,
+          latestVersion: version,
+          currentVersion: version
+        };
+      }
+    }
+    logger.debug("Checking for CLI updates...");
+    const response = await apiService.checkVersion();
+    const latestVersion = response.latest_version;
+    const currentVersion = version;
+    logger.debug(`Current version: ${currentVersion}, Latest version: ${latestVersion}`);
+    const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+    if (!silent && updateAvailable) {
+      displayUpdateNotification(currentVersion, latestVersion, response.critical_update);
+    }
+    return {
+      updateAvailable,
+      latestVersion,
+      currentVersion
+    };
+  } catch (error) {
+    logger.debug(`Version check failed: ${error.message}`);
+    return {
+      updateAvailable: false,
+      latestVersion: version,
+      currentVersion: version
+    };
+  }
+}
+function displayUpdateNotification(currentVersion, latestVersion, critical = false) {
+  const urgency = critical ? chalk2.red.bold("CRITICAL UPDATE") : chalk2.yellow.bold("Update Available");
+  const message = `${urgency}
+
+Current version: ${chalk2.dim(currentVersion)}
+Latest version:  ${chalk2.green(latestVersion)}
+
+Update with: ${chalk2.cyan("npm install -g @bragduck/cli@latest")}`;
+  console.log("");
+  console.log(
+    boxen(message, {
+      padding: 1,
+      margin: { top: 0, right: 1, bottom: 0, left: 1 },
+      borderStyle: "round",
+      borderColor: critical ? "red" : "yellow"
+    })
+  );
+  console.log("");
+  if (critical) {
+    logger.warning("This is a critical update. Please update as soon as possible.");
+    console.log("");
+  }
+}
+function formatVersion(includePrefix = true) {
+  const prefix = includePrefix ? "v" : "";
+  return `${prefix}${version}`;
+}
+var __filename3, __dirname3, version;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_api_service();
+    init_storage_service();
+    init_logger();
+    __filename3 = fileURLToPath3(import.meta.url);
+    __dirname3 = dirname2(__filename3);
+    version = getCurrentVersion();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+init_version();
+export {
+  version
+};
+//# sourceMappingURL=index.js.map