npm - @plaud-ai/cli - Versions diffs - 0.1.5 → 0.2.4 - Mend

@plaud-ai/cli 0.1.5 → 0.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +665 -82
package/package.json +2 -1

package/dist/index.js CHANGED Viewed

@@ -2,21 +2,15 @@
 // src/index.ts
 import "dotenv/config";
-import { Command as Command10 } from "commander";
+import { Command as Command13 } from "commander";
 // src/commands/login.ts
 import { Command } from "commander";
-import { createServer } from "http";
+import { createServer as createServer2 } from "net";
 import open from "open";
 import chalk2 from "chalk";
 import ora from "ora";
-// src/config.ts
-import { readFileSync, existsSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { parse } from "yaml";
 // ../shared/dist/oauth.js
 import { randomBytes, createHash } from "crypto";
@@ -61,6 +55,9 @@ function generateCodeVerifier() {
 function generateCodeChallenge(verifier) {
   return createHash("sha256").update(verifier).digest("base64url");
 }
+function generateState() {
+  return randomBytes(16).toString("base64url");
+}
 var OAuth = class {
   config;
   tokenStore;
@@ -77,17 +74,19 @@ var OAuth = class {
   createAuthorizationRequest() {
     const codeVerifier = generateCodeVerifier();
     const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = generateState();
     const params = new URLSearchParams({
       client_id: this.config.clientId,
       redirect_uri: this.config.redirectUri,
       response_type: "code",
       code_challenge: codeChallenge,
-      code_challenge_method: "S256"
+      code_challenge_method: "S256",
+      state
     });
     return {
       url: `${this.authorizationUrl}?${params.toString()}`,
       codeVerifier,
-      state: ""
+      state
     };
   }
   /**
@@ -96,7 +95,7 @@ var OAuth = class {
   getAuthorizationUrl() {
     return this.createAuthorizationRequest().url;
   }
-  async exchangeCode(code, codeVerifier) {
+  async exchangeCode(code, codeVerifier, state) {
     const basicAuth = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString("base64");
     const body = {
       code,
@@ -105,6 +104,9 @@ var OAuth = class {
     if (codeVerifier) {
       body.code_verifier = codeVerifier;
     }
+    if (state) {
+      body.state = state;
+    }
     const res = await fetch(this.tokenUrl, {
       method: "POST",
       headers: {
@@ -182,16 +184,18 @@ var PlaudClient = class {
   oauth;
   apiBase;
   extraHeaders;
+  staticToken;
   constructor(config) {
     this.oauth = new OAuth(config);
     this.apiBase = config.apiBase ?? DEFAULT_API_BASE;
     this.extraHeaders = config.extraHeaders ?? {};
+    this.staticToken = config.staticToken;
   }
   get auth() {
     return this.oauth;
   }
   async request(path, init) {
-    const token = await this.oauth.getAccessToken();
+    const token = this.staticToken ?? await this.oauth.getAccessToken();
     if (!token) {
       throw new Error("Not authenticated. Please login first.");
     }
@@ -238,7 +242,128 @@ var PlaudClient = class {
   }
 };
+// ../shared/dist/oauth-callback-server.js
+import { createServer } from "http";
+var SUCCESS_HTML = '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Authorization successful!</h1><p>You can close this tab.</p></body></html>';
+var NEUTRAL_HTML = '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Continue authorization in the original window.</h1><p>This page can be closed.</p></body></html>';
+function errorHtml(message) {
+  const escaped = message.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+  return '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Authorization failed</h1><pre style="white-space:pre-wrap;">' + escaped + "</pre></body></html>";
+}
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+function runOAuthCallback(opts) {
+  const { port, expectedState, exchangeCode, timeoutMs = 12e4, onListening, postSuccessDelayMs = 1500 } = opts;
+  return new Promise((resolve) => {
+    let settled = false;
+    let exchangeStarted = false;
+    let exchangeSucceeded = false;
+    let timeoutId = null;
+    let closeTimeoutId = null;
+    const server = createServer((req, res) => {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
+      if (reqUrl.pathname !== "/auth/callback") {
+        res.writeHead(404, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      const params = reqUrl.searchParams;
+      const error = params.get("error");
+      const state = params.get("state");
+      const code = params.get("code");
+      if (error) {
+        const desc = params.get("error_description") ?? error;
+        res.writeHead(400, { "Content-Type": "text/html", ...CORS_HEADERS });
+        res.end(errorHtml(`Authorization denied: ${desc}`));
+        finalize({ status: "denied", error: new Error(desc) });
+        return;
+      }
+      if (!state || state !== expectedState) {
+        respondNeutral(res);
+        return;
+      }
+      if (exchangeSucceeded) {
+        respondSuccess(res);
+        return;
+      }
+      if (!code) {
+        respondNeutral(res);
+        return;
+      }
+      if (exchangeStarted) {
+        respondNeutral(res);
+        return;
+      }
+      exchangeStarted = true;
+      exchangeCode(code).then(() => {
+        exchangeSucceeded = true;
+        respondSuccess(res);
+        finalize({ status: "success" });
+      }, (err) => {
+        const e = err instanceof Error ? err : new Error(String(err));
+        res.writeHead(500, { "Content-Type": "text/html", ...CORS_HEADERS });
+        res.end(errorHtml(e.message));
+        finalize({ status: "exchange-failed", error: e });
+      });
+    });
+    server.on("error", (err) => {
+      if (settled)
+        return;
+      const message = err.code === "EADDRINUSE" ? `port ${port} is in use \u2014 another \`plaud login\` may still be running. Wait a few seconds and retry.` : `callback server error: ${err.message}`;
+      finalize({ status: "listen-failed", error: new Error(message) }, true);
+    });
+    timeoutId = setTimeout(() => {
+      finalize({ status: "timeout" }, true);
+    }, timeoutMs);
+    server.listen(port, () => {
+      onListening?.();
+    });
+    function respondSuccess(res) {
+      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
+      res.end(SUCCESS_HTML);
+    }
+    function respondNeutral(res) {
+      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
+      res.end(NEUTRAL_HTML);
+    }
+    function finalize(result, immediate = false) {
+      if (settled)
+        return;
+      settled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      const close = () => {
+        try {
+          server.closeAllConnections?.();
+        } catch {
+        }
+        server.close(() => resolve(result));
+      };
+      if (immediate || result.status !== "success") {
+        close();
+      } else {
+        closeTimeoutId = setTimeout(close, postSuccessDelayMs);
+        closeTimeoutId.unref?.();
+      }
+    }
+  });
+}
 // src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { parse } from "yaml";
 function loadCliConfig() {
   const configPath = join2(homedir2(), ".plaud", "cli.yaml");
   if (!existsSync(configPath)) return {};
@@ -306,66 +431,99 @@ function isTimeoutError(err) {
 }
 // src/commands/login.ts
-var CORS_HEADERS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, OPTIONS",
-  "Access-Control-Allow-Headers": "*"
-};
+var CALLBACK_PORT = 8199;
+var LOGIN_TIMEOUT_MS = 12e4;
+function probeCallbackPort(port) {
+  return new Promise((resolve) => {
+    const probe = createServer2();
+    probe.once("error", (err) => resolve(err));
+    probe.listen(port, "127.0.0.1", () => {
+      probe.close(() => resolve(null));
+    });
+  });
+}
 var loginCommand = new Command("login").description("Authenticate with Plaud via OAuth").action(async () => {
   const client2 = getClient();
   try {
     const token = await client2.auth.getAccessToken();
     if (token) {
-      console.log(chalk2.yellow("Already logged in. Run `plaud logout` first to switch accounts."));
-      return;
+      try {
+        await client2.getCurrentUser();
+        console.log(chalk2.yellow("Already logged in. Run `plaud logout` first to switch accounts."));
+        return;
+      } catch (err) {
+        if (isAuthError(err)) {
+          console.log(chalk2.yellow("Existing credentials are no longer valid. Starting fresh login..."));
+          await client2.auth.logout();
+        } else if (isNetworkError(err)) {
+          printError("UNREACHABLE", "Cannot reach Plaud servers to verify login state. Check your network.", err);
+          process.exit(ExitCode.UNREACHABLE);
+        } else if (isTimeoutError(err)) {
+          printError("TIMEOUT", "Login state check timed out.");
+          process.exit(ExitCode.TIMEOUT);
+        } else {
+          printError("FETCH_FAILED", "Failed to verify login state.", err);
+          process.exit(ExitCode.ERROR);
+        }
+      }
     }
   } catch {
     await client2.auth.logout();
   }
-  const { url, codeVerifier } = client2.auth.createAuthorizationRequest();
-  const spinner = ora("Waiting for browser authentication...").start();
-  const server = createServer(async (req, res) => {
-    if (req.method === "OPTIONS") {
-      res.writeHead(204, CORS_HEADERS);
-      res.end();
-      return;
-    }
-    const reqUrl = new URL(req.url, `http://localhost:8199`);
-    if (reqUrl.pathname !== "/auth/callback") {
-      res.writeHead(404, CORS_HEADERS);
-      res.end();
-      return;
-    }
-    const code = reqUrl.searchParams.get("code");
-    if (!code) {
-      res.writeHead(400, CORS_HEADERS);
-      res.end("Invalid callback: missing code");
-      spinner.stop();
-      printError("AUTH_FAILED", "Authentication failed: missing authorization code");
-      server.close(() => process.exit(ExitCode.AUTH_FAILED));
-      return;
-    }
-    try {
-      await client2.auth.exchangeCode(code, codeVerifier);
-      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
-      res.end("<h1>Authentication successful!</h1><p>You can close this tab.</p>");
-      spinner.succeed("Logged in successfully!");
-    } catch (err) {
-      res.writeHead(500, CORS_HEADERS);
-      res.end("Token exchange failed");
-      spinner.stop();
-      printError("AUTH_FAILED", "Authentication failed.", err);
-    } finally {
-      server.closeAllConnections();
-      server.close(() => process.exit(0));
+  const portError = await probeCallbackPort(CALLBACK_PORT);
+  if (portError) {
+    if (portError.code === "EADDRINUSE") {
+      printError(
+        "PORT_IN_USE",
+        `OAuth callback port ${CALLBACK_PORT} is already in use. Another Plaud process is likely holding it (e.g. \`plaud-mcp http\` or another \`plaud login\`). The OAuth redirect_uri is fixed to localhost:${CALLBACK_PORT}, so login cannot proceed until the port is free.`
+      );
+      console.error(chalk2.gray(`  Find the process:  lsof -nP -iTCP:${CALLBACK_PORT} -sTCP:LISTEN`));
+      console.error(chalk2.gray(`  Then stop it and retry \`plaud login\`.`));
+    } else {
+      printError("PORT_PROBE_FAILED", `Could not bind callback port ${CALLBACK_PORT}.`, portError);
     }
-  });
-  server.listen(8199, () => {
-    console.log(chalk2.blue(`
+    process.exit(ExitCode.ERROR);
+  }
+  const { url, codeVerifier, state } = client2.auth.createAuthorizationRequest();
+  const spinner = ora("Waiting for browser authentication...").start();
+  const result = await runOAuthCallback({
+    port: CALLBACK_PORT,
+    expectedState: state,
+    timeoutMs: LOGIN_TIMEOUT_MS,
+    exchangeCode: async (code) => {
+      await client2.auth.exchangeCode(code, codeVerifier, state);
+    },
+    onListening: () => {
+      console.log(chalk2.blue(`
 Opening browser for authentication...
 `));
-    open(url);
+      open(url).catch(() => {
+        console.log(chalk2.yellow(`Could not open browser. Open this URL manually:
+  ${url}`));
+      });
+    }
   });
+  switch (result.status) {
+    case "success":
+      spinner.succeed("Logged in successfully!");
+      process.exit(ExitCode.OK);
+    case "timeout":
+      spinner.stop();
+      printError("AUTH_FAILED", "Authentication timed out after 2 minutes.");
+      process.exit(ExitCode.TIMEOUT);
+    case "denied":
+      spinner.stop();
+      printError("AUTH_FAILED", "Authentication was denied.", result.error);
+      process.exit(ExitCode.AUTH_FAILED);
+    case "exchange-failed":
+      spinner.stop();
+      printError("AUTH_FAILED", "Authentication failed.", result.error);
+      process.exit(ExitCode.AUTH_FAILED);
+    case "listen-failed":
+      spinner.stop();
+      printError("AUTH_FAILED", "Could not start callback server.", result.error);
+      process.exit(ExitCode.ERROR);
+  }
 });
 // src/commands/logout.ts
@@ -424,6 +582,42 @@ var meCommand = new Command3("me").description("Show current authenticated user
 import { Command as Command4 } from "commander";
 import chalk5 from "chalk";
 import ora3 from "ora";
+// src/format.ts
+function formatDuration(ms) {
+  if (!ms || ms < 0) return "-";
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+function formatDate(iso) {
+  if (!iso) return "-";
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function formatTime(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+// src/commands/list-files.ts
+var ID_WIDTH = 34;
+var NAME_WIDTH = 36;
+var DATE_WIDTH = 12;
+function truncate(s, width) {
+  if (s.length <= width) return s.padEnd(width);
+  return s.slice(0, width - 1) + "\u2026";
+}
 var listFilesCommand = new Command4("files").description("List your Plaud recordings").option("-p, --page <number>", "Page number", "1").option("-s, --page-size <number>", "Page size", "20").action(async (opts) => {
   const page = parseInt(opts.page);
   const pageSize = parseInt(opts.pageSize);
@@ -443,10 +637,15 @@ var listFilesCommand = new Command4("files").description("List your Plaud record
     console.log(chalk5.bold(`
 Files on this page: ${result.data.length}
 `));
+    const header = `  ${chalk5.bold("ID".padEnd(ID_WIDTH))}  ${chalk5.bold("NAME".padEnd(NAME_WIDTH))}  ${chalk5.bold("DATE".padEnd(DATE_WIDTH))}  ${chalk5.bold("DURATION")}`;
+    console.log(header);
+    console.log(chalk5.gray("  " + "\u2500".repeat(ID_WIDTH + NAME_WIDTH + DATE_WIDTH + 16)));
     for (const file of result.data) {
-      const date = new Date(file.created_at).toLocaleDateString();
-      const duration = file.duration ? `${Math.round(file.duration / 60)}min` : "";
-      console.log(`  ${chalk5.cyan(file.id)}  ${file.name}  ${chalk5.gray(date)}  ${chalk5.gray(duration)}`);
+      const id = chalk5.cyan(file.id.padEnd(ID_WIDTH));
+      const name = truncate(file.name ?? "", NAME_WIDTH);
+      const date = chalk5.gray(formatDate(file.created_at).padEnd(DATE_WIDTH));
+      const duration = chalk5.gray(formatDuration(file.duration));
+      console.log(`  ${id}  ${name}  ${date}  ${duration}`);
     }
     console.log(chalk5.gray(`
 Page ${result.page}`));
@@ -473,12 +672,6 @@ Page ${result.page}`));
 import { Command as Command5 } from "commander";
 import chalk6 from "chalk";
 import ora4 from "ora";
-function formatDuration(ms) {
-  const totalSeconds = Math.floor(ms / 1e3);
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return minutes > 0 ? `${minutes}min ${seconds}sec` : `${seconds}sec`;
-}
 var getFileCommand = new Command5("file").description("Get details of a specific Plaud recording").argument("<file_id>", "The file ID to retrieve").action(async (fileId) => {
   const client2 = getClient();
   const spinner = ora4("Fetching file...").start();
@@ -494,7 +687,7 @@ var getFileCommand = new Command5("file").description("Get details of a specific
     console.log(`  ${chalk6.cyan("name")}:         ${file.name}`);
     console.log(`  ${chalk6.cyan("created_at")}:   ${file.created_at}`);
     console.log(`  ${chalk6.cyan("start_at")}:     ${file.start_at ?? "-"}`);
-    console.log(`  ${chalk6.cyan("duration")}:     ${file.duration ? formatDuration(file.duration) : "-"}`);
+    console.log(`  ${chalk6.cyan("duration")}:     ${formatDuration(file.duration)}`);
     console.log(`  ${chalk6.cyan("serial_number")}: ${file.serial_number ?? "-"}`);
     console.log(`  ${chalk6.cyan("audio")}:        ${file.presigned_url ? chalk6.green("available") : chalk6.gray("unavailable")}`);
     console.log(`  ${chalk6.cyan("transcript")}:   ${hasTranscript ? chalk6.green("available") : chalk6.gray("unavailable")}`);
@@ -565,12 +758,6 @@ import { Command as Command7 } from "commander";
 import chalk8 from "chalk";
 import ora6 from "ora";
 import { writeFile as writeFile2 } from "fs/promises";
-function formatTime(ms) {
-  const totalSeconds = Math.floor(ms / 1e3);
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-}
 var transcriptCommand = new Command7("transcript").description("Get the transcript for a Plaud recording").argument("<file_id>", "The file ID to retrieve transcript for").option("-o, --output <file>", "Save transcript to a file").action(async (fileId, opts) => {
   const client2 = getClient();
   const spinner = ora6("Fetching transcript...").start();
@@ -667,16 +854,408 @@ Summary: ${file.name}
 });
 // src/commands/version.ts
+import { Command as Command10 } from "commander";
+import chalk11 from "chalk";
+import { readFile as readFile2, writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join3, dirname } from "path";
+// src/commands/update.ts
 import { Command as Command9 } from "commander";
-var versionCommand = new Command9("version").description("Show CLI version information").action(() => {
-  console.log(`plaud ${"0.1.5"}`);
-  if ("8ad7434") console.log(`commit  ${"8ad7434"}`);
-  if ("2026-04-16T09:19:58.868Z") console.log(`built   ${"2026-04-16T09:19:58.868Z"}`);
+import chalk10 from "chalk";
+import ora8 from "ora";
+var PKG_NAME = "@plaud-ai/cli";
+var REGISTRY = "https://registry.npmjs.org";
+async function fetchLatestVersion(timeoutMs = 5e3) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${REGISTRY}/${encodeURIComponent(PKG_NAME)}/latest`, { signal: ctrl.signal });
+    if (!res.ok) return null;
+    const json = await res.json();
+    return json.version ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+function isNewer(current, latest) {
+  const c = current.split(".").map(Number);
+  const l = latest.split(".").map(Number);
+  for (let i = 0; i < Math.max(c.length, l.length); i++) {
+    const cv = c[i] ?? 0;
+    const lv = l[i] ?? 0;
+    if (lv > cv) return true;
+    if (lv < cv) return false;
+  }
+  return false;
+}
+var updateCommand = new Command9("update").description("Check npm for the latest Plaud CLI and print the upgrade command").action(async () => {
+  const current = "0.2.4";
+  const spinner = ora8("Checking npm for latest version...").start();
+  const latest = await fetchLatestVersion();
+  spinner.stop();
+  if (!latest) {
+    printError("UNREACHABLE", "Could not reach npm registry to check for updates.");
+    process.exit(ExitCode.UNREACHABLE);
+  }
+  if (!isNewer(current, latest)) {
+    console.log(chalk10.green(`You're on the latest version (${current}).`));
+    return;
+  }
+  console.log(chalk10.yellow(`A newer version is available: ${current} \u2192 ${latest}`));
+  console.log();
+  console.log("Run this command to upgrade:");
+  console.log();
+  console.log(chalk10.bold(`  npm install -g ${PKG_NAME}@latest`));
+  console.log();
+});
+// src/commands/version.ts
+var CACHE_PATH = join3(homedir3(), ".plaud", "version-check.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+async function readCache() {
+  try {
+    const raw = await readFile2(CACHE_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.checked_at !== "number" || typeof parsed.latest !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(entry) {
+  try {
+    await mkdir2(dirname(CACHE_PATH), { recursive: true });
+    await writeFile4(CACHE_PATH, JSON.stringify(entry), "utf-8");
+  } catch {
+  }
+}
+async function checkForUpdate(current) {
+  const cached = await readCache();
+  const now = Date.now();
+  let latest = null;
+  if (cached && now - cached.checked_at < CACHE_TTL_MS) {
+    latest = cached.latest;
+  } else {
+    latest = await fetchLatestVersion(2e3);
+    if (latest) await writeCache({ checked_at: now, latest });
+  }
+  if (!latest) return null;
+  return isNewer(current, latest) ? latest : null;
+}
+var versionCommand = new Command10("version").description("Show CLI version information").action(async () => {
+  const current = "0.2.4";
+  console.log(`plaud ${current}`);
+  if ("4b84277") console.log(`commit  ${"4b84277"}`);
+  if ("2026-05-07T11:34:37.562Z") console.log(`built   ${"2026-05-07T11:34:37.562Z"}`);
+  if (current === "unknown") return;
+  const newer = await checkForUpdate(current);
+  if (newer) {
+    console.log();
+    console.log(chalk11.yellow(`A newer version is available: ${current} \u2192 ${newer}`));
+    console.log(chalk11.gray(`Run \`plaud update\` for upgrade instructions.`));
+  }
+});
+// src/commands/search.ts
+import { Command as Command11 } from "commander";
+import chalk12 from "chalk";
+import ora9 from "ora";
+var MAX_PAGES = 5;
+var PAGE_SIZE = 100;
+function parseDate(s) {
+  if (!s) return null;
+  const d = new Date(s);
+  return Number.isNaN(d.getTime()) ? null : d.getTime();
+}
+var searchCommand = new Command11("search").description("Search recordings by name keyword (client-side, scans up to 500 most recent recordings)").argument("<keyword>", "Case-insensitive substring to match against recording names").option("--from <date>", "Start date inclusive, YYYY-MM-DD").option("--to <date>", "End date inclusive, YYYY-MM-DD").option("--max <n>", "Maximum matches to display", "50").action(async (keyword, opts) => {
+  const max = parseInt(opts.max);
+  if (isNaN(max) || max < 1 || max > 500) {
+    printError("INVALID_ARGS", "--max must be a number between 1 and 500");
+    process.exit(ExitCode.ERROR);
+  }
+  const from = parseDate(opts.from);
+  const toRaw = parseDate(opts.to);
+  const to = toRaw !== null ? toRaw + 24 * 60 * 60 * 1e3 - 1 : null;
+  if (opts.from && from === null) {
+    printError("INVALID_ARGS", `Invalid --from date: ${opts.from}`);
+    process.exit(ExitCode.ERROR);
+  }
+  if (opts.to && toRaw === null) {
+    printError("INVALID_ARGS", `Invalid --to date: ${opts.to}`);
+    process.exit(ExitCode.ERROR);
+  }
+  const client2 = getClient();
+  const spinner = ora9(`Searching for "${keyword}"...`).start();
+  const q = keyword.toLowerCase();
+  try {
+    const matches = [];
+    let scanned = 0;
+    let truncated = false;
+    for (let page = 1; page <= MAX_PAGES; page++) {
+      spinner.text = `Searching for "${keyword}"... (page ${page})`;
+      const result = await client2.listFiles(page, PAGE_SIZE);
+      scanned += result.data.length;
+      for (const file of result.data) {
+        if (!(file.name ?? "").toLowerCase().includes(q)) continue;
+        if (from !== null || to !== null) {
+          const created = parseDate(file.created_at);
+          if (created === null) continue;
+          if (from !== null && created < from) continue;
+          if (to !== null && created > to) continue;
+        }
+        matches.push(file);
+        if (matches.length >= max) break;
+      }
+      if (matches.length >= max) break;
+      if (result.data.length < PAGE_SIZE) break;
+      if (page === MAX_PAGES) truncated = true;
+    }
+    spinner.stop();
+    if (matches.length === 0) {
+      console.log(chalk12.yellow(`No recordings matched "${keyword}" in ${scanned} scanned.`));
+      if (truncated) {
+        console.log(chalk12.gray(`(Scanned first ${MAX_PAGES * PAGE_SIZE}; narrow the window with --from/--to if your target is older.)`));
+      }
+      return;
+    }
+    console.log(chalk12.bold(`
+Matched ${matches.length}${truncated ? `+` : ""} of ${scanned} scanned
+`));
+    for (const file of matches) {
+      const id = chalk12.cyan(file.id);
+      const date = chalk12.gray(formatDate(file.created_at));
+      const duration = chalk12.gray(formatDuration(file.duration));
+      console.log(`  ${id}  ${file.name ?? ""}  ${date}  ${duration}`);
+    }
+    if (truncated) {
+      console.log(chalk12.gray(`
+(Truncated at ${MAX_PAGES} pages; results beyond the most recent ${MAX_PAGES * PAGE_SIZE} not scanned.)`));
+    }
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    if (isAuthError(err)) {
+      printError("AUTH_FAILED", "Token invalid or expired. Run `plaud login`.");
+      process.exit(ExitCode.AUTH_FAILED);
+    }
+    if (isNetworkError(err)) {
+      printError("UNREACHABLE", "Cannot reach Plaud servers. Check your network.", err);
+      process.exit(ExitCode.UNREACHABLE);
+    }
+    if (isTimeoutError(err)) {
+      printError("TIMEOUT", "Request timed out.");
+      process.exit(ExitCode.TIMEOUT);
+    }
+    printError("FETCH_FAILED", "Failed to search files.", err);
+    process.exit(ExitCode.ERROR);
+  }
+});
+// src/commands/recent.ts
+import { Command as Command12 } from "commander";
+import chalk13 from "chalk";
+import ora10 from "ora";
+var MAX_PAGES2 = 3;
+var PAGE_SIZE2 = 100;
+var recentCommand = new Command12("recent").description("List recordings from the last N days (default 7)").option("-d, --days <n>", "Number of days to include", "7").action(async (opts) => {
+  const days = parseInt(opts.days);
+  if (isNaN(days) || days < 1 || days > 365) {
+    printError("INVALID_ARGS", "--days must be a number between 1 and 365");
+    process.exit(ExitCode.ERROR);
+  }
+  const from = Date.now() - days * 24 * 60 * 60 * 1e3;
+  const client2 = getClient();
+  const spinner = ora10(`Fetching recordings from the last ${days} days...`).start();
+  try {
+    const matches = [];
+    for (let page = 1; page <= MAX_PAGES2; page++) {
+      const result = await client2.listFiles(page, PAGE_SIZE2);
+      let allOlder = true;
+      let hasValidTimestamps = false;
+      for (const file of result.data) {
+        const created = new Date(file.created_at).getTime();
+        if (Number.isNaN(created)) continue;
+        hasValidTimestamps = true;
+        if (created >= from) {
+          matches.push(file);
+          allOlder = false;
+        }
+      }
+      if (hasValidTimestamps && allOlder && result.data.length > 0) break;
+      if (result.data.length < PAGE_SIZE2) break;
+    }
+    spinner.stop();
+    if (matches.length === 0) {
+      console.log(chalk13.yellow(`No recordings in the last ${days} days.`));
+      return;
+    }
+    console.log(chalk13.bold(`
+Recordings in the last ${days} days: ${matches.length}
+`));
+    for (const file of matches) {
+      const id = chalk13.cyan(file.id);
+      const date = chalk13.gray(formatDate(file.created_at));
+      const duration = chalk13.gray(formatDuration(file.duration));
+      console.log(`  ${id}  ${file.name ?? ""}  ${date}  ${duration}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    if (isAuthError(err)) {
+      printError("AUTH_FAILED", "Token invalid or expired. Run `plaud login`.");
+      process.exit(ExitCode.AUTH_FAILED);
+    }
+    if (isNetworkError(err)) {
+      printError("UNREACHABLE", "Cannot reach Plaud servers. Check your network.", err);
+      process.exit(ExitCode.UNREACHABLE);
+    }
+    if (isTimeoutError(err)) {
+      printError("TIMEOUT", "Request timed out.");
+      process.exit(ExitCode.TIMEOUT);
+    }
+    printError("FETCH_FAILED", "Failed to fetch recent files.", err);
+    process.exit(ExitCode.ERROR);
+  }
+});
+var todayCommand = new Command12("today").description("List recordings created today").action(async () => {
+  const start = /* @__PURE__ */ new Date();
+  start.setHours(0, 0, 0, 0);
+  const startMs = start.getTime();
+  const client2 = getClient();
+  const spinner = ora10("Fetching today's recordings...").start();
+  try {
+    const result = await client2.listFiles(1, 50);
+    spinner.stop();
+    const matches = result.data.filter((f) => {
+      const t = new Date(f.created_at).getTime();
+      return !Number.isNaN(t) && t >= startMs;
+    });
+    if (matches.length === 0) {
+      console.log(chalk13.yellow("No recordings created today."));
+      return;
+    }
+    console.log(chalk13.bold(`
+Today's recordings: ${matches.length}
+`));
+    for (const file of matches) {
+      const id = chalk13.cyan(file.id);
+      const date = chalk13.gray(formatDate(file.created_at));
+      const duration = chalk13.gray(formatDuration(file.duration));
+      console.log(`  ${id}  ${file.name ?? ""}  ${date}  ${duration}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    if (isAuthError(err)) {
+      printError("AUTH_FAILED", "Token invalid or expired. Run `plaud login`.");
+      process.exit(ExitCode.AUTH_FAILED);
+    }
+    if (isNetworkError(err)) {
+      printError("UNREACHABLE", "Cannot reach Plaud servers. Check your network.", err);
+      process.exit(ExitCode.UNREACHABLE);
+    }
+    if (isTimeoutError(err)) {
+      printError("TIMEOUT", "Request timed out.");
+      process.exit(ExitCode.TIMEOUT);
+    }
+    printError("FETCH_FAILED", "Failed to fetch today's files.", err);
+    process.exit(ExitCode.ERROR);
+  }
 });
+// src/commands/wizard.ts
+import chalk14 from "chalk";
+import { select, input, confirm } from "@inquirer/prompts";
+import { spawnSync } from "child_process";
+function runSelf(args) {
+  const result = spawnSync(process.execPath, [process.argv[1] ?? "", ...args], {
+    stdio: "inherit"
+  });
+  return result.status ?? 0;
+}
+async function ensureLoggedIn() {
+  const client2 = getClient();
+  try {
+    const token = await client2.auth.getAccessToken();
+    if (token) return true;
+  } catch {
+  }
+  const go = await confirm({ message: "You are not logged in. Open the browser to log in now?", default: true });
+  if (!go) return false;
+  const code = runSelf(["login"]);
+  return code === 0;
+}
+async function runWizard() {
+  console.log(chalk14.bold("\nWelcome to Plaud\n"));
+  try {
+    const ok = await ensureLoggedIn();
+    if (!ok) {
+      console.log(chalk14.gray("Exiting. Run `plaud login` when ready."));
+      return;
+    }
+    const action = await select({
+      message: "What do you want to do?",
+      choices: [
+        { name: "Browse my recordings", value: "browse" },
+        { name: "Search by name", value: "search" },
+        { name: "Recent recordings (7 days)", value: "recent" },
+        { name: "Today's recordings", value: "today" },
+        { name: "Read a transcript", value: "transcript" },
+        { name: "Read an AI summary", value: "summary" },
+        { name: "Who am I logged in as", value: "me" },
+        { name: "Log out", value: "logout" },
+        { name: "Quit", value: "quit" }
+      ]
+    });
+    switch (action) {
+      case "browse":
+        runSelf(["files"]);
+        break;
+      case "search": {
+        const keyword = await input({ message: "Keyword to search for:", validate: (v) => v.trim().length > 0 || "Enter a keyword" });
+        runSelf(["search", keyword.trim()]);
+        break;
+      }
+      case "recent":
+        runSelf(["recent"]);
+        break;
+      case "today":
+        runSelf(["today"]);
+        break;
+      case "transcript": {
+        const id = await input({ message: "File ID:", validate: (v) => v.trim().length > 0 || "Enter a file ID" });
+        runSelf(["transcript", id.trim()]);
+        break;
+      }
+      case "summary": {
+        const id = await input({ message: "File ID:", validate: (v) => v.trim().length > 0 || "Enter a file ID" });
+        runSelf(["summary", id.trim()]);
+        break;
+      }
+      case "me":
+        runSelf(["me"]);
+        break;
+      case "logout":
+        runSelf(["logout"]);
+        break;
+      case "quit":
+        return;
+    }
+  } catch (err) {
+    const name = err?.name;
+    if (name === "ExitPromptError") return;
+    throw err;
+  }
+}
 // src/index.ts
-var program = new Command10();
-program.name("plaud").description("Plaud CLI - manage your Plaud recordings");
+var program = new Command13();
+program.name("plaud").description("Plaud CLI - manage your Plaud recordings").action(async () => {
+  await runWizard();
+});
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(meCommand);
@@ -685,5 +1264,9 @@ program.addCommand(getFileCommand);
 program.addCommand(audioCommand);
 program.addCommand(transcriptCommand);
 program.addCommand(summaryCommand);
+program.addCommand(searchCommand);
+program.addCommand(recentCommand);
+program.addCommand(todayCommand);
+program.addCommand(updateCommand);
 program.addCommand(versionCommand);
-program.parse();
+program.parseAsync();

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@plaud-ai/cli",
-  "version": "0.1.5",
+  "version": "0.2.4",
   "type": "module",
   "bin": {
     "plaud": "dist/index.js"
@@ -14,6 +14,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
+    "@inquirer/prompts": "^7.2.0",
     "chalk": "^5.4.0",
     "commander": "^13.0.0",
     "dotenv": "^17.3.1",