granola-cli 0.1.1 → 0.2.0

package/dist/main.js

@@ -254,12 +254,12 @@ async function isLockStale(lockPath) {
     return true;
   }
 }
-async function acquireLock() {
+async function acquireLock(timeoutMs = LOCK_TIMEOUT_MS) {
   const lockPath = getLockFilePath();
   const startTime = Date.now();
   await ensureLockDirectory();
   debug4("attempting to acquire lock at %s", lockPath);
-  while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+  while (Date.now() - startTime < timeoutMs) {
     try {
       const handle = await open(lockPath, "wx");
       debug4("lock acquired");
@@ -297,8 +297,8 @@ async function releaseLock(lockHandle) {
     debug4("error releasing lock: %O", error);
   }
 }
-async function withLock(operation) {
-  const handle = await acquireLock();
+async function withLock(operation, timeoutMs = LOCK_TIMEOUT_MS) {
+  const handle = await acquireLock(timeoutMs);
   if (handle === null) {
     throw new Error("Failed to acquire token refresh lock");
   }
@@ -1159,17 +1159,90 @@ function applyMarks(text, marks) {
   return text;
 }
 
+// src/lib/filters.ts
+var debug16 = createGranolaDebug("lib:filters");
+function isSameDay(d1, d2) {
+  return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth() && d1.getDate() === d2.getDate();
+}
+function startOfDay(date) {
+  const result = new Date(date);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfDay(date) {
+  const result = new Date(date);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+function matchesSearch(meeting, query) {
+  const normalizedQuery = query.toLowerCase();
+  const normalizedTitle = meeting.title.toLowerCase();
+  return normalizedTitle.includes(normalizedQuery);
+}
+function matchesAttendee(meeting, query) {
+  const normalizedQuery = query.toLowerCase();
+  const peopleAttendees = meeting.people?.attendees ?? [];
+  const topLevelAttendees = meeting.attendees ?? [];
+  const allAttendees = [...peopleAttendees, ...topLevelAttendees];
+  return allAttendees.some((attendee) => {
+    const name = attendee.name?.toLowerCase() ?? "";
+    const email = attendee.email?.toLowerCase() ?? "";
+    return name.includes(normalizedQuery) || email.includes(normalizedQuery);
+  });
+}
+function matchesDate(meeting, date) {
+  const meetingDate = new Date(meeting.created_at);
+  return isSameDay(meetingDate, date);
+}
+function matchesDateRange(meeting, since, until) {
+  const meetingDate = new Date(meeting.created_at);
+  if (since && meetingDate < startOfDay(since)) {
+    return false;
+  }
+  if (until && meetingDate > endOfDay(until)) {
+    return false;
+  }
+  return true;
+}
+function hasActiveFilters(options) {
+  return !!(options.search || options.attendee || options.date || options.since || options.until);
+}
+function applyFilters(meetings, options) {
+  if (!hasActiveFilters(options)) {
+    return meetings;
+  }
+  debug16("applying filters: %O", options);
+  const startCount = meetings.length;
+  const filtered = meetings.filter((meeting) => {
+    if (options.search && !matchesSearch(meeting, options.search)) {
+      return false;
+    }
+    if (options.attendee && !matchesAttendee(meeting, options.attendee)) {
+      return false;
+    }
+    if (options.date && !matchesDate(meeting, options.date)) {
+      return false;
+    }
+    if (!matchesDateRange(meeting, options.since, options.until)) {
+      return false;
+    }
+    return true;
+  });
+  debug16("filtered %d -> %d meetings", startCount, filtered.length);
+  return filtered;
+}
+
 // src/services/meetings.ts
-var debug16 = createGranolaDebug("service:meetings");
+var debug17 = createGranolaDebug("service:meetings");
 async function getFolderDocumentIds(client2, folderId) {
-  debug16("fetching folder %s via getDocumentList", folderId);
+  debug17("fetching folder %s via getDocumentList", folderId);
   const folder = await client2.getDocumentList(folderId);
   if (!folder) {
-    debug16("folder %s not found", folderId);
+    debug17("folder %s not found", folderId);
     return [];
   }
   const ids = folder.document_ids || folder.documents?.map((doc) => doc.id) || [];
-  debug16("folder %s returned %d document ids", folderId, ids.length);
+  debug17("folder %s returned %d document ids", folderId, ids.length);
   return ids;
 }
 var DOCUMENT_BATCH_SIZE = 100;
@@ -1187,50 +1260,63 @@ async function fetchMeetingsByIds(client2, documentIds) {
     const docs = res?.documents || res?.docs || [];
     meetings.push(...docs);
   }
-  debug16("fetched %d meetings via getDocumentsBatch", meetings.length);
+  debug17("fetched %d meetings via getDocumentsBatch", meetings.length);
   return meetings;
 }
 async function loadMeetingMetadata(client2, id) {
   try {
     const metadata = await client2.getDocumentMetadata(id);
     if (!metadata) {
-      debug16("getDocumentMetadata returned null for %s", id);
+      debug17("getDocumentMetadata returned null for %s", id);
       return null;
     }
     return metadata;
   } catch (err) {
-    debug16("getDocumentMetadata failed for %s: %O", id, err);
+    debug17("getDocumentMetadata failed for %s: %O", id, err);
     return null;
   }
 }
 async function fetchFolderMeetings(client2, folderId) {
   const ids = await getFolderDocumentIds(client2, folderId);
   if (ids.length === 0) {
-    debug16("folder %s has no documents", folderId);
+    debug17("folder %s has no documents", folderId);
     return [];
   }
   return fetchMeetingsByIds(client2, ids);
 }
 async function list2(opts = {}) {
   return withTokenRefresh(async () => {
-    debug16("list called with opts: %O", opts);
+    debug17("list called with opts: %O", opts);
     const client2 = await getClient();
-    const { limit = 20, offset = 0, workspace, folder } = opts;
+    const { limit = 20, offset = 0, workspace, folder, ...filterOpts } = opts;
     if (folder) {
-      debug16("listing meetings for folder: %s", folder);
+      debug17("listing meetings for folder: %s", folder);
       const folderMeetings = await fetchFolderMeetings(client2, folder);
-      debug16("fetched %d meetings for folder %s", folderMeetings.length, folder);
+      debug17("fetched %d meetings for folder %s", folderMeetings.length, folder);
       let filtered = folderMeetings;
       if (workspace) {
         filtered = folderMeetings.filter((m) => m.workspace_id === workspace);
-        debug16(
+        debug17(
           "workspace filter applied for folder %s: %d meetings remain",
           folder,
           filtered.length
         );
       }
+      filtered = applyFilters(filtered, filterOpts);
       const paginated = filtered.slice(offset, offset + limit);
-      debug16("returning %d meetings from folder %s after pagination", paginated.length, folder);
+      debug17("returning %d meetings from folder %s after pagination", paginated.length, folder);
+      return paginated;
+    }
+    if (hasActiveFilters(filterOpts)) {
+      debug17("filters active, using cached meetings for filtering");
+      let meetings2 = await getCachedMeetings(client2);
+      if (workspace) {
+        meetings2 = meetings2.filter((m) => m.workspace_id === workspace);
+        debug17("filtered to %d meetings for workspace: %s", meetings2.length, workspace);
+      }
+      meetings2 = applyFilters(meetings2, filterOpts);
+      const paginated = meetings2.slice(offset, offset + limit);
+      debug17("returning %d meetings after filtering and pagination", paginated.length);
       return paginated;
     }
     const res = await client2.getDocuments({
@@ -1239,10 +1325,10 @@ async function list2(opts = {}) {
       include_last_viewed_panel: false
     });
     let meetings = res?.docs || [];
-    debug16("fetched %d meetings", meetings.length);
+    debug17("fetched %d meetings", meetings.length);
     if (workspace) {
       meetings = meetings.filter((m) => m.workspace_id === workspace);
-      debug16("filtered to %d meetings for workspace: %s", meetings.length, workspace);
+      debug17("filtered to %d meetings for workspace: %s", meetings.length, workspace);
     }
     return meetings;
   });
@@ -1254,10 +1340,10 @@ var CACHE_TTL_MS = 6e4;
 var meetingsCache = null;
 async function getCachedMeetings(client2) {
   if (meetingsCache && Date.now() - meetingsCache.timestamp < CACHE_TTL_MS) {
-    debug16("using cached meetings (%d items)", meetingsCache.meetings.length);
+    debug17("using cached meetings (%d items)", meetingsCache.meetings.length);
     return meetingsCache.meetings;
   }
-  debug16("cache miss or expired, fetching meetings");
+  debug17("cache miss or expired, fetching meetings");
   const meetings = [];
   let offset = 0;
   for (let page = 0; page < MAX_RESOLVE_PAGES; page += 1) {
@@ -1274,23 +1360,23 @@ async function getCachedMeetings(client2) {
     offset += RESOLVE_PAGE_SIZE;
   }
   meetingsCache = { meetings, timestamp: Date.now() };
-  debug16("cached %d meetings", meetings.length);
+  debug17("cached %d meetings", meetings.length);
   return meetings;
 }
 async function resolveId(partialId) {
   return withTokenRefresh(async () => {
-    debug16("resolving meeting id: %s (length: %d)", partialId, partialId.length);
+    debug17("resolving meeting id: %s (length: %d)", partialId, partialId.length);
     const client2 = await getClient();
     if (partialId.length >= FULL_UUID_LENGTH) {
-      debug16("attempting direct lookup for full UUID");
+      debug17("attempting direct lookup for full UUID");
       try {
         const metadata = await client2.getDocumentMetadata(partialId);
         if (metadata) {
-          debug16("direct lookup successful for: %s", partialId);
+          debug17("direct lookup successful for: %s", partialId);
           return partialId;
         }
       } catch {
-        debug16("direct lookup failed, falling back to search");
+        debug17("direct lookup failed, falling back to search");
       }
     }
     const meetings = await getCachedMeetings(client2);
@@ -1299,30 +1385,30 @@ async function resolveId(partialId) {
       if (meeting.id?.startsWith(partialId)) {
         matches.add(meeting.id);
         if (matches.size > 1) {
-          debug16("ambiguous id: %s matches >1 meetings", partialId);
+          debug17("ambiguous id: %s matches >1 meetings", partialId);
           throw new Error(`Ambiguous ID: ${partialId} matches ${matches.size} meetings`);
         }
       }
     }
     if (matches.size === 0) {
-      debug16("no meeting found for id: %s", partialId);
+      debug17("no meeting found for id: %s", partialId);
       return null;
     }
     const match = matches.values().next().value;
-    debug16("resolved meeting: %s -> %s", partialId, match);
+    debug17("resolved meeting: %s -> %s", partialId, match);
     return match;
   });
 }
 async function get2(id) {
   return withTokenRefresh(async () => {
-    debug16("getting meeting: %s", id);
+    debug17("getting meeting: %s", id);
     const client2 = await getClient();
     const metadata = await loadMeetingMetadata(client2, id);
     if (!metadata) {
-      debug16("meeting %s: not found", id);
+      debug17("meeting %s: not found", id);
       return null;
     }
-    debug16("meeting %s: found", id);
+    debug17("meeting %s: found", id);
     return { id, ...metadata };
   });
 }
@@ -1330,36 +1416,36 @@ async function findMeetingViaDocuments(client2, id, { includeLastViewedPanel })
   let offset = 0;
   for (let page = 0; page < MAX_NOTES_PAGES; page += 1) {
     try {
-      debug16("findMeetingViaDocuments fetching page %d (offset: %d)", page, offset);
+      debug17("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 || [];
-      debug16("findMeetingViaDocuments got %d meetings on page %d", meetings.length, page);
+      debug17("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) {
-        debug16("findMeetingViaDocuments located meeting %s on page %d", id, page);
+        debug17("findMeetingViaDocuments located meeting %s on page %d", id, page);
         return meeting;
       }
       offset += NOTES_PAGE_SIZE;
     } catch (err) {
-      debug16("findMeetingViaDocuments error: %O", err);
+      debug17("findMeetingViaDocuments error: %O", err);
       return null;
     }
   }
-  debug16("findMeetingViaDocuments did not locate meeting %s", id);
+  debug17("findMeetingViaDocuments did not locate meeting %s", id);
   return null;
 }
 async function getNotes(id) {
   return withTokenRefresh(async () => {
-    debug16("getNotes called with id: %s", id);
+    debug17("getNotes called with id: %s", id);
     const client2 = await getClient();
     const metadata = await loadMeetingMetadata(client2, id);
     if (metadata && "notes" in metadata) {
-      debug16("getNotes resolved via metadata response");
+      debug17("getNotes resolved via metadata response");
       return metadata.notes || null;
     }
     const meeting = await findMeetingViaDocuments(client2, id, {
@@ -1373,11 +1459,11 @@ async function getNotes(id) {
 }
 async function getEnhancedNotes(id) {
   return withTokenRefresh(async () => {
-    debug16("getEnhancedNotes called with id: %s", id);
+    debug17("getEnhancedNotes called with id: %s", id);
     const client2 = await getClient();
     const metadata = await loadMeetingMetadata(client2, id);
     if (metadata && "last_viewed_panel" in metadata) {
-      debug16("getEnhancedNotes resolved via metadata response");
+      debug17("getEnhancedNotes resolved via metadata response");
       return metadata.last_viewed_panel?.content || null;
     }
     const meeting = await findMeetingViaDocuments(client2, id, {
@@ -1391,24 +1477,24 @@ async function getEnhancedNotes(id) {
 }
 async function getTranscript(id) {
   return withTokenRefresh(async () => {
-    debug16("getTranscript called with id: %s", id);
+    debug17("getTranscript called with id: %s", id);
     const client2 = await getClient();
     try {
       const transcript = await client2.getDocumentTranscript(id);
-      debug16("getTranscript got %d utterances", transcript.length);
+      debug17("getTranscript got %d utterances", transcript.length);
       return transcript;
     } catch (err) {
-      debug16("getTranscript error: %O", err);
+      debug17("getTranscript error: %O", err);
       return [];
     }
   });
 }
 
 // src/commands/meeting/enhanced.ts
-var debug17 = createGranolaDebug("cmd:meeting:enhanced");
+var debug18 = 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) => {
-    debug17("enhanced command invoked with id: %s", id);
+    debug18("enhanced command invoked with id: %s", id);
     const global = cmd.optsWithGlobals();
     let fullId;
     try {
@@ -1426,7 +1512,7 @@ function createEnhancedCommand() {
     try {
       notes = await getEnhancedNotes(fullId);
     } catch (error) {
-      debug17("failed to load enhanced notes: %O", error);
+      debug18("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));
@@ -1470,10 +1556,10 @@ function toToon(data) {
 }
 
 // src/commands/meeting/export.ts
-var debug18 = createGranolaDebug("cmd:meeting:export");
+var debug19 = 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) => {
-    debug18("export command invoked with id: %s, format: %s", id, options.format);
+    debug19("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'.`));
@@ -1523,10 +1609,132 @@ var exportCommand = createExportCommand();
 // src/commands/meeting/list.ts
 import chalk12 from "chalk";
 import { Command as Command12 } from "commander";
-var debug19 = createGranolaDebug("cmd:meeting:list");
+
+// src/lib/date-parser.ts
+var debug20 = createGranolaDebug("lib:date-parser");
+var MONTH_NAMES = {
+  jan: 0,
+  january: 0,
+  feb: 1,
+  february: 1,
+  mar: 2,
+  march: 2,
+  apr: 3,
+  april: 3,
+  may: 4,
+  jun: 5,
+  june: 5,
+  jul: 6,
+  july: 6,
+  aug: 7,
+  august: 7,
+  sep: 8,
+  september: 8,
+  oct: 9,
+  october: 9,
+  nov: 10,
+  november: 10,
+  dec: 11,
+  december: 11
+};
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function addMonths(date, months) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + months);
+  return result;
+}
+function startOfDay2(date) {
+  const result = new Date(date);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function parseDate(input) {
+  const normalized = input.trim().toLowerCase();
+  debug20("parsing date: %s", normalized);
+  if (normalized === "today") {
+    return startOfDay2(/* @__PURE__ */ new Date());
+  }
+  if (normalized === "yesterday") {
+    return startOfDay2(addDays(/* @__PURE__ */ new Date(), -1));
+  }
+  if (normalized === "tomorrow") {
+    return startOfDay2(addDays(/* @__PURE__ */ new Date(), 1));
+  }
+  if (normalized === "last week") {
+    return startOfDay2(addDays(/* @__PURE__ */ new Date(), -7));
+  }
+  if (normalized === "last month") {
+    return startOfDay2(addMonths(/* @__PURE__ */ new Date(), -1));
+  }
+  const daysAgoMatch = normalized.match(/^(\d+)\s+days?\s+ago$/);
+  if (daysAgoMatch) {
+    return startOfDay2(addDays(/* @__PURE__ */ new Date(), -Number.parseInt(daysAgoMatch[1], 10)));
+  }
+  const weeksAgoMatch = normalized.match(/^(\d+)\s+weeks?\s+ago$/);
+  if (weeksAgoMatch) {
+    return startOfDay2(addDays(/* @__PURE__ */ new Date(), -Number.parseInt(weeksAgoMatch[1], 10) * 7));
+  }
+  const monthsAgoMatch = normalized.match(/^(\d+)\s+months?\s+ago$/);
+  if (monthsAgoMatch) {
+    return startOfDay2(addMonths(/* @__PURE__ */ new Date(), -Number.parseInt(monthsAgoMatch[1], 10)));
+  }
+  const isoMatch = input.match(/^(\d{4})[-/](\d{1,2})[-/](\d{1,2})$/);
+  if (isoMatch) {
+    const year = Number.parseInt(isoMatch[1], 10);
+    const month = Number.parseInt(isoMatch[2], 10) - 1;
+    const day = Number.parseInt(isoMatch[3], 10);
+    const date = new Date(year, month, day);
+    if (!Number.isNaN(date.getTime())) {
+      return startOfDay2(date);
+    }
+  }
+  const monthDayMatch = normalized.match(/^([a-z]+)\s+(\d{1,2})(?:\s+(\d{4}))?$/);
+  if (monthDayMatch) {
+    const monthNum = MONTH_NAMES[monthDayMatch[1]];
+    if (monthNum !== void 0) {
+      const day = Number.parseInt(monthDayMatch[2], 10);
+      const year = monthDayMatch[3] ? Number.parseInt(monthDayMatch[3], 10) : (/* @__PURE__ */ new Date()).getFullYear();
+      const date = new Date(year, monthNum, day);
+      if (!Number.isNaN(date.getTime())) {
+        return startOfDay2(date);
+      }
+    }
+  }
+  const dayMonthMatch = normalized.match(/^(\d{1,2})\s+([a-z]+)(?:\s+(\d{4}))?$/);
+  if (dayMonthMatch) {
+    const monthNum = MONTH_NAMES[dayMonthMatch[2]];
+    if (monthNum !== void 0) {
+      const day = Number.parseInt(dayMonthMatch[1], 10);
+      const year = dayMonthMatch[3] ? Number.parseInt(dayMonthMatch[3], 10) : (/* @__PURE__ */ new Date()).getFullYear();
+      const date = new Date(year, monthNum, day);
+      if (!Number.isNaN(date.getTime())) {
+        return startOfDay2(date);
+      }
+    }
+  }
+  debug20("failed to parse date: %s", input);
+  return null;
+}
+function validateDateOption(value, optionName) {
+  const parsed = parseDate(value);
+  if (!parsed) {
+    throw new Error(
+      `Invalid date for ${optionName}: "${value}". Try formats like: today, yesterday, last week, 2024-01-15, "Dec 20"`
+    );
+  }
+  debug20("validated %s: %s -> %s", optionName, value, parsed.toISOString());
+  return parsed;
+}
+
+// src/commands/meeting/list.ts
+var debug21 = 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) => {
-    debug19("list command invoked with opts: %O", opts);
+  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("-s, --search <query>", "Search in meeting titles").option("-a, --attendee <name>", "Filter by attendee name or email").option("-d, --date <date>", "Filter meetings on a specific date").option("--since <date>", "Filter meetings from date (inclusive)").option("--until <date>", "Filter meetings up to date (inclusive)").option("-o, --output <format>", "Output format (json, yaml, toon)").action(async (opts) => {
+    debug21("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."));
@@ -1534,14 +1742,40 @@ function createListCommand2() {
     }
     const configuredWorkspace = getConfigValue("default_workspace");
     const workspace = opts.workspace ?? configuredWorkspace;
+    let date;
+    let since;
+    let until;
+    try {
+      if (opts.date) {
+        date = validateDateOption(opts.date, "--date");
+      }
+      if (opts.since) {
+        since = validateDateOption(opts.since, "--since");
+      }
+      if (opts.until) {
+        until = validateDateOption(opts.until, "--until");
+      }
+    } catch (err) {
+      console.error(chalk12.red(err.message));
+      process.exit(1);
+    }
+    if (since && until && since > until) {
+      console.error(chalk12.red("--since date must be before --until date"));
+      process.exit(1);
+    }
     const data = await list2({
       limit,
       workspace,
-      folder: opts.folder
+      folder: opts.folder,
+      search: opts.search,
+      attendee: opts.attendee,
+      date,
+      since,
+      until
     });
-    debug19("fetched %d meetings", data.length);
+    debug21("fetched %d meetings", data.length);
     const format = opts.output || null;
-    debug19("output format: %s", format || "table");
+    debug21("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'.`));
@@ -1569,10 +1803,10 @@ var listCommand2 = createListCommand2();
 // src/commands/meeting/notes.ts
 import chalk13 from "chalk";
 import { Command as Command13 } from "commander";
-var debug20 = createGranolaDebug("cmd:meeting:notes");
+var debug22 = 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) => {
-    debug20("notes command invoked with id: %s", id);
+    debug22("notes command invoked with id: %s", id);
     const global = cmd.optsWithGlobals();
     let fullId;
     try {
@@ -1590,7 +1824,7 @@ function createNotesCommand() {
     try {
       notes = await getNotes(fullId);
     } catch (error) {
-      debug20("failed to load notes: %O", error);
+      debug22("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));
@@ -1628,17 +1862,17 @@ import chalk14 from "chalk";
 import { Command as Command14 } from "commander";
 
 // src/lib/transcript.ts
-var debug21 = createGranolaDebug("lib:transcript");
+var debug23 = createGranolaDebug("lib:transcript");
 function formatTranscript(utterances, opts = {}) {
-  debug21("formatTranscript: %d utterances, opts=%O", utterances.length, opts);
+  debug23("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);
-    debug21("filtered to %d utterances (source=%s)", filtered.length, source);
+    debug23("filtered to %d utterances (source=%s)", filtered.length, source);
   }
   if (filtered.length === 0) {
-    debug21("no transcript available");
+    debug23("no transcript available");
     return "No transcript available.";
   }
   const lines = [];
@@ -1665,11 +1899,11 @@ function formatTimestamp(iso) {
 }
 
 // src/commands/meeting/transcript.ts
-var debug22 = createGranolaDebug("cmd:meeting:transcript");
+var debug24 = 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) => {
-    debug22("transcript command invoked with id: %s, opts: %O", id, opts);
+    debug24("transcript command invoked with id: %s, opts: %O", id, opts);
     const global = cmd.optsWithGlobals();
     let fullId;
     try {
@@ -1724,10 +1958,10 @@ var transcriptCommand = createTranscriptCommand();
 import chalk15 from "chalk";
 import { Command as Command15 } from "commander";
 import open2 from "open";
-var debug23 = createGranolaDebug("cmd:meeting:view");
+var debug25 = 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) => {
-    debug23("view command invoked with id: %s, opts: %O", id, opts);
+    debug25("view command invoked with id: %s, opts: %O", id, opts);
     let fullId;
     try {
       const resolved = await resolveId(id);
@@ -1741,7 +1975,7 @@ function createViewCommand2() {
       process.exit(1);
     }
     if (opts.web) {
-      await open2(`https://app.granola.ai/meeting/${fullId}`);
+      await open2(`https://notes.granola.ai/d/${fullId}`);
       return;
     }
     const meeting = await get2(fullId);
@@ -1792,14 +2026,14 @@ import chalk16 from "chalk";
 import { Command as Command17 } from "commander";
 
 // src/services/workspaces.ts
-var debug24 = createGranolaDebug("service:workspaces");
+var debug26 = createGranolaDebug("service:workspaces");
 async function list3() {
   return withTokenRefresh(async () => {
-    debug24("fetching workspaces");
+    debug26("fetching workspaces");
     const client2 = await getClient();
     const res = await client2.getWorkspaces();
     const workspacesArray = res?.workspaces || [];
-    debug24("found %d workspaces", workspacesArray.length);
+    debug26("found %d workspaces", workspacesArray.length);
     return workspacesArray.map((item) => {
       const ws = item.workspace;
       return {
@@ -1812,35 +2046,35 @@ async function list3() {
   });
 }
 async function resolveId2(partialId) {
-  debug24("resolving workspace id: %s", partialId);
+  debug26("resolving workspace id: %s", partialId);
   const workspaces = await list3();
   const matches = workspaces.filter((w) => w.id.startsWith(partialId));
   if (matches.length === 0) {
-    debug24("no workspace found for id: %s", partialId);
+    debug26("no workspace found for id: %s", partialId);
     return null;
   }
   if (matches.length > 1) {
-    debug24("ambiguous id: %s matches %d workspaces", partialId, matches.length);
+    debug26("ambiguous id: %s matches %d workspaces", partialId, matches.length);
     throw new Error(`Ambiguous ID: ${partialId} matches ${matches.length} workspaces`);
   }
-  debug24("resolved workspace: %s -> %s", partialId, matches[0].id);
+  debug26("resolved workspace: %s -> %s", partialId, matches[0].id);
   return matches[0].id;
 }
 async function get3(id) {
-  debug24("getting workspace: %s", id);
+  debug26("getting workspace: %s", id);
   const workspaces = await list3();
   const workspace = workspaces.find((w) => w.id === id) || null;
-  debug24("workspace %s: %s", id, workspace ? "found" : "not found");
+  debug26("workspace %s: %s", id, workspace ? "found" : "not found");
   return workspace;
 }
 
 // src/commands/workspace/list.ts
-var debug25 = createGranolaDebug("cmd:workspace:list");
+var debug27 = 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) => {
-    debug25("workspace list command invoked");
+    debug27("workspace list command invoked");
     const data = await list3();
-    debug25("fetched %d workspaces", data.length);
+    debug27("fetched %d workspaces", data.length);
     const format = opts.output || null;
     if (format) {
       if (!["json", "yaml", "toon"].includes(format)) {
@@ -1867,10 +2101,10 @@ var listCommand3 = createListCommand3();
 // src/commands/workspace/view.ts
 import chalk17 from "chalk";
 import { Command as Command18 } from "commander";
-var debug26 = createGranolaDebug("cmd:workspace:view");
+var debug28 = 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) => {
-    debug26("workspace view command invoked with id: %s", id);
+    debug28("workspace view command invoked with id: %s", id);
     let fullId;
     try {
       const resolved = await resolveId2(id);
@@ -1908,12 +2142,36 @@ var viewCommand3 = createViewCommand3();
 // src/commands/workspace/index.ts
 var workspaceCommand = new Command19("workspace").description("Work with workspaces").addCommand(listCommand3).addCommand(viewCommand3);
 
+// src/lib/errors.ts
+import chalk18 from "chalk";
+function handleGlobalError(error) {
+  if (error instanceof ApiError) {
+    if (error.status === 401) {
+      console.error(chalk18.red("Error:"), "Authentication required.");
+      console.error(`Run ${chalk18.cyan("granola auth login")} to authenticate.`);
+      return 2;
+    }
+    console.error(chalk18.red("Error:"), error.message);
+    return 1;
+  }
+  if (error instanceof Error && error.message.includes("fetch failed")) {
+    console.error(chalk18.red("Error:"), "Network error. Check your connection.");
+    return 1;
+  }
+  if (error instanceof Error) {
+    console.error(chalk18.red("Error:"), error.message || "An unexpected error occurred.");
+  } else {
+    console.error(chalk18.red("Error:"), "An unexpected error occurred.");
+  }
+  return 1;
+}
+
 // src/main.ts
-var debug27 = createGranolaDebug("cli");
+var debug29 = createGranolaDebug("cli");
 var debugAlias = createGranolaDebug("cli:alias");
 var packageJson = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
-debug27("granola-cli v%s starting", packageJson.version);
-debug27("arguments: %O", process.argv.slice(2));
+debug29("granola-cli v%s starting", packageJson.version);
+debug29("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);
@@ -1942,6 +2200,9 @@ function expandAlias(args) {
   return args;
 }
 var expandedArgs = expandAlias(process.argv);
-debug27("parsing with args: %O", expandedArgs.slice(2));
-program.parseAsync(expandedArgs);
+debug29("parsing with args: %O", expandedArgs.slice(2));
+program.parseAsync(expandedArgs).catch((error) => {
+  const exitCode = handleGlobalError(error);
+  process.exit(exitCode);
+});
 //# sourceMappingURL=main.js.map