@kyoji2/raindrop-cli 0.1.1

package/src/api/types.ts

@@ -0,0 +1,74 @@
+import type { z } from "zod";
+import type {
+  CollectionSchema,
+  HighlightSchema,
+  MediaSchema,
+  RaindropSchema,
+  RaindropUserSchema,
+  TagSchema,
+  UserStatsSchema,
+} from "./schemas";
+
+export type RaindropUser = z.infer<typeof RaindropUserSchema>;
+export type Collection = z.infer<typeof CollectionSchema>;
+export type Highlight = z.infer<typeof HighlightSchema>;
+export type Media = z.infer<typeof MediaSchema>;
+export type Raindrop = z.infer<typeof RaindropSchema>;
+export type Tag = z.infer<typeof TagSchema>;
+export type UserStats = z.infer<typeof UserStatsSchema>;
+
+export interface CollectionCreate {
+  title: string;
+  parent?: { $id: number };
+  public?: boolean;
+  view?: "list" | "simple" | "grid" | "masonry";
+  sort?: number;
+  cover?: string[];
+  color?: string;
+}
+
+export interface CollectionUpdate {
+  title?: string;
+  parent?: { $id: number };
+  public?: boolean;
+  view?: "list" | "simple" | "grid" | "masonry";
+  sort?: number;
+  cover?: string[];
+  color?: string;
+  expanded?: boolean;
+}
+
+export interface RaindropCreate {
+  link: string;
+  title?: string;
+  excerpt?: string;
+  tags?: string[];
+  collection?: { $id: number };
+  type?: string;
+  important?: boolean;
+  cover?: string;
+  note?: string;
+  highlights?: Highlight[];
+}
+
+export interface RaindropUpdate {
+  title?: string;
+  excerpt?: string;
+  tags?: string[];
+  collection?: { $id: number };
+  cover?: string;
+  important?: boolean;
+  note?: string;
+  link?: string;
+  order?: number;
+  pleaseParse?: boolean;
+}
+
+export interface ApiResponse<T> {
+  result: boolean;
+  item?: T;
+  items?: T[];
+  count?: number;
+  user?: RaindropUser;
+  errorMessage?: string;
+}

package/src/commands/auth.ts

@@ -0,0 +1,58 @@
+import { RaindropAPI } from "../api";
+import { deleteConfig, getToken, saveConfig } from "../utils/config";
+import { type GlobalOptions, output, outputError } from "../utils/output";
+import { withSpinner } from "../utils/spinner";
+
+export interface LoginOptions extends GlobalOptions {
+  token?: string;
+}
+
+export async function cmdLogin(options: LoginOptions): Promise<void> {
+  let token = options.token ?? "";
+
+  if (!token) {
+    process.stdout.write("Enter your Raindrop.io API Token: ");
+    const prompt = await import("node:readline");
+    const rl = prompt.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    token = await new Promise((resolve) => {
+      rl.question("", (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+
+  if (!token) {
+    outputError("Token is required", 400);
+  }
+
+  const api = new RaindropAPI(token);
+  const user = await withSpinner("Verifying token...", () => api.getUser(), `Logged in as ${token.slice(0, 8)}...`);
+
+  await saveConfig({ token });
+  console.log(`Welcome, ${user.fullName}!`);
+}
+
+export async function cmdLogout(_options: GlobalOptions): Promise<void> {
+  await deleteConfig();
+  console.log("Logged out. Credentials removed.");
+}
+
+export async function cmdWhoami(options: GlobalOptions): Promise<void> {
+  const api = getAuthenticatedAPI(options);
+  const user = await withSpinner("Fetching user info...", () => api.getUser());
+  output(user, options.format);
+}
+
+function getAuthenticatedAPI(options: GlobalOptions): RaindropAPI {
+  const token = getToken();
+  if (!token) {
+    outputError("Not logged in. Run `raindrop login` first.", 401);
+  }
+  return new RaindropAPI(token, options.dryRun);
+}
+
+export { getAuthenticatedAPI };

package/src/commands/batch.ts

@@ -0,0 +1,50 @@
+import type { RaindropUpdate } from "../api";
+import { type GlobalOptions, output, outputError } from "../utils/output";
+import { withSpinner } from "../utils/spinner";
+import { getAuthenticatedAPI } from "./auth";
+
+export interface BatchUpdateOptions extends GlobalOptions {
+  ids: string;
+  json: string;
+  collection?: string;
+}
+
+export async function cmdBatchUpdate(options: BatchUpdateOptions): Promise<void> {
+  const ids = options.ids.split(",").map((id) => parseInt(id.trim(), 10));
+
+  if (ids.length === 0 || ids.some(Number.isNaN)) {
+    outputError("--ids is required (comma-separated list)", 400);
+  }
+
+  if (!options.json) {
+    outputError("JSON patch data is required", 400);
+  }
+
+  const collectionId = options.collection ? parseInt(options.collection, 10) : 0;
+  const api = getAuthenticatedAPI(options);
+  const patchData: RaindropUpdate = JSON.parse(options.json);
+  const success = await withSpinner(`Updating ${ids.length} bookmark(s)...`, () =>
+    api.batchUpdateRaindrops(collectionId, ids, patchData),
+  );
+  output({ success }, options.format);
+}
+
+export interface BatchDeleteOptions extends GlobalOptions {
+  ids: string;
+  collection?: string;
+}
+
+export async function cmdBatchDelete(options: BatchDeleteOptions): Promise<void> {
+  const ids = options.ids.split(",").map((id) => parseInt(id.trim(), 10));
+
+  if (ids.length === 0 || ids.some(Number.isNaN)) {
+    outputError("--ids is required (comma-separated list)", 400);
+  }
+
+  const collectionId = options.collection ? parseInt(options.collection, 10) : 0;
+  const api = getAuthenticatedAPI(options);
+  const success = await withSpinner(`Deleting ${ids.length} bookmark(s)...`, () =>
+    api.batchDeleteRaindrops(collectionId, ids),
+  );
+  output({ success }, options.format);
+}

package/src/commands/collections.ts

@@ -0,0 +1,257 @@
+import type { CollectionCreate, CollectionUpdate } from "../api";
+import { type GlobalOptions, output, outputError } from "../utils/output";
+import { startSpinner, stopSpinner, withSpinner } from "../utils/spinner";
+import { getTempFilePath } from "../utils/tempfile";
+import { getAuthenticatedAPI } from "./auth";
+
+export interface CollectionCreateOptions extends GlobalOptions {
+  title: string;
+  parent?: string;
+  public?: boolean;
+  private?: boolean;
+  view?: string;
+}
+
+export async function cmdCollectionCreate(options: CollectionCreateOptions): Promise<void> {
+  if (!options.title) {
+    outputError("Collection title is required", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const parentId = options.parent ? parseInt(options.parent, 10) : undefined;
+  const isPublic = options.public ? true : options.private ? false : undefined;
+
+  const collection: CollectionCreate = {
+    title: options.title,
+    parent: parentId ? { $id: parentId } : undefined,
+    public: isPublic,
+    view: options.view as CollectionCreate["view"],
+  };
+  const result = await withSpinner("Creating collection...", () => api.createCollection(collection));
+  output(result, options.format);
+}
+
+export interface CollectionGetOptions extends GlobalOptions {
+  id: string;
+}
+
+export async function cmdCollectionGet(options: CollectionGetOptions): Promise<void> {
+  const id = parseInt(options.id, 10);
+
+  if (Number.isNaN(id)) {
+    outputError("Invalid collection ID", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const result = await withSpinner("Fetching collection...", () => api.getCollection(id));
+  output(result, options.format);
+}
+
+export interface CollectionUpdateOptions extends GlobalOptions {
+  id: string;
+  json: string;
+}
+
+export async function cmdCollectionUpdate(options: CollectionUpdateOptions): Promise<void> {
+  const id = parseInt(options.id, 10);
+
+  if (Number.isNaN(id)) {
+    outputError("Invalid collection ID", 400);
+  }
+
+  if (!options.json) {
+    outputError("JSON patch data is required", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const patchData: CollectionUpdate = JSON.parse(options.json);
+  const result = await withSpinner("Updating collection...", () => api.updateCollection(id, patchData));
+  output(result, options.format);
+}
+
+export interface CollectionDeleteOptions extends GlobalOptions {
+  id: string;
+}
+
+export async function cmdCollectionDelete(options: CollectionDeleteOptions): Promise<void> {
+  const id = parseInt(options.id, 10);
+
+  if (Number.isNaN(id)) {
+    outputError("Invalid collection ID", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const success = await withSpinner("Deleting collection...", () => api.deleteCollection(id));
+  output({ success }, options.format);
+}
+
+export interface CollectionDeleteMultipleOptions extends GlobalOptions {
+  ids: string;
+}
+
+export async function cmdCollectionDeleteMultiple(options: CollectionDeleteMultipleOptions): Promise<void> {
+  if (!options.ids) {
+    outputError("Collection IDs are required (comma-separated)", 400);
+  }
+
+  const ids = options.ids.split(",").map((id) => parseInt(id.trim(), 10));
+  if (ids.some(Number.isNaN)) {
+    outputError("Invalid collection IDs", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const success = await withSpinner(`Deleting ${ids.length} collections...`, () => api.deleteCollections(ids));
+  output({ success }, options.format);
+}
+
+export interface CollectionReorderOptions extends GlobalOptions {
+  sort: string;
+}
+
+export async function cmdCollectionReorder(options: CollectionReorderOptions): Promise<void> {
+  if (!options.sort) {
+    outputError("Sort order is required (title, -title, -count)", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const success = await withSpinner("Reordering collections...", () => api.reorderCollections(options.sort));
+  output({ success }, options.format);
+}
+
+export interface CollectionExpandAllOptions extends GlobalOptions {
+  expanded: string;
+}
+
+export async function cmdCollectionExpandAll(options: CollectionExpandAllOptions): Promise<void> {
+  const expanded = options.expanded.toLowerCase() === "true";
+
+  const api = getAuthenticatedAPI(options);
+  const action = expanded ? "Expanding" : "Collapsing";
+  const success = await withSpinner(`${action} all collections...`, () => api.expandAllCollections(expanded));
+  output({ success }, options.format);
+}
+
+export interface CollectionMergeOptions extends GlobalOptions {
+  ids: string;
+  target: string;
+}
+
+export async function cmdCollectionMerge(options: CollectionMergeOptions): Promise<void> {
+  if (!options.ids) {
+    outputError("Source collection IDs are required (comma-separated)", 400);
+  }
+
+  const targetId = parseInt(options.target, 10);
+  if (Number.isNaN(targetId)) {
+    outputError("Target collection ID is required", 400);
+  }
+
+  const ids = options.ids.split(",").map((id) => parseInt(id.trim(), 10));
+  if (ids.some(Number.isNaN)) {
+    outputError("Invalid collection IDs", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const success = await withSpinner("Merging collections...", () => api.mergeCollections(ids, targetId));
+  output({ success }, options.format);
+}
+
+export async function cmdCollectionClean(options: GlobalOptions): Promise<void> {
+  const api = getAuthenticatedAPI(options);
+  const count = await withSpinner("Cleaning empty collections...", () => api.cleanEmptyCollections());
+  output({ removed_count: count }, options.format);
+}
+
+export async function cmdCollectionEmptyTrash(options: GlobalOptions): Promise<void> {
+  const api = getAuthenticatedAPI(options);
+  const success = await withSpinner("Emptying trash...", () => api.emptyTrash());
+  output({ success }, options.format);
+}
+
+export interface CollectionCoverOptions extends GlobalOptions {
+  id: string;
+  source: string;
+}
+
+export async function cmdCollectionCover(options: CollectionCoverOptions): Promise<void> {
+  const id = parseInt(options.id, 10);
+
+  if (Number.isNaN(id)) {
+    outputError("Invalid collection ID", 400);
+  }
+
+  if (!options.source) {
+    outputError("Cover image path or URL is required", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  let filePath = options.source;
+  let isTemp = false;
+
+  if (options.source.startsWith("http://") || options.source.startsWith("https://")) {
+    const spinner = startSpinner("Downloading cover image...");
+    const response = await fetch(options.source);
+    if (!response.ok) {
+      stopSpinner(spinner, false);
+      outputError(`Failed to download image: ${response.status}`, response.status);
+    }
+    filePath = getTempFilePath("raindrop_cover", ".png");
+    await Bun.write(filePath, await response.arrayBuffer());
+    stopSpinner(spinner, true, "Downloaded");
+    isTemp = true;
+  }
+
+  const result = await withSpinner("Uploading cover...", () => api.uploadCollectionCover(id, filePath));
+
+  if (isTemp) {
+    await Bun.$`rm -f ${filePath}`;
+  }
+
+  output(result, options.format);
+}
+
+export interface CollectionSetIconOptions extends GlobalOptions {
+  id: string;
+  query: string;
+}
+
+export async function cmdCollectionSetIcon(options: CollectionSetIconOptions): Promise<void> {
+  const id = parseInt(options.id, 10);
+
+  if (Number.isNaN(id)) {
+    outputError("Invalid collection ID", 400);
+  }
+
+  if (!options.query) {
+    outputError("Icon search query is required", 400);
+  }
+
+  const api = getAuthenticatedAPI(options);
+  const icons = await withSpinner(`Searching icons for '${options.query}'...`, () => api.searchCovers(options.query));
+
+  if (icons.length === 0) {
+    outputError("No icons found", 404);
+  }
+
+  const iconUrl = icons[0];
+  if (!iconUrl) {
+    outputError("No icons found", 404);
+  }
+
+  const spinner = startSpinner("Downloading icon...");
+  const response = await fetch(iconUrl);
+  if (!response.ok) {
+    stopSpinner(spinner, false);
+    outputError(`Failed to download icon: ${response.status}`, response.status);
+  }
+
+  const filePath = getTempFilePath("raindrop_icon", ".png");
+  await Bun.write(filePath, await response.arrayBuffer());
+  stopSpinner(spinner, true, "Downloaded");
+
+  const result = await withSpinner("Uploading icon...", () => api.uploadCollectionCover(id, filePath));
+
+  await Bun.$`rm -f ${filePath}`;
+
+  output(result, options.format);
+}

package/src/commands/index.ts

@@ -0,0 +1,27 @@
+export { cmdLogin, cmdLogout, cmdWhoami, getAuthenticatedAPI } from "./auth";
+export { cmdBatchDelete, cmdBatchUpdate } from "./batch";
+export {
+  cmdCollectionClean,
+  cmdCollectionCover,
+  cmdCollectionCreate,
+  cmdCollectionDelete,
+  cmdCollectionDeleteMultiple,
+  cmdCollectionEmptyTrash,
+  cmdCollectionExpandAll,
+  cmdCollectionGet,
+  cmdCollectionMerge,
+  cmdCollectionReorder,
+  cmdCollectionSetIcon,
+  cmdCollectionUpdate,
+} from "./collections";
+export { cmdContext, cmdSchema, cmdStructure } from "./overview";
+export {
+  cmdAdd,
+  cmdDelete,
+  cmdGet,
+  cmdPatch,
+  cmdSearch,
+  cmdSuggest,
+  cmdWayback,
+} from "./raindrops";
+export { cmdTagDelete, cmdTagRename } from "./tags";

package/src/commands/overview.ts

@@ -0,0 +1,95 @@
+import { type GlobalOptions, output } from "../utils/output";
+import { withSpinner } from "../utils/spinner";
+import { getAuthenticatedAPI } from "./auth";
+
+export async function cmdContext(options: GlobalOptions): Promise<void> {
+  const api = getAuthenticatedAPI(options);
+
+  const [user, stats, recent, collections] = await withSpinner("Loading account context...", () =>
+    Promise.all([api.getUser(), api.getStats(), api.search("", 0, 5), api.getCollections()]),
+  );
+
+  const totalBookmarks = stats.find((s) => s._id === 0)?.count ?? 0;
+
+  const contextData = {
+    user: [{ id: user._id, name: user.fullName }],
+    stats: [
+      {
+        total_bookmarks: totalBookmarks,
+        total_collections: collections.length,
+      },
+    ],
+    structure: {
+      root_collections: collections
+        .filter((c) => !c.parent)
+        .map((c) => ({ id: c._id, title: c.title, count: c.count })),
+    },
+    recent_activity: recent.slice(0, 5).map((r) => ({
+      id: r._id,
+      title: r.title,
+      created: r.created,
+    })),
+  };
+
+  output(contextData, options.format);
+}
+
+export async function cmdStructure(options: GlobalOptions): Promise<void> {
+  const api = getAuthenticatedAPI(options);
+
+  const [collections, tags] = await withSpinner("Loading structure...", () =>
+    Promise.all([api.getCollections(), api.getTags()]),
+  );
+
+  output(
+    {
+      collections: collections.map((c) => ({
+        id: c._id,
+        title: c.title,
+        count: c.count,
+        parent_id: c.parent?.$id ?? null,
+        last_update: c.lastUpdate,
+      })),
+      tags: tags.map((t) => t._id),
+    },
+    options.format,
+  );
+}
+
+export function cmdSchema(): void {
+  const schemas = {
+    Raindrop: {
+      type: "object",
+      properties: {
+        link: { type: "string", required: true },
+        title: { type: "string" },
+        excerpt: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        collection: { type: "object", properties: { $id: { type: "number" } } },
+        important: { type: "boolean" },
+        cover: { type: "string" },
+        note: { type: "string" },
+      },
+    },
+    Collection: {
+      type: "object",
+      properties: {
+        title: { type: "string", required: true },
+        parent: { type: "object", properties: { $id: { type: "number" } } },
+        public: { type: "boolean" },
+        view: { type: "string", enum: ["list", "simple", "grid", "masonry"] },
+      },
+    },
+  };
+
+  const usageExamples = {
+    patch_update_title_tags: 'raindrop patch <id> \'{"title": "New Title", "tags": ["ai", "cli"]}\'',
+    move_single_bookmark: 'raindrop patch <id> \'{"collection": {"$id": <target_col_id>}}\'',
+    move_batch_bookmarks:
+      'raindrop batch update --ids 1,2 --collection <source_col_id> \'{"collection": {"$id": <target_col_id>}}\'',
+    create_collection: 'raindrop collection create "Research" --public',
+    search_with_tags: 'raindrop search "python tag:important"',
+  };
+
+  console.log(JSON.stringify({ schemas, usage_examples: usageExamples }, null, 2));
+}