granola-cli 0.1.0

package/dist/main.js

@@ -0,0 +1,1893 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { delimiter, join as join2 } from "path";
+import { Command as Command20 } from "commander";
+
+// src/commands/alias.ts
+import chalk2 from "chalk";
+import { Command } from "commander";
+
+// src/lib/config.ts
+import Conf from "conf";
+
+// src/lib/alias.ts
+import { parse as parseShellQuote } from "shell-quote";
+var UNSAFE_ALIAS_PATTERN = /[`$]/;
+function parseAliasArguments(command) {
+  const parsed = parseShellQuote(command);
+  if (parsed.length === 0) {
+    throw new Error("Alias command cannot be empty.");
+  }
+  const hasUnsafeToken = parsed.some((token) => typeof token !== "string");
+  if (hasUnsafeToken) {
+    throw new Error("Alias command contains unsupported shell syntax.");
+  }
+  const args = parsed;
+  const hasSubstitution = args.some((token) => UNSAFE_ALIAS_PATTERN.test(token));
+  if (hasSubstitution) {
+    throw new Error("Alias command contains unsupported substitution syntax.");
+  }
+  return args;
+}
+function isAliasCommandSafe(command) {
+  try {
+    parseAliasArguments(command);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/debug.ts
+import createDebug from "debug";
+function createGranolaDebug(namespace) {
+  return createDebug(`granola:${namespace}`);
+}
+function maskToken(token) {
+  if (!token || token.length < 12) return "[REDACTED]";
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+
+// src/lib/config.ts
+var debug = createGranolaDebug("lib:config");
+var config = new Conf({
+  projectName: "granola",
+  defaults: {}
+});
+debug("config store initialized at: %s", config.path);
+function getConfig() {
+  debug("getConfig: returning store");
+  return config.store;
+}
+function getConfigValue(key) {
+  const value = config.get(key);
+  debug("getConfigValue: %s = %O", key, value);
+  return value;
+}
+function setConfigValue(key, value) {
+  debug("setConfigValue: %s = %O", key, value);
+  config.set(key, value);
+}
+function resetConfig() {
+  debug("resetConfig: clearing all configuration");
+  config.clear();
+}
+function getAlias(name) {
+  const aliases = config.get("aliases") || {};
+  const alias = aliases[name];
+  debug("getAlias: %s -> %s", name, alias || "(not found)");
+  return alias;
+}
+function validateAliasCommand(command) {
+  return isAliasCommandSafe(command);
+}
+function setAlias(name, command) {
+  debug("setAlias: %s -> %s", name, command);
+  if (!validateAliasCommand(command)) {
+    debug("setAlias: invalid command characters");
+    throw new Error(
+      "Alias command contains invalid characters or shell syntax. Only literal arguments are allowed."
+    );
+  }
+  const aliases = config.get("aliases") || {};
+  aliases[name] = command;
+  config.set("aliases", aliases);
+}
+function deleteAlias(name) {
+  debug("deleteAlias: removing %s", name);
+  const aliases = config.get("aliases") || {};
+  delete aliases[name];
+  config.set("aliases", aliases);
+}
+function listAliases() {
+  const aliases = config.get("aliases") || {};
+  debug("listAliases: returning %d aliases", Object.keys(aliases).length);
+  return aliases;
+}
+
+// src/lib/output.ts
+import { encode as toonEncode } from "@toon-format/toon";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { stringify as yamlStringify } from "yaml";
+var debug2 = createGranolaDebug("lib:output");
+function formatOutput(data, format) {
+  debug2("formatOutput: format=%s, dataType=%s", format, typeof data);
+  switch (format) {
+    case "yaml":
+      return yamlStringify(data);
+    case "toon":
+      return toonEncode(data);
+    default:
+      return JSON.stringify(data, null, 2);
+  }
+}
+function table(data, columns) {
+  debug2("table: rendering %d rows, %d columns", data.length, columns.length);
+  const colWidths = columns.map((c) => c.width ?? null);
+  const t = new Table({
+    head: columns.map((c) => chalk.bold(c.header)),
+    colWidths,
+    style: { head: [], border: [] },
+    chars: {
+      top: "",
+      "top-mid": "",
+      "top-left": "",
+      "top-right": "",
+      bottom: "",
+      "bottom-mid": "",
+      "bottom-left": "",
+      "bottom-right": "",
+      left: "",
+      "left-mid": "",
+      mid: "",
+      "mid-mid": "",
+      right: "",
+      "right-mid": "",
+      middle: "  "
+    }
+  });
+  for (const row of data) {
+    t.push(
+      columns.map((c) => {
+        const val = row[c.key];
+        return c.format ? c.format(val) : String(val ?? "");
+      })
+    );
+  }
+  return t.toString();
+}
+function formatDate(iso) {
+  const d = new Date(iso);
+  return d.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function truncate(s, len) {
+  if (s.length <= len) return s;
+  return `${s.slice(0, len - 1)}\u2026`;
+}
+
+// src/commands/alias.ts
+var debug3 = createGranolaDebug("cmd:alias");
+function createAliasCommand() {
+  const cmd = new Command("alias").description("Create command shortcuts");
+  cmd.command("list").description("List aliases").option("-o, --output <format>", "Output format (json, yaml, toon)").action((opts) => {
+    debug3("alias list command invoked");
+    const aliases = listAliases();
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk2.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(aliases, format));
+      return;
+    }
+    if (Object.keys(aliases).length === 0) {
+      console.log(chalk2.dim("No aliases defined."));
+      return;
+    }
+    for (const [name, command] of Object.entries(aliases)) {
+      console.log(`${chalk2.bold(name)}: ${command}`);
+    }
+  });
+  cmd.command("set <name> <command>").description("Create alias").action((name, command) => {
+    debug3("alias set command invoked: %s -> %s", name, command);
+    setAlias(name, command);
+    console.log(chalk2.green(`Created alias: ${name} -> ${command}`));
+  });
+  cmd.command("delete <name>").description("Delete alias").action((name) => {
+    debug3("alias delete command invoked: %s", name);
+    const existing = getAlias(name);
+    if (!existing) {
+      console.log(chalk2.yellow(`Alias '${name}' not found`));
+      return;
+    }
+    deleteAlias(name);
+    console.log(chalk2.green(`Deleted alias: ${name}`));
+  });
+  return cmd;
+}
+var aliasCommand = createAliasCommand();
+
+// src/commands/auth/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/auth/login.ts
+import chalk3 from "chalk";
+import { Command as Command2 } from "commander";
+
+// src/lib/auth.ts
+import { readFile } from "fs/promises";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { deletePassword, getPassword, setPassword } from "cross-keychain";
+var debug4 = createGranolaDebug("lib:auth");
+var SERVICE_NAME = "com.granola.cli";
+var ACCOUNT_NAME = "credentials";
+var DEFAULT_CLIENT_ID = "client_GranolaMac";
+async function getCredentials() {
+  debug4("loading credentials from keychain");
+  try {
+    const stored = await getPassword(SERVICE_NAME, ACCOUNT_NAME);
+    if (!stored) {
+      debug4("no credentials found in keychain");
+      return null;
+    }
+    const parsed = JSON.parse(stored);
+    debug4("credentials loaded, hasAccessToken: %s", Boolean(parsed.accessToken));
+    return {
+      refreshToken: parsed.refreshToken,
+      accessToken: parsed.accessToken || "",
+      clientId: parsed.clientId
+    };
+  } catch (error) {
+    debug4("failed to get credentials: %O", error);
+    return null;
+  }
+}
+async function saveCredentials(creds) {
+  debug4("saving credentials to keychain");
+  await setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(creds));
+  debug4("credentials saved");
+}
+async function deleteCredentials() {
+  debug4("deleting credentials from keychain");
+  await deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+  debug4("credentials deleted");
+}
+var WORKOS_AUTH_URL = "https://api.workos.com/user_management/authenticate";
+async function refreshAccessToken() {
+  debug4("attempting token refresh");
+  const creds = await getCredentials();
+  if (!creds?.refreshToken || !creds?.clientId) {
+    debug4("cannot refresh: missing refreshToken or clientId");
+    return null;
+  }
+  try {
+    const response = await fetch(WORKOS_AUTH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: creds.clientId,
+        grant_type: "refresh_token",
+        refresh_token: creds.refreshToken
+      })
+    });
+    if (!response.ok) {
+      debug4("token refresh failed: %d %s", response.status, response.statusText);
+      return null;
+    }
+    const data = await response.json();
+    const newCreds = {
+      refreshToken: data.refresh_token,
+      accessToken: data.access_token,
+      clientId: creds.clientId
+    };
+    await saveCredentials(newCreds);
+    debug4("token refresh successful, new credentials saved");
+    return newCreds;
+  } catch (error) {
+    debug4("token refresh error: %O", error);
+    return null;
+  }
+}
+function parseSupabaseJson(json) {
+  debug4("parsing supabase.json");
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed.workos_tokens && typeof parsed.workos_tokens === "string") {
+      const workosTokens = JSON.parse(parsed.workos_tokens);
+      if (workosTokens.access_token) {
+        debug4("found WorkOS tokens");
+        return {
+          refreshToken: workosTokens.refresh_token || "",
+          accessToken: workosTokens.access_token,
+          clientId: workosTokens.client_id || DEFAULT_CLIENT_ID
+        };
+      }
+    }
+    if (parsed.cognito_tokens && typeof parsed.cognito_tokens === "string") {
+      const cognitoTokens = JSON.parse(parsed.cognito_tokens);
+      if (!cognitoTokens.refresh_token) return null;
+      debug4("found Cognito tokens");
+      return {
+        refreshToken: cognitoTokens.refresh_token,
+        accessToken: cognitoTokens.access_token || "",
+        clientId: cognitoTokens.client_id || DEFAULT_CLIENT_ID
+      };
+    }
+    if (!parsed.refresh_token) return null;
+    debug4("found legacy token format");
+    return {
+      refreshToken: parsed.refresh_token,
+      accessToken: parsed.access_token || "",
+      clientId: parsed.client_id || DEFAULT_CLIENT_ID
+    };
+  } catch (error) {
+    debug4("failed to parse supabase.json: %O", error);
+    return null;
+  }
+}
+function getDefaultSupabasePath() {
+  const home = homedir();
+  const os2 = platform();
+  let path;
+  switch (os2) {
+    case "darwin":
+      path = join(home, "Library", "Application Support", "Granola", "supabase.json");
+      break;
+    case "win32":
+      path = join(
+        process.env.APPDATA || join(home, "AppData", "Roaming"),
+        "Granola",
+        "supabase.json"
+      );
+      break;
+    default:
+      path = join(home, ".config", "granola", "supabase.json");
+  }
+  debug4("platform: %s, supabase path: %s", os2, path);
+  return path;
+}
+async function loadCredentialsFromFile() {
+  const path = getDefaultSupabasePath();
+  debug4("loading credentials from file: %s", path);
+  try {
+    const content = await readFile(path, "utf-8");
+    debug4("file read successful, parsing content");
+    return parseSupabaseJson(content);
+  } catch (error) {
+    debug4("failed to load credentials from file: %O", error);
+    return null;
+  }
+}
+
+// src/commands/auth/login.ts
+var debug5 = createGranolaDebug("cmd:auth:login");
+function createLoginCommand() {
+  return new Command2("login").description("Import credentials from Granola desktop app").action(async () => {
+    debug5("login command invoked");
+    const creds = await loadCredentialsFromFile();
+    if (!creds) {
+      const path = getDefaultSupabasePath();
+      debug5("login failed: could not load credentials from %s", path);
+      console.error(chalk3.red("Error:"), "Could not load credentials.");
+      console.error(`Expected file at: ${chalk3.dim(path)}`);
+      console.error("\nMake sure the Granola desktop app is installed and you are logged in.");
+      process.exit(1);
+    }
+    debug5("credentials loaded, saving to keychain");
+    await saveCredentials(creds);
+    debug5("login successful");
+    console.log(chalk3.green("Credentials imported successfully"));
+  });
+}
+var loginCommand = createLoginCommand();
+
+// src/commands/auth/logout.ts
+import chalk4 from "chalk";
+import { Command as Command3 } from "commander";
+var debug6 = createGranolaDebug("cmd:auth:logout");
+function createLogoutCommand() {
+  return new Command3("logout").description("Logout from Granola").action(async () => {
+    debug6("logout command invoked");
+    try {
+      await deleteCredentials();
+      debug6("logout successful");
+      console.log(chalk4.green("Logged out successfully"));
+    } catch (error) {
+      debug6("logout failed: %O", error);
+      console.error(chalk4.red("Error:"), "Failed to logout.");
+      if (error instanceof Error) {
+        console.error(chalk4.dim(error.message));
+      }
+      process.exit(1);
+    }
+  });
+}
+var logoutCommand = createLogoutCommand();
+
+// src/commands/auth/status.ts
+import chalk5 from "chalk";
+import { Command as Command4 } from "commander";
+var debug7 = createGranolaDebug("cmd:auth:status");
+function createStatusCommand() {
+  return new Command4("status").description("Check authentication status").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (opts) => {
+    debug7("status command invoked");
+    const creds = await getCredentials();
+    debug7("authenticated: %s", !!creds);
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk5.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput({ authenticated: !!creds }, format));
+      return;
+    }
+    if (creds) {
+      console.log(chalk5.green("Authenticated"));
+    } else {
+      console.log(chalk5.yellow("Not authenticated"));
+      console.log(chalk5.dim("Run: granola auth login"));
+    }
+  });
+}
+var statusCommand = createStatusCommand();
+
+// src/commands/auth/index.ts
+var authCommand = new Command5("auth").description("Manage authentication").addCommand(loginCommand).addCommand(logoutCommand).addCommand(statusCommand);
+
+// src/commands/config.ts
+import chalk6 from "chalk";
+import { Command as Command6 } from "commander";
+var debug8 = createGranolaDebug("cmd:config");
+var CONFIG_VALUE_PARSERS = {
+  default_workspace: (value) => value,
+  pager: (value) => value,
+  aliases: (value) => {
+    try {
+      const parsed = JSON.parse(value);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error('Aliases must be a JSON object of { "name": "command" } pairs.');
+      }
+      for (const [alias, command] of Object.entries(parsed)) {
+        if (typeof command !== "string") {
+          throw new Error(`Alias "${alias}" must map to a string command.`);
+        }
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error('Aliases must be valid JSON (example: {"meetings":"meeting list"}).');
+      }
+      throw error;
+    }
+  }
+};
+var CONFIG_KEYS = Object.keys(CONFIG_VALUE_PARSERS);
+function isConfigKey(key) {
+  return CONFIG_KEYS.includes(key);
+}
+function createConfigCommand() {
+  const cmd = new Command6("config").description("Manage CLI configuration");
+  cmd.command("list").description("View current config").option("-o, --output <format>", "Output format (json, yaml, toon)").action((opts) => {
+    debug8("config list command invoked");
+    const config2 = getConfig();
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk6.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(config2, format));
+      return;
+    }
+    if (Object.keys(config2).length === 0) {
+      console.log(chalk6.dim("No configuration set."));
+      return;
+    }
+    for (const [key, value] of Object.entries(config2)) {
+      if (typeof value === "object") {
+        console.log(`${chalk6.bold(key)}:`);
+        for (const [k, v] of Object.entries(value)) {
+          console.log(`  ${k}: ${v}`);
+        }
+      } else {
+        console.log(`${chalk6.bold(key)}: ${value}`);
+      }
+    }
+  });
+  cmd.command("get <key>").description("Get a config value").option("-o, --output <format>", "Output format (json, yaml, toon)").action((key, opts) => {
+    debug8("config get command invoked with key: %s", key);
+    const value = getConfigValue(key);
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk6.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput({ [key]: value }, format));
+      return;
+    }
+    if (value === void 0) {
+      console.log(chalk6.dim("(not set)"));
+    } else {
+      console.log(value);
+    }
+  });
+  cmd.command("set <key> <value>").description("Set a config value").action((key, value) => {
+    debug8("config set command invoked: %s = %s", key, value);
+    if (!isConfigKey(key)) {
+      console.error(
+        chalk6.red(
+          `Invalid config key: ${key}. Allowed keys: ${CONFIG_KEYS.map((k) => `'${k}'`).join(", ")}.`
+        )
+      );
+      process.exit(1);
+    }
+    const parser = CONFIG_VALUE_PARSERS[key];
+    let parsedValue;
+    try {
+      parsedValue = parser(value);
+    } catch (error) {
+      console.error(chalk6.red("Invalid value for config key:"), key);
+      if (error instanceof Error) {
+        console.error(chalk6.dim(error.message));
+      }
+      process.exit(1);
+    }
+    setConfigValue(key, parsedValue);
+    console.log(chalk6.green(`Set ${key} = ${value}`));
+  });
+  cmd.command("reset").description("Reset to defaults").action(() => {
+    debug8("config reset command invoked");
+    resetConfig();
+    console.log(chalk6.green("Configuration reset"));
+  });
+  return cmd;
+}
+var configCommand = createConfigCommand();
+
+// src/commands/folder/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/folder/list.ts
+import chalk8 from "chalk";
+import { Command as Command7 } from "commander";
+
+// src/services/client.ts
+import chalk7 from "chalk";
+
+// src/lib/api.ts
+function createApiClient(httpClient) {
+  async function getDocuments(options = {}) {
+    const body = {
+      include_last_viewed_panel: options.include_last_viewed_panel ?? false
+    };
+    if (options.workspace_id) body.workspace_id = options.workspace_id;
+    if (options.limit !== void 0) body.limit = options.limit;
+    if (options.offset !== void 0) body.offset = options.offset;
+    if (options.cursor) body.cursor = options.cursor;
+    return httpClient.post("/v2/get-documents", body);
+  }
+  async function getDocumentsBatch(options) {
+    return httpClient.post("/v1/get-documents-batch", {
+      document_ids: options.document_ids,
+      include_last_viewed_panel: options.include_last_viewed_panel ?? false
+    });
+  }
+  async function getDocumentMetadata(documentId) {
+    return httpClient.post("/v1/get-document-metadata", {
+      document_id: documentId
+    });
+  }
+  async function getDocumentTranscript(documentId) {
+    return httpClient.post("/v1/get-document-transcript", {
+      document_id: documentId
+    });
+  }
+  async function getDocumentLists() {
+    return httpClient.post("/v2/get-document-lists", {});
+  }
+  async function getDocumentList(folderId) {
+    const folders = await getDocumentLists();
+    return folders.find((f) => f.id === folderId) || null;
+  }
+  async function getWorkspaces() {
+    return httpClient.post("/v1/get-workspaces", {});
+  }
+  function setToken(token) {
+    httpClient.setToken(token);
+  }
+  return {
+    getDocuments,
+    getDocumentsBatch,
+    getDocumentMetadata,
+    getDocumentTranscript,
+    getDocumentLists,
+    getDocumentList,
+    getWorkspaces,
+    setToken
+  };
+}
+
+// src/lib/http.ts
+import { readFileSync } from "fs";
+import os from "os";
+import process2 from "process";
+function getPackageVersion() {
+  for (const path of ["../package.json", "../../package.json"]) {
+    try {
+      const pkg = JSON.parse(readFileSync(new URL(path, import.meta.url), "utf-8"));
+      return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var version = getPackageVersion();
+var BASE_URL = "https://api.granola.ai";
+var APP_VERSION = "7.0.0";
+function buildUserAgent() {
+  const platform2 = process2.platform === "darwin" ? "macOS" : process2.platform;
+  const osRelease = os.release();
+  return `Granola/${APP_VERSION} granola-cli/${version} (${platform2} ${osRelease})`;
+}
+function getClientHeaders() {
+  return {
+    "X-App-Version": APP_VERSION,
+    "X-Client-Version": APP_VERSION,
+    "X-Client-Type": "cli",
+    "X-Client-Platform": process2.platform,
+    "X-Client-Architecture": process2.arch,
+    "X-Client-Id": `granola-cli-${version}`,
+    "User-Agent": buildUserAgent()
+  };
+}
+var RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelay: 250,
+  retryableStatuses: [429, 500, 502, 503, 504]
+};
+var ApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+function isRetryable(status) {
+  return RETRY_CONFIG.retryableStatuses.includes(status);
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createHttpClient(token) {
+  let currentToken = token;
+  async function post(endpoint, body = {}) {
+    let lastError = null;
+    const maxAttempts = RETRY_CONFIG.maxRetries + 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const response = await fetch(`${BASE_URL}${endpoint}`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${currentToken}`,
+            "Content-Type": "application/json",
+            ...getClientHeaders()
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const responseBody = await response.json().catch(() => ({}));
+          if (isRetryable(response.status) && attempt < maxAttempts - 1) {
+            const delay = RETRY_CONFIG.baseDelay * 2 ** attempt;
+            await sleep(delay);
+            continue;
+          }
+          throw new ApiError(
+            `HTTP ${response.status}: ${response.statusText}`,
+            response.status,
+            responseBody
+          );
+        }
+        return await response.json();
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw error;
+        }
+        lastError = error;
+        if (attempt < maxAttempts - 1) {
+          const delay = RETRY_CONFIG.baseDelay * 2 ** attempt;
+          await sleep(delay);
+        }
+      }
+    }
+    throw lastError;
+  }
+  function setToken(newToken) {
+    currentToken = newToken;
+  }
+  return { post, setToken };
+}
+
+// src/services/client.ts
+var debug9 = createGranolaDebug("service:client");
+var client = null;
+async function getClient() {
+  debug9("getClient called, cached: %s", client ? "yes" : "no");
+  if (client) return client;
+  debug9("fetching credentials");
+  const creds = await getCredentials();
+  if (!creds) {
+    debug9("no credentials found, exiting");
+    console.error(chalk7.red("Error:"), "Not authenticated.");
+    console.error(`Run ${chalk7.cyan("granola auth login")} to authenticate.`);
+    process.exit(2);
+  }
+  debug9("creating API client, token: %s", maskToken(creds.accessToken));
+  const httpClient = createHttpClient(creds.accessToken);
+  client = createApiClient(httpClient);
+  return client;
+}
+function resetClient() {
+  debug9("client reset");
+  client = null;
+}
+function isUnauthorizedError(error) {
+  if (error && typeof error === "object") {
+    const e = error;
+    return e.status === 401;
+  }
+  return false;
+}
+async function withTokenRefresh(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (isUnauthorizedError(error)) {
+      debug9("401 detected, attempting token refresh");
+      const newCreds = await refreshAccessToken();
+      if (!newCreds) {
+        debug9("token refresh failed, re-throwing original error");
+        throw error;
+      }
+      resetClient();
+      debug9("retrying operation with refreshed token");
+      return operation();
+    }
+    throw error;
+  }
+}
+
+// src/services/folders.ts
+var debug10 = createGranolaDebug("service:folders");
+function normalizeFolder(folder) {
+  const documentIdsFromDocs = Array.isArray(folder.documents) ? folder.documents.map((doc) => doc?.id).filter((id) => Boolean(id)) : void 0;
+  const documentIds = Array.isArray(folder.document_ids) && folder.document_ids.length > 0 ? folder.document_ids : documentIdsFromDocs;
+  return {
+    id: folder.id,
+    name: folder.name ?? folder.title,
+    title: folder.title ?? folder.name ?? "Untitled",
+    created_at: folder.created_at,
+    workspace_id: folder.workspace_id,
+    owner_id: folder.owner_id,
+    document_ids: documentIds ?? [],
+    is_favourite: folder.is_favourite
+  };
+}
+async function list(opts = {}) {
+  return withTokenRefresh(async () => {
+    const client2 = await getClient();
+    const documentLists = await client2.getDocumentLists();
+    const folders = documentLists.map(normalizeFolder);
+    debug10("list fetched %d folders", folders.length);
+    if (opts.workspace) {
+      const filtered = folders.filter((folder) => folder.workspace_id === opts.workspace);
+      debug10("filtered to %d folders for workspace %s", filtered.length, opts.workspace);
+      return filtered;
+    }
+    return folders;
+  });
+}
+async function get(id) {
+  return withTokenRefresh(async () => {
+    debug10("get called for folder: %s", id);
+    const client2 = await getClient();
+    const documentLists = await client2.getDocumentLists();
+    const folder = documentLists.find((f) => f.id === id);
+    if (!folder) {
+      debug10("folder %s not found", id);
+      return null;
+    }
+    debug10("folder %s found", id);
+    return normalizeFolder(folder);
+  });
+}
+
+// src/commands/folder/list.ts
+var debug11 = createGranolaDebug("cmd:folder:list");
+function createListCommand() {
+  return new Command7("list").description("List folders").option("-w, --workspace <id>", "Filter by workspace").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (opts) => {
+    debug11("folder list command invoked with opts: %O", opts);
+    let data;
+    try {
+      data = await list({
+        workspace: opts.workspace
+      });
+      debug11("fetched %d folders", data.length);
+    } catch (error) {
+      console.error(chalk8.red("Error:"), "Failed to list folders.");
+      if (error instanceof Error) {
+        console.error(chalk8.dim(error.message));
+      }
+      process.exit(1);
+    }
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk8.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(data, format));
+      return;
+    }
+    if (data.length === 0) {
+      console.log(chalk8.dim("No folders found."));
+      return;
+    }
+    const rows = data.map((folder) => ({
+      ...folder,
+      display_name: folder.name || folder.title || "Unnamed"
+    }));
+    const output = table(rows, [
+      { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 8) },
+      { key: "display_name", header: "NAME", width: 20, format: (v) => String(v || "") },
+      {
+        key: "workspace_id",
+        header: "WORKSPACE",
+        width: 12,
+        format: (v) => String(v).slice(0, 8)
+      }
+    ]);
+    console.log(output);
+  });
+}
+var listCommand = createListCommand();
+
+// src/commands/folder/view.ts
+import chalk9 from "chalk";
+import { Command as Command8 } from "commander";
+var debug12 = createGranolaDebug("cmd:folder:view");
+function createViewCommand() {
+  return new Command8("view").description("View folder details").argument("<id>", "Folder ID").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (id, opts) => {
+    debug12("folder view command invoked with id: %s", id);
+    let folder;
+    try {
+      folder = await get(id);
+    } catch (error) {
+      console.error(chalk9.red("Error:"), "Failed to load folder.");
+      if (error instanceof Error) {
+        console.error(chalk9.dim(error.message));
+      }
+      process.exit(1);
+    }
+    if (!folder) {
+      console.error(chalk9.red(`Folder ${id} not found`));
+      process.exit(4);
+    }
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk9.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(folder, format));
+      return;
+    }
+    const name = folder.name || folder.title || "Unnamed";
+    const docCount = folder.document_ids?.length || 0;
+    console.log(chalk9.bold(name));
+    console.log(chalk9.dim(`${docCount} meetings \xB7 Workspace ${folder.workspace_id}`));
+    console.log();
+    console.log(chalk9.dim('Tip: Use "granola meeting list" to browse recent meetings.'));
+  });
+}
+var viewCommand = createViewCommand();
+
+// src/commands/folder/index.ts
+var folderCommand = new Command9("folder").description("Work with folders").addCommand(listCommand).addCommand(viewCommand);
+
+// src/commands/meeting/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/meeting/enhanced.ts
+import chalk10 from "chalk";
+import { Command as Command10 } from "commander";
+
+// src/lib/pager.ts
+import { spawn } from "child_process";
+var debug13 = createGranolaDebug("lib:pager");
+var ALLOWED_PAGERS = ["less", "more", "cat", "head", "tail", "bat", "most"];
+var SHELL_METACHARACTERS = /[;&|`$(){}[\]<>\\!#*?]/;
+function validatePagerCommand(cmd) {
+  debug13("validating pager command: %s", cmd);
+  if (SHELL_METACHARACTERS.test(cmd)) {
+    debug13("pager validation failed: contains shell metacharacters");
+    return false;
+  }
+  const [binary] = cmd.split(" ");
+  const binaryName = binary.split("/").pop() || "";
+  const valid = ALLOWED_PAGERS.includes(binaryName);
+  debug13("pager validation: %s (binary: %s)", valid ? "passed" : "failed", binaryName);
+  return valid;
+}
+function getPagerCommand() {
+  if (process.env.GRANOLA_PAGER) {
+    debug13("pager command: %s (source: GRANOLA_PAGER)", process.env.GRANOLA_PAGER);
+    return process.env.GRANOLA_PAGER;
+  }
+  if (process.env.PAGER) {
+    debug13("pager command: %s (source: PAGER)", process.env.PAGER);
+    return process.env.PAGER;
+  }
+  const configuredPager = getConfigValue("pager");
+  if (configuredPager) {
+    debug13("pager command: %s (source: config)", configuredPager);
+    return configuredPager;
+  }
+  debug13("pager command: less -R (source: default)");
+  return "less -R";
+}
+async function pipeToPager(content) {
+  debug13("pipeToPager: isTTY=%s, contentLength=%d", process.stdout.isTTY, content.length);
+  if (!process.stdout.isTTY) {
+    debug13("not a TTY, writing directly to stdout");
+    process.stdout.write(`${content}
+`);
+    return;
+  }
+  const pagerCmd = getPagerCommand();
+  if (!validatePagerCommand(pagerCmd)) {
+    console.error(`Warning: Invalid pager command "${pagerCmd}". Falling back to direct output.`);
+    process.stdout.write(`${content}
+`);
+    return;
+  }
+  const [cmd, ...args] = pagerCmd.split(" ");
+  debug13("spawning pager: %s with args: %O", cmd, args);
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (!settled) {
+        settled = true;
+        resolve();
+      }
+    };
+    const fallbackToStdout = (reason) => {
+      if (settled) return;
+      settled = true;
+      debug13("falling back to stdout: %s", reason);
+      console.error(
+        `Warning: Unable to launch pager "${pagerCmd}" (${reason}). Falling back to direct output.`
+      );
+      process.stdout.write(`${content}
+`);
+      resolve();
+    };
+    try {
+      const pager = spawn(cmd, args, {
+        stdio: ["pipe", "inherit", "inherit"]
+      });
+      pager.stdin.write(content);
+      pager.stdin.end();
+      pager.on("close", () => {
+        debug13("pager closed");
+        finish();
+      });
+      pager.on("error", (err) => {
+        debug13("pager error: %O", err);
+        fallbackToStdout(err.message);
+      });
+    } catch (err) {
+      debug13("failed to spawn pager: %O", err);
+      fallbackToStdout(err.message);
+    }
+  });
+}
+
+// src/lib/prosemirror.ts
+var debug14 = createGranolaDebug("lib:prosemirror");
+function toMarkdown(doc) {
+  debug14("toMarkdown called with doc: %O", doc);
+  if (!doc?.content) {
+    debug14("No content in doc, returning empty string");
+    return "";
+  }
+  const result = doc.content.map((n) => nodeToMd(n)).join("\n\n");
+  debug14("toMarkdown result: %s", result);
+  return result;
+}
+function nodeToMd(node) {
+  debug14("nodeToMd processing node type: %s, node: %O", node.type, node);
+  let result;
+  switch (node.type) {
+    case "heading": {
+      const lvl = node.attrs?.level || 1;
+      result = `${"#".repeat(lvl)} ${inlineToMd(node.content)}`;
+      break;
+    }
+    case "paragraph":
+      result = inlineToMd(node.content);
+      break;
+    case "bulletList":
+      result = (node.content || []).map((li) => nodeToMd(li)).join("\n");
+      break;
+    case "orderedList":
+      result = (node.content || []).map((li, i) => nodeToMd(li).replace(/^- /, `${i + 1}. `)).join("\n");
+      break;
+    case "listItem":
+      result = `- ${(node.content || []).map((c) => nodeToMd(c)).join("\n  ")}`;
+      break;
+    case "blockquote":
+      result = (node.content || []).map((c) => `> ${nodeToMd(c)}`).join("\n");
+      break;
+    case "codeBlock": {
+      const lang = node.attrs?.language || "";
+      result = `\`\`\`${lang}
+${inlineToMd(node.content)}
+\`\`\``;
+      break;
+    }
+    case "horizontalRule":
+      result = "---";
+      break;
+    case "text":
+      result = applyMarks(node.text || "", node.marks);
+      break;
+    default:
+      debug14("Unknown node type: %s", node.type);
+      result = node.content ? node.content.map((c) => nodeToMd(c)).join("") : "";
+  }
+  debug14("nodeToMd result for %s: %s", node.type, result);
+  return result;
+}
+function inlineToMd(content) {
+  return content ? content.map((n) => nodeToMd(n)).join("") : "";
+}
+function applyMarks(text, marks) {
+  if (!marks) return text;
+  for (const m of marks) {
+    if (m.type === "bold" || m.type === "strong") text = `**${text}**`;
+    if (m.type === "italic" || m.type === "em") text = `*${text}*`;
+    if (m.type === "code") text = `\`${text}\``;
+    if (m.type === "strike") text = `~~${text}~~`;
+  }
+  return text;
+}
+
+// src/services/meetings.ts
+var debug15 = createGranolaDebug("service:meetings");
+async function getFolderDocumentIds(client2, folderId) {
+  debug15("fetching folder %s via getDocumentList", folderId);
+  const folder = await client2.getDocumentList(folderId);
+  if (!folder) {
+    debug15("folder %s not found", folderId);
+    return [];
+  }
+  const ids = folder.document_ids || folder.documents?.map((doc) => doc.id) || [];
+  debug15("folder %s returned %d document ids", folderId, ids.length);
+  return ids;
+}
+var DOCUMENT_BATCH_SIZE = 100;
+var NOTES_PAGE_SIZE = 50;
+var MAX_NOTES_PAGES = 100;
+async function fetchMeetingsByIds(client2, documentIds) {
+  if (documentIds.length === 0) return [];
+  const meetings = [];
+  for (let i = 0; i < documentIds.length; i += DOCUMENT_BATCH_SIZE) {
+    const chunk = documentIds.slice(i, i + DOCUMENT_BATCH_SIZE);
+    const res = await client2.getDocumentsBatch({
+      document_ids: chunk,
+      include_last_viewed_panel: false
+    });
+    const docs = res?.documents || res?.docs || [];
+    meetings.push(...docs);
+  }
+  debug15("fetched %d meetings via getDocumentsBatch", meetings.length);
+  return meetings;
+}
+async function loadMeetingMetadata(client2, id) {
+  try {
+    const metadata = await client2.getDocumentMetadata(id);
+    if (!metadata) {
+      debug15("getDocumentMetadata returned null for %s", id);
+      return null;
+    }
+    return metadata;
+  } catch (err) {
+    debug15("getDocumentMetadata failed for %s: %O", id, err);
+    return null;
+  }
+}
+async function fetchFolderMeetings(client2, folderId) {
+  const ids = await getFolderDocumentIds(client2, folderId);
+  if (ids.length === 0) {
+    debug15("folder %s has no documents", folderId);
+    return [];
+  }
+  return fetchMeetingsByIds(client2, ids);
+}
+async function list2(opts = {}) {
+  return withTokenRefresh(async () => {
+    debug15("list called with opts: %O", opts);
+    const client2 = await getClient();
+    const { limit = 20, offset = 0, workspace, folder } = opts;
+    if (folder) {
+      debug15("listing meetings for folder: %s", folder);
+      const folderMeetings = await fetchFolderMeetings(client2, folder);
+      debug15("fetched %d meetings for folder %s", folderMeetings.length, folder);
+      let filtered = folderMeetings;
+      if (workspace) {
+        filtered = folderMeetings.filter((m) => m.workspace_id === workspace);
+        debug15(
+          "workspace filter applied for folder %s: %d meetings remain",
+          folder,
+          filtered.length
+        );
+      }
+      const paginated = filtered.slice(offset, offset + limit);
+      debug15("returning %d meetings from folder %s after pagination", paginated.length, folder);
+      return paginated;
+    }
+    const res = await client2.getDocuments({
+      limit,
+      offset,
+      include_last_viewed_panel: false
+    });
+    let meetings = res?.docs || [];
+    debug15("fetched %d meetings", meetings.length);
+    if (workspace) {
+      meetings = meetings.filter((m) => m.workspace_id === workspace);
+      debug15("filtered to %d meetings for workspace: %s", meetings.length, workspace);
+    }
+    return meetings;
+  });
+}
+var RESOLVE_PAGE_SIZE = 100;
+var MAX_RESOLVE_PAGES = 100;
+async function resolveId(partialId) {
+  return withTokenRefresh(async () => {
+    debug15("resolving meeting id: %s", partialId);
+    const client2 = await getClient();
+    const matches = /* @__PURE__ */ new Set();
+    let offset = 0;
+    for (let page = 0; page < MAX_RESOLVE_PAGES; page += 1) {
+      const res = await client2.getDocuments({
+        limit: RESOLVE_PAGE_SIZE,
+        offset,
+        include_last_viewed_panel: false
+      });
+      const meetings = res?.docs || [];
+      debug15(
+        "resolveId page %d (offset %d) returned %d meetings",
+        page + 1,
+        offset,
+        meetings.length
+      );
+      for (const meeting of meetings) {
+        if (meeting.id?.startsWith(partialId)) {
+          matches.add(meeting.id);
+          if (matches.size > 1) {
+            debug15("ambiguous id: %s matches >1 meetings", partialId);
+            throw new Error(`Ambiguous ID: ${partialId} matches ${matches.size} meetings`);
+          }
+        }
+      }
+      if (meetings.length < RESOLVE_PAGE_SIZE) {
+        break;
+      }
+      offset += RESOLVE_PAGE_SIZE;
+    }
+    if (matches.size === 0) {
+      debug15("no meeting found for id: %s", partialId);
+      return null;
+    }
+    const match = matches.values().next().value;
+    debug15("resolved meeting: %s -> %s", partialId, match);
+    return match;
+  });
+}
+async function get2(id) {
+  return withTokenRefresh(async () => {
+    debug15("getting meeting: %s", id);
+    const client2 = await getClient();
+    const metadata = await loadMeetingMetadata(client2, id);
+    if (!metadata) {
+      debug15("meeting %s: not found", id);
+      return null;
+    }
+    debug15("meeting %s: found", id);
+    return { id, ...metadata };
+  });
+}
+async function findMeetingViaDocuments(client2, id, { includeLastViewedPanel }) {
+  let offset = 0;
+  for (let page = 0; page < MAX_NOTES_PAGES; page += 1) {
+    try {
+      debug15("findMeetingViaDocuments fetching page %d (offset: %d)", page, offset);
+      const res = await client2.getDocuments({
+        limit: NOTES_PAGE_SIZE,
+        offset,
+        include_last_viewed_panel: includeLastViewedPanel
+      });
+      const meetings = res?.docs || [];
+      debug15("findMeetingViaDocuments got %d meetings on page %d", meetings.length, page);
+      if (meetings.length === 0) break;
+      const meeting = meetings.find((m) => m.id === id);
+      if (meeting) {
+        debug15("findMeetingViaDocuments located meeting %s on page %d", id, page);
+        return meeting;
+      }
+      offset += NOTES_PAGE_SIZE;
+    } catch (err) {
+      debug15("findMeetingViaDocuments error: %O", err);
+      return null;
+    }
+  }
+  debug15("findMeetingViaDocuments did not locate meeting %s", id);
+  return null;
+}
+async function getNotes(id) {
+  return withTokenRefresh(async () => {
+    debug15("getNotes called with id: %s", id);
+    const client2 = await getClient();
+    const metadata = await loadMeetingMetadata(client2, id);
+    if (metadata && "notes" in metadata) {
+      debug15("getNotes resolved via metadata response");
+      return metadata.notes || null;
+    }
+    const meeting = await findMeetingViaDocuments(client2, id, {
+      includeLastViewedPanel: false
+    });
+    if (meeting) {
+      return meeting.notes || null;
+    }
+    return null;
+  });
+}
+async function getEnhancedNotes(id) {
+  return withTokenRefresh(async () => {
+    debug15("getEnhancedNotes called with id: %s", id);
+    const client2 = await getClient();
+    const metadata = await loadMeetingMetadata(client2, id);
+    if (metadata && "last_viewed_panel" in metadata) {
+      debug15("getEnhancedNotes resolved via metadata response");
+      return metadata.last_viewed_panel?.content || null;
+    }
+    const meeting = await findMeetingViaDocuments(client2, id, {
+      includeLastViewedPanel: true
+    });
+    if (meeting) {
+      return meeting.last_viewed_panel?.content || null;
+    }
+    return null;
+  });
+}
+async function getTranscript(id) {
+  return withTokenRefresh(async () => {
+    debug15("getTranscript called with id: %s", id);
+    const client2 = await getClient();
+    try {
+      const transcript = await client2.getDocumentTranscript(id);
+      debug15("getTranscript got %d utterances", transcript.length);
+      return transcript;
+    } catch (err) {
+      debug15("getTranscript error: %O", err);
+      return [];
+    }
+  });
+}
+
+// src/commands/meeting/enhanced.ts
+var debug16 = createGranolaDebug("cmd:meeting:enhanced");
+function createEnhancedCommand() {
+  return new Command10("enhanced").description("View AI-enhanced meeting notes").argument("<id>", "Meeting ID").option("-o, --output <format>", "Output format (markdown, json, yaml, toon)", "markdown").action(async (id, opts, cmd) => {
+    debug16("enhanced command invoked with id: %s", id);
+    const global = cmd.optsWithGlobals();
+    let fullId;
+    try {
+      const resolved = await resolveId(id);
+      if (!resolved) {
+        console.error(chalk10.red(`Meeting ${id} not found`));
+        process.exit(4);
+      }
+      fullId = resolved;
+    } catch (err) {
+      console.error(chalk10.red(err.message));
+      process.exit(1);
+    }
+    let notes;
+    try {
+      notes = await getEnhancedNotes(fullId);
+    } catch (error) {
+      debug16("failed to load enhanced notes: %O", error);
+      console.error(chalk10.red("Error:"), "Failed to fetch enhanced notes.");
+      if (error instanceof Error) {
+        console.error(chalk10.dim(error.message));
+      }
+      process.exit(1);
+    }
+    if (!notes) {
+      console.error(chalk10.red(`No enhanced notes found for meeting ${id}`));
+      process.exit(4);
+    }
+    const format = opts.output || "markdown";
+    const structuredFormats = ["json", "yaml", "toon"];
+    if (format !== "markdown" && !structuredFormats.includes(format)) {
+      console.error(
+        chalk10.red(`Invalid format: ${format}. Use 'markdown', 'json', 'yaml', or 'toon'.`)
+      );
+      process.exit(1);
+    }
+    if (structuredFormats.includes(format)) {
+      console.log(formatOutput(notes, format));
+      return;
+    }
+    const md = toMarkdown(notes);
+    if (global.noPager || !process.stdout.isTTY) {
+      console.log(md);
+    } else {
+      await pipeToPager(md);
+    }
+  });
+}
+var enhancedCommand = createEnhancedCommand();
+
+// src/commands/meeting/export.ts
+import chalk11 from "chalk";
+import { Command as Command11 } from "commander";
+
+// src/lib/toon.ts
+import { encode } from "@toon-format/toon";
+function toToon(data) {
+  return encode(data);
+}
+
+// src/commands/meeting/export.ts
+var debug17 = createGranolaDebug("cmd:meeting:export");
+function createExportCommand() {
+  return new Command11("export").description("Export meeting data").argument("<id>", "Meeting ID").option("-f, --format <format>", "Output format (json, toon)", "json").action(async (id, options) => {
+    debug17("export command invoked with id: %s, format: %s", id, options.format);
+    const format = options.format;
+    if (format !== "json" && format !== "toon") {
+      console.error(chalk11.red(`Invalid format: ${options.format}. Use 'json' or 'toon'.`));
+      process.exit(1);
+    }
+    let fullId;
+    try {
+      const resolved = await resolveId(id);
+      if (!resolved) {
+        console.error(chalk11.red(`Meeting ${id} not found`));
+        process.exit(4);
+      }
+      fullId = resolved;
+    } catch (err) {
+      console.error(chalk11.red(err.message));
+      process.exit(1);
+    }
+    const [meeting, notes, transcript] = await Promise.all([
+      get2(fullId),
+      getNotes(fullId),
+      getTranscript(fullId)
+    ]);
+    if (!meeting) {
+      console.error(chalk11.red(`Meeting ${id} not found`));
+      process.exit(4);
+    }
+    const output = {
+      id: meeting.id,
+      title: meeting.title,
+      created_at: meeting.created_at,
+      updated_at: meeting.updated_at,
+      workspace_id: meeting.workspace_id,
+      people: meeting.people,
+      notes_markdown: notes ? toMarkdown(notes) : null,
+      notes_raw: notes,
+      transcript
+    };
+    if (format === "toon") {
+      console.log(toToon(output));
+    } else {
+      console.log(JSON.stringify(output, null, 2));
+    }
+  });
+}
+var exportCommand = createExportCommand();
+
+// src/commands/meeting/list.ts
+import chalk12 from "chalk";
+import { Command as Command12 } from "commander";
+var debug18 = createGranolaDebug("cmd:meeting:list");
+function createListCommand2() {
+  return new Command12("list").description("List meetings").option("-l, --limit <n>", "Number of meetings", "20").option("-w, --workspace <id>", "Filter by workspace").option("-f, --folder <id>", "Filter by folder").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (opts) => {
+    debug18("list command invoked with opts: %O", opts);
+    const limit = Number.parseInt(opts.limit, 10);
+    if (!Number.isFinite(limit) || limit < 1) {
+      console.error(chalk12.red("Invalid --limit value. Please provide a positive number."));
+      process.exit(1);
+    }
+    const configuredWorkspace = getConfigValue("default_workspace");
+    const workspace = opts.workspace ?? configuredWorkspace;
+    const data = await list2({
+      limit,
+      workspace,
+      folder: opts.folder
+    });
+    debug18("fetched %d meetings", data.length);
+    const format = opts.output || null;
+    debug18("output format: %s", format || "table");
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk12.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(data, format));
+      return;
+    }
+    if (data.length === 0) {
+      console.log(chalk12.dim("No meetings found."));
+      return;
+    }
+    console.log(chalk12.dim(`Showing ${data.length} meetings
+`));
+    const output = table(data, [
+      { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 8) },
+      { key: "title", header: "TITLE", width: 36, format: (v) => truncate(String(v), 35) },
+      { key: "created_at", header: "DATE", width: 14, format: (v) => formatDate(String(v)) }
+    ]);
+    console.log(output);
+  });
+}
+var listCommand2 = createListCommand2();
+
+// src/commands/meeting/notes.ts
+import chalk13 from "chalk";
+import { Command as Command13 } from "commander";
+var debug19 = createGranolaDebug("cmd:meeting:notes");
+function createNotesCommand() {
+  return new Command13("notes").description("View meeting notes").argument("<id>", "Meeting ID").option("-o, --output <format>", "Output format (markdown, json, yaml, toon)", "markdown").action(async (id, opts, cmd) => {
+    debug19("notes command invoked with id: %s", id);
+    const global = cmd.optsWithGlobals();
+    let fullId;
+    try {
+      const resolved = await resolveId(id);
+      if (!resolved) {
+        console.error(chalk13.red(`Meeting ${id} not found`));
+        process.exit(4);
+      }
+      fullId = resolved;
+    } catch (err) {
+      console.error(chalk13.red(err.message));
+      process.exit(1);
+    }
+    let notes;
+    try {
+      notes = await getNotes(fullId);
+    } catch (error) {
+      debug19("failed to load notes: %O", error);
+      console.error(chalk13.red("Error:"), "Failed to fetch notes.");
+      if (error instanceof Error) {
+        console.error(chalk13.dim(error.message));
+      }
+      process.exit(1);
+    }
+    if (!notes) {
+      console.error(chalk13.red(`No notes found for meeting ${id}`));
+      process.exit(4);
+    }
+    const format = opts.output || "markdown";
+    const structuredFormats = ["json", "yaml", "toon"];
+    if (format !== "markdown" && !structuredFormats.includes(format)) {
+      console.error(
+        chalk13.red(`Invalid format: ${format}. Use 'markdown', 'json', 'yaml', or 'toon'.`)
+      );
+      process.exit(1);
+    }
+    if (structuredFormats.includes(format)) {
+      console.log(formatOutput(notes, format));
+      return;
+    }
+    const md = toMarkdown(notes);
+    if (global.noPager || !process.stdout.isTTY) {
+      console.log(md);
+    } else {
+      await pipeToPager(md);
+    }
+  });
+}
+var notesCommand = createNotesCommand();
+
+// src/commands/meeting/transcript.ts
+import chalk14 from "chalk";
+import { Command as Command14 } from "commander";
+
+// src/lib/transcript.ts
+var debug20 = createGranolaDebug("lib:transcript");
+function formatTranscript(utterances, opts = {}) {
+  debug20("formatTranscript: %d utterances, opts=%O", utterances.length, opts);
+  const { timestamps = false, source = "all" } = opts;
+  let filtered = utterances;
+  if (source !== "all") {
+    filtered = utterances.filter((u) => u.source === source);
+    debug20("filtered to %d utterances (source=%s)", filtered.length, source);
+  }
+  if (filtered.length === 0) {
+    debug20("no transcript available");
+    return "No transcript available.";
+  }
+  const lines = [];
+  for (const u of filtered) {
+    const speaker = u.source === "microphone" ? "You" : "Participant";
+    if (timestamps) {
+      const time = formatTimestamp(u.start_timestamp);
+      lines.push(`[${time}] ${speaker}`);
+      lines.push(u.text);
+      lines.push("");
+    } else {
+      lines.push(`${speaker}: ${u.text}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function formatTimestamp(iso) {
+  const d = new Date(iso);
+  const h = d.getUTCHours().toString().padStart(2, "0");
+  const m = d.getUTCMinutes().toString().padStart(2, "0");
+  const s = d.getUTCSeconds().toString().padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+
+// src/commands/meeting/transcript.ts
+var debug21 = createGranolaDebug("cmd:meeting:transcript");
+var SOURCE_OPTIONS = /* @__PURE__ */ new Set(["microphone", "system", "all"]);
+function createTranscriptCommand() {
+  return new Command14("transcript").description("View meeting transcript").argument("<id>", "Meeting ID").option("-t, --timestamps", "Include timestamps").option("-s, --source <type>", "Filter: microphone, system, all", "all").option("-o, --output <format>", "Output format (text, json, yaml, toon)", "text").action(async (id, opts, cmd) => {
+    debug21("transcript command invoked with id: %s, opts: %O", id, opts);
+    const global = cmd.optsWithGlobals();
+    let fullId;
+    try {
+      const resolved = await resolveId(id);
+      if (!resolved) {
+        console.error(chalk14.red(`Meeting ${id} not found`));
+        process.exit(4);
+      }
+      fullId = resolved;
+    } catch (err) {
+      console.error(chalk14.red(err.message));
+      process.exit(1);
+    }
+    const transcript = await getTranscript(fullId);
+    if (transcript.length === 0) {
+      console.error(chalk14.red(`No transcript found for meeting ${id}`));
+      process.exit(4);
+    }
+    const requestedSource = opts.source || "all";
+    if (!SOURCE_OPTIONS.has(requestedSource)) {
+      console.error(
+        chalk14.red(`Invalid source: ${requestedSource}. Use 'microphone', 'system', or 'all'.`)
+      );
+      process.exit(1);
+    }
+    const format = opts.output || "text";
+    const structuredFormats = ["json", "yaml", "toon"];
+    if (format !== "text" && !structuredFormats.includes(format)) {
+      console.error(
+        chalk14.red(`Invalid format: ${format}. Use 'text', 'json', 'yaml', or 'toon'.`)
+      );
+      process.exit(1);
+    }
+    if (structuredFormats.includes(format)) {
+      console.log(formatOutput(transcript, format));
+      return;
+    }
+    const output = formatTranscript(transcript, {
+      timestamps: opts.timestamps,
+      source: requestedSource
+    });
+    if (global.noPager || !process.stdout.isTTY) {
+      console.log(output);
+    } else {
+      await pipeToPager(output);
+    }
+  });
+}
+var transcriptCommand = createTranscriptCommand();
+
+// src/commands/meeting/view.ts
+import chalk15 from "chalk";
+import { Command as Command15 } from "commander";
+import open from "open";
+var debug22 = createGranolaDebug("cmd:meeting:view");
+function createViewCommand2() {
+  return new Command15("view").description("View meeting details").argument("<id>", "Meeting ID").option("--web", "Open in browser").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (id, opts) => {
+    debug22("view command invoked with id: %s, opts: %O", id, opts);
+    let fullId;
+    try {
+      const resolved = await resolveId(id);
+      if (!resolved) {
+        console.error(chalk15.red(`Meeting ${id} not found`));
+        process.exit(4);
+      }
+      fullId = resolved;
+    } catch (err) {
+      console.error(chalk15.red(err.message));
+      process.exit(1);
+    }
+    if (opts.web) {
+      await open(`https://app.granola.ai/meeting/${fullId}`);
+      return;
+    }
+    const meeting = await get2(fullId);
+    if (!meeting) {
+      console.error(chalk15.red(`Meeting ${id} not found`));
+      process.exit(4);
+    }
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk15.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(meeting, format));
+      return;
+    }
+    console.log(chalk15.bold(meeting.title));
+    console.log(chalk15.dim(`Recorded ${formatDate(meeting.created_at)}`));
+    console.log();
+    console.log(`Workspace:    ${meeting.workspace_id || "Personal"}`);
+    if (meeting.creator?.name) {
+      console.log(`Organizer:    ${meeting.creator.name}`);
+    }
+    if (meeting.attendees?.length) {
+      console.log(`Attendees:    ${meeting.attendees.length} participant(s)`);
+      for (const attendee of meeting.attendees) {
+        const name = attendee.name || attendee.details?.person?.name?.fullName || "Unknown";
+        const title = attendee.details?.employment?.title;
+        const info = title ? `${name} (${title})` : name;
+        console.log(chalk15.dim(`              - ${info}`));
+      }
+    }
+    console.log();
+    console.log(`${chalk15.dim("View notes:       ")}granola meeting notes ${id}`);
+    console.log(`${chalk15.dim("View transcript:  ")}granola meeting transcript ${id}`);
+  });
+}
+var viewCommand2 = createViewCommand2();
+
+// src/commands/meeting/index.ts
+var meetingCommand = new Command16("meeting").description("Work with meetings").addCommand(listCommand2).addCommand(viewCommand2).addCommand(notesCommand).addCommand(enhancedCommand).addCommand(transcriptCommand).addCommand(exportCommand);
+
+// src/commands/workspace/index.ts
+import { Command as Command19 } from "commander";
+
+// src/commands/workspace/list.ts
+import chalk16 from "chalk";
+import { Command as Command17 } from "commander";
+
+// src/services/workspaces.ts
+var debug23 = createGranolaDebug("service:workspaces");
+async function list3() {
+  return withTokenRefresh(async () => {
+    debug23("fetching workspaces");
+    const client2 = await getClient();
+    const res = await client2.getWorkspaces();
+    const workspacesArray = res?.workspaces || [];
+    debug23("found %d workspaces", workspacesArray.length);
+    return workspacesArray.map((item) => {
+      const ws = item.workspace;
+      return {
+        id: ws.workspace_id,
+        name: ws.display_name,
+        created_at: ws.created_at,
+        owner_id: ""
+      };
+    });
+  });
+}
+async function resolveId2(partialId) {
+  debug23("resolving workspace id: %s", partialId);
+  const workspaces = await list3();
+  const matches = workspaces.filter((w) => w.id.startsWith(partialId));
+  if (matches.length === 0) {
+    debug23("no workspace found for id: %s", partialId);
+    return null;
+  }
+  if (matches.length > 1) {
+    debug23("ambiguous id: %s matches %d workspaces", partialId, matches.length);
+    throw new Error(`Ambiguous ID: ${partialId} matches ${matches.length} workspaces`);
+  }
+  debug23("resolved workspace: %s -> %s", partialId, matches[0].id);
+  return matches[0].id;
+}
+async function get3(id) {
+  debug23("getting workspace: %s", id);
+  const workspaces = await list3();
+  const workspace = workspaces.find((w) => w.id === id) || null;
+  debug23("workspace %s: %s", id, workspace ? "found" : "not found");
+  return workspace;
+}
+
+// src/commands/workspace/list.ts
+var debug24 = createGranolaDebug("cmd:workspace:list");
+function createListCommand3() {
+  return new Command17("list").description("List workspaces").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (opts) => {
+    debug24("workspace list command invoked");
+    const data = await list3();
+    debug24("fetched %d workspaces", data.length);
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk16.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(data, format));
+      return;
+    }
+    if (data.length === 0) {
+      console.log(chalk16.dim("No workspaces found."));
+      return;
+    }
+    const output = table(data, [
+      { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 8) },
+      { key: "name", header: "NAME", width: 20 },
+      { key: "created_at", header: "CREATED", width: 14, format: (v) => formatDate(String(v)) }
+    ]);
+    console.log(output);
+  });
+}
+var listCommand3 = createListCommand3();
+
+// src/commands/workspace/view.ts
+import chalk17 from "chalk";
+import { Command as Command18 } from "commander";
+var debug25 = createGranolaDebug("cmd:workspace:view");
+function createViewCommand3() {
+  return new Command18("view").description("View workspace details").argument("<id>", "Workspace ID").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (id, opts) => {
+    debug25("workspace view command invoked with id: %s", id);
+    let fullId;
+    try {
+      const resolved = await resolveId2(id);
+      if (!resolved) {
+        console.error(chalk17.red(`Workspace ${id} not found`));
+        process.exit(4);
+      }
+      fullId = resolved;
+    } catch (err) {
+      console.error(chalk17.red(err.message));
+      process.exit(1);
+    }
+    const workspace = await get3(fullId);
+    if (!workspace) {
+      console.error(chalk17.red(`Workspace ${id} not found`));
+      process.exit(4);
+    }
+    const format = opts.output || null;
+    if (format) {
+      if (!["json", "yaml", "toon"].includes(format)) {
+        console.error(chalk17.red(`Invalid format: ${format}. Use 'json', 'yaml', or 'toon'.`));
+        process.exit(1);
+      }
+      console.log(formatOutput(workspace, format));
+      return;
+    }
+    console.log(chalk17.bold(workspace.name));
+    console.log(chalk17.dim(`Created ${formatDate(workspace.created_at)}`));
+    console.log();
+    console.log(`View all meetings:  granola meeting list --workspace ${id}`);
+  });
+}
+var viewCommand3 = createViewCommand3();
+
+// src/commands/workspace/index.ts
+var workspaceCommand = new Command19("workspace").description("Work with workspaces").addCommand(listCommand3).addCommand(viewCommand3);
+
+// src/main.ts
+var debug26 = createGranolaDebug("cli");
+var debugAlias = createGranolaDebug("cli:alias");
+var debugSubcmd = createGranolaDebug("cli:subcommand");
+var packageJson = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
+debug26("granola-cli v%s starting", packageJson.version);
+debug26("arguments: %O", process.argv.slice(2));
+var program = new Command20();
+program.name("granola").description("CLI for Granola meeting notes").version(packageJson.version).option("--no-pager", "Disable pager");
+program.addCommand(authCommand);
+program.addCommand(meetingCommand);
+program.addCommand(workspaceCommand);
+program.addCommand(folderCommand);
+program.addCommand(configCommand);
+program.addCommand(aliasCommand);
+function discoverExternalSubcommands() {
+  const subcommands = /* @__PURE__ */ new Map();
+  const pathDirs = (process.env.PATH || "").split(delimiter);
+  debugSubcmd("scanning PATH directories: %d dirs", pathDirs.length);
+  for (const dir of pathDirs) {
+    if (!existsSync(dir)) continue;
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        if (!entry.startsWith("granola-")) continue;
+        const fullPath = join2(dir, entry);
+        try {
+          const stat = statSync(fullPath);
+          if (stat.isFile()) {
+            const subcommandName = entry.replace(/^granola-/, "").replace(/\.(exe|cmd|bat)$/i, "");
+            if (!subcommands.has(subcommandName)) {
+              debugSubcmd("found external subcommand: %s at %s", subcommandName, fullPath);
+              subcommands.set(subcommandName, fullPath);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  debugSubcmd("discovered %d external subcommands", subcommands.size);
+  return subcommands;
+}
+var externalSubcommands = discoverExternalSubcommands();
+for (const [name, execPath] of externalSubcommands) {
+  if (program.commands.some((cmd) => cmd.name() === name)) continue;
+  const externalCmd = new Command20(name).description(`[external] ${name}`).allowUnknownOption().allowExcessArguments().action((...args) => {
+    const cmdArgs = args.slice(0, -1);
+    debugSubcmd("executing external command: %s with args: %O", execPath, cmdArgs);
+    const child = spawn2(execPath, cmdArgs, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("close", (code) => {
+      debugSubcmd("external command exited with code: %d", code);
+      process.exit(code ?? 0);
+    });
+    child.on("error", (err) => {
+      debugSubcmd("external command error: %O", err);
+      console.error(`Failed to run external command: ${err.message}`);
+      process.exit(1);
+    });
+  });
+  program.addCommand(externalCmd);
+}
+function expandAlias(args) {
+  if (args.length < 3) return args;
+  const command = args[2];
+  debugAlias("checking alias for command: %s", command);
+  const alias = getAlias(command);
+  if (alias) {
+    debugAlias("alias found: %s -> %s", command, alias);
+    try {
+      const aliasArgs = parseAliasArguments(alias);
+      const expanded = [...args.slice(0, 2), ...aliasArgs, ...args.slice(3)];
+      debugAlias("expanded args: %O", expanded.slice(2));
+      return expanded;
+    } catch (err) {
+      debugAlias("failed to expand alias %s: %O", command, err);
+      return args;
+    }
+  }
+  return args;
+}
+var expandedArgs = expandAlias(process.argv);
+debug26("parsing with args: %O", expandedArgs.slice(2));
+program.parseAsync(expandedArgs);
+//# sourceMappingURL=main.js.map