@botdocs/cli 0.3.2 → 0.4.0

package/dist/commands/sync.js

@@ -1,13 +1,54 @@
+import React from 'react';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
+import { render } from 'ink';
 import { ApiError, apiFetch, fetchRawContent } from '../lib/api.js';
-import { loadLockfile, fingerprintFile, upsertInstall } from '../lib/lockfile.js';
+import { loadLockfile, fingerprintFile, fingerprintContent, upsertInstall, } from '../lib/lockfile.js';
 import { renderDiff, hasChanges } from '../lib/diff.js';
 import { promptConflict, confirmOverwrite, promptCleanUpdate } from '../lib/prompts.js';
 import { syncLibrary } from '../lib/library-sync.js';
-async function syncSkill(entry, manifest, options) {
+import { detectDestination } from '../lib/auto-detect.js';
+import { backupDestination, backupFile, isLockfileOwnedAndUnchanged } from '../lib/backup.js';
+import { SyncApp } from './views/sync-app.js';
+/** Backup the existing content at `dest` before sync overwrites it. Skipped
+ * entirely if `--no-backup` is set or the file is "ours and unchanged" per
+ * the lockfile. Under `--dry-run`, prints the would-be backup path but does
+ * not write anything. */
+function maybeBackupBeforeSyncOverwrite(dest, options, silent) {
+    if (options.noBackup)
+        return;
+    if (!fs.existsSync(dest))
+        return;
+    if (isLockfileOwnedAndUnchanged(dest))
+        return;
+    if (options.dryRun) {
+        if (!silent && !options.json) {
+            const projectDir = process.cwd();
+            const wouldDest = backupDestination(dest, projectDir);
+            const relSrc = path.relative(projectDir, dest);
+            const relDest = path.relative(projectDir, wouldDest);
+            console.log(`  ⚠ Would back up ${relSrc} → ${relDest}`);
+        }
+        return;
+    }
+    const result = backupFile(dest, process.cwd());
+    if (!silent && !options.json) {
+        if (result.ok) {
+            const relSrc = path.relative(process.cwd(), dest);
+            const relDest = path.relative(process.cwd(), result.dest);
+            console.log(`  ⚠ Backed up existing file: ${relSrc} → ${relDest}`);
+        }
+        else {
+            console.log(`  ⚠ Could not back up ${dest}: ${result.error} — proceeding with overwrite.`);
+        }
+    }
+}
+async function syncSkill(entry, manifest, deps) {
+    const { options, awaitConflictChoice, silent } = deps;
     let updatedCount = 0;
     let skippedCount = 0;
+    let conflicted = false;
     const newFiles = [];
     for (const installedFile of entry.files) {
         const upstream = manifest.files.find((f) => f.filename === installedFile.src);
@@ -15,7 +56,9 @@ async function syncSkill(entry, manifest, options) {
             // Upstream removed this file — delete the local copy and drop the lockfile entry.
             if (fs.existsSync(installedFile.dest))
                 fs.unlinkSync(installedFile.dest);
-            console.log(`  ⌀ ${entry.ref}: removed ${installedFile.src} (no longer in upstream)`);
+            if (!silent) {
+                console.log(`  ⌀ ${entry.ref}: removed ${installedFile.src} (no longer in upstream)`);
+            }
             // Don't push to newFiles — let it drop from the lockfile.
             continue;
         }
@@ -40,6 +83,13 @@ async function syncSkill(entry, manifest, options) {
             if (options.yes) {
                 choice = 'apply';
             }
+            else if (silent) {
+                // Live Ink path treats a clean update as auto-apply — the user already
+                // implicitly consented to "sync" and there's no local edit at risk.
+                // The plain-text path keeps the three-way prompt because it has the
+                // screen real estate for a "diff" view.
+                choice = 'apply';
+            }
             else {
                 choice = await promptCleanUpdate(`${entry.ref}:${installedFile.src}`);
                 while (choice === 'diff') {
@@ -48,6 +98,11 @@ async function syncSkill(entry, manifest, options) {
                 }
             }
             if (choice === 'apply') {
+                // Clean-update branch: by definition the file is tracked and unchanged
+                // (localFp === installedFile.fingerprint), so the helper short-circuits.
+                // Still routed through for symmetry — if a future code path lands here
+                // with an untracked file we'd want it backed up.
+                maybeBackupBeforeSyncOverwrite(installedFile.dest, options, silent);
                 if (!options.dryRun) {
                     fs.writeFileSync(installedFile.dest, upstreamContent, 'utf-8');
                 }
@@ -61,20 +116,23 @@ async function syncSkill(entry, manifest, options) {
             }
             continue;
         }
-        // Conflict: local has been edited.
-        console.log(renderDiff(localContent, upstreamContent));
-        const conflict = await promptConflict(`${entry.ref}:${installedFile.src}`);
-        if (conflict === 'skip') {
-            newFiles.push(installedFile);
-            skippedCount++;
-            continue;
+        // Conflict: local has been edited. Print the diff (plain-text path only)
+        // and ask via the awaiter. The awaiter is the "ask the user" abstraction —
+        // Ink supplies a Promise resolved by the inline SelectInput; the plain
+        // path supplies one that calls clack `promptConflict` (+ confirmOverwrite).
+        conflicted = true;
+        if (!silent) {
+            console.log(renderDiff(localContent, upstreamContent));
         }
-        const sure = await confirmOverwrite(`${entry.ref}:${installedFile.src}`);
-        if (!sure) {
+        const choice = await awaitConflictChoice(entry.ref, installedFile.src);
+        if (choice === 'skip' || choice === 'keep') {
             newFiles.push(installedFile);
             skippedCount++;
             continue;
         }
+        // 'overwrite': the user accepted. Backup-on-overwrite always runs unless
+        // --no-backup. Under --dry-run we print the path but don't write.
+        maybeBackupBeforeSyncOverwrite(installedFile.dest, options, silent);
         if (!options.dryRun) {
             fs.writeFileSync(installedFile.dest, upstreamContent, 'utf-8');
         }
@@ -97,7 +155,7 @@ async function syncSkill(entry, manifest, options) {
             });
         }
     }
-    return { updated: updatedCount > 0, skipped: skippedCount };
+    return { updated: updatedCount > 0, skipped: skippedCount, conflicted };
 }
 function refToPath(ref) {
     const cleaned = ref.startsWith('@') ? ref.slice(1) : ref;
@@ -106,47 +164,291 @@ function refToPath(ref) {
         throw new Error(`Invalid ref in lockfile: ${ref}`);
     return { username, slug };
 }
-export async function sync(rawRef, options) {
+/** Install a team-pinned skill at a specific version. Mirrors the
+ * personal-install path in commands/install.ts but tags the lockfile entry
+ * with source.type = 'team' so we can identify team-pinned entries on
+ * future syncs. Idempotent — re-running with the same version is a no-op. */
+async function installTeamSkill(teamSlug, skill, options, silent) {
+    const ref = `@${skill.username}/${skill.slug}`;
+    // Determine target version: explicit pin wins, else current.
+    const targetVersion = skill.versionPin ?? skill.currentVersion;
+    if (!targetVersion) {
+        // Skill not yet published — nothing to install.
+        return { ref, status: 'skipped' };
+    }
     const lf = loadLockfile();
-    const targets = rawRef
-        ? lf.installs.filter((i) => i.ref === rawRef)
-        : lf.installs.filter((i) => i.type === 'SKILL');
-    if (targets.length === 0) {
-        console.log('\n  nothing installed to sync\n');
-        await syncLibrary();
-        return;
+    const existing = lf.installs.find((i) => i.ref === ref);
+    if (existing && existing.version === targetVersion) {
+        // Ensure source is tagged so future syncs don't lose track.
+        const isTagged = existing.source?.type === 'team' && existing.source.slug === teamSlug;
+        if (!isTagged) {
+            upsertInstall({
+                ...existing,
+                source: { type: 'team', slug: teamSlug },
+            });
+        }
+        return { ref, status: 'up-to-date' };
+    }
+    // Pull the manifest at the target version. The manifest endpoint always
+    // returns the latest published version — when we pinned to an older
+    // version we still install whatever's current. (v0 limitation; the
+    // versionPin is currently advisory for team curation rather than strict
+    // version locking.)
+    let manifest;
+    try {
+        manifest = await apiFetch(`/api/skills/${skill.username}/${skill.slug}/manifest`);
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            return { ref, status: 'skipped' };
+        }
+        throw err;
+    }
+    if (manifest.type !== 'SKILL') {
+        return { ref, status: 'skipped' };
+    }
+    const ctx = {
+        scope: skill.username,
+        slug: skill.slug,
+        homeDir: os.homedir(),
+        projectDir: process.cwd(),
+        flatScope: false,
+    };
+    const filesInstalled = [];
+    for (const file of manifest.files) {
+        const detection = detectDestination(file.filename, ctx);
+        if (detection.kind === 'skip' || detection.kind === 'manual')
+            continue;
+        const content = await fetchRawContent(file.rawUrl);
+        if (fs.existsSync(detection.dest)) {
+            const existingFp = fingerprintFile(detection.dest);
+            const tmpFp = fingerprintContent(content);
+            if (existingFp === tmpFp) {
+                filesInstalled.push({ src: file.filename, dest: detection.dest, fingerprint: existingFp });
+                continue;
+            }
+        }
+        // About to overwrite during team-pin install. Backup if untracked or
+        // locally edited.
+        maybeBackupBeforeSyncOverwrite(detection.dest, options, silent);
+        fs.mkdirSync(path.dirname(detection.dest), { recursive: true });
+        fs.writeFileSync(detection.dest, content, 'utf-8');
+        filesInstalled.push({
+            src: file.filename,
+            dest: detection.dest,
+            fingerprint: fingerprintFile(detection.dest),
+        });
     }
+    upsertInstall({
+        ref,
+        type: 'SKILL',
+        version: manifest.version,
+        installedAt: new Date().toISOString(),
+        files: filesInstalled,
+        source: { type: 'team', slug: teamSlug },
+    });
+    return { ref, status: existing ? 'updated' : 'installed' };
+}
+/** The core sync work, decoupled from presentation. Takes a dispatch + awaiter
+ * pair so the Ink view and the plain-text path can share one loop. The function
+ * is structured so the live view can flicker rows through their states in real
+ * time — every meaningful transition dispatches a reducer action. */
+async function runSyncCore(rawRef, targets, options, deps) {
+    const { dispatch, awaitConflictChoice, silent } = deps;
     const summary = [];
     for (const entry of targets) {
         if (entry.type !== 'SKILL')
             continue;
+        dispatch({ type: 'CHECKING', ref: entry.ref });
         const { username, slug } = refToPath(entry.ref);
         let manifest;
         try {
             const resp = await apiFetch(`/api/skills/${username}/${slug}/manifest`);
-            if (resp.type !== 'SKILL')
+            if (resp.type !== 'SKILL') {
+                // Bundles inside the sync flow are intentionally skipped — handled at
+                // install time. Mirror the existing behavior: silently continue.
                 continue;
+            }
             manifest = resp;
         }
         catch (err) {
             if (err instanceof ApiError) {
                 if (err.status === 401) {
+                    // 401 is fatal — print the login hint on stderr unconditionally
+                    // (mirrors pre-PR-#68 behavior) and exit non-zero. The Ink view
+                    // gets an ERROR dispatch as a courtesy but the process exits
+                    // before the next frame renders.
                     console.error('\n  ✗ Not authenticated. Run `botdocs login` first.\n');
+                    dispatch({ type: 'ERROR', ref: entry.ref, details: 'not authenticated' });
                     process.exit(1);
                 }
                 summary.push({ ref: entry.ref, status: 'skipped' });
+                dispatch({ type: 'ERROR', ref: entry.ref, details: `api error ${err.status}` });
                 continue;
             }
             throw err;
         }
-        const { updated, skipped } = await syncSkill(entry, manifest, options);
-        summary.push({ ref: entry.ref, status: updated ? 'updated' : skipped > 0 ? 'skipped' : 'up-to-date' });
+        const { updated, skipped } = await syncSkill(entry, manifest, {
+            options,
+            awaitConflictChoice,
+            silent,
+        });
+        const status = updated ? 'updated' : skipped > 0 ? 'skipped' : 'up-to-date';
+        summary.push({ ref: entry.ref, status });
+        if (status === 'updated') {
+            dispatch({
+                type: 'UPDATED',
+                ref: entry.ref,
+                details: entry.version !== manifest.version
+                    ? `${entry.version} → ${manifest.version}`
+                    : 'updated',
+            });
+        }
+        else if (status === 'up-to-date') {
+            dispatch({ type: 'UP_TO_DATE', ref: entry.ref });
+        }
+        else {
+            dispatch({ type: 'SKIPPED', ref: entry.ref, details: 'changes skipped' });
+        }
+    }
+    // After per-target sync, also pull team-pinned skills (unless --ref-specific).
+    const teamResults = rawRef ? [] : await syncTeamSkills(options, dispatch, silent);
+    return { summary, teamResults };
+}
+async function syncTeamSkills(options, dispatch, silent) {
+    let payload;
+    try {
+        payload = await apiFetch('/api/cli/teams', { auth: true });
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 401) {
+            // User not logged in — skip silently. The personal sync path already
+            // surfaced the auth error to the user.
+            return [];
+        }
+        if (err instanceof ApiError)
+            return [];
+        throw err;
+    }
+    const results = [];
+    for (const team of payload.teams) {
+        for (const skill of team.skills) {
+            const ref = `@${skill.username}/${skill.slug}`;
+            dispatch({ type: 'ADD_ROW', ref, team: team.slug });
+            dispatch({ type: 'CHECKING', ref });
+            if (options.dryRun) {
+                results.push({ ref, status: 'skipped', team: team.slug });
+                dispatch({ type: 'SKIPPED', ref, details: 'dry run' });
+                continue;
+            }
+            const result = await installTeamSkill(team.slug, skill, options, silent);
+            results.push({ ...result, team: team.slug });
+            if (result.status === 'installed' || result.status === 'updated') {
+                dispatch({ type: 'UPDATED', ref, details: result.status });
+            }
+            else if (result.status === 'up-to-date') {
+                dispatch({ type: 'UP_TO_DATE', ref });
+            }
+            else {
+                dispatch({ type: 'SKIPPED', ref, details: 'skipped' });
+            }
+        }
+    }
+    return results;
+}
+/** Default awaiter for the plain-text path. Delegates to the existing clack
+ * prompts so screen-reader users and non-TTY runners keep the same UX. The
+ * three-way choice (`keep`/`overwrite`/`skip`) collapses to clack's existing
+ * binary skip/overwrite — `keep` and `skip` both map to skipping, since the
+ * plain prompt has no separate "keep" affordance today. */
+function plainAwaitConflictChoice(ref, file) {
+    return (async () => {
+        const label = `${ref}:${file}`;
+        const choice = await promptConflict(label);
+        if (choice === 'skip')
+            return 'skip';
+        const sure = await confirmOverwrite(label);
+        return sure ? 'overwrite' : 'skip';
+    })();
+}
+export async function sync(rawRef, options) {
+    const lf = loadLockfile();
+    const targets = rawRef
+        ? lf.installs.filter((i) => i.ref === rawRef)
+        : lf.installs.filter((i) => i.type === 'SKILL');
+    const useInk = !options.noInk && Boolean(process.stdout.isTTY) && !options.json;
+    if (targets.length === 0 && !rawRef) {
+        // Even with nothing installed, pull team-pinned skills.
+        const noopDispatch = () => { };
+        const teamResults = await syncTeamSkills(options, noopDispatch, false);
+        if (teamResults.length === 0) {
+            console.log('\n  nothing installed to sync\n');
+        }
+        else if (options.json) {
+            console.log(JSON.stringify({ summary: [], teamSummary: teamResults }));
+        }
+        else {
+            console.log('');
+            for (const r of teamResults) {
+                if (r.status === 'installed')
+                    console.log(`  ✓ ${r.ref}: installed (team ${r.team})`);
+                else if (r.status === 'updated')
+                    console.log(`  ✓ ${r.ref}: updated (team ${r.team})`);
+                else if (r.status === 'up-to-date')
+                    console.log(`  ✓ ${r.ref}: up to date (team ${r.team})`);
+                else
+                    console.log(`  ⌀ ${r.ref}: skipped (team ${r.team})`);
+            }
+            console.log('');
+        }
+        await syncLibrary();
+        return;
+    }
+    if (targets.length === 0) {
+        console.log('\n  nothing installed to sync\n');
+        await syncLibrary();
+        return;
     }
+    // JSON path: stay silent, no Ink, no console output until the final JSON.
     if (options.json) {
-        console.log(JSON.stringify({ summary }));
+        const noopDispatch = () => { };
+        const { summary, teamResults } = await runSyncCore(rawRef, targets, options, {
+            dispatch: noopDispatch,
+            awaitConflictChoice: plainAwaitConflictChoice,
+            silent: true,
+        });
+        console.log(JSON.stringify({ summary, teamSummary: teamResults }));
+        await syncLibrary();
+        return;
+    }
+    if (useInk) {
+        // Ink path: mount <SyncApp /> and let it drive the loop. The component
+        // owns the run lifecycle — it constructs the dispatch+awaiter pair and
+        // calls runSyncCore via the supplied runSync callback. We await the
+        // returned Promise (waitUntilExit) so the parent process doesn't fall
+        // through to syncLibrary() before the live view has unmounted.
+        const initialRows = targets.map((t) => ({ ref: t.ref }));
+        const runSync = async (sdeps) => {
+            const start = Date.now();
+            await runSyncCore(rawRef, targets, options, {
+                dispatch: sdeps.dispatch,
+                awaitConflictChoice: sdeps.awaitConflictChoice,
+                silent: true,
+            });
+            sdeps.dispatch({ type: 'FINISH', elapsedMs: Date.now() - start });
+        };
+        const instance = render(React.createElement(SyncApp, { initialRows, runSync }));
+        await instance.waitUntilExit();
         await syncLibrary();
         return;
     }
+    // Plain text path: console.log line-by-line, clack prompts for conflicts.
+    const noopDispatch = () => { };
+    const { summary, teamResults } = await runSyncCore(rawRef, targets, options, {
+        dispatch: noopDispatch,
+        awaitConflictChoice: plainAwaitConflictChoice,
+        silent: false,
+    });
     console.log('');
     for (const s of summary) {
         if (s.status === 'up-to-date')
@@ -156,6 +458,16 @@ export async function sync(rawRef, options) {
         else
             console.log(`  ⌀ ${s.ref}: changes skipped`);
     }
+    for (const r of teamResults) {
+        if (r.status === 'installed')
+            console.log(`  ✓ ${r.ref}: installed (team ${r.team})`);
+        else if (r.status === 'updated')
+            console.log(`  ✓ ${r.ref}: updated (team ${r.team})`);
+        else if (r.status === 'up-to-date')
+            console.log(`  ✓ ${r.ref}: up to date (team ${r.team})`);
+        else
+            console.log(`  ⌀ ${r.ref}: skipped (team ${r.team})`);
+    }
     console.log('');
     await syncLibrary();
 }

package/dist/commands/team.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTeamCommands(program: Command): void;