granola-toolkit 0.21.1 → 0.23.0

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/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 { createHash } from "node:crypto";
+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
 const INVALID_FILENAME_CHARS = /[<>:"/\\|?*]/g;
@@ -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())
 		}))
 	};
 }
@@ -718,6 +767,81 @@ async function loadOptionalGranolaCache(cacheFile) {
 	return parseCacheContents(await readFile(cacheFile, "utf8"));
 }
 //#endregion
+//#region src/export-jobs.ts
+const EXPORT_JOBS_VERSION = 1;
+const MAX_EXPORT_JOBS = 100;
+function normaliseJob(value) {
+	const record = asRecord(value);
+	if (!record) return;
+	const id = stringValue(record.id);
+	const kind = stringValue(record.kind);
+	const status = stringValue(record.status);
+	const format = stringValue(record.format);
+	const outputDir = stringValue(record.outputDir);
+	const startedAt = stringValue(record.startedAt);
+	const itemCount = typeof record.itemCount === "number" && Number.isFinite(record.itemCount) ? record.itemCount : 0;
+	const written = typeof record.written === "number" && Number.isFinite(record.written) ? record.written : 0;
+	const completedCount = typeof record.completedCount === "number" && Number.isFinite(record.completedCount) ? record.completedCount : written;
+	if (!id || !format || !outputDir || !startedAt || kind !== "notes" && kind !== "transcripts" || status !== "running" && status !== "completed" && status !== "failed") return;
+	return {
+		completedCount,
+		error: stringValue(record.error) || void 0,
+		finishedAt: stringValue(record.finishedAt) || void 0,
+		format,
+		id,
+		itemCount,
+		kind,
+		outputDir,
+		startedAt,
+		status,
+		written
+	};
+}
+function normaliseJobsFile(parsed) {
+	const record = asRecord(parsed);
+	if (!record || record.version !== EXPORT_JOBS_VERSION || !Array.isArray(record.jobs)) return {
+		jobs: [],
+		version: EXPORT_JOBS_VERSION
+	};
+	return {
+		jobs: record.jobs.map((job) => normaliseJob(job)).filter((job) => Boolean(job)).slice(0, MAX_EXPORT_JOBS),
+		version: EXPORT_JOBS_VERSION
+	};
+}
+function createExportJobId(kind) {
+	return `${kind}-${randomUUID()}`;
+}
+function defaultExportJobsFilePath() {
+	const home = homedir();
+	return platform() === "darwin" ? join(home, "Library", "Application Support", "granola-toolkit", "export-jobs.json") : join(home, ".config", "granola-toolkit", "export-jobs.json");
+}
+var FileExportJobStore = class {
+	constructor(filePath = defaultExportJobsFilePath()) {
+		this.filePath = filePath;
+	}
+	async readJobs() {
+		try {
+			return normaliseJobsFile(parseJsonString(await readFile(this.filePath, "utf8"))).jobs;
+		} catch {
+			return [];
+		}
+	}
+	async writeJobs(jobs) {
+		const payload = {
+			jobs: jobs.slice(0, MAX_EXPORT_JOBS),
+			version: EXPORT_JOBS_VERSION
+		};
+		await mkdir(dirname(this.filePath), { recursive: true });
+		await writeFile(this.filePath, `${JSON.stringify(payload, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+	}
+};
+function createDefaultExportJobStore() {
+	return new FileExportJobStore();
+}
+//#endregion
 //#region src/export-state.ts
 const EXPORT_STATE_VERSION = 1;
 function exportStatePath(outputDir, kind) {
@@ -783,7 +907,7 @@ function entryChanged(left, right) {
 	if (!left) return true;
 	return left.contentHash !== right.contentHash || left.exportedAt !== right.exportedAt || left.fileName !== right.fileName || left.fileStem !== right.fileStem || left.sourceUpdatedAt !== right.sourceUpdatedAt;
 }
-async function syncManagedExports({ items, kind, outputDir }) {
+async function syncManagedExports({ items, kind, onProgress, outputDir }) {
 	await ensureDirectory(outputDir);
 	const previousEntries = (await loadExportState(outputDir, kind)).entries;
 	const used = /* @__PURE__ */ new Map();
@@ -804,6 +928,7 @@ async function syncManagedExports({ items, kind, outputDir }) {
 	const activeFileNames = new Set(plans.map((plan) => plan.fileName));
 	const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const nextEntries = {};
+	let completed = 0;
 	let written = 0;
 	let stateChanged = false;
 	for (const plan of plans) {
@@ -822,6 +947,12 @@ async function syncManagedExports({ items, kind, outputDir }) {
 		};
 		nextEntries[plan.id] = nextEntry;
 		stateChanged = stateChanged || entryChanged(plan.existing, nextEntry);
+		completed += 1;
+		if (onProgress) await onProgress({
+			completed,
+			total: plans.length,
+			written
+		});
 	}
 	for (const plan of plans) {
 		const previousFileName = plan.existing?.fileName;
@@ -1106,7 +1237,7 @@ function noteFileExtension(format) {
 		case "markdown": return ".md";
 	}
 }
-async function writeNotes(documents, outputDir, format = "markdown") {
+async function writeNotes(documents, outputDir, format = "markdown", options = {}) {
 	return await syncManagedExports({
 		items: [...documents].sort((left, right) => compareStrings(left.title || left.id, right.title || right.id) || compareStrings(left.id, right.id)).map((document) => {
 			const note = buildNoteExport(document);
@@ -1119,6 +1250,7 @@ async function writeNotes(documents, outputDir, format = "markdown") {
 			};
 		}),
 		kind: "notes",
+		onProgress: options.onProgress,
 		outputDir
 	});
 }
@@ -1230,7 +1362,7 @@ function transcriptFileExtension(format) {
 		case "yaml": return ".yaml";
 	}
 }
-async function writeTranscripts(cacheData, outputDir, format = "text") {
+async function writeTranscripts(cacheData, outputDir, format = "text", options = {}) {
 	return await syncManagedExports({
 		items: Object.entries(cacheData.transcripts).filter(([, segments]) => segments.length > 0).sort(([leftId], [rightId]) => {
 			const leftDocument = cacheData.documents[leftId];
@@ -1254,6 +1386,7 @@ async function writeTranscripts(cacheData, outputDir, format = "text") {
 			}];
 		}),
 		kind: "transcripts",
+		onProgress: options.onProgress,
 		outputDir
 	});
 }
@@ -1514,6 +1647,9 @@ function transcriptCount(cacheData) {
 function cloneExportState(state) {
 	return state ? { ...state } : void 0;
 }
+function cloneExportJob(job) {
+	return { ...job };
+}
 function cloneState(state) {
 	return {
 		auth: { ...state.auth },
@@ -1525,6 +1661,7 @@ function cloneState(state) {
 		},
 		documents: { ...state.documents },
 		exports: {
+			jobs: state.exports.jobs.map((job) => cloneExportJob(job)),
 			notes: cloneExportState(state.exports.notes),
 			transcripts: cloneExportState(state.exports.transcripts)
 		},
@@ -1550,7 +1687,7 @@ function defaultState(config, auth, surface) {
 			count: 0,
 			loaded: false
 		},
-		exports: {},
+		exports: { jobs: [] },
 		ui: {
 			surface,
 			view: "idle"
@@ -1568,6 +1705,7 @@ var GranolaApp = class {
 		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));
 	}
 	getState() {
 		return cloneState(this.#state);
@@ -1586,6 +1724,24 @@ 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 };
+	}
 	nowIso() {
 		return (this.deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
 	}
@@ -1604,15 +1760,121 @@ 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() {
 		return /* @__PURE__ */ new Error(`Granola cache file not found. Pass --cache or create .granola.toml. Expected locations include: ${granolaCacheCandidates().join(", ")}`);
 	}
+	async persistExportJobs() {
+		if (!this.deps.exportJobStore) return;
+		await this.deps.exportJobStore.writeJobs(this.#state.exports.jobs);
+	}
+	async updateExportJob(job) {
+		const nextJobs = [cloneExportJob(job), ...this.#state.exports.jobs.filter((candidate) => candidate.id !== job.id).map(cloneExportJob)].slice(0, 100);
+		this.#state.exports.jobs = nextJobs;
+		await this.persistExportJobs();
+		this.emitStateUpdate();
+		return cloneExportJob(job);
+	}
+	async startExportJob(kind, format, itemCount, outputDir) {
+		return await this.updateExportJob({
+			completedCount: 0,
+			format,
+			id: createExportJobId(kind),
+			itemCount,
+			kind,
+			outputDir,
+			startedAt: this.nowIso(),
+			status: "running",
+			written: 0
+		});
+	}
+	async completeExportJob(job, patch) {
+		return await this.updateExportJob({
+			...job,
+			completedCount: patch.completedCount,
+			finishedAt: this.nowIso(),
+			status: "completed",
+			written: patch.written
+		});
+	}
+	async failExportJob(job, error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return await this.updateExportJob({
+			...job,
+			error: message,
+			finishedAt: this.nowIso(),
+			status: "failed"
+		});
+	}
+	async setExportJobProgress(job, patch) {
+		return await this.updateExportJob({
+			...job,
+			completedCount: patch.completedCount,
+			written: patch.written
+		});
+	}
+	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() {
 		if (this.#documents) return this.#documents;
 		const documents = await (await this.getGranolaClient()).listDocuments({ timeoutMs: this.config.notes.timeoutMs });
@@ -1701,13 +1963,42 @@ var GranolaApp = class {
 			meeting
 		};
 	}
+	async listExportJobs(options = {}) {
+		const limit = options.limit ?? 20;
+		const jobs = this.#state.exports.jobs.slice(0, limit).map((job) => cloneExportJob(job));
+		this.setUiState({ view: "exports-history" });
+		return { jobs };
+	}
 	async exportNotes(format = "markdown") {
+		return await this.runNotesExport({
+			format,
+			outputDir: this.config.notes.output
+		});
+	}
+	async runNotesExport(options) {
 		const documents = await this.listDocuments();
-		const written = await writeNotes(documents, this.config.notes.output, format);
+		let job = await this.startExportJob("notes", options.format, documents.length, options.outputDir);
+		let written = 0;
+		try {
+			written = await writeNotes(documents, options.outputDir, options.format, { onProgress: async (progress) => {
+				job = await this.setExportJobProgress(job, {
+					completedCount: progress.completed,
+					written: progress.written
+				});
+			} });
+			job = await this.completeExportJob(job, {
+				completedCount: documents.length,
+				written
+			});
+		} catch (error) {
+			await this.failExportJob(job, error);
+			throw error;
+		}
 		this.#state.exports.notes = {
-			format,
+			format: options.format,
 			itemCount: documents.length,
-			outputDir: this.config.notes.output,
+			jobId: job.id,
+			outputDir: options.outputDir,
 			ranAt: this.nowIso(),
 			written
 		};
@@ -1716,20 +2007,44 @@ var GranolaApp = class {
 		return {
 			documentCount: documents.length,
 			documents,
-			format,
-			outputDir: this.config.notes.output,
+			format: options.format,
+			job,
+			outputDir: options.outputDir,
 			written
 		};
 	}
 	async exportTranscripts(format = "text") {
-		const cacheData = await this.loadCache({ required: true });
-		if (!cacheData) throw this.missingCacheError();
-		const written = await writeTranscripts(cacheData, this.config.transcripts.output, format);
+		return await this.runTranscriptsExport({
+			format,
+			outputDir: this.config.transcripts.output
+		});
+	}
+	async runTranscriptsExport(options) {
+		const cacheData = await this.loadCache({ required: true });
+		if (!cacheData) throw this.missingCacheError();
 		const count = transcriptCount(cacheData);
+		let job = await this.startExportJob("transcripts", options.format, count, options.outputDir);
+		let written = 0;
+		try {
+			written = await writeTranscripts(cacheData, options.outputDir, options.format, { onProgress: async (progress) => {
+				job = await this.setExportJobProgress(job, {
+					completedCount: progress.completed,
+					written: progress.written
+				});
+			} });
+			job = await this.completeExportJob(job, {
+				completedCount: count,
+				written
+			});
+		} catch (error) {
+			await this.failExportJob(job, error);
+			throw error;
+		}
 		this.#state.exports.transcripts = {
-			format,
+			format: options.format,
 			itemCount: count,
-			outputDir: this.config.transcripts.output,
+			jobId: job.id,
+			outputDir: options.outputDir,
 			ranAt: this.nowIso(),
 			written
 		};
@@ -1737,18 +2052,37 @@ var GranolaApp = class {
 		this.setUiState({ view: "transcripts-export" });
 		return {
 			cacheData,
-			format,
-			outputDir: this.config.transcripts.output,
+			format: options.format,
+			job,
+			outputDir: options.outputDir,
 			transcriptCount: count,
 			written
 		};
 	}
+	async rerunExportJob(id) {
+		const job = this.#state.exports.jobs.find((candidate) => candidate.id === id);
+		if (!job) throw new Error(`export job not found: ${id}`);
+		if (job.kind === "notes") return await this.runNotesExport({
+			format: job.format,
+			outputDir: job.outputDir
+		});
+		return await this.runTranscriptsExport({
+			format: job.format,
+			outputDir: job.outputDir
+		});
+	}
 };
 async function createGranolaApp(config, options = {}) {
+	const auth = await inspectDefaultGranolaAuth(config);
+	const authController = createDefaultGranolaAuthController(config);
+	const exportJobStore = createDefaultExportJobStore();
 	return new GranolaApp(config, {
-		auth: await inspectDefaultGranolaAuth(config),
+		auth,
+		authController,
 		cacheLoader: loadOptionalGranolaCache,
-		createGranolaClient: async () => await createDefaultGranolaRuntime(config, options.logger),
+		createGranolaClient: async (mode) => await createDefaultGranolaRuntime(config, options.logger, { preferredMode: mode }),
+		exportJobs: await exportJobStore.readJobs(),
+		exportJobStore,
 		now: options.now
 	}, { surface: options.surface });
 }
@@ -1868,6 +2202,203 @@ 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
+
+Usage:
+  granola exports <list|rerun> [options]
+
+Subcommands:
+  list                Show recent export jobs
+  rerun <job-id>      Rerun a previous notes or transcripts export job
+
+Options:
+  --cache <path>      Path to Granola cache JSON
+  --format <value>    list output format: text, json, yaml (default: text)
+  --limit <n>         Number of jobs to show for list (default: 20)
+  --timeout <value>   Request timeout, e.g. 2m, 30s, 120000 (default: 2m)
+  --supabase <path>   Path to supabase.json
+  --debug             Enable debug logging
+  --config <path>     Path to .granola.toml
+  -h, --help          Show help
+`;
+}
+function resolveListFormat$1(value) {
+	switch (value) {
+		case void 0: return "text";
+		case "json":
+		case "text":
+		case "yaml": return value;
+		default: throw new Error("invalid exports format: expected text, json, or yaml");
+	}
+}
+function parseLimit$1(value) {
+	if (value === void 0) return 20;
+	if (typeof value !== "string" || !/^\d+$/.test(value)) throw new Error("invalid exports limit: expected a positive integer");
+	const limit = Number(value);
+	if (!Number.isInteger(limit) || limit < 1) throw new Error("invalid exports limit: expected a positive integer");
+	return limit;
+}
+function renderExportJobs(jobs, format) {
+	if (format === "json") return toJson({ jobs });
+	if (format === "yaml") return toYaml({ jobs });
+	if (jobs.length === 0) return "No export jobs\n";
+	return `${["ID                           KIND         STATUS      FORMAT      ITEMS   WRITTEN  STARTED", ...jobs.map((job) => {
+		return `${job.id.padEnd(28).slice(0, 28)} ${job.kind.padEnd(12)} ${job.status.padEnd(11)} ${job.format.padEnd(11)} ${String(job.itemCount).padEnd(7)} ${String(job.written).padEnd(8)} ${job.startedAt.slice(0, 19)}`;
+	})].join("\n")}\n`;
+}
+const exportsCommand = {
+	description: "List and rerun tracked export jobs",
+	flags: {
+		cache: { type: "string" },
+		format: { type: "string" },
+		help: { type: "boolean" },
+		limit: { type: "string" },
+		timeout: { type: "string" }
+	},
+	help: exportsHelp,
+	name: "exports",
+	async run({ commandArgs, commandFlags, globalFlags }) {
+		const [action, id] = commandArgs;
+		switch (action) {
+			case "list": return await list$1(commandFlags, globalFlags);
+			case "rerun":
+				if (!id) throw new Error("exports rerun requires a job id");
+				return await rerun(id, commandFlags, globalFlags);
+			case void 0:
+				console.log(exportsHelp());
+				return 1;
+			default: throw new Error("invalid exports command: expected list or rerun");
+		}
+	}
+};
+async function list$1(commandFlags, globalFlags) {
+	const format = resolveListFormat$1(commandFlags.format);
+	const limit = parseLimit$1(commandFlags.limit);
+	const config = await loadConfig({
+		globalFlags,
+		subcommandFlags: commandFlags
+	});
+	debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+	const result = await (await createGranolaApp(config)).listExportJobs({ limit });
+	console.log(renderExportJobs(result.jobs, format).trimEnd());
+	return 0;
+}
+async function rerun(id, commandFlags, globalFlags) {
+	const config = await loadConfig({
+		globalFlags,
+		subcommandFlags: commandFlags
+	});
+	debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+	debug(config.debug, "supabase", config.supabase);
+	debug(config.debug, "cacheFile", config.transcripts.cacheFile || "(none)");
+	const result = await (await createGranolaApp(config)).rerunExportJob(id);
+	if ("documentCount" in result) {
+		console.log(`✓ Reran notes export job ${result.job.id} to ${result.outputDir} (${result.written}/${result.documentCount} written)`);
+		return 0;
+	}
+	console.log(`✓ Reran transcripts export job ${result.job.id} to ${result.outputDir} (${result.written}/${result.transcriptCount} written)`);
+	return 0;
+}
+//#endregion
 //#region src/commands/meeting.ts
 function meetingHelp() {
 	return `Granola meeting
@@ -2116,7 +2647,7 @@ const notesCommand = {
 		const app = await createGranolaApp(config);
 		debug(config.debug, "authMode", app.getState().auth.mode);
 		const result = await app.exportNotes(format);
-		console.log(`✓ Exported ${result.documentCount} notes to ${result.outputDir}`);
+		console.log(`✓ Exported ${result.documentCount} notes to ${result.outputDir} (job ${result.job.id})`);
 		debug(config.debug, "notes written", result.written);
 		return 0;
 	}
@@ -2152,9 +2683,11 @@ 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]"),
+  jobsList: document.querySelector("[data-jobs-list]"),
   list: document.querySelector("[data-meeting-list]"),
   noteButton: document.querySelector("[data-export-notes]"),
   quickOpen: document.querySelector("[data-quick-open]"),
@@ -2217,6 +2750,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;
   }
 
@@ -2238,6 +2772,74 @@ function renderAppState() {
     '<div><span class="status-label">Cache</span><strong>' + escapeHtml(cache) + "</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() {
@@ -2350,6 +2952,44 @@ function renderMeetingDetail() {
   ].join("");
 }
 
+function renderExportJobs() {
+  const jobs = state.appState?.exports?.jobs || [];
+  if (jobs.length === 0) {
+    els.jobsList.innerHTML = '<div class="job-empty">No export jobs yet.</div>';
+    return;
+  }
+
+  els.jobsList.innerHTML = jobs
+    .slice(0, 6)
+    .map((job) => {
+      const progress = job.itemCount > 0
+        ? job.completedCount + "/" + job.itemCount + " items"
+        : "0 items";
+      const error = job.error ? '<div class="job-card__meta">' + escapeHtml(job.error) + "</div>" : "";
+      const rerunButton =
+        job.status === "running"
+          ? ""
+          : '<button class="button button--secondary" data-rerun-job-id="' + escapeHtml(job.id) + '">Rerun</button>';
+
+      return [
+        '<article class="job-card">',
+        '<div class="job-card__head">',
+        '<div>',
+        '<div class="job-card__title">' + escapeHtml(job.kind) + " export</div>",
+        '<div class="job-card__meta">' + escapeHtml(job.id) + "</div>",
+        "</div>",
+        '<div class="job-card__status" data-status="' + escapeHtml(job.status) + '">' + escapeHtml(job.status) + "</div>",
+        "</div>",
+        '<div class="job-card__meta">Format: ' + escapeHtml(job.format) + " • " + escapeHtml(progress) + " • Written: " + escapeHtml(String(job.written)) + "</div>",
+        '<div class="job-card__meta">Started: ' + escapeHtml(job.startedAt.slice(0, 19)) + "</div>",
+        error,
+        '<div class="job-card__actions">' + rerunButton + "</div>",
+        "</article>",
+      ].join("");
+    })
+    .join("");
+}
+
 async function fetchJson(path, init) {
   const response = await fetch(path, init);
   const payload = await response.json().catch(() => ({}));
@@ -2456,12 +3096,24 @@ async function quickOpenMeeting() {
 
 async function refreshAll() {
   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()]);
+  state.appState = {
+    ...appState,
+    auth: authState,
+  };
   renderAppState();
   setStatus("Connected", "ok");
 }
 
+async function syncAuthState() {
+  const [appState, authState] = await Promise.all([fetchJson("/state"), fetchJson("/auth/status")]);
+  state.appState = {
+    ...appState,
+    auth: authState,
+  };
+  renderAppState();
+}
+
 async function exportNotes() {
   setStatus("Exporting notes…", "busy");
   await fetchJson("/exports/notes", {
@@ -2482,6 +3134,76 @@ async function exportTranscripts() {
   await refreshAll();
 }
 
+async function rerunJob(id) {
+  setStatus("Rerunning export…", "busy");
+  try {
+    await fetchJson("/exports/jobs/" + encodeURIComponent(id) + "/rerun", {
+      method: "POST",
+    });
+    await refreshAll();
+  } catch (error) {
+    setStatus("Rerun failed", "error");
+    state.detailError = error instanceof Error ? error.message : String(error);
+    renderMeetingDetail();
+  }
+}
+
+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;
@@ -2492,6 +3214,49 @@ els.list.addEventListener("click", (event) => {
   void loadMeeting(button.dataset.meetingId);
 });
 
+els.jobsList.addEventListener("click", (event) => {
+  if (!(event.target instanceof Element)) {
+    return;
+  }
+
+  const button = event.target.closest("[data-rerun-job-id]");
+  if (!button) {
+    return;
+  }
+
+  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();
 });
@@ -2690,6 +3455,20 @@ 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>
+        <p>Tracked across CLI and web runs.</p>
+      </div>
+      <div class="jobs-list" data-jobs-list></div>
+    </section>
     <nav class="workspace-tabs">
       <button class="workspace-tab" data-workspace-tab="notes">Notes</button>
       <button class="workspace-tab" data-workspace-tab="transcript">Transcript</button>
@@ -2912,6 +3691,123 @@ 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;
+  letter-spacing: 0.08em;
+  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;
+  margin-top: 14px;
+}
+
+.job-card {
+  display: grid;
+  gap: 10px;
+  padding: 14px 16px;
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.job-card__head {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.job-card__title {
+  font-weight: 700;
+}
+
+.job-card__meta {
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
+.job-card__status {
+  padding: 6px 10px;
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: var(--accent);
+  font-size: 0.82rem;
+  font-weight: 700;
+}
+
+.job-card__status[data-status="running"] {
+  background: rgba(163, 79, 47, 0.12);
+  color: var(--warm);
+}
+
+.job-card__status[data-status="failed"] {
+  background: rgba(157, 44, 44, 0.12);
+  color: var(--error);
+}
+
+.job-card__status[data-status="completed"] {
+  background: rgba(36, 107, 79, 0.12);
+  color: var(--ok);
+}
+
+.job-card__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.job-empty {
+  color: var(--muted);
+  font-size: 0.92rem;
+}
+
 .workspace-tabs {
   display: flex;
   flex-wrap: wrap;
@@ -2952,6 +3848,11 @@ body {
   cursor: pointer;
 }
 
+.button:disabled {
+  cursor: not-allowed;
+  opacity: 0.56;
+}
+
 .button--primary {
   background: var(--ink);
   color: white;
@@ -3099,6 +4000,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, {
@@ -3181,6 +4089,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",
@@ -3234,11 +4146,41 @@ 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 });
 				return;
 			}
+			if (method === "GET" && path === "/exports/jobs") {
+				const limit = parseInteger(url.searchParams.get("limit"));
+				sendJson(response, await app.listExportJobs({ limit }));
+				return;
+			}
+			if (method === "POST" && path.startsWith("/exports/jobs/") && path.endsWith("/rerun")) {
+				const id = decodeURIComponent(path.slice(14, -6));
+				if (!id) throw new Error("export job id is required");
+				sendJson(response, await app.rerunExportJob(id), { status: 202 });
+				return;
+			}
 			if (method === "POST" && path === "/exports/transcripts") {
 				const body = await readJsonBody(request);
 				sendJson(response, await app.exportTranscripts(transcriptFormatFromBody(body.format)), { status: 202 });
@@ -3325,11 +4267,18 @@ 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");
 		await waitForShutdown(async () => await server.close());
 		return 0;
@@ -3375,7 +4324,7 @@ const transcriptsCommand = {
 		const app = await createGranolaApp(config);
 		debug(config.debug, "authMode", app.getState().auth.mode);
 		const result = await app.exportTranscripts(format);
-		console.log(`✓ Exported ${result.transcriptCount} transcripts to ${result.outputDir}`);
+		console.log(`✓ Exported ${result.transcriptCount} transcripts to ${result.outputDir} (job ${result.job.id})`);
 		debug(config.debug, "transcripts written", result.written);
 		return 0;
 	}
@@ -3445,6 +4394,7 @@ Options:
 //#region src/commands/index.ts
 const commands = [
 	authCommand,
+	exportsCommand,
 	meetingCommand,
 	notesCommand,
 	serveCommand,
@@ -3483,11 +4433,18 @@ 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");
 			if (openBrowser) try {
 				await openExternalUrl(server.url);