@readwise/cli 0.3.0

package/dist/index.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import { login, loginWithToken, ensureValidToken } from "./auth.js";
+import { getTools, callTool } from "./mcp.js";
+import { registerTools, displayResult } from "./commands.js";
+import { loadConfig } from "./config.js";
+import { VERSION } from "./version.js";
+function readHiddenInput(prompt) {
+    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) => {
+            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.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) => {
+    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.message}\x1b[0m\n`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command("search <query>")
+    .description("Search across Reader documents and Readwise highlights")
+    .option("--limit <n>", "Max results per source (default: 10)")
+    .action(async (query, options) => {
+    try {
+        const { token, authType } = await ensureValidToken();
+        const limit = options.limit ? Number(options.limit) : 10;
+        const json = program.opts().json || false;
+        const [readerResult, highlightsResult] = await Promise.all([
+            callTool(token, authType, "reader_search_documents", { query, limit }),
+            callTool(token, authType, "readwise_search_highlights", { vector_search_term: query, limit }),
+        ]);
+        if (json) {
+            const combined = {};
+            for (const item of readerResult.content) {
+                if (item.type === "text" && item.text) {
+                    try {
+                        combined.reader = JSON.parse(item.text);
+                    }
+                    catch {
+                        combined.reader = item.text;
+                    }
+                }
+            }
+            for (const item of highlightsResult.content) {
+                if (item.type === "text" && item.text) {
+                    try {
+                        combined.highlights = JSON.parse(item.text);
+                    }
+                    catch {
+                        combined.highlights = item.text;
+                    }
+                }
+            }
+            process.stdout.write(JSON.stringify(combined) + "\n");
+        }
+        else {
+            console.log("\x1b[1m\x1b[36m── Reader Documents ──\x1b[0m\n");
+            displayResult(readerResult, false);
+            console.log("\n\x1b[1m\x1b[36m── Readwise Highlights ──\x1b[0m\n");
+            displayResult(highlightsResult, false);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`\x1b[31m${err.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.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.message}\x1b[0m\n`);
+            }
+        }
+    }
+    await program.parseAsync(process.argv);
+}
+main();

package/dist/mcp.d.ts

@@ -0,0 +1,10 @@
+import { type ToolDef } from "./config.js";
+export declare function getTools(token: string, authType: "oauth" | "token", forceRefresh?: boolean): Promise<ToolDef[]>;
+export declare 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;
+}>;

package/dist/mcp.js

@@ -0,0 +1,53 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { loadConfig, saveConfig, isCacheValid } from "./config.js";
+import { VERSION } from "./version.js";
+const MCP_URL = "https://mcp2.readwise.io/mcp";
+function createTransport(token, authType) {
+    const authHeader = authType === "token" ? `Token ${token}` : `Bearer ${token}`;
+    return new StreamableHTTPClientTransport(new URL(MCP_URL), {
+        requestInit: {
+            headers: {
+                Authorization: authHeader,
+            },
+        },
+    });
+}
+export async function getTools(token, authType, forceRefresh = false) {
+    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;
+        // 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, authType, name, args) {
+    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;
+    }
+    finally {
+        await client.close();
+    }
+}

package/dist/tui/app.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDef } from "../config.js";
+export declare function runApp(tools: ToolDef[]): Promise<void>;