granola-cli 0.1.0 → 0.1.1

package/dist/main.js

@@ -1,9 +1,7 @@
 #!/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 { readFileSync as readFileSync2 } from "fs";
 import { Command as Command20 } from "commander";
 
 // src/commands/alias.ts
@@ -225,87 +223,173 @@ 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 { homedir as homedir2, platform } from "os";
+import { join as join2 } from "path";
 import { deletePassword, getPassword, setPassword } from "cross-keychain";
-var debug4 = createGranolaDebug("lib:auth");
+
+// src/lib/lock.ts
+import { mkdir, open, stat, unlink } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { dirname, join } from "path";
+var debug4 = createGranolaDebug("lib:lock");
+var LOCK_FILE_NAME = "granola-token-refresh.lock";
+var LOCK_TIMEOUT_MS = 3e4;
+var LOCK_RETRY_INTERVAL_MS = 100;
+var LOCK_STALE_MS = 6e4;
+function getLockFilePath() {
+  const tempDir = process.platform === "darwin" ? join(homedir(), "Library", "Caches", "granola") : tmpdir();
+  return join(tempDir, LOCK_FILE_NAME);
+}
+async function ensureLockDirectory() {
+  const lockPath = getLockFilePath();
+  const dir = dirname(lockPath);
+  await mkdir(dir, { recursive: true });
+}
+async function isLockStale(lockPath) {
+  try {
+    const stats = await stat(lockPath);
+    const age = Date.now() - stats.mtimeMs;
+    return age > LOCK_STALE_MS;
+  } catch {
+    return true;
+  }
+}
+async function acquireLock() {
+  const lockPath = getLockFilePath();
+  const startTime = Date.now();
+  await ensureLockDirectory();
+  debug4("attempting to acquire lock at %s", lockPath);
+  while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+    try {
+      const handle = await open(lockPath, "wx");
+      debug4("lock acquired");
+      return { handle };
+    } catch (error) {
+      const err = error;
+      if (err.code === "EEXIST") {
+        if (await isLockStale(lockPath)) {
+          debug4("removing stale lock");
+          try {
+            await unlink(lockPath);
+          } catch {
+          }
+          continue;
+        }
+        debug4("lock held by another process, waiting...");
+        await new Promise((r) => setTimeout(r, LOCK_RETRY_INTERVAL_MS));
+      } else {
+        debug4("lock acquisition failed: %O", error);
+        throw error;
+      }
+    }
+  }
+  debug4("lock acquisition timed out");
+  return null;
+}
+async function releaseLock(lockHandle) {
+  const lockPath = getLockFilePath();
+  debug4("releasing lock");
+  try {
+    await lockHandle.handle.close();
+    await unlink(lockPath);
+    debug4("lock released");
+  } catch (error) {
+    debug4("error releasing lock: %O", error);
+  }
+}
+async function withLock(operation) {
+  const handle = await acquireLock();
+  if (handle === null) {
+    throw new Error("Failed to acquire token refresh lock");
+  }
+  try {
+    return await operation();
+  } finally {
+    await releaseLock(handle);
+  }
+}
+
+// src/lib/auth.ts
+var debug5 = 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");
+  debug5("loading credentials from keychain");
   try {
     const stored = await getPassword(SERVICE_NAME, ACCOUNT_NAME);
     if (!stored) {
-      debug4("no credentials found in keychain");
+      debug5("no credentials found in keychain");
       return null;
     }
     const parsed = JSON.parse(stored);
-    debug4("credentials loaded, hasAccessToken: %s", Boolean(parsed.accessToken));
+    debug5("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);
+    debug5("failed to get credentials: %O", error);
     return null;
   }
 }
 async function saveCredentials(creds) {
-  debug4("saving credentials to keychain");
+  debug5("saving credentials to keychain");
   await setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(creds));
-  debug4("credentials saved");
+  debug5("credentials saved");
 }
 async function deleteCredentials() {
-  debug4("deleting credentials from keychain");
+  debug5("deleting credentials from keychain");
   await deletePassword(SERVICE_NAME, ACCOUNT_NAME);
-  debug4("credentials deleted");
+  debug5("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;
-  }
+  debug5("attempting token refresh");
   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
-      })
+    return await withLock(async () => {
+      const creds = await getCredentials();
+      if (!creds?.refreshToken || !creds?.clientId) {
+        debug5("cannot refresh: missing refreshToken or clientId");
+        return null;
+      }
+      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) {
+        debug5("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);
+      debug5("token refresh successful, new credentials saved");
+      return newCreds;
     });
-    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);
+    debug5("token refresh error: %O", error);
     return null;
   }
 }
 function parseSupabaseJson(json) {
-  debug4("parsing supabase.json");
+  debug5("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");
+        debug5("found WorkOS tokens");
         return {
           refreshToken: workosTokens.refresh_token || "",
           accessToken: workosTokens.access_token,
@@ -316,7 +400,7 @@ function parseSupabaseJson(json) {
     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");
+      debug5("found Cognito tokens");
       return {
         refreshToken: cognitoTokens.refresh_token,
         accessToken: cognitoTokens.access_token || "",
@@ -324,68 +408,68 @@ function parseSupabaseJson(json) {
       };
     }
     if (!parsed.refresh_token) return null;
-    debug4("found legacy token format");
+    debug5("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);
+    debug5("failed to parse supabase.json: %O", error);
     return null;
   }
 }
 function getDefaultSupabasePath() {
-  const home = homedir();
+  const home = homedir2();
   const os2 = platform();
   let path;
   switch (os2) {
     case "darwin":
-      path = join(home, "Library", "Application Support", "Granola", "supabase.json");
+      path = join2(home, "Library", "Application Support", "Granola", "supabase.json");
       break;
     case "win32":
-      path = join(
-        process.env.APPDATA || join(home, "AppData", "Roaming"),
+      path = join2(
+        process.env.APPDATA || join2(home, "AppData", "Roaming"),
         "Granola",
         "supabase.json"
       );
       break;
     default:
-      path = join(home, ".config", "granola", "supabase.json");
+      path = join2(home, ".config", "granola", "supabase.json");
   }
-  debug4("platform: %s, supabase path: %s", os2, path);
+  debug5("platform: %s, supabase path: %s", os2, path);
   return path;
 }
 async function loadCredentialsFromFile() {
   const path = getDefaultSupabasePath();
-  debug4("loading credentials from file: %s", path);
+  debug5("loading credentials from file: %s", path);
   try {
     const content = await readFile(path, "utf-8");
-    debug4("file read successful, parsing content");
+    debug5("file read successful, parsing content");
     return parseSupabaseJson(content);
   } catch (error) {
-    debug4("failed to load credentials from file: %O", error);
+    debug5("failed to load credentials from file: %O", error);
     return null;
   }
 }
 
 // src/commands/auth/login.ts
-var debug5 = createGranolaDebug("cmd:auth:login");
+var debug6 = createGranolaDebug("cmd:auth:login");
 function createLoginCommand() {
   return new Command2("login").description("Import credentials from Granola desktop app").action(async () => {
-    debug5("login command invoked");
+    debug6("login command invoked");
     const creds = await loadCredentialsFromFile();
     if (!creds) {
       const path = getDefaultSupabasePath();
-      debug5("login failed: could not load credentials from %s", path);
+      debug6("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");
+    debug6("credentials loaded, saving to keychain");
     await saveCredentials(creds);
-    debug5("login successful");
+    debug6("login successful");
     console.log(chalk3.green("Credentials imported successfully"));
   });
 }
@@ -394,16 +478,16 @@ var loginCommand = createLoginCommand();
 // src/commands/auth/logout.ts
 import chalk4 from "chalk";
 import { Command as Command3 } from "commander";
-var debug6 = createGranolaDebug("cmd:auth:logout");
+var debug7 = createGranolaDebug("cmd:auth:logout");
 function createLogoutCommand() {
   return new Command3("logout").description("Logout from Granola").action(async () => {
-    debug6("logout command invoked");
+    debug7("logout command invoked");
     try {
       await deleteCredentials();
-      debug6("logout successful");
+      debug7("logout successful");
       console.log(chalk4.green("Logged out successfully"));
     } catch (error) {
-      debug6("logout failed: %O", error);
+      debug7("logout failed: %O", error);
       console.error(chalk4.red("Error:"), "Failed to logout.");
       if (error instanceof Error) {
         console.error(chalk4.dim(error.message));
@@ -417,12 +501,12 @@ var logoutCommand = createLogoutCommand();
 // src/commands/auth/status.ts
 import chalk5 from "chalk";
 import { Command as Command4 } from "commander";
-var debug7 = createGranolaDebug("cmd:auth:status");
+var debug8 = 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");
+    debug8("status command invoked");
     const creds = await getCredentials();
-    debug7("authenticated: %s", !!creds);
+    debug8("authenticated: %s", !!creds);
     const format = opts.output || null;
     if (format) {
       if (!["json", "yaml", "toon"].includes(format)) {
@@ -448,7 +532,7 @@ var authCommand = new Command5("auth").description("Manage authentication").addC
 // src/commands/config.ts
 import chalk6 from "chalk";
 import { Command as Command6 } from "commander";
-var debug8 = createGranolaDebug("cmd:config");
+var debug9 = createGranolaDebug("cmd:config");
 var CONFIG_VALUE_PARSERS = {
   default_workspace: (value) => value,
   pager: (value) => value,
@@ -479,7 +563,7 @@ function isConfigKey(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");
+    debug9("config list command invoked");
     const config2 = getConfig();
     const format = opts.output || null;
     if (format) {
@@ -506,7 +590,7 @@ function createConfigCommand() {
     }
   });
   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);
+    debug9("config get command invoked with key: %s", key);
     const value = getConfigValue(key);
     const format = opts.output || null;
     if (format) {
@@ -524,7 +608,7 @@ function createConfigCommand() {
     }
   });
   cmd.command("set <key> <value>").description("Set a config value").action((key, value) => {
-    debug8("config set command invoked: %s = %s", key, value);
+    debug9("config set command invoked: %s = %s", key, value);
     if (!isConfigKey(key)) {
       console.error(
         chalk6.red(
@@ -548,7 +632,7 @@ function createConfigCommand() {
     console.log(chalk6.green(`Set ${key} = ${value}`));
   });
   cmd.command("reset").description("Reset to defaults").action(() => {
-    debug8("config reset command invoked");
+    debug9("config reset command invoked");
     resetConfig();
     console.log(chalk6.green("Configuration reset"));
   });
@@ -721,26 +805,26 @@ function createHttpClient(token) {
 }
 
 // src/services/client.ts
-var debug9 = createGranolaDebug("service:client");
+var debug10 = createGranolaDebug("service:client");
 var client = null;
 async function getClient() {
-  debug9("getClient called, cached: %s", client ? "yes" : "no");
+  debug10("getClient called, cached: %s", client ? "yes" : "no");
   if (client) return client;
-  debug9("fetching credentials");
+  debug10("fetching credentials");
   const creds = await getCredentials();
   if (!creds) {
-    debug9("no credentials found, exiting");
+    debug10("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));
+  debug10("creating API client, token: %s", maskToken(creds.accessToken));
   const httpClient = createHttpClient(creds.accessToken);
   client = createApiClient(httpClient);
   return client;
 }
 function resetClient() {
-  debug9("client reset");
+  debug10("client reset");
   client = null;
 }
 function isUnauthorizedError(error) {
@@ -755,14 +839,14 @@ async function withTokenRefresh(operation) {
     return await operation();
   } catch (error) {
     if (isUnauthorizedError(error)) {
-      debug9("401 detected, attempting token refresh");
+      debug10("401 detected, attempting token refresh");
       const newCreds = await refreshAccessToken();
       if (!newCreds) {
-        debug9("token refresh failed, re-throwing original error");
+        debug10("token refresh failed, re-throwing original error");
         throw error;
       }
       resetClient();
-      debug9("retrying operation with refreshed token");
+      debug10("retrying operation with refreshed token");
       return operation();
     }
     throw error;
@@ -770,7 +854,7 @@ async function withTokenRefresh(operation) {
 }
 
 // src/services/folders.ts
-var debug10 = createGranolaDebug("service:folders");
+var debug11 = 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;
@@ -790,10 +874,10 @@ async function list(opts = {}) {
     const client2 = await getClient();
     const documentLists = await client2.getDocumentLists();
     const folders = documentLists.map(normalizeFolder);
-    debug10("list fetched %d folders", folders.length);
+    debug11("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);
+      debug11("filtered to %d folders for workspace %s", filtered.length, opts.workspace);
       return filtered;
     }
     return folders;
@@ -801,30 +885,30 @@ async function list(opts = {}) {
 }
 async function get(id) {
   return withTokenRefresh(async () => {
-    debug10("get called for folder: %s", id);
+    debug11("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);
+      debug11("folder %s not found", id);
       return null;
     }
-    debug10("folder %s found", id);
+    debug11("folder %s found", id);
     return normalizeFolder(folder);
   });
 }
 
 // src/commands/folder/list.ts
-var debug11 = createGranolaDebug("cmd:folder:list");
+var debug12 = 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);
+    debug12("folder list command invoked with opts: %O", opts);
     let data;
     try {
       data = await list({
         workspace: opts.workspace
       });
-      debug11("fetched %d folders", data.length);
+      debug12("fetched %d folders", data.length);
     } catch (error) {
       console.error(chalk8.red("Error:"), "Failed to list folders.");
       if (error instanceof Error) {
@@ -867,10 +951,10 @@ var listCommand = createListCommand();
 // src/commands/folder/view.ts
 import chalk9 from "chalk";
 import { Command as Command8 } from "commander";
-var debug12 = createGranolaDebug("cmd:folder:view");
+var debug13 = 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);
+    debug13("folder view command invoked with id: %s", id);
     let folder;
     try {
       folder = await get(id);
@@ -916,42 +1000,42 @@ import { Command as Command10 } from "commander";
 
 // src/lib/pager.ts
 import { spawn } from "child_process";
-var debug13 = createGranolaDebug("lib:pager");
+var debug14 = 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);
+  debug14("validating pager command: %s", cmd);
   if (SHELL_METACHARACTERS.test(cmd)) {
-    debug13("pager validation failed: contains shell metacharacters");
+    debug14("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);
+  debug14("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);
+    debug14("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);
+    debug14("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);
+    debug14("pager command: %s (source: config)", configuredPager);
     return configuredPager;
   }
-  debug13("pager command: less -R (source: default)");
+  debug14("pager command: less -R (source: default)");
   return "less -R";
 }
 async function pipeToPager(content) {
-  debug13("pipeToPager: isTTY=%s, contentLength=%d", process.stdout.isTTY, content.length);
+  debug14("pipeToPager: isTTY=%s, contentLength=%d", process.stdout.isTTY, content.length);
   if (!process.stdout.isTTY) {
-    debug13("not a TTY, writing directly to stdout");
+    debug14("not a TTY, writing directly to stdout");
     process.stdout.write(`${content}
 `);
     return;
@@ -964,7 +1048,7 @@ async function pipeToPager(content) {
     return;
   }
   const [cmd, ...args] = pagerCmd.split(" ");
-  debug13("spawning pager: %s with args: %O", cmd, args);
+  debug14("spawning pager: %s with args: %O", cmd, args);
   return new Promise((resolve) => {
     let settled = false;
     const finish = () => {
@@ -976,7 +1060,7 @@ async function pipeToPager(content) {
     const fallbackToStdout = (reason) => {
       if (settled) return;
       settled = true;
-      debug13("falling back to stdout: %s", reason);
+      debug14("falling back to stdout: %s", reason);
       console.error(
         `Warning: Unable to launch pager "${pagerCmd}" (${reason}). Falling back to direct output.`
       );
@@ -991,34 +1075,34 @@ async function pipeToPager(content) {
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", () => {
-        debug13("pager closed");
+        debug14("pager closed");
         finish();
       });
       pager.on("error", (err) => {
-        debug13("pager error: %O", err);
+        debug14("pager error: %O", err);
         fallbackToStdout(err.message);
       });
     } catch (err) {
-      debug13("failed to spawn pager: %O", err);
+      debug14("failed to spawn pager: %O", err);
       fallbackToStdout(err.message);
     }
   });
 }
 
 // src/lib/prosemirror.ts
-var debug14 = createGranolaDebug("lib:prosemirror");
+var debug15 = createGranolaDebug("lib:prosemirror");
 function toMarkdown(doc) {
-  debug14("toMarkdown called with doc: %O", doc);
+  debug15("toMarkdown called with doc: %O", doc);
   if (!doc?.content) {
-    debug14("No content in doc, returning empty string");
+    debug15("No content in doc, returning empty string");
     return "";
   }
   const result = doc.content.map((n) => nodeToMd(n)).join("\n\n");
-  debug14("toMarkdown result: %s", result);
+  debug15("toMarkdown result: %s", result);
   return result;
 }
 function nodeToMd(node) {
-  debug14("nodeToMd processing node type: %s, node: %O", node.type, node);
+  debug15("nodeToMd processing node type: %s, node: %O", node.type, node);
   let result;
   switch (node.type) {
     case "heading": {
@@ -1055,10 +1139,10 @@ ${inlineToMd(node.content)}
       result = applyMarks(node.text || "", node.marks);
       break;
     default:
-      debug14("Unknown node type: %s", node.type);
+      debug15("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);
+  debug15("nodeToMd result for %s: %s", node.type, result);
   return result;
 }
 function inlineToMd(content) {
@@ -1076,16 +1160,16 @@ function applyMarks(text, marks) {
 }
 
 // src/services/meetings.ts
-var debug15 = createGranolaDebug("service:meetings");
+var debug16 = createGranolaDebug("service:meetings");
 async function getFolderDocumentIds(client2, folderId) {
-  debug15("fetching folder %s via getDocumentList", folderId);
+  debug16("fetching folder %s via getDocumentList", folderId);
   const folder = await client2.getDocumentList(folderId);
   if (!folder) {
-    debug15("folder %s not found", folderId);
+    debug16("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);
+  debug16("folder %s returned %d document ids", folderId, ids.length);
   return ids;
 }
 var DOCUMENT_BATCH_SIZE = 100;
@@ -1103,50 +1187,50 @@ async function fetchMeetingsByIds(client2, documentIds) {
     const docs = res?.documents || res?.docs || [];
     meetings.push(...docs);
   }
-  debug15("fetched %d meetings via getDocumentsBatch", meetings.length);
+  debug16("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);
+      debug16("getDocumentMetadata returned null for %s", id);
       return null;
     }
     return metadata;
   } catch (err) {
-    debug15("getDocumentMetadata failed for %s: %O", id, err);
+    debug16("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);
+    debug16("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);
+    debug16("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);
+      debug16("listing meetings for folder: %s", folder);
       const folderMeetings = await fetchFolderMeetings(client2, folder);
-      debug15("fetched %d meetings for folder %s", folderMeetings.length, folder);
+      debug16("fetched %d meetings for folder %s", folderMeetings.length, folder);
       let filtered = folderMeetings;
       if (workspace) {
         filtered = folderMeetings.filter((m) => m.workspace_id === workspace);
-        debug15(
+        debug16(
           "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);
+      debug16("returning %d meetings from folder %s after pagination", paginated.length, folder);
       return paginated;
     }
     const res = await client2.getDocuments({
@@ -1155,68 +1239,90 @@ async function list2(opts = {}) {
       include_last_viewed_panel: false
     });
     let meetings = res?.docs || [];
-    debug15("fetched %d meetings", meetings.length);
+    debug16("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);
+      debug16("filtered to %d meetings for workspace: %s", meetings.length, workspace);
     }
     return meetings;
   });
 }
 var RESOLVE_PAGE_SIZE = 100;
 var MAX_RESOLVE_PAGES = 100;
+var FULL_UUID_LENGTH = 36;
+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);
+    return meetingsCache.meetings;
+  }
+  debug16("cache miss or expired, fetching meetings");
+  const meetings = [];
+  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 docs = res?.docs || [];
+    meetings.push(...docs);
+    if (docs.length < RESOLVE_PAGE_SIZE) {
+      break;
+    }
+    offset += RESOLVE_PAGE_SIZE;
+  }
+  meetingsCache = { meetings, timestamp: Date.now() };
+  debug16("cached %d meetings", meetings.length);
+  return meetings;
+}
 async function resolveId(partialId) {
   return withTokenRefresh(async () => {
-    debug15("resolving meeting id: %s", partialId);
+    debug16("resolving meeting id: %s (length: %d)", partialId, partialId.length);
     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 (partialId.length >= FULL_UUID_LENGTH) {
+      debug16("attempting direct lookup for full UUID");
+      try {
+        const metadata = await client2.getDocumentMetadata(partialId);
+        if (metadata) {
+          debug16("direct lookup successful for: %s", partialId);
+          return partialId;
         }
+      } catch {
+        debug16("direct lookup failed, falling back to search");
       }
-      if (meetings.length < RESOLVE_PAGE_SIZE) {
-        break;
+    }
+    const meetings = await getCachedMeetings(client2);
+    const matches = /* @__PURE__ */ new Set();
+    for (const meeting of meetings) {
+      if (meeting.id?.startsWith(partialId)) {
+        matches.add(meeting.id);
+        if (matches.size > 1) {
+          debug16("ambiguous id: %s matches >1 meetings", partialId);
+          throw new Error(`Ambiguous ID: ${partialId} matches ${matches.size} meetings`);
+        }
       }
-      offset += RESOLVE_PAGE_SIZE;
     }
     if (matches.size === 0) {
-      debug15("no meeting found for id: %s", partialId);
+      debug16("no meeting found for id: %s", partialId);
       return null;
     }
     const match = matches.values().next().value;
-    debug15("resolved meeting: %s -> %s", partialId, match);
+    debug16("resolved meeting: %s -> %s", partialId, match);
     return match;
   });
 }
 async function get2(id) {
   return withTokenRefresh(async () => {
-    debug15("getting meeting: %s", id);
+    debug16("getting meeting: %s", id);
     const client2 = await getClient();
     const metadata = await loadMeetingMetadata(client2, id);
     if (!metadata) {
-      debug15("meeting %s: not found", id);
+      debug16("meeting %s: not found", id);
       return null;
     }
-    debug15("meeting %s: found", id);
+    debug16("meeting %s: found", id);
     return { id, ...metadata };
   });
 }
@@ -1224,36 +1330,36 @@ 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);
+      debug16("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);
+      debug16("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);
+        debug16("findMeetingViaDocuments located meeting %s on page %d", id, page);
         return meeting;
       }
       offset += NOTES_PAGE_SIZE;
     } catch (err) {
-      debug15("findMeetingViaDocuments error: %O", err);
+      debug16("findMeetingViaDocuments error: %O", err);
       return null;
     }
   }
-  debug15("findMeetingViaDocuments did not locate meeting %s", id);
+  debug16("findMeetingViaDocuments did not locate meeting %s", id);
   return null;
 }
 async function getNotes(id) {
   return withTokenRefresh(async () => {
-    debug15("getNotes called with id: %s", id);
+    debug16("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");
+      debug16("getNotes resolved via metadata response");
       return metadata.notes || null;
     }
     const meeting = await findMeetingViaDocuments(client2, id, {
@@ -1267,11 +1373,11 @@ async function getNotes(id) {
 }
 async function getEnhancedNotes(id) {
   return withTokenRefresh(async () => {
-    debug15("getEnhancedNotes called with id: %s", id);
+    debug16("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");
+      debug16("getEnhancedNotes resolved via metadata response");
       return metadata.last_viewed_panel?.content || null;
     }
     const meeting = await findMeetingViaDocuments(client2, id, {
@@ -1285,24 +1391,24 @@ async function getEnhancedNotes(id) {
 }
 async function getTranscript(id) {
   return withTokenRefresh(async () => {
-    debug15("getTranscript called with id: %s", id);
+    debug16("getTranscript called with id: %s", id);
     const client2 = await getClient();
     try {
       const transcript = await client2.getDocumentTranscript(id);
-      debug15("getTranscript got %d utterances", transcript.length);
+      debug16("getTranscript got %d utterances", transcript.length);
       return transcript;
     } catch (err) {
-      debug15("getTranscript error: %O", err);
+      debug16("getTranscript error: %O", err);
       return [];
     }
   });
 }
 
 // src/commands/meeting/enhanced.ts
-var debug16 = createGranolaDebug("cmd:meeting:enhanced");
+var debug17 = 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);
+    debug17("enhanced command invoked with id: %s", id);
     const global = cmd.optsWithGlobals();
     let fullId;
     try {
@@ -1320,7 +1426,7 @@ function createEnhancedCommand() {
     try {
       notes = await getEnhancedNotes(fullId);
     } catch (error) {
-      debug16("failed to load enhanced notes: %O", error);
+      debug17("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));
@@ -1364,10 +1470,10 @@ function toToon(data) {
 }
 
 // src/commands/meeting/export.ts
-var debug17 = createGranolaDebug("cmd:meeting:export");
+var debug18 = 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);
+    debug18("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'.`));
@@ -1417,10 +1523,10 @@ var exportCommand = createExportCommand();
 // src/commands/meeting/list.ts
 import chalk12 from "chalk";
 import { Command as Command12 } from "commander";
-var debug18 = createGranolaDebug("cmd:meeting:list");
+var debug19 = 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);
+    debug19("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."));
@@ -1433,9 +1539,9 @@ function createListCommand2() {
       workspace,
       folder: opts.folder
     });
-    debug18("fetched %d meetings", data.length);
+    debug19("fetched %d meetings", data.length);
     const format = opts.output || null;
-    debug18("output format: %s", format || "table");
+    debug19("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'.`));
@@ -1463,10 +1569,10 @@ var listCommand2 = createListCommand2();
 // src/commands/meeting/notes.ts
 import chalk13 from "chalk";
 import { Command as Command13 } from "commander";
-var debug19 = createGranolaDebug("cmd:meeting:notes");
+var debug20 = 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);
+    debug20("notes command invoked with id: %s", id);
     const global = cmd.optsWithGlobals();
     let fullId;
     try {
@@ -1484,7 +1590,7 @@ function createNotesCommand() {
     try {
       notes = await getNotes(fullId);
     } catch (error) {
-      debug19("failed to load notes: %O", error);
+      debug20("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));
@@ -1522,17 +1628,17 @@ import chalk14 from "chalk";
 import { Command as Command14 } from "commander";
 
 // src/lib/transcript.ts
-var debug20 = createGranolaDebug("lib:transcript");
+var debug21 = createGranolaDebug("lib:transcript");
 function formatTranscript(utterances, opts = {}) {
-  debug20("formatTranscript: %d utterances, opts=%O", utterances.length, opts);
+  debug21("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);
+    debug21("filtered to %d utterances (source=%s)", filtered.length, source);
   }
   if (filtered.length === 0) {
-    debug20("no transcript available");
+    debug21("no transcript available");
     return "No transcript available.";
   }
   const lines = [];
@@ -1559,11 +1665,11 @@ function formatTimestamp(iso) {
 }
 
 // src/commands/meeting/transcript.ts
-var debug21 = createGranolaDebug("cmd:meeting:transcript");
+var debug22 = 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);
+    debug22("transcript command invoked with id: %s, opts: %O", id, opts);
     const global = cmd.optsWithGlobals();
     let fullId;
     try {
@@ -1617,11 +1723,11 @@ 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");
+import open2 from "open";
+var debug23 = 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);
+    debug23("view command invoked with id: %s, opts: %O", id, opts);
     let fullId;
     try {
       const resolved = await resolveId(id);
@@ -1635,7 +1741,7 @@ function createViewCommand2() {
       process.exit(1);
     }
     if (opts.web) {
-      await open(`https://app.granola.ai/meeting/${fullId}`);
+      await open2(`https://app.granola.ai/meeting/${fullId}`);
       return;
     }
     const meeting = await get2(fullId);
@@ -1686,14 +1792,14 @@ import chalk16 from "chalk";
 import { Command as Command17 } from "commander";
 
 // src/services/workspaces.ts
-var debug23 = createGranolaDebug("service:workspaces");
+var debug24 = createGranolaDebug("service:workspaces");
 async function list3() {
   return withTokenRefresh(async () => {
-    debug23("fetching workspaces");
+    debug24("fetching workspaces");
     const client2 = await getClient();
     const res = await client2.getWorkspaces();
     const workspacesArray = res?.workspaces || [];
-    debug23("found %d workspaces", workspacesArray.length);
+    debug24("found %d workspaces", workspacesArray.length);
     return workspacesArray.map((item) => {
       const ws = item.workspace;
       return {
@@ -1706,35 +1812,35 @@ async function list3() {
   });
 }
 async function resolveId2(partialId) {
-  debug23("resolving workspace id: %s", partialId);
+  debug24("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);
+    debug24("no workspace found for id: %s", partialId);
     return null;
   }
   if (matches.length > 1) {
-    debug23("ambiguous id: %s matches %d workspaces", partialId, matches.length);
+    debug24("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);
+  debug24("resolved workspace: %s -> %s", partialId, matches[0].id);
   return matches[0].id;
 }
 async function get3(id) {
-  debug23("getting workspace: %s", id);
+  debug24("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");
+  debug24("workspace %s: %s", id, workspace ? "found" : "not found");
   return workspace;
 }
 
 // src/commands/workspace/list.ts
-var debug24 = createGranolaDebug("cmd:workspace:list");
+var debug25 = 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");
+    debug25("workspace list command invoked");
     const data = await list3();
-    debug24("fetched %d workspaces", data.length);
+    debug25("fetched %d workspaces", data.length);
     const format = opts.output || null;
     if (format) {
       if (!["json", "yaml", "toon"].includes(format)) {
@@ -1761,10 +1867,10 @@ var listCommand3 = createListCommand3();
 // src/commands/workspace/view.ts
 import chalk17 from "chalk";
 import { Command as Command18 } from "commander";
-var debug25 = createGranolaDebug("cmd:workspace:view");
+var debug26 = 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);
+    debug26("workspace view command invoked with id: %s", id);
     let fullId;
     try {
       const resolved = await resolveId2(id);
@@ -1803,12 +1909,11 @@ var viewCommand3 = createViewCommand3();
 var workspaceCommand = new Command19("workspace").description("Work with workspaces").addCommand(listCommand3).addCommand(viewCommand3);
 
 // src/main.ts
-var debug26 = createGranolaDebug("cli");
+var debug27 = 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));
+debug27("granola-cli v%s starting", packageJson.version);
+debug27("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);
@@ -1817,57 +1922,6 @@ 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];
@@ -1888,6 +1942,6 @@ function expandAlias(args) {
   return args;
 }
 var expandedArgs = expandAlias(process.argv);
-debug26("parsing with args: %O", expandedArgs.slice(2));
+debug27("parsing with args: %O", expandedArgs.slice(2));
 program.parseAsync(expandedArgs);
 //# sourceMappingURL=main.js.map