granola-toolkit 0.22.0 → 0.24.0

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { existsSync } from "node:fs";
-import { execFile } from "node:child_process";
 import { mkdir, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
-import { promisify } from "node:util";
 import { NodeHtmlMarkdown } from "node-html-markdown";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { createHash, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 //#region src/utils.ts
@@ -153,6 +153,60 @@ function transcriptSpeakerLabel(segment) {
 	return segment.source === "microphone" ? "You" : "System";
 }
 //#endregion
+//#region src/cache.ts
+function parseCacheDocument(id, value) {
+	const record = asRecord(value);
+	if (!record) return;
+	return {
+		createdAt: stringValue(record.created_at),
+		id,
+		title: stringValue(record.title),
+		updatedAt: stringValue(record.updated_at)
+	};
+}
+function parseTranscriptSegments(value) {
+	if (!Array.isArray(value)) return;
+	return value.flatMap((segment) => {
+		const record = asRecord(segment);
+		if (!record) return [];
+		return [{
+			documentId: stringValue(record.document_id),
+			endTimestamp: stringValue(record.end_timestamp),
+			id: stringValue(record.id),
+			isFinal: Boolean(record.is_final),
+			source: stringValue(record.source),
+			startTimestamp: stringValue(record.start_timestamp),
+			text: stringValue(record.text)
+		}];
+	});
+}
+function parseCacheContents(contents) {
+	const outer = parseJsonString(contents);
+	if (!outer) throw new Error("failed to parse cache JSON");
+	const rawCache = outer.cache;
+	let cachePayload;
+	if (typeof rawCache === "string") cachePayload = parseJsonString(rawCache);
+	else cachePayload = asRecord(rawCache);
+	const state = cachePayload ? asRecord(cachePayload.state) : void 0;
+	if (!state) throw new Error("failed to parse cache state");
+	const rawDocuments = asRecord(state.documents) ?? {};
+	const rawTranscripts = asRecord(state.transcripts) ?? {};
+	const documents = {};
+	for (const [id, rawDocument] of Object.entries(rawDocuments)) {
+		const document = parseCacheDocument(id, rawDocument);
+		if (document) documents[id] = document;
+	}
+	const transcripts = {};
+	for (const [id, rawTranscript] of Object.entries(rawTranscripts)) {
+		const segments = parseTranscriptSegments(rawTranscript);
+		if (segments) transcripts[id] = segments;
+	}
+	return {
+		documents,
+		transcripts
+	};
+}
+//#endregion
 //#region src/client/auth.ts
 const execFileAsync$1 = promisify(execFile);
 const DEFAULT_CLIENT_ID = "client_GranolaMac";
@@ -380,121 +434,126 @@ function createDefaultSessionStore() {
 	return platform() === "darwin" ? new KeychainSessionStore() : new FileSessionStore();
 }
 //#endregion
-//#region src/commands/auth.ts
-function authHelp() {
-	return `Granola auth
-
-Usage:
-  granola auth <login|status|logout>
-
-Subcommands:
-  login               Import credentials from the Granola desktop app
-  status              Show whether a stored Granola session is available
-  logout              Delete the stored Granola session
-
-Options:
-  --supabase <path>   Path to supabase.json for auth login
-  -h, --help          Show help
-`;
-}
-const authCommand = {
-	description: "Manage stored Granola sessions",
-	flags: { help: { type: "boolean" } },
-	help: authHelp,
-	name: "auth",
-	async run({ commandArgs, globalFlags }) {
-		const [action] = commandArgs;
-		switch (action) {
-			case "login": return await login(globalFlags.supabase);
-			case "logout": return await logout();
-			case "status": return await status();
-			case void 0:
-				console.log(authHelp());
-				return 1;
-			default: throw new Error("invalid auth command: expected login, status, or logout");
-		}
-	}
-};
-async function login(supabaseFlag) {
-	const supabasePath = typeof supabaseFlag === "string" && supabaseFlag.trim() || firstExistingPath(granolaSupabaseCandidates());
-	if (!supabasePath) throw new Error(`supabase.json not found. Pass --supabase or create .granola.toml. Expected locations include: ${granolaSupabaseCandidates().join(", ")}`);
-	if (!existsSync(supabasePath)) throw new Error(`supabase.json not found: ${supabasePath}`);
-	const sessionStore = createDefaultSessionStore();
-	const session = await new SupabaseFileSessionSource(supabasePath).loadSession();
-	await sessionStore.writeSession(session);
-	console.log(`Imported Granola session from ${supabasePath}`);
-	return 0;
-}
-async function status() {
-	const session = await createDefaultSessionStore().readSession();
-	if (!session) {
-		console.log("No stored Granola session");
-		return 1;
-	}
-	console.log("Stored Granola session");
-	console.log(`Client ID: ${session.clientId}`);
-	console.log(`Refresh token: ${session.refreshToken ? "available" : "missing"}`);
-	console.log(`Sign-in method: ${session.signInMethod ?? "unknown"}`);
-	return 0;
-}
-async function logout() {
-	await createDefaultSessionStore().clearSession();
-	console.log("Stored Granola session deleted");
-	return 0;
-}
-//#endregion
-//#region src/cache.ts
-function parseCacheDocument(id, value) {
-	const record = asRecord(value);
-	if (!record) return;
+//#region src/client/default-auth.ts
+function hasStoredSession(session) {
+	return Boolean(session?.accessToken.trim());
+}
+function resolveActiveMode(options) {
+	if (options.preferredMode === "stored-session" && options.storedSessionAvailable) return "stored-session";
+	if (options.preferredMode === "supabase-file" && options.supabaseAvailable) return "supabase-file";
+	if (options.storedSessionAvailable) return "stored-session";
+	return "supabase-file";
+}
+function missingSupabaseError() {
+	return /* @__PURE__ */ new Error(`supabase.json not found. Pass --supabase or create .granola.toml. Expected locations include: ${granolaSupabaseCandidates().join(", ")}`);
+}
+function buildDefaultGranolaAuthInfo(config, options = {}) {
+	const existsSyncImpl = options.existsSyncImpl ?? existsSync;
+	const session = options.session;
+	const storedSessionAvailable = hasStoredSession(session);
+	const supabasePath = config.supabase || void 0;
+	const supabaseAvailable = Boolean(supabasePath && existsSyncImpl(supabasePath));
 	return {
-		createdAt: stringValue(record.created_at),
-		id,
-		title: stringValue(record.title),
-		updatedAt: stringValue(record.updated_at)
+		clientId: session?.clientId,
+		lastError: options.lastError,
+		mode: resolveActiveMode({
+			preferredMode: options.preferredMode,
+			storedSessionAvailable,
+			supabaseAvailable
+		}),
+		refreshAvailable: Boolean(session?.refreshToken?.trim()),
+		signInMethod: session?.signInMethod,
+		storedSessionAvailable,
+		supabaseAvailable,
+		supabasePath
 	};
 }
-function parseTranscriptSegments(value) {
-	if (!Array.isArray(value)) return;
-	return value.flatMap((segment) => {
-		const record = asRecord(segment);
-		if (!record) return [];
-		return [{
-			documentId: stringValue(record.document_id),
-			endTimestamp: stringValue(record.end_timestamp),
-			id: stringValue(record.id),
-			isFinal: Boolean(record.is_final),
-			source: stringValue(record.source),
-			startTimestamp: stringValue(record.start_timestamp),
-			text: stringValue(record.text)
-		}];
+async function inspectDefaultGranolaAuth(config, options = {}) {
+	const sessionStore = options.sessionStore ?? createDefaultSessionStore();
+	const session = options.session ?? await sessionStore.readSession();
+	return buildDefaultGranolaAuthInfo(config, {
+		existsSyncImpl: options.existsSyncImpl,
+		lastError: options.lastError,
+		preferredMode: options.preferredMode,
+		session
 	});
 }
-function parseCacheContents(contents) {
-	const outer = parseJsonString(contents);
-	if (!outer) throw new Error("failed to parse cache JSON");
-	const rawCache = outer.cache;
-	let cachePayload;
-	if (typeof rawCache === "string") cachePayload = parseJsonString(rawCache);
-	else cachePayload = asRecord(rawCache);
-	const state = cachePayload ? asRecord(cachePayload.state) : void 0;
-	if (!state) throw new Error("failed to parse cache state");
-	const rawDocuments = asRecord(state.documents) ?? {};
-	const rawTranscripts = asRecord(state.transcripts) ?? {};
-	const documents = {};
-	for (const [id, rawDocument] of Object.entries(rawDocuments)) {
-		const document = parseCacheDocument(id, rawDocument);
-		if (document) documents[id] = document;
+var DefaultAuthController = class {
+	#lastError;
+	#preferredMode;
+	constructor(config, options = {}) {
+		this.config = config;
+		this.options = options;
 	}
-	const transcripts = {};
-	for (const [id, rawTranscript] of Object.entries(rawTranscripts)) {
-		const segments = parseTranscriptSegments(rawTranscript);
-		if (segments) transcripts[id] = segments;
+	sessionStore() {
+		return this.options.sessionStore ?? createDefaultSessionStore();
 	}
-	return {
-		documents,
-		transcripts
-	};
+	readSession() {
+		return this.sessionStore().readSession();
+	}
+	resolveSupabasePath(overridePath) {
+		const supabasePath = overridePath?.trim() || this.config.supabase || "";
+		if (!supabasePath) throw missingSupabaseError();
+		if (!(this.options.existsSyncImpl ?? existsSync)(supabasePath)) throw new Error(`supabase.json not found: ${supabasePath}`);
+		return supabasePath;
+	}
+	sessionSource(supabasePath) {
+		return this.options.sessionSourceFactory?.(supabasePath) ?? new SupabaseFileSessionSource(supabasePath);
+	}
+	async inspect() {
+		const session = await this.readSession();
+		return buildDefaultGranolaAuthInfo(this.config, {
+			existsSyncImpl: this.options.existsSyncImpl,
+			lastError: this.#lastError,
+			preferredMode: this.#preferredMode,
+			session
+		});
+	}
+	async login(options = {}) {
+		const supabasePath = this.resolveSupabasePath(options.supabasePath);
+		const session = await this.sessionSource(supabasePath).loadSession();
+		await this.sessionStore().writeSession(session);
+		this.#lastError = void 0;
+		this.#preferredMode = "stored-session";
+		return await this.inspect();
+	}
+	async logout() {
+		await this.sessionStore().clearSession();
+		this.#lastError = void 0;
+		this.#preferredMode = void 0;
+		return await this.inspect();
+	}
+	async refresh() {
+		const session = await this.readSession();
+		if (!hasStoredSession(session)) {
+			this.#lastError = "no stored Granola session found";
+			throw new Error(this.#lastError);
+		}
+		try {
+			const refreshed = await refreshGranolaSession(session, this.options.fetchImpl);
+			await this.sessionStore().writeSession(refreshed);
+			this.#lastError = void 0;
+			this.#preferredMode = "stored-session";
+			return await this.inspect();
+		} catch (error) {
+			this.#lastError = error instanceof Error ? error.message : String(error);
+			throw error;
+		}
+	}
+	async switchMode(mode) {
+		const state = await this.inspect();
+		if (mode === "stored-session" && !state.storedSessionAvailable) {
+			this.#lastError = "no stored Granola session found";
+			throw new Error(this.#lastError);
+		}
+		if (mode === "supabase-file") this.resolveSupabasePath();
+		this.#lastError = void 0;
+		this.#preferredMode = mode;
+		return await this.inspect();
+	}
+};
+function createDefaultGranolaAuthController(config, options = {}) {
+	return new DefaultAuthController(config, options);
 }
 //#endregion
 //#region src/client/parsers.ts
@@ -690,26 +749,16 @@ var AuthenticatedHttpClient = class {
 };
 //#endregion
 //#region src/client/default.ts
-async function inspectDefaultGranolaAuth(config) {
-	const storedSession = await createDefaultSessionStore().readSession();
-	const hasStoredSession = Boolean(storedSession?.accessToken.trim());
-	return {
-		mode: hasStoredSession ? "stored-session" : "supabase-file",
-		storedSessionAvailable: hasStoredSession,
-		supabasePath: config.supabase || void 0
-	};
-}
-async function createDefaultGranolaRuntime(config, logger = console) {
+async function createDefaultGranolaRuntime(config, logger = console, options = {}) {
+	const auth = await inspectDefaultGranolaAuth(config, { preferredMode: options.preferredMode });
+	if (!auth.storedSessionAvailable && !config.supabase) throw new Error(`supabase.json not found. Pass --supabase or create .granola.toml. Expected locations include: ${granolaSupabaseCandidates().join(", ")}`);
+	if (!auth.storedSessionAvailable && config.supabase && !existsSync(config.supabase)) throw new Error(`supabase.json not found: ${config.supabase}`);
 	const sessionStore = createDefaultSessionStore();
-	const auth = await inspectDefaultGranolaAuth(config);
-	const hasStoredSession = auth.storedSessionAvailable;
-	if (!hasStoredSession && !config.supabase) throw new Error(`supabase.json not found. Pass --supabase or create .granola.toml. Expected locations include: ${granolaSupabaseCandidates().join(", ")}`);
-	if (!hasStoredSession && config.supabase && !existsSync(config.supabase)) throw new Error(`supabase.json not found: ${config.supabase}`);
 	return {
 		auth,
 		client: new GranolaApiClient(new AuthenticatedHttpClient({
 			logger,
-			tokenProvider: hasStoredSession ? new StoredSessionTokenProvider(sessionStore, { source: config.supabase && existsSync(config.supabase) ? new SupabaseFileSessionSource(config.supabase) : void 0 }) : new CachedTokenProvider(new SupabaseFileTokenSource(config.supabase), new NoopTokenStore())
+			tokenProvider: auth.mode === "stored-session" ? new StoredSessionTokenProvider(sessionStore, { source: config.supabase && existsSync(config.supabase) ? new SupabaseFileSessionSource(config.supabase) : void 0 }) : new CachedTokenProvider(new SupabaseFileTokenSource(config.supabase), new NoopTokenStore())
 		}))
 	};
 }
@@ -1370,6 +1419,20 @@ function compareMeetingDocumentsBySort(left, right, sort) {
 		default: return compareMeetingDocuments(left, right);
 	}
 }
+function compareMeetingSummariesByUpdated(left, right) {
+	return compareTimestampsDescending(left.updatedAt, right.updatedAt) || compareTimestampsDescending(left.createdAt, right.createdAt) || compareStrings(left.title || left.id, right.title || right.id) || compareStrings(left.id, right.id);
+}
+function compareMeetingSummariesByTitle(left, right) {
+	return compareStrings(left.title || left.id, right.title || right.id) || compareTimestampsDescending(left.updatedAt, right.updatedAt) || compareStrings(left.id, right.id);
+}
+function compareMeetingSummariesBySort(left, right, sort) {
+	switch (sort) {
+		case "title-asc": return compareMeetingSummariesByTitle(left, right);
+		case "title-desc": return -compareMeetingSummariesByTitle(left, right);
+		case "updated-asc": return -compareMeetingSummariesByUpdated(left, right);
+		default: return compareMeetingSummariesByUpdated(left, right);
+	}
+}
 function serialiseNote(note) {
 	return {
 		content: note.content,
@@ -1433,6 +1496,15 @@ function matchesMeetingSearch(document, search) {
 		...document.tags
 	].some((value) => value.toLowerCase().includes(query));
 }
+function matchesMeetingSummarySearch(meeting, search) {
+	const query = search.trim().toLowerCase();
+	if (!query) return true;
+	return [
+		meeting.id,
+		meeting.title,
+		...meeting.tags
+	].some((value) => value.toLowerCase().includes(query));
+}
 function parseDateFilter(value, label) {
 	const trimmed = value?.trim();
 	if (!trimmed) return;
@@ -1450,6 +1522,15 @@ function matchesUpdatedRange(document, updatedFrom, updatedTo) {
 	if (to != null && updatedAt > to) return false;
 	return true;
 }
+function matchesMeetingSummaryUpdatedRange(meeting, updatedFrom, updatedTo) {
+	const from = parseDateFilter(updatedFrom, "updatedFrom");
+	const to = parseDateFilter(updatedTo, "updatedTo");
+	const updatedAt = parseTimestamp(meeting.updatedAt || meeting.createdAt);
+	if (updatedAt == null) return from == null && to == null;
+	if (from != null && updatedAt < from) return false;
+	if (to != null && updatedAt > to) return false;
+	return true;
+}
 function truncate(value, width) {
 	if (value.length <= width) return value.padEnd(width);
 	return `${value.slice(0, Math.max(0, width - 1))}…`;
@@ -1505,6 +1586,14 @@ function listMeetings(documents, options = {}) {
 	const sort = options.sort ?? "updated-desc";
 	return documents.filter((document) => options.search ? matchesMeetingSearch(document, options.search) : true).filter((document) => matchesUpdatedRange(document, options.updatedFrom, options.updatedTo)).sort((left, right) => compareMeetingDocumentsBySort(left, right, sort)).slice(0, limit).map((document) => buildMeetingSummary(document, options.cacheData));
 }
+function filterMeetingSummaries(meetings, options = {}) {
+	const limit = options.limit ?? 20;
+	const sort = options.sort ?? "updated-desc";
+	return meetings.filter((meeting) => options.search ? matchesMeetingSummarySearch(meeting, options.search) : true).filter((meeting) => matchesMeetingSummaryUpdatedRange(meeting, options.updatedFrom, options.updatedTo)).sort((left, right) => compareMeetingSummariesBySort(left, right, sort)).slice(0, limit).map((meeting) => ({
+		...meeting,
+		tags: [...meeting.tags]
+	}));
+}
 function resolveMeetingQuery(documents, query) {
 	const trimmed = query.trim();
 	if (!trimmed) throw new Error("meeting query is required");
@@ -1591,6 +1680,48 @@ function renderMeetingTranscript(document, cacheData, format = "text") {
 	return renderTranscriptExport(transcript, format);
 }
 //#endregion
+//#region src/meeting-index.ts
+const MEETING_INDEX_VERSION = 1;
+var FileMeetingIndexStore = class {
+	constructor(filePath = defaultMeetingIndexFilePath()) {
+		this.filePath = filePath;
+	}
+	async readIndex() {
+		try {
+			const parsed = parseJsonString(await readFile(this.filePath, "utf8"));
+			if (!parsed || parsed.version !== MEETING_INDEX_VERSION || !Array.isArray(parsed.meetings)) return [];
+			return parsed.meetings.map((meeting) => ({
+				...meeting,
+				tags: [...meeting.tags]
+			}));
+		} catch {
+			return [];
+		}
+	}
+	async writeIndex(meetings) {
+		await mkdir(dirname(this.filePath), { recursive: true });
+		const payload = {
+			meetings: meetings.map((meeting) => ({
+				...meeting,
+				tags: [...meeting.tags]
+			})),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			version: MEETING_INDEX_VERSION
+		};
+		await writeFile(this.filePath, `${JSON.stringify(payload, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+	}
+};
+function defaultMeetingIndexFilePath() {
+	const home = homedir();
+	return platform() === "darwin" ? join(home, "Library", "Application Support", "granola-toolkit", "meeting-index.json") : join(home, ".config", "granola-toolkit", "meeting-index.json");
+}
+function createDefaultMeetingIndexStore() {
+	return new FileMeetingIndexStore();
+}
+//#endregion
 //#region src/app/core.ts
 function transcriptCount(cacheData) {
 	return Object.values(cacheData.transcripts).filter((segments) => segments.length > 0).length;
@@ -1616,6 +1747,7 @@ function cloneState(state) {
 			notes: cloneExportState(state.exports.notes),
 			transcripts: cloneExportState(state.exports.transcripts)
 		},
+		index: { ...state.index },
 		ui: { ...state.ui }
 	};
 }
@@ -1639,6 +1771,12 @@ function defaultState(config, auth, surface) {
 			loaded: false
 		},
 		exports: { jobs: [] },
+		index: {
+			available: false,
+			filePath: defaultMeetingIndexFilePath(),
+			loaded: false,
+			meetingCount: 0
+		},
 		ui: {
 			surface,
 			view: "idle"
@@ -1650,13 +1788,26 @@ var GranolaApp = class {
 	#cacheResolved = false;
 	#granolaClient;
 	#documents;
+	#meetingIndex;
 	#listeners = /* @__PURE__ */ new Set();
+	#refreshingMeetingIndex;
 	#state;
 	constructor(config, deps, options = {}) {
 		this.config = config;
 		this.deps = deps;
 		this.#state = defaultState(config, deps.auth, options.surface ?? "cli");
 		this.#state.exports.jobs = (deps.exportJobs ?? []).map((job) => cloneExportJob(job));
+		this.#meetingIndex = (deps.meetingIndex ?? []).map((meeting) => ({
+			...meeting,
+			tags: [...meeting.tags]
+		}));
+		this.#state.index = {
+			available: this.#meetingIndex.length > 0,
+			filePath: defaultMeetingIndexFilePath(),
+			loaded: this.#meetingIndex.length > 0,
+			loadedAt: this.#meetingIndex.length > 0 ? this.nowIso() : void 0,
+			meetingCount: this.#meetingIndex.length
+		};
 	}
 	getState() {
 		return cloneState(this.#state);
@@ -1675,6 +1826,59 @@ var GranolaApp = class {
 		this.emitStateUpdate();
 		return this.getState();
 	}
+	resetDocumentsState() {
+		this.#granolaClient = void 0;
+		this.#documents = void 0;
+		this.#state.documents = {
+			count: 0,
+			loaded: false
+		};
+	}
+	applyAuthState(auth, options = {}) {
+		if (options.resetDocuments) this.resetDocumentsState();
+		this.#state.auth = { ...auth };
+		if (options.view) this.#state.ui = {
+			...this.#state.ui,
+			view: options.view
+		};
+		this.emitStateUpdate();
+		return { ...auth };
+	}
+	async persistMeetingIndex(meetings) {
+		this.#meetingIndex = meetings.map((meeting) => ({
+			...meeting,
+			tags: [...meeting.tags]
+		}));
+		this.#state.index = {
+			available: this.#meetingIndex.length > 0,
+			filePath: this.#state.index.filePath,
+			loaded: this.#meetingIndex.length > 0,
+			loadedAt: this.#meetingIndex.length > 0 ? this.nowIso() : void 0,
+			meetingCount: this.#meetingIndex.length
+		};
+		if (this.deps.meetingIndexStore) await this.deps.meetingIndexStore.writeIndex(this.#meetingIndex);
+		this.emitStateUpdate();
+	}
+	async refreshMeetingIndexFromLiveData() {
+		const cacheData = await this.loadCache();
+		const documents = await this.listDocuments();
+		const meetings = listMeetings(documents, {
+			cacheData,
+			limit: documents.length || 1,
+			sort: "updated-desc"
+		});
+		await this.persistMeetingIndex(meetings);
+	}
+	triggerMeetingIndexRefresh() {
+		if (this.#refreshingMeetingIndex) return;
+		this.#refreshingMeetingIndex = (async () => {
+			try {
+				await this.refreshMeetingIndexFromLiveData();
+			} catch {} finally {
+				this.#refreshingMeetingIndex = void 0;
+			}
+		})();
+	}
 	nowIso() {
 		return (this.deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
 	}
@@ -1693,10 +1897,9 @@ var GranolaApp = class {
 			return this.#granolaClient;
 		}
 		if (!this.deps.createGranolaClient) throw new Error("Granola API client is not configured");
-		const runtime = await this.deps.createGranolaClient();
+		const runtime = await this.deps.createGranolaClient(this.#state.auth.mode);
 		this.#granolaClient = runtime.client;
-		this.#state.auth = { ...runtime.auth };
-		this.emitStateUpdate();
+		this.applyAuthState(runtime.auth);
 		return this.#granolaClient;
 	}
 	missingCacheError() {
@@ -1751,7 +1954,74 @@ var GranolaApp = class {
 			written: patch.written
 		});
 	}
-	async listDocuments() {
+	requireAuthController() {
+		if (!this.deps.authController) throw new Error("Granola auth control is not configured");
+		return this.deps.authController;
+	}
+	async inspectAuth() {
+		if (!this.deps.authController) return { ...this.#state.auth };
+		const auth = await this.deps.authController.inspect();
+		return this.applyAuthState(auth, { view: "auth" });
+	}
+	async loginAuth(options = {}) {
+		const controller = this.requireAuthController();
+		try {
+			const auth = await controller.login(options);
+			return this.applyAuthState(auth, {
+				resetDocuments: true,
+				view: "auth"
+			});
+		} catch (error) {
+			const auth = await controller.inspect();
+			this.applyAuthState(auth, { view: "auth" });
+			throw error;
+		}
+	}
+	async logoutAuth() {
+		const auth = await this.requireAuthController().logout();
+		return this.applyAuthState(auth, {
+			resetDocuments: true,
+			view: "auth"
+		});
+	}
+	async refreshAuth() {
+		const controller = this.requireAuthController();
+		try {
+			const auth = await controller.refresh();
+			return this.applyAuthState(auth, {
+				resetDocuments: true,
+				view: "auth"
+			});
+		} catch (error) {
+			const auth = await controller.inspect();
+			this.applyAuthState(auth, { view: "auth" });
+			throw error;
+		}
+	}
+	async switchAuthMode(mode) {
+		const controller = this.requireAuthController();
+		try {
+			const auth = await controller.switchMode(mode);
+			return this.applyAuthState(auth, {
+				resetDocuments: true,
+				view: "auth"
+			});
+		} catch (error) {
+			const auth = await controller.inspect();
+			this.applyAuthState(auth, { view: "auth" });
+			throw error;
+		}
+	}
+	async listDocuments(options = {}) {
+		if (options.forceRefresh) {
+			this.#granolaClient = void 0;
+			this.#documents = void 0;
+			this.#state.documents = {
+				count: 0,
+				loaded: false
+			};
+			this.emitStateUpdate();
+		}
 		if (this.#documents) return this.#documents;
 		const documents = await (await this.getGranolaClient()).listDocuments({ timeoutMs: this.config.notes.timeoutMs });
 		this.#documents = documents;
@@ -1791,15 +2061,41 @@ var GranolaApp = class {
 		return cacheData;
 	}
 	async listMeetings(options = {}) {
-		const meetings = listMeetings(await this.listDocuments(), {
-			cacheData: await this.loadCache(),
+		const preferIndex = options.preferIndex ?? (this.#state.ui.surface === "web" || this.#state.ui.surface === "server");
+		if (!options.forceRefresh && preferIndex && !this.#documents && this.#meetingIndex.length > 0) {
+			const meetings = filterMeetingSummaries(this.#meetingIndex, options);
+			this.setUiState({
+				meetingListSource: "index",
+				meetingSearch: options.search,
+				meetingSort: options.sort,
+				meetingUpdatedFrom: options.updatedFrom,
+				meetingUpdatedTo: options.updatedTo,
+				selectedMeetingId: void 0,
+				view: "meeting-list"
+			});
+			this.triggerMeetingIndexRefresh();
+			return {
+				meetings,
+				source: "index"
+			};
+		}
+		const cacheData = await this.loadCache();
+		const documents = await this.listDocuments({ forceRefresh: options.forceRefresh });
+		const meetings = listMeetings(documents, {
+			cacheData,
 			limit: options.limit,
 			search: options.search,
 			sort: options.sort,
 			updatedFrom: options.updatedFrom,
 			updatedTo: options.updatedTo
 		});
+		await this.persistMeetingIndex(listMeetings(documents, {
+			cacheData,
+			limit: Math.max(documents.length, 1),
+			sort: "updated-desc"
+		}));
 		this.setUiState({
+			meetingListSource: "live",
 			meetingSearch: options.search,
 			meetingSort: options.sort,
 			meetingUpdatedFrom: options.updatedFrom,
@@ -1807,7 +2103,10 @@ var GranolaApp = class {
 			selectedMeetingId: void 0,
 			view: "meeting-list"
 		});
-		return meetings;
+		return {
+			meetings,
+			source: "live"
+		};
 	}
 	async getMeeting(id, options = {}) {
 		const documents = await this.listDocuments();
@@ -1950,13 +2249,19 @@ var GranolaApp = class {
 };
 async function createGranolaApp(config, options = {}) {
 	const auth = await inspectDefaultGranolaAuth(config);
+	const authController = createDefaultGranolaAuthController(config);
 	const exportJobStore = createDefaultExportJobStore();
+	const exportJobs = await exportJobStore.readJobs();
+	const meetingIndexStore = createDefaultMeetingIndexStore();
 	return new GranolaApp(config, {
 		auth,
+		authController,
 		cacheLoader: loadOptionalGranolaCache,
-		createGranolaClient: async () => await createDefaultGranolaRuntime(config, options.logger),
-		exportJobs: await exportJobStore.readJobs(),
+		createGranolaClient: async (mode) => await createDefaultGranolaRuntime(config, options.logger, { preferredMode: mode }),
+		exportJobs,
 		exportJobStore,
+		meetingIndex: await meetingIndexStore.readIndex(),
+		meetingIndexStore,
 		now: options.now
 	}, { surface: options.surface });
 }
@@ -2076,6 +2381,103 @@ async function waitForShutdown(close) {
 	});
 }
 //#endregion
+//#region src/commands/auth.ts
+function authHelp() {
+	return `Granola auth
+
+Usage:
+  granola auth <login|status|logout|refresh|use> [options]
+
+Subcommands:
+  login               Import credentials from the Granola desktop app
+  status              Show the current Granola auth state
+  logout              Delete the stored Granola session
+  refresh             Refresh the stored Granola session
+  use <stored|supabase>
+                      Switch the active auth source for this toolkit instance
+
+Options:
+  --supabase <path>   Path to supabase.json for auth login
+  --config <path>     Path to .granola.toml
+  --debug             Enable debug logging
+  -h, --help          Show help
+`;
+}
+function formatAuthSource(mode) {
+	return mode === "stored-session" ? "stored session" : "supabase.json";
+}
+function printAuthState(state) {
+	console.log(`Active source: ${formatAuthSource(state.mode)}`);
+	console.log(`Stored session: ${state.storedSessionAvailable ? "available" : "missing"}`);
+	console.log(`supabase.json: ${state.supabaseAvailable ? "available" : "missing"}`);
+	if (state.supabasePath) console.log(`supabase path: ${state.supabasePath}`);
+	if (state.clientId) console.log(`Client ID: ${state.clientId}`);
+	console.log(`Refresh token: ${state.refreshAvailable ? "available" : "missing"}`);
+	if (state.signInMethod) console.log(`Sign-in method: ${state.signInMethod}`);
+	if (state.lastError) console.log(`Last error: ${state.lastError}`);
+}
+const authCommand = {
+	description: "Manage stored Granola sessions",
+	flags: { help: { type: "boolean" } },
+	help: authHelp,
+	name: "auth",
+	async run({ commandArgs, globalFlags }) {
+		const [action, value] = commandArgs;
+		const config = await loadConfig({
+			globalFlags,
+			subcommandFlags: {}
+		});
+		debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+		debug(config.debug, "supabase", config.supabase);
+		const app = await createGranolaApp(config);
+		switch (action) {
+			case "login": {
+				const state = await app.loginAuth();
+				console.log(`Imported Granola session from ${state.supabasePath ?? "desktop app defaults"}`);
+				printAuthState(state);
+				return 0;
+			}
+			case "logout": {
+				const state = await app.logoutAuth();
+				console.log("Stored Granola session deleted");
+				printAuthState(state);
+				return 0;
+			}
+			case "refresh": {
+				const state = await app.refreshAuth();
+				console.log("Stored Granola session refreshed");
+				printAuthState(state);
+				return 0;
+			}
+			case "status": {
+				const state = await app.inspectAuth();
+				printAuthState(state);
+				return state.storedSessionAvailable ? 0 : 1;
+			}
+			case "use": {
+				const mode = resolveAuthMode(value);
+				const state = await app.switchAuthMode(mode);
+				console.log(`Switched auth source to ${formatAuthSource(state.mode)}`);
+				printAuthState(state);
+				return 0;
+			}
+			case void 0:
+				console.log(authHelp());
+				return 1;
+			default: throw new Error("invalid auth command: expected login, status, logout, refresh, or use");
+		}
+	}
+};
+function resolveAuthMode(value) {
+	switch (value) {
+		case "stored":
+		case "stored-session": return "stored-session";
+		case "supabase":
+		case "supabase-file": return "supabase-file";
+		default: throw new Error("invalid auth mode: expected stored or supabase");
+	}
+}
+//#endregion
 //#region src/commands/exports.ts
 function exportsHelp() {
 	return `Granola exports
@@ -2304,12 +2706,13 @@ async function list(commandFlags, globalFlags) {
 	debug(config.debug, "timeoutMs", config.notes.timeoutMs);
 	const app = await createGranolaApp(config);
 	debug(config.debug, "authMode", app.getState().auth.mode);
-	console.log("Fetching meetings from Granola API...");
-	const meetings = await app.listMeetings({
+	console.log("Loading meetings...");
+	const result = await app.listMeetings({
 		limit,
 		search
 	});
-	console.log(renderMeetingList(meetings, format).trimEnd());
+	console.log(result.source === "index" ? "Loaded meetings from the local index" : "Fetched meetings from Granola API");
+	console.log(renderMeetingList(result.meetings, format).trimEnd());
 	return 0;
 }
 async function view(id, commandFlags, globalFlags) {
@@ -2452,6 +2855,7 @@ const state = {
   selectedMeeting: null,
   selectedMeetingBundle: null,
   selectedMeetingId: null,
+  meetingSource: "live",
   sort: "updated-desc",
   updatedFrom: "",
   updatedTo: "",
@@ -2460,6 +2864,7 @@ const state = {
 
 const els = {
   appState: document.querySelector("[data-app-state]"),
+  authPanel: document.querySelector("[data-auth-panel]"),
   detailBody: document.querySelector("[data-detail-body]"),
   detailMeta: document.querySelector("[data-detail-meta]"),
   empty: document.querySelector("[data-empty]"),
@@ -2526,6 +2931,7 @@ function renderWorkspaceTabs() {
 function renderAppState() {
   if (!state.appState) {
     els.appState.innerHTML = "<p>Waiting for server state…</p>";
+    els.authPanel.innerHTML = "<p>Waiting for auth state…</p>";
     return;
   }
 
@@ -2537,6 +2943,11 @@ function renderAppState() {
     : appState.cache.configured
       ? "configured"
       : "not configured";
+  const indexStatus = appState.index.loaded
+    ? appState.index.meetingCount + " meetings"
+    : appState.index.available
+      ? "available"
+      : "not built";
 
   els.appState.innerHTML = [
     '<div class="status-grid">',
@@ -2545,12 +2956,79 @@ function renderAppState() {
     '<div><span class="status-label">Auth</span><strong>' + escapeHtml(authMode) + "</strong></div>",
     '<div><span class="status-label">Documents</span><strong>' + escapeHtml(docs) + "</strong></div>",
     '<div><span class="status-label">Cache</span><strong>' + escapeHtml(cache) + "</strong></div>",
+    '<div><span class="status-label">Index</span><strong>' + escapeHtml(indexStatus) + "</strong></div>",
     "</div>",
   ].join("");
 
+  renderAuthPanel();
   renderExportJobs();
 }
 
+function authActionButton(label, action, disabled) {
+  return (
+    '<button class="button button--secondary" data-auth-action="' +
+    escapeHtml(action) +
+    '"' +
+    (disabled ? " disabled" : "") +
+    ">" +
+    escapeHtml(label) +
+    "</button>"
+  );
+}
+
+function authModeButton(label, mode, disabled) {
+  return (
+    '<button class="button button--secondary" data-auth-mode="' +
+    escapeHtml(mode) +
+    '"' +
+    (disabled ? " disabled" : "") +
+    ">" +
+    escapeHtml(label) +
+    "</button>"
+  );
+}
+
+function renderAuthPanel() {
+  const auth = state.appState?.auth;
+  if (!auth) {
+    els.authPanel.innerHTML = '<div class="auth-card"><div class="auth-card__meta">Auth state unavailable.</div></div>';
+    return;
+  }
+
+  const activeSource = auth.mode === "stored-session" ? "Stored session" : "supabase.json";
+  const lastError = auth.lastError
+    ? '<div class="auth-card__meta auth-card__error">' + escapeHtml(auth.lastError) + "</div>"
+    : "";
+
+  els.authPanel.innerHTML = [
+    '<div class="auth-card">',
+    '<div class="status-grid">',
+    '<div><span class="status-label">Active</span><strong>' + escapeHtml(activeSource) + "</strong></div>",
+    '<div><span class="status-label">Stored</span><strong>' + escapeHtml(auth.storedSessionAvailable ? "available" : "missing") + "</strong></div>",
+    '<div><span class="status-label">supabase.json</span><strong>' + escapeHtml(auth.supabaseAvailable ? "available" : "missing") + "</strong></div>",
+    '<div><span class="status-label">Refresh</span><strong>' + escapeHtml(auth.refreshAvailable ? "available" : "missing") + "</strong></div>",
+    "</div>",
+    auth.clientId
+      ? '<div class="auth-card__meta">Client ID: ' + escapeHtml(auth.clientId) + "</div>"
+      : "",
+    auth.signInMethod
+      ? '<div class="auth-card__meta">Sign-in method: ' + escapeHtml(auth.signInMethod) + "</div>"
+      : "",
+    auth.supabasePath
+      ? '<div class="auth-card__meta">supabase path: ' + escapeHtml(auth.supabasePath) + "</div>"
+      : "",
+    lastError,
+    '<div class="auth-card__actions">',
+    authActionButton("Import desktop session", "login", !auth.supabaseAvailable),
+    authActionButton("Refresh stored session", "refresh", !auth.storedSessionAvailable || !auth.refreshAvailable),
+    authModeButton("Use stored session", "stored-session", !auth.storedSessionAvailable || auth.mode === "stored-session"),
+    authModeButton("Use supabase.json", "supabase-file", !auth.supabaseAvailable || auth.mode === "supabase-file"),
+    authActionButton("Sign out", "logout", !auth.storedSessionAvailable),
+    "</div>",
+    "</div>",
+  ].join("");
+}
+
 function renderMeetingList() {
   if (state.listError) {
     els.list.innerHTML =
@@ -2708,7 +3186,7 @@ async function fetchJson(path, init) {
   return payload;
 }
 
-function buildMeetingsQuery(limit = 100) {
+function buildMeetingsQuery(limit = 100, refresh = false) {
   const params = new URLSearchParams();
   params.set("limit", String(limit));
   params.set("sort", state.sort);
@@ -2725,16 +3203,22 @@ function buildMeetingsQuery(limit = 100) {
     params.set("updatedTo", state.updatedTo);
   }
 
+  if (refresh) {
+    params.set("refresh", "true");
+  }
+
   return "?" + params.toString();
 }
 
 async function loadMeetings(options = {}) {
   const preferredMeetingId = options.preferredMeetingId || state.selectedMeetingId;
+  const refresh = options.refresh === true;
 
   try {
     state.listError = "";
-    const payload = await fetchJson("/meetings" + buildMeetingsQuery());
+    const payload = await fetchJson("/meetings" + buildMeetingsQuery(100, refresh));
     state.meetings = payload.meetings || [];
+    state.meetingSource = payload.source || "live";
 
     if (preferredMeetingId && state.meetings.some((meeting) => meeting.id === preferredMeetingId)) {
       state.selectedMeetingId = preferredMeetingId;
@@ -2803,12 +3287,28 @@ async function quickOpenMeeting() {
   }
 }
 
-async function refreshAll() {
+async function refreshAll(forceLiveMeetings = false) {
   setStatus("Refreshing…", "busy");
-  const [appState] = await Promise.all([fetchJson("/state"), loadMeetings()]);
-  state.appState = appState;
+  const [appState, authState] = await Promise.all([
+    fetchJson("/state"),
+    fetchJson("/auth/status"),
+    loadMeetings({ refresh: forceLiveMeetings }),
+  ]);
+  state.appState = {
+    ...appState,
+    auth: authState,
+  };
+  renderAppState();
+  setStatus(forceLiveMeetings ? "Live data refreshed" : state.meetingSource === "index" ? "Loaded from index" : "Connected", "ok");
+}
+
+async function syncAuthState() {
+  const [appState, authState] = await Promise.all([fetchJson("/state"), fetchJson("/auth/status")]);
+  state.appState = {
+    ...appState,
+    auth: authState,
+  };
   renderAppState();
-  setStatus("Connected", "ok");
 }
 
 async function exportNotes() {
@@ -2845,6 +3345,62 @@ async function rerunJob(id) {
   }
 }
 
+async function loginAuth() {
+  setStatus("Importing desktop session…", "busy");
+  try {
+    await fetchJson("/auth/login", { method: "POST" });
+    await refreshAll();
+  } catch (error) {
+    await syncAuthState();
+    setStatus("Auth import failed", "error");
+    state.detailError = error instanceof Error ? error.message : String(error);
+    renderMeetingDetail();
+  }
+}
+
+async function logoutAuth() {
+  setStatus("Signing out…", "busy");
+  try {
+    await fetchJson("/auth/logout", { method: "POST" });
+    await refreshAll();
+  } catch (error) {
+    await syncAuthState();
+    setStatus("Sign out failed", "error");
+    state.detailError = error instanceof Error ? error.message : String(error);
+    renderMeetingDetail();
+  }
+}
+
+async function refreshAuth() {
+  setStatus("Refreshing session…", "busy");
+  try {
+    await fetchJson("/auth/refresh", { method: "POST" });
+    await refreshAll();
+  } catch (error) {
+    await syncAuthState();
+    setStatus("Refresh failed", "error");
+    state.detailError = error instanceof Error ? error.message : String(error);
+    renderMeetingDetail();
+  }
+}
+
+async function switchAuthMode(mode) {
+  setStatus("Switching auth source…", "busy");
+  try {
+    await fetchJson("/auth/mode", {
+      body: JSON.stringify({ mode }),
+      headers: { "content-type": "application/json" },
+      method: "POST",
+    });
+    await refreshAll();
+  } catch (error) {
+    await syncAuthState();
+    setStatus("Switch failed", "error");
+    state.detailError = error instanceof Error ? error.message : String(error);
+    renderMeetingDetail();
+  }
+}
+
 els.list.addEventListener("click", (event) => {
   if (!(event.target instanceof Element)) {
     return;
@@ -2868,8 +3424,38 @@ els.jobsList.addEventListener("click", (event) => {
   void rerunJob(button.dataset.rerunJobId);
 });
 
+els.authPanel.addEventListener("click", (event) => {
+  if (!(event.target instanceof Element)) {
+    return;
+  }
+
+  const actionButton = event.target.closest("[data-auth-action]");
+  if (actionButton) {
+    switch (actionButton.dataset.authAction) {
+      case "login":
+        void loginAuth();
+        return;
+      case "logout":
+        void logoutAuth();
+        return;
+      case "refresh":
+        void refreshAuth();
+        return;
+      default:
+        return;
+    }
+  }
+
+  const modeButton = event.target.closest("[data-auth-mode]");
+  if (!modeButton) {
+    return;
+  }
+
+  void switchAuthMode(modeButton.dataset.authMode);
+});
+
 els.refreshButton.addEventListener("click", () => {
-  void refreshAll();
+  void refreshAll(true);
 });
 
 els.noteButton.addEventListener("click", () => {
@@ -2994,9 +3580,20 @@ document.addEventListener("keydown", (event) => {
 
 const events = new EventSource("/events");
 events.addEventListener("state.updated", (event) => {
+  const previousLoadedAt = state.appState?.documents?.loadedAt;
   const payload = JSON.parse(event.data);
   state.appState = payload.state;
   renderAppState();
+
+  if (
+    state.meetingSource === "index" &&
+    payload.state.documents?.loadedAt &&
+    payload.state.documents.loadedAt !== previousLoadedAt
+  ) {
+    void loadMeetings({
+      preferredMeetingId: state.selectedMeetingId,
+    });
+  }
 });
 events.addEventListener("error", () => {
   setStatus("Disconnected", "error");
@@ -3066,6 +3663,13 @@ const granolaWebMarkup = String.raw`
       </div>
       <p>Initial beta web client. It speaks to the same local API that future TUI and attach flows will use.</p>
     </section>
+    <section class="auth-panel">
+      <div class="auth-panel__head">
+        <h3>Auth Session</h3>
+        <p>Inspect, refresh, and switch between stored session and <code>supabase.json</code>.</p>
+      </div>
+      <div class="auth-panel__body" data-auth-panel></div>
+    </section>
     <section class="jobs-panel">
       <div class="jobs-panel__head">
         <h3>Recent Export Jobs</h3>
@@ -3295,10 +3899,12 @@ body {
   width: min(440px, 100%);
 }
 
+.auth-panel,
 .jobs-panel {
   padding: 0 24px 18px;
 }
 
+.auth-panel__head h3,
 .jobs-panel__head h3 {
   margin: 0;
   font-size: 0.92rem;
@@ -3306,12 +3912,43 @@ body {
   text-transform: uppercase;
 }
 
+.auth-panel__head p,
 .jobs-panel__head p {
   margin: 6px 0 0;
   color: var(--muted);
   font-size: 0.9rem;
 }
 
+.auth-panel__body {
+  display: grid;
+  gap: 12px;
+  margin-top: 14px;
+}
+
+.auth-card {
+  display: grid;
+  gap: 12px;
+  padding: 14px 16px;
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.auth-card__meta {
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
+.auth-card__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.auth-card__error {
+  color: var(--error);
+}
+
 .jobs-list {
   display: grid;
   gap: 10px;
@@ -3419,6 +4056,11 @@ body {
   cursor: pointer;
 }
 
+.button:disabled {
+  cursor: not-allowed;
+  opacity: 0.56;
+}
+
 .button--primary {
   background: var(--ink);
   color: white;
@@ -3566,6 +4208,13 @@ function parseMeetingSort(value) {
 		default: throw new Error("invalid sort: expected updated-desc, updated-asc, title-asc, or title-desc");
 	}
 }
+function parseAuthMode(value) {
+	switch (value) {
+		case "stored-session":
+		case "supabase-file": return value;
+		default: throw new Error("invalid auth mode: expected stored-session or supabase-file");
+	}
+}
 function sendJson(response, body, init = {}) {
 	const payload = `${JSON.stringify(body, null, 2)}\n`;
 	response.writeHead(init.status ?? 200, {
@@ -3648,6 +4297,10 @@ async function startGranolaServer(app, options = {}) {
 				sendJson(response, app.getState());
 				return;
 			}
+			if (method === "GET" && path === "/auth/status") {
+				sendJson(response, await app.inspectAuth());
+				return;
+			}
 			if (method === "GET" && path === "/events") {
 				response.writeHead(200, {
 					"cache-control": "no-cache, no-transform",
@@ -3670,19 +4323,24 @@ async function startGranolaServer(app, options = {}) {
 			}
 			if (method === "GET" && path === "/meetings") {
 				const limit = parseInteger(url.searchParams.get("limit"));
+				const refresh = url.searchParams.get("refresh") === "true";
 				const search = url.searchParams.get("search")?.trim() || void 0;
 				const sort = parseMeetingSort(url.searchParams.get("sort"));
 				const updatedFrom = url.searchParams.get("updatedFrom")?.trim() || void 0;
 				const updatedTo = url.searchParams.get("updatedTo")?.trim() || void 0;
+				const result = await app.listMeetings({
+					forceRefresh: refresh,
+					limit,
+					search,
+					sort,
+					updatedFrom,
+					updatedTo
+				});
 				sendJson(response, {
-					meetings: await app.listMeetings({
-						limit,
-						search,
-						sort,
-						updatedFrom,
-						updatedTo
-					}),
+					meetings: result.meetings,
+					refresh,
 					search,
+					source: result.source,
 					sort,
 					updatedFrom,
 					updatedTo
@@ -3701,6 +4359,25 @@ async function startGranolaServer(app, options = {}) {
 				sendJson(response, await app.getMeeting(id, { requireCache: url.searchParams.get("includeTranscript") === "true" }));
 				return;
 			}
+			if (method === "POST" && path === "/auth/login") {
+				const body = await readJsonBody(request);
+				const supabasePath = typeof body.supabasePath === "string" && body.supabasePath.trim() ? body.supabasePath.trim() : void 0;
+				sendJson(response, await app.loginAuth({ supabasePath }));
+				return;
+			}
+			if (method === "POST" && path === "/auth/logout") {
+				sendJson(response, await app.logoutAuth());
+				return;
+			}
+			if (method === "POST" && path === "/auth/refresh") {
+				sendJson(response, await app.refreshAuth());
+				return;
+			}
+			if (method === "POST" && path === "/auth/mode") {
+				const body = await readJsonBody(request);
+				sendJson(response, await app.switchAuthMode(parseAuthMode(body.mode)));
+				return;
+			}
 			if (method === "POST" && path === "/exports/notes") {
 				const body = await readJsonBody(request);
 				sendJson(response, await app.exportNotes(noteFormatFromBody(body.format)), { status: 202 });
@@ -3803,11 +4480,16 @@ const serveCommand = {
 		console.log(`Granola server listening on ${server.url.href}`);
 		console.log("Endpoints:");
 		console.log("  GET  /health");
+		console.log("  GET  /auth/status");
 		console.log("  GET  /state");
 		console.log("  GET  /events");
 		console.log("  GET  /meetings");
 		console.log("  GET  /meetings/:id");
 		console.log("  GET  /exports/jobs");
+		console.log("  POST /auth/login");
+		console.log("  POST /auth/logout");
+		console.log("  POST /auth/mode");
+		console.log("  POST /auth/refresh");
 		console.log("  POST /exports/notes");
 		console.log("  POST /exports/jobs/:id/rerun");
 		console.log("  POST /exports/transcripts");
@@ -3964,11 +4646,16 @@ const commands = [
 			console.log("Routes:");
 			console.log("  GET  /");
 			console.log("  GET  /health");
+			console.log("  GET  /auth/status");
 			console.log("  GET  /state");
 			console.log("  GET  /events");
 			console.log("  GET  /meetings");
 			console.log("  GET  /meetings/:id");
 			console.log("  GET  /exports/jobs");
+			console.log("  POST /auth/login");
+			console.log("  POST /auth/logout");
+			console.log("  POST /auth/mode");
+			console.log("  POST /auth/refresh");
 			console.log("  POST /exports/notes");
 			console.log("  POST /exports/jobs/:id/rerun");
 			console.log("  POST /exports/transcripts");