@plosson/agentio 0.5.7 → 0.5.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",
@@ -55,8 +55,9 @@
     "@inquirer/prompts": "^8.2.0",
     "@whiskeysockets/baileys": "^7.0.0-rc.9",
     "commander": "^14.0.2",
-    "google-auth-library": "^9.0.0",
+    "google-auth-library": "^10.0.0",
     "libsodium-wrappers": "^0.8.1",
+    "long": "^5.3.2",
     "qrcode-terminal": "^0.12.0",
     "rss-parser": "^3.13.0"
   }

package/src/auth/oauth.ts

@@ -7,6 +7,7 @@ const GMAIL_SCOPES = [
   'https://www.googleapis.com/auth/gmail.readonly',  // search & read emails
   'https://www.googleapis.com/auth/gmail.send',      // send emails
   'https://www.googleapis.com/auth/gmail.compose',   // create/update drafts
+  'https://www.googleapis.com/auth/userinfo.email',  // get email for profile naming
 ];
 
 const GCHAT_SCOPES = [

package/src/commands/gcal.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { calendar } from '@googleapis/calendar';
 import { getValidTokens, createGoogleAuth, fetchGoogleUserEmail } from '../auth/token-manager';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { performOAuthFlow } from '../auth/oauth';
 import { GCalClient } from '../services/gcal/client';
@@ -373,7 +373,16 @@ export function registerGCalCommands(program: Command): void {
           throw new CliError('AUTH_FAILED', 'Could not fetch email from Calendar', 'Try again or specify --profile manually');
         }
 
-        const profileName = options.profile || email;
+        // Determine profile name: use explicit --profile, or email, or email-readonly if conflict
+        let profileName: string;
+        if (options.profile) {
+          profileName = options.profile;
+        } else if (options.readOnly && await getProfile('gcal', email)) {
+          // Profile with email already exists, use -readonly suffix
+          profileName = `${email}-readonly`;
+        } else {
+          profileName = email;
+        }
 
         await setProfile('gcal', profileName, { readOnly: options.readOnly });
         await setCredentials('gcal', profileName, { ...tokens, email });

package/src/commands/gchat.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { chat as gchat } from '@googleapis/chat';
 import { readFile } from 'fs/promises';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { createClientGetter } from '../utils/client-factory';
 import { performOAuthFlow } from '../auth/oauth';
@@ -309,7 +309,16 @@ async function setupOAuthProfile(profileNameOverride?: string, readOnly?: boolea
     );
   }
 
-  const profileName = profileNameOverride || userEmail;
+  // Determine profile name: use explicit override, or email, or email-readonly if conflict
+  let profileName: string;
+  if (profileNameOverride) {
+    profileName = profileNameOverride;
+  } else if (readOnly && await getProfile('gchat', userEmail)) {
+    // Profile with email already exists, use -readonly suffix
+    profileName = `${userEmail}-readonly`;
+  } else {
+    profileName = userEmail;
+  }
 
   const credentials: GChatOAuthCredentials = {
     type: 'oauth',

package/src/commands/gdocs.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { writeFile } from 'fs/promises';
 import { createGoogleAuth, fetchGoogleUserEmail } from '../auth/token-manager';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { createClientGetter } from '../utils/client-factory';
 import { performOAuthFlow } from '../auth/oauth';
@@ -159,7 +159,16 @@ Query Syntax Examples:
           );
         }
 
-        const profileName = options.profile || userEmail;
+        // Determine profile name: use explicit --profile, or email, or email-readonly if conflict
+        let profileName: string;
+        if (options.profile) {
+          profileName = options.profile;
+        } else if (options.readOnly && await getProfile('gdocs', userEmail)) {
+          // Profile with email already exists, use -readonly suffix
+          profileName = `${userEmail}-readonly`;
+        } else {
+          profileName = userEmail;
+        }
 
         const credentials: GDocsCredentials = {
           accessToken: tokens.access_token,

package/src/commands/gdrive.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { createGoogleAuth, fetchGoogleUserEmail } from '../auth/token-manager';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { createClientGetter } from '../utils/client-factory';
 import { performOAuthFlow } from '../auth/oauth';
@@ -258,7 +258,16 @@ Examples:
           );
         }
 
-        const profileName = options.profile || userEmail;
+        // Determine profile name: use explicit --profile, or email, or email-readonly if conflict
+        let profileName: string;
+        if (options.profile) {
+          profileName = options.profile;
+        } else if (options.readOnly && await getProfile('gdrive', userEmail)) {
+          // Profile with email already exists, use -readonly suffix
+          profileName = `${userEmail}-readonly`;
+        } else {
+          profileName = userEmail;
+        }
 
         const credentials: GDriveCredentials = {
           accessToken: tokens.access_token,

package/src/commands/gmail.ts

@@ -3,7 +3,7 @@ import { basename, join } from 'path';
 import { tmpdir } from 'os';
 import { getValidTokens, createGoogleAuth, fetchGoogleUserEmail } from '../auth/token-manager';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { performOAuthFlow } from '../auth/oauth';
 import { GmailClient } from '../services/gmail/client';
@@ -477,7 +477,16 @@ ${emailHeader}
           throw new CliError('AUTH_FAILED', 'Could not fetch email from Gmail', 'Try again or specify --profile manually');
         }
 
-        const profileName = options.profile || email;
+        // Determine profile name: use explicit --profile, or email, or email-readonly if conflict
+        let profileName: string;
+        if (options.profile) {
+          profileName = options.profile;
+        } else if (options.readOnly && await getProfile('gmail', email)) {
+          // Profile with email already exists, use -readonly suffix
+          profileName = `${email}-readonly`;
+        } else {
+          profileName = email;
+        }
 
         await setProfile('gmail', profileName, { readOnly: options.readOnly });
         await setCredentials('gmail', profileName, { ...tokens, email });

package/src/commands/gsheets.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { writeFile } from 'fs/promises';
 import { createGoogleAuth, fetchGoogleUserEmail } from '../auth/token-manager';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { createClientGetter } from '../utils/client-factory';
 import { performOAuthFlow } from '../auth/oauth';
@@ -341,7 +341,16 @@ Examples:
           throw new CliError('AUTH_FAILED', `Failed to fetch user email: ${errorMessage}`, 'Ensure the account has an email address');
         }
 
-        const profileName = options.profile || userEmail;
+        // Determine profile name: use explicit --profile, or email, or email-readonly if conflict
+        let profileName: string;
+        if (options.profile) {
+          profileName = options.profile;
+        } else if (options.readOnly && await getProfile('gsheets', userEmail)) {
+          // Profile with email already exists, use -readonly suffix
+          profileName = `${userEmail}-readonly`;
+        } else {
+          profileName = userEmail;
+        }
 
         const credentials: GSheetsCredentials = {
           accessToken: tokens.access_token,

package/src/commands/gtasks.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { getValidTokens, createGoogleAuth, fetchGoogleUserEmail } from '../auth/token-manager';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { performOAuthFlow } from '../auth/oauth';
 import { GTasksClient } from '../services/gtasks/client';
@@ -320,7 +320,16 @@ export function registerGTasksCommands(program: Command): void {
           throw new CliError('AUTH_FAILED', 'Could not fetch email', 'Try again or specify --profile manually');
         }
 
-        const profileName = options.profile || email;
+        // Determine profile name: use explicit --profile, or email, or email-readonly if conflict
+        let profileName: string;
+        if (options.profile) {
+          profileName = options.profile;
+        } else if (options.readOnly && await getProfile('gtasks', email)) {
+          // Profile with email already exists, use -readonly suffix
+          profileName = `${email}-readonly`;
+        } else {
+          profileName = email;
+        }
 
         await setProfile('gtasks', profileName, { readOnly: options.readOnly });
         await setCredentials('gtasks', profileName, { ...tokens, email });

package/src/commands/reauth.ts

@@ -0,0 +1,278 @@
+import { Command } from 'commander';
+import { getProfileStatuses, type ProfileStatus } from './status';
+import { getCredentials, setCredentials } from '../auth/token-store';
+import { performOAuthFlow, type OAuthService } from '../auth/oauth';
+import { performGitHubOAuthFlow } from '../auth/github-oauth';
+import { performJiraOAuthFlow, type AtlassianSite } from '../auth/jira-oauth';
+import { fetchGoogleUserEmail } from '../auth/token-manager';
+import { GitHubClient } from '../services/github/client';
+import { interactiveCheckbox, interactiveSelect } from '../utils/interactive';
+import { handleError } from '../utils/errors';
+import type { ServiceName } from '../types/config';
+import type { GDocsCredentials } from '../types/gdocs';
+import type { GDriveCredentials } from '../types/gdrive';
+import type { GChatCredentials } from '../types/gchat';
+import type { GSheetsCredentials } from '../types/gsheets';
+import type { GitHubCredentials } from '../types/github';
+import type { JiraCredentials } from '../types/jira';
+import type { OAuthTokens } from '../types/tokens';
+
+type GmailCredentials = OAuthTokens & { email?: string };
+type GCalCredentials = OAuthTokens & { email?: string };
+type GTasksCredentials = OAuthTokens & { email?: string };
+
+// Services that use Google OAuth and store { ...tokens, email }
+const GOOGLE_SIMPLE_SERVICES: ServiceName[] = ['gmail', 'gcal', 'gtasks'];
+
+// Services that use Google OAuth with custom credential objects
+const GOOGLE_CUSTOM_SERVICES: ServiceName[] = ['gdocs', 'gsheets'];
+
+// Services that require manual credential setup
+const MANUAL_SERVICES: ServiceName[] = ['telegram', 'slack', 'discourse', 'sql'];
+
+async function reauthGoogleSimple(
+  service: ServiceName,
+  profileName: string
+): Promise<void> {
+  const oauthService = service as OAuthService;
+  console.error(`\nRe-authenticating ${service} / ${profileName}...`);
+
+  const tokens = await performOAuthFlow(oauthService);
+  const email = await fetchGoogleUserEmail(tokens.access_token);
+
+  // Preserve existing credential fields, update tokens and email
+  const existing = await getCredentials<GmailCredentials | GCalCredentials | GTasksCredentials>(service, profileName);
+  await setCredentials(service, profileName, { ...existing, ...tokens, email });
+
+  console.error(`  Done (${email})`);
+}
+
+async function reauthGoogleCustom(
+  service: ServiceName,
+  profileName: string
+): Promise<void> {
+  const oauthService = service as OAuthService;
+  console.error(`\nRe-authenticating ${service} / ${profileName}...`);
+
+  const tokens = await performOAuthFlow(oauthService);
+  const email = await fetchGoogleUserEmail(tokens.access_token);
+
+  const existing = await getCredentials<GDocsCredentials | GSheetsCredentials>(service, profileName);
+  const credentials = {
+    ...existing,
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiryDate: tokens.expiry_date,
+    tokenType: tokens.token_type,
+    scope: tokens.scope,
+    email,
+  };
+
+  await setCredentials(service, profileName, credentials);
+  console.error(`  Done (${email})`);
+}
+
+async function reauthGDrive(profileName: string): Promise<void> {
+  console.error(`\nRe-authenticating gdrive / ${profileName}...`);
+
+  // Read existing credentials to preserve accessLevel
+  const existing = await getCredentials<GDriveCredentials>('gdrive', profileName);
+  const accessLevel = existing?.accessLevel || 'readonly';
+  const oauthService: OAuthService = accessLevel === 'full' ? 'gdrive-full' : 'gdrive-readonly';
+
+  const tokens = await performOAuthFlow(oauthService);
+  const email = await fetchGoogleUserEmail(tokens.access_token);
+
+  const credentials: GDriveCredentials = {
+    ...existing,
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiryDate: tokens.expiry_date,
+    tokenType: tokens.token_type,
+    scope: tokens.scope,
+    email,
+    accessLevel,
+  };
+
+  await setCredentials('gdrive', profileName, credentials);
+  console.error(`  Done (${email}, ${accessLevel})`);
+}
+
+async function reauthGChat(profileName: string): Promise<void> {
+  const existing = await getCredentials<GChatCredentials>('gchat', profileName);
+
+  if (existing?.type === 'webhook') {
+    console.error(`\nSkipping gchat / ${profileName}: webhook profiles don't expire. Run 'agentio gchat profile add' to update.`);
+    return;
+  }
+
+  console.error(`\nRe-authenticating gchat / ${profileName}...`);
+
+  const tokens = await performOAuthFlow('gchat');
+  const email = await fetchGoogleUserEmail(tokens.access_token);
+
+  const credentials = {
+    ...existing,
+    type: 'oauth' as const,
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiryDate: tokens.expiry_date,
+    tokenType: tokens.token_type,
+    scope: tokens.scope,
+    email,
+  };
+
+  await setCredentials('gchat', profileName, credentials);
+  console.error(`  Done (${email})`);
+}
+
+async function reauthGitHub(profileName: string): Promise<void> {
+  console.error(`\nRe-authenticating github / ${profileName}...`);
+
+  const oauthResult = await performGitHubOAuthFlow();
+
+  // Fetch updated user info
+  const tempCreds: GitHubCredentials = {
+    accessToken: oauthResult.accessToken,
+    username: '',
+    email: null,
+  };
+  const client = new GitHubClient(tempCreds);
+  const user = await client.getUser();
+
+  // Preserve existing fields, update token and user info
+  const existing = await getCredentials<GitHubCredentials>('github', profileName);
+  const credentials: GitHubCredentials = {
+    ...existing,
+    accessToken: oauthResult.accessToken,
+    username: user.login,
+    email: user.email,
+  };
+
+  await setCredentials('github', profileName, credentials);
+  console.error(`  Done (${user.login})`);
+}
+
+async function reauthJira(profileName: string): Promise<void> {
+  console.error(`\nRe-authenticating jira / ${profileName}...`);
+
+  const selectSite = async (sites: AtlassianSite[]): Promise<AtlassianSite> => {
+    return interactiveSelect({
+      message: 'Select a JIRA site:',
+      choices: sites.map((site) => ({
+        name: site.name,
+        value: site,
+        description: site.url,
+      })),
+    });
+  };
+
+  const result = await performJiraOAuthFlow(selectSite);
+
+  const existing = await getCredentials<JiraCredentials>('jira', profileName);
+  const credentials: JiraCredentials = {
+    ...existing,
+    accessToken: result.accessToken,
+    refreshToken: result.refreshToken,
+    expiryDate: result.expiryDate,
+    cloudId: result.cloudId,
+    siteUrl: result.siteUrl,
+  };
+
+  await setCredentials('jira', profileName, credentials);
+  console.error(`  Done (${result.siteUrl})`);
+}
+
+async function reauthProfile(service: ServiceName, profileName: string): Promise<void> {
+  if (GOOGLE_SIMPLE_SERVICES.includes(service)) {
+    await reauthGoogleSimple(service, profileName);
+    return;
+  }
+
+  if (GOOGLE_CUSTOM_SERVICES.includes(service)) {
+    await reauthGoogleCustom(service, profileName);
+    return;
+  }
+
+  switch (service) {
+    case 'gdrive':
+      await reauthGDrive(profileName);
+      break;
+
+    case 'gchat':
+      await reauthGChat(profileName);
+      break;
+
+    case 'github':
+      await reauthGitHub(profileName);
+      break;
+
+    case 'jira':
+      await reauthJira(profileName);
+      break;
+
+    case 'whatsapp':
+      console.error(`\nSkipping whatsapp / ${profileName}: use 'agentio whatsapp profile add' to re-pair.`);
+      break;
+
+    default:
+      if (MANUAL_SERVICES.includes(service)) {
+        console.error(`\nSkipping ${service} / ${profileName}: uses manual credentials. Run 'agentio ${service} profile add' to update.`);
+      }
+      break;
+  }
+}
+
+export function registerReauthCommand(program: Command): void {
+  program
+    .command('reauth')
+    .description('Re-authenticate expired or invalid profiles')
+    .option('--all', 'Re-authenticate all invalid profiles without prompting')
+    .action(async (options) => {
+      try {
+        console.error('Checking profile credentials...\n');
+
+        const statuses = await getProfileStatuses();
+        const invalid = statuses.filter(
+          (s) => s.status === 'invalid' || s.status === 'no-creds'
+        );
+
+        if (invalid.length === 0) {
+          console.log('All profiles are valid.');
+          return;
+        }
+
+        let selected: ProfileStatus[];
+
+        if (options.all) {
+          selected = invalid;
+        } else {
+          const choices = invalid.map((s) => ({
+            name: `${s.service} / ${s.profile} (${s.error || 'no credentials'})`,
+            value: s,
+            checked: true,
+          }));
+
+          selected = await interactiveCheckbox({
+            message: 'Select profiles to re-authenticate:',
+            choices,
+            required: true,
+          });
+        }
+
+        for (const s of selected) {
+          try {
+            await reauthProfile(s.service, s.profile);
+          } catch (error) {
+            console.error(
+              `\n  Failed to reauth ${s.service} / ${s.profile}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+
+        console.log('\nDone.');
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/status.ts

@@ -14,6 +14,7 @@ import { JiraClient } from '../services/jira/client';
 import { GChatClient } from '../services/gchat/client';
 import { SlackClient } from '../services/slack/client';
 import { DiscourseClient } from '../services/discourse/client';
+import { GSheetsClient } from '../services/gsheets/client';
 import { SqlClient } from '../services/sql/client';
 import type { ServiceClient, ValidationResult } from '../types/service';
 import type { ServiceName } from '../types/config';
@@ -26,6 +27,7 @@ import type { GDriveCredentials } from '../types/gdrive';
 import type { GCalCredentials } from '../types/gcal';
 import type { GTasksCredentials } from '../types/gtasks';
 import type { GChatCredentials } from '../types/gchat';
+import type { GSheetsCredentials } from '../types/gsheets';
 import type { SlackCredentials } from '../types/slack';
 import type { DiscourseCredentials } from '../types/discourse';
 import type { SqlCredentials } from '../types/sql';
@@ -66,6 +68,11 @@ async function createServiceClient(
       return new GDriveClient(creds);
     }
 
+    case 'gsheets': {
+      const creds = credentials as GSheetsCredentials;
+      return new GSheetsClient(creds);
+    }
+
     case 'gcal': {
       const creds = credentials as GCalCredentials;
       const auth = createGoogleAuth({
@@ -240,8 +247,8 @@ async function createServiceClient(
   }
 }
 
-interface ProfileStatus {
-  service: string;
+export interface ProfileStatus {
+  service: ServiceName;
   profile: string;
   readOnly?: boolean;
   status: 'ok' | 'invalid' | 'no-creds' | 'skipped';
@@ -249,6 +256,58 @@ interface ProfileStatus {
   error?: string;
 }
 
+export async function getProfileStatuses(options?: { test?: boolean }): Promise<ProfileStatus[]> {
+  const shouldTest = options?.test !== false;
+  const allProfiles = await listProfiles();
+  const statuses: ProfileStatus[] = [];
+
+  for (const { service, profiles } of allProfiles) {
+    for (const entry of profiles) {
+      const credentials = await getCredentials(service, entry.name);
+
+      if (!credentials) {
+        statuses.push({
+          service,
+          profile: entry.name,
+          readOnly: entry.readOnly,
+          status: 'no-creds',
+        });
+        continue;
+      }
+
+      if (!shouldTest) {
+        statuses.push({
+          service,
+          profile: entry.name,
+          readOnly: entry.readOnly,
+          status: 'skipped',
+        });
+        continue;
+      }
+
+      const client = await createServiceClient(service, credentials, entry.name);
+      let result: ValidationResult;
+
+      if (client) {
+        result = await client.validate();
+      } else {
+        result = { valid: true, info: 'unknown service' };
+      }
+
+      statuses.push({
+        service,
+        profile: entry.name,
+        readOnly: entry.readOnly,
+        status: result.valid ? 'ok' : 'invalid',
+        info: result.info,
+        error: result.error,
+      });
+    }
+  }
+
+  return statuses;
+}
+
 export function registerStatusCommand(program: Command): void {
   program
     .command('status')
@@ -257,57 +316,11 @@ export function registerStatusCommand(program: Command): void {
     .option('--json', 'Output in JSON format')
     .action(async (options) => {
       try {
-        const allProfiles = await listProfiles();
         const version = program.version();
         const envVars = await listEnv();
         const envKeys = Object.keys(envVars).sort();
 
-        // Collect all profile statuses
-        const statuses: ProfileStatus[] = [];
-
-        for (const { service, profiles } of allProfiles) {
-          for (const entry of profiles) {
-            const credentials = await getCredentials(service, entry.name);
-
-            if (!credentials) {
-              statuses.push({
-                service,
-                profile: entry.name,
-                readOnly: entry.readOnly,
-                status: 'no-creds',
-              });
-              continue;
-            }
-
-            if (options.test === false) {
-              statuses.push({
-                service,
-                profile: entry.name,
-                readOnly: entry.readOnly,
-                status: 'skipped',
-              });
-              continue;
-            }
-
-            const client = await createServiceClient(service, credentials, entry.name);
-            let result: ValidationResult;
-
-            if (client) {
-              result = await client.validate();
-            } else {
-              result = { valid: true, info: 'unknown service' };
-            }
-
-            statuses.push({
-              service,
-              profile: entry.name,
-              readOnly: entry.readOnly,
-              status: result.valid ? 'ok' : 'invalid',
-              info: result.info,
-              error: result.error,
-            });
-          }
-        }
+        const statuses = await getProfileStatuses({ test: options.test });
 
         // JSON output mode
         if (options.json) {

package/src/index.ts

@@ -24,6 +24,7 @@ import { registerClaudeCommands } from './commands/claude';
 import { registerConfigCommands } from './commands/config';
 import { registerDocsCommand } from './commands/docs';
 import { registerGatewayCommands } from './commands/gateway';
+import { registerReauthCommand } from './commands/reauth';
 import { registerStatusCommand } from './commands/status';
 import { registerUpdateCommand } from './commands/update';
 
@@ -66,6 +67,7 @@ registerClaudeCommands(program);
 registerConfigCommands(program);
 registerDocsCommand(program);
 registerGatewayCommands(program);
+registerReauthCommand(program);
 registerStatusCommand(program);
 registerUpdateCommand(program);
 

package/src/polyfills.ts

@@ -2,9 +2,9 @@
 // This must be imported BEFORE any code that uses protobufjs (e.g., Baileys)
 
 import Long from 'long';
-import protobuf from 'protobufjs';
 
-// Fix for protobufjs Long support in Bun native binaries
-// Without this, $util.Long.fromBits is undefined at runtime
-protobuf.util.Long = Long;
-protobuf.configure();
+// Fix for protobufjs Long support in Bun native binaries.
+// protobufjs/minimal uses inquire("long") with eval-based require that fails in Bun bundles.
+// It falls back to checking global.Long (util/minimal.js:181), so we set it on globalThis
+// BEFORE any protobufjs code initializes (WAProto evaluates $util.Long at module load time).
+(globalThis as any).Long = Long;

package/src/services/gchat/client.ts

@@ -33,7 +33,7 @@ export class GChatClient implements ServiceClient {
       const auth = this.createOAuthClient(oauthCreds);
       const chat = gchat({ version: 'v1', auth: auth as any });
       await chat.spaces.list({ pageSize: 1 });
-      return { valid: true, info: 'oauth' };
+      return { valid: true, info: oauthCreds.email || 'oauth' };
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Unknown error';
       if (message.includes('invalid_grant') || message.includes('Token has been expired or revoked')) {