@xditya/pastr 0.2.0 → 0.4.2

package/README.md

@@ -4,7 +4,7 @@ Paste from the terminal to any [pastr](https://github.com/xditya/pastr) instance
 
 ```sh
 npm install -g @xditya/pastr        # or: npx @xditya/pastr …
-pastr config host https://your-pastr.example
+pastr config host https://your-pastr.example   # optional, defaults to pastr.xditya.me
 
 ls -la | pastr                  # stdin → link
 pastr main.go --expires 1d      # file (language from the extension)
@@ -12,13 +12,14 @@ pastr clip -E -c                # clipboard, encrypted in the terminal, link cop
 pastr shot.png                  # images (png/jpeg/gif/webp, up to 700 KB); clip also takes a copied image
 pastr text "hello there" -b     # literal text, burn after read
 pastr get https://host/AbCd1234#key
-pastr ls                        # what you pasted from this machine
+pastr ls                        # browse what you pasted here: ↑↓ or click a row, enter reveals the edit token, again copies it
 pastr rm AbCd1234               # delete (uses the locally stored edit token)
+pastr token AbCd1234            # show that token, for the site's Edit/Delete prompt
 ```
 
 - Zero dependencies, Node 20+, macOS/Linux/Windows/WSL.
 - `-E` encrypts with AES-256-GCM before upload; the key is only in the URL fragment. `-p`/`-P` uses a password instead.
 - Edit tokens and link keys are kept in `~/.config/pastr/history.json` (`%APPDATA%\pastr` on Windows), mode 0600.
-- Set the host once with `pastr config host …` or `PASTR_HOST`.
+- Talks to pastr.xditya.me unless you point it elsewhere with `pastr config host …`, `PASTR_HOST` or `-H`.
 
 Prefer no Node at all? Every pastr instance serves a tiny POSIX shell version: `curl -fsSL https://your-pastr.example/install.sh | sh`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xditya/pastr",
-  "version": "0.2.0",
+  "version": "0.4.2",
   "description": "Paste from the terminal to a pastr instance: pipe, files, clipboard, with optional end-to-end encryption.",
   "type": "module",
   "bin": {

package/pastr.mjs

@@ -11,11 +11,49 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
+import { parseArgs, styleText } from "node:util";
 import { createInterface } from "node:readline";
 
-export const VERSION = "0.2.0";
+export const VERSION = "0.4.2";
 const NAME = "pastr";
+const DEFAULT_HOST = "https://pastr.xditya.me";
+
+// ---------------------------------------------------------------------------
+// Terminal styling: colour only on a TTY, never when piped or under NO_COLOR,
+// so `pastr | pbcopy` and scripts see plain text.
+// ---------------------------------------------------------------------------
+
+const OUT_TTY = !process.env.NO_COLOR && !!process.stdout.isTTY;
+const ERR_TTY = !process.env.NO_COLOR && !!process.stderr.isTTY;
+const paint = (style) => (s) => (OUT_TTY && styleText ? styleText(style, s) : s);
+const bold = paint("bold");
+const dim = paint("dim");
+const cyan = paint("cyan");
+const yellow = paint("yellow");
+const green = paint("green");
+const link = paint(["cyan", "underline"]);
+
+const len = (s) => [...s].length;
+const fit = (s, n) => (len(s) > n ? [...s].slice(0, Math.max(n - 1, 0)).join("") + "…" : s.padEnd(n));
+
+/** Box-drawn table sized to the terminal; column `shrink` gives up characters first, then the widest. */
+export function table(head, rows, styles = [], shrink = -1, width = process.stdout.columns || 120, selected = -1) {
+  const w = head.map((h, i) => Math.max(len(h), ...rows.map((r) => len(r[i]))));
+  let over = w.reduce((a, b) => a + b, 0) + 3 * w.length + 1 - width;
+  while (over > 0) {
+    const i = w[shrink] > 8 ? shrink : w.indexOf(Math.max(...w));
+    if (w[i] <= 8) break;
+    w[i]--;
+    over--;
+  }
+  const rule = (l, m, r) => dim(l + w.map((n) => "─".repeat(n + 2)).join(m) + r);
+  const line = (cells, f) => dim("│ ") + cells.map((c, i) => (f[i] ?? ((s) => s))(fit(c, w[i]))).join(dim(" │ ")) + dim(" │");
+  const body = rows.map((r, i) => (i === selected ? line(r, r.map(() => paint("inverse"))) : line(r, styles)));
+  return [rule("╭", "┬", "╮"), line(head, head.map(() => bold)), rule("├", "┼", "┤"), ...body, rule("╰", "┴", "╯")].join("\n") + "\n";
+}
+
+const ok = (msg) => out(`${OUT_TTY ? green("✓ ") : ""}${msg}\n`);
+const note = (msg) => process.stderr.write(ERR_TTY ? styleText("dim", `  ${msg}\n`) : `${msg}\n`);
 
 // ---------------------------------------------------------------------------
 // Config & history
@@ -67,10 +105,7 @@ function forget(id) {
 }
 
 export function resolveHost(flag) {
-  const host = flag || process.env.PASTR_HOST || getConfig().host;
-  if (!host) {
-    throw new UsageError(`no host configured. Run \`${NAME} config host https://your-pastr.example\` or set PASTR_HOST.`);
-  }
+  const host = flag || process.env.PASTR_HOST || getConfig().host || DEFAULT_HOST;
   return host.replace(/\/+$/, "");
 }
 
@@ -226,10 +261,20 @@ function promptHidden(question) {
 }
 
 async function readStdin() {
-  if (process.stdin.isTTY) process.stderr.write("Type or paste, then press Ctrl-D:\n");
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  return Buffer.concat(chunks).toString("utf8");
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+  }
+  // Interactive: readline handles Ctrl-D itself, so it ends the paste on Windows too (the console's
+  // Ctrl-Z convention never reaches a Node stream reliably there).
+  note("Type or paste, then press Ctrl-D on an empty line to finish:");
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true, prompt: "" });
+  const lines = [];
+  rl.on("line", (l) => lines.push(l));
+  rl.on("SIGINT", () => process.exit(130));
+  await new Promise((resolve) => rl.on("close", resolve));
+  return lines.length ? lines.join("\n") + "\n" : "";
 }
 
 // ---------------------------------------------------------------------------
@@ -336,15 +381,16 @@ async function createPaste(host, { content, title, lang, expires, burn, encrypt,
 // CLI
 // ---------------------------------------------------------------------------
 
-const HELP = `${NAME} ${VERSION} — paste from the terminal
+const HELP = `${NAME} ${VERSION} · paste from the terminal
 
 Usage
   ${NAME} [options] [file ...]        paste files (text, or png/jpeg/gif/webp up to 700 KB), or stdin
   ${NAME} clip [options]              paste the clipboard (text or an image)
   ${NAME} text [options] <words ...>  paste literal text
   ${NAME} get <id|url> [--json]       print a paste (decrypts when the URL carries a #key)
-  ${NAME} ls                          pastes created from this machine
+  ${NAME} ls [--json]                 browse pastes made here: arrows or click, enter reveals the edit token
   ${NAME} rm <id|url>                 delete a paste created from this machine
+  ${NAME} token <id|url>              print the edit token (paste it into the site's Edit/Delete prompt)
   ${NAME} config [host <url>]         show or set the default host
 
 Options
@@ -359,7 +405,7 @@ Options
   -o, --open              open the URL in a browser
   -r, --raw               print the raw URL (plain text) instead of the page URL
   -j, --json              print the full API response
-  -H, --host <url>        server to use (env PASTR_HOST, or \`${NAME} config host …\`)
+  -H, --host <url>        server to use (default ${DEFAULT_HOST}; env PASTR_HOST, or \`${NAME} config host …\`)
   -h, --help              show this help
   -v, --version           show the version
 
@@ -372,6 +418,13 @@ Examples
   ${NAME} shot.png -e 1d              # image paste; "get" writes the bytes back
 `;
 
+/** Bold section headings, cyan command/flag column, dim trailing comments. */
+const styleHelp = (s) =>
+  s
+    .split("\n")
+    .map((l) => (/^\S/.test(l) ? bold(l) : l.replace(/^(\s+)(\S.*?)(\s{2,}|$)/, (_, a, b, c) => a + cyan(b) + c).replace(/#.*$/, dim)))
+    .join("\n");
+
 function fmtRel(ms) {
   const d = ms - Date.now();
   const abs = Math.abs(d);
@@ -380,6 +433,104 @@ function fmtRel(ms) {
   return d >= 0 ? `in ${n}${u[1]}` : `${n}${u[1]} ago`;
 }
 
+const flags = (p) => [p.encrypted && "enc", p.burn && "burn"].filter(Boolean).join(" ");
+
+/** Keys stay out of the table (`get <id>` finds them in history); the piped form has the full URL. */
+function lsTable(list, selected = -1) {
+  const head = ["id", "title", "lang", "created", "expires", "", "url"];
+  const rows = list.map((p) => [p.id, p.title || "", p.lang || "", fmtRel(p.created), p.expires ? fmtRel(p.expires) : "never", flags(p), p.url.split("#")[0]]);
+  // Narrow window: drop the url column (the id is enough for `get`) rather than mangling it.
+  const need = head.reduce((sum, h, i) => sum + 3 + Math.min(i === 1 ? 20 : Infinity, Math.max(len(h), ...rows.map((r) => len(r[i])))), 1);
+  if (need > (process.stdout.columns || 120)) for (const r of [head, ...rows]) r.pop();
+  return table(head, rows, [cyan, undefined, dim, dim, undefined, yellow, dim], 1, process.stdout.columns || 120, selected);
+}
+
+/**
+ * Interactive `ls`: arrow keys or a mouse click pick a paste, Enter (or a second click) reveals its
+ * edit token, once more copies it. Runs on the alternate screen so the shell scrollback stays clean.
+ */
+function browse(list) {
+  const { stdin, stdout } = process;
+  let sel = 0;
+  let revealed = false;
+  let msg = "";
+  let confirmDelete = false;
+  const rowsVisible = () => Math.max(3, (stdout.rows || 24) - 10);
+  const first = () => Math.min(Math.max(0, sel - rowsVisible() + 1), Math.max(0, list.length - rowsVisible()));
+  const draw = () => {
+    const p = list[sel];
+    const start = first();
+    const detail = [
+      `  ${cyan(p.id)}  ${p.title || dim("untitled")}`,
+      `  ${dim("url    ")}${link(p.url)}`,
+      `  ${dim("token  ")}${p.editToken ? (revealed ? yellow(p.editToken) : dim("•".repeat(24) + "  enter to reveal")) : dim("not on this machine")}`,
+      "",
+      confirmDelete ? yellow(`  delete ${p.id} from the server? y/n`) : msg ? `  ${msg}` : dim("  ↑↓ move · enter reveal, again to copy token · c copy url · o open · d delete · q quit"),
+    ];
+    stdout.write("\x1b[H\x1b[2J" + lsTable(list.slice(start, start + rowsVisible()), sel - start) + detail.join("\n") + "\n");
+  };
+  const enter = async () => {
+    const p = list[sel];
+    if (!p.editToken) return (msg = yellow("no token stored for this paste"));
+    if (!revealed) return (revealed = true);
+    msg = writeClipboard(p.editToken) ? green("✓ token copied") : yellow("could not copy");
+  };
+  const select = (i) => {
+    if (i === sel || i < 0 || i >= list.length) return false;
+    sel = i;
+    revealed = false;
+    msg = "";
+    return true;
+  };
+  return new Promise((resolve) => {
+    const done = () => {
+      stdout.write("\x1b[?1006l\x1b[?1000l\x1b[?25h\x1b[?1049l");
+      stdin.setRawMode(false);
+      stdin.pause();
+      resolve();
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdout.write("\x1b[?1049h\x1b[?25l\x1b[?1000h\x1b[?1006h");
+    draw();
+    stdin.on("data", async (k) => {
+      const mouse = /^\x1b\[<(\d+);(\d+);(\d+)M/.exec(k);
+      if (confirmDelete) {
+        confirmDelete = false;
+        if (k === "y") {
+          const p = list[sel];
+          try {
+            await api(new URL(p.url).origin, `/api/v1/pastes/${p.id}`, { method: "DELETE", headers: { Authorization: `Bearer ${p.editToken}` } });
+            forget(p.id);
+            list.splice(sel, 1);
+            if (!list.length) return done();
+            sel = Math.min(sel, list.length - 1);
+            msg = green(`✓ deleted ${p.id}`);
+          } catch (err) {
+            msg = yellow(err.message);
+          }
+        }
+      } else if (mouse) {
+        const [, button, , y] = mouse.map(Number);
+        if (button === 64) select(sel - 1);
+        else if (button === 65) select(sel + 1);
+        else if (button === 0) {
+          const i = y - 4 + first(); // 3 header lines above the first row
+          if (i >= 0 && i < list.length && !select(i)) await enter();
+        }
+      } else if (k === "\x1b[A" || k === "k") select(sel - 1);
+      else if (k === "\x1b[B" || k === "j") select(sel + 1);
+      else if (k === "\r") await enter();
+      else if (k === "c") msg = writeClipboard(list[sel].url) ? green("✓ url copied") : yellow("could not copy");
+      else if (k === "o") openInBrowser(list[sel].url);
+      else if (k === "d") confirmDelete = !!list[sel].editToken || ((msg = yellow("no token stored for this paste")), false);
+      else if (k === "q" || k === "\x1b" || k === "\x03") return done();
+      draw();
+    });
+  });
+}
+
 export async function main(argv) {
   const { values: o, positionals } = parseArgs({
     args: argv,
@@ -402,7 +553,7 @@ export async function main(argv) {
     },
   });
 
-  if (o.help) return out(HELP);
+  if (o.help) return out(styleHelp(HELP));
   if (o.version) return out(`${NAME} ${VERSION}\n`);
 
   const [cmd, ...rest] = positionals;
@@ -410,20 +561,25 @@ export async function main(argv) {
   if (cmd === "config") {
     if (rest[0] === "host" && rest[1]) {
       setConfig({ host: rest[1].replace(/\/+$/, "") });
-      return out(`host set to ${rest[1]}\n`);
+      return ok(`host set to ${rest[1]}`);
     }
     const cfg = getConfig();
-    return out(`host: ${process.env.PASTR_HOST || cfg.host || "(not set)"}\nconfig: ${configDir()}\n`);
+    const source = process.env.PASTR_HOST ? "env PASTR_HOST" : cfg.host ? "config" : "default";
+    return out(`${dim("host   ")} ${link(process.env.PASTR_HOST || cfg.host || DEFAULT_HOST)} ${dim(`(${source})`)}\n${dim("config ")} ${configDir()}\n`);
   }
 
   if (cmd === "ls") {
     const list = getHistory();
-    if (!list.length) return out("no pastes yet\n");
-    for (const p of list) {
-      const flags = [p.encrypted && "enc", p.burn && "burn"].filter(Boolean).join(",");
-      out(`${p.id}  ${(p.title || p.lang || "").padEnd(24).slice(0, 24)}  ${fmtRel(p.created).padEnd(9)}  ${p.expires ? "expires " + fmtRel(p.expires) : "never expires"}${flags ? "  [" + flags + "]" : ""}\n  ${p.url}\n`);
+    if (o.json) return out(JSON.stringify(list, null, 2) + "\n");
+    if (!list.length) return out(`no pastes yet${OUT_TTY ? dim(` · try: ls -la | ${NAME}`) : ""}\n`);
+    // Piped: one tab-separated line per paste, ISO dates. TTY: a table sized to the window.
+    if (!OUT_TTY) {
+      for (const p of list) out([p.id, p.title || "", p.lang || "", new Date(p.created).toISOString(), p.expires ? new Date(p.expires).toISOString() : "never", flags(p), p.url].join("\t") + "\n");
+      return;
     }
-    return;
+    if (process.stdin.isTTY) return browse(list);
+    out(lsTable(list));
+    return out(dim(`  ${list.length} ${list.length === 1 ? "paste" : "pastes"} · ${NAME} get <id> · ${NAME} rm <id>\n`));
   }
 
   if (cmd === "get") {
@@ -445,6 +601,15 @@ export async function main(argv) {
     return emit(env.content, env.lang);
   }
 
+  if (cmd === "token") {
+    if (!rest[0]) throw new UsageError("usage: token <id|url>");
+    const { id } = parsePasteRef(rest[0]);
+    const entry = getHistory().find((h) => h.id === id);
+    if (!entry?.editToken) throw new CliError(`no edit token for ${id} on this machine`);
+    if (OUT_TTY) note("Anyone with this token can edit or delete the paste.");
+    return out(entry.editToken + "\n");
+  }
+
   if (cmd === "rm") {
     if (!rest[0]) throw new UsageError("usage: rm <id|url>");
     const ref = parsePasteRef(rest[0]);
@@ -454,7 +619,7 @@ export async function main(argv) {
     if (!token) throw new CliError(`no edit token for ${ref.id} on this machine (set PASTR_EDIT_TOKEN to use one)`);
     await api(host, `/api/v1/pastes/${ref.id}`, { method: "DELETE", headers: { Authorization: `Bearer ${token}` } });
     forget(ref.id);
-    return out(`deleted ${ref.id}\n`);
+    return ok(`deleted ${ref.id}`);
   }
 
   // ---- create ----
@@ -485,21 +650,22 @@ export async function main(argv) {
 
   for (const item of items) {
     if (!item.content.trim()) throw new CliError("nothing to paste");
-    const p = await createPaste(host, {
-      content: item.content,
-      title: item.title,
-      lang: item.lang ?? o.lang,
-      expires: o.expires,
-      burn: o.burn,
-      encrypt: o.encrypt,
-      password,
-    });
+    // Progress on stderr while the upload (and PBKDF2 for -p) runs, cleared before the result.
+    if (ERR_TTY) process.stderr.write(styleText("dim", "  uploading…"));
+    let p;
+    try {
+      p = await createPaste(host, { content: item.content, title: item.title, lang: item.lang ?? o.lang, expires: o.expires, burn: o.burn, encrypt: o.encrypt, password });
+    } finally {
+      if (ERR_TTY) process.stderr.write("\r\x1b[2K");
+    }
     const url = o.raw ? p.rawUrl : p.url;
     if (o.json) out(JSON.stringify(p, null, 2) + "\n");
-    else out(url + "\n");
-    if (o.copy) {
-      if (writeClipboard(url)) process.stderr.write("copied to clipboard\n");
-      else process.stderr.write("could not copy to clipboard\n");
+    else out(link(url) + "\n");
+    const copied = o.copy ? (writeClipboard(url) ? "copied to clipboard" : "could not copy to clipboard") : "";
+    // The URL alone goes to stdout; everything else is a dim stderr line so pipes stay clean.
+    if (!o.json && (ERR_TTY || copied)) {
+      const meta = ERR_TTY ? [item.title, p.expires ? `expires ${fmtRel(p.expires)}` : "never expires", p.burn && "burn after read", p.enc && "encrypted", copied, `${NAME} token ${p.id} to edit on the site`] : [copied];
+      note(meta.filter(Boolean).join(" · "));
     }
     if (o.open) openInBrowser(url);
   }
@@ -518,7 +684,9 @@ const isMain = process.argv[1] && import.meta.url === new URL(`file://${process.
 if (isMain || (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1])) {
   main(process.argv.slice(2)).catch((err) => {
     const usage = err instanceof UsageError || err?.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" || err?.code?.startsWith?.("ERR_PARSE_ARGS");
-    process.stderr.write(`${NAME}: ${err.message}\n${usage ? `Run \`${NAME} --help\` for usage.\n` : ""}`);
+    const prefix = ERR_TTY ? styleText("red", "✗") : `${NAME}:`;
+    const hint = usage ? `Run \`${NAME} --help\` for usage.\n` : "";
+    process.stderr.write(`${prefix} ${err.message}\n${ERR_TTY ? styleText("dim", hint) : hint}`);
     process.exit(usage ? 2 : 1);
   });
 }