m365-agent-cli 1.2.0

package/src/lib/outlook-master-categories.ts

@@ -0,0 +1,145 @@
+import { callGraph, GraphApiError, type GraphResponse, graphError, graphResult } from './graph-client.js';
+import { graphUserPath } from './graph-user-path.js';
+
+/** Preset color name from Graph (`preset0`..`preset24`). */
+export interface OutlookMasterCategory {
+  id: string;
+  displayName: string;
+  color: string;
+}
+
+/** Valid Microsoft Graph outlookCategory color constants (25 presets). */
+export const OUTLOOK_CATEGORY_COLOR_PRESETS = [
+  'preset0',
+  'preset1',
+  'preset2',
+  'preset3',
+  'preset4',
+  'preset5',
+  'preset6',
+  'preset7',
+  'preset8',
+  'preset9',
+  'preset10',
+  'preset11',
+  'preset12',
+  'preset13',
+  'preset14',
+  'preset15',
+  'preset16',
+  'preset17',
+  'preset18',
+  'preset19',
+  'preset20',
+  'preset21',
+  'preset22',
+  'preset23',
+  'preset24'
+] as const;
+
+export type OutlookCategoryColorPreset = (typeof OUTLOOK_CATEGORY_COLOR_PRESETS)[number];
+
+export function isValidOutlookCategoryColor(s: string): s is OutlookCategoryColorPreset {
+  return OUTLOOK_CATEGORY_COLOR_PRESETS.includes(s as OutlookCategoryColorPreset);
+}
+
+export async function listOutlookMasterCategories(
+  token: string,
+  user?: string
+): Promise<GraphResponse<OutlookMasterCategory[]>> {
+  const path = graphUserPath(user, 'outlook/masterCategories');
+  let result: GraphResponse<{ value: OutlookMasterCategory[] }>;
+  try {
+    result = await callGraph<{ value: OutlookMasterCategory[] }>(token, path);
+  } catch (err) {
+    if (err instanceof GraphApiError) {
+      return graphError(err.message, err.code, err.status);
+    }
+    return graphError(err instanceof Error ? err.message : 'Failed to list master categories');
+  }
+  if (!result.ok || !result.data) {
+    return graphError(
+      result.error?.message || 'Failed to list master categories',
+      result.error?.code,
+      result.error?.status
+    );
+  }
+  return graphResult(result.data.value);
+}
+
+export async function createOutlookMasterCategory(
+  token: string,
+  displayName: string,
+  color: string,
+  user?: string
+): Promise<GraphResponse<OutlookMasterCategory>> {
+  const path = graphUserPath(user, 'outlook/masterCategories');
+  try {
+    const result = await callGraph<OutlookMasterCategory>(token, path, {
+      method: 'POST',
+      body: JSON.stringify({ displayName: displayName.trim(), color })
+    });
+    if (!result.ok || !result.data) {
+      return graphError(
+        result.error?.message || 'Failed to create master category',
+        result.error?.code,
+        result.error?.status
+      );
+    }
+    return graphResult(result.data);
+  } catch (err) {
+    if (err instanceof GraphApiError) return graphError(err.message, err.code, err.status);
+    return graphError(err instanceof Error ? err.message : 'Failed to create master category');
+  }
+}
+
+export async function updateOutlookMasterCategory(
+  token: string,
+  categoryId: string,
+  updates: { displayName?: string; color?: string },
+  user?: string
+): Promise<GraphResponse<OutlookMasterCategory>> {
+  const path = `${graphUserPath(user, 'outlook/masterCategories')}/${encodeURIComponent(categoryId)}`;
+  try {
+    const body: Record<string, string> = {};
+    if (updates.displayName !== undefined) body.displayName = updates.displayName.trim();
+    if (updates.color !== undefined) body.color = updates.color;
+    const result = await callGraph<OutlookMasterCategory>(token, path, {
+      method: 'PATCH',
+      body: JSON.stringify(body)
+    });
+    if (!result.ok || !result.data) {
+      return graphError(
+        result.error?.message || 'Failed to update master category',
+        result.error?.code,
+        result.error?.status
+      );
+    }
+    return graphResult(result.data);
+  } catch (err) {
+    if (err instanceof GraphApiError) return graphError(err.message, err.code, err.status);
+    return graphError(err instanceof Error ? err.message : 'Failed to update master category');
+  }
+}
+
+export async function deleteOutlookMasterCategory(
+  token: string,
+  categoryId: string,
+  user?: string
+): Promise<GraphResponse<void>> {
+  const path = `${graphUserPath(user, 'outlook/masterCategories')}/${encodeURIComponent(categoryId)}`;
+  try {
+    const result = await callGraph<void>(token, path, { method: 'DELETE' });
+    if (!result.ok) {
+      return graphError(
+        result.error?.message || 'Failed to delete master category',
+        result.error?.code,
+        result.error?.status
+      );
+    }
+    return graphResult(undefined as undefined);
+  } catch (err) {
+    if (err instanceof GraphApiError) return graphError(err.message, err.code, err.status);
+    return graphError(err instanceof Error ? err.message : 'Failed to delete master category');
+  }
+}

package/src/lib/package-info.ts

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PKG_NAME = 'm365-agent-cli';
+
+function isOurPackageJson(path: string): boolean {
+  try {
+    const raw = readFileSync(path, 'utf8');
+    const j = JSON.parse(raw) as { name?: string };
+    return j.name === PKG_NAME;
+  } catch {
+    return false;
+  }
+}
+
+function walkUpForOurPackageJson(startDir: string): string | null {
+  let dir = startDir;
+  for (let i = 0; i < 14; i++) {
+    const candidate = join(dir, 'package.json');
+    if (existsSync(candidate) && isOurPackageJson(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Resolves package.json for this package (installed layout, repo checkout, or tests).
+ */
+export function getPackageJsonPath(): string {
+  const libDir = dirname(fileURLToPath(import.meta.url));
+  const fromAdjacent = join(libDir, '../../package.json');
+  if (existsSync(fromAdjacent) && isOurPackageJson(fromAdjacent)) {
+    return fromAdjacent;
+  }
+  const fromModuleWalk = walkUpForOurPackageJson(libDir);
+  if (fromModuleWalk) {
+    return fromModuleWalk;
+  }
+  const fromCwdWalk = walkUpForOurPackageJson(process.cwd());
+  if (fromCwdWalk) {
+    return fromCwdWalk;
+  }
+  return fromAdjacent;
+}
+
+/** Uses sync fs so tests that mock `node:fs/promises` (e.g. auth) do not break version reads. */
+export async function getPackageVersion(): Promise<string> {
+  return getPackageVersionSync();
+}
+
+export function getPackageVersionSync(): string {
+  const raw = readFileSync(getPackageJsonPath(), 'utf8');
+  return (JSON.parse(raw) as { version?: string }).version?.trim() ?? '0.0.0';
+}

package/src/lib/places-client.ts

@@ -0,0 +1,144 @@
+import { resolveGraphAuth } from './graph-auth.js';
+import { callGraph, fetchAllPages, graphError, graphResult } from './graph-client.js';
+
+export interface Place {
+  id?: string;
+  displayName: string;
+  emailAddress?: string;
+  address?: {
+    street?: string;
+    city?: string;
+    state?: string;
+    countryOrRegion?: string;
+    postalCode?: string;
+    fullAddress?: string;
+  };
+  geoCoordinates?: {
+    latitude?: number;
+    longitude?: number;
+  };
+  capacity?: number;
+  bookingType?: 'standard' | 'reserved';
+  tags?: string[];
+  building?: string;
+  floorNumber?: string;
+  isManaged?: boolean;
+  isBookable?: boolean;
+  phone?: string;
+}
+
+export interface RoomList {
+  id: string;
+  displayName: string;
+  emailAddress?: string;
+}
+
+async function withAuth<T>(
+  fn: (
+    token: string
+  ) => Promise<{ ok: boolean; data?: T; error?: { message: string; code?: string; status?: number } }>,
+  options?: { token?: string; identity?: string }
+): Promise<{ ok: boolean; data?: T; error?: { message: string; code?: string; status?: number } }> {
+  const auth = await resolveGraphAuth(options);
+  if (!auth.success || !auth.token) {
+    return graphError(auth.error || 'Authentication failed');
+  }
+  return fn(auth.token);
+}
+
+export async function listPlaceRoomLists(options?: { token?: string; identity?: string }): Promise<{
+  ok: boolean;
+  data?: RoomList[];
+  error?: { message: string; code?: string; status?: number };
+}> {
+  return withAuth<RoomList[]>(async (token) => {
+    return fetchAllPages<RoomList>(token, '/places/microsoft.graph.roomList', 'Failed to list room lists');
+  }, options);
+}
+
+export async function listRoomsInRoomList(
+  roomListEmail: string,
+  options?: { token?: string; identity?: string }
+): Promise<{
+  ok: boolean;
+  data?: Place[];
+  error?: { message: string; code?: string; status?: number };
+}> {
+  return withAuth<Place[]>(async (token) => {
+    return fetchAllPages<Place>(
+      token,
+      `/places/${encodeURIComponent(roomListEmail)}/microsoft.graph.roomlist/rooms`,
+      'Failed to list rooms'
+    );
+  }, options);
+}
+
+export interface RoomFilters {
+  building?: string;
+  capacityMin?: number;
+  equipment?: string[];
+}
+
+export async function findRooms(
+  filters?: RoomFilters,
+  options?: { token?: string; identity?: string }
+): Promise<{
+  ok: boolean;
+  data?: Place[];
+  error?: { message: string; code?: string; status?: number };
+}> {
+  return withAuth<Place[]>(async (token) => {
+    const result = await fetchAllPages<Place>(token, '/places/microsoft.graph.room', 'Failed to find rooms');
+    if (!result.ok || !result.data) {
+      return result;
+    }
+
+    let rooms = result.data;
+
+    if (filters?.building) {
+      const buildingLower = filters.building.toLowerCase();
+      rooms = rooms.filter((r) => r.building?.toLowerCase().includes(buildingLower));
+    }
+
+    if (filters?.capacityMin !== undefined) {
+      rooms = rooms.filter((r) => r.capacity !== undefined && r.capacity >= filters.capacityMin!);
+    }
+
+    if (filters?.equipment && filters.equipment.length > 0) {
+      const equipLower = filters.equipment.map((e) => e.toLowerCase());
+      rooms = rooms.filter((r) => {
+        if (!r.tags || r.tags.length === 0) return false;
+        const tagsLower = r.tags.map((t) => t.toLowerCase());
+        return equipLower.every((e) => tagsLower.some((t) => t.includes(e)));
+      });
+    }
+
+    return graphResult(rooms);
+  }, options);
+}
+
+export async function isRoomFree(
+  token: string,
+  roomEmail: string,
+  startISO: string,
+  endISO: string
+): Promise<boolean | null> {
+  let result: any;
+  try {
+    result = await callGraph<{ value: Array<{ showAs?: string }> }>(
+      token,
+      `/users/${encodeURIComponent(roomEmail)}/calendar/calendarView?startDateTime=${encodeURIComponent(
+        startISO
+      )}&endDateTime=${encodeURIComponent(endISO)}`
+    );
+  } catch (_err) {
+    return null;
+  }
+
+  if (!result.ok || !result.data) {
+    return null;
+  }
+
+  const busyEvents = (result.data.value || []).filter((event: any) => event.showAs !== 'free');
+  return busyEvents.length === 0;
+}