@plosson/agentio 0.5.15 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.5.15",
+  "version": "0.7.0",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",

package/src/auth/oauth.ts

@@ -15,6 +15,7 @@ const GCHAT_SCOPES = [
   'https://www.googleapis.com/auth/chat.messages.readonly',   // read messages (get operations)
   'https://www.googleapis.com/auth/chat.spaces.readonly',     // read space info and list
   'https://www.googleapis.com/auth/chat.memberships.readonly', // read space members
+  'https://www.googleapis.com/auth/directory.readonly',        // resolve user IDs to names/emails via People API
   'https://www.googleapis.com/auth/userinfo.email',           // get user email for profile naming
 ];
 

package/src/mcp/server.ts

@@ -197,6 +197,9 @@ export async function startMcpServer(
     process.exit(1);
   }
 
+  // Track last-checked timestamps per service:space for automatic --since injection
+  const lastChecked = new Map<string, Date>();
+
   // Create MCP server
   const server = new Server(
     { name: 'agentio', version: '1.0.0' },
@@ -230,6 +233,8 @@ export async function startMcpServer(
     const service = tool.commandPath[0];
     const profile = profileMap.get(service);
 
+    const input = (args as Record<string, unknown>) || {};
+
     // Build a fresh program for each call to avoid state leaks
     const execProgram = buildProgram(services);
 
@@ -237,11 +242,23 @@ export async function startMcpServer(
       const output = await executeCommand(
         execProgram,
         tool,
-        (args as Record<string, unknown>) || {},
+        input,
         profile
       );
+
+      // For list commands, append last-checked info and update timestamp
+      let result = output || '(no output)';
+      if (name === 'gchat_list' && input.space) {
+        const key = `gchat:${input.space}`;
+        const last = lastChecked.get(key);
+        if (last) {
+          result += `\n\nPreviously checked: ${last.toISOString()}`;
+        }
+        lastChecked.set(key, new Date());
+      }
+
       return {
-        content: [{ type: 'text' as const, text: output || '(no output)' }],
+        content: [{ type: 'text' as const, text: result }],
       };
     } catch (error: unknown) {
       const message =

package/src/services/gchat/client.ts

@@ -15,8 +15,15 @@ import type {
   GChatSpace,
 } from '../../types/gchat';
 
+interface ResolvedUser {
+  displayName: string;
+  email?: string;
+}
+
 export class GChatClient implements ServiceClient {
   private credentials: GChatCredentials;
+  private userCache = new Map<string, ResolvedUser>();
+  private spaceIdCache = new Map<string, string>();
 
   constructor(credentials: GChatCredentials) {
     this.credentials = credentials;
@@ -46,9 +53,11 @@ export class GChatClient implements ServiceClient {
   async send(options: GChatSendOptions & { spaceId?: string }): Promise<GChatSendResult> {
     if (this.credentials.type === 'webhook') {
       return this.sendViaWebhook(options);
-    } else {
-      return this.sendViaOAuth(options);
     }
+    if (options.spaceId) {
+      options.spaceId = await this.resolveSpaceId(options.spaceId);
+    }
+    return this.sendViaOAuth(options);
   }
 
   async list(options: GChatListOptions): Promise<GChatMessage[]> {
@@ -66,6 +75,7 @@ export class GChatClient implements ServiceClient {
         'Use an OAuth profile to read messages'
       );
     }
+    options.spaceId = await this.resolveSpaceId(options.spaceId);
     return this.listViaOAuth(options);
   }
 
@@ -84,6 +94,7 @@ export class GChatClient implements ServiceClient {
         'Use an OAuth profile to read messages'
       );
     }
+    options.spaceId = await this.resolveSpaceId(options.spaceId);
     return this.getViaOAuth(options);
   }
 
@@ -223,6 +234,11 @@ export class GChatClient implements ServiceClient {
       });
 
       const messages = response.data.messages || [];
+
+      // Resolve unique sender IDs to display names via People API
+      const senderIds = [...new Set(messages.map(m => m.sender?.name).filter(Boolean))] as string[];
+      await this.resolveUsers(senderIds, auth);
+
       return messages.map((msg: chat_v1.Schema$Message) => {
         const gchatMsg: GChatMessage = {
           name: msg.name || '',
@@ -231,12 +247,7 @@ export class GChatClient implements ServiceClient {
           updateTime: (msg as Record<string, unknown>).lastUpdateTime as string || new Date().toISOString(),
         };
         if (msg.text) gchatMsg.text = msg.text;
-        if (msg.sender?.name) {
-          gchatMsg.sender = {
-            name: msg.sender.name,
-            displayName: msg.sender.displayName || msg.sender.name,
-          };
-        }
+        gchatMsg.sender = this.enrichSender(msg);
         if (msg.thread?.name) {
           gchatMsg.thread = {
             name: msg.thread.name,
@@ -270,6 +281,12 @@ export class GChatClient implements ServiceClient {
       }
 
       const msg = response.data as chat_v1.Schema$Message;
+
+      // Resolve sender
+      if (msg.sender?.name) {
+        await this.resolveUsers([msg.sender.name], auth);
+      }
+
       const gchatMsg: GChatMessage = {
         name: msg.name || '',
         createTime: msg.createTime || new Date().toISOString(),
@@ -277,12 +294,7 @@ export class GChatClient implements ServiceClient {
         updateTime: (msg as Record<string, unknown>).lastUpdateTime as string || new Date().toISOString(),
       };
       if (msg.text) gchatMsg.text = msg.text;
-      if (msg.sender?.name) {
-        gchatMsg.sender = {
-          name: msg.sender.name,
-          displayName: msg.sender.displayName || msg.sender.name,
-        };
-      }
+      gchatMsg.sender = this.enrichSender(msg);
       if (msg.thread?.name) {
         gchatMsg.thread = {
           name: msg.thread.name,
@@ -306,15 +318,29 @@ export class GChatClient implements ServiceClient {
     const chat = gchat({ version: 'v1', auth: auth as any });
 
     try {
-      const response = await chat.spaces.list({});
-
-      const spaces = response.data.spaces || [];
-      return spaces.map((space: chat_v1.Schema$Space) => ({
-        name: space.name || '',
-        displayName: space.displayName || 'Unnamed',
-        type: (space.type as 'ROOM' | 'DM') || 'ROOM',
-        description: space.spaceDetails?.description || undefined,
-      }));
+      const allSpaces: GChatSpace[] = [];
+      let pageToken: string | undefined;
+
+      do {
+        const response = await chat.spaces.list({
+          pageSize: 100,
+          pageToken,
+        });
+
+        const spaces = response.data.spaces || [];
+        for (const space of spaces) {
+          allSpaces.push({
+            name: space.name || '',
+            displayName: space.displayName || 'Unnamed',
+            type: (space.type as 'ROOM' | 'DM') || 'ROOM',
+            description: space.spaceDetails?.description || undefined,
+          });
+        }
+
+        pageToken = response.data.nextPageToken || undefined;
+      } while (pageToken);
+
+      return allSpaces;
     } catch (err) {
       const code = this.getErrorCode(err);
       const message = this.getErrorMessage(err);
@@ -326,6 +352,88 @@ export class GChatClient implements ServiceClient {
     }
   }
 
+  /**
+   * Resolve a space identifier that may be an ID or a display name.
+   * Tries as ID first (no API call), falls back to name resolution via listSpaces.
+   * Results are cached for the lifetime of this client instance.
+   */
+  private async resolveSpaceId(spaceIdOrName: string): Promise<string> {
+    // Check cache first
+    const cached = this.spaceIdCache.get(spaceIdOrName);
+    if (cached) return cached;
+
+    const oauthCreds = this.credentials as GChatOAuthCredentials;
+    const auth = this.createOAuthClient(oauthCreds);
+    const chat = gchat({ version: 'v1', auth: auth as any });
+
+    // Try as ID first
+    try {
+      const resp = await chat.spaces.get({ name: `spaces/${spaceIdOrName}` });
+      if (resp.data.name) {
+        this.spaceIdCache.set(spaceIdOrName, spaceIdOrName);
+        return spaceIdOrName;
+      }
+    } catch {
+      // Not a valid ID, try as display name
+    }
+
+    // Resolve by display name
+    const spaces = await this.listSpacesViaOAuth();
+    const nameLower = spaceIdOrName.toLowerCase();
+    const match = spaces.find(s => s.displayName.toLowerCase() === nameLower);
+
+    if (!match) {
+      throw new CliError(
+        'NOT_FOUND',
+        `Space not found: "${spaceIdOrName}"`,
+        'Use "agentio gchat spaces" to list available spaces'
+      );
+    }
+
+    const id = match.name.replace('spaces/', '');
+    this.spaceIdCache.set(spaceIdOrName, id);
+    return id;
+  }
+
+  private async resolveUsers(userIds: string[], auth: OAuth2Client): Promise<void> {
+    const unknown = userIds.filter(id => !this.userCache.has(id));
+    if (unknown.length === 0) return;
+
+    const token = await auth.getAccessToken();
+    if (!token.token) return;
+
+    // Resolve users in parallel via People API
+    await Promise.all(unknown.map(async (userId) => {
+      try {
+        // userId is like "users/123456", extract the numeric part
+        const personId = userId.replace('users/', '');
+        const res = await fetch(
+          `https://people.googleapis.com/v1/people/${personId}?personFields=names,emailAddresses`,
+          { headers: { Authorization: `Bearer ${token.token}` } }
+        );
+        if (!res.ok) return;
+        const data = await res.json() as Record<string, any>;
+        const name = data.names?.[0]?.displayName;
+        const email = data.emailAddresses?.[0]?.value;
+        if (name) {
+          this.userCache.set(userId, { displayName: name, email });
+        }
+      } catch {
+        // Silently skip unresolvable users
+      }
+    }));
+  }
+
+  private enrichSender(msg: chat_v1.Schema$Message): GChatMessage['sender'] {
+    if (!msg.sender?.name) return undefined;
+    const cached = this.userCache.get(msg.sender.name);
+    return {
+      name: msg.sender.name,
+      displayName: cached?.displayName || msg.sender.displayName || msg.sender.name,
+      email: cached?.email,
+    };
+  }
+
   private getErrorCode(err: unknown): ErrorCode {
     if (err && typeof err === 'object') {
       const error = err as Record<string, unknown>;

package/src/types/gchat.ts

@@ -1,6 +1,7 @@
 export interface GChatSender {
   name: string;
   displayName: string;
+  email?: string;
   avatarUrl?: string;
 }
 

package/src/utils/output.ts

@@ -132,7 +132,10 @@ export function printGChatMessageList(messages: GChatMessage[]): void {
     const msg = messages[i];
     console.log(`[${i + 1}] ${msg.name}`);
     if (msg.sender) {
-      console.log(`    From: ${msg.sender.displayName || 'Unknown'}`);
+      const from = msg.sender.email
+        ? `${msg.sender.displayName} <${msg.sender.email}>`
+        : msg.sender.displayName || 'Unknown';
+      console.log(`    From: ${from}`);
     }
     if (msg.text) {
       const snippet = msg.text.length > 100 ? msg.text.substring(0, 100) + '...' : msg.text;
@@ -146,7 +149,10 @@ export function printGChatMessageList(messages: GChatMessage[]): void {
 export function printGChatMessage(msg: GChatMessage): void {
   console.log(`ID: ${msg.name}`);
   if (msg.sender) {
-    console.log(`From: ${msg.sender.displayName || 'Unknown'}`);
+    const from = msg.sender.email
+      ? `${msg.sender.displayName} <${msg.sender.email}>`
+      : msg.sender.displayName || 'Unknown';
+    console.log(`From: ${from}`);
   }
   console.log(`Date: ${msg.createTime}`);
   if (msg.thread) {