granola-toolkit 0.59.0 → 0.60.0

package/README.md

@@ -26,8 +26,7 @@ macOS arm64, Linux x64, and Windows x64. Extract the archive and run `granola` (
 ```bash
 granola init --provider openrouter
 granola auth login --api-key grn_...
-granola sync
-granola sync --watch
+granola service start
 granola web
 ```
 
@@ -39,6 +38,10 @@ If you start with `granola web`, the browser now walks you through the same firs
 enter a Granola API key, import your meetings, choose an agent provider, and land in a workspace
 with a starter reviewable notes pipeline already configured.
 
+`granola service start` is the new long-running background mode. It keeps the local sync loop warm,
+serves the browser workspace, and lets `granola attach` discover the running service without making
+you keep a foreground terminal open.
+
 If you prefer to reuse the desktop app session instead, `granola auth login` still imports it from
 `supabase.json`.
 

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { Input, ProcessTerminal, TUI, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
-import { existsSync } from "node:fs";
+import { closeSync, existsSync, openSync } from "node:fs";
 import { access, appendFile, mkdir, mkdtemp, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
 import { homedir, platform, tmpdir } from "node:os";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { NodeHtmlMarkdown } from "node-html-markdown";
+import { Input, ProcessTerminal, TUI, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
 import { createHash, randomUUID } from "node:crypto";
-import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { createServer } from "node:http";
 //#region src/transport.ts
@@ -453,6 +453,34 @@ async function createGranolaServerClient(serverUrl, options = {}) {
 	return await GranolaServerClient.connect(serverUrl, options);
 }
 //#endregion
+//#region src/persistence/layout.ts
+function defaultGranolaToolkitDataDirectory(targetPlatform = platform(), homeDirectory = homedir()) {
+	return targetPlatform === "darwin" ? join(homeDirectory, "Library", "Application Support", "granola-toolkit") : join(homeDirectory, ".config", "granola-toolkit");
+}
+function defaultGranolaToolkitPersistenceLayout(options = {}) {
+	const targetPlatform = options.platform ?? platform();
+	const dataDirectory = defaultGranolaToolkitDataDirectory(targetPlatform, options.homeDirectory ?? homedir());
+	return {
+		agentHarnessesFile: join(dataDirectory, "agent-harnesses.json"),
+		automationArtefactsFile: join(dataDirectory, "automation-artefacts.json"),
+		automationMatchesFile: join(dataDirectory, "automation-matches.jsonl"),
+		automationRulesFile: join(dataDirectory, "automation-rules.json"),
+		automationRunsFile: join(dataDirectory, "automation-runs.jsonl"),
+		apiKeyFile: join(dataDirectory, "api-key.txt"),
+		dataDirectory,
+		exportJobsFile: join(dataDirectory, "export-jobs.json"),
+		meetingIndexFile: join(dataDirectory, "meeting-index.json"),
+		pkmTargetsFile: join(dataDirectory, "pkm-targets.json"),
+		searchIndexFile: join(dataDirectory, "search-index.json"),
+		serviceLogFile: join(dataDirectory, "service.log"),
+		serviceStateFile: join(dataDirectory, "service.json"),
+		sessionFile: join(dataDirectory, "session.json"),
+		sessionStoreKind: targetPlatform === "darwin" ? "keychain" : "file",
+		syncEventsFile: join(dataDirectory, "sync-events.jsonl"),
+		syncStateFile: join(dataDirectory, "sync-state.json")
+	};
+}
+//#endregion
 //#region src/utils.ts
 const INVALID_FILENAME_CHARS = /[<>:"/\\|?*]/g;
 const CONTROL_CHARACTERS = /\p{Cc}/gu;
@@ -602,6 +630,159 @@ function transcriptSpeakerLabel(segment) {
 	return source;
 }
 //#endregion
+//#region src/service.ts
+function defaultServiceStateFilePath() {
+	return defaultGranolaToolkitPersistenceLayout().serviceStateFile;
+}
+function defaultServiceLogFilePath() {
+	return defaultGranolaToolkitPersistenceLayout().serviceLogFile;
+}
+function createTimeoutSignal(timeoutMs) {
+	if (timeoutMs <= 0 || typeof AbortSignal.timeout !== "function") return;
+	return AbortSignal.timeout(timeoutMs);
+}
+function parseServiceRecord(value) {
+	if (!value || typeof value !== "object") return;
+	const candidate = value;
+	if (typeof candidate.hostname !== "string" || typeof candidate.logFile !== "string" || typeof candidate.passwordProtected !== "boolean" || typeof candidate.pid !== "number" || typeof candidate.port !== "number" || typeof candidate.protocolVersion !== "number" || typeof candidate.startedAt !== "string" || typeof candidate.syncEnabled !== "boolean" || typeof candidate.syncIntervalMs !== "number" || typeof candidate.url !== "string") return;
+	return candidate;
+}
+async function fetchServerInfo(serviceUrl, options = {}) {
+	const response = await (options.fetchImpl ?? globalThis.fetch)(new URL(granolaTransportPaths.serverInfo, serviceUrl), {
+		headers: { accept: "application/json" },
+		signal: createTimeoutSignal(options.timeoutMs ?? 1500)
+	});
+	if (!response.ok) throw new Error(`service responded with ${response.status} ${response.statusText}`.trim());
+	const info = await response.json();
+	if (info.product !== "granola-toolkit" || info.protocolVersion !== 2) throw new Error("service metadata did not match the expected Granola Toolkit protocol");
+	return info;
+}
+function currentGranolaCliInvocation(argv = process.argv, execPath = process.execPath) {
+	const entrypoint = argv[1];
+	return {
+		args: typeof entrypoint === "string" && /\.(?:[cm]?js|mjs|cjs|ts)$/.test(entrypoint) ? [entrypoint] : [],
+		file: execPath
+	};
+}
+function defaultGranolaServiceRecord() {
+	return {
+		logFile: defaultServiceLogFilePath(),
+		serviceStateFile: defaultServiceStateFilePath()
+	};
+}
+function isGranolaServiceProcessRunning(pid) {
+	if (!Number.isInteger(pid) || pid < 1) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "EPERM") return true;
+		return false;
+	}
+}
+async function readGranolaServiceRecord(serviceStateFile = defaultServiceStateFilePath()) {
+	try {
+		const raw = await readUtf8(serviceStateFile);
+		return parseServiceRecord(JSON.parse(raw));
+	} catch {
+		return;
+	}
+}
+async function writeGranolaServiceRecord(record, serviceStateFile = defaultServiceStateFilePath()) {
+	await writeTextFile$1(serviceStateFile, `${JSON.stringify(record, null, 2)}\n`);
+}
+async function removeGranolaServiceRecord(serviceStateFile = defaultServiceStateFilePath()) {
+	await rm(serviceStateFile, { force: true });
+}
+async function inspectGranolaService(options = {}) {
+	const record = await readGranolaServiceRecord(options.serviceStateFile);
+	if (!record) return { kind: "missing" };
+	if (!(options.isProcessRunning ?? isGranolaServiceProcessRunning)(record.pid)) {
+		if (options.cleanupStale !== false) await removeGranolaServiceRecord(options.serviceStateFile);
+		return {
+			kind: "stale",
+			record
+		};
+	}
+	try {
+		return {
+			info: await fetchServerInfo(record.url, {
+				fetchImpl: options.fetchImpl,
+				timeoutMs: options.timeoutMs
+			}),
+			kind: "running",
+			record
+		};
+	} catch (error) {
+		return {
+			error: error instanceof Error ? error : new Error(String(error)),
+			kind: "unreachable",
+			record
+		};
+	}
+}
+async function discoverGranolaService(options = {}) {
+	const status = await inspectGranolaService(options);
+	return status.kind === "running" ? status.record : void 0;
+}
+async function waitForGranolaService(options = {}) {
+	const intervalMs = Math.max(100, options.intervalMs ?? 200);
+	const timeoutMs = Math.max(intervalMs, options.timeoutMs ?? 1e4);
+	const startedAt = Date.now();
+	let lastStatus = { kind: "missing" };
+	while (Date.now() - startedAt <= timeoutMs) {
+		lastStatus = await inspectGranolaService({
+			cleanupStale: false,
+			fetchImpl: options.fetchImpl,
+			isProcessRunning: options.isProcessRunning,
+			serviceStateFile: options.serviceStateFile,
+			timeoutMs: options.timeoutMs
+		});
+		if (lastStatus.kind === "running") return lastStatus;
+		await new Promise((resolve) => {
+			setTimeout(resolve, intervalMs);
+		});
+	}
+	return lastStatus;
+}
+async function readGranolaServiceLogTail(options = {}) {
+	const logFile = options.logFile ?? defaultServiceLogFilePath();
+	try {
+		await access(logFile);
+	} catch {
+		return;
+	}
+	const raw = await readFile(logFile, "utf8");
+	const byteLimit = Math.max(256, options.bytes ?? 4e3);
+	return raw.slice(-byteLimit).trim() || void 0;
+}
+async function spawnGranolaServiceProcess(options = {}) {
+	const cliInvocation = options.cliInvocation ?? currentGranolaCliInvocation();
+	const stdoutFd = openSync(options.logFile ?? defaultServiceLogFilePath(), "a");
+	const spawnImpl = options.spawnImpl ?? spawn;
+	try {
+		const child = spawnImpl(cliInvocation.file, [
+			...cliInvocation.args,
+			"service",
+			"run",
+			...options.commandArgs ?? []
+		], {
+			cwd: options.cwd ?? process.cwd(),
+			detached: true,
+			env: options.env ?? process.env,
+			stdio: [
+				"ignore",
+				stdoutFd,
+				stdoutFd
+			]
+		});
+		child.unref();
+		return child.pid ?? 0;
+	} finally {
+		closeSync(stdoutFd);
+	}
+}
+//#endregion
 //#region src/meeting-roles.ts
 function normaliseKey(value) {
 	return (value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
@@ -2963,7 +3144,7 @@ function attachHelp() {
 	return `Granola attach
 
 Usage:
-  granola attach <url> [options]
+  granola attach [url] [options]
 
 Options:
   --meeting <id>      Open the workspace focused on a specific meeting
@@ -2981,39 +3162,19 @@ const attachCommand = {
 	help: attachHelp,
 	name: "attach",
 	async run({ commandArgs, commandFlags }) {
-		const serverUrl = commandArgs[0];
-		if (!serverUrl?.trim()) throw new Error("attach requires a server URL, for example http://127.0.0.1:4123");
+		let serverUrl = commandArgs[0];
+		if (!serverUrl?.trim()) {
+			const discovered = await discoverGranolaService();
+			if (!discovered) throw new Error("attach requires a server URL or a running background service. Start one with `granola service start`.");
+			serverUrl = discovered.url;
+			console.log(`Attaching to ${serverUrl}`);
+		}
 		const initialMeetingId = typeof commandFlags.meeting === "string" && commandFlags.meeting.trim() ? commandFlags.meeting.trim() : void 0;
-		return await runGranolaTui(await createGranolaServerClient(serverUrl, { password: typeof commandFlags.password === "string" && commandFlags.password.trim() ? commandFlags.password.trim() : void 0 }), { initialMeetingId });
+		const password = typeof commandFlags.password === "string" && commandFlags.password.trim() ? commandFlags.password.trim() : void 0;
+		return await runGranolaTui(await createGranolaServerClient(serverUrl, { password }), { initialMeetingId });
 	}
 };
 //#endregion
-//#region src/persistence/layout.ts
-function defaultGranolaToolkitDataDirectory(targetPlatform = platform(), homeDirectory = homedir()) {
-	return targetPlatform === "darwin" ? join(homeDirectory, "Library", "Application Support", "granola-toolkit") : join(homeDirectory, ".config", "granola-toolkit");
-}
-function defaultGranolaToolkitPersistenceLayout(options = {}) {
-	const targetPlatform = options.platform ?? platform();
-	const dataDirectory = defaultGranolaToolkitDataDirectory(targetPlatform, options.homeDirectory ?? homedir());
-	return {
-		agentHarnessesFile: join(dataDirectory, "agent-harnesses.json"),
-		automationArtefactsFile: join(dataDirectory, "automation-artefacts.json"),
-		automationMatchesFile: join(dataDirectory, "automation-matches.jsonl"),
-		automationRulesFile: join(dataDirectory, "automation-rules.json"),
-		automationRunsFile: join(dataDirectory, "automation-runs.jsonl"),
-		apiKeyFile: join(dataDirectory, "api-key.txt"),
-		dataDirectory,
-		exportJobsFile: join(dataDirectory, "export-jobs.json"),
-		meetingIndexFile: join(dataDirectory, "meeting-index.json"),
-		pkmTargetsFile: join(dataDirectory, "pkm-targets.json"),
-		searchIndexFile: join(dataDirectory, "search-index.json"),
-		sessionFile: join(dataDirectory, "session.json"),
-		sessionStoreKind: targetPlatform === "darwin" ? "keychain" : "file",
-		syncEventsFile: join(dataDirectory, "sync-events.jsonl"),
-		syncStateFile: join(dataDirectory, "sync-state.json")
-	};
-}
-//#endregion
 //#region src/agent-harnesses.ts
 function stringArray$1(value) {
 	if (!Array.isArray(value)) return;
@@ -10787,6 +10948,229 @@ const searchCommand = {
 	}
 };
 //#endregion
+//#region src/commands/service.ts
+function serviceHelp() {
+	return `Granola service
+
+Usage:
+  granola service start [options]
+  granola service status
+  granola service stop
+
+Options:
+  --network <mode>        Network mode: local or lan (default: local)
+  --hostname <value>      Hostname to bind (overrides network default)
+  --port <value>          Port to bind (default: 0 for any available port)
+  --password <value>      Optional server password for API and browser access
+  --sync-interval <value> Background sync interval, e.g. 60s or 5m (default: 60s)
+  --no-sync               Disable the background sync loop
+  --trusted-origins <v>   Comma-separated extra browser origins to trust
+  --cache <path>          Path to Granola cache JSON
+  --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 appendFlag(args, name, value) {
+	if (value === void 0 || value === false) return;
+	args.push(`--${name}`);
+	if (typeof value === "string") args.push(value);
+}
+function serialiseServiceFlags(commandFlags, globalFlags) {
+	const args = [];
+	appendFlag(args, "network", commandFlags.network);
+	appendFlag(args, "hostname", commandFlags.hostname);
+	appendFlag(args, "port", commandFlags.port);
+	appendFlag(args, "password", commandFlags.password);
+	appendFlag(args, "sync-interval", commandFlags["sync-interval"]);
+	appendFlag(args, "no-sync", commandFlags["no-sync"]);
+	appendFlag(args, "trusted-origins", commandFlags["trusted-origins"]);
+	appendFlag(args, "cache", commandFlags.cache);
+	appendFlag(args, "timeout", commandFlags.timeout);
+	appendFlag(args, "config", globalFlags.config);
+	appendFlag(args, "rules", globalFlags.rules);
+	appendFlag(args, "supabase", globalFlags.supabase);
+	appendFlag(args, "debug", globalFlags.debug);
+	const env = { ...process.env };
+	if (typeof globalFlags["api-key"] === "string" && globalFlags["api-key"].trim()) env.GRANOLA_API_KEY = globalFlags["api-key"].trim();
+	return {
+		args,
+		env
+	};
+}
+function printServiceStatus(status) {
+	switch (status.kind) {
+		case "running":
+			console.log(`Granola Toolkit service is running on ${status.record?.url}`);
+			console.log(`PID: ${status.record?.pid}`);
+			console.log(`Log: ${status.record?.logFile}`);
+			console.log(status.record?.syncEnabled ? `Background sync: enabled (${status.record.syncIntervalMs}ms)` : "Background sync: disabled");
+			if (status.record?.passwordProtected) console.log("Password protection: enabled");
+			return;
+		case "stale":
+			console.log("Granola Toolkit service metadata exists, but the process is not running.");
+			return;
+		case "unreachable":
+			console.log("Granola Toolkit service metadata exists, but the server did not respond.");
+			if (status.record?.url) console.log(`Last known URL: ${status.record.url}`);
+			if (status.error) console.log(`Health check: ${status.error.message}`);
+			return;
+		case "invalid":
+			console.log("Granola Toolkit service metadata is invalid.");
+			return;
+		default: console.log("Granola Toolkit service is not running.");
+	}
+}
+function printServiceRunBanner(record) {
+	console.log(`Granola Toolkit background service listening on ${record.url}`);
+	console.log(record.syncEnabled ? `Background sync: enabled (${record.syncIntervalMs}ms)` : "Background sync: disabled");
+	if (record.passwordProtected) console.log("Password protection: enabled");
+}
+async function runServiceProcess(config, commandFlags) {
+	const hostname = resolveServerHostname(parseNetworkMode(commandFlags.network), commandFlags.hostname);
+	const port = parsePort(commandFlags.port);
+	const password = typeof commandFlags.password === "string" && commandFlags.password.trim() ? commandFlags.password.trim() : void 0;
+	const syncEnabledForService = syncEnabled(commandFlags);
+	const syncIntervalMs = parseSyncInterval(commandFlags["sync-interval"]);
+	const trustedOrigins = parseTrustedOrigins(commandFlags["trusted-origins"]);
+	const { logFile, serviceStateFile } = defaultGranolaServiceRecord();
+	const app = await createGranolaApp(config, { surface: "server" });
+	const server = await startGranolaServer(app, {
+		enableWebClient: true,
+		hostname,
+		port,
+		security: {
+			password,
+			trustedOrigins
+		}
+	});
+	const syncLoop = syncEnabledForService ? createGranolaSyncLoop({
+		app,
+		intervalMs: syncIntervalMs,
+		logger: console
+	}) : void 0;
+	const record = {
+		hostname: server.hostname,
+		logFile,
+		passwordProtected: Boolean(password),
+		pid: process.pid,
+		port: server.port,
+		protocolVersion: 2,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		syncEnabled: syncEnabledForService,
+		syncIntervalMs,
+		url: server.url.href
+	};
+	await writeGranolaServiceRecord(record, serviceStateFile);
+	syncLoop?.start();
+	printServiceRunBanner(record);
+	await waitForShutdown(async () => {
+		await syncLoop?.stop();
+		await server.close();
+		await removeGranolaServiceRecord(serviceStateFile);
+	});
+	return 0;
+}
+const serviceCommand = {
+	description: "Run and manage the Granola Toolkit background service",
+	flags: {
+		cache: { type: "string" },
+		help: { type: "boolean" },
+		hostname: { type: "string" },
+		network: { type: "string" },
+		"no-sync": { type: "boolean" },
+		password: { type: "string" },
+		port: { type: "string" },
+		"sync-interval": { type: "string" },
+		timeout: { type: "string" },
+		"trusted-origins": { type: "string" }
+	},
+	help: serviceHelp,
+	name: "service",
+	async run({ commandArgs, commandFlags, globalFlags }) {
+		const action = commandArgs[0];
+		if (!action) {
+			console.log(serviceHelp());
+			return 1;
+		}
+		if (action === "status") {
+			const status = await inspectGranolaService();
+			printServiceStatus(status);
+			return status.kind === "running" ? 0 : 1;
+		}
+		if (action === "stop") {
+			const status = await inspectGranolaService({ cleanupStale: false });
+			if (status.kind === "missing" || status.kind === "stale") {
+				printServiceStatus(status);
+				await removeGranolaServiceRecord(defaultGranolaServiceRecord().serviceStateFile);
+				return 0;
+			}
+			if (status.kind !== "running" || !status.record) {
+				printServiceStatus(status);
+				return 1;
+			}
+			process.kill(status.record.pid, "SIGTERM");
+			const startedAt = Date.now();
+			while (Date.now() - startedAt <= 1e4) {
+				const nextStatus = await inspectGranolaService();
+				if (nextStatus.kind === "missing" || nextStatus.kind === "stale") {
+					console.log("Granola Toolkit service stopped.");
+					return 0;
+				}
+				await new Promise((resolve) => {
+					setTimeout(resolve, 200);
+				});
+			}
+			throw new Error("service did not stop within 10s");
+		}
+		if (action === "run") {
+			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)");
+			debug(config.debug, "timeoutMs", config.notes.timeoutMs);
+			return await runServiceProcess(config, commandFlags);
+		}
+		if (action === "start") {
+			const existing = await discoverGranolaService();
+			if (existing) {
+				console.log(`Granola Toolkit service is already running on ${existing.url}`);
+				console.log(`PID: ${existing.pid}`);
+				return 0;
+			}
+			await loadConfig({
+				env: typeof globalFlags["api-key"] === "string" && globalFlags["api-key"].trim() ? {
+					...process.env,
+					GRANOLA_API_KEY: globalFlags["api-key"].trim()
+				} : process.env,
+				globalFlags,
+				subcommandFlags: commandFlags
+			});
+			const { args, env } = serialiseServiceFlags(commandFlags, globalFlags);
+			await spawnGranolaServiceProcess({
+				commandArgs: args,
+				env,
+				logFile: defaultGranolaServiceRecord().logFile
+			});
+			const status = await waitForGranolaService();
+			if (status.kind !== "running" || !status.record) {
+				const logTail = await readGranolaServiceLogTail();
+				throw new Error(logTail ? `service failed to start cleanly:\n${logTail}` : "service failed to start cleanly");
+			}
+			console.log(`Granola Toolkit service started on ${status.record.url}`);
+			console.log(`PID: ${status.record.pid}`);
+			console.log(`Log: ${status.record.logFile}`);
+			return 0;
+		}
+		throw new Error(`unknown service command: ${action}`);
+	}
+};
+//#endregion
 //#region src/commands/serve.ts
 function serveHelp() {
 	return `Granola serve
@@ -11131,6 +11515,11 @@ Options:
   -h, --help              Show help
 `;
 }
+function canReuseRunningService(commandFlags, globalFlags) {
+	const hasRuntimeOverride = commandFlags.cache !== void 0 || commandFlags.hostname !== void 0 || commandFlags.network !== void 0 || commandFlags["no-sync"] !== void 0 || commandFlags.password !== void 0 || commandFlags.port !== void 0 || commandFlags["sync-interval"] !== void 0 || commandFlags.timeout !== void 0 || commandFlags["trusted-origins"] !== void 0;
+	const hasGlobalOverride = globalFlags["api-key"] !== void 0 || globalFlags.config !== void 0 || globalFlags.rules !== void 0 || globalFlags.supabase !== void 0;
+	return !hasRuntimeOverride && !hasGlobalOverride;
+}
 //#endregion
 //#region src/commands/index.ts
 const commands = [
@@ -11143,6 +11532,7 @@ const commands = [
 	meetingCommand,
 	notesCommand,
 	searchCommand,
+	serviceCommand,
 	serveCommand,
 	syncCommand,
 	tuiCommand,
@@ -11166,6 +11556,24 @@ const commands = [
 		help: webHelp,
 		name: "web",
 		async run({ commandFlags, globalFlags }) {
+			const options = resolveGranolaWebWorkspaceOptions(commandFlags);
+			const targetMeetingId = typeof commandFlags.meeting === "string" && commandFlags.meeting.trim() ? commandFlags.meeting.trim() : void 0;
+			if (canReuseRunningService(commandFlags, globalFlags)) {
+				const runningService = await discoverGranolaService();
+				if (runningService) {
+					const targetUrl = targetMeetingId ? buildGranolaMeetingUrl(new URL(runningService.url), targetMeetingId) : new URL(runningService.url);
+					console.log(`Granola Toolkit web workspace already running on ${runningService.url}`);
+					if (targetUrl.href !== runningService.url) console.log(`Focused meeting URL: ${targetUrl.href}`);
+					if (options.openBrowser) try {
+						await openExternalUrl(targetUrl);
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						console.error(`failed to open browser automatically: ${message}`);
+						console.error(`open ${targetUrl.href} manually`);
+					}
+					return 0;
+				}
+			}
 			const config = await loadConfig({
 				globalFlags,
 				subcommandFlags: commandFlags
@@ -11174,10 +11582,7 @@ const commands = [
 			debug(config.debug, "supabase", config.supabase);
 			debug(config.debug, "cacheFile", config.transcripts.cacheFile || "(none)");
 			debug(config.debug, "timeoutMs", config.notes.timeoutMs);
-			const app = await createGranolaApp(config, { surface: "web" });
-			const options = resolveGranolaWebWorkspaceOptions(commandFlags);
-			const targetMeetingId = typeof commandFlags.meeting === "string" && commandFlags.meeting.trim() ? commandFlags.meeting.trim() : void 0;
-			return await runGranolaWebWorkspace(app, {
+			return await runGranolaWebWorkspace(await createGranolaApp(config, { surface: "web" }), {
 				...options,
 				targetMeetingId
 			});
@@ -11276,6 +11681,7 @@ Examples:
   granola attach http://127.0.0.1:4123
   granola folder list
   granola init --provider openrouter
+  granola service start
   granola sync
   granola notes --supabase "${granolaSupabaseCandidates()[0] ?? "/path/to/supabase.json"}"
   granola transcripts --cache "${granolaCacheCandidates()[0] ?? "/path/to/cache-v3.json"}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granola-toolkit",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Toolkit for exporting and working with Granola meetings, notes, and transcripts",
   "keywords": [
     "cli",