@botdocs/cli 0.3.2 → 0.4.0

package/dist/commands/views/sync-app.js

@@ -0,0 +1,147 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useReducer, useRef } from 'react';
+import { Box, Text, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import { theme } from './theme.js';
+import { initialState, syncReducer, } from './sync-state.js';
+import { ConflictPrompt } from './conflict-prompt.js';
+/** Map a row state to a one-character status icon. Active states ('checking',
+ * 'updating') render a spinner instead and pass `null` through here. */
+function statusIcon(state) {
+    switch (state) {
+        case 'queued':
+            return { glyph: '◌', color: theme.zinc };
+        case 'up-to-date':
+        case 'updated':
+            return { glyph: '✓', color: theme.green };
+        case 'skipped':
+            return { glyph: '⌀', color: theme.zinc };
+        case 'conflict':
+            return { glyph: '⚠', color: theme.amber };
+        case 'error':
+            return { glyph: '✗', color: theme.red };
+        // checking/updating handled by the spinner branch in the renderer.
+        default:
+            return { glyph: ' ', color: theme.zinc };
+    }
+}
+/** Right-hand details text for a row. Keeps the rendering consistent across
+ * the per-section loops below. */
+function detailsText(row) {
+    if (row.details)
+        return row.details;
+    switch (row.state) {
+        case 'queued':
+            return 'queued';
+        case 'checking':
+            return 'checking...';
+        case 'up-to-date':
+            return 'up to date';
+        case 'updating':
+            return 'installing...';
+        case 'updated':
+            return 'updated';
+        case 'skipped':
+            return 'skipped';
+        case 'conflict':
+            return 'local edits detected';
+        case 'error':
+            return 'error';
+        default:
+            return '';
+    }
+}
+/** Render one row. Conflict rows still render through this — the inline
+ * `<ConflictPrompt />` is rendered separately below the section so the user
+ * sees the row + the choice list together. */
+function Row({ row }) {
+    const isActive = row.state === 'checking' || row.state === 'updating';
+    const { glyph, color } = statusIcon(row.state);
+    return (_jsxs(Box, { marginLeft: 2, children: [_jsx(Box, { width: 2, children: isActive ? (_jsx(Text, { color: theme.cyan, children: _jsx(Spinner, { type: "dots" }) })) : (_jsx(Text, { color: color, children: glyph })) }), _jsx(Text, { children: row.ref }), _jsxs(Text, { color: theme.zinc, children: [" \u2014 ", detailsText(row)] })] }));
+}
+/** Group rows by their `team` field. Personal rows (no team) come first;
+ * teams are sorted alphabetically by slug to keep the layout stable across
+ * runs even when the server returns teams in a different order. */
+function groupByTeam(rows) {
+    const personal = [];
+    const byTeam = new Map();
+    for (const r of rows) {
+        if (!r.team) {
+            personal.push(r);
+            continue;
+        }
+        const list = byTeam.get(r.team) ?? [];
+        list.push(r);
+        byTeam.set(r.team, list);
+    }
+    const sections = [];
+    if (personal.length > 0)
+        sections.push({ team: null, rows: personal });
+    const teamSlugs = Array.from(byTeam.keys()).sort();
+    for (const slug of teamSlugs) {
+        sections.push({ team: slug, rows: byTeam.get(slug) });
+    }
+    return sections;
+}
+/** Live Ink view for `botdocs sync`. Owns the reducer state and the conflict
+ * resolver Map. On mount it kicks off `runSync` with a dispatch/awaiter pair —
+ * the awaiter parks a Promise resolver keyed by `ref|file` in a ref-held Map,
+ * and the inline `<ConflictPrompt />` resolves it when the user picks. */
+export function SyncApp({ initialRows, runSync }) {
+    const [state, dispatch] = useReducer(syncReducer, initialRows, (rows) => syncReducer(initialState(), { type: 'INIT', rows }));
+    const conflictResolvers = useRef(new Map());
+    const { exit } = useApp();
+    const didRun = useRef(false);
+    // Kick off the sync once on mount. Strict-mode-style double-invocation would
+    // re-run; we guard with a ref because the work has side effects.
+    useEffect(() => {
+        if (didRun.current)
+            return;
+        didRun.current = true;
+        const awaitConflictChoice = (ref, file) => new Promise((resolve) => {
+            const key = `${ref}|${file}`;
+            conflictResolvers.current.set(key, resolve);
+            // Wire up the row-level resolver so the inline <ConflictPrompt /> can
+            // call it directly without needing to know which file is active.
+            dispatch({
+                type: 'CONFLICT',
+                ref,
+                details: file,
+                resolveConflict: (choice) => {
+                    const r = conflictResolvers.current.get(key);
+                    if (r) {
+                        conflictResolvers.current.delete(key);
+                        r(choice);
+                    }
+                },
+            });
+        });
+        runSync({ dispatch, awaitConflictChoice }).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            // Surface fatal errors as a synthetic row + finish so the user still
+            // sees something rather than an empty frame.
+            dispatch({ type: 'FINISH', elapsedMs: 0 });
+            // Re-throw via process.nextTick so the unmount completes first.
+            process.nextTick(() => {
+                throw err instanceof Error ? err : new Error(message);
+            });
+        });
+        // Intentionally only depend on first mount; the runner is consumed once.
+    }, []);
+    // Hold the final summary briefly before unmounting so the user can read it.
+    useEffect(() => {
+        if (state.finished) {
+            const timer = setTimeout(() => exit(), 600);
+            return () => clearTimeout(timer);
+        }
+        return undefined;
+    }, [state.finished, exit]);
+    const { rows, summary, finished, elapsedMs } = state;
+    const sections = groupByTeam(rows);
+    const totals = `${rows.length} file${rows.length === 1 ? '' : 's'}`;
+    // Find the first unresolved conflict row to render the inline prompt under.
+    // Only one conflict prompt is active at a time because the runner awaits
+    // each one before moving on.
+    const activeConflict = rows.find((r) => r.state === 'conflict' && Boolean(r.resolveConflict));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { bold: true, color: theme.cyan, children: "BotDocs sync" }), _jsx(Text, { color: theme.zinc, children: totals }), sections.map((section) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.violet, children: section.team ? `TEAM ${section.team}` : 'PERSONAL' }), section.rows.map((r) => (_jsx(Row, { row: r }, r.ref)))] }, section.team ?? '__personal'))), activeConflict ? (_jsx(ConflictPrompt, { row: activeConflict, onChoice: (choice) => activeConflict.resolveConflict?.(choice) })) : null, finished ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.zinc, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { children: [_jsxs(Text, { color: theme.green, children: [summary.updated, " updated"] }), _jsx(Text, { color: theme.zinc, children: " \u00B7 " }), _jsxs(Text, { color: theme.green, children: [summary.upToDate, " up to date"] }), summary.skipped > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.zinc, children: " \u00B7 " }), _jsxs(Text, { color: theme.zinc, children: [summary.skipped, " skipped"] })] })) : null, summary.conflict > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.zinc, children: " \u00B7 " }), _jsxs(Text, { color: theme.amber, children: [summary.conflict, " conflict"] })] })) : null, summary.error > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.zinc, children: " \u00B7 " }), _jsxs(Text, { color: theme.red, children: [summary.error, " error"] })] })) : null, typeof elapsedMs === 'number' ? (_jsxs(Text, { color: theme.zinc, children: [' · ', "finished in ", (elapsedMs / 1000).toFixed(1), "s"] })) : null] })] })) : null] }));
+}

package/dist/commands/views/sync-state.d.ts

@@ -0,0 +1,84 @@
+/** Pure reducer + types for the Ink sync view. Kept in a separate file from
+ * the React component so we can drive it through unit tests without rendering. */
+/** Per-row state machine. The order roughly tracks the path a row takes during
+ * a sync: queued → checking → (up-to-date | updating → updated | conflict →
+ * skipped|updated | error). 'skipped' is reachable both from clean-update
+ * "skip" and from conflict "skip"; both render identically. */
+export type SyncFileState = 'queued' | 'checking' | 'up-to-date' | 'updating' | 'updated' | 'conflict' | 'skipped' | 'error';
+export interface SyncFileRow {
+    /** Display label, typically `@user/slug` or `@user/slug:filename`. */
+    ref: string;
+    /** Owning section. `undefined` is treated as the personal section. */
+    team?: string;
+    /** Optional secondary detail (e.g. version delta or error message). */
+    details?: string;
+    state: SyncFileState;
+    /** When `state === 'conflict'`, optional handler the view layer can call
+     * with the user's selection. Kept off the wire format and out of summaries.
+     *
+     * The live Ink view sets this via `CONFLICT` so the inline `<SelectInput />`
+     * can resolve the promise the runner is awaiting. When undefined, the row
+     * is in a non-interactive "conflict" presentation (e.g. test fixtures). */
+    resolveConflict?: (choice: 'overwrite' | 'skip' | 'keep') => void;
+}
+export interface SyncSummary {
+    updated: number;
+    upToDate: number;
+    conflict: number;
+    error: number;
+    skipped: number;
+}
+export interface SyncState {
+    rows: SyncFileRow[];
+    summary: SyncSummary;
+    /** Wall-clock ms since the sync started. Set on FINISH so the final summary
+     * can render "finished in X.Ys" without the view layer needing its own timer. */
+    elapsedMs?: number;
+    /** True once the parent driver has dispatched FINISH. View uses this to
+     * render the divider + summary footer and stop showing active spinners. */
+    finished: boolean;
+}
+export type SyncAction = {
+    type: 'INIT';
+    rows: Array<{
+        ref: string;
+        team?: string;
+    }>;
+} | {
+    type: 'ADD_ROW';
+    ref: string;
+    team?: string;
+} | {
+    type: 'CHECKING';
+    ref: string;
+} | {
+    type: 'UP_TO_DATE';
+    ref: string;
+    details?: string;
+} | {
+    type: 'UPDATING';
+    ref: string;
+    details?: string;
+} | {
+    type: 'UPDATED';
+    ref: string;
+    details?: string;
+} | {
+    type: 'CONFLICT';
+    ref: string;
+    details?: string;
+    resolveConflict?: (choice: 'overwrite' | 'skip' | 'keep') => void;
+} | {
+    type: 'SKIPPED';
+    ref: string;
+    details?: string;
+} | {
+    type: 'ERROR';
+    ref: string;
+    details?: string;
+} | {
+    type: 'FINISH';
+    elapsedMs: number;
+};
+export declare function initialState(): SyncState;
+export declare function syncReducer(state: SyncState, action: SyncAction): SyncState;

package/dist/commands/views/sync-state.js

@@ -0,0 +1,93 @@
+/** Pure reducer + types for the Ink sync view. Kept in a separate file from
+ * the React component so we can drive it through unit tests without rendering. */
+export function initialState() {
+    return {
+        rows: [],
+        summary: { updated: 0, upToDate: 0, conflict: 0, error: 0, skipped: 0 },
+        finished: false,
+    };
+}
+/** Recompute the summary counts from rows in their current state. We keep
+ * `summary` in sync this way (rather than incrementing on each transition) so
+ * a row moving from CONFLICT → UPDATED doesn't double-count. */
+function recomputeSummary(rows) {
+    const s = { updated: 0, upToDate: 0, conflict: 0, error: 0, skipped: 0 };
+    for (const r of rows) {
+        if (r.state === 'updated')
+            s.updated++;
+        else if (r.state === 'up-to-date')
+            s.upToDate++;
+        else if (r.state === 'conflict')
+            s.conflict++;
+        else if (r.state === 'error')
+            s.error++;
+        else if (r.state === 'skipped')
+            s.skipped++;
+    }
+    return s;
+}
+function updateRow(state, ref, patch) {
+    const rows = state.rows.map((r) => (r.ref === ref ? { ...r, ...patch } : r));
+    return { ...state, rows, summary: recomputeSummary(rows) };
+}
+export function syncReducer(state, action) {
+    switch (action.type) {
+        case 'INIT': {
+            const rows = action.rows.map((r) => ({
+                ref: r.ref,
+                team: r.team,
+                state: 'queued',
+            }));
+            return { rows, summary: recomputeSummary(rows), finished: false };
+        }
+        case 'ADD_ROW': {
+            // Late-added row (e.g. team-pinned skills surfaced after personal sync).
+            // No-op if a row with this ref already exists — keep the existing state.
+            if (state.rows.some((r) => r.ref === action.ref))
+                return state;
+            const rows = [
+                ...state.rows,
+                { ref: action.ref, team: action.team, state: 'queued' },
+            ];
+            return { ...state, rows, summary: recomputeSummary(rows) };
+        }
+        case 'CHECKING':
+            return updateRow(state, action.ref, { state: 'checking' });
+        case 'UP_TO_DATE':
+            return updateRow(state, action.ref, {
+                state: 'up-to-date',
+                details: action.details,
+                resolveConflict: undefined,
+            });
+        case 'UPDATING':
+            return updateRow(state, action.ref, { state: 'updating', details: action.details });
+        case 'UPDATED':
+            return updateRow(state, action.ref, {
+                state: 'updated',
+                details: action.details,
+                resolveConflict: undefined,
+            });
+        case 'CONFLICT':
+            return updateRow(state, action.ref, {
+                state: 'conflict',
+                details: action.details,
+                resolveConflict: action.resolveConflict,
+            });
+        case 'SKIPPED':
+            return updateRow(state, action.ref, {
+                state: 'skipped',
+                details: action.details,
+                resolveConflict: undefined,
+            });
+        case 'ERROR':
+            return updateRow(state, action.ref, {
+                state: 'error',
+                details: action.details,
+                resolveConflict: undefined,
+            });
+        case 'FINISH':
+            return { ...state, elapsedMs: action.elapsedMs, finished: true };
+        default:
+            return state;
+    }
+}

package/dist/commands/views/theme.d.ts

@@ -0,0 +1,16 @@
+/** Shared BotDocs CLI theme tokens. Mirrors the web app's Tailwind palette so
+ * the brand stays consistent across surfaces. Values are hex strings; Ink
+ * components accept hex directly for `color` and `backgroundColor` props. */
+export declare const theme: {
+    readonly cyan: "#22d3ee";
+    readonly violet: "#a78bfa";
+    readonly green: "#34d399";
+    readonly amber: "#fbbf24";
+    readonly red: "#f87171";
+    readonly zinc: "#71717a";
+};
+/** Width below which we skip the `ink-big-text` ASCII wordmark and fall back
+ * to a plain bold "botdocs" line — narrower terminals render the big-text
+ * with awkward wrapping. 60 was chosen empirically: a 50-column wordmark plus
+ * margins fits comfortably above that. */
+export declare const BIG_TEXT_MIN_COLS = 60;

package/dist/commands/views/theme.js

@@ -0,0 +1,16 @@
+/** Shared BotDocs CLI theme tokens. Mirrors the web app's Tailwind palette so
+ * the brand stays consistent across surfaces. Values are hex strings; Ink
+ * components accept hex directly for `color` and `backgroundColor` props. */
+export const theme = {
+    cyan: '#22d3ee', // Tailwind cyan-400 — primary brand
+    violet: '#a78bfa', // Tailwind violet-400 — secondary brand
+    green: '#34d399', // Tailwind emerald-400 — success
+    amber: '#fbbf24', // Tailwind amber-400 — warning
+    red: '#f87171', // Tailwind red-400 — error
+    zinc: '#71717a', // Tailwind zinc-500 — subtle / hint
+};
+/** Width below which we skip the `ink-big-text` ASCII wordmark and fall back
+ * to a plain bold "botdocs" line — narrower terminals render the big-text
+ * with awkward wrapping. 60 was chosen empirically: a 50-column wordmark plus
+ * margins fits comfortably above that. */
+export const BIG_TEXT_MIN_COLS = 60;

package/dist/commands/whoami.js

@@ -1,26 +1,26 @@
 import { loadAuth } from '../lib/config.js';
+import { apiFetch, ApiError } from '../lib/api.js';
 export async function whoami(options = {}) {
     const auth = loadAuth();
     if (!auth) {
         console.log('Not logged in. Run `botdocs login` to authenticate.');
         process.exit(1);
     }
-    // Verify token is still valid
-    const response = await fetch('https://api.github.com/user', {
-        headers: {
-            Authorization: `Bearer ${auth.githubToken}`,
-            Accept: 'application/vnd.github+json',
-        },
-    });
-    if (!response.ok) {
-        console.log('Session expired. Run `botdocs login` to re-authenticate.');
-        process.exit(1);
+    let user;
+    try {
+        user = await apiFetch('/api/cli/whoami', { auth: true });
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 401) {
+            console.log('Authentication failed. Run `botdocs login` to sign in again.');
+            process.exit(1);
+        }
+        throw err;
     }
-    const user = (await response.json());
     if (options.json) {
-        console.log(JSON.stringify({ login: user.login, name: user.name }));
+        console.log(JSON.stringify({ login: user.username, name: user.displayName }));
     }
     else {
-        console.log(`Logged in as ${user.login}${user.name ? ` (${user.name})` : ''}`);
+        console.log(`Logged in as ${user.username}${user.displayName && user.displayName !== user.username ? ` (${user.displayName})` : ''}`);
     }
 }

package/dist/index.js

@@ -1,15 +1,11 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { clone } from './commands/clone.js';
 import { search } from './commands/search.js';
 import { publish } from './commands/publish.js';
-import { pull } from './commands/pull.js';
 import { login } from './commands/login.js';
 import { whoami } from './commands/whoami.js';
 import { init } from './commands/init.js';
 import { validate } from './commands/validate.js';
-import { diff } from './commands/diff.js';
-import { endorse } from './commands/endorse.js';
 import { installInstructions } from './commands/install-instructions.js';
 import { install } from './commands/install.js';
 import { list } from './commands/list.js';
@@ -19,11 +15,17 @@ import { ingest } from './commands/ingest.js';
 import { checkUpdates } from './commands/check-updates.js';
 import { compile } from './commands/compile.js';
 import { edit } from './commands/edit.js';
+import { registerTeamCommands } from './commands/team.js';
+import { registerBackupCommands } from './commands/backups.js';
+import { undo } from './commands/undo.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
 const program = new Command();
 program
     .name('botdocs')
-    .description('CLI for BotDocs — clone, search, and publish concept specifications')
-    .version('0.1.0')
+    .description('CLI for BotDocs — author, publish, install, and sync agent skills')
+    .version(pkg.version)
     .option('--json', 'Output results as JSON');
 program
     .command('init [name]')
@@ -40,12 +42,6 @@ program
     .action(async (source) => {
     await validate(source, { json: program.opts().json });
 });
-program
-    .command('clone <username/slug>')
-    .description('Download all BotDoc files to a local directory')
-    .action(async (ref) => {
-    await clone(ref, { json: program.opts().json });
-});
 program
     .command('search <query>')
     .description('Search for BotDocs')
@@ -64,32 +60,17 @@ program
     .action(async (source, options) => {
     await publish(source, { ...options, json: program.opts().json });
 });
-program
-    .command('diff <username/slug>')
-    .description('Preview remote changes before pulling')
-    .action(async (ref) => {
-    await diff(ref, { json: program.opts().json });
-});
-program
-    .command('pull <username/slug>')
-    .description('Update previously cloned BotDoc files with the latest version')
-    .action(async (ref) => {
-    await pull(ref, { json: program.opts().json });
-});
-program
-    .command('endorse <username/slug>')
-    .description('Endorse a BotDoc after building from it')
-    .requiredOption('--rating <rating>', 'Rating: positive, neutral, or negative')
-    .option('--comment <comment>', 'Optional feedback about the build experience')
-    .action(async (ref, opts) => {
-    await endorse(ref, { ...opts, json: program.opts().json });
-});
 program
     .command('login')
-    .description('Authenticate via GitHub device code flow')
+    .description('Authenticate by opening your browser; or pass --token for non-interactive use')
     .option('--sync-library', 'Enable personalized Library page (uploads sanitized lockfile after install/sync/uninstall)')
+    .option('--token <token>', 'Authenticate non-interactively with a bd_<...> token (mint one at /settings/tokens)')
+    .option('--no-ink', 'Disable the live Ink UI and use plain text output (for screen readers or simple terminals)')
     .action(async (opts) => {
-    await login(opts);
+    // Commander's --no-ink convention sets opts.ink = false; flip to noInk
+    // so downstream consumers don't have to handle the inverted boolean.
+    const { ink, ...rest } = opts;
+    await login({ ...rest, noInk: ink === false });
 });
 program
     .command('whoami')
@@ -108,12 +89,16 @@ program
 });
 program
     .command('install <ref>')
-    .description('Install a skill or bundle locally (skills go to ~/.claude/skills/, project files to .cursor/rules/, etc.)')
+    .description('Install a skill or bundle locally (skills go to ~/.claude/skills/, project files to .cursor/rules/, .codex/skills/, .github/instructions/, etc.)')
     .option('--project <dir>', 'Override the project root used for project-local files')
     .option('--flat', 'Skip the {scope} subdirectory in install paths (collision-prone, not recommended)')
     .option('--clean', 'Wipe-and-reinstall instead of additive')
+    .option('--no-backup', 'Do not back up files that would be overwritten (use in CI where backups are noise)')
     .action(async (ref, opts) => {
-    await install(ref, { ...opts, json: program.opts().json });
+    // Commander's --no-backup convention sets opts.backup = false.
+    // Translate to options.noBackup for downstream consumers.
+    const { backup, ...rest } = opts;
+    await install(ref, { ...rest, noBackup: backup === false, json: program.opts().json });
 });
 program
     .command('list')
@@ -133,8 +118,16 @@ program
     .description('Check installed skills/bundles for updates and apply')
     .option('--yes', 'Auto-accept clean updates; skip files with local edits')
     .option('--dry-run', 'Show what would change without applying')
+    .option('--no-backup', 'Do not back up files that would be overwritten (use in CI where backups are noise)')
+    .option('--no-ink', 'Disable the live Ink summary view and use plain text output')
     .action(async (ref, opts) => {
-    await sync(ref, { ...opts, json: program.opts().json });
+    const { backup, ink, ...rest } = opts;
+    await sync(ref, {
+        ...rest,
+        noBackup: backup === false,
+        noInk: ink === false,
+        json: program.opts().json,
+    });
 });
 program
     .command('check-updates')
@@ -164,9 +157,22 @@ program
 program
     .command('edit <ref>')
     .description('LLM-assisted revision of a published skill ecosystem file (BYOK; pushes a draft)')
-    .requiredOption('--ecosystem <name>', 'Which ecosystem file to edit (claude, claude-code, cursor, chatgpt, codex)')
+    .requiredOption('--ecosystem <name>', 'Which ecosystem file to edit (claude, claude-code, cursor, chatgpt, codex, copilot, antigravity, gemini, opencode, windsurf)')
     .option('--key-env <name>', 'Override the env var used for the API key')
     .action(async (ref, opts) => {
     await edit(ref, { ...opts, json: program.opts().json });
 });
+registerTeamCommands(program);
+registerBackupCommands(program);
+program
+    .command('undo')
+    .description('Restore files from the most recent backup run (reversible)')
+    .option('--dry-run', 'Show what would be restored without writing')
+    .option('--yes', 'Skip the confirmation prompt')
+    .option('--no-backup', 'Skip backing up the current state before restoring (advanced)')
+    .action(async (opts) => {
+    // Commander's --no-backup convention sets opts.backup = false.
+    const { backup, ...rest } = opts;
+    await undo({ ...rest, noBackup: backup === false, json: program.opts().json });
+});
 program.parse();

package/dist/lib/api.d.ts

@@ -1,8 +1,7 @@
 export declare function getApiUrl(): string;
 /** Thrown by apiFetch when the server returns a non-2xx response. Carries the
- * status code and the server-provided message so callers can branch on it
- * (e.g. the `endorse` command surfaces a friendly hint on the 403 returned by
- * the clone-required guard). */
+ * status code and the server-provided message so callers can branch on
+ * different HTTP error codes (404 vs 403 vs 5xx) with friendly hints. */
 export declare class ApiError extends Error {
     readonly status: number;
     constructor(status: number, message: string);

package/dist/lib/api.js

@@ -1,12 +1,11 @@
 import { loadAuth } from './config.js';
-const DEFAULT_API_URL = 'https://botdocs.ai';
+const DEFAULT_API_URL = 'https://www.botdocs.ai';
 export function getApiUrl() {
     return process.env.BOTDOCS_API_URL || DEFAULT_API_URL;
 }
 /** Thrown by apiFetch when the server returns a non-2xx response. Carries the
- * status code and the server-provided message so callers can branch on it
- * (e.g. the `endorse` command surfaces a friendly hint on the 403 returned by
- * the clone-required guard). */
+ * status code and the server-provided message so callers can branch on
+ * different HTTP error codes (404 vs 403 vs 5xx) with friendly hints. */
 export class ApiError extends Error {
     status;
     constructor(status, message) {
@@ -27,10 +26,13 @@ export async function apiFetch(path, options = {}) {
     }
     if (auth) {
         const config = loadAuth();
-        if (!config?.githubToken) {
-            throw new Error('Not authenticated. Run `botdocs login` first.');
+        if (!config?.token) {
+            // Shape this as an ApiError(401) so callers that already branch on auth
+            // failures (e.g. sync's optional team-skill path) handle it uniformly
+            // without a separate "no token saved" code path.
+            throw new ApiError(401, 'Not authenticated. Run `botdocs login` first.');
         }
-        headers['Authorization'] = `Bearer ${config.githubToken}`;
+        headers['Authorization'] = `Bearer ${config.token}`;
     }
     const response = await fetch(url, {
         method,
@@ -47,6 +49,11 @@ export async function apiFetch(path, options = {}) {
         catch {
             message = text;
         }
+        // Friendlier 401 hint when the saved token is stale (e.g. left over from a
+        // previous CLI version that stored a GitHub access token).
+        if (response.status === 401 && auth) {
+            message = 'Authentication failed. Run `botdocs login` to sign in again.';
+        }
         throw new ApiError(response.status, message);
     }
     const contentType = response.headers.get('content-type') || '';

package/dist/lib/auto-detect.js

@@ -27,6 +27,52 @@ export function detectDestination(srcRelative, ctx) {
             dest: path.join(ctx.projectDir, '.cursor', 'rules', path.basename(src)),
         };
     }
+    if (src.startsWith('codex/')) {
+        return {
+            kind: 'project',
+            dest: path.join(ctx.projectDir, '.codex', 'skills', path.basename(src)),
+        };
+    }
+    if (src.startsWith('copilot/instructions/')) {
+        // GitHub Copilot custom instructions live in .github/instructions/
+        // (https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot).
+        return {
+            kind: 'project',
+            dest: path.join(ctx.projectDir, '.github', 'instructions', path.basename(src)),
+        };
+    }
+    if (src.startsWith('windsurf/rules/')) {
+        // Windsurf (Codeium) reads project rules from .codeium/windsurf-rules/
+        // (https://docs.codeium.com/windsurf/cascade#windsurfrules).
+        return {
+            kind: 'project',
+            dest: path.join(ctx.projectDir, '.codeium', 'windsurf-rules', path.basename(src)),
+        };
+    }
+    if (src.startsWith('gemini/instructions/')) {
+        // Gemini CLI reads global instructions from ~/.gemini/instructions/
+        // (https://github.com/google-gemini/gemini-cli).
+        return {
+            kind: 'global',
+            dest: path.join(ctx.homeDir, '.gemini', 'instructions', path.basename(src)),
+        };
+    }
+    if (src.startsWith('antigravity/skills/')) {
+        // Google Antigravity reads skills from ~/.gemini/antigravity/skills/
+        // (shares the gemini config tree).
+        return {
+            kind: 'global',
+            dest: path.join(ctx.homeDir, '.gemini', 'antigravity', 'skills', path.basename(src)),
+        };
+    }
+    if (src.startsWith('opencode/instructions/')) {
+        // OpenCode (SST) reads instructions from ~/.config/opencode/instructions/
+        // (https://github.com/sst/opencode).
+        return {
+            kind: 'global',
+            dest: path.join(ctx.homeDir, '.config', 'opencode', 'instructions', path.basename(src)),
+        };
+    }
     if (src.startsWith('chatgpt/')) {
         return { kind: 'manual', dest: src };
     }