m365-agent-cli 1.2.0

package/src/commands/send.ts

@@ -0,0 +1,204 @@
+import { readFile } from 'node:fs/promises';
+import { Command } from 'commander';
+import { AttachmentLinkSpecError, parseAttachLinkSpec } from '../lib/attach-link-spec.js';
+import { AttachmentPathError, validateAttachmentPath } from '../lib/attachments.js';
+import { resolveAuth } from '../lib/auth.js';
+import { type EmailAttachment, type ReferenceAttachmentInput, sendEmail } from '../lib/ews-client.js';
+import { markdownToHtml } from '../lib/markdown.js';
+import { lookupMimeType } from '../lib/mime-type.js';
+import { checkReadOnly } from '../lib/utils.js';
+
+export const sendCommand = new Command('send')
+  .description('Send an email')
+  .requiredOption('--to <emails>', 'Recipient email(s), comma-separated')
+  .requiredOption('--subject <text>', 'Email subject')
+  .option('--body <text>', 'Email body', '')
+  .option('--category <name>', 'Category label (repeatable)', (v, acc) => [...acc, v], [] as string[])
+  .option('--cc <emails>', 'CC recipient(s), comma-separated')
+  .option('--bcc <emails>', 'BCC recipient(s), comma-separated')
+  .option('--attach <files>', 'Attach file(s), comma-separated paths')
+  .option(
+    '--attach-link <spec>',
+    'Attach link: "Title|https://url" or bare https URL (repeatable)',
+    (v: string, prev: string[]) => [...prev, v],
+    [] as string[]
+  )
+  .option('--html', 'Send body as HTML')
+  .option('--markdown', 'Parse body as markdown (bold, links, lists)')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--mailbox <email>', 'Send from shared mailbox (Send As)')
+  .option('--identity <name>', 'Use a specific authentication identity (default: default)')
+  .action(
+    async (
+      options: {
+        to: string;
+        subject: string;
+        body?: string;
+        cc?: string;
+        bcc?: string;
+        attach?: string;
+        attachLink?: string[];
+        html?: boolean;
+        markdown?: boolean;
+        json?: boolean;
+        token?: string;
+        mailbox?: string;
+        identity?: string;
+        category?: string[];
+      },
+      cmd: any
+    ) => {
+      checkReadOnly(cmd);
+      const authResult = await resolveAuth({
+        token: options.token,
+        identity: options.identity
+      });
+
+      if (!authResult.success) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: authResult.error }, null, 2));
+        } else {
+          console.error(`Error: ${authResult.error}`);
+          console.error('\nCheck your .env file for EWS_CLIENT_ID and EWS_REFRESH_TOKEN.');
+        }
+        process.exit(1);
+      }
+
+      const toList = options.to
+        .split(',')
+        .map((e) => e.trim())
+        .filter(Boolean);
+      const ccList = options.cc
+        ? options.cc
+            .split(',')
+            .map((e) => e.trim())
+            .filter(Boolean)
+        : undefined;
+      const bccList = options.bcc
+        ? options.bcc
+            .split(',')
+            .map((e) => e.trim())
+            .filter(Boolean)
+        : undefined;
+
+      if (toList.length === 0) {
+        console.error('At least one recipient is required.');
+        process.exit(1);
+      }
+
+      let body = options.body ?? '';
+      let bodyType: 'Text' | 'HTML' = 'Text';
+
+      if (options.markdown) {
+        body = markdownToHtml(body);
+        bodyType = 'HTML';
+      } else if (options.html) {
+        bodyType = 'HTML';
+      }
+
+      // Process attachments
+      let attachments: EmailAttachment[] | undefined;
+      const workingDirectory = process.cwd();
+      if (options.attach) {
+        const filePaths = options.attach
+          .split(',')
+          .map((f) => f.trim())
+          .filter(Boolean);
+        attachments = [];
+
+        for (const filePath of filePaths) {
+          try {
+            const validated = await validateAttachmentPath(filePath, workingDirectory);
+            const content = await readFile(validated.absolutePath);
+            const contentType = lookupMimeType(validated.fileName);
+
+            attachments.push({
+              name: validated.fileName,
+              contentType,
+              contentBytes: content.toString('base64')
+            });
+
+            if (!options.json) {
+              console.log(`  Attaching: ${validated.fileName} (${Math.round(validated.size / 1024)} KB)`);
+            }
+          } catch (err) {
+            console.error(`Failed to read attachment: ${filePath}`);
+            if (err instanceof AttachmentPathError) {
+              console.error(err.message);
+            } else {
+              console.error(err instanceof Error ? err.message : 'Unknown error');
+            }
+            process.exit(1);
+          }
+        }
+      }
+
+      let referenceAttachments: ReferenceAttachmentInput[] | undefined;
+      const linkSpecs = options.attachLink ?? [];
+      if (linkSpecs.length > 0) {
+        referenceAttachments = [];
+        for (const spec of linkSpecs) {
+          try {
+            const { name, url } = parseAttachLinkSpec(spec);
+            referenceAttachments.push({ name, url, contentType: 'text/html' });
+            if (!options.json) {
+              console.log(`  Attaching link: ${name}`);
+            }
+          } catch (err) {
+            const msg =
+              err instanceof AttachmentLinkSpecError ? err.message : err instanceof Error ? err.message : String(err);
+            console.error(`Invalid --attach-link: ${msg}`);
+            process.exit(1);
+          }
+        }
+      }
+
+      const result = await sendEmail(authResult.token!, {
+        to: toList,
+        cc: ccList,
+        bcc: bccList,
+        subject: options.subject,
+        body,
+        bodyType,
+        attachments,
+        referenceAttachments,
+        mailbox: options.mailbox,
+        categories: options.category && options.category.length > 0 ? options.category : undefined
+      });
+
+      if (!result.ok) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: result.error?.message || 'Failed to send email' }, null, 2));
+        } else {
+          console.error(`Error: ${result.error?.message || 'Failed to send email'}`);
+        }
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              to: toList,
+              subject: options.subject,
+              attachments: attachments?.map((a) => a.name),
+              attachLinks: referenceAttachments?.map((a) => a.name)
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log(`\n\u2713 Email sent to ${toList.join(', ')}`);
+        console.log(`  Subject: ${options.subject}`);
+        const nFile = attachments?.length ?? 0;
+        const nLink = referenceAttachments?.length ?? 0;
+        if (nFile + nLink > 0) {
+          console.log(`  Attachments: ${nFile} file(s), ${nLink} link(s)`);
+        }
+        console.log();
+      }
+    }
+  );

package/src/commands/serve.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import { startWebhookServer } from '../lib/webhook-server.js';
+
+export const serveCommand = new Command('serve')
+  .description('Start the webhook receiver server')
+  .option('-p, --port <port>', 'Port to listen on', '3000')
+  .action((options) => {
+    const port = parseInt(options.port, 10);
+    if (Number.isNaN(port) || port <= 0 || port > 65535) {
+      console.error(`Invalid port "${options.port}". Please provide an integer between 1 and 65535.`);
+      process.exit(1);
+    }
+    startWebhookServer(port);
+  });

package/src/commands/sharepoint.ts

@@ -0,0 +1,179 @@
+import { Command } from 'commander';
+import { resolveGraphAuth } from '../lib/graph-auth.js';
+import { createListItem, getListItems, getLists, updateListItem } from '../lib/sharepoint-client.js';
+import { checkReadOnly } from '../lib/utils.js';
+
+export const sharepointCommand = new Command('sharepoint').description('Manage Microsoft SharePoint Lists').alias('sp');
+
+sharepointCommand
+  .command('lists')
+  .description('List all SharePoint lists in a site')
+  .requiredOption('--site-id <id>', 'SharePoint Site ID')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(async (opts: { siteId: string; json?: boolean; token?: string; identity?: string }) => {
+    const auth = await resolveGraphAuth({ token: opts.token, identity: opts.identity });
+    if (!auth.success || !auth.token) {
+      console.error(`Auth error: ${auth.error || 'Unknown error'}`);
+      process.exit(1);
+    }
+    const res = await getLists(auth.token, opts.siteId);
+    if (!res.ok) {
+      console.error(`Error listing lists: ${res.error?.message || 'Unknown error'}`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(res.data, null, 2));
+      return;
+    }
+    if (!res.data || res.data.length === 0) {
+      console.log('No lists found in this site.');
+      return;
+    }
+    for (const list of res.data) {
+      console.log(`${list.name} (${list.id})`);
+      if (list.description) console.log(`  ${list.description}`);
+    }
+  });
+
+sharepointCommand
+  .command('items')
+  .description('Get items from a SharePoint list')
+  .requiredOption('--site-id <id>', 'SharePoint Site ID')
+  .requiredOption('--list-id <id>', 'SharePoint List ID')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(async (opts: { siteId: string; listId: string; json?: boolean; token?: string; identity?: string }) => {
+    const auth = await resolveGraphAuth({ token: opts.token, identity: opts.identity });
+    if (!auth.success || !auth.token) {
+      console.error(`Auth error: ${auth.error || 'Unknown error'}`);
+      process.exit(1);
+    }
+    const res = await getListItems(auth.token, opts.siteId, opts.listId);
+    if (!res.ok) {
+      console.error(`Error getting list items: ${res.error?.message || 'Unknown error'}`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(res.data, null, 2));
+      return;
+    }
+    if (!res.data || res.data.length === 0) {
+      console.log('No items found in this list.');
+      return;
+    }
+    for (const item of res.data) {
+      console.log(`Item ID: ${item.id}`);
+      if (item.fields) {
+        for (const [key, val] of Object.entries(item.fields)) {
+          if (!key.startsWith('@odata')) {
+            console.log(`  ${key}: ${val}`);
+          }
+        }
+      }
+      console.log('---');
+    }
+  });
+
+sharepointCommand
+  .command('create-item')
+  .description('Create an item in a SharePoint list')
+  .requiredOption('--site-id <id>', 'SharePoint Site ID')
+  .requiredOption('--list-id <id>', 'SharePoint List ID')
+  .requiredOption('--fields <json>', 'JSON string of fields to set (e.g. \'{"Title": "My Item"}\')')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(
+    async (
+      opts: { siteId: string; listId: string; fields: string; json?: boolean; token?: string; identity?: string },
+      cmd: any
+    ) => {
+      checkReadOnly(cmd);
+      const auth = await resolveGraphAuth({ token: opts.token, identity: opts.identity });
+      if (!auth.success || !auth.token) {
+        console.error(`Auth error: ${auth.error || 'Unknown error'}`);
+        process.exit(1);
+      }
+      let parsedFields: Record<string, any>;
+      try {
+        parsedFields = JSON.parse(opts.fields);
+      } catch (err: any) {
+        console.error(`Error parsing fields JSON: ${err.message}`);
+        process.exit(1);
+      }
+      if (typeof parsedFields !== 'object' || parsedFields === null || Array.isArray(parsedFields)) {
+        console.error(
+          'Error: --fields JSON must be an object (e.g. "{"Title": "New Title"}"), not an array or primitive.'
+        );
+        process.exit(1);
+      }
+      const res = await createListItem(auth.token, opts.siteId, opts.listId, parsedFields);
+      if (!res.ok) {
+        console.error(`Error creating list item: ${res.error?.message || 'Unknown error'}`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        console.log(JSON.stringify(res.data, null, 2));
+        return;
+      }
+      console.log(`Successfully created item ${res.data?.id}`);
+    }
+  );
+
+sharepointCommand
+  .command('update-item')
+  .description('Update an item in a SharePoint list')
+  .requiredOption('--site-id <id>', 'SharePoint Site ID')
+  .requiredOption('--list-id <id>', 'SharePoint List ID')
+  .requiredOption('--item-id <id>', 'SharePoint List Item ID')
+  .requiredOption('--fields <json>', 'JSON string of fields to set (e.g. \'{"Title": "New Title"}\')')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(
+    async (
+      opts: {
+        siteId: string;
+        listId: string;
+        itemId: string;
+        fields: string;
+        json?: boolean;
+        token?: string;
+        identity?: string;
+      },
+      cmd: any
+    ) => {
+      checkReadOnly(cmd);
+      const auth = await resolveGraphAuth({ token: opts.token, identity: opts.identity });
+      if (!auth.success || !auth.token) {
+        console.error(`Auth error: ${auth.error || 'Unknown error'}`);
+        process.exit(1);
+      }
+      let parsedFields: Record<string, any>;
+      try {
+        parsedFields = JSON.parse(opts.fields);
+      } catch (err: any) {
+        console.error(`Error parsing fields JSON: ${err.message}`);
+        process.exit(1);
+      }
+      if (typeof parsedFields !== 'object' || parsedFields === null || Array.isArray(parsedFields)) {
+        console.error(
+          'Error: --fields JSON must be an object (e.g. "{"Title": "New Title"}"), not an array or primitive.'
+        );
+        process.exit(1);
+      }
+      const res = await updateListItem(auth.token, opts.siteId, opts.listId, opts.itemId, parsedFields);
+      if (!res.ok) {
+        console.error(`Error updating list item: ${res.error?.message || 'Unknown error'}`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        console.log(JSON.stringify(res.data, null, 2));
+        return;
+      }
+      console.log(`Successfully updated item ${opts.itemId}`);
+    }
+  );

package/src/commands/site-pages.ts

@@ -0,0 +1,163 @@
+import { Command } from 'commander';
+import { resolveGraphAuth } from '../lib/graph-auth.js';
+import {
+  getSitePage,
+  listSitePages,
+  publishSitePage,
+  type SitePage,
+  updateSitePage
+} from '../lib/site-pages-client.js';
+import { checkReadOnly } from '../lib/utils.js';
+
+export const sitePagesCommand = new Command('pages').description('Manage SharePoint Site Pages');
+
+sitePagesCommand
+  .command('list <siteId>')
+  .description('List site pages for a given site ID')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific Graph token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(async (siteId: string, options: { json?: boolean; token?: string; identity?: string }) => {
+    const auth = await resolveGraphAuth({ token: options.token, identity: options.identity });
+    if (!auth.success) {
+      console.error(`Error: ${auth.error}`);
+      process.exit(1);
+    }
+
+    const result = await listSitePages(auth.token!, siteId);
+    if (!result.ok || !result.data) {
+      console.error(`Error: ${result.error?.message || 'Request failed'}`);
+      process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(result.data, null, 2));
+      return;
+    }
+
+    if (!result.data || result.data.length === 0) {
+      console.log('No pages found.');
+      return;
+    }
+
+    for (const page of result.data) {
+      const state = page.publishingState
+        ? `${page.publishingState.level} (v${page.publishingState.versionId})`
+        : 'Unknown';
+      console.log(`- ${page.name || page.title || page.id} (${page.id}) - State: ${state}`);
+    }
+  });
+
+sitePagesCommand
+  .command('get <siteId> <pageId>')
+  .description('Get a site page by ID')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific Graph token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(async (siteId: string, pageId: string, options: { json?: boolean; token?: string; identity?: string }) => {
+    const auth = await resolveGraphAuth({ token: options.token, identity: options.identity });
+    if (!auth.success) {
+      console.error(`Error: ${auth.error}`);
+      process.exit(1);
+    }
+
+    const result = await getSitePage(auth.token!, siteId, pageId);
+    if (!result.ok || !result.data) {
+      console.error(`Error: ${result.error?.message || 'Request failed'}`);
+      process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(result.data, null, 2));
+      return;
+    }
+
+    console.log(`ID: ${result.data.id}`);
+    console.log(`Name: ${result.data.name || '-'}`);
+    console.log(`Title: ${result.data.title || '-'}`);
+    console.log(`Web URL: ${result.data.webUrl || '-'}`);
+    if (result.data.publishingState) {
+      console.log(`State: ${result.data.publishingState.level} (v${result.data.publishingState.versionId})`);
+    }
+  });
+
+sitePagesCommand
+  .command('update <siteId> <pageId>')
+  .description('Update a site page')
+  .option('--title <title>', 'New title')
+  .option('--name <name>', 'New name')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific Graph token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(
+    async (
+      siteId: string,
+      pageId: string,
+      options: { title?: string; name?: string; json?: boolean; token?: string; identity?: string },
+      cmd: any
+    ) => {
+      checkReadOnly(cmd);
+      const auth = await resolveGraphAuth({ token: options.token, identity: options.identity });
+      if (!auth.success) {
+        console.error(`Error: ${auth.error}`);
+        process.exit(1);
+      }
+
+      const payload: Partial<SitePage> = {};
+      if (options.title) payload.title = options.title;
+      if (options.name) payload.name = options.name;
+
+      if (Object.keys(payload).length === 0) {
+        console.error('Error: Please provide at least one field to update (--title or --name)');
+        process.exit(1);
+      }
+
+      const result = await updateSitePage(auth.token!, siteId, pageId, payload);
+      if (!result.ok || !result.data) {
+        console.error(`Error: ${result.error?.message || 'Request failed'}`);
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(result.data, null, 2));
+        return;
+      }
+
+      console.log(`✓ Updated page ${pageId}`);
+    }
+  );
+
+sitePagesCommand
+  .command('publish <siteId> <pageId>')
+  .description('Publish a site page')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific Graph token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(
+    async (
+      siteId: string,
+      pageId: string,
+      options: { json?: boolean; token?: string; identity?: string },
+      cmd: any
+    ) => {
+      checkReadOnly(cmd);
+      const auth = await resolveGraphAuth({ token: options.token, identity: options.identity });
+      if (!auth.success) {
+        console.error(`Error: ${auth.error}`);
+        process.exit(1);
+      }
+
+      const result = await publishSitePage(auth.token!, siteId, pageId);
+      if (!result.ok) {
+        console.error(`Error: ${result.error?.message || 'Request failed'}`);
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({ ok: true }, null, 2));
+        return;
+      }
+
+      console.log(`✓ Published page ${pageId}`);
+    }
+  );

package/src/commands/subscribe.ts

@@ -0,0 +1,103 @@
+import { Command } from 'commander';
+import { createSubscription, deleteSubscription } from '../lib/graph-subscriptions.js';
+import { checkReadOnly } from '../lib/utils.js';
+
+export const subscribeCommand = new Command('subscribe')
+  .description('Subscribe to Microsoft Graph push notifications')
+  .argument('[resource]', 'Resource to subscribe to (e.g. mail, event, contact, todoTask)')
+  .option('--url <url>', 'Webhook notification URL')
+  .option('--expiry <datetime>', 'Expiration datetime (ISO 8601, defaults to 3 days from now)')
+  .option('--change-type <type>', 'Change type (comma-separated)', 'created,updated')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .option('--user <email>', 'Subscribe under this user or shared mailbox (users/{id}/...)')
+  .action(async (resource, options, cmd) => {
+    if (!resource) {
+      return cmd.help();
+    }
+    if (!options.url) {
+      console.error('Error: --url is required.');
+      process.exit(1);
+    }
+
+    checkReadOnly(cmd);
+
+    // Map friendly resource names to graph endpoints
+    const mapResource = (res: string, user?: string) => {
+      const prefix = user?.trim() ? `users/${encodeURIComponent(user.trim())}` : 'me';
+      switch (res.toLowerCase()) {
+        case 'mail':
+          return `${prefix}/messages`;
+        case 'event':
+          return `${prefix}/events`;
+        case 'contact':
+          return `${prefix}/contacts`;
+        case 'todotask':
+          // Note: Todo subscriptions require a specific list ID.
+          // Use the format: me/todo/lists/{listId}/tasks
+          // For the default Tasks list, use: me/todo/lists/Tasks/tasks
+          return `${prefix}/todo/lists/Tasks/tasks`;
+        default:
+          return res;
+      }
+    };
+
+    // Generate clientState for subscription validation (if GRAPH_CLIENT_STATE env is set)
+    const clientState = process.env.GRAPH_CLIENT_STATE;
+
+    const graphResource = mapResource(resource, options.user);
+
+    // Default expiration to 3 days (Graph allows up to 3 days for most resources)
+    let expiry = options.expiry;
+    if (!expiry) {
+      const date = new Date();
+      date.setDate(date.getDate() + 3);
+      // Ensure we don't exceed max limits by shaving off a minute
+      date.setMinutes(date.getMinutes() - 1);
+      expiry = date.toISOString();
+    }
+
+    try {
+      console.log(`Creating subscription for ${graphResource}...`);
+      const res = await createSubscription(
+        graphResource,
+        options.changeType,
+        options.url,
+        expiry,
+        clientState,
+        options.token,
+        options.identity
+      );
+      if (!res.ok) {
+        console.error(`Failed to create subscription: ${res.error?.message}`);
+        process.exit(1);
+      }
+      const sub = res.data;
+      console.log('Subscription created successfully!');
+      console.log(JSON.stringify(sub, null, 2));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+subscribeCommand
+  .command('cancel <id>')
+  .description('Cancel an existing subscription')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(async (id, options, cmd) => {
+    try {
+      checkReadOnly(cmd);
+      console.log(`Deleting subscription ${id}...`);
+      const res = await deleteSubscription(id, options.token, options.identity);
+      if (!res.ok) {
+        console.error(`Failed to delete subscription: ${res.error?.message}`);
+        process.exit(1);
+      }
+      console.log('Subscription deleted successfully.');
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });

package/src/commands/subscriptions.ts

@@ -0,0 +1,29 @@
+import { Command } from 'commander';
+import { listSubscriptions } from '../lib/graph-subscriptions.js';
+
+export const subscriptionsCommand = new Command('subscriptions').description('Manage Microsoft Graph subscriptions');
+
+subscriptionsCommand
+  .command('list')
+  .description('List all active subscriptions')
+  .option('--token <token>', 'Use a specific token')
+  .option('--identity <name>', 'Graph token cache identity (default: default)')
+  .action(async (options: { token?: string; identity?: string }) => {
+    try {
+      const res = await listSubscriptions(options.token, options.identity);
+      if (!res.ok || !res.data) {
+        console.error(`Failed to list subscriptions: ${res.error?.message}`);
+        process.exit(1);
+      }
+      const subs = res.data;
+      if (subs.length === 0) {
+        console.log('No active subscriptions found.');
+        return;
+      }
+      console.log(`Found ${subs.length} active subscription(s):`);
+      console.log(JSON.stringify(subs, null, 2));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });