@bragduck/cli 2.30.2 → 2.36.3

package/dist/bin/bragduck.js

@@ -22,7 +22,7 @@ var init_esm_shims = __esm({
 import { config } from "dotenv";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join } from "path";
-var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, ATLASSIAN_OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS, CONFIG_FILES;
+var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, ATLASSIAN_OAUTH_CONFIG, GOOGLE_OAUTH_CONFIG, SLACK_OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS, CONFIG_FILES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -65,6 +65,16 @@ var init_constants = __esm({
       ACCESSIBLE_RESOURCES_URL: "https://api.atlassian.com/oauth/token/accessible-resources",
       API_GATEWAY_URL: "https://api.atlassian.com"
     };
+    GOOGLE_OAUTH_CONFIG = {
+      CLIENT_ID: "1009691892834-l4hu4qce7jg4a6k1eh2kru0uov1a9fho.apps.googleusercontent.com",
+      AUTH_URL: "https://accounts.google.com/o/oauth2/v2/auth",
+      SCOPES: "https://www.googleapis.com/auth/drive.metadata.readonly"
+    };
+    SLACK_OAUTH_CONFIG = {
+      CLIENT_ID: "2492403850420.10637070025476",
+      AUTH_URL: "https://slack.com/oauth/v2/authorize",
+      USER_SCOPE: "search:read"
+    };
     API_ENDPOINTS = {
       AUTH: {
         INITIATE: "/v1/auth/cli/initiate",
@@ -74,6 +84,13 @@ var init_constants = __esm({
         TOKEN: "/v1/auth/atlassian/token",
         REFRESH: "/v1/auth/atlassian/refresh"
       },
+      GOOGLE: {
+        TOKEN: "/v1/auth/google/token",
+        REFRESH: "/v1/auth/google/refresh"
+      },
+      SLACK: {
+        TOKEN: "/v1/auth/slack/token"
+      },
       BRAGS: {
         CREATE: "/v1/brags",
         LIST: "/v1/brags",
@@ -169,7 +186,7 @@ var init_env_loader = __esm({
 });
 
 // src/utils/errors.ts
-var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError, AtlassianError;
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError, AtlassianError, GoogleDocsError, SlackError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -266,6 +283,18 @@ var init_errors = __esm({
         this.name = "AtlassianError";
       }
     };
+    GoogleDocsError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GOOGLE_DOCS_ERROR", details);
+        this.name = "GoogleDocsError";
+      }
+    };
+    SlackError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "SLACK_ERROR", details);
+        this.name = "SlackError";
+      }
+    };
   }
 });
 
@@ -1042,7 +1071,7 @@ var init_browser = __esm({
 // src/services/auth.service.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath3, URLSearchParams } from "url";
+import { fileURLToPath as fileURLToPath3, URLSearchParams as URLSearchParams2 } from "url";
 import { dirname as dirname2, join as join3 } from "path";
 import { ofetch } from "ofetch";
 function getUserAgent() {
@@ -1086,7 +1115,7 @@ var init_auth_service = __esm({
        * Build the OAuth authorization URL
        */
       async buildAuthUrl(state, callbackUrl) {
-        const params = new URLSearchParams({
+        const params = new URLSearchParams2({
           client_id: OAUTH_CONFIG.CLIENT_ID,
           redirect_uri: callbackUrl,
           state
@@ -1261,15 +1290,15 @@ __export(version_exports, {
   getCurrentVersion: () => getCurrentVersion,
   version: () => version
 });
-import { readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname4, join as join6 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { dirname as dirname6, join as join8 } from "path";
 import chalk4 from "chalk";
 import boxen2 from "boxen";
 function getCurrentVersion() {
   try {
-    const packageJsonPath2 = join6(__dirname5, "../../package.json");
-    const packageJson2 = JSON.parse(readFileSync4(packageJsonPath2, "utf-8"));
+    const packageJsonPath2 = join8(__dirname7, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync6(packageJsonPath2, "utf-8"));
     return packageJson2.version;
   } catch {
     logger.debug("Failed to read package.json version");
@@ -1351,7 +1380,7 @@ function formatVersion(includePrefix = true) {
   const prefix = includePrefix ? "v" : "";
   return `${prefix}${version}`;
 }
-var __filename5, __dirname5, version;
+var __filename7, __dirname7, version;
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
@@ -1359,22 +1388,22 @@ var init_version = __esm({
     init_api_service();
     init_storage_service();
     init_logger();
-    __filename5 = fileURLToPath5(import.meta.url);
-    __dirname5 = dirname4(__filename5);
+    __filename7 = fileURLToPath7(import.meta.url);
+    __dirname7 = dirname6(__filename7);
     version = getCurrentVersion();
   }
 });
 
 // src/services/api.service.ts
-import { ofetch as ofetch3 } from "ofetch";
-import { readFileSync as readFileSync5 } from "fs";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { URLSearchParams as URLSearchParams3 } from "url";
-import { dirname as dirname5, join as join7 } from "path";
+import { ofetch as ofetch5 } from "ofetch";
+import { readFileSync as readFileSync7 } from "fs";
+import { fileURLToPath as fileURLToPath8 } from "url";
+import { URLSearchParams as URLSearchParams6 } from "url";
+import { dirname as dirname7, join as join9 } from "path";
 function getCliVersion() {
   try {
-    const packageJsonPath2 = join7(__dirname6, "../../package.json");
-    const packageJson2 = JSON.parse(readFileSync5(packageJsonPath2, "utf-8"));
+    const packageJsonPath2 = join9(__dirname8, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync7(packageJsonPath2, "utf-8"));
     return packageJson2.version;
   } catch {
     logger.debug("Failed to read package.json version");
@@ -1386,7 +1415,7 @@ function getPlatformInfo() {
   const arch = process.arch;
   return `${platform}-${arch}`;
 }
-var __filename6, __dirname6, ApiService, apiService;
+var __filename8, __dirname8, ApiService, apiService;
 var init_api_service = __esm({
   "src/services/api.service.ts"() {
     "use strict";
@@ -1395,14 +1424,14 @@ var init_api_service = __esm({
     init_constants();
     init_errors();
     init_logger();
-    __filename6 = fileURLToPath6(import.meta.url);
-    __dirname6 = dirname5(__filename6);
+    __filename8 = fileURLToPath8(import.meta.url);
+    __dirname8 = dirname7(__filename8);
     ApiService = class {
       baseURL;
       client;
       constructor() {
         this.baseURL = process.env.API_BASE_URL || "https://api.bragduck.com";
-        this.client = ofetch3.create({
+        this.client = ofetch5.create({
           baseURL: this.baseURL,
           // Request interceptor
           onRequest: async ({ request, options }) => {
@@ -1566,7 +1595,7 @@ var init_api_service = __esm({
         const { limit = 50, offset = 0, tags, search } = params;
         logger.debug(`Listing brags: limit=${limit}, offset=${offset}`);
         try {
-          const queryParams = new URLSearchParams3({
+          const queryParams = new URLSearchParams6({
             limit: limit.toString(),
             offset: offset.toString()
           });
@@ -1663,7 +1692,7 @@ var init_api_service = __esm({
        */
       setBaseURL(url) {
         this.baseURL = url;
-        this.client = ofetch3.create({
+        this.client = ofetch5.create({
           baseURL: url
         });
       }
@@ -1681,9 +1710,9 @@ var init_api_service = __esm({
 // src/cli.ts
 init_esm_shims();
 import { Command } from "commander";
-import { readFileSync as readFileSync6 } from "fs";
-import { fileURLToPath as fileURLToPath7 } from "url";
-import { dirname as dirname6, join as join8 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { fileURLToPath as fileURLToPath9 } from "url";
+import { dirname as dirname8, join as join10 } from "path";
 
 // src/commands/auth.ts
 init_esm_shims();
@@ -1702,7 +1731,7 @@ init_errors();
 init_logger();
 import { randomBytes as randomBytes3 } from "crypto";
 import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath as fileURLToPath4, URLSearchParams as URLSearchParams2 } from "url";
+import { fileURLToPath as fileURLToPath4, URLSearchParams as URLSearchParams3 } from "url";
 import { dirname as dirname3, join as join4 } from "path";
 import { ofetch as ofetch2 } from "ofetch";
 import { select } from "@inquirer/prompts";
@@ -1737,7 +1766,7 @@ var AtlassianAuthService = class {
    * Build the Atlassian OAuth authorization URL
    */
   buildAuthUrl(state, callbackUrl) {
-    const params = new URLSearchParams2({
+    const params = new URLSearchParams3({
       audience: ATLASSIAN_OAUTH_CONFIG.AUDIENCE,
       client_id: ATLASSIAN_OAUTH_CONFIG.CLIENT_ID,
       scope: ATLASSIAN_OAUTH_CONFIG.SCOPES,
@@ -1938,6 +1967,348 @@ var AtlassianAuthService = class {
 };
 var atlassianAuthService = new AtlassianAuthService();
 
+// src/services/google-auth.service.ts
+init_esm_shims();
+init_constants();
+init_storage_service();
+init_oauth_server();
+init_browser();
+init_errors();
+init_logger();
+import { randomBytes as randomBytes4 } from "crypto";
+import { readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath as fileURLToPath5, URLSearchParams as URLSearchParams4 } from "url";
+import { dirname as dirname4, join as join5 } from "path";
+import { ofetch as ofetch3 } from "ofetch";
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname5 = dirname4(__filename5);
+function getUserAgent3() {
+  try {
+    const packageJsonPath2 = join5(__dirname5, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync4(packageJsonPath2, "utf-8"));
+    const version2 = packageJson2.version;
+    const platform = process.platform;
+    const arch = process.arch;
+    return `BragDuck-CLI/${version2} (${platform}-${arch})`;
+  } catch {
+    logger.debug("Failed to read package.json version");
+    return "BragDuck-CLI/2.0.0";
+  }
+}
+var GoogleAuthService = class {
+  apiBaseUrl;
+  refreshPromise = null;
+  constructor() {
+    this.apiBaseUrl = process.env.API_BASE_URL || "https://api.bragduck.com";
+  }
+  /**
+   * Generate a random state string for CSRF protection
+   */
+  generateState() {
+    return randomBytes4(32).toString("hex");
+  }
+  /**
+   * Build the Google OAuth authorization URL
+   */
+  buildAuthUrl(state, callbackUrl) {
+    const params = new URLSearchParams4({
+      client_id: GOOGLE_OAUTH_CONFIG.CLIENT_ID,
+      scope: GOOGLE_OAUTH_CONFIG.SCOPES,
+      redirect_uri: callbackUrl,
+      state,
+      response_type: "code",
+      access_type: "offline",
+      prompt: "consent"
+    });
+    return `${GOOGLE_OAUTH_CONFIG.AUTH_URL}?${params.toString()}`;
+  }
+  /**
+   * Exchange authorization code for tokens via BragDuck backend
+   */
+  async exchangeCodeForToken(code, redirectUri) {
+    try {
+      const tokenUrl = `${this.apiBaseUrl}${API_ENDPOINTS.GOOGLE.TOKEN}`;
+      logger.debug(`Exchanging Google authorization code via: ${tokenUrl}`);
+      const response = await ofetch3(tokenUrl, {
+        method: "POST",
+        body: {
+          code,
+          redirect_uri: redirectUri
+        },
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": getUserAgent3()
+        }
+      });
+      logger.debug("Google token exchange successful");
+      return response;
+    } catch (error) {
+      const detail = error?.data?.message || error?.data?.error_description || error.message;
+      logger.debug(`Google token exchange failed: ${detail}`);
+      throw new GoogleDocsError(`Failed to exchange Google authorization code: ${detail}`);
+    }
+  }
+  /**
+   * Full OAuth login flow:
+   * 1. Open browser to Google consent screen
+   * 2. Wait for callback with authorization code
+   * 3. Exchange code for tokens via BragDuck backend
+   * 4. Store credentials under 'google-docs'
+   */
+  async login() {
+    logger.debug("Starting Google OAuth login flow");
+    const state = this.generateState();
+    const { callbackUrl: rawCallbackUrl, resultPromise } = await startOAuthCallbackServer(state);
+    const callbackUrl = rawCallbackUrl.replace("127.0.0.1", "localhost");
+    storageService.setOAuthState({
+      state,
+      createdAt: Date.now()
+    });
+    logger.debug(`OAuth state: ${state}`);
+    logger.debug(`Callback URL: ${callbackUrl}`);
+    const authUrl = this.buildAuthUrl(state, callbackUrl);
+    logger.debug(`Authorization URL: ${authUrl}`);
+    try {
+      await openBrowser(authUrl);
+    } catch {
+      logger.warning("Could not open browser automatically");
+      logger.info("Please open this URL in your browser:");
+      logger.log(authUrl);
+    }
+    let callbackResult;
+    try {
+      callbackResult = await resultPromise;
+    } 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,
+      authMethod: "oauth"
+    };
+    await storageService.setServiceCredentials("google-docs", credentials);
+    logger.debug("Google OAuth login successful");
+    let email = "authenticated";
+    try {
+      const about = await ofetch3(
+        "https://www.googleapis.com/drive/v3/about?fields=user",
+        {
+          headers: {
+            Authorization: `Bearer ${tokenResponse.access_token}`
+          }
+        }
+      );
+      email = about.user?.emailAddress || email;
+    } catch {
+      logger.debug("Could not fetch Google user info after login");
+    }
+    return { email };
+  }
+  /**
+   * Refresh Google OAuth tokens via BragDuck backend.
+   * Uses a singleton promise to prevent concurrent refresh race conditions.
+   */
+  async refreshToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.doRefreshToken();
+    try {
+      await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async doRefreshToken() {
+    logger.debug("Refreshing Google OAuth token");
+    const creds = await storageService.getServiceCredentials("google-docs");
+    if (!creds?.refreshToken) {
+      throw new GoogleDocsError("No Google refresh token available", {
+        hint: "Run: bragduck auth google"
+      });
+    }
+    try {
+      const response = await ofetch3(
+        `${this.apiBaseUrl}${API_ENDPOINTS.GOOGLE.REFRESH}`,
+        {
+          method: "POST",
+          body: {
+            refresh_token: creds.refreshToken
+          },
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": getUserAgent3()
+          }
+        }
+      );
+      const expiresAt = response.expires_in ? Date.now() + response.expires_in * 1e3 : void 0;
+      const updatedCreds = {
+        ...creds,
+        accessToken: response.access_token,
+        refreshToken: response.refresh_token ?? creds.refreshToken,
+        expiresAt
+      };
+      await storageService.setServiceCredentials("google-docs", updatedCreds);
+      logger.debug("Google token refresh successful");
+    } catch (error) {
+      const detail = error?.data?.message || error?.data?.error_description || error.message;
+      logger.debug(`Google token refresh failed: ${detail}`);
+      throw new GoogleDocsError(
+        `Google token refresh failed: ${detail}. Please run "bragduck auth google" to re-authenticate.`
+      );
+    }
+  }
+};
+var googleAuthService = new GoogleAuthService();
+
+// src/services/slack-auth.service.ts
+init_esm_shims();
+init_constants();
+init_storage_service();
+init_browser();
+init_errors();
+init_logger();
+import { randomBytes as randomBytes5 } from "crypto";
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath as fileURLToPath6, URLSearchParams as URLSearchParams5 } from "url";
+import { dirname as dirname5, join as join6 } from "path";
+import { ofetch as ofetch4 } from "ofetch";
+var __filename6 = fileURLToPath6(import.meta.url);
+var __dirname6 = dirname5(__filename6);
+var POLL_INTERVAL_MS = 2e3;
+var POLL_TIMEOUT_MS = 12e4;
+function getUserAgent4() {
+  try {
+    const packageJsonPath2 = join6(__dirname6, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync5(packageJsonPath2, "utf-8"));
+    const version2 = packageJson2.version;
+    const platform = process.platform;
+    const arch = process.arch;
+    return `BragDuck-CLI/${version2} (${platform}-${arch})`;
+  } catch {
+    logger.debug("Failed to read package.json version");
+    return "BragDuck-CLI/2.0.0";
+  }
+}
+var SlackAuthService = class {
+  apiBaseUrl;
+  constructor() {
+    this.apiBaseUrl = process.env.API_BASE_URL || "https://api.bragduck.com";
+  }
+  /**
+   * The HTTPS redirect URI registered with Slack.
+   * Slack redirects here after the user authorises.
+   */
+  get redirectUri() {
+    return `${this.apiBaseUrl}/v1/auth/slack/callback`;
+  }
+  /**
+   * Generate a random state string for CSRF protection
+   */
+  generateState() {
+    return randomBytes5(32).toString("hex");
+  }
+  /**
+   * Build the Slack OAuth v2 authorization URL.
+   * Uses user_scope param (not scope) to request a user token.
+   */
+  buildAuthUrl(state) {
+    const params = new URLSearchParams5({
+      client_id: SLACK_OAUTH_CONFIG.CLIENT_ID,
+      user_scope: SLACK_OAUTH_CONFIG.USER_SCOPE,
+      redirect_uri: this.redirectUri,
+      state
+    });
+    return `${SLACK_OAUTH_CONFIG.AUTH_URL}?${params.toString()}`;
+  }
+  /**
+   * Poll the BragDuck backend until the Slack callback arrives or timeout
+   */
+  async pollForCode(state) {
+    const pollUrl = `${this.apiBaseUrl}/v1/auth/slack/poll`;
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => globalThis.setTimeout(r, POLL_INTERVAL_MS));
+      const result = await ofetch4(`${pollUrl}?state=${state}`, {
+        headers: { "User-Agent": getUserAgent4() }
+      }).catch(() => null);
+      if (!result) continue;
+      if (result.status === "complete" && result.code) {
+        return result.code;
+      }
+      if (result.status === "error") {
+        throw new SlackError(`Slack OAuth error: ${result.error}`);
+      }
+    }
+    throw new SlackError("Slack authentication timed out. Please try again.");
+  }
+  /**
+   * Exchange authorization code for a user token via BragDuck backend
+   */
+  async exchangeCodeForToken(code) {
+    try {
+      const tokenUrl = `${this.apiBaseUrl}${API_ENDPOINTS.SLACK.TOKEN}`;
+      logger.debug(`Exchanging Slack authorization code via: ${tokenUrl}`);
+      const response = await ofetch4(tokenUrl, {
+        method: "POST",
+        body: {
+          code,
+          redirect_uri: this.redirectUri
+        },
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": getUserAgent4()
+        }
+      });
+      logger.debug("Slack token exchange successful");
+      return response;
+    } catch (error) {
+      const detail = error?.data?.message || error?.data?.error_description || error.message;
+      logger.debug(`Slack token exchange failed: ${detail}`);
+      throw new SlackError(`Failed to exchange Slack authorization code: ${detail}`);
+    }
+  }
+  /**
+   * Full OAuth login flow:
+   * 1. Open browser to Slack consent screen (redirect_uri → BragDuck backend)
+   * 2. Poll backend until the code arrives
+   * 3. Exchange code for user token
+   * 4. Store credentials under 'slack' service key
+   * Returns team name for confirmation display.
+   */
+  async login() {
+    logger.debug("Starting Slack OAuth login flow");
+    const state = this.generateState();
+    const authUrl = this.buildAuthUrl(state);
+    logger.debug(`Authorization URL: ${authUrl}`);
+    logger.debug(`Redirect URI: ${this.redirectUri}`);
+    try {
+      await openBrowser(authUrl);
+    } catch {
+      logger.warning("Could not open browser automatically");
+      logger.info("Please open this URL in your browser:");
+      logger.log(authUrl);
+    }
+    logger.info("Waiting for Slack authorization...");
+    const code = await this.pollForCode(state);
+    const tokenResponse = await this.exchangeCodeForToken(code);
+    const credentials = {
+      accessToken: tokenResponse.access_token,
+      username: tokenResponse.user_id,
+      authMethod: "oauth"
+    };
+    await storageService.setServiceCredentials("slack", credentials);
+    logger.debug("Slack OAuth login successful");
+    return { teamName: tokenResponse.team_name };
+  }
+};
+var slackAuthService = new SlackAuthService();
+
 // src/commands/auth.ts
 init_storage_service();
 
@@ -1956,9 +2327,9 @@ import simpleGit from "simple-git";
 init_esm_shims();
 init_errors();
 import { existsSync as existsSync2 } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 function validateGitRepository(path4) {
-  const gitDir = join5(path4, ".git");
+  const gitDir = join7(path4, ".git");
   if (!existsSync2(gitDir)) {
     throw new GitError(
       "Not a git repository. Please run this command from within a git repository.",
@@ -2269,6 +2640,18 @@ var GitHubService = class {
         });
       }
       if (error.message?.includes("Could not resolve to a Repository")) {
+        try {
+          const { stdout: remoteUrl } = await execAsync2("command git remote get-url origin", {
+            cwd: repoPath || process.cwd()
+          });
+          if (remoteUrl.includes("github.com")) {
+            throw new GitHubError("Cannot access this GitHub repository", {
+              hint: 'For private repositories, run "gh auth refresh -s repo" to add the required scope'
+            });
+          }
+        } catch (remoteErr) {
+          if (remoteErr instanceof GitHubError) throw remoteErr;
+        }
         throw new GitHubError("This repository is not hosted on GitHub", {
           hint: "Only GitHub repositories are currently supported for PR scanning"
         });
@@ -2576,9 +2959,15 @@ async function authCommand(subcommand) {
     await authGitLab();
   } else if (subcommand === "atlassian") {
     await authAtlassian();
+  } else if (subcommand === "google") {
+    await authGoogle();
+  } else if (subcommand === "slack") {
+    await authSlack();
   } else {
     logger.error(`Unknown auth subcommand: ${subcommand}`);
-    logger.info("Available subcommands: login, status, bitbucket, gitlab, atlassian");
+    logger.info(
+      "Available subcommands: login, status, bitbucket, gitlab, atlassian, google, slack"
+    );
     process.exit(1);
   }
 }
@@ -2650,43 +3039,87 @@ async function authStatus() {
   logger.log("");
   logger.info("Authentication Status:");
   logger.log("");
-  const services = await storageService.getAuthenticatedServices();
   const bragduckAuth = await storageService.isServiceAuthenticated("bragduck");
   if (bragduckAuth) {
     const userInfo = authService.getUserInfo();
     logger.info(`${colors.success("\u2713")} Bragduck: ${userInfo?.name || "Authenticated"}`);
   } else {
     logger.info(`${colors.error("\u2717")} Bragduck: Not authenticated`);
+    logger.info(theme.secondary(`  Run: bragduck auth login`));
   }
+  logger.log("");
+  logger.info("Git Sources:");
+  logger.log("");
   const ghStatus = await githubService.getAuthStatus();
   if (ghStatus.installed) {
     if (ghStatus.authenticated) {
-      logger.info(`${colors.success("\u2713")} GitHub CLI (gh): Authenticated`);
+      logger.info(`${colors.success("\u2713")} GitHub: Authenticated`);
     } else {
-      logger.info(`${colors.error("\u2717")} GitHub CLI (gh): Not authenticated`);
+      logger.info(`${colors.error("\u2717")} GitHub: Not authenticated`);
       logger.info(theme.secondary("  Run: gh auth login"));
     }
   } else {
-    logger.info(`${colors.error("\u2717")} GitHub CLI (gh): Not installed`);
+    logger.info(`${colors.error("\u2717")} GitHub: gh CLI not installed`);
     logger.info(theme.secondary("  Install from: https://cli.github.com"));
   }
-  for (const service of services) {
-    if (service !== "bragduck") {
-      const creds = await storageService.getServiceCredentials(service);
-      let methodLabel = "";
-      if (creds?.authMethod === "oauth") {
-        methodLabel = " (Cloud - OAuth)";
-      } else if (creds?.authMethod === "basic") {
-        methodLabel = " (Server - API Token)";
-      }
-      logger.info(`${colors.success("\u2713")} ${service}: Authenticated${methodLabel}`);
-    }
+  const gitlabAuth = await storageService.isServiceAuthenticated("gitlab");
+  if (gitlabAuth) {
+    const creds = await storageService.getServiceCredentials("gitlab");
+    const instanceLabel = creds?.instanceUrl ? ` (${creds.instanceUrl})` : " (gitlab.com)";
+    logger.info(`${colors.success("\u2713")} GitLab: Authenticated${instanceLabel}`);
+  } else {
+    logger.info(`${colors.error("\u2717")} GitLab: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth gitlab"));
+  }
+  const bitbucketAuth = await storageService.isServiceAuthenticated("bitbucket");
+  if (bitbucketAuth) {
+    const creds = await storageService.getServiceCredentials("bitbucket");
+    const userLabel = creds?.username ? ` (${creds.username})` : "";
+    logger.info(`${colors.success("\u2713")} Bitbucket: Authenticated${userLabel}`);
+  } else {
+    logger.info(`${colors.error("\u2717")} Bitbucket: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth bitbucket"));
   }
   logger.log("");
-  if (services.length === 0) {
-    logger.info(`Run ${theme.command("bragduck auth login")} to authenticate with Bragduck`);
-    logger.log("");
+  logger.info("Project Management:");
+  logger.log("");
+  const jiraAuth = await storageService.isServiceAuthenticated("jira");
+  const confluenceAuth = await storageService.isServiceAuthenticated("confluence");
+  if (jiraAuth || confluenceAuth) {
+    const creds = await storageService.getServiceCredentials("jira");
+    let methodLabel = "";
+    if (creds?.authMethod === "oauth") {
+      methodLabel = " (Cloud - OAuth)";
+    } else if (creds?.authMethod === "basic") {
+      methodLabel = " (Server - API Token)";
+    }
+    logger.info(`${colors.success("\u2713")} Atlassian${methodLabel}`);
+    if (jiraAuth) logger.info(theme.secondary("  \xB7 Jira"));
+    if (confluenceAuth) logger.info(theme.secondary("  \xB7 Confluence"));
+  } else {
+    logger.info(`${colors.error("\u2717")} Atlassian (Jira + Confluence): Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth atlassian"));
   }
+  logger.log("");
+  logger.info("Document Sources:");
+  logger.log("");
+  const googleDocsAuth = await storageService.isServiceAuthenticated("google-docs");
+  if (googleDocsAuth) {
+    logger.info(`${colors.success("\u2713")} Google Docs (OAuth)`);
+  } else {
+    logger.info(`${colors.error("\u2717")} Google Docs: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth google"));
+  }
+  const slackAuth = await storageService.isServiceAuthenticated("slack");
+  if (slackAuth) {
+    const creds = await storageService.getServiceCredentials("slack");
+    const userLabel = creds?.username ? ` (user: ${creds.username})` : "";
+    logger.info(`${colors.success("\u2713")} Slack: Connected${userLabel}`);
+  } else {
+    logger.info(`${colors.error("\u2717")} Slack: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth slack"));
+  }
+  logger.log("");
 }
 async function authBitbucket() {
   logger.log("");
@@ -2863,8 +3296,72 @@ Services configured:
     process.exit(1);
   }
 }
-
-// src/commands/sync.ts
+async function authGoogle() {
+  logger.log("");
+  logger.info("Opening browser for Google authentication...");
+  logger.log("");
+  try {
+    const result = await googleAuthService.login();
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Google") + `
+
+Account: ${result.email}
+
+Services configured:
+  - Google Docs (OAuth)`,
+        boxStyles.success
+      )
+    );
+    logger.log("");
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.error("\u2717 Authentication Failed") + "\n\n" + (err.message || "Unknown error"),
+        boxStyles.error
+      )
+    );
+    logger.log("");
+    process.exit(1);
+  }
+}
+async function authSlack() {
+  logger.log("");
+  logger.info("Opening browser for Slack authentication...");
+  logger.log("");
+  try {
+    const result = await slackAuthService.login();
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Slack") + `
+
+Workspace: ${result.teamName}
+
+Services configured:
+  - Slack messages (OAuth)`,
+        boxStyles.success
+      )
+    );
+    logger.log("");
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.error("\u2717 Authentication Failed") + "\n\n" + (err.message || "Unknown error"),
+        boxStyles.error
+      )
+    );
+    logger.log("");
+    process.exit(1);
+  }
+}
+
+// src/commands/sync.ts
 init_esm_shims();
 
 // ../../node_modules/.pnpm/@inquirer+core@9.2.1/node_modules/@inquirer/core/dist/esm/lib/errors.mjs
@@ -3459,7 +3956,7 @@ init_logger();
 init_storage_service();
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { URLSearchParams as URLSearchParams4 } from "url";
+import { URLSearchParams as URLSearchParams7 } from "url";
 var execAsync5 = promisify5(exec5);
 var GitLabService = class {
   DEFAULT_INSTANCE = "https://gitlab.com";
@@ -3605,7 +4102,7 @@ var GitLabService = class {
   async getMergedMRs(options = {}) {
     const { projectPath } = await this.getProjectFromGit();
     const encodedPath = encodeURIComponent(projectPath);
-    const params = new URLSearchParams4({
+    const params = new URLSearchParams7({
       state: "merged",
       order_by: "updated_at",
       sort: "desc",
@@ -4073,6 +4570,9 @@ var JiraService = class {
         logger.debug(
           `Fetched ${newIssuesCount} new issues (total: ${allIssues.length} of ${response.total})${startAt + maxResults < response.total ? ", fetching next page..." : ""}`
         );
+        if (options.onProgress) {
+          options.onProgress(allIssues.length, response.total);
+        }
         if (newIssuesCount === 0) {
           logger.debug("All results are duplicates, stopping pagination");
           break;
@@ -4240,7 +4740,8 @@ var jiraSyncAdapter = {
     return jiraService.getIssues({
       days: options.days,
       limit: options.limit,
-      author: author || void 0
+      author: author || void 0,
+      onProgress: options.onProgress
     });
   },
   async isAuthenticated() {
@@ -4558,6 +5059,9 @@ var ConfluenceService = class {
         logger.debug(
           `Fetched ${newPagesCount} new pages (total: ${allPages.length}, duplicates: ${response.results.length - newPagesCount})${response.size === limit ? ", fetching next page..." : ""}`
         );
+        if (options.onProgress) {
+          options.onProgress(allPages.length);
+        }
         if (newPagesCount === 0) {
           logger.debug("All results are duplicates, stopping pagination");
           break;
@@ -4707,7 +5211,8 @@ var confluenceSyncAdapter = {
     return confluenceService.getPages({
       days: options.days,
       limit: options.limit,
-      author: author || void 0
+      author: author || void 0,
+      onProgress: options.onProgress ? (fetched) => options.onProgress(fetched, 0) : void 0
     });
   },
   async isAuthenticated() {
@@ -4723,6 +5228,479 @@ var confluenceSyncAdapter = {
   }
 };
 
+// src/sync/google-docs-adapter.ts
+init_esm_shims();
+
+// src/services/google-docs.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+var GoogleDocsService = class {
+  /**
+   * Get stored Google credentials, auto-refreshing OAuth tokens if expired
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("google-docs");
+    if (!creds || !creds.accessToken) {
+      throw new GoogleDocsError("Not authenticated with Google Docs", {
+        hint: "Run: bragduck auth google"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      if (creds.refreshToken) {
+        logger.debug("Google OAuth token expired, refreshing...");
+        await googleAuthService.refreshToken();
+        const refreshed = await storageService.getServiceCredentials("google-docs");
+        if (!refreshed?.accessToken) {
+          throw new GoogleDocsError("Token refresh failed", {
+            hint: "Run: bragduck auth google"
+          });
+        }
+        return refreshed;
+      }
+      throw new GoogleDocsError("OAuth token has expired and no refresh token available", {
+        hint: "Run: bragduck auth google"
+      });
+    }
+    return creds;
+  }
+  /**
+   * Make authenticated request to Google APIs.
+   * Retries once on 401 (auto-refresh).
+   */
+  async request(url) {
+    const creds = await this.getCredentials();
+    logger.debug(`Google API: GET ${url}`);
+    const options = {
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        Accept: "application/json"
+      }
+    };
+    let response = await fetch(url, options);
+    if (response.status === 401 && creds.refreshToken) {
+      logger.debug("Google API 401, attempting token refresh and retry");
+      await googleAuthService.refreshToken();
+      const refreshedCreds = await storageService.getServiceCredentials("google-docs");
+      if (refreshedCreds?.accessToken) {
+        response = await fetch(url, {
+          headers: {
+            Authorization: `Bearer ${refreshedCreds.accessToken}`,
+            Accept: "application/json"
+          }
+        });
+      }
+    }
+    if (!response.ok) {
+      const status = response.status;
+      const statusText = response.statusText;
+      let errorDetail = statusText;
+      try {
+        const body = await response.json();
+        errorDetail = body?.error?.message || body?.error?.errors?.[0]?.message || statusText;
+        logger.debug(`Google API error body: ${JSON.stringify(body)}`);
+      } catch {
+      }
+      if (status === 401) {
+        throw new GoogleDocsError(`Invalid or expired Google token: ${errorDetail}`, {
+          hint: "Run: bragduck auth google"
+        });
+      } else if (status === 403) {
+        throw new GoogleDocsError(`Forbidden - check Drive API permissions: ${errorDetail}`, {
+          hint: "Token needs: drive.metadata.readonly"
+        });
+      } else if (status === 429) {
+        throw new GoogleDocsError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again"
+        });
+      }
+      throw new GoogleDocsError(`API request failed: ${errorDetail}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get current user's email address via Drive API (works with drive.metadata.readonly scope)
+   */
+  async getCurrentUser() {
+    try {
+      const about = await this.request(
+        "https://www.googleapis.com/drive/v3/about?fields=user"
+      );
+      return about.user?.emailAddress || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Validate Google credentials using Drive API (drive.metadata.readonly scope is sufficient)
+   */
+  async validateCredentials() {
+    try {
+      await this.request(
+        "https://www.googleapis.com/drive/v3/about?fields=user"
+      );
+    } catch (error) {
+      if (error instanceof GoogleDocsError) {
+        throw error;
+      }
+      throw new GoogleDocsError("Could not access Google Drive API", {
+        hint: "Check that your credentials are valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Map Google Workspace MIME type to a short display label
+   */
+  getMimeTypeLabel(mimeType) {
+    switch (mimeType) {
+      case "application/vnd.google-apps.document":
+        return "Doc";
+      case "application/vnd.google-apps.spreadsheet":
+        return "Sheet";
+      case "application/vnd.google-apps.presentation":
+        return "Slides";
+      default:
+        return "Doc";
+    }
+  }
+  /**
+   * Transform a Google Drive file to GitCommit format
+   */
+  transformDocToCommit(file) {
+    const isOwner = file.owners?.[0]?.me === true;
+    const contributionType = isOwner ? "created" : "edited";
+    const typeLabel = this.getMimeTypeLabel(file.mimeType);
+    return {
+      sha: file.id,
+      message: `Google Doc [${typeLabel}]: ${file.name}`,
+      author: file.lastModifyingUser?.displayName || "Unknown",
+      authorEmail: file.lastModifyingUser?.emailAddress || "unknown@example.com",
+      date: file.modifiedByMeTime || file.modifiedTime,
+      url: file.webViewLink,
+      diffStats: {
+        filesChanged: 1,
+        insertions: 50,
+        deletions: 0
+      },
+      externalId: file.id,
+      externalType: contributionType,
+      externalSource: "google-docs",
+      externalUrl: file.webViewLink
+    };
+  }
+  /**
+   * Fetch Google Docs the user has contributed to
+   */
+  async getDocs(options = {}) {
+    const allFiles = [];
+    let pageToken;
+    const pageSize = 100;
+    let cutoffDate = "";
+    if (options.days) {
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() - options.days);
+      cutoffDate = cutoff.toISOString().replace(/\.\d{3}Z$/, "Z");
+    }
+    const docTypes = [
+      "mimeType='application/vnd.google-apps.document'",
+      "mimeType='application/vnd.google-apps.spreadsheet'",
+      "mimeType='application/vnd.google-apps.presentation'"
+    ].join(" or ");
+    const queryParts = [`(${docTypes})`, "trashed = false"];
+    if (cutoffDate) {
+      queryParts.push(`modifiedTime > '${cutoffDate}'`);
+    }
+    const q = queryParts.join(" and ");
+    const fields = "nextPageToken,files(id,name,mimeType,createdTime,modifiedTime,modifiedByMeTime,webViewLink,owners(me,displayName,emailAddress),lastModifyingUser(displayName,emailAddress))";
+    while (true) {
+      const params = new URLSearchParams({
+        q,
+        fields,
+        pageSize: pageSize.toString(),
+        orderBy: "modifiedByMeTime desc"
+      });
+      if (pageToken) {
+        params.set("pageToken", pageToken);
+      }
+      const url = `https://www.googleapis.com/drive/v3/files?${params.toString()}`;
+      const response = await this.request(url);
+      if (response.files && response.files.length > 0) {
+        const cutoffMs = cutoffDate ? new Date(cutoffDate).getTime() : 0;
+        const userInteracted = response.files.filter((f) => {
+          const modifiedByMeMs = f.modifiedByMeTime ? new Date(f.modifiedByMeTime).getTime() : 0;
+          const isOwnerCreatedRecently = f.owners?.[0]?.me === true && new Date(f.createdTime).getTime() >= cutoffMs;
+          return modifiedByMeMs >= cutoffMs || isOwnerCreatedRecently;
+        });
+        allFiles.push(...userInteracted);
+      }
+      if (options.onProgress) {
+        options.onProgress(allFiles.length, 0);
+      }
+      if (!response.nextPageToken) {
+        break;
+      }
+      if (options.limit && allFiles.length >= options.limit) {
+        break;
+      }
+      pageToken = response.nextPageToken;
+    }
+    const files = options.limit ? allFiles.slice(0, options.limit) : allFiles;
+    return files.map((file) => this.transformDocToCommit(file));
+  }
+};
+var googleDocsService = new GoogleDocsService();
+
+// src/sync/google-docs-adapter.ts
+var googleDocsSyncAdapter = {
+  name: "google-docs",
+  async validate() {
+    await googleDocsService.validateCredentials();
+  },
+  async getRepositoryInfo() {
+    const user = await googleDocsService.getCurrentUser();
+    const userName = user || "Unknown User";
+    return {
+      owner: userName,
+      name: "Google Docs",
+      fullName: `${userName}'s Google Docs`,
+      url: "https://drive.google.com"
+    };
+  },
+  async fetchWorkItems(options) {
+    return googleDocsService.getDocs({
+      days: options.days,
+      limit: options.limit,
+      onProgress: options.onProgress ? (fetched) => options.onProgress(fetched, 0) : void 0
+    });
+  },
+  async isAuthenticated() {
+    try {
+      await this.validate();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async getCurrentUser() {
+    return googleDocsService.getCurrentUser();
+  }
+};
+
+// src/sync/slack-adapter.ts
+init_esm_shims();
+
+// src/services/slack.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+import { URLSearchParams as URLSearchParams8 } from "url";
+var SlackService = class {
+  /**
+   * Get stored Slack credentials.
+   * Slack user tokens (xoxp-) don't expire by default — no expiry check needed.
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("slack");
+    if (!creds || !creds.accessToken) {
+      throw new SlackError("Not authenticated with Slack", {
+        hint: "Run: bragduck auth slack"
+      });
+    }
+    return creds;
+  }
+  /**
+   * Make authenticated GET request to Slack Web API
+   */
+  async request(url) {
+    const creds = await this.getCredentials();
+    logger.debug(`Slack API: GET ${url}`);
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const status = response.status;
+      let errorDetail = response.statusText;
+      try {
+        const body = await response.json();
+        errorDetail = body?.error || errorDetail;
+        logger.debug(`Slack API error body: ${JSON.stringify(body)}`);
+      } catch {
+      }
+      if (status === 401) {
+        throw new SlackError(`Invalid or expired Slack token: ${errorDetail}`, {
+          hint: "Run: bragduck auth slack"
+        });
+      } else if (status === 429) {
+        throw new SlackError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again"
+        });
+      }
+      throw new SlackError(`API request failed: ${errorDetail}`);
+    }
+    const data = await response.json();
+    if (data.ok === false) {
+      if (data.error === "invalid_auth" || data.error === "token_revoked") {
+        throw new SlackError(`Invalid or revoked Slack token: ${data.error}`, {
+          hint: "Run: bragduck auth slack"
+        });
+      }
+      throw new SlackError(`Slack API error: ${data.error}`);
+    }
+    return data;
+  }
+  /**
+   * Validate Slack credentials via auth.test
+   */
+  async validateCredentials() {
+    const creds = await this.getCredentials();
+    const response = await fetch("https://slack.com/api/auth.test", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    const data = await response.json();
+    if (!data.ok) {
+      throw new SlackError(`Slack credentials invalid: ${data.error || "unknown error"}`, {
+        hint: "Run: bragduck auth slack"
+      });
+    }
+  }
+  /**
+   * Get current Slack user display name via auth.test
+   */
+  async getCurrentUser() {
+    try {
+      const creds = await this.getCredentials();
+      const response = await fetch("https://slack.com/api/auth.test", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${creds.accessToken}`,
+          "Content-Type": "application/json"
+        }
+      });
+      const data = await response.json();
+      return data.ok ? data.user : null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch messages sent by the authenticated user via search.messages.
+   * Paginates across all pages until exhausted or limit reached.
+   */
+  async getMessages(options = {}) {
+    const creds = await this.getCredentials();
+    if (!creds.username) {
+      throw new SlackError("No Slack user ID stored", {
+        hint: "Run: bragduck auth slack"
+      });
+    }
+    let query = `from:<@${creds.username}>`;
+    if (options.days) {
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() - options.days);
+      const dateStr = cutoff.toISOString().slice(0, 10);
+      query += ` after:${dateStr}`;
+    }
+    const allMessages = [];
+    let page = 1;
+    while (true) {
+      const params = new URLSearchParams8({
+        query,
+        count: "100",
+        page: page.toString()
+      });
+      const url = `https://slack.com/api/search.messages?${params.toString()}`;
+      const response = await this.request(url);
+      const matches = response.messages?.matches || [];
+      allMessages.push(...matches);
+      if (options.onProgress) {
+        options.onProgress(allMessages.length, response.messages?.paging?.total || 0);
+      }
+      const paging = response.messages?.paging;
+      if (!paging || page >= paging.pages) {
+        break;
+      }
+      if (options.limit && allMessages.length >= options.limit) {
+        break;
+      }
+      page++;
+    }
+    const messages = options.limit ? allMessages.slice(0, options.limit) : allMessages;
+    return messages.map((msg) => this.transformMessageToCommit(msg));
+  }
+  /**
+   * Transform a Slack message to GitCommit format
+   */
+  transformMessageToCommit(msg) {
+    const channelName = msg.channel?.name || msg.channel?.id || "unknown";
+    const preview = msg.text.slice(0, 100);
+    const date = new Date(parseFloat(msg.ts) * 1e3).toISOString();
+    return {
+      sha: msg.ts,
+      message: `Slack [#${channelName}]: ${preview}`,
+      author: msg.username || "Unknown",
+      authorEmail: "unknown@slack",
+      date,
+      url: msg.permalink,
+      diffStats: {
+        filesChanged: 1,
+        insertions: 1,
+        deletions: 0
+      },
+      externalId: msg.ts,
+      externalType: "message",
+      externalSource: "slack",
+      externalUrl: msg.permalink
+    };
+  }
+};
+var slackService = new SlackService();
+
+// src/sync/slack-adapter.ts
+var slackSyncAdapter = {
+  name: "slack",
+  async validate() {
+    await slackService.validateCredentials();
+  },
+  async getRepositoryInfo() {
+    const user = await slackService.getCurrentUser();
+    const userName = user || "Unknown User";
+    return {
+      owner: userName,
+      name: "Slack",
+      fullName: `${userName}'s Slack Messages`,
+      url: "https://slack.com"
+    };
+  },
+  async fetchWorkItems(options) {
+    return slackService.getMessages({
+      days: options.days,
+      limit: options.limit,
+      onProgress: options.onProgress ? (fetched, total) => options.onProgress(fetched, total) : void 0
+    });
+  },
+  async isAuthenticated() {
+    try {
+      await this.validate();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async getCurrentUser() {
+    return slackService.getCurrentUser();
+  }
+};
+
 // src/sync/adapter-factory.ts
 var AdapterFactory = class {
   /**
@@ -4741,6 +5719,10 @@ var AdapterFactory = class {
         return jiraSyncAdapter;
       case "confluence":
         return confluenceSyncAdapter;
+      case "google-docs":
+        return googleDocsSyncAdapter;
+      case "slack":
+        return slackSyncAdapter;
       default:
         throw new Error(`Unknown source type: ${source}`);
     }
@@ -4749,7 +5731,7 @@ var AdapterFactory = class {
    * Check if adapter is available for source
    */
   static isSupported(source) {
-    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab" || source === "jira" || source === "confluence";
+    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab" || source === "jira" || source === "confluence" || source === "google-docs" || source === "slack";
   }
 };
 
@@ -5216,11 +6198,18 @@ async function ensureAuthenticated() {
 // src/ui/spinners.ts
 init_esm_shims();
 import ora from "ora";
-function createSpinner(text) {
+function createFetchSpinner(text) {
   return ora({
     text,
     color: "cyan",
-    spinner: "dots"
+    spinner: "bouncingBar"
+  });
+}
+function createValidateSpinner(text) {
+  return ora({
+    text,
+    color: "cyan",
+    spinner: "line"
   });
 }
 function createStepSpinner(currentStep, totalSteps, text) {
@@ -5231,8 +6220,12 @@ function createStepSpinner(currentStep, totalSteps, text) {
     spinner: "dots"
   });
 }
+function updateStepSpinner(spinner, currentStep, totalSteps, text) {
+  const stepIndicator = theme.step(currentStep, totalSteps);
+  spinner.text = `${stepIndicator} ${text}`;
+}
 function fetchingBragsSpinner() {
-  return createSpinner("Fetching your brags...");
+  return createFetchSpinner("Fetching your brags...");
 }
 function succeedSpinner(spinner, text) {
   if (text) {
@@ -5257,6 +6250,20 @@ function failStepSpinner(spinner, currentStep, totalSteps, text) {
   spinner.fail(`${stepIndicator} ${colors.error(text)}`);
 }
 
+// src/ui/header.ts
+init_esm_shims();
+init_logger();
+function showCommandHeader(userInfo, tier) {
+  if (!userInfo?.email) return;
+  if (tier) {
+    const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1).toLowerCase() + " plan";
+    logger.log(colors.dim(`  ${userInfo.email}  \xB7  ${tierLabel}`));
+  } else {
+    logger.log(colors.dim(`  ${userInfo.email}`));
+  }
+  logger.log("");
+}
+
 // src/utils/repo-scanner.ts
 init_esm_shims();
 import { promises as fs2 } from "fs";
@@ -5509,12 +6516,12 @@ async function syncSingleRepository(repo, days, sortOption, scanMode, orgId, opt
     return { repoName: repo.name, service: repo.service, created: 0, skipped: duplicates.length };
   }
   logger.log("");
-  const createSpinner2 = createStepSpinner(
+  const createSpinner = createStepSpinner(
     4,
     TOTAL_STEPS,
     `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
   );
-  createSpinner2.start();
+  createSpinner.start();
   const createRequest = {
     brags: acceptedBrags.map((refined, index) => {
       const originalCommit = selectedCommits[index];
@@ -5558,14 +6565,14 @@ async function syncSingleRepository(repo, days, sortOption, scanMode, orgId, opt
     ]);
     logger.debug(`API response: ${createResponse.created} brags created`);
     succeedStepSpinner(
-      createSpinner2,
+      createSpinner,
       4,
       TOTAL_STEPS,
       `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
     );
     logger.log("");
   } catch (error) {
-    failStepSpinner(createSpinner2, 4, TOTAL_STEPS, "Failed to create brags");
+    failStepSpinner(createSpinner, 4, TOTAL_STEPS, "Failed to create brags");
     logger.log("");
     throw error;
   }
@@ -5697,7 +6704,7 @@ async function syncMultipleRepositories(repos, options) {
 
 // src/commands/sync.ts
 async function promptSelectService() {
-  const nonGitServices = ["atlassian", "jira", "confluence"];
+  const nonGitServices = ["atlassian", "jira", "confluence", "google-docs", "slack"];
   const authenticatedServices = await storageService.getAuthenticatedServices();
   const allServices = [
     "github",
@@ -5705,7 +6712,9 @@ async function promptSelectService() {
     "bitbucket",
     "atlassian",
     "jira",
-    "confluence"
+    "confluence",
+    "google-docs",
+    "slack"
   ];
   const authenticatedSyncServices = authenticatedServices.filter(
     (service) => service !== "bragduck" && allServices.includes(service)
@@ -5720,7 +6729,7 @@ async function promptSelectService() {
   for (const service of nonGitServices) {
     const isAuth = await storageService.isServiceAuthenticated(service);
     const indicator = isAuth ? "\u2713" : "\u2717";
-    const serviceLabel = service.charAt(0).toUpperCase() + service.slice(1);
+    const serviceLabel = getServiceLabel(service);
     serviceChoices.push({
       name: `${indicator} ${serviceLabel}`,
       value: service,
@@ -5728,7 +6737,7 @@ async function promptSelectService() {
     });
   }
   if (authenticatedSyncServices.length > 0) {
-    const serviceNames = authenticatedSyncServices.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(", ");
+    const serviceNames = authenticatedSyncServices.map(getServiceLabel).join(", ");
     serviceChoices.push({
       name: `\u2713 All authenticated services (${serviceNames})`,
       value: "all",
@@ -5743,7 +6752,8 @@ async function promptSelectService() {
 }
 async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, sharedOrgId) {
   const adapter = AdapterFactory.getAdapter(sourceType);
-  const repoSpinner = createStepSpinner(2, TOTAL_STEPS, "Validating repository");
+  const validationText = sourceType === "jira" || sourceType === "confluence" ? "Connecting to Atlassian instance" : sourceType === "google-docs" ? "Connecting to Google Drive" : "Validating repository";
+  const repoSpinner = createStepSpinner(2, TOTAL_STEPS, validationText);
   repoSpinner.start();
   const VALIDATION_TIMEOUT = 3e4;
   let repoInfo;
@@ -5789,7 +6799,16 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   fetchSpinner.start();
   const workItems = await adapter.fetchWorkItems({
     days,
-    author: await adapter.getCurrentUser() || void 0
+    author: await adapter.getCurrentUser() || void 0,
+    onProgress: (fetched, total) => {
+      const progress = total > 0 ? `${fetched} of ${total}` : `${fetched} so far`;
+      updateStepSpinner(
+        fetchSpinner,
+        3,
+        TOTAL_STEPS,
+        `Fetching work items from the last ${days} days (${progress})`
+      );
+    }
   });
   if (workItems.length === 0) {
     failStepSpinner(fetchSpinner, 3, TOTAL_STEPS, `No work items found in the last ${days} days`);
@@ -5806,6 +6825,8 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   logger.log("");
   logger.log(formatCommitStats(workItems));
   logger.log("");
+  const dupSpinner = createFetchSpinner("Checking for duplicates...");
+  dupSpinner.start();
   const existingBrags = await apiService.listBrags({ limit: 100 });
   logger.debug(`Fetched ${existingBrags.brags.length} existing brags`);
   const existingUrls = new Set(existingBrags.brags.flatMap((b) => b.attachments || []));
@@ -5814,13 +6835,14 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   const newWorkItems = workItems.filter((c) => !c.url || !existingUrls.has(c.url));
   logger.debug(`Found ${duplicates.length} duplicates, ${newWorkItems.length} new items`);
   if (duplicates.length > 0) {
-    logger.log("");
-    logger.info(
-      colors.dim(
-        `\u2139 ${duplicates.length} work item${duplicates.length > 1 ? "s" : ""} already exist in Bragduck (will be skipped)`
-      )
+    succeedSpinner(
+      dupSpinner,
+      `${duplicates.length} item${duplicates.length > 1 ? "s" : ""} already synced, skipping`
     );
     logger.log("");
+  } else {
+    succeedSpinner(dupSpinner, "No duplicates found");
+    logger.log("");
   }
   if (newWorkItems.length === 0) {
     logger.log("");
@@ -5907,23 +6929,27 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   if (sharedOrgId === void 0) {
     const userInfo = authService.getUserInfo();
     if (userInfo?.id) {
+      const orgSpinner = createFetchSpinner("Loading organizations...");
+      orgSpinner.start();
       try {
         const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
+        orgSpinner.stop();
         if (orgsResponse.items.length > 0) {
           selectedOrgId = await promptSelectOrganisation(orgsResponse.items);
           logger.log("");
         }
       } catch {
+        orgSpinner.stop();
         logger.debug("Failed to fetch organisations, skipping org selection");
       }
     }
   }
-  const createSpinner2 = createStepSpinner(
+  const createSpinner = createStepSpinner(
     5,
     TOTAL_STEPS,
     `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
   );
-  createSpinner2.start();
+  createSpinner.start();
   const createRequest = {
     brags: acceptedBrags.map((refined, index) => {
       const originalCommit = selectedCommits[index];
@@ -5971,14 +6997,14 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
     ]);
     logger.debug(`API response: ${createResponse.created} brags created`);
     succeedStepSpinner(
-      createSpinner2,
+      createSpinner,
       5,
       TOTAL_STEPS,
       `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
     );
     logger.log("");
   } catch (error) {
-    failStepSpinner(createSpinner2, 5, TOTAL_STEPS, "Failed to create brags");
+    failStepSpinner(createSpinner, 5, TOTAL_STEPS, "Failed to create brags");
     logger.log("");
     throw error;
   }
@@ -5997,7 +7023,9 @@ async function syncAllAuthenticatedServices(options) {
     "bitbucket",
     "atlassian",
     "jira",
-    "confluence"
+    "confluence",
+    "google-docs",
+    "slack"
   ];
   const authenticatedServices = await storageService.getAuthenticatedServices();
   let servicesToSync = authenticatedServices.filter(
@@ -6064,14 +7092,18 @@ async function syncAllAuthenticatedServices(options) {
   if (!options.turbo) {
     const userInfo = authService.getUserInfo();
     if (userInfo?.id) {
+      const orgSpinner = createFetchSpinner("Loading organizations...");
+      orgSpinner.start();
       try {
         const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
+        orgSpinner.stop();
         if (orgsResponse.items.length > 0) {
           const defaultOrgId = storageService.getConfig("defaultCompany");
           sharedOrgId = await promptSelectOrganisationWithDefault(orgsResponse.items, defaultOrgId);
           logger.log("");
         }
       } catch {
+        orgSpinner.stop();
         logger.debug("Failed to fetch organisations, skipping org selection");
       }
     }
@@ -6080,7 +7112,7 @@ async function syncAllAuthenticatedServices(options) {
   for (let i = 0; i < servicesToSync.length; i++) {
     const service = servicesToSync[i];
     if (!service) continue;
-    const serviceLabel = service.charAt(0).toUpperCase() + service.slice(1);
+    const serviceLabel = getServiceLabel(service);
     logger.log(
       colors.highlight(`\u2501\u2501\u2501 Syncing ${i + 1}/${servicesToSync.length}: ${serviceLabel} \u2501\u2501\u2501`)
     );
@@ -6121,7 +7153,7 @@ async function syncAllAuthenticatedServices(options) {
       )
     );
     for (const result of successful) {
-      const serviceLabel = result.service.charAt(0).toUpperCase() + result.service.slice(1);
+      const serviceLabel = getServiceLabel(result.service);
       if (result.created === 0 && result.skipped > 0) {
         logger.info(
           `  \u2022 ${serviceLabel}: ${colors.dim(`All ${result.skipped} item${result.skipped !== 1 ? "s" : ""} already synced`)}`
@@ -6141,7 +7173,7 @@ async function syncAllAuthenticatedServices(options) {
       colors.warning(`\u2717 Failed to sync ${failed.length} service${failed.length > 1 ? "s" : ""}:`)
     );
     for (const result of failed) {
-      const serviceLabel = result.service.charAt(0).toUpperCase() + result.service.slice(1);
+      const serviceLabel = getServiceLabel(result.service);
       logger.info(`  \u2022 ${serviceLabel}: ${result.error}`);
     }
     logger.log("");
@@ -6169,10 +7201,19 @@ async function syncCommand(options = {}) {
       process.exit(1);
     }
     logger.debug("Fetching subscription status...");
-    const subscriptionStatus = await apiService.getSubscriptionStatus();
+    const subSpinner = createValidateSpinner("Checking subscription...");
+    subSpinner.start();
+    let subscriptionStatus;
+    try {
+      subscriptionStatus = await apiService.getSubscriptionStatus();
+    } catch (error) {
+      failSpinner(subSpinner, "Failed to check subscription");
+      throw error;
+    }
     logger.debug("Subscription status response:", JSON.stringify(subscriptionStatus, null, 2));
     if (subscriptionStatus.tier === "FREE") {
       logger.debug("FREE tier detected - blocking sync command");
+      failSpinner(subSpinner, "Free plan \u2014 upgrade to use CLI sync");
       logger.log("");
       logger.log(
         boxen5(
@@ -6187,7 +7228,13 @@ async function syncCommand(options = {}) {
       logger.log("");
       return;
     }
+    succeedSpinner(
+      subSpinner,
+      `${subscriptionStatus.tier.charAt(0).toUpperCase() + subscriptionStatus.tier.slice(1).toLowerCase()} plan \xB7 Ready`
+    );
     logger.debug(`Subscription tier "${subscriptionStatus.tier}" - proceeding with sync`);
+    const userInfo = authService.getUserInfo();
+    showCommandHeader(userInfo, subscriptionStatus.tier);
     let selectedSource;
     if (options.all) {
       selectedSource = "all";
@@ -6198,7 +7245,9 @@ async function syncCommand(options = {}) {
         logger.log("");
         logger.error(`Unsupported source: ${options.source}`);
         logger.log("");
-        logger.info("Supported sources: github, gitlab, bitbucket, atlassian, jira, confluence");
+        logger.info(
+          "Supported sources: github, gitlab, bitbucket, atlassian, jira, confluence, google-docs"
+        );
         return;
       }
       selectedSource = sourceType;
@@ -6213,6 +7262,69 @@ async function syncCommand(options = {}) {
       const detectionSpinner = createStepSpinner(1, TOTAL_STEPS, "Preparing sync");
       detectionSpinner.start();
       if (selectedSource === "git") {
+        let authCheckService;
+        let authCheckPassed = false;
+        try {
+          const detection = await sourceDetector.detectSources({}, process.cwd());
+          if (detection.detected.length > 0) {
+            authCheckService = detection.detected[0]?.type;
+            authCheckPassed = detection.detected.some((s) => s.isAuthenticated);
+          }
+        } catch {
+        }
+        if (!authCheckPassed && authCheckService) {
+          failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Not authenticated");
+          logger.log("");
+          logger.log(
+            boxen5(
+              theme.warning("Authentication Required") + `
+
+Not authenticated with ${authCheckService.charAt(0).toUpperCase() + authCheckService.slice(1)}.
+
+To authenticate:
+
+` + getGitAuthCommand(authCheckService),
+              { ...boxStyles.warning, padding: 1, margin: 1 }
+            )
+          );
+          logger.log("");
+          return;
+        }
+        if (!authCheckPassed && !authCheckService) {
+          const gitServices = ["github", "gitlab", "bitbucket"];
+          const authResults = await Promise.all(
+            gitServices.map(async (s) => ({
+              service: s,
+              auth: await sourceDetector.checkAuthentication(s)
+            }))
+          );
+          const anyAuth = authResults.some((r) => r.auth);
+          if (!anyAuth) {
+            failStepSpinner(
+              detectionSpinner,
+              1,
+              TOTAL_STEPS,
+              "Not authenticated with any git service"
+            );
+            logger.log("");
+            logger.log(
+              boxen5(
+                theme.warning("Authentication Required") + `
+
+Not authenticated with any git service.
+
+To authenticate:
+
+  GitHub:    ${theme.command("gh auth login")}
+  GitLab:    ${theme.command("bragduck auth gitlab")}
+  Bitbucket: ${theme.command("bragduck auth atlassian")}`,
+                { ...boxStyles.warning, padding: 1, margin: 1 }
+              )
+            );
+            logger.log("");
+            return;
+          }
+        }
         succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Discovering repositories");
         logger.log("");
         const repos = await discoverRepositories();
@@ -6261,6 +7373,24 @@ async function syncCommand(options = {}) {
           );
           return;
         }
+        if (!creds?.accessToken) {
+          failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Not authenticated with ${sourceType}`);
+          logger.log("");
+          logger.log(
+            boxen5(
+              theme.warning("Authentication Required") + `
+
+Not authenticated with ${sourceType.charAt(0).toUpperCase() + sourceType.slice(1)}.
+
+To authenticate:
+
+  ${theme.command("bragduck auth atlassian")}`,
+              { ...boxStyles.warning, padding: 1, margin: 1 }
+            )
+          );
+          logger.log("");
+          return;
+        }
       }
       succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source: ${theme.value(sourceType)}`);
       logger.log("");
@@ -6299,6 +7429,23 @@ async function syncCommand(options = {}) {
     process.exit(1);
   }
 }
+function getServiceLabel(service) {
+  if (service === "google-docs") return "Google Docs";
+  if (service === "slack") return "Slack";
+  return service.charAt(0).toUpperCase() + service.slice(1);
+}
+function getGitAuthCommand(service) {
+  if (service === "github") {
+    return `  ${theme.command("gh auth login")}`;
+  }
+  if (service === "gitlab") {
+    return `  ${theme.command("bragduck auth gitlab")}`;
+  }
+  if (service === "bitbucket" || service === "atlassian") {
+    return `  ${theme.command("bragduck auth atlassian")}`;
+  }
+  return `  ${theme.command("bragduck auth login")}`;
+}
 function getErrorHint(error, sourceType) {
   if (error.name === "GitHubError") {
     return 'Make sure you are in a GitHub repository and have authenticated with "gh auth login"';
@@ -6312,6 +7459,9 @@ function getErrorHint(error, sourceType) {
     }
     return 'Run "bragduck auth login" to login again';
   }
+  if (error.name === "GoogleDocsError") {
+    return 'Run "bragduck auth google" to re-authenticate with Google';
+  }
   if (error.name === "NetworkError") {
     return "Check your internet connection and try again";
   }
@@ -6391,6 +7541,7 @@ init_api_service();
 import boxen7 from "boxen";
 import Table2 from "cli-table3";
 init_logger();
+init_auth_service();
 async function listCommand(options = {}) {
   logger.log("");
   try {
@@ -6423,6 +7574,7 @@ async function listCommand(options = {}) {
       return;
     }
     succeedSpinner(spinner, `Found ${response.total} brag${response.total > 1 ? "s" : ""}`);
+    showCommandHeader(authService.getUserInfo());
     logger.log("");
     if (options.oneline) {
       logger.log(formatBragsOneline(response.brags));
@@ -6756,13 +7908,15 @@ function getConfigHint(error) {
 // src/cli.ts
 init_version();
 init_logger();
-var __filename7 = fileURLToPath7(import.meta.url);
-var __dirname7 = dirname6(__filename7);
-var packageJsonPath = join8(__dirname7, "../../package.json");
-var packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+var __filename9 = fileURLToPath9(import.meta.url);
+var __dirname9 = dirname8(__filename9);
+var packageJsonPath = join10(__dirname9, "../../package.json");
+var packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
 var program = new Command();
 program.name("bragduck").description("CLI tool for managing developer achievements and brags\nAliases: duck, brag").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information").option("--skip-version-check", "Skip automatic version check on startup").option("--debug", "Enable debug mode (shows detailed logs)");
-program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status, bitbucket, gitlab)").action(async (subcommand) => {
+program.command("auth [subcommand]").description(
+  "Manage authentication (subcommands: login, status, github, gitlab, bitbucket, atlassian, google, slack)"
+).action(async (subcommand) => {
   try {
     await authCommand(subcommand);
   } catch (error) {