@readwise/cli 0.3.0

package/src/config.ts

@@ -0,0 +1,64 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface ToolDef {
+  name: string;
+  description?: string;
+  inputSchema: {
+    type: string;
+    properties?: Record<string, SchemaProperty>;
+    required?: string[];
+    $defs?: Record<string, SchemaProperty>;
+  };
+}
+
+export interface SchemaProperty {
+  type?: string;
+  format?: string;
+  description?: string;
+  enum?: string[];
+  items?: SchemaProperty;
+  default?: unknown;
+  anyOf?: SchemaProperty[];
+  $ref?: string;
+  properties?: Record<string, SchemaProperty>;
+  required?: string[];
+}
+
+export interface Config {
+  client_id?: string;
+  client_secret?: string;
+  access_token?: string;
+  refresh_token?: string;
+  expires_at?: number;
+  auth_type?: "oauth" | "token";
+  tools_cache?: {
+    tools: ToolDef[];
+    fetched_at: number;
+  };
+}
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+export function getConfigPath(): string {
+  return join(homedir(), ".readwise-cli.json");
+}
+
+export async function loadConfig(): Promise<Config> {
+  try {
+    const data = await readFile(getConfigPath(), "utf-8");
+    return JSON.parse(data) as Config;
+  } catch {
+    return {};
+  }
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  await writeFile(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+export function isCacheValid(config: Config): boolean {
+  if (!config.tools_cache) return false;
+  return Date.now() - config.tools_cache.fetched_at < CACHE_TTL_MS;
+}

package/src/index.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import { login, loginWithToken, ensureValidToken } from "./auth.js";
+import { getTools } from "./mcp.js";
+import { registerTools } from "./commands.js";
+import { loadConfig } from "./config.js";
+import { VERSION } from "./version.js";
+
+function readHiddenInput(prompt: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (!process.stdin.isTTY) {
+      // Piped input (e.g. echo $TOKEN | readwise login-with-token)
+      const rl = createInterface({ input: process.stdin });
+      rl.once("line", (line) => { resolve(line.trim()); rl.close(); });
+      rl.once("close", () => resolve(""));
+      return;
+    }
+
+    process.stdout.write(prompt);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+
+    let input = "";
+    const onData = (ch: string) => {
+      if (ch === "\r" || ch === "\n" || ch === "\u0004") {
+        process.stdin.removeListener("data", onData);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write("\n");
+        resolve(input);
+      } else if (ch === "\u0003") {
+        process.stdin.removeListener("data", onData);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write("\n");
+        reject(new Error("Aborted"));
+      } else if (ch === "\u007f" || ch === "\b") {
+        input = input.slice(0, -1);
+      } else {
+        input += ch;
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+const program = new Command();
+
+program
+  .name("readwise")
+  .version(VERSION)
+  .description("Command-line interface for Readwise and Reader")
+  .option("--json", "Output raw JSON (machine-readable)")
+  .option("--refresh", "Force-refresh the tool cache");
+
+program
+  .command("login")
+  .description("Authenticate with Readwise via OAuth (opens browser)")
+  .action(async () => {
+    try {
+      await login();
+    } catch (err) {
+      process.stderr.write(`\x1b[31m${(err as Error).message}\x1b[0m\n`);
+      process.exitCode = 1;
+    }
+  });
+
+program
+  .command("login-with-token [token]")
+  .description("Authenticate with a Readwise access token (for scripts/CI)")
+  .action(async (token?: string) => {
+    try {
+      if (!token) {
+        console.log("Get your token from https://readwise.io/access_token");
+        token = await readHiddenInput("Enter token: ");
+        if (!token) {
+          process.stderr.write("\x1b[31mNo token provided.\x1b[0m\n");
+          process.exitCode = 1;
+          return;
+        }
+      }
+      await loginWithToken(token);
+    } catch (err) {
+      process.stderr.write(`\x1b[31m${(err as Error).message}\x1b[0m\n`);
+      process.exitCode = 1;
+    }
+  });
+
+async function main() {
+  const config = await loadConfig();
+  const forceRefresh = process.argv.includes("--refresh");
+  const positionalArgs = process.argv.slice(2).filter((a) => !a.startsWith("--"));
+  const hasSubcommand = positionalArgs.length > 0;
+
+  // If no subcommand, TTY, and authenticated → launch TUI
+  if (!hasSubcommand && process.stdout.isTTY && config.access_token) {
+    try {
+      const { token, authType } = await ensureValidToken();
+      const tools = await getTools(token, authType, forceRefresh);
+      const { startTui } = await import("./tui/index.js");
+      await startTui(tools, token, authType);
+      return;
+    } catch (err) {
+      process.stderr.write(`\x1b[33mWarning: Could not start TUI: ${(err as Error).message}\x1b[0m\n`);
+      // Fall through to Commander help
+    }
+  }
+
+  // If no subcommand and not authenticated → hint to login
+  if (!hasSubcommand && process.stdout.isTTY && !config.access_token) {
+    await program.parseAsync(process.argv);
+    console.log("\nRun `readwise login` or `readwise login-with-token` to authenticate.");
+    return;
+  }
+
+  // Try to load tools if we have a token (for subcommand mode)
+  if (config.access_token) {
+    try {
+      const { token, authType } = await ensureValidToken();
+      const tools = await getTools(token, authType, forceRefresh);
+      registerTools(program, tools);
+    } catch (err) {
+      // Don't fail — login command should still work
+      // Only warn if user is trying to run a non-login command
+      if (hasSubcommand && positionalArgs[0] !== "login" && positionalArgs[0] !== "login-with-token") {
+        process.stderr.write(`\x1b[33mWarning: Could not fetch tools: ${(err as Error).message}\x1b[0m\n`);
+      }
+    }
+  }
+
+  await program.parseAsync(process.argv);
+}
+
+main();

package/src/mcp.ts

@@ -0,0 +1,66 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { loadConfig, saveConfig, isCacheValid, type ToolDef } from "./config.js";
+import { VERSION } from "./version.js";
+
+const MCP_URL = "https://mcp2.readwise.io/mcp";
+
+function createTransport(token: string, authType: "oauth" | "token"): StreamableHTTPClientTransport {
+  const authHeader = authType === "token" ? `Token ${token}` : `Bearer ${token}`;
+  return new StreamableHTTPClientTransport(new URL(MCP_URL), {
+    requestInit: {
+      headers: {
+        Authorization: authHeader,
+      },
+    },
+  });
+}
+
+export async function getTools(token: string, authType: "oauth" | "token", forceRefresh = false): Promise<ToolDef[]> {
+  if (!forceRefresh) {
+    const config = await loadConfig();
+    if (isCacheValid(config)) {
+      return config.tools_cache!.tools;
+    }
+  }
+
+  const client = new Client({ name: "readwise", version: VERSION });
+  const transport = createTransport(token, authType);
+
+  try {
+    await client.connect(transport);
+    const result = await client.listTools();
+
+    const tools = result.tools as ToolDef[];
+
+    // Cache
+    const config = await loadConfig();
+    config.tools_cache = {
+      tools,
+      fetched_at: Date.now(),
+    };
+    await saveConfig(config);
+
+    return tools;
+  } finally {
+    await client.close();
+  }
+}
+
+export async function callTool(
+  token: string,
+  authType: "oauth" | "token",
+  name: string,
+  args: Record<string, unknown>,
+): Promise<{ content: Array<{ type: string; text?: string }>; structuredContent?: Record<string, unknown>; isError?: boolean }> {
+  const client = new Client({ name: "readwise", version: VERSION });
+  const transport = createTransport(token, authType);
+
+  try {
+    await client.connect(transport);
+    const result = await client.callTool({ name, arguments: args });
+    return result as { content: Array<{ type: string; text?: string }>; structuredContent?: Record<string, unknown>; isError?: boolean };
+  } finally {
+    await client.close();
+  }
+}