@skillsmanager/cli 0.0.4 → 0.0.6

package/dist/commands/init.js

@@ -2,13 +2,13 @@ import chalk from "chalk";
 import ora from "ora";
 import { writeConfig, mergeCollections, readConfig } from "../config.js";
 import { ensureAuth } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function initCommand() {
     console.log(chalk.bold("\nSkills Manager Init\n"));
     const auth = await ensureAuth();
     console.log(chalk.green("  ✓ Authenticated"));
     const spinner = ora("  Discovering collections...").start();
-    const backend = new GDriveBackend(auth);
+    const backend = await resolveBackend("gdrive");
     const fresh = await backend.discoverCollections();
     let existing = [];
     try {
@@ -25,7 +25,7 @@ export async function initCommand() {
         console.log(chalk.green(`  ✓ Found ${collections.length} collection(s):`));
         for (const c of collections) {
             const col = await backend.readCollection(c);
-            console.log(`    gdrive:${c.name}  (${col.skills.length} skills)`);
+            console.log(`    ${c.backend}:${c.name}  (${col.skills.length} skills)`);
         }
     }
     let existingSkills = {};

package/dist/commands/list.js

@@ -1,3 +1,4 @@
+import os from "os";
 import chalk from "chalk";
 import ora from "ora";
 import { readConfig } from "../config.js";
@@ -14,24 +15,93 @@ export async function getAllSkills() {
     }
     return allSkills;
 }
+function collectionTag(col) {
+    if (col.backend === "github") {
+        const repo = col.folderId.split(":")[0];
+        return `[github: ${repo}]`;
+    }
+    return `[${col.backend}]`;
+}
+const HOME = os.homedir();
+function shortenPath(p) {
+    return p.startsWith(HOME) ? "~" + p.slice(HOME.length) : p;
+}
+function installedPaths(skillName, collectionId, skillIndex) {
+    const entries = skillIndex[skillName] ?? [];
+    const paths = [];
+    for (const entry of entries) {
+        if (entry.collectionId !== collectionId)
+            continue;
+        for (const p of entry.installedAt) {
+            paths.push(shortenPath(p));
+        }
+    }
+    return paths;
+}
+function renderCollections(cols, collectionSkills, skillIndex) {
+    for (let ci = 0; ci < cols.length; ci++) {
+        const col = cols[ci];
+        const isLastCol = ci === cols.length - 1;
+        const colBranch = isLastCol ? "└──" : "├──";
+        const childPad = isLastCol ? "    " : "│   ";
+        console.log(`${colBranch} ${chalk.bold.yellow(col.name)} ${chalk.dim(collectionTag(col))}`);
+        const skills = (collectionSkills.get(col.id) ?? []).sort((a, b) => a.name.localeCompare(b.name));
+        for (let si = 0; si < skills.length; si++) {
+            const skill = skills[si];
+            const isLastSkill = si === skills.length - 1;
+            const skillBranch = isLastSkill ? "└──" : "├──";
+            const paths = installedPaths(skill.name, col.id, skillIndex);
+            console.log(`${childPad}${skillBranch} ${chalk.cyan(skill.name)}  ${chalk.dim(skill.description)}`);
+            if (paths.length > 0) {
+                const installPad = childPad + (isLastSkill ? "    " : "│   ");
+                console.log(`${installPad}${chalk.magenta(`(${paths.join(", ")})`)}`);
+            }
+        }
+    }
+}
 export async function listCommand() {
     const spinner = ora("Fetching skills...").start();
     try {
-        const skills = await getAllSkills();
+        const config = readConfig();
+        // Fetch skills per collection
+        const collectionSkills = new Map();
+        for (const col of config.collections) {
+            const backend = await resolveBackend(col.backend);
+            const colFile = await backend.readCollection(col);
+            collectionSkills.set(col.id, colFile.skills);
+        }
         spinner.stop();
-        if (skills.length === 0) {
+        const totalSkills = [...collectionSkills.values()].reduce((n, s) => n + s.length, 0);
+        if (totalSkills === 0) {
             console.log(chalk.yellow("No skills found across any collections."));
             console.log(chalk.dim('Run "skillsmanager collection create <name>" to create a collection, then "skillsmanager add <path>" to add skills.'));
             return;
         }
-        const maxName = Math.max(...skills.map((s) => s.entry.name.length), 4);
-        const maxDesc = Math.max(...skills.map((s) => s.entry.description.length), 11);
-        console.log(`\n  ${chalk.dim("NAME".padEnd(maxName + 2))}${chalk.dim("DESCRIPTION".padEnd(maxDesc + 2))}${chalk.dim("SOURCE")}`);
-        console.log(`  ${chalk.dim("-".repeat(maxName + maxDesc + 30))}`);
-        for (const s of skills.sort((a, b) => a.entry.name.localeCompare(b.entry.name))) {
-            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`${s.collection.backend}:${s.collection.name}`)}`);
+        // Group collections by their source registry
+        const byRegistry = new Map();
+        for (const col of config.collections) {
+            const key = col.sourceRegistryId ?? null;
+            if (!byRegistry.has(key))
+                byRegistry.set(key, []);
+            byRegistry.get(key).push(col);
         }
         console.log();
+        // Render each registry and its collections
+        for (const reg of config.registries) {
+            const cols = byRegistry.get(reg.id);
+            if (!cols || cols.length === 0)
+                continue;
+            console.log(`${chalk.bold.white(reg.name)}  ${chalk.dim(`${reg.backend}`)}`);
+            renderCollections(cols, collectionSkills, config.skills);
+            console.log();
+        }
+        // Collections not associated with any registry
+        const orphans = byRegistry.get(null);
+        if (orphans && orphans.length > 0) {
+            console.log(`${chalk.bold.white("(unregistered)")}  ${chalk.dim("run 'skillsmanager refresh' to link to a registry")}`);
+            renderCollections(orphans, collectionSkills, config.skills);
+            console.log();
+        }
     }
     catch (err) {
         spinner.stop();

package/dist/commands/logout.d.ts

@@ -0,0 +1,4 @@
+export declare function logoutGoogleCommand(options: {
+    all?: boolean;
+}): Promise<void>;
+export declare function logoutGithubCommand(): void;

package/dist/commands/logout.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+import chalk from "chalk";
+import { CREDENTIALS_PATH, TOKEN_PATH } from "../config.js";
+import { spawnSync } from "child_process";
+export async function logoutGoogleCommand(options) {
+    const removeAll = options.all;
+    let removed = false;
+    if (fs.existsSync(TOKEN_PATH)) {
+        fs.unlinkSync(TOKEN_PATH);
+        console.log(chalk.green("  ✓ Removed token.json (OAuth session cleared)"));
+        removed = true;
+    }
+    else {
+        console.log(chalk.dim("  – token.json not found (already logged out)"));
+    }
+    if (removeAll) {
+        if (fs.existsSync(CREDENTIALS_PATH)) {
+            fs.unlinkSync(CREDENTIALS_PATH);
+            console.log(chalk.green("  ✓ Removed credentials.json (OAuth client cleared)"));
+            removed = true;
+        }
+        else {
+            console.log(chalk.dim("  – credentials.json not found"));
+        }
+    }
+    if (removed) {
+        console.log(chalk.dim("\n  Run skillsmanager setup google to set up again."));
+    }
+}
+export function logoutGithubCommand() {
+    const r = spawnSync("gh", ["auth", "logout"], { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.log(chalk.red("  gh auth logout failed. Try manually: gh auth logout"));
+    }
+}

package/dist/commands/refresh.js

@@ -46,7 +46,7 @@ export async function refreshCommand() {
                         const refBackend = await resolveBackend(ref.backend);
                         const colInfo = await refBackend.resolveCollectionRef(ref);
                         if (colInfo) {
-                            freshCollections.push(colInfo);
+                            freshCollections.push({ ...colInfo, sourceRegistryId: registry.id });
                         }
                         else {
                             console.log(chalk.dim(`\n  Warning: collection "${ref.name}" listed in registry "${registry.name}" could not be resolved`));

package/dist/commands/registry.d.ts

@@ -12,6 +12,7 @@ export declare function registryAddCollectionCommand(collectionName: string, opt
 }): Promise<void>;
 export declare function registryRemoveCollectionCommand(collectionName: string, options: {
     delete?: boolean;
+    backend?: string;
 }): Promise<void>;
 export declare function registryPushCommand(options: {
     backend?: string;

package/dist/commands/registry.js

@@ -2,8 +2,6 @@ import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
 import { readConfig, writeConfig, mergeRegistries, CONFIG_PATH, CACHE_DIR } from "../config.js";
-import { GithubBackend } from "../backends/github.js";
-import { LocalBackend } from "../backends/local.js";
 import { resolveBackend } from "../backends/resolve.js";
 export async function registryCreateCommand(options) {
     const backend = options.backend ?? "local";
@@ -20,13 +18,7 @@ export async function registryCreateCommand(options) {
     const label = backend === "local" ? "locally" : `in ${backend}`;
     const spinner = ora(`Creating registry ${label}...`).start();
     try {
-        let registry;
-        if (backend === "github") {
-            registry = await new GithubBackend().createRegistry(undefined, options.repo);
-        }
-        else {
-            registry = await (await resolveBackend(backend)).createRegistry();
-        }
+        const registry = await (await resolveBackend(backend)).createRegistry({ repo: options.repo });
         spinner.succeed(`Registry created ${label}`);
         let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
         if (fs.existsSync(CONFIG_PATH)) {
@@ -37,6 +29,25 @@ export async function registryCreateCommand(options) {
         }
         config.registries.push(registry);
         writeConfig(config);
+        if (backend !== "local") {
+            const localReg = config.registries.find((r) => r.backend === "local");
+            if (localReg) {
+                const local = await resolveBackend("local");
+                try {
+                    const localData = await local.readRegistry(localReg);
+                    const localCollections = localData.collections.filter((c) => c.backend === "local");
+                    if (localCollections.length > 0) {
+                        const names = localCollections.map((c) => chalk.cyan(c.name)).join(", ");
+                        console.log(chalk.yellow(`\n  Found local registry with ${localCollections.length} collection(s): ${names}`));
+                        const pushCmd = backend === "github"
+                            ? `skillsmanager registry push --backend github --repo ${options.repo}`
+                            : `skillsmanager registry push --backend ${backend}`;
+                        console.log(chalk.dim(`  Run ${chalk.white(pushCmd)} to back them up to ${backend}.\n`));
+                    }
+                }
+                catch { /* local registry unreadable, skip hint */ }
+            }
+        }
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);
@@ -149,12 +160,35 @@ export async function registryRemoveCollectionCommand(collectionName, options) {
         console.log(chalk.red("No registries configured."));
         return;
     }
-    const reg = config.registries[0];
-    const backend = await resolveBackend(reg.backend);
-    const data = await backend.readRegistry(reg);
-    const ref = data.collections.find((c) => c.name === collectionName);
+    // Search all registries for the collection; prefer one matching --backend if given
+    let reg = config.registries[0];
+    let data = null;
+    let backend = await resolveBackend(reg.backend);
+    for (const r of config.registries) {
+        if (options.backend && r.backend !== options.backend)
+            continue;
+        try {
+            const b = await resolveBackend(r.backend);
+            const d = await b.readRegistry(r);
+            if (d.collections.find((c) => c.name === collectionName)) {
+                reg = r;
+                backend = b;
+                data = d;
+                break;
+            }
+        }
+        catch { /* skip unreadable registries */ }
+    }
+    if (!data) {
+        // Fall back to reading the first (or backend-matched) registry for the error message
+        try {
+            data = await backend.readRegistry(reg);
+        }
+        catch { /**/ }
+    }
+    const ref = data?.collections.find((c) => c.name === collectionName);
     if (!ref) {
-        console.log(chalk.yellow(`Collection "${collectionName}" not found in registry.`));
+        console.log(chalk.yellow(`Collection "${collectionName}" not found in any registry.`));
         return;
     }
     // If --delete, delete the actual collection and skills from the backend
@@ -228,7 +262,7 @@ export async function registryPushCommand(options) {
         console.log(chalk.yellow("No local registry to push."));
         return;
     }
-    const local = new LocalBackend();
+    const local = await resolveBackend("local");
     const localData = await local.readRegistry(localReg);
     const localCollectionRefs = localData.collections.filter((c) => c.backend === "local");
     if (localCollectionRefs.length === 0) {
@@ -243,24 +277,33 @@ export async function registryPushCommand(options) {
         spinner.text = `Creating registry in ${targetBackend}...`;
         targetReg = await remote.createRegistry();
     }
-    // Phase 1: Upload all collections — abort on any failure
+    // Read remote registry upfront to know what's already synced
+    let remoteData;
+    try {
+        remoteData = await remote.readRegistry(targetReg);
+    }
+    catch {
+        remoteData = { name: targetReg.name, owner: await remote.getOwner(), source: targetBackend, collections: [] };
+    }
+    const alreadySynced = new Set(remoteData.collections.map((c) => c.name));
+    // Skip collections already present in the remote registry
+    const toUpload = localCollectionRefs.filter((ref) => !alreadySynced.has(ref.name));
+    if (toUpload.length === 0) {
+        spinner.succeed("Remote registry is already up to date.");
+        return;
+    }
+    // Phase 1: Upload new collections — abort on any failure
     const pushed = [];
     try {
-        for (const ref of localCollectionRefs) {
+        for (const ref of toUpload) {
             spinner.text = `Uploading collection "${ref.name}"...`;
             const collInfo = await local.resolveCollectionRef(ref);
             if (!collInfo)
                 throw new Error(`Collection "${ref.name}" not found locally`);
-            let remoteCol;
-            if (targetBackend === "gdrive") {
-                const gdrive = remote;
-                const folderName = `SKILLS_${ref.name.toUpperCase()}`;
-                remoteCol = await gdrive.createCollection(folderName);
-            }
-            else {
-                const github = remote;
-                remoteCol = await github.createCollection(ref.name, options.repo);
-            }
+            const remoteCol = await remote.createCollection({
+                name: ref.name,
+                repo: options.repo,
+            });
             const colData = await local.readCollection({ ...collInfo, id: "temp" });
             for (const skill of colData.skills) {
                 const localSkillPath = path.join(collInfo.folderId, skill.name);
@@ -281,17 +324,12 @@ export async function registryPushCommand(options) {
     // Phase 2: Commit — update registry and config atomically
     spinner.text = "Updating registry...";
     try {
-        let targetData;
-        try {
-            targetData = await remote.readRegistry(targetReg);
-        }
-        catch {
-            targetData = { name: targetReg.name, owner: await remote.getOwner(), source: targetBackend, collections: [] };
-        }
         for (const { ref, remoteCol } of pushed) {
-            targetData.collections.push({ name: ref.name, backend: targetBackend, ref: remoteCol.folderId });
+            if (!remoteData.collections.find((c) => c.name === ref.name)) {
+                remoteData.collections.push({ name: ref.name, backend: targetBackend, ref: remoteCol.folderId });
+            }
         }
-        await remote.writeRegistry(targetReg, targetData);
+        await remote.writeRegistry(targetReg, remoteData);
         if (!config.registries.find((r) => r.id === targetReg.id)) {
             config.registries.push(targetReg);
         }

package/dist/commands/search.js

@@ -26,7 +26,7 @@ export async function searchCommand(query) {
         console.log(`\n  ${chalk.dim("NAME".padEnd(maxName + 2))}${chalk.dim("DESCRIPTION".padEnd(maxDesc + 2))}${chalk.dim("SOURCE")}`);
         console.log(`  ${chalk.dim("-".repeat(maxName + maxDesc + 30))}`);
         for (const s of ranked) {
-            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`gdrive:${s.collection.name}`)}`);
+            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`${s.collection.backend}:${s.collection.name}`)}`);
         }
         console.log();
     }

package/dist/commands/setup/github.d.ts

@@ -1 +1,4 @@
+export declare function ghInstalled(): boolean;
+export declare function ghAuthed(): boolean;
+export declare function ghGetLogin(): string;
 export declare function setupGithubCommand(): Promise<void>;

package/dist/commands/setup/github.js

@@ -1,12 +1,18 @@
 import { spawnSync } from "child_process";
 import chalk from "chalk";
 // ── helpers ───────────────────────────────────────────────────────────────────
-function ghInstalled() {
+export function ghInstalled() {
     return spawnSync("gh", ["--version"], { stdio: "pipe" }).status === 0;
 }
-function ghAuthed() {
+export function ghAuthed() {
     return spawnSync("gh", ["auth", "status"], { stdio: "pipe" }).status === 0;
 }
+export function ghGetLogin() {
+    const r = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+        encoding: "utf-8", stdio: "pipe",
+    });
+    return r.status === 0 ? (r.stdout?.trim() ?? "") : "";
+}
 async function installGh() {
     if (process.platform !== "darwin") {
         console.log(chalk.yellow("  Auto-install is only supported on macOS."));

package/dist/commands/setup/google.js

@@ -4,9 +4,10 @@ import os from "os";
 import readline from "readline";
 import { execSync, spawnSync } from "child_process";
 import chalk from "chalk";
-import { CREDENTIALS_PATH, ensureConfigDir } from "../../config.js";
-import { runAuthFlow, hasToken } from "../../auth.js";
+import { CREDENTIALS_PATH, ensureConfigDir, CONFIG_PATH, readConfig } from "../../config.js";
+import { runAuthFlow, hasToken, getAuthedEmail } from "../../auth.js";
 import { credentialsExist } from "../../config.js";
+import { LocalBackend } from "../../backends/local.js";
 // ─── Prompt helpers ──────────────────────────────────────────────────────────
 function ask(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -123,6 +124,26 @@ function openUrl(url) {
     }
     catch { /* ignore */ }
 }
+// ─── Post-auth nudge ─────────────────────────────────────────────────────────
+async function printPushNudgeIfNeeded() {
+    if (!fs.existsSync(CONFIG_PATH))
+        return;
+    try {
+        const config = readConfig();
+        const localReg = config.registries.find((r) => r.backend === "local");
+        if (!localReg)
+            return;
+        const local = new LocalBackend();
+        const localData = await local.readRegistry(localReg);
+        const localCollections = localData.collections.filter((c) => c.backend === "local");
+        if (localCollections.length === 0)
+            return;
+        const names = localCollections.map((c) => chalk.cyan(c.name)).join(", ");
+        console.log(chalk.yellow(`\n  Found local registry with ${localCollections.length} collection(s): ${names}`));
+        console.log(chalk.dim(`  Run ${chalk.white("skillsmanager registry push --backend gdrive")} to back them up to Google Drive.\n`));
+    }
+    catch { /* unreadable config, skip hint */ }
+}
 // ─── Main command ─────────────────────────────────────────────────────────────
 export async function setupGoogleCommand() {
     console.log(chalk.bold("\nSkills Manager — Google Drive Setup\n"));
@@ -131,13 +152,16 @@ export async function setupGoogleCommand() {
         console.log(chalk.green("  ✓ credentials.json found"));
         if (hasToken()) {
             console.log(chalk.green("  ✓ Already authenticated — nothing to do."));
-            console.log(`\nRun ${chalk.bold("skillsmanager init")} to discover registries.\n`);
+            await printPushNudgeIfNeeded();
+            console.log(`Run ${chalk.bold("skillsmanager refresh")} to discover registries.\n`);
             return;
         }
         console.log(chalk.yellow("  ✗ Not yet authenticated — starting OAuth flow...\n"));
-        await runAuthFlow();
-        console.log(chalk.green("\n  ✓ Authenticated successfully."));
-        console.log(`\nRun ${chalk.bold("skillsmanager init")} to discover registries.\n`);
+        const client = await runAuthFlow();
+        const authedEmail = await getAuthedEmail(client);
+        console.log(chalk.green(`\n  ✓ Authenticated successfully${authedEmail ? ` as ${chalk.white(authedEmail)}` : ""}.`));
+        await printPushNudgeIfNeeded();
+        console.log(`Run ${chalk.bold("skillsmanager refresh")} to discover registries.\n`);
         return;
     }
     // ── Case 2: No credentials.json ───────────────────────────────────────────
@@ -189,33 +213,54 @@ export async function setupGoogleCommand() {
     const projectId = await selectOrCreateProject();
     if (!projectId)
         return;
-    // ── Enable Drive API ──────────────────────────────────────────────────────
-    console.log(chalk.bold("\nStep 4 — Enable Google Drive API\n"));
-    const DRIVE_API = "drive.googleapis.com";
-    if (apiEnabled(projectId, DRIVE_API)) {
-        console.log(chalk.green("  ✓ Google Drive API already enabled"));
-    }
-    else {
-        const ok = enableApi(projectId, DRIVE_API);
-        if (ok) {
-            console.log(chalk.green("  ✓ Google Drive API enabled"));
+    // ── Enable APIs ───────────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 4 — Enable Required APIs\n"));
+    const REQUIRED_APIS = [
+        { api: "drive.googleapis.com", label: "Google Drive API" },
+    ];
+    for (const { api, label } of REQUIRED_APIS) {
+        if (apiEnabled(projectId, api)) {
+            console.log(chalk.green(`  ✓ ${label} already enabled`));
         }
         else {
-            console.log(chalk.red("  Failed to enable Google Drive API. Check that billing is set up for the project."));
-            return;
+            const ok = enableApi(projectId, api);
+            if (ok) {
+                console.log(chalk.green(`  ✓ ${label} enabled`));
+            }
+            else {
+                console.log(chalk.red(`  Failed to enable ${label}. Check that billing is set up for the project.`));
+                return;
+            }
         }
     }
+    // ── Configure OAuth Consent Screen ────────────────────────────────────────
+    console.log(chalk.bold("\nStep 5 — Configure OAuth Consent Screen\n"));
+    console.log("  Before creating credentials, Google requires you to configure the");
+    console.log("  OAuth consent screen (the login screen your users will see).\n");
+    console.log(`  ${chalk.yellow("Note:")} Personal Google accounts can only create ${chalk.white("External")} apps.`);
+    console.log(`  External apps start in Testing mode — only test users you add can sign in.\n`);
+    const consentUrl = `https://console.cloud.google.com/apis/credentials/consent?project=${projectId}`;
+    console.log(`  URL: ${chalk.cyan(consentUrl)}\n`);
+    console.log(chalk.dim("  Instructions:"));
+    console.log(chalk.dim(`    1. Audience → select ${chalk.white("External")} (required for personal accounts)`));
+    console.log(chalk.dim(`    2. App name → ${chalk.white("Skills Manager")}`));
+    console.log(chalk.dim(`    3. User support email → ${chalk.white(account)}`));
+    console.log(chalk.dim(`    4. Contact email → ${chalk.white(account)}`));
+    console.log(chalk.dim(`    5. Click "Create"`));
+    console.log(chalk.dim(`    6. Scroll to "Test users" → "Add users" → enter ${chalk.white(account)} → Save\n`));
+    openUrl(consentUrl);
+    await ask("Press Enter once you have configured the consent screen and added yourself as a test user...");
     // ── OAuth credentials (browser) ───────────────────────────────────────────
-    console.log(chalk.bold("\nStep 5 — Create OAuth 2.0 Credentials\n"));
-    console.log("  Google does not allow creating OAuth client credentials from the CLI.");
-    console.log("  Opening the Google Cloud Console to create them...\n");
+    console.log(chalk.bold("\nStep 6 — Create OAuth 2.0 Credentials\n"));
+    console.log("  Now create the OAuth client ID that Skills Manager will use to authenticate.");
+    console.log("  Opening the Google Cloud Console...\n");
     const credentialsUrl = `https://console.cloud.google.com/apis/credentials/oauthclient?project=${projectId}`;
     console.log(`  URL: ${chalk.cyan(credentialsUrl)}\n`);
     console.log(chalk.dim("  Instructions:"));
-    console.log(chalk.dim("    1. Application type → Desktop app"));
-    console.log(chalk.dim('    2. Name → "Skills Manager" (or anything)'));
-    console.log(chalk.dim('    3. Click "Create" → then "Download JSON"'));
-    console.log(chalk.dim("    4. Note where the file is saved\n"));
+    console.log(chalk.dim(`    1. Application type → ${chalk.white("Desktop app")}`));
+    console.log(chalk.dim(`    2. Name → ${chalk.white("Skills Manager")} (or anything)`));
+    console.log(chalk.dim(`    3. Click "Create" → then "Download JSON"`));
+    console.log(chalk.dim(`    4. Save the file (it will land in your Downloads folder)\n`));
     openUrl(credentialsUrl);
     await ask("Press Enter once you have downloaded the credentials JSON file...");
     // ── Locate and copy the file ──────────────────────────────────────────────
@@ -248,23 +293,13 @@ export async function setupGoogleCommand() {
     ensureConfigDir();
     fs.copyFileSync(credSrc, CREDENTIALS_PATH);
     console.log(chalk.green(`\n  ✓ Credentials saved to ~/.skillsmanager/credentials.json`));
-    // ── Add test user ─────────────────────────────────────────────────────────
-    console.log(chalk.bold("\nStep 6 — Add Test User\n"));
-    console.log("  Your app is in Testing mode. You must add your Google account as a test user.");
-    console.log("  Opening the OAuth consent screen...\n");
-    console.log(chalk.dim("  Instructions:"));
-    console.log(chalk.dim("    1. Scroll down to \"Test users\""));
-    console.log(chalk.dim(`    2. Click \"Add users\" → enter ${chalk.white(account)}`));
-    console.log(chalk.dim("    3. Click \"Save\"\n"));
-    const consentUrl = `https://console.cloud.google.com/apis/credentials/consent?project=${projectId}`;
-    console.log(`  URL: ${chalk.cyan(consentUrl)}\n`);
-    openUrl(consentUrl);
-    await ask("Press Enter once you have added your email as a test user...");
     // ── OAuth flow ────────────────────────────────────────────────────────────
     console.log(chalk.bold("\nStep 7 — Authorize Skills Manager\n"));
-    await runAuthFlow();
-    console.log(chalk.green("\n  ✓ Setup complete!"));
-    console.log(`\nRun ${chalk.bold("skillsmanager init")} to discover your registries.\n`);
+    const client = await runAuthFlow();
+    const authedEmail = await getAuthedEmail(client);
+    console.log(chalk.green(`\n  ✓ Setup complete! Authenticated as ${chalk.white(authedEmail ?? account)}`));
+    await printPushNudgeIfNeeded();
+    console.log(`Run ${chalk.bold("skillsmanager refresh")} to discover your registries.\n`);
 }
 function printManualInstructions() {
     console.log(chalk.bold("\nManual Setup Instructions\n"));
@@ -272,10 +307,15 @@ function printManualInstructions() {
     console.log("  2. Create a project (or select an existing one)");
     console.log("  3. Enable the Google Drive API:");
     console.log("       APIs & Services → Library → search \"Google Drive API\" → Enable");
-    console.log("  4. Create OAuth credentials:");
+    console.log("  4. Configure the OAuth consent screen:");
+    console.log("       APIs & Services → OAuth consent screen");
+    console.log("       Audience: External (required for personal Google accounts)");
+    console.log("       Fill in App name, support email, and contact email");
+    console.log("       Under \"Test users\", add your own Google account email");
+    console.log("  5. Create OAuth credentials:");
     console.log("       APIs & Services → Credentials → Create Credentials → OAuth 2.0 Client ID");
     console.log("       Application type: Desktop app");
-    console.log("  5. Download the JSON and save it:");
+    console.log("  6. Download the JSON and save it:");
     console.log(chalk.cyan(`       ~/.skillsmanager/credentials.json`));
     console.log(`\n  Then run: ${chalk.bold("skillsmanager setup google")}\n`);
 }

package/dist/commands/skill.d.ts

@@ -0,0 +1,3 @@
+export declare function skillDeleteCommand(skillName: string, options: {
+    collection?: string;
+}): Promise<void>;