@skillsmanager/cli 0.0.5 → 0.0.6

package/README.md

@@ -4,7 +4,7 @@
 [![CI](https://github.com/talktoajayprakash/skillsmanager/actions/workflows/release.yml/badge.svg)](https://github.com/talktoajayprakash/skillsmanager/actions)
 [![Docs](https://img.shields.io/badge/docs-skillsmanager-blue)](https://talktoajayprakash.github.io/skillsmanager)
 
-# Skills Manager
+# Skills Manager CLI
 
 **One place to manage, sync, and share all your AI agent skills — across every agent you use.**
 
@@ -72,10 +72,13 @@ skillsmanager refresh        # discovers collections in your Drive
 | `skillsmanager search <query>` | Search skills by name or description |
 | `skillsmanager fetch <name> --agent <agent>` | Download and install a skill for an agent |
 | `skillsmanager add <path>` | Upload a local skill to a collection |
+| `skillsmanager add --remote-path <path> --name <n> --description <d>` | Register a remote skill path (no upload) |
 | `skillsmanager update <path>` | Push local changes back to remote storage |
 | `skillsmanager refresh` | Re-discover collections from remote |
-| `skillsmanager collection create` | Create a new skill collection |
+| `skillsmanager collection create [name] --backend github --repo <owner/repo>` | Create a collection in a GitHub repo |
+| `skillsmanager collection create [name] --skills-repo <owner/repo>` | Create a collection with skills in a separate GitHub repo |
 | `skillsmanager registry push --backend gdrive` | Push local registry to Google Drive |
+| `skillsmanager registry push --backend github --repo <owner/repo>` | Push local registry to GitHub |
 
 ## Local Development
 

package/dist/backends/gdrive.d.ts

@@ -1,25 +1,26 @@
 import type { OAuth2Client } from "google-auth-library";
-import type { StorageBackend } from "./interface.js";
+import type { BackendStatus, CreateRegistryOptions, StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 export declare class GDriveBackend implements StorageBackend {
     private drive;
     constructor(auth: OAuth2Client);
     getOwner(): Promise<string>;
     getOwnerEmail(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
     private downloadFolder;
-    createCollection(folderName: string): Promise<CollectionInfo>;
+    createCollection({ name, skillsRepo }: import("./interface.js").CreateCollectionOptions): Promise<CollectionInfo>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
     deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
     resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
-    createRegistry(name?: string): Promise<RegistryInfo>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
     private findFolder;
     private uploadFolder;
 }

package/dist/backends/gdrive.js

@@ -18,6 +18,14 @@ export class GDriveBackend {
     async getOwnerEmail() {
         return this.getOwner();
     }
+    async getStatus() {
+        try {
+            return { loggedIn: true, identity: await this.getOwner() };
+        }
+        catch {
+            return { loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
+        }
+    }
     // ── Collection operations ────────────────────────────────────────────────
     async discoverCollections() {
         const collections = [];
@@ -149,30 +157,28 @@ export class GDriveBackend {
             }
         } while (pageToken);
     }
-    async createCollection(folderName) {
+    async createCollection({ name, skillsRepo }) {
+        const folderName = `SKILLS_${name.toUpperCase()}`;
         const folderRes = await this.drive.files.create({
-            requestBody: {
-                name: folderName,
-                mimeType: FOLDER_MIME,
-            },
+            requestBody: { name: folderName, mimeType: FOLDER_MIME },
             fields: "id, name",
         });
         const folderId = folderRes.data.id;
         const owner = await this.getOwnerEmail();
-        const logicalName = folderName.replace(/^SKILLS_/i, "");
-        const emptyCollection = { name: logicalName, owner, skills: [] };
+        const emptyCollection = { name, owner, skills: [] };
+        if (skillsRepo) {
+            emptyCollection.type = "github";
+            emptyCollection.metadata = { repo: skillsRepo };
+        }
         const content = serializeCollection(emptyCollection);
         const fileRes = await this.drive.files.create({
-            requestBody: {
-                name: COLLECTION_FILENAME,
-                parents: [folderId],
-            },
+            requestBody: { name: COLLECTION_FILENAME, parents: [folderId] },
             media: { mimeType: "text/yaml", body: Readable.from(content) },
             fields: "id",
         });
         return {
             id: randomUUID(),
-            name: logicalName,
+            name,
             backend: "gdrive",
             folderId,
             registryFileId: fileRes.data.id ?? undefined,
@@ -205,6 +211,7 @@ export class GDriveBackend {
             folderId = res.data.id;
         }
         await this.uploadFolder(localPath, folderId);
+        return `${skillName}/`;
     }
     // ── Registry operations ──────────────────────────────────────────────────
     async discoverRegistries() {
@@ -298,7 +305,8 @@ export class GDriveBackend {
         }
         return null;
     }
-    async createRegistry(name) {
+    async createRegistry(options) {
+        const name = options?.name;
         const folderName = name ? `SKILLS_REGISTRY_${name}` : "SKILLS_REGISTRY";
         const folderRes = await this.drive.files.create({
             requestBody: { name: folderName, mimeType: FOLDER_MIME },

package/dist/backends/github.d.ts

@@ -1,7 +1,8 @@
-import type { StorageBackend } from "./interface.js";
+import type { BackendStatus, CreateRegistryOptions, StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 export declare class GithubBackend implements StorageBackend {
     getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     ensureRepo(repo: string): Promise<void>;
     private ensureWorkdir;
     private gitPushOrPR;
@@ -9,19 +10,18 @@ export declare class GithubBackend implements StorageBackend {
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
+    /** Clone/pull repo and copy relPath to destDir. Usable by other backends for cross-backend routing. */
+    downloadSkillFromRepo(repo: string, relPath: string, destDir: string): Promise<void>;
+    /** Clone/pull repo and delete relPath. Usable by other backends for cross-backend routing. */
+    deleteSkillFromRepo(repo: string, relPath: string): Promise<void>;
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
     deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
     resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
-    createRegistry(name?: string, repoRef?: string): Promise<RegistryInfo>;
-    createCollection(collectionName: string, repoRef?: string, skillsRepoRef?: string): Promise<CollectionInfo>;
-    static detectRepoContext(absPath: string): {
-        repo: string;
-        repoRoot: string;
-        relPath: string;
-    } | null;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection({ name, repo, skillsRepo }: import("./interface.js").CreateCollectionOptions): Promise<CollectionInfo>;
 }

package/dist/backends/github.js

@@ -3,6 +3,7 @@ import path from "path";
 import { randomUUID } from "crypto";
 import { spawnSync } from "child_process";
 import chalk from "chalk";
+import { ghInstalled, ghAuthed, ghGetLogin } from "../commands/setup/github.js";
 import { parseCollection, serializeCollection, parseRegistryFile, serializeRegistryFile, COLLECTION_FILENAME, REGISTRY_FILENAME, } from "../registry.js";
 import { CONFIG_DIR } from "../config.js";
 const GITHUB_WORKDIR = path.join(CONFIG_DIR, "github-workdir");
@@ -20,9 +21,12 @@ function parseRef(folderId) {
 function workdirFor(repo) {
     return path.join(GITHUB_WORKDIR, repo.replace("/", "_"));
 }
-/** Returns the repo where skill files live — defaults to the collection host repo. */
+/** Returns the repo where skill files live — respects col.type + metadata.repo; defaults to host repo. */
 function skillsRepo(col, hostRepo) {
-    return col.metadata?.repo ?? hostRepo;
+    if (col.type === "github" || col.type === undefined) {
+        return col.metadata?.repo ?? hostRepo;
+    }
+    return hostRepo;
 }
 // ── CLI helpers ───────────────────────────────────────────────────────────────
 function ghExec(args, opts) {
@@ -68,6 +72,13 @@ export class GithubBackend {
         }
         return r.stdout;
     }
+    async getStatus() {
+        if (!ghInstalled())
+            return { loggedIn: false, identity: "", hint: "install gh CLI first" };
+        if (!ghAuthed())
+            return { loggedIn: false, identity: "", hint: "run: skillsmanager setup github" };
+        return { loggedIn: true, identity: ghGetLogin() };
+    }
     // ── Ensure repo exists (create private if not) ───────────────────────────────
     async ensureRepo(repo) {
         const check = ghExec(["api", `repos/${repo}`]);
@@ -209,6 +220,29 @@ export class GithubBackend {
         gitExec(["add", path.join(metaDir, COLLECTION_FILENAME)], workdir);
         await this.commitAndPush(workdir, `chore: update ${COLLECTION_FILENAME} for ${collection.name}`);
     }
+    /** Clone/pull repo and copy relPath to destDir. Usable by other backends for cross-backend routing. */
+    async downloadSkillFromRepo(repo, relPath, destDir) {
+        const workdir = this.ensureWorkdir(repo);
+        gitExec(["pull", "--ff-only"], workdir);
+        const skillPath = path.join(workdir, relPath);
+        if (!fs.existsSync(skillPath)) {
+            throw new Error(`Skill directory not found at "${relPath}" in repo "${repo}"`);
+        }
+        if (path.resolve(skillPath) !== path.resolve(destDir)) {
+            copyDirSync(skillPath, destDir);
+        }
+    }
+    /** Clone/pull repo and delete relPath. Usable by other backends for cross-backend routing. */
+    async deleteSkillFromRepo(repo, relPath) {
+        const workdir = this.ensureWorkdir(repo);
+        gitExec(["pull", "--ff-only"], workdir);
+        const skillPath = path.join(workdir, relPath);
+        if (!fs.existsSync(skillPath))
+            return;
+        fs.rmSync(skillPath, { recursive: true, force: true });
+        gitExec(["add", "-A"], workdir);
+        await this.commitAndPush(workdir, `chore: remove skill at ${relPath}`);
+    }
     async downloadSkill(collection, skillName, destDir) {
         const { repo: hostRepo } = parseRef(collection.folderId);
         const col = await this.readCollection(collection);
@@ -217,38 +251,24 @@ export class GithubBackend {
             throw new Error(`Skill "${skillName}" not found in collection "${collection.name}"`);
         }
         const srcRepo = skillsRepo(col, hostRepo);
-        const workdir = this.ensureWorkdir(srcRepo);
-        gitExec(["pull", "--ff-only"], workdir);
-        const skillPath = path.join(workdir, entry.path);
-        if (!fs.existsSync(skillPath)) {
-            throw new Error(`Skill directory not found at "${entry.path}" in repo "${srcRepo}"`);
-        }
-        if (path.resolve(skillPath) !== path.resolve(destDir)) {
-            copyDirSync(skillPath, destDir);
-        }
+        await this.downloadSkillFromRepo(srcRepo, entry.path, destDir);
     }
     async uploadSkill(collection, localPath, skillName) {
         const { repo: hostRepo } = parseRef(collection.folderId);
-        // If collection points to a foreign skills repo, we can't upload there
-        const col = await this.readCollection(collection);
-        const foreign = col.metadata?.repo;
-        if (foreign && foreign !== hostRepo) {
-            throw new Error(`Cannot upload skill to collection "${collection.name}": its skills source is "${foreign}" (a repo you may not own). ` +
-                `Use --remote-path to register a skill path from that repo instead.`);
-        }
         const workdir = this.ensureWorkdir(hostRepo);
         const resolvedLocal = path.resolve(localPath);
         const resolvedWorkdir = path.resolve(workdir);
         if (resolvedLocal.startsWith(resolvedWorkdir + path.sep) ||
             resolvedLocal === resolvedWorkdir) {
-            // Already in the repo — no copy needed
-            return;
+            // Already in the repo — no copy needed; return relative path from workdir
+            return path.relative(workdir, resolvedLocal).replace(/\\/g, "/");
         }
         // External skill: copy into .agentskills/<skillName>/ in the repo
         const dest = path.join(workdir, ".agentskills", skillName);
         copyDirSync(localPath, dest);
         gitExec(["add", path.join(".agentskills", skillName)], workdir);
         await this.commitAndPush(workdir, `chore: add skill ${skillName}`);
+        return `.agentskills/${skillName}`;
     }
     async deleteCollection(collection) {
         const { repo, metaDir } = parseRef(collection.folderId);
@@ -267,13 +287,7 @@ export class GithubBackend {
         if (!entry)
             return;
         const srcRepo = skillsRepo(col, hostRepo);
-        const workdir = this.ensureWorkdir(srcRepo);
-        const skillPath = path.join(workdir, entry.path);
-        if (!fs.existsSync(skillPath))
-            return;
-        fs.rmSync(skillPath, { recursive: true, force: true });
-        gitExec(["add", "-A"], workdir);
-        await this.commitAndPush(workdir, `chore: remove skill ${skillName}`);
+        await this.deleteSkillFromRepo(srcRepo, entry.path);
     }
     // ── Registry operations ───────────────────────────────────────────────────────
     async discoverRegistries() {
@@ -331,17 +345,18 @@ export class GithubBackend {
             return null;
         return { name: ref.name, backend: "github", folderId: ref.ref };
     }
-    async createRegistry(name, repoRef) {
-        if (!repoRef)
+    async createRegistry(options) {
+        const { name, repo } = options ?? {};
+        if (!repo)
             throw new Error("GitHub backend requires --repo <owner/repo>");
-        await this.ensureRepo(repoRef);
-        const workdir = this.ensureWorkdir(repoRef);
+        await this.ensureRepo(repo);
+        const workdir = this.ensureWorkdir(repo);
         const metaDir = SKILLSMANAGER_DIR;
         const filePath = path.join(workdir, metaDir, REGISTRY_FILENAME);
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         const owner = await this.getOwner();
         const registryData = {
-            name: name ?? (repoRef.split("/")[1] ?? "default"),
+            name: name ?? (repo.split("/")[1] ?? "default"),
             owner,
             source: "github",
             collections: [],
@@ -353,55 +368,32 @@ export class GithubBackend {
             id: randomUUID(),
             name: registryData.name,
             backend: "github",
-            folderId: `${repoRef}:${metaDir}`,
-            fileId: `${repoRef}:${metaDir}/${REGISTRY_FILENAME}`,
+            folderId: `${repo}:${metaDir}`,
+            fileId: `${repo}:${metaDir}/${REGISTRY_FILENAME}`,
         };
     }
     // ── createCollection ─────────────────────────────────────────────────────────
-    async createCollection(collectionName, repoRef, skillsRepoRef) {
-        if (!repoRef)
+    async createCollection({ name, repo, skillsRepo }) {
+        if (!repo)
             throw new Error("GitHub backend requires --repo <owner/repo>");
-        const repo = repoRef;
         await this.ensureRepo(repo);
         const workdir = this.ensureWorkdir(repo);
-        const metaDir = `${SKILLSMANAGER_DIR}/${collectionName}`;
+        const metaDir = `${SKILLSMANAGER_DIR}/${name}`;
         const filePath = path.join(workdir, metaDir, COLLECTION_FILENAME);
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         const owner = await this.getOwner();
-        const colData = { name: collectionName, owner, skills: [] };
-        if (skillsRepoRef && skillsRepoRef !== repo) {
-            colData.metadata = { repo: skillsRepoRef };
+        const colData = { name, owner, skills: [] };
+        if (skillsRepo && skillsRepo !== repo) {
+            colData.metadata = { repo: skillsRepo };
         }
         fs.writeFileSync(filePath, serializeCollection(colData));
         gitExec(["add", path.join(metaDir, COLLECTION_FILENAME)], workdir);
-        await this.commitAndPush(workdir, `chore: init collection ${collectionName}`);
+        await this.commitAndPush(workdir, `chore: init collection ${name}`);
         return {
             id: randomUUID(),
-            name: collectionName,
+            name,
             backend: "github",
             folderId: `${repo}:${metaDir}`,
         };
     }
-    // ── Static: detect if a path is inside a GitHub-tracked git repo ──────────────
-    static detectRepoContext(absPath) {
-        const rootResult = spawnSync("git", ["-C", absPath, "rev-parse", "--show-toplevel"], {
-            encoding: "utf-8", stdio: "pipe",
-        });
-        if (rootResult.status !== 0)
-            return null;
-        const repoRoot = rootResult.stdout.trim();
-        const remoteResult = spawnSync("git", ["-C", repoRoot, "remote", "get-url", "origin"], {
-            encoding: "utf-8", stdio: "pipe",
-        });
-        if (remoteResult.status !== 0)
-            return null;
-        const remoteUrl = remoteResult.stdout.trim();
-        const match = remoteUrl.match(/github\.com[/:]([^/]+\/[^/]+?)(?:\.git)?$/) ??
-            remoteUrl.match(/github\.com\/([^/]+\/[^/]+)/);
-        if (!match)
-            return null;
-        const repo = match[1].replace(/\.git$/, "");
-        const relPath = path.relative(repoRoot, absPath).replace(/\\/g, "/");
-        return { repo, repoRoot, relPath };
-    }
 }

package/dist/backends/interface.d.ts

@@ -1,16 +1,32 @@
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
+export interface CreateCollectionOptions {
+    name: string;
+    repo?: string;
+    skillsRepo?: string;
+}
+export interface CreateRegistryOptions {
+    name?: string;
+    repo?: string;
+}
+export interface BackendStatus {
+    loggedIn: boolean;
+    identity: string;
+    hint?: string;
+}
 export interface StorageBackend {
     getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
     deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
     resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
-    createRegistry(name?: string): Promise<RegistryInfo>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection(options: CreateCollectionOptions): Promise<CollectionInfo>;
 }

package/dist/backends/local.d.ts

@@ -1,4 +1,4 @@
-import type { StorageBackend } from "./interface.js";
+import type { BackendStatus, CreateRegistryOptions, StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 /**
  * Local filesystem backend — stores collections and the registry under ~/.skillsmanager/.
@@ -6,17 +6,18 @@ import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFil
  */
 export declare class LocalBackend implements StorageBackend {
     getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
     deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
     resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
-    createRegistry(name?: string): Promise<RegistryInfo>;
-    createCollection(name: string): Promise<CollectionInfo>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection({ name }: import("./interface.js").CreateCollectionOptions): Promise<CollectionInfo>;
 }

package/dist/backends/local.js

@@ -20,6 +20,9 @@ export class LocalBackend {
         }
         return process.env.USER ?? process.env.USERNAME ?? "unknown";
     }
+    async getStatus() {
+        return { loggedIn: true, identity: await this.getOwner() };
+    }
     // ── Collection operations ────────────────────────────────────────────────
     async discoverCollections() {
         if (!fs.existsSync(COLLECTIONS_DIR))
@@ -68,10 +71,10 @@ export class LocalBackend {
     }
     async uploadSkill(collection, localPath, skillName) {
         const dest = path.join(collection.folderId, skillName);
-        // If source and dest are the same, no-op
-        if (path.resolve(localPath) === path.resolve(dest))
-            return;
-        copyDirSync(localPath, dest);
+        if (path.resolve(localPath) !== path.resolve(dest)) {
+            copyDirSync(localPath, dest);
+        }
+        return `${skillName}/`;
     }
     async deleteCollection(collection) {
         if (fs.existsSync(collection.folderId)) {
@@ -121,26 +124,22 @@ export class LocalBackend {
             folderId: dir,
         };
     }
-    async createRegistry(name) {
+    async createRegistry(options) {
+        const name = options?.name ?? "local";
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
         const owner = await this.getOwner();
-        const data = {
-            name: name ?? "local",
-            owner,
-            source: "local",
-            collections: [],
-        };
+        const data = { name, owner, source: "local", collections: [] };
         fs.writeFileSync(LOCAL_REGISTRY_PATH, serializeRegistryFile(data));
         return {
             id: randomUUID(),
-            name: name ?? "local",
+            name,
             backend: "local",
             folderId: CONFIG_DIR,
             fileId: LOCAL_REGISTRY_PATH,
         };
     }
     // ── Convenience: create a local collection ───────────────────────────────
-    async createCollection(name) {
+    async createCollection({ name }) {
         const dir = path.join(COLLECTIONS_DIR, name);
         fs.mkdirSync(dir, { recursive: true });
         const owner = await this.getOwner();

package/dist/backends/resolve.d.ts

@@ -1,2 +1,4 @@
 import type { StorageBackend } from "./interface.js";
 export declare function resolveBackend(backendName: string): Promise<StorageBackend>;
+/** Like resolveBackend but never triggers auth flows — returns null for unconfigured backends. */
+export declare function tryResolveBackend(backendName: string): Promise<StorageBackend | null>;

package/dist/backends/resolve.js

@@ -1,11 +1,32 @@
-import { ensureAuth } from "../auth.js";
+import { ensureAuth, getAuthClient, hasToken } from "../auth.js";
+import { credentialsExist } from "../config.js";
 import { GDriveBackend } from "./gdrive.js";
 import { GithubBackend } from "./github.js";
 import { LocalBackend } from "./local.js";
+import { RoutingBackend } from "./routing.js";
 export async function resolveBackend(backendName) {
+    let inner;
     if (backendName === "gdrive")
-        return new GDriveBackend(await ensureAuth());
+        inner = new GDriveBackend(await ensureAuth());
+    else if (backendName === "github")
+        inner = new GithubBackend();
+    else
+        inner = new LocalBackend();
+    return new RoutingBackend(inner);
+}
+/** Like resolveBackend but never triggers auth flows — returns null for unconfigured backends. */
+export async function tryResolveBackend(backendName) {
+    if (backendName === "gdrive") {
+        if (!credentialsExist() || !hasToken())
+            return null;
+        try {
+            return new RoutingBackend(new GDriveBackend(getAuthClient()));
+        }
+        catch {
+            return null;
+        }
+    }
     if (backendName === "github")
-        return new GithubBackend();
-    return new LocalBackend();
+        return new RoutingBackend(new GithubBackend());
+    return new RoutingBackend(new LocalBackend());
 }

package/dist/backends/routing.d.ts

@@ -0,0 +1,38 @@
+import type { BackendStatus, CreateCollectionOptions, CreateRegistryOptions, StorageBackend } from "./interface.js";
+import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
+/**
+ * RoutingBackend — a transparent decorator over any StorageBackend.
+ *
+ * Collection-metadata operations (readCollection, writeCollection, registry ops, etc.)
+ * pass straight through to the inner backend — the YAML always lives where the
+ * collection was declared.
+ *
+ * Skill-file operations (downloadSkill, uploadSkill, deleteSkill) inspect col.type
+ * and dispatch to the appropriate handler:
+ *   - col.type === "github"  → GithubBackend helpers (clone/pull the skills repo)
+ *   - col.type absent/same  → inner backend (normal behaviour, no change)
+ *
+ * This means every backend gets cross-backend routing for free without any
+ * per-backend col.type checks.
+ */
+export declare class RoutingBackend implements StorageBackend {
+    private readonly inner;
+    constructor(inner: StorageBackend);
+    getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
+    discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
+    readCollection(collection: CollectionInfo): Promise<CollectionFile>;
+    writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
+    deleteCollection(collection: CollectionInfo): Promise<void>;
+    discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
+    readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
+    writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
+    resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection(options: CreateCollectionOptions): Promise<CollectionInfo>;
+    downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
+    deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
+    private requireRepo;
+    private requireEntry;
+}