biblioplex 0.1.1 → 0.2.0

package/src/commands/deck.mjs

@@ -1,52 +1,18 @@
-import { loadSnapshot } from '../mutate.mjs';
-import { findContainer, containerCards } from '../snapshot.mjs';
-import { cardRow, CARD_COLUMNS } from '../render.mjs';
-import { usageError, CliError } from '../errors.mjs';
-import { runDeckExport } from './deckExport.mjs';
-
-const BOARDS = ['main', 'sideboard', 'maybe'];
-
-async function deckShow(ctx, name) {
-  const { out } = ctx;
-  if (!name) throw usageError('usage: bp deck show <name>');
-  const session = ctx.makeSession();
-  const { snapshot } = await loadSnapshot(session);
-  const { matches } = findContainer(snapshot, 'deck:' + name);
-  const decks = matches.filter(m => m.type === 'deck');
-  if (!decks.length) throw new CliError(`no deck named "${name}"`);
-
-  const deck = decks[0];
-  const cards = containerCards(snapshot, deck);
-  const boards = { main: [], sideboard: [], maybe: [] };
-  for (const c of cards) (boards[c.deckBoard] || boards.main).push(c);
-
-  out.emit({ deck: { name: deck.name, meta: deck.deck || null }, boards }, () => {
-    out.line(out.c.bold('deck: ' + deck.name));
-    const meta = deck.deck || {};
-    if (meta.format) out.line('  format: ' + meta.format);
-    if (meta.commander?.name) out.line('  commander: ' + meta.commander.name);
-    for (const b of BOARDS) {
-      const list = boards[b];
-      if (!list.length) continue;
-      const n = list.reduce((s, c) => s + (parseInt(c.qty, 10) || 0), 0);
-      out.line('');
-      out.line(out.c.bold(`${b} (${n})`));
-      out.table(CARD_COLUMNS, list.map(cardRow));
-    }
-  });
-  return 0;
-}
+import { emitResult, DECKLIST_COLUMNS, CONTAINER_COLUMNS } from '../render.mjs';
 
 export default {
-  summary: 'inspect or export a deck',
-  help: [
-    'usage: bp deck show <name>',
-    '       bp deck export <name> [--preset plain|moxfield|arena|mtgo|csv|json] [--boards main,sideboard,maybe]',
-  ].join('\n'),
+  summary: 'list decks or show a decklist',
+  help: `bp deck [name]
+
+With no name, lists your decks/containers. With a deck name, shows its decklist.`,
   async run(ctx) {
-    const [sub, ...rest] = ctx.args;
-    if (sub === 'show') return deckShow(ctx, rest.join(' '));
-    if (sub === 'export') return runDeckExport(ctx, rest);
-    throw usageError('usage: bp deck <show|export> <name>');
+    const session = await ctx.makeSession();
+    const name = ctx.args.join(' ').trim();
+    if (!name) {
+      const sc = await session.call('query_collection', { from: 'containers' });
+      return emitResult(ctx, sc, { columns: CONTAINER_COLUMNS });
+    }
+    const sc = await session.call('query_collection', { from: 'decklist', deckName: name });
+    return emitResult(ctx, sc, { columns: DECKLIST_COLUMNS });
   },
 };

package/src/commands/edit.mjs

@@ -1,45 +1,33 @@
-import { collectionKey, normalizeCondition, normalizeFinish } from '../../vendor/collection.js';
-import { applyMutation } from '../mutate.mjs';
-import { strFlag, intFlag, boolFlag } from '../args.mjs';
-import { requireWrite, selectorFrom, requireStacks, persistUndo, printWrite } from './writeHelpers.mjs';
+import { strFlag } from '../args.mjs';
 import { usageError } from '../errors.mjs';
+import { runMutation } from '../mutate.mjs';
 
 export default {
-  summary: 'edit a stack (condition / finish / qty / tags)',
-  help: [
-    'usage: bp edit <name> [--set --cn ...] [--condition lightly_played] [--finish foil]',
-    '                      [--qty 3] [--tags trade,foil] [--all] [--dry-run]',
-    '',
-    'updates fields on a matching stack. --tags replaces the tag set ("" clears).',
-  ].join('\n'),
+  summary: 'edit a card (finish, condition, tags)',
+  help: `bp edit <itemKey> [--finish ...] [--condition ...] [--tag a,b,c] [--yes] [--dry-run]
+
+Edit an inventory row. Tags use set-semantics: pass the full desired list
+(empty --tag clears them).`,
   async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    requireWrite(session);
-    const sel = selectorFrom(flags, args);
-    const newCond = strFlag(flags, 'condition', 'cond');
-    const newFinish = strFlag(flags, 'finish');
-    const newQty = intFlag(flags, 'qty', null);
-    const setTags = strFlag(flags, 'tags');
-    if (newCond == null && newFinish == null && newQty == null && setTags == null) {
-      throw usageError('nothing to edit — pass --condition, --finish, --qty, or --tags');
+    const itemKey = ctx.args[0] || strFlag(ctx.flags, 'item');
+    if (!itemKey)
+      throw usageError('usage: bp edit <itemKey> [--finish ...] [--condition ...] [--tag ...]');
+    const session = await ctx.makeSession({ write: true });
+    const args = { operation: 'edit', itemKey };
+    const finish = strFlag(ctx.flags, 'finish');
+    if (finish) args.finish = finish;
+    const condition = strFlag(ctx.flags, 'condition');
+    if (condition) args.condition = condition;
+    const tagStr = strFlag(ctx.flags, 'tag', 'tags');
+    if (tagStr != null) {
+      args.tags = tagStr
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
     }
-
-    const result = await applyMutation(session, (draft) => {
-      const stacks = requireStacks(draft.app.collection, sel, { all: boolFlag(flags, 'all') });
-      const keys = new Set(stacks.map(collectionKey));
-      for (const e of draft.app.collection) {
-        if (!keys.has(collectionKey(e))) continue;
-        if (newCond) e.condition = normalizeCondition(newCond);
-        if (newFinish) e.finish = normalizeFinish(newFinish);
-        if (newQty != null) e.qty = Math.max(1, newQty);
-        if (setTags != null) e.tags = setTags ? setTags.split(',').map(s => s.trim()).filter(Boolean) : [];
-      }
-      return { edited: stacks.length };
-    }, { dryRun: boolFlag(flags, 'dry-run') });
-
-    persistUndo(result);
-    printWrite(out, result, () => out.info(out.c.green('✓ edited') + ` ${result.meta.edited} stack(s)`));
-    return 0;
+    if (!finish && !condition && tagStr == null) {
+      throw usageError('nothing to edit — pass --finish, --condition, or --tag');
+    }
+    return runMutation(ctx, session, args, { verb: 'edit' });
   },
 };

package/src/commands/export.mjs

@@ -1,56 +1,72 @@
 import { writeFileSync } from 'node:fs';
-import { loadSnapshot } from '../mutate.mjs';
-import { runQuery, collectionOf } from '../snapshot.mjs';
-import { getAdapter } from '../../vendor/adapters.js';
-import { buildPortableArchive, portableArchiveToJson } from '../../vendor/portableArchive.js';
-import { strFlag, boolFlag } from '../args.mjs';
-import { usageError, CliError } from '../errors.mjs';
+import { strFlag, boolFlag, intFlag } from '../args.mjs';
+import { toCsv } from '../csv.mjs';
+import { pickRows } from '../render.mjs';
+import { EXIT } from '../constants.mjs';
 
-const CSV_FORMATS = ['canonical', 'moxfield', 'manabox', 'deckbox'];
+const INVENTORY_EXPORT_COLUMNS = [
+  'name',
+  'setCode',
+  'cn',
+  'finish',
+  'condition',
+  'qty',
+  'location',
+  'tags',
+  'price',
+];
 
 export default {
-  summary: 'export your collection to csv / json',
-  help: [
-    'usage: bp export [query] [--format canonical|moxfield|manabox|deckbox|json] [--output file]',
-    '       bp export --archive [--output backup.json]   (full round-trippable backup)',
-    '',
-    'with a query, exports only the matching cards (e.g. bp export "f:foil" --format moxfield).',
-    'writes to stdout unless --output is given.',
-  ].join('\n'),
+  summary: 'export your collection (CSV/JSON)',
+  help: `bp export [--deck NAME] [--format csv|json] [--all] [--output FILE]
+
+Export your inventory (default) or a deck's list (--deck NAME). CSV by default.
+--all pages the entire collection (otherwise one page). Writes to --output, or
+stdout if omitted. The inventory CSV round-trips with \`bp import\`.`,
   async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    const { snapshot } = await loadSnapshot(session);
-    const file = strFlag(flags, 'output', 'o');
+    const session = await ctx.makeSession();
+    const deck = strFlag(ctx.flags, 'deck');
+    const format = (
+      strFlag(ctx.flags, 'format') || (boolFlag(ctx.flags, 'json') ? 'json' : 'csv')
+    ).toLowerCase();
 
-    let body;
+    const rows = [];
     let meta;
-    if (boolFlag(flags, 'archive')) {
-      const archive = buildPortableArchive({ snapshot });
-      if (!archive) throw new CliError('could not build archive');
-      body = portableArchiveToJson(archive);
-      meta = { kind: 'archive' };
+    if (deck) {
+      const sc = await session.call('query_collection', { from: 'decklist', deckName: deck });
+      rows.push(...pickRows(sc));
+      meta = { deck };
     } else {
-      const cards = runQuery(collectionOf(snapshot), args.join(' '));
-      const format = strFlag(flags, 'format') || 'canonical';
-      if (format === 'json') {
-        body = JSON.stringify(cards, null, 2);
-      } else if (CSV_FORMATS.includes(format)) {
-        body = getAdapter(format).export(cards);
-      } else {
-        throw usageError(`unknown format: ${format} (use ${CSV_FORMATS.join('/')}, json, or --archive)`);
-      }
-      meta = { format, count: cards.length };
+      const all = boolFlag(ctx.flags, 'all');
+      const limit = intFlag(ctx.flags, 'limit');
+      let cursor;
+      let pages = 0;
+      do {
+        const args = { from: 'inventory' };
+        if (limit) args.limit = limit;
+        if (cursor) args.cursor = cursor;
+        const sc = await session.call('query_collection', args);
+        rows.push(...pickRows(sc));
+        cursor = all ? sc?.nextCursor : undefined;
+        pages += 1;
+      } while (cursor && pages < 1000);
+      meta = { count: rows.length };
     }
 
+    const payload =
+      format === 'json'
+        ? JSON.stringify({ ...meta, rows }, null, 2) + '\n'
+        : toCsv(rows, deck ? undefined : INVENTORY_EXPORT_COLUMNS);
+
+    const file = strFlag(ctx.flags, 'output');
     if (file) {
-      writeFileSync(file, body.endsWith('\n') ? body : body + '\n');
-      out.emit({ file, ...meta }, () => out.info(`wrote ${file}`));
-    } else if (out.json) {
-      out.emit({ ...meta, body });
+      writeFileSync(file, payload);
+      ctx.out.emit({ written: file, count: rows.length }, () =>
+        ctx.out.info(`wrote ${rows.length} rows to ${file}`),
+      );
     } else {
-      out.raw(body);
+      ctx.out.raw(payload.replace(/\n$/, ''));
     }
-    return 0;
+    return EXIT.OK;
   },
 };

package/src/commands/history.mjs

@@ -0,0 +1,24 @@
+import { intFlag } from '../args.mjs';
+import { emitResult } from '../render.mjs';
+
+export default {
+  summary: 'recent collection changes',
+  help: `bp history [--limit N]
+
+Recent change events for your collection.`,
+  async run(ctx) {
+    const session = await ctx.makeSession();
+    const args = { from: 'history' };
+    const limit = intFlag(ctx.flags, 'limit');
+    if (limit != null) args.limit = limit;
+    const sc = await session.call('query_collection', args);
+    return emitResult(ctx, sc, {
+      columns: [
+        { key: 'type', header: 'type' },
+        { key: 'summary', header: 'summary' },
+        { key: 'description', header: 'description' },
+        { key: 'at', header: 'when' },
+      ],
+    });
+  },
+};

package/src/commands/import.mjs

@@ -1,94 +1,66 @@
 import { readFileSync } from 'node:fs';
-import { parseCsv } from '../../vendor/importParsing.js';
-import { detectAdapter } from '../../vendor/adapters.js';
-import { mergeIntoCollection } from '../../vendor/importMerge.js';
-import { normalizeCollectionEntry } from '../../vendor/collection.js';
-import { resolvePrinting, cardToFields, sleep } from '../scryfall.mjs';
-import { applyMutation } from '../mutate.mjs';
-import { boolFlag } from '../args.mjs';
-import { requireWrite, ensureContainer, printWrite } from './writeHelpers.mjs';
+import { strFlag } from '../args.mjs';
 import { usageError, CliError } from '../errors.mjs';
+import { fromCsv } from '../csv.mjs';
+import { runMutation } from '../mutate.mjs';
+import { EXIT } from '../constants.mjs';
 
-// Pushed in chunks so a large import stays within the worker's per-request CPU
-// and payload limits; each chunk is one revision. Not undoable (too large).
-const CHUNK = 150;
+// The server caps mutate_inventory at 200 items/call; keep v1 import to a single
+// call and tell the user to split larger files (auto-chunking can come later).
+const MAX_ROWS = 200;
 
 export default {
-  summary: 'import cards from a csv file (moxfield/manabox/deckbox/canonical)',
-  help: [
-    'usage: bp import <file.csv> [--no-resolve] [--dry-run]',
-    '',
-    'auto-detects the csv format and merges the cards into your cloud collection.',
-    'by default each card is resolved on scryfall so it is fully searchable; pass',
-    '--no-resolve to import as-is (faster, but no oracle/color/price data).',
-  ].join('\n'),
-  async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    requireWrite(session);
-    const path = args[0];
-    if (!path) throw usageError('usage: bp import <file.csv>');
+  summary: 'import cards from a CSV file',
+  help: `bp import <file.csv> [--to LOCATION] [--yes] [--dry-run]
 
+Bulk-add cards from CSV (previewed and confirmed like any write). Columns:
+setCode (or set), cn, finish, qty, condition, tags (; or | separated), location.
+--to overrides the location for every row. Up to ${MAX_ROWS} rows per file.`,
+  async run(ctx) {
+    const file = ctx.args[0] || strFlag(ctx.flags, 'input');
+    if (!file) throw usageError('usage: bp import <file.csv> [--to LOCATION]');
     let text;
-    try { text = readFileSync(path, 'utf8'); } catch { throw new CliError('cannot read file: ' + path); }
-    const rows = parseCsv(text);
-    if (rows.length < 2) throw new CliError('no rows found in ' + path);
-    const adapter = detectAdapter(rows[0]);
-    if (!adapter) throw new CliError('could not detect a supported csv format (moxfield/manabox/deckbox/canonical)');
-    let entries = adapter.parse(rows);
-    if (!entries.length) throw new CliError('no cards parsed from ' + path);
-
-    let resolved = 0;
-    let unresolved = 0;
-    if (!boolFlag(flags, 'no-resolve')) {
-      out.info(`resolving ${entries.length} card(s) on scryfall…`);
-      const next = [];
-      for (let i = 0; i < entries.length; i += 1) {
-        const e = entries[i];
-        let card = null;
-        try { card = await resolvePrinting({ scryfallId: e.scryfallId || null, set: e.setCode, cn: e.cn, name: e.name }); } catch { /* leave unresolved */ }
-        if (card) {
-          resolved += 1;
-          next.push(normalizeCollectionEntry({
-            ...cardToFields(card, e.finish), finish: e.finish, qty: e.qty,
-            condition: e.condition, language: e.language, location: e.location, tags: e.tags,
-            ...(e._source ? { _source: e._source } : {}),
-          }, { preserveResolvedFields: true }));
-        } else {
-          unresolved += 1;
-          next.push(e);
-        }
-        if ((i + 1) % 25 === 0) out.info(out.c.dim(`  ${i + 1}/${entries.length}`));
-        await sleep(80);
-      }
-      entries = next;
+    try {
+      text = readFileSync(file, 'utf8');
+    } catch (e) {
+      throw new CliError(`cannot read ${file}: ${e.message}`, EXIT.USAGE);
     }
-
-    if (boolFlag(flags, 'dry-run')) {
-      const result = await applyMutation(session, (draft) => {
-        for (const e of entries) ensureContainer(draft, e.location);
-        draft.app.collection = mergeIntoCollection(draft.app.collection, entries);
-        return { format: adapter.id, imported: entries.length, resolved, unresolved };
-      }, { dryRun: true });
-      printWrite(out, result, () => out.info(out.c.dim(`dry run — would import ${entries.length} card(s) (${adapter.id})`)));
-      return 0;
+    const rows = fromCsv(text);
+    if (!rows.length) throw new CliError(`no rows found in ${file}`, EXIT.USAGE);
+    if (rows.length > MAX_ROWS) {
+      throw new CliError(
+        `${rows.length} rows exceeds the ${MAX_ROWS}-row per-import cap — split the file`,
+        EXIT.USAGE,
+      );
     }
 
-    let revision = 0;
-    for (let i = 0; i < entries.length; i += CHUNK) {
-      const chunk = entries.slice(i, i + CHUNK);
-      const result = await applyMutation(session, (draft) => {
-        for (const e of chunk) ensureContainer(draft, e.location);
-        draft.app.collection = mergeIntoCollection(draft.app.collection, chunk);
-      });
-      revision = result.revision || revision;
-      if (entries.length > CHUNK) out.info(out.c.dim(`  pushed ${Math.min(i + CHUNK, entries.length)}/${entries.length}`));
-    }
+    const to = strFlag(ctx.flags, 'to');
+    const items = rows.map((r) => {
+      const item = {};
+      const set = r.setCode || r.set;
+      if (set) item.setCode = set;
+      if (r.cn) item.cn = r.cn;
+      if (r.finish) item.finish = r.finish;
+      const qty = parseInt(r.qty, 10);
+      item.qty = Number.isFinite(qty) && qty > 0 ? qty : 1;
+      if (r.condition) item.condition = r.condition;
+      if (r.tags) {
+        item.tags = String(r.tags)
+          .split(/[;|]/)
+          .map((s) => s.trim())
+          .filter(Boolean);
+      }
+      const loc = to || r.location;
+      if (loc) item.location = loc;
+      return item;
+    });
 
-    out.emit(
-      { changed: true, imported: entries.length, format: adapter.id, resolved, unresolved, revision },
-      () => out.info(out.c.green('✓ imported') + ` ${entries.length} card(s) (${adapter.id})` + (unresolved ? `, ${unresolved} unresolved` : '')),
+    const session = await ctx.makeSession({ write: true });
+    return runMutation(
+      ctx,
+      session,
+      { operation: 'add', items },
+      { verb: `import ${items.length} rows` },
     );
-    return 0;
   },
 };

package/src/commands/index.mjs

@@ -1,40 +1,64 @@
-import login from './login.mjs';
-import logout from './logout.mjs';
-import whoami from './whoami.mjs';
-import search from './search.mjs';
+// Command registry. Each command is { summary, help?, run(ctx) }.
 import summary from './summary.mjs';
+import search from './search.mjs';
 import ls from './ls.mjs';
-import show from './show.mjs';
 import deck from './deck.mjs';
+import value from './value.mjs';
+import prices from './prices.mjs';
+import history from './history.mjs';
+import resolve from './resolve.mjs';
+import exportCmd from './export.mjs';
+import importCmd from './import.mjs';
 import add from './add.mjs';
 import rm from './rm.mjs';
 import move from './move.mjs';
 import edit from './edit.mjs';
-import tag from './tag.mjs';
-import container from './container.mjs';
 import undo from './undo.mjs';
-import importCmd from './import.mjs';
-import exportCmd from './export.mjs';
+import recover from './recover.mjs';
+import login from './login.mjs';
+import logout from './logout.mjs';
+import whoami from './whoami.mjs';
 
-// Registry. commandOrder controls help-listing order.
 export const commands = {
-  login,
-  logout,
-  whoami,
-  search,
   summary,
+  search,
   ls,
-  show,
   deck,
+  value,
+  prices,
+  history,
+  resolve,
+  export: exportCmd,
+  import: importCmd,
   add,
   rm,
   move,
   edit,
-  tag,
-  container,
   undo,
-  import: importCmd,
-  export: exportCmd,
+  recover,
+  login,
+  logout,
+  whoami,
 };
 
-export const commandOrder = Object.keys(commands);
+export const commandOrder = [
+  'summary',
+  'search',
+  'ls',
+  'deck',
+  'value',
+  'prices',
+  'history',
+  'resolve',
+  'export',
+  'import',
+  'add',
+  'rm',
+  'move',
+  'edit',
+  'undo',
+  'recover',
+  'login',
+  'logout',
+  'whoami',
+];

package/src/commands/login.mjs

@@ -1,48 +1,39 @@
-import { login as oauthLogin } from '../oauth.mjs';
+import { login } from '../oauth.mjs';
 import { saveCredentials } from '../store.mjs';
-import { Session } from '../api.mjs';
-import { READ_SCOPE, WRITE_SCOPE } from '../constants.mjs';
+import { READ_SCOPE, WRITE_SCOPE, EXIT } from '../constants.mjs';
 import { boolFlag } from '../args.mjs';
-import { loadSnapshot } from '../mutate.mjs';
-import { summarize, collectionOf } from '../snapshot.mjs';
 
 export default {
-  summary: 'sign in to your collection',
-  help: [
-    'usage: bp login [--write] [--no-browser]',
-    '',
-    'opens your browser once to authorize the cli, then stores a refresh token',
-    'locally so future commands stay signed in (~30 days).',
-    '',
-    '  --write       also request permission to make changes (add/edit/import)',
-    '  --no-browser  print the url to open manually instead of launching a browser',
-  ].join('\n'),
-  async run(ctx) {
-    const { out, flags, apiBase } = ctx;
-    const scope = boolFlag(flags, 'write') ? `${READ_SCOPE} ${WRITE_SCOPE}` : READ_SCOPE;
-    const tokens = await oauthLogin({ base: apiBase, scope, out, noBrowser: boolFlag(flags, 'no-browser') });
+  summary: 'sign in via your browser',
+  help: `bp login [--write] [--no-browser]
+
+Authenticate via your browser (OAuth 2.0 + PKCE) and store credentials locally.
+Requests read-only access by default; --write also allows modifying your
+collection. --no-browser just prints the URL to open manually (useful over SSH).
 
-    const creds = {
+For headless / CI use, skip login and set BIBLIOPLEX_TOKEN to a personal access
+token (created in the Biblioplex web app) instead.`,
+  async run(ctx) {
+    const scope = boolFlag(ctx.flags, 'write') ? `${READ_SCOPE} ${WRITE_SCOPE}` : READ_SCOPE;
+    const { tokens, clientId, tokenEndpoint } = await login({
+      origin: ctx.apiOrigin,
+      scope,
+      out: ctx.out,
+      noBrowser: boolFlag(ctx.flags, 'no-browser'),
+    });
+    const granted = tokens.scope || scope;
+    saveCredentials({
       accessToken: tokens.access_token,
       refreshToken: tokens.refresh_token,
-      accessExpiresAt: Date.now() + (Number(tokens.expires_in) || 3600) * 1000,
-      scope: tokens.scope || scope,
-      apiBase,
-      loggedInAt: new Date().toISOString(),
-    };
-    saveCredentials(creds);
-
-    let stats = null;
-    try {
-      const session = new Session({ base: apiBase, credentials: creds, persist: saveCredentials });
-      const { snapshot } = await loadSnapshot(session);
-      stats = summarize(collectionOf(snapshot));
-    } catch { /* confirmation is best-effort */ }
-
-    out.emit({ loggedIn: true, scope: creds.scope, collection: stats }, () => {
-      out.info(out.c.green('✓ signed in') + ' — scope: ' + creds.scope);
-      if (stats) out.info(`cloud collection: ${stats.unique} unique · ${stats.total} cards · $${stats.value}`);
+      expiresAt: Date.now() + (tokens.expires_in ? tokens.expires_in * 1000 : 3_600_000),
+      scope: granted,
+      clientId,
+      tokenEndpoint,
+      origin: ctx.apiOrigin,
     });
-    return 0;
+    ctx.out.emit({ status: 'signed_in', scope: granted, origin: ctx.apiOrigin }, () =>
+      ctx.out.line(`signed in (${granted})`),
+    );
+    return EXIT.OK;
   },
 };

package/src/commands/logout.mjs

@@ -1,16 +1,19 @@
-import { loadCredentials, clearCredentials } from '../store.mjs';
-import { revokeToken } from '../oauth.mjs';
+import { clearCredentials } from '../store.mjs';
+import { EXIT } from '../constants.mjs';
 
 export default {
-  summary: 'sign out and revoke the session',
-  help: 'usage: bp logout\n\nrevokes the stored tokens server-side and deletes the local credentials file.',
+  summary: 'sign out (clears local credentials)',
+  help: `bp logout
+
+Remove locally stored credentials. Biblioplex has no server-side token
+revocation, so existing tokens remain valid until they expire (access ~1h,
+refresh ~30d). To kill a credential sooner, revoke the relevant personal access
+token in the Biblioplex web app.`,
   async run(ctx) {
-    const { out, apiBase } = ctx;
-    const creds = loadCredentials();
-    if (creds?.refreshToken) await revokeToken({ base: apiBase, token: creds.refreshToken });
-    if (creds?.accessToken) await revokeToken({ base: apiBase, token: creds.accessToken });
     clearCredentials();
-    out.emit({ loggedOut: true }, () => out.info(out.c.green('✓ signed out')));
-    return 0;
+    ctx.out.emit({ status: 'signed_out' }, () =>
+      ctx.out.line('signed out (local credentials cleared)'),
+    );
+    return EXIT.OK;
   },
 };