msteams 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,595 @@
+#!/usr/bin/env node
+import { n as TokenManager, t as TeamsClient } from "../TeamsClient-D4-exLIC.mjs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+//#region src/cli/constants.ts
+const DEFAULT_PROFILE_NAME = "default";
+const DEFAULT_PROFILE_DIR = ".teams-cli";
+const DEFAULT_MESSAGE_LIMIT = 20;
+const ANSI_CODES = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	cyan: "\x1B[36m",
+	brightCyan: "\x1B[96m"
+};
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+
+//#endregion
+//#region src/cli/output.ts
+function createContext(options) {
+	const interactive = process.stdout.isTTY === true && process.stderr.isTTY === true;
+	return {
+		machine: options.jsonOutput || !interactive,
+		color: interactive && !options.noColor && !options.jsonOutput
+	};
+}
+async function withSpinner(context, label, task) {
+	if (context.machine) return task();
+	let frame = 0;
+	const timer = setInterval(() => {
+		process.stdout.write(`\r${SPINNER_FRAMES[frame]} ${label}`);
+		frame = (frame + 1) % SPINNER_FRAMES.length;
+	}, 80);
+	try {
+		const result = await task();
+		clearInterval(timer);
+		process.stdout.write(`\r${ANSI_CODES.green}✓${ANSI_CODES.reset} ${label}\n`);
+		return result;
+	} catch (error) {
+		clearInterval(timer);
+		process.stdout.write(`\r${ANSI_CODES.red}x${ANSI_CODES.reset} ${label}\n`);
+		throw error;
+	}
+}
+function printHelp(context, command, compact = false) {
+	const colorize = (color, text) => context.color ? `${ANSI_CODES[color]}${text}${ANSI_CODES.reset}` : text;
+	if (command === "messages") {
+		console.log("Usage:");
+		console.log("  teams messages <conversationId> [--limit <n>]");
+		console.log("  Fetch messages in a conversation");
+		return;
+	}
+	if (command === "notifications") {
+		console.log("Usage:");
+		console.log("  teams notifications [--limit <n>]");
+		console.log("  Fetch latest notifications");
+		return;
+	}
+	if (command === "channel" || command === "channel-messages") {
+		console.log("Usage:");
+		console.log("  teams channel messages <channelId> [--limit <n>]");
+		console.log("  Fetch messages in a team channel using channel id");
+		return;
+	}
+	if (command === "me") {
+		console.log("Usage:");
+		console.log("  teams me");
+		console.log("  Show current user snapshot");
+		return;
+	}
+	if (command === "set-refresh-token") {
+		console.log("Usage:");
+		console.log("  teams set-refresh-token --refresh-token=<token> [options]");
+		console.log("  Save refresh token to the selected profile");
+		return;
+	}
+	if (command === "list") {
+		console.log("Usage:");
+		console.log("  teams list");
+		console.log("  List all teams for the current user");
+		return;
+	}
+	if (command === "teams") {
+		console.log("Usage:");
+		console.log("  teams list");
+		console.log("  teams channels <teamId>");
+		console.log("  Commands:");
+		console.log("    list    List all teams for the current user");
+		console.log("    channels <teamId>    List channels in a team");
+		return;
+	}
+	if (command === "channels") {
+		console.log("Usage:");
+		console.log("  teams channels <teamId>");
+		console.log("  List channels in the team");
+		return;
+	}
+	console.log(`${colorize("bold", "teams cli")} - a small Teams helper for human + LLM workflows`);
+	if (!compact) {
+		console.log("Usage:");
+		console.log("  teams [options] <command> [arguments]");
+		console.log();
+		console.log("Global options:");
+		console.log("  --profile=<name>         Use ~/.teams-cli/<name>.json (default: default)");
+		console.log("  --profile-json=<path>    Use custom profile json path");
+		console.log("  --refresh-token=<token>  Use and persist this refresh token");
+		console.log("  --json                   Output machine-readable JSON only (default in automation)");
+		console.log("  --no-color               Disable ANSI colors");
+		console.log("  --help, -h               Show this help");
+		console.log();
+		console.log("Commands:");
+		console.log("  notifications [--limit N]           Fetch latest notifications");
+		console.log("  messages <conversationId> [--limit N]   Fetch conversation messages");
+		console.log("  channel messages <channelId> [--limit N] Fetch channel messages");
+		console.log("  teams list                          List all teams for the current user");
+		console.log("  teams channels <teamId>             List channels in a team");
+		console.log("  me                                  Fetch current user snapshot");
+		console.log("  set-refresh-token --refresh-token=<token> Save refresh token to selected profile");
+	}
+}
+function printError(context, message) {
+	if (context.machine) console.log(JSON.stringify({ error: message }));
+	else {
+		const prefix = `${ANSI_CODES.red}${ANSI_CODES.bold}error${ANSI_CODES.reset}`;
+		console.log(`${context.color ? prefix : "error"}: ${message}`);
+		console.log();
+		printHelp(context, void 0, true);
+	}
+	process.exitCode = 1;
+}
+function printResult(context, result, profile) {
+	if (context.machine) {
+		console.log(JSON.stringify({
+			command: result.command,
+			profile,
+			data: result.data
+		}));
+		return;
+	}
+	if (result.command === "help") return;
+	const colorize = (color, text) => context.color ? `${ANSI_CODES[color]}${text}${ANSI_CODES.reset}` : text;
+	if (result.command === "set-refresh-token") {
+		const payload = result.data;
+		console.log(colorize("bold", "Refresh token stored"));
+		console.log(`  profile: ${colorize("cyan", payload.profile)}`);
+		console.log(`  file: ${colorize("dim", payload.profilePath)}`);
+		return;
+	}
+	if (result.command === "me") {
+		const me = result.data;
+		const teams = Array.isArray(me?.teams) ? me.teams : [];
+		const chats = Array.isArray(me?.chats) ? me.chats : [];
+		const privateFeeds = Array.isArray(me?.privateFeeds) ? me.privateFeeds : [];
+		console.log(colorize("bold", "Teams profile snapshot"));
+		console.log(`  ${colorize("cyan", "profile:")} ${colorize("yellow", `${teams.length} teams`)} / ${colorize("yellow", `${chats.length} chats`)} / ${colorize("yellow", `${privateFeeds.length} private feeds`)}`);
+		return;
+	}
+	if (result.command === "list") {
+		const teams = Array.isArray(result.data) ? result.data : [];
+		if (teams.length === 0) {
+			console.log(colorize("dim", "Teams: no items found"));
+			return;
+		}
+		console.log(colorize("bold", `Teams (${teams.length})`));
+		for (const [index, team] of teams.entries()) {
+			const name = typeof team?.displayName === "string" ? team.displayName : "Unknown team";
+			const id = typeof team?.id === "string" ? team.id : "unknown";
+			const line = `${String(index + 1).padStart(2, "0")}. ${colorize("cyan", name)} (${colorize("dim", id)})`;
+			console.log(`  ${line}`);
+		}
+		return;
+	}
+	if (result.command === "channels") {
+		const payload = result.data;
+		const channels = Array.isArray(payload?.channels) ? payload.channels : [];
+		const label = `Channels (${payload?.teamName ?? "team"})`;
+		if (channels.length === 0) {
+			console.log(colorize("dim", `${label}: no items found`));
+			return;
+		}
+		console.log(colorize("bold", `${label} (${channels.length})`));
+		for (const [index, channel] of channels.entries()) {
+			const name = typeof channel?.displayName === "string" ? channel.displayName : "Unknown channel";
+			const id = typeof channel?.id === "string" ? channel.id : "unknown";
+			const line = `${String(index + 1).padStart(2, "0")}. ${colorize("cyan", name)} (${colorize("dim", id)})`;
+			console.log(`  ${line}`);
+		}
+		return;
+	}
+	const notifications = result.command === "notifications" || result.command === "messages" ? result.data.messages : result.command === "channel-messages" ? result.data : [];
+	if (result.command === "notifications") {
+		if (!Array.isArray(notifications) || notifications.length === 0) {
+			console.log(colorize("dim", "Notifications: no items found"));
+			return;
+		}
+		console.log(colorize("bold", `Notifications (${notifications.length})`));
+		for (const [index, notification] of notifications.entries()) {
+			const messagePreview = (typeof notification === "object" && notification !== null ? notification.properties : void 0)?.activity?.messagePreview ?? "";
+			const id = pickFirstString(notification, "id", "messageId", "messageID", "id1", "clientMessageId");
+			const clumpId = pickFirstString(notification, "clumpId", "clumpID", "converationId", "conversationId");
+			const safeMessagePreview = messagePreview.length > 0 ? sanitizeMessageBody(messagePreview) : "no message preview";
+			const clippedPreview = safeMessagePreview.length > 160 ? `${safeMessagePreview.slice(0, 157)}...` : safeMessagePreview;
+			const safeId = id.length > 0 ? id : "unknown-id";
+			console.log(`${colorize("dim", `- msg: ${clumpId}, notify:`)} ${colorize("cyan", safeId)}`);
+			console.log(`    ${colorize("dim", clippedPreview)}`);
+		}
+		return;
+	}
+	const label = result.command === "channel-messages" ? "Channel messages" : result.command === "messages" ? "Conversation messages" : "Notifications";
+	if (!Array.isArray(notifications) || notifications.length === 0) {
+		console.log(colorize("dim", `${label}: no items found`));
+		return;
+	}
+	console.log(colorize("bold", `${label} (${notifications.length})`));
+	for (const [index, message] of notifications.entries()) {
+		const sender = pickFirstString(message, "imdisplayname", "fromDisplayNameInToken", "fromDisplayName", "from");
+		const composedAt = pickFirstString(message, "composetime", "composeTime", "originalarrivaltime", "originalArrivalTime");
+		const content = pickFirstString(message, "content", "text");
+		const safeFrom = sender ? sender : "Unknown";
+		const safeTime = toPrettyTime(composedAt) ?? "unknown time";
+		const body = sanitizeMessageBody(content);
+		const clippedBody = body.length > 240 ? `${body.slice(0, 237)}...` : body;
+		const prefix = colorize("dim", `${String(index + 1).padStart(2, "0")}.`);
+		console.log(`${prefix} ${safeFrom} [${safeTime}]`);
+		console.log(`    ${colorize("dim", clippedBody)}`);
+	}
+}
+function sanitizeMessageBody(input) {
+	return input.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function toPrettyTime(input) {
+	if (!input) return;
+	const date = Number.isNaN(Number(input)) ? new Date(input) : new Date(Number(input));
+	if (Number.isNaN(date.getTime())) return;
+	return date.toLocaleString();
+}
+function pickFirstString(value, ...keys) {
+	if (!value) return "";
+	for (const key of keys) {
+		const candidate = value[key];
+		if (typeof candidate === "string" && candidate.trim().length > 0) return candidate.trim();
+	}
+	return "";
+}
+
+//#endregion
+//#region src/cli/args.ts
+function parseArgs(argv) {
+	const parsed = {
+		command: "notifications",
+		hasCommand: false,
+		commandArgs: [],
+		profileName: DEFAULT_PROFILE_NAME,
+		profileJsonPath: void 0,
+		refreshToken: void 0,
+		jsonOutput: false,
+		noColor: false,
+		showHelp: false
+	};
+	let index = 0;
+	while (index < argv.length) {
+		const token = argv[index];
+		if (!token.startsWith("-")) break;
+		if (token === "--help" || token === "-h") {
+			parsed.showHelp = true;
+			index += 1;
+			continue;
+		}
+		if (token === "--json") {
+			parsed.jsonOutput = true;
+			index += 1;
+			continue;
+		}
+		if (token === "--no-color") {
+			parsed.noColor = true;
+			index += 1;
+			continue;
+		}
+		if (token === "--profile" || token.startsWith("--profile=")) {
+			const value = token === "--profile" ? argv[index + 1] : token.slice(10);
+			if (!value) throw new Error("Missing --profile value");
+			parsed.profileName = value;
+			index += token === "--profile" ? 2 : 1;
+			continue;
+		}
+		if (token === "--profile-json" || token.startsWith("--profile-json=")) {
+			const value = token === "--profile-json" ? argv[index + 1] : token.slice(15);
+			if (!value) throw new Error("Missing --profile-json path");
+			parsed.profileJsonPath = value;
+			index += token === "--profile-json" ? 2 : 1;
+			continue;
+		}
+		if (token === "--refresh-token" || token.startsWith("--refresh-token=")) {
+			const value = token === "--refresh-token" ? argv[index + 1] : token.slice(16);
+			if (!value) throw new Error("Missing --refresh-token value");
+			parsed.refreshToken = value;
+			index += token === "--refresh-token" ? 2 : 1;
+			continue;
+		}
+		throw new Error(`Unknown option: ${token}`);
+	}
+	const commandArg = argv[index];
+	if (!commandArg) {
+		parsed.hasCommand = false;
+		parsed.commandArgs = [];
+		return parsed;
+	}
+	if (commandArg.startsWith("-")) throw new Error(`Unknown command or option: ${commandArg}`);
+	parsed.command = parseCommand(commandArg);
+	parsed.hasCommand = true;
+	parsed.commandArgs = argv.slice(index + 1);
+	return parsed;
+}
+function parseCommand(input) {
+	if (input === "notifications" || input === "messages" || input === "channel" || input === "me" || input === "teams" || input === "set-refresh-token" || input === "help") return input;
+	throw new Error(`Unknown command: ${input}`);
+}
+function parseLimitArgs(args, command) {
+	const rest = [];
+	let limit = DEFAULT_MESSAGE_LIMIT;
+	for (let index = 0; index < args.length; index++) {
+		const token = args[index];
+		if (token === "--limit") {
+			const value = args[index + 1];
+			if (!value || value.startsWith("--")) throw new Error(`--limit requires a number for command: teams ${command}`);
+			const parsed = Number.parseInt(value, 10);
+			if (Number.isNaN(parsed) || parsed <= 0) throw new Error(`--limit requires a positive integer for command: teams ${command}`);
+			limit = parsed;
+			index += 1;
+			continue;
+		}
+		if (token.startsWith("--limit=")) {
+			const value = token.slice(8);
+			const parsed = Number.parseInt(value, 10);
+			if (Number.isNaN(parsed) || parsed <= 0) throw new Error(`--limit requires a positive integer for command: teams ${command}`);
+			limit = parsed;
+			continue;
+		}
+		if (token.startsWith("-")) throw new Error(`Unknown option: ${token}`);
+		rest.push(token);
+	}
+	return {
+		limit,
+		rest
+	};
+}
+
+//#endregion
+//#region src/cli/commands.ts
+async function executeCommand(args, client, context) {
+	const animationContext = context;
+	switch (args.command) {
+		case "notifications": {
+			if (args.commandArgs.includes("--help") || args.commandArgs.includes("-h")) return {
+				command: "help",
+				data: "notifications"
+			};
+			const parsed = parseLimitArgs(args.commandArgs, "notifications");
+			if (parsed.rest.length > 0) throw new Error("notifications accepts only --limit option; no positional arguments are supported");
+			return {
+				command: "notifications",
+				data: await withSpinner(animationContext, "Fetching notifications...", () => client.teams.notifications.fetchMessages({ pageSize: parsed.limit }))
+			};
+		}
+		case "messages": {
+			if (args.commandArgs.includes("--help") || args.commandArgs.includes("-h")) return {
+				command: "help",
+				data: "messages"
+			};
+			const parsed = parseLimitArgs(args.commandArgs, "messages");
+			const [conversationId] = parsed.rest;
+			if (!conversationId) throw new Error("Usage: teams messages <conversationId> [--limit <n>]");
+			return {
+				command: "messages",
+				data: await withSpinner(animationContext, `Fetching conversation ${conversationId}...`, () => client.teams.conversations.fetchMessages(conversationId, { pageSize: parsed.limit }))
+			};
+		}
+		case "channel": {
+			const [subCommand, ...subCommandArgs] = args.commandArgs;
+			if (!subCommand || subCommand === "--help" || subCommand === "-h") return {
+				command: "help",
+				data: "channel"
+			};
+			if (subCommand === "messages") {
+				if (subCommandArgs.includes("--help") || subCommandArgs.includes("-h")) return {
+					command: "help",
+					data: "channel"
+				};
+				const parsed = parseLimitArgs(subCommandArgs, "channel messages");
+				const [channelId] = parsed.rest;
+				if (!channelId) throw new Error("Usage: teams channel messages <channelId> [--limit <n>]");
+				return {
+					command: "channel-messages",
+					data: await withSpinner(animationContext, `Fetching messages for channel=${channelId}...`, async () => {
+						const teamIds = resolveTeamIdFromMe(await client.teams.users.me.fetch(), channelId);
+						if (teamIds.length === 0) throw new Error(`Channel not found: ${channelId}`);
+						if (teamIds.length > 1) throw new Error(`Ambiguous channel: ${channelId} exists in multiple teams`);
+						return client.teams.channels.fetchMessages(teamIds[0], channelId, { pageSize: parsed.limit });
+					})
+				};
+			}
+			throw new Error(`Unknown channel subcommand: ${subCommand}`);
+		}
+		case "me":
+			if (args.commandArgs.includes("--help") || args.commandArgs.includes("-h")) return {
+				command: "help",
+				data: "me"
+			};
+			if (args.commandArgs.length > 0) throw new Error("me does not accept positional arguments");
+			return {
+				command: "me",
+				data: await withSpinner(animationContext, "Fetching current user...", () => client.teams.users.me.fetch())
+			};
+		case "teams": {
+			const [subCommand, ...subArgs] = args.commandArgs;
+			if (subCommand === "--help" || subCommand === "-h") return {
+				command: "help",
+				data: "teams"
+			};
+			if (!subCommand) return {
+				command: "help",
+				data: "teams"
+			};
+			if (subCommand === "list") {
+				if (subArgs.includes("--help") || subArgs.includes("-h")) return {
+					command: "help",
+					data: "list"
+				};
+				if (subArgs.length > 0) throw new Error("teams teams list does not accept positional arguments");
+				return {
+					command: "list",
+					data: (await withSpinner(animationContext, "Fetching teams list...", () => client.teams.users.me.fetch())).teams
+				};
+			}
+			if (subCommand === "channels") {
+				if (subArgs.includes("--help") || subArgs.includes("-h")) return {
+					command: "help",
+					data: "channels"
+				};
+				const [teamId] = subArgs;
+				if (!teamId) throw new Error("Usage: teams teams channels <teamId>");
+				if (subArgs.length > 1) throw new Error("teams teams channels does not accept positional arguments");
+				const payload = await withSpinner(animationContext, "Fetching team channels...", () => client.teams.users.me.fetch());
+				const target = (Array.isArray(payload.teams) ? payload.teams : []).find((team) => team.id === teamId);
+				if (!target) throw new Error(`Team not found: ${teamId}`);
+				const channels = Array.isArray(target.channels) ? target.channels : [];
+				return {
+					command: "channels",
+					data: {
+						teamId,
+						teamName: target.displayName ?? "Unknown team",
+						channels
+					}
+				};
+			}
+			throw new Error(`Unknown teams subcommand: ${subCommand}`);
+		}
+		case "set-refresh-token": throw new Error("set-refresh-token is a profile-only command");
+		case "help": return {
+			command: "help",
+			data: void 0
+		};
+	}
+}
+function resolveTeamIdFromMe(me, channelId) {
+	const teams = Array.isArray(me?.teams) ? me.teams : [];
+	const teamIds = [];
+	for (const team of teams) if ((Array.isArray(team?.channels) ? team.channels : []).some((channel) => channel?.id === channelId) && typeof team?.id === "string") teamIds.push(team.id);
+	return teamIds;
+}
+
+//#endregion
+//#region src/cli/profile.ts
+const PROFILE_KEY = "refreshToken";
+function resolveProfilePath(args) {
+	if (args.profileJsonPath) return expandHome(args.profileJsonPath);
+	return join(getHomeDirectory(), DEFAULT_PROFILE_DIR, `${normalizeProfileName(args.profileName)}.json`);
+}
+function getProfileLabel(args) {
+	if (args.profileJsonPath) return "profile-json";
+	return normalizeProfileName(args.profileName);
+}
+async function loadRefreshToken(path) {
+	try {
+		const raw = await readFile(path, "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed[PROFILE_KEY] !== "string") return;
+		const token = parsed[PROFILE_KEY].trim();
+		return token.length > 0 ? token : void 0;
+	} catch (_error) {
+		return;
+	}
+}
+async function saveRefreshToken(path, refreshToken) {
+	const directory = dirname(path);
+	if (directory !== ".") await mkdir(directory, { recursive: true });
+	await writeFile(path, JSON.stringify({
+		refreshToken: refreshToken.trim(),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2), "utf8");
+}
+async function resolveProfile(args) {
+	const profilePath = resolveProfilePath(args);
+	const storedRefreshToken = await loadRefreshToken(profilePath);
+	const token = args.refreshToken ?? storedRefreshToken ?? process.env.REFRESH_TOKEN;
+	if (!token) throw new Error("No refresh token found. Use --refresh-token, --profile-json file, or set REFRESH_TOKEN in env.");
+	return {
+		token,
+		profilePath,
+		profileLabel: getProfileLabel(args)
+	};
+}
+function resolveRefreshTokenForStore(args) {
+	const token = args.refreshToken ?? process.env.REFRESH_TOKEN;
+	if (!token) throw new Error("set-refresh-token requires --refresh-token or REFRESH_TOKEN.");
+	return token;
+}
+function getHomeDirectory() {
+	const home = process.env.HOME || process.env.USERPROFILE;
+	if (!home) throw new Error("Cannot resolve home directory (HOME/USERPROFILE not set)");
+	return home;
+}
+function normalizeProfileName(name) {
+	return name.trim().replace(/[^a-zA-Z0-9._-]/g, "_") || DEFAULT_PROFILE_NAME;
+}
+function expandHome(value) {
+	if (value === "~") return getHomeDirectory();
+	if (value.startsWith("~/") || value.startsWith("~\\")) return join(getHomeDirectory(), value.slice(2));
+	return value;
+}
+
+//#endregion
+//#region src/cli/index.ts
+if (import.meta.main) await runCli(process.argv.slice(2));
+async function runCli(argv) {
+	const args = parseArgs(argv);
+	const context = createContext({
+		jsonOutput: args.jsonOutput,
+		noColor: args.noColor
+	});
+	if (args.showHelp || args.command === "help") {
+		printHelp(context);
+		return;
+	}
+	if (!args.hasCommand) {
+		printHelp(context);
+		process.exitCode = 1;
+		return;
+	}
+	if (args.command === "set-refresh-token") try {
+		const profilePath = resolveProfilePath(args);
+		await saveRefreshToken(profilePath, resolveRefreshTokenForStore(args));
+		printResult(context, {
+			command: "set-refresh-token",
+			data: {
+				profile: getProfileLabel(args),
+				profilePath
+			}
+		}, getProfileLabel(args));
+		return;
+	} catch (error) {
+		printError(context, error instanceof Error ? error.message : String(error));
+	}
+	try {
+		const { token, profilePath, profileLabel } = await resolveProfile(args);
+		const tokenManager = new TokenManager(token);
+		const result = await executeCommand(args, new TeamsClient(tokenManager), context);
+		if (result.command === "help" && typeof result.data === "string") {
+			printHelp(context, result.data);
+			return;
+		}
+		await saveRefreshToken(profilePath, tokenManager.getRefreshToken());
+		printResult(context, result, profileLabel);
+	} catch (error) {
+		printError(context, error instanceof Error ? error.message : String(error));
+	}
+}
+
+//#endregion
+export {  };