@shiori-sh/cli 0.1.0

package/README.md

@@ -0,0 +1,63 @@
+# @shiori-sh/cli
+
+Command-line interface for [Shiori](https://www.shiori.sh) — save, organize, and manage your links from the terminal.
+
+## Install
+
+```bash
+npm install -g @shiori-sh/cli
+```
+
+Or use without installing:
+
+```bash
+npx @shiori-sh/cli list
+```
+
+## Authenticate
+
+```bash
+shiori auth
+```
+
+This saves your API key to `~/.shiori/config.json`. Generate an API key at [shiori.sh/home](https://www.shiori.sh/home) → Settings.
+
+You can also set `SHIORI_API_KEY` as an environment variable.
+
+## Commands
+
+```bash
+shiori list                        # List recent links
+shiori list --read unread          # List unread links
+shiori list --limit 5 --sort oldest # Paginate and sort
+
+shiori get <id>                    # Get a link with full content
+shiori save <url>                  # Save a new link
+shiori save <url> --title "..."    # Save with custom title
+
+shiori update <id> --read          # Mark as read
+shiori update <id> --unread        # Mark as unread
+shiori update <id> --title "..."   # Update title
+shiori update <id> --restore       # Restore from trash
+
+shiori delete <id>                 # Move to trash
+shiori trash                       # List trashed links
+shiori trash --empty               # Permanently delete all trash
+
+shiori me                          # Show account info
+shiori auth --status               # Check auth status
+shiori auth --logout               # Remove stored credentials
+```
+
+Add `--json` to any command for machine-readable output.
+
+## Environment Variables
+
+| Variable          | Description                                        |
+| ----------------- | -------------------------------------------------- |
+| `SHIORI_API_KEY`  | API key (overrides config file)                    |
+| `SHIORI_BASE_URL` | Custom base URL (default: `https://www.shiori.sh`) |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+
+// src/commands/auth.ts
+import { createInterface } from "readline";
+
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".shiori");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function getApiKey() {
+  const envKey = process.env.SHIORI_API_KEY;
+  if (envKey) return envKey;
+  const config = readConfig();
+  if (config.api_key) return config.api_key;
+  console.error(
+    "Not authenticated. Run `shiori auth` to set up your API key."
+  );
+  console.error("Or set the SHIORI_API_KEY environment variable.");
+  process.exit(1);
+}
+function getBaseUrl() {
+  return process.env.SHIORI_BASE_URL || readConfig().base_url || "https://www.shiori.sh";
+}
+
+// src/commands/auth.ts
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+function promptSecret(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    const { stdin } = process;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let input = "";
+    let displayed = 0;
+    const MAX_STARS = 10;
+    const onData = (char) => {
+      if (char === "\r" || char === "\n") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        resolve(input);
+      } else if (char === "") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        process.stdout.write("\n");
+        process.exit(1);
+      } else if (char === "\x7F" || char === "\b") {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          if (displayed > 0) {
+            displayed--;
+            process.stdout.write("\b \b");
+          }
+        }
+      } else {
+        input += char;
+        const toShow = Math.min(char.length, MAX_STARS - displayed);
+        if (toShow > 0) {
+          process.stdout.write("*".repeat(toShow));
+          displayed += toShow;
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function run(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`shiori auth - Authenticate with your Shiori API key
+
+Usage: shiori auth [options]
+
+Options:
+  --status    Show current authentication status
+  --logout    Remove stored credentials
+  --help, -h  Show this help`);
+    return;
+  }
+  if (args.includes("--status")) {
+    const config2 = readConfig();
+    if (config2.api_key) {
+      const prefix = config2.api_key.slice(0, 8) + "...";
+      console.log(`Authenticated with key: ${prefix}`);
+      if (config2.base_url) console.log(`Base URL: ${config2.base_url}`);
+    } else if (process.env.SHIORI_API_KEY) {
+      console.log("Authenticated via SHIORI_API_KEY environment variable.");
+    } else {
+      console.log("Not authenticated. Run `shiori auth` to set up.");
+    }
+    return;
+  }
+  if (args.includes("--logout")) {
+    writeConfig({});
+    console.log("Credentials removed from ~/.shiori/config.json");
+    return;
+  }
+  const config = readConfig();
+  if (config.api_key) {
+    const answer = await prompt("You are already authenticated. Replace existing key? (y/N) ");
+    if (answer.trim().toLowerCase() !== "y") return;
+  }
+  console.log("\nTo authenticate, you need an API key from Shiori.\n");
+  console.log("  1. Open https://www.shiori.sh/home -> Settings");
+  console.log("  2. Create and copy your API key");
+  console.log("  3. Paste it below\n");
+  const key = await promptSecret("API key: ");
+  const trimmed = key.trim();
+  if (!trimmed.startsWith("shk_")) {
+    console.error("\nInvalid API key format. Keys start with 'shk_'.");
+    process.exit(1);
+  }
+  process.stdout.write("\nVerifying... ");
+  const baseUrl = getBaseUrl();
+  const res = await fetch(`${baseUrl}/api/user/me`, {
+    headers: { Authorization: `Bearer ${trimmed}` }
+  });
+  if (!res.ok) {
+    console.error("failed.\nAuthentication failed. Check your API key and try again.");
+    process.exit(1);
+  }
+  const data = await res.json();
+  writeConfig({ ...readConfig(), api_key: trimmed });
+  console.log(`done.
+
+Authenticated as ${data.user?.full_name || data.user?.id}`);
+  console.log("API key saved to ~/.shiori/config.json");
+}
+
+// src/api.ts
+async function api(method, path, body) {
+  const baseUrl = getBaseUrl();
+  const apiKey = getApiKey();
+  const res = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await res.json();
+  if (!res.ok || data.success === false) {
+    const message = data.error || `Request failed (HTTP ${res.status})`;
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+  return { status: res.status, data };
+}
+
+// src/format.ts
+function formatDate(iso) {
+  if (!iso) return "--";
+  return new Date(iso).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
+function getFlag(args, name, fallback) {
+  const idx = args.indexOf(name);
+  if (idx === -1 || idx + 1 >= args.length) return fallback;
+  return args[idx + 1];
+}
+function hasFlag(args, ...names) {
+  return names.some((n) => args.includes(n));
+}
+function getPositional(args) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--") && ["--limit", "--offset", "--sort", "--read", "--title", "--summary"].includes(args[i])) {
+        i++;
+      }
+      continue;
+    }
+    return args[i];
+  }
+  return void 0;
+}
+
+// src/commands/delete.ts
+async function run2(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori delete - Delete a link (move to trash)
+
+Usage: shiori delete <id> [options]
+
+Options:
+  --json      Output raw JSON
+  --help, -h  Show this help`);
+    return;
+  }
+  const id = getPositional(args);
+  if (!id) {
+    console.error("Usage: shiori delete <id>");
+    process.exit(1);
+  }
+  const { data } = await api("DELETE", `/api/links/${id}`);
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(data.message || "Deleted.");
+}
+
+// src/commands/get.ts
+async function run3(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori get - Get a link by ID (includes content)
+
+Usage: shiori get <id> [options]
+
+Options:
+  --json      Output raw JSON
+  --help, -h  Show this help`);
+    return;
+  }
+  const id = getPositional(args);
+  if (!id) {
+    console.error("Usage: shiori get <link-id>");
+    process.exit(1);
+  }
+  const { data } = await api("GET", `/api/links/${id}`);
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  const link = data.link;
+  console.log();
+  console.log(`  ID:        ${link.id}`);
+  console.log(`  Title:     ${link.title || "(untitled)"}`);
+  console.log(`  URL:       ${link.url}`);
+  console.log(`  Domain:    ${link.domain || "--"}`);
+  console.log(`  Status:    ${link.status}`);
+  console.log(`  Source:    ${link.source || "--"}`);
+  console.log(`  Author:    ${link.author || "--"}`);
+  console.log(`  Published: ${formatDate(link.publication_date)}`);
+  console.log(`  Saved:     ${formatDate(link.created_at)}`);
+  console.log(
+    `  Read:      ${link.read_at ? formatDate(link.read_at) : "unread"}`
+  );
+  console.log(`  Summary:   ${link.summary || "--"}`);
+  if (link.content) {
+    console.log(`
+--- Content (${link.content.length} chars) ---`);
+    console.log(truncate(link.content, 3e3));
+  } else {
+    console.log("\n  (no content)");
+  }
+  console.log();
+}
+
+// src/commands/list.ts
+async function run4(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori list - List saved links
+
+Usage: shiori list [options]
+
+Options:
+  --limit <n>              Number of links (1-100, default: 25)
+  --offset <n>             Pagination offset (default: 0)
+  --sort <newest|oldest>   Sort order (default: newest)
+  --read <all|read|unread> Filter by read status (default: all)
+  --json                   Output raw JSON
+  --help, -h               Show this help`);
+    return;
+  }
+  const limit = getFlag(args, "--limit", "25");
+  const offset = getFlag(args, "--offset", "0");
+  const sort = getFlag(args, "--sort", "newest");
+  const read = getFlag(args, "--read", "all");
+  const params = new URLSearchParams({
+    limit,
+    offset,
+    sort,
+    read
+  });
+  const { data } = await api("GET", `/api/links?${params}`);
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(`
+Links: ${data.links.length} of ${data.total} total
+`);
+  for (const [i, link] of data.links.entries()) {
+    const readStatus = link.read_at ? "read" : "unread";
+    const title = truncate(link.title || "(untitled)", 60);
+    console.log(
+      `  ${String(Number(offset) + i + 1).padStart(3)}. ${title}  ${link.domain || ""}  ${formatDate(link.created_at)}  ${readStatus}`
+    );
+  }
+  if (data.links.length === 0) {
+    console.log("  No links found.");
+  }
+  console.log();
+}
+
+// src/commands/me.ts
+async function run5(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori me - Show current user info
+
+Usage: shiori me [options]
+
+Options:
+  --json      Output raw JSON
+  --help, -h  Show this help`);
+    return;
+  }
+  const { data } = await api("GET", "/api/user/me");
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  const user = data.user;
+  console.log(`
+  Name:         ${user.full_name || "--"}`);
+  const plan = user.subscription?.plan === "subscription" ? "Pro" : user.subscription?.plan || "Free";
+  console.log(`  Plan:         ${plan}`);
+  console.log(`  Member since: ${new Date(user.created_at).toLocaleDateString("en-US", { month: "long", year: "numeric" })}`);
+  console.log();
+}
+
+// src/commands/save.ts
+async function run6(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori save - Save a new link
+
+Usage: shiori save <url> [options]
+
+Options:
+  --title <title>  Set a custom title
+  --read           Mark as read immediately
+  --json           Output raw JSON
+  --help, -h       Show this help`);
+    return;
+  }
+  const url = getPositional(args);
+  if (!url) {
+    console.error("Usage: shiori save <url> [--title <title>] [--read]");
+    process.exit(1);
+  }
+  const body = { url };
+  const title = getFlag(args, "--title");
+  if (title) body.title = title;
+  if (hasFlag(args, "--read")) body.read = true;
+  const { data } = await api("POST", "/api/links", body);
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data.duplicate) {
+    console.log(`Link already saved (bumped to top): ${data.linkId}`);
+  } else {
+    console.log(`Saved: ${data.linkId}`);
+  }
+}
+
+// src/commands/trash.ts
+async function run7(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori trash - List or empty the trash
+
+Usage: shiori trash [options]
+
+Options:
+  --limit <n>    Number of links (1-100, default: 25)
+  --offset <n>   Pagination offset (default: 0)
+  --empty        Permanently delete all trashed links
+  --json         Output raw JSON
+  --help, -h     Show this help`);
+    return;
+  }
+  if (hasFlag(args, "--empty")) {
+    const { data: data2 } = await api("DELETE", "/api/links");
+    if (hasFlag(args, "--json")) {
+      console.log(JSON.stringify(data2, null, 2));
+      return;
+    }
+    console.log(`Permanently deleted ${data2.deleted || 0} link(s).`);
+    return;
+  }
+  const limit = getFlag(args, "--limit", "25");
+  const offset = getFlag(args, "--offset", "0");
+  const params = new URLSearchParams({
+    trash: "true",
+    limit,
+    offset
+  });
+  const { data } = await api("GET", `/api/links?${params}`);
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(`
+Trashed links: ${data.links.length} of ${data.total} total
+`);
+  for (const [i, link] of data.links.entries()) {
+    const title = truncate(link.title || "(untitled)", 60);
+    console.log(
+      `  ${String(i + 1).padStart(3)}. ${title}  ${link.domain || ""}  deleted ${formatDate(link.deleted_at)}`
+    );
+  }
+  if (data.links.length === 0) {
+    console.log("  Trash is empty.");
+  }
+  console.log();
+}
+
+// src/commands/update.ts
+async function run8(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`shiori update - Update a link
+
+Usage: shiori update <id> [options]
+
+Options:
+  --read             Mark as read
+  --unread           Mark as unread
+  --title <title>    Update title
+  --summary <text>   Update summary
+  --restore          Restore from trash
+  --json             Output raw JSON
+  --help, -h         Show this help`);
+    return;
+  }
+  const id = getPositional(args);
+  if (!id) {
+    console.error("Usage: shiori update <id> [--read | --unread | --title <title> | --restore]");
+    process.exit(1);
+  }
+  let body;
+  if (hasFlag(args, "--restore")) {
+    body = { restore: true };
+  } else if (hasFlag(args, "--read")) {
+    body = { read: true };
+  } else if (hasFlag(args, "--unread")) {
+    body = { read: false };
+  } else {
+    const title = getFlag(args, "--title");
+    const summary = getFlag(args, "--summary");
+    if (!title && !summary) {
+      console.error("Provide at least one update flag: --read, --unread, --title, --summary, --restore");
+      process.exit(1);
+    }
+    body = {};
+    if (title) body.title = title;
+    if (summary !== void 0) body.summary = summary;
+  }
+  const { data } = await api("PATCH", `/api/links/${id}`, body);
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(data.message || "Updated.");
+}
+
+// src/error-report.ts
+function reportError(command, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const baseUrl = getBaseUrl();
+  fetch(`${baseUrl}/api/cli/report`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      version: "0.1.0",
+      command,
+      error: message,
+      platform: process.platform
+    }),
+    signal: AbortSignal.timeout(3e3)
+  }).catch(() => {
+  });
+}
+
+// src/update-check.ts
+var REGISTRY_URL = "https://registry.npmjs.org/@shiori-sh/cli/latest";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+async function checkForUpdate(currentVersion, isJson) {
+  if (process.env.CI || process.env.NO_UPDATE_NOTIFIER || isJson) return;
+  const config = readConfig();
+  const now = Date.now();
+  if (config.last_update_check && now - config.last_update_check < CHECK_INTERVAL_MS)
+    return;
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return;
+    const data = await res.json();
+    writeConfig({ ...config, last_update_check: now });
+    if (data.version && data.version !== currentVersion) {
+      process.stderr.write(
+        `
+  Update available: ${currentVersion} \u2192 ${data.version}
+  Run: npm install -g @shiori-sh/cli
+
+`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/index.ts
+var COMMANDS = {
+  auth: { run, desc: "Authenticate with your Shiori API key" },
+  list: { run: run4, desc: "List saved links" },
+  get: { run: run3, desc: "Get a link by ID (includes content)" },
+  save: { run: run6, desc: "Save a new link" },
+  update: { run: run8, desc: "Update a link" },
+  delete: { run: run2, desc: "Delete a link (move to trash)" },
+  trash: { run: run7, desc: "List or empty the trash" },
+  me: { run: run5, desc: "Show current user info" }
+};
+function printHelp() {
+  console.log(`shiori - Manage your Shiori link library from the terminal
+
+Usage: shiori <command> [options]
+
+Commands:
+${Object.entries(COMMANDS).map(([name, { desc }]) => `  ${name.padEnd(10)} ${desc}`).join("\n")}
+
+Options:
+  --help, -h       Show help
+  --version, -v    Show version
+
+Get started:
+  shiori auth        Authenticate with your API key
+  shiori list        List your recent links
+  shiori save <url>  Save a new link`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command === "--version" || command === "-v") {
+    console.log("0.1.0");
+    return;
+  }
+  const cmd = COMMANDS[command];
+  if (!cmd) {
+    console.error(`Unknown command: ${command}
+`);
+    printHelp();
+    process.exit(1);
+  }
+  const cmdArgs = args.slice(1);
+  const isJson = cmdArgs.includes("--json");
+  await cmd.run(cmdArgs);
+  checkForUpdate("0.1.0", isJson).catch(() => {
+  });
+}
+main().catch((err) => {
+  const command = process.argv[2] ?? "unknown";
+  reportError(command, err);
+  console.error(err.message || err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@shiori-sh/cli",
+  "version": "0.1.0",
+  "description": "CLI for managing your Shiori link library",
+  "author": "Brian Lovin",
+  "license": "MIT",
+  "homepage": "https://www.shiori.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brianlovin/shiori",
+    "directory": "cli"
+  },
+  "type": "module",
+  "bin": {
+    "shiori": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "shiori",
+    "bookmarks",
+    "links",
+    "read-it-later",
+    "cli"
+  ]
+}