@plaud-ai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,542 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "dotenv/config";
+import { Command as Command9 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import { createServer } from "http";
+import open from "open";
+import chalk from "chalk";
+import ora from "ora";
+
+// ../shared/dist/oauth.js
+import { randomBytes, createHash } from "crypto";
+
+// ../shared/dist/token-store.js
+import { readFile, writeFile, mkdir, rm } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var TokenStore = class {
+  configDir;
+  tokenPath;
+  constructor() {
+    this.configDir = join(homedir(), ".plaud");
+    this.tokenPath = join(this.configDir, "tokens.json");
+  }
+  async save(tokenSet) {
+    await mkdir(this.configDir, { recursive: true });
+    await writeFile(this.tokenPath, JSON.stringify(tokenSet, null, 2), "utf-8");
+  }
+  async load() {
+    try {
+      const data = await readFile(this.tokenPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    try {
+      await rm(this.tokenPath);
+    } catch {
+    }
+  }
+};
+
+// ../shared/dist/oauth.js
+var DEFAULT_AUTHORIZATION_URL = "https://app.plaud.ai/platform/oauth";
+var DEFAULT_TOKEN_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token";
+var DEFAULT_REFRESH_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token/refresh";
+function generateCodeVerifier() {
+  return randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+var OAuth = class {
+  config;
+  tokenStore;
+  authorizationUrl;
+  tokenUrl;
+  refreshUrl;
+  constructor(config) {
+    this.config = config;
+    this.tokenStore = new TokenStore();
+    this.authorizationUrl = config.authorizationUrl ?? DEFAULT_AUTHORIZATION_URL;
+    this.tokenUrl = config.tokenUrl ?? DEFAULT_TOKEN_URL;
+    this.refreshUrl = config.refreshUrl ?? DEFAULT_REFRESH_URL;
+  }
+  createAuthorizationRequest() {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const params = new URLSearchParams({
+      client_id: this.config.clientId,
+      redirect_uri: this.config.redirectUri,
+      response_type: "code",
+      code_challenge: codeChallenge,
+      code_challenge_method: "S256"
+    });
+    return {
+      url: `${this.authorizationUrl}?${params.toString()}`,
+      codeVerifier,
+      state: ""
+    };
+  }
+  /**
+   * @deprecated Use createAuthorizationRequest() for PKCE flow
+   */
+  getAuthorizationUrl() {
+    return this.createAuthorizationRequest().url;
+  }
+  async exchangeCode(code, codeVerifier) {
+    const basicAuth = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString("base64");
+    const body = {
+      code,
+      redirect_uri: this.config.redirectUri
+    };
+    if (codeVerifier) {
+      body.code_verifier = codeVerifier;
+    }
+    const res = await fetch(this.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        Authorization: `Basic ${basicAuth}`,
+        ...this.config.extraHeaders
+      },
+      body: new URLSearchParams(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Token exchange failed: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    const tokenSet = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token,
+      token_type: data.token_type ?? "Bearer",
+      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+    };
+    await this.tokenStore.save(tokenSet);
+    return tokenSet;
+  }
+  async getAccessToken() {
+    const tokenSet = await this.tokenStore.load();
+    if (!tokenSet)
+      return null;
+    if (tokenSet.expires_at && Date.now() > tokenSet.expires_at - 6e4) {
+      if (tokenSet.refresh_token) {
+        const refreshed = await this.refresh(tokenSet.refresh_token);
+        return refreshed.access_token;
+      }
+      return null;
+    }
+    return tokenSet.access_token;
+  }
+  async refresh(refreshToken) {
+    const res = await fetch(this.refreshUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        ...this.config.extraHeaders
+      },
+      body: new URLSearchParams({
+        refresh_token: refreshToken
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Token refresh failed: ${res.status} ${body}`);
+    }
+    const data = await res.json();
+    const tokenSet = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token ?? refreshToken,
+      token_type: data.token_type ?? "Bearer",
+      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+    };
+    await this.tokenStore.save(tokenSet);
+    return tokenSet;
+  }
+  async logout() {
+    await this.tokenStore.clear();
+  }
+};
+
+// ../shared/dist/client.js
+var DEFAULT_API_BASE = "https://platform.plaud.ai/developer/api";
+var PlaudClient = class {
+  oauth;
+  apiBase;
+  extraHeaders;
+  constructor(config) {
+    this.oauth = new OAuth(config);
+    this.apiBase = config.apiBase ?? DEFAULT_API_BASE;
+    this.extraHeaders = config.extraHeaders ?? {};
+  }
+  get auth() {
+    return this.oauth;
+  }
+  async request(path, init) {
+    const token = await this.oauth.getAccessToken();
+    if (!token) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const url = `${this.apiBase}${path}`;
+    const method = init?.method ?? "GET";
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      ...this.extraHeaders,
+      ...init?.headers
+    };
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) {
+      const body = await res.text();
+      if (res.status === 422) {
+        try {
+          const parsed = JSON.parse(body);
+          const messages = parsed.detail.map((d) => `${d.loc.at(-1)}: ${d.msg}`).join("; ");
+          throw new Error(messages);
+        } catch (e) {
+          if (e instanceof SyntaxError)
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+          throw e;
+        }
+      }
+      throw new Error(`API error: ${res.status} ${res.statusText}`);
+    }
+    const json = await res.json();
+    return json;
+  }
+  async getCurrentUser() {
+    return this.request("/open/third-party/users/current");
+  }
+  async revokeCurrentUser() {
+    await this.request("/open/third-party/users/current/revoke", {
+      method: "POST"
+    });
+  }
+  async listFiles(page = 1, pageSize = 20) {
+    return this.request(`/open/third-party/files/?page=${page}&page_size=${pageSize}`);
+  }
+  async getFile(fileId) {
+    return this.request(`/open/third-party/files/${fileId}`);
+  }
+};
+
+// src/config.ts
+function buildExtraHeaders() {
+  const headers = {};
+  if (process.env.PLAUD_ENV) headers["x-pld-env"] = process.env.PLAUD_ENV;
+  if (process.env.PLAUD_REGION) headers["x-pld-region"] = process.env.PLAUD_REGION;
+  return headers;
+}
+var CONFIG = {
+  clientId: process.env.PLAUD_CLIENT_ID ?? "client_f9e0b214-c11f-434b-8b95-c4497d1feb81",
+  clientSecret: process.env.PLAUD_CLIENT_SECRET ?? "",
+  redirectUri: "http://localhost:8199/auth/callback",
+  apiBase: process.env.PLAUD_API_BASE,
+  authorizationUrl: process.env.PLAUD_AUTH_URL,
+  tokenUrl: process.env.PLAUD_TOKEN_URL,
+  refreshUrl: process.env.PLAUD_REFRESH_URL,
+  extraHeaders: buildExtraHeaders()
+};
+var client = null;
+function getClient() {
+  if (!client) {
+    client = new PlaudClient(CONFIG);
+  }
+  return client;
+}
+
+// src/commands/login.ts
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+var loginCommand = new Command("login").description("Authenticate with Plaud via OAuth").action(async () => {
+  const client2 = getClient();
+  const token = await client2.auth.getAccessToken();
+  if (token) {
+    console.log(chalk.yellow("Already logged in. Run `plaud logout` first to switch accounts."));
+    return;
+  }
+  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.fail("Authentication failed: missing authorization code");
+      server.close();
+      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.fail(`Authentication failed: ${err}`);
+    } finally {
+      server.closeAllConnections();
+      server.close(() => process.exit(0));
+    }
+  });
+  server.listen(8199, () => {
+    console.log(chalk.blue(`
+Opening browser for authentication...
+`));
+    open(url);
+  });
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+var logoutCommand = new Command2("logout").description("Log out and revoke authorization").action(async () => {
+  const client2 = getClient();
+  const token = await client2.auth.getAccessToken();
+  if (!token) {
+    console.log(chalk2.yellow("Not logged in."));
+    return;
+  }
+  try {
+    await client2.revokeCurrentUser();
+  } catch {
+  }
+  await client2.auth.logout();
+  console.log(chalk2.green("Logged out and revoked authorization."));
+});
+
+// src/commands/me.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora2 from "ora";
+var meCommand = new Command3("me").description("Show current authenticated user info").action(async () => {
+  const client2 = getClient();
+  const spinner = ora2("Fetching user info...").start();
+  try {
+    const user = await client2.getCurrentUser();
+    spinner.stop();
+    console.log(chalk3.bold("\nUser Info:\n"));
+    for (const [key, value] of Object.entries(user)) {
+      console.log(`  ${chalk3.cyan(key)}: ${value}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(`Failed to fetch user info: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/list-files.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora3 from "ora";
+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);
+  if (isNaN(page) || page < 1 || page > 1e3) {
+    console.error(chalk4.red("Error: --page must be a number between 1 and 1000"));
+    process.exit(1);
+  }
+  if (isNaN(pageSize) || pageSize < 10 || pageSize > 100) {
+    console.error(chalk4.red("Error: --page-size must be a number between 10 and 100"));
+    process.exit(1);
+  }
+  const client2 = getClient();
+  const spinner = ora3("Fetching files...").start();
+  try {
+    const result = await client2.listFiles(page, pageSize);
+    spinner.stop();
+    console.log(chalk4.bold(`
+Files on this page: ${result.data.length}
+`));
+    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(`  ${chalk4.cyan(file.id)}  ${file.name}  ${chalk4.gray(date)}  ${chalk4.gray(duration)}`);
+    }
+    console.log(
+      chalk4.gray(`
+Page ${result.page}`)
+    );
+  } catch (err) {
+    spinner.fail(`Failed to fetch files: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/get-file.ts
+import { Command as Command5 } from "commander";
+import chalk5 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();
+  try {
+    const file = await client2.getFile(fileId);
+    spinner.stop();
+    const sourceList = file.source_list ?? [];
+    const noteList = file.note_list ?? [];
+    const hasTranscript = sourceList.some((s) => s.data_type === "transaction");
+    const hasSummary = noteList.some((n) => n.data_type === "auto_sum_note");
+    console.log(chalk5.bold("\nFile Details:\n"));
+    console.log(`  ${chalk5.cyan("id")}:           ${file.id}`);
+    console.log(`  ${chalk5.cyan("name")}:         ${file.name}`);
+    console.log(`  ${chalk5.cyan("created_at")}:   ${file.created_at}`);
+    console.log(`  ${chalk5.cyan("start_at")}:     ${file.start_at ?? "-"}`);
+    console.log(`  ${chalk5.cyan("duration")}:     ${file.duration ? formatDuration(file.duration) : "-"}`);
+    console.log(`  ${chalk5.cyan("serial_number")}: ${file.serial_number ?? "-"}`);
+    console.log(`  ${chalk5.cyan("audio")}:        ${file.presigned_url ? chalk5.green("available") : chalk5.gray("unavailable")}`);
+    console.log(`  ${chalk5.cyan("transcript")}:   ${hasTranscript ? chalk5.green("available") : chalk5.gray("unavailable")}`);
+    console.log(`  ${chalk5.cyan("summary")}:      ${hasSummary ? chalk5.green("available") : chalk5.gray("unavailable")}`);
+    console.log();
+  } catch (err) {
+    spinner.fail(`Failed to fetch file: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/audio.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora5 from "ora";
+var audioCommand = new Command6("audio").description("Get the audio download URL for a Plaud recording").argument("<file_id>", "The file ID to retrieve audio for").action(async (fileId) => {
+  const client2 = getClient();
+  const spinner = ora5("Fetching audio URL...").start();
+  try {
+    const file = await client2.getFile(fileId);
+    spinner.stop();
+    if (!file.presigned_url) {
+      console.log(chalk6.yellow("Audio not available for this recording."));
+      return;
+    }
+    console.log(chalk6.bold("\nAudio Download URL:\n"));
+    console.log(file.presigned_url);
+    console.log(chalk6.gray("\nNote: This URL expires in 24 hours."));
+    console.log();
+  } catch (err) {
+    spinner.fail(`Failed to fetch audio URL: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/transcript.ts
+import { Command as Command7 } from "commander";
+import chalk7 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();
+  try {
+    const file = await client2.getFile(fileId);
+    spinner.stop();
+    const sourceList = file.source_list ?? [];
+    const source = sourceList.find((s) => s.data_type === "transaction");
+    if (!source) {
+      console.log(chalk7.yellow("Transcript not available for this recording."));
+      return;
+    }
+    const segments = JSON.parse(source.data_content);
+    const lines = segments.map((seg) => {
+      const time = `[${formatTime(seg.start_time)} - ${formatTime(seg.end_time)}]`;
+      const speaker = seg.speaker ? `${seg.speaker}: ` : "";
+      return `${time} ${speaker}${seg.content}`;
+    });
+    const output = lines.join("\n");
+    if (opts.output) {
+      await writeFile2(opts.output, output, "utf-8");
+      console.log(chalk7.green(`Transcript saved to ${opts.output}`));
+    } else {
+      console.log(chalk7.bold(`
+Transcript: ${file.name}
+`));
+      console.log(output);
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail(`Failed to fetch transcript: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/summary.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora7 from "ora";
+import { writeFile as writeFile3 } from "fs/promises";
+var summaryCommand = new Command8("summary").description("Get the AI summary for a Plaud recording").argument("<file_id>", "The file ID to retrieve summary for").option("-o, --output <file>", "Save summary to a file").action(async (fileId, opts) => {
+  const client2 = getClient();
+  const spinner = ora7("Fetching summary...").start();
+  try {
+    const file = await client2.getFile(fileId);
+    spinner.stop();
+    const noteList = file.note_list ?? [];
+    const note = noteList.find((n) => n.data_type === "auto_sum_note");
+    if (!note || !note.data_content) {
+      console.log(chalk8.yellow("Summary not available for this recording."));
+      return;
+    }
+    const content = note.data_content;
+    if (opts.output) {
+      await writeFile3(opts.output, content, "utf-8");
+      console.log(chalk8.green(`Summary saved to ${opts.output}`));
+    } else {
+      console.log(chalk8.bold(`
+Summary: ${file.name}
+`));
+      console.log(content);
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail(`Failed to fetch summary: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command9();
+program.name("plaud").description("Plaud CLI - manage your Plaud recordings").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(meCommand);
+program.addCommand(listFilesCommand);
+program.addCommand(getFileCommand);
+program.addCommand(audioCommand);
+program.addCommand(transcriptCommand);
+program.addCommand(summaryCommand);
+program.parse();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@plaud-ai/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "plaud": "dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "dotenv": "^17.3.1",
+    "open": "^10.2.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@plaud-ai/shared": "workspace:*",
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.0"
+  }
+}