m365-agent-cli 1.2.0

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "m365-agent-cli",
+  "version": "1.2.0",
+  "description": "CLI for Microsoft 365/EWS using OAuth2 refresh token authentication",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markus-lassfolk/m365-agent-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/markus-lassfolk/m365-agent-cli/issues"
+  },
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "m365-agent-cli": "src/cli.ts"
+  },
+  "scripts": {
+    "start": "bun run src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome lint --max-diagnostics=none --diagnostic-level=error .",
+    "lint:fix": "biome lint --write --unsafe --diagnostic-level=error .",
+    "format": "biome format --write .",
+    "format:check": "biome format --max-diagnostics=none .",
+    "biome:check": "biome check --max-diagnostics=none .",
+    "embed-sha": "node scripts/embed-git-sha.mjs",
+    "sync-skill": "node scripts/sync-skill-version.mjs",
+    "test-glitchtip-send": "node scripts/test-glitchtip-send.mjs",
+    "knip": "knip",
+    "verify:coverage": "node scripts/check-coverage.mjs",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text"
+  },
+  "files": [
+    "src",
+    "package.json",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@sentry/node": "^8.55.1",
+    "commander": "^12.0.0",
+    "semver": "^7.7.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.10",
+    "@types/bun": "latest",
+    "@types/semver": "^7.5.8",
+    "knip": "^5.46.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env bun
+import './lib/global-env.js';
+import { Command } from 'commander';
+import { autoReplyCommand } from './commands/auto-reply.js';
+import { calendarCommand } from './commands/calendar.js';
+import { counterCommand } from './commands/counter.js';
+import { createEventCommand } from './commands/create-event.js';
+import { delegatesCommand } from './commands/delegates.js';
+import { deleteEventCommand } from './commands/delete-event.js';
+import { draftsCommand } from './commands/drafts.js';
+import { filesCommand } from './commands/files.js';
+import { findCommand } from './commands/find.js';
+import { findtimeCommand } from './commands/findtime.js';
+import { foldersCommand } from './commands/folders.js';
+import { forwardEventCommand } from './commands/forward-event.js';
+import { graphCalendarCommand } from './commands/graph-calendar.js';
+import { loginCommand } from './commands/login.js';
+import { mailCommand } from './commands/mail.js';
+import { oofCommand } from './commands/oof.js';
+import { outlookCategoriesCommand } from './commands/outlook-categories.js';
+import { outlookGraphCommand } from './commands/outlook-graph.js';
+import { plannerCommand } from './commands/planner.js';
+import { respondCommand } from './commands/respond.js';
+import { roomsCommand } from './commands/rooms.js';
+import { rulesCommand } from './commands/rules.js';
+import { scheduleCommand } from './commands/schedule.js';
+import { sendCommand } from './commands/send.js';
+import { serveCommand } from './commands/serve.js';
+import { sharepointCommand } from './commands/sharepoint.js';
+import { sitePagesCommand } from './commands/site-pages.js';
+import { subscribeCommand } from './commands/subscribe.js';
+import { subscriptionsCommand } from './commands/subscriptions.js';
+import { suggestCommand } from './commands/suggest.js';
+import { todoCommand } from './commands/todo.js';
+import { updateCommand } from './commands/update.js';
+import { updateEventCommand } from './commands/update-event.js';
+import { verifyTokenCommand } from './commands/verify-token.js';
+import { whoamiCommand } from './commands/whoami.js';
+import { captureCliException, flushGlitchTip, initGlitchTip } from './lib/glitchtip.js';
+import { getPackageVersionSync } from './lib/package-info.js';
+
+const program = new Command();
+
+program.name('m365-agent-cli').description('CLI for Microsoft 365/EWS').version(getPackageVersionSync());
+
+program.option('--read-only', 'Run in read-only mode, blocking any mutating operations');
+
+program.addCommand(whoamiCommand);
+program.addCommand(updateCommand);
+program.addCommand(loginCommand);
+program.addCommand(sitePagesCommand);
+program.addCommand(verifyTokenCommand);
+program.addCommand(autoReplyCommand);
+program.addCommand(calendarCommand);
+program.addCommand(findtimeCommand);
+program.addCommand(respondCommand);
+program.addCommand(createEventCommand);
+program.addCommand(deleteEventCommand);
+program.addCommand(findCommand);
+program.addCommand(updateEventCommand);
+program.addCommand(mailCommand);
+program.addCommand(foldersCommand);
+program.addCommand(sendCommand);
+program.addCommand(draftsCommand);
+program.addCommand(filesCommand);
+program.addCommand(forwardEventCommand);
+program.addCommand(counterCommand);
+program.addCommand(scheduleCommand);
+program.addCommand(suggestCommand);
+program.addCommand(subscribeCommand);
+program.addCommand(subscriptionsCommand);
+program.addCommand(serveCommand);
+program.addCommand(roomsCommand);
+program.addCommand(oofCommand);
+program.addCommand(rulesCommand);
+program.addCommand(delegatesCommand);
+program.addCommand(todoCommand);
+
+program.addCommand(outlookCategoriesCommand);
+program.addCommand(outlookGraphCommand);
+program.addCommand(graphCalendarCommand);
+
+program.addCommand(plannerCommand);
+
+program.addCommand(sharepointCommand);
+
+(async () => {
+  await initGlitchTip();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    captureCliException(err);
+    await flushGlitchTip(2000);
+    process.exit(1);
+  }
+})().catch(async (err) => {
+  captureCliException(err);
+  await flushGlitchTip(2000);
+  process.exit(1);
+});

package/src/commands/auto-reply.ts

@@ -0,0 +1,182 @@
+import { Command } from 'commander';
+import { resolveAuth } from '../lib/auth.js';
+import { getAutoReplyRule, setAutoReplyRule } from '../lib/ews-client.js';
+import { checkReadOnly } from '../lib/utils.js';
+
+export const autoReplyCommand = new Command('auto-reply')
+  .description('Manage server-side out-of-office (OOF) auto-reply templates via EWS Inbox Rules')
+  .option('--message <text>', 'The message text for the auto-reply template')
+  .option('--enable', 'Enable the auto-reply rule')
+  .option('--disable', 'Disable the auto-reply rule')
+  .option('--start <datetime>', 'Start datetime (ISO string)')
+  .option('--end <datetime>', 'End datetime (ISO string)')
+  .option('--mailbox <email>', 'Target mailbox (if different from authenticated user)')
+  .option('--json', 'Output as JSON')
+  .option('--token <token>', 'Use a specific EWS token')
+  .option('--identity <name>', 'Use a specific authentication identity (default: default)')
+  .action(async (options, cmd: any) => {
+    checkReadOnly(cmd);
+    try {
+      const auth = await resolveAuth({ token: options.token, identity: options.identity });
+      if (!auth.success || !auth.token) {
+        const msg = auth.error || 'Authentication failed';
+        if (options.json) {
+          console.log(JSON.stringify({ error: msg }, null, 2));
+        } else {
+          console.error(`Error: ${msg}`);
+        }
+        process.exit(1);
+      }
+
+      // Validate mutually exclusive --enable and --disable
+      if (options.enable && options.disable) {
+        const msg = 'Error: --enable and --disable cannot be used together.';
+        if (options.json) {
+          console.log(JSON.stringify({ error: msg }, null, 2));
+        } else {
+          console.error(msg);
+        }
+        process.exit(1);
+      }
+
+      // Validate date inputs
+      let start: Date | undefined;
+      let end: Date | undefined;
+      if (options.start) {
+        start = new Date(options.start);
+        if (!Number.isFinite(start.getTime())) {
+          const msg = 'Error: --start must be a valid ISO datetime string.';
+          if (options.json) {
+            console.log(JSON.stringify({ error: msg }, null, 2));
+          } else {
+            console.error(msg);
+          }
+          process.exit(1);
+        }
+      }
+      if (options.end) {
+        end = new Date(options.end);
+        if (!Number.isFinite(end.getTime())) {
+          const msg = 'Error: --end must be a valid ISO datetime string.';
+          if (options.json) {
+            console.log(JSON.stringify({ error: msg }, null, 2));
+          } else {
+            console.error(msg);
+          }
+          process.exit(1);
+        }
+      }
+
+      if (options.message || options.enable || options.disable || options.start || options.end) {
+        let enabled = true;
+        let messageText = options.message;
+        const currentRuleRes = await getAutoReplyRule(auth.token, options.mailbox);
+
+        // Handle error case separately from "not found"
+        if (!currentRuleRes.ok) {
+          const msg = `Failed to get current auto-reply rule: ${currentRuleRes.status} ${currentRuleRes.error?.message || ''}`;
+          if (options.json) {
+            console.log(JSON.stringify({ error: msg }, null, 2));
+          } else {
+            console.error(msg);
+          }
+          process.exit(1);
+        }
+
+        if (currentRuleRes.data) {
+          if (options.enable === undefined && options.disable === undefined) {
+            enabled = currentRuleRes.data.enabled;
+          } else {
+            enabled = !!options.enable;
+          }
+          if (!messageText) messageText = currentRuleRes.data.messageText;
+          if (!options.start && currentRuleRes.data.startTime) start = currentRuleRes.data.startTime;
+          if (!options.end && currentRuleRes.data.endTime) end = currentRuleRes.data.endTime;
+        } else {
+          if (options.disable) enabled = false;
+          if (!messageText) {
+            const msg = 'Error: --message is required when creating a new auto-reply rule.';
+            if (options.json) {
+              console.log(JSON.stringify({ error: msg }, null, 2));
+            } else {
+              console.error(msg);
+            }
+            process.exit(1);
+          }
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ status: 'updating', enabled }, null, 2));
+        } else {
+          console.log(`Setting auto-reply rule (enabled: ${enabled})...`);
+        }
+        const result = await setAutoReplyRule(auth.token, messageText!, enabled, start, end, options.mailbox);
+
+        if (!result.ok) {
+          const msg = `Failed to set auto-reply rule: ${result.status} ${(result.error as any)?.message || result.error}`;
+          if (options.json) {
+            console.log(JSON.stringify({ error: msg }, null, 2));
+          } else {
+            console.error(msg);
+          }
+          process.exit(1);
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ status: 'success' }, null, 2));
+        } else {
+          console.log('Auto-reply rule successfully set.');
+        }
+      } else {
+        const result = await getAutoReplyRule(auth.token, options.mailbox);
+
+        if (!result.ok) {
+          const msg = `Failed to get auto-reply rule: ${result.status} ${(result.error as any)?.message || result.error}`;
+          if (options.json) {
+            console.log(JSON.stringify({ error: msg }, null, 2));
+          } else {
+            console.error(msg);
+          }
+          process.exit(1);
+        }
+
+        if (!result.data) {
+          if (options.json) {
+            console.log(JSON.stringify({ exists: false }, null, 2));
+          } else {
+            console.log('No auto-reply template rule found.');
+          }
+        } else {
+          if (options.json) {
+            console.log(
+              JSON.stringify(
+                {
+                  exists: true,
+                  enabled: result.data.enabled,
+                  startTime: result.data.startTime ? result.data.startTime.toISOString() : null,
+                  endTime: result.data.endTime ? result.data.endTime.toISOString() : null,
+                  messageText: result.data.messageText
+                },
+                null,
+                2
+              )
+            );
+          } else {
+            console.log('Auto-Reply Template Rule:');
+            console.log(`  Enabled: ${result.data.enabled}`);
+            console.log(`  Start Time: ${result.data.startTime ? result.data.startTime.toISOString() : 'None'}`);
+            console.log(`  End Time:   ${result.data.endTime ? result.data.endTime.toISOString() : 'None'}`);
+            console.log(`\nMessage:\n${result.data.messageText}`);
+          }
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'An unexpected error occurred';
+      if (options.json) {
+        console.log(JSON.stringify({ error: msg }, null, 2));
+      } else {
+        console.error('An unexpected error occurred:', msg);
+      }
+      process.exit(1);
+    }
+  });