@yonpark/skillhub-cli 0.1.3 → 0.2.0

package/dist/index.js

@@ -2,9 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const login_1 = require("./commands/login");
+const logout_1 = require("./commands/logout");
+const status_1 = require("./commands/status");
 const sync_1 = require("./commands/sync");
+function getPackageVersion() {
+    try {
+        const pkg = require("../package.json");
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 const program = new commander_1.Command();
-program.name("skillhub").description("SkillHub CLI").version("0.1.0");
+program.name("skillhub").description("SkillHub CLI").version(getPackageVersion());
 program
     .command("login")
     .description("Login: register your GitHub PAT with gist access")
@@ -15,7 +29,70 @@ program
     .command("sync")
     .description("Sync: reconcile local skills with remote Gist backup")
     .option("-s, --strategy <strategy>", "merge strategy (union|latest)", "union")
+    .option("--dry-run", "show planned changes without applying them", false)
+    .option("--json", "print output as JSON", false)
     .action(async (options) => {
-    await (0, sync_1.runSync)(options.strategy);
+    try {
+        await (0, sync_1.runSync)({
+            strategyInput: options.strategy,
+            dryRun: options.dryRun,
+            json: options.json,
+        });
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                error: errorMessage(error),
+            }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+});
+program
+    .command("status")
+    .description("Show local auth/sync status")
+    .option("--json", "print output as JSON", false)
+    .action(async (options) => {
+    try {
+        await (0, status_1.runStatus)({ json: options.json });
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                error: errorMessage(error),
+            }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+});
+program
+    .command("logout")
+    .description("Clear stored session data (token, gist id, last sync)")
+    .option("--yes", "skip confirmation prompt", false)
+    .option("--json", "print output as JSON", false)
+    .action(async (options) => {
+    try {
+        await (0, logout_1.runLogout)({ yes: options.yes, json: options.json });
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                error: errorMessage(error),
+            }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+});
+program.parseAsync(process.argv).catch((error) => {
+    console.error(`Error: ${errorMessage(error)}`);
+    process.exitCode = 1;
 });
-program.parseAsync(process.argv);

package/dist/service/config.js

@@ -25,4 +25,30 @@ exports.configStore = {
         const config = await getConfig();
         config.set("gistId", gistId);
     },
+    async getLastSyncAt() {
+        const config = await getConfig();
+        return config.get("lastSyncAt");
+    },
+    async setLastSyncAt(lastSyncAt) {
+        const config = await getConfig();
+        config.set("lastSyncAt", lastSyncAt);
+    },
+    async clearToken() {
+        const config = await getConfig();
+        config.delete("githubToken");
+    },
+    async clearGistId() {
+        const config = await getConfig();
+        config.delete("gistId");
+    },
+    async clearLastSyncAt() {
+        const config = await getConfig();
+        config.delete("lastSyncAt");
+    },
+    async clearSession() {
+        const config = await getConfig();
+        config.delete("githubToken");
+        config.delete("gistId");
+        config.delete("lastSyncAt");
+    },
 };

package/dist/service/gistService.js

@@ -2,33 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOctokit = createOctokit;
 exports.verifyToken = verifyToken;
+exports.checkGistAccess = checkGistAccess;
 exports.findSkillhubGist = findSkillhubGist;
 exports.getSkillhubPayload = getSkillhubPayload;
 exports.createSkillhubGist = createSkillhubGist;
 exports.updateSkillhubGist = updateSkillhubGist;
 const rest_1 = require("@octokit/rest");
+const retry_1 = require("../utils/retry");
 const SKILLHUB_FILENAME = "skillhub.json";
+const DEFAULT_SKILL_SOURCE_REPO = "vercel-labs/agent-skills";
+const GITHUB_TIMEOUT_MS = 10000;
+function withGitHubRetry(label, fn) {
+    return (0, retry_1.retryAsync)(fn, { label, shouldRetry: retry_1.isTransientError });
+}
 function createOctokit(token) {
-    return new rest_1.Octokit({ auth: token });
+    return new rest_1.Octokit({
+        auth: token,
+        request: {
+            timeout: GITHUB_TIMEOUT_MS,
+        },
+    });
 }
 async function verifyToken(token) {
     const octokit = createOctokit(token);
-    await octokit.users.getAuthenticated();
-    // Also verify that the token can actually talk to the Gist API
-    // (this catches fine-grained tokens that don't have gist access).
-    await octokit.rest.gists.list({ per_page: 1 });
+    await withGitHubRetry("users.getAuthenticated", () => octokit.users.getAuthenticated());
+    await withGitHubRetry("gists.list", () => octokit.rest.gists.list({ per_page: 1 }));
+}
+async function checkGistAccess(octokit) {
+    await withGitHubRetry("gists.list", () => octokit.rest.gists.list({ per_page: 1 }));
 }
 async function findSkillhubGist(octokit) {
-    const gists = await octokit.paginate(octokit.rest.gists.list, {
-        per_page: 100,
-    });
+    const gists = await withGitHubRetry("gists.paginate", () => octokit.paginate(octokit.rest.gists.list, { per_page: 100 }));
     return gists.find((gist) => {
         const files = Object.values(gist.files ?? {});
         return files.some((file) => file?.filename === SKILLHUB_FILENAME);
     });
 }
 async function getSkillhubPayload(octokit, gistId) {
-    const gist = await octokit.gists.get({ gist_id: gistId });
+    const gist = await withGitHubRetry("gists.get", () => octokit.gists.get({ gist_id: gistId }));
     const file = Object.values(gist.data.files ?? {}).find((item) => item?.filename === SKILLHUB_FILENAME);
     if (!file?.content) {
         return null;
@@ -38,10 +49,9 @@ async function getSkillhubPayload(octokit, gistId) {
         if (!Array.isArray(parsed.skills)) {
             return null;
         }
-        // 하위 호환성: string[] 형식을 SkillInfo[] 형식으로 변환
         const normalizedSkills = parsed.skills.map((skill) => {
             if (typeof skill === "string") {
-                return { name: skill, source: "vercel-labs/agent-skills" };
+                return { name: skill, source: DEFAULT_SKILL_SOURCE_REPO };
             }
             return skill;
         });
@@ -55,7 +65,7 @@ async function getSkillhubPayload(octokit, gistId) {
     }
 }
 async function createSkillhubGist(octokit, payload) {
-    const response = await octokit.gists.create({
+    const response = await withGitHubRetry("gists.create", () => octokit.gists.create({
         description: "SkillHub sync",
         public: false,
         files: {
@@ -63,16 +73,16 @@ async function createSkillhubGist(octokit, payload) {
                 content: JSON.stringify(payload, null, 2),
             },
         },
-    });
+    }));
     return response.data;
 }
 async function updateSkillhubGist(octokit, gistId, payload) {
-    await octokit.gists.update({
+    await withGitHubRetry("gists.update", () => octokit.gists.update({
         gist_id: gistId,
         files: {
             [SKILLHUB_FILENAME]: {
                 content: JSON.stringify(payload, null, 2),
             },
         },
-    });
+    }));
 }

package/dist/service/skillsService.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSource = isValidSource;
+exports.getLocalSkills = getLocalSkills;
+exports.installSkills = installSkills;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const syncCore_1 = require("../core/syncCore");
+const retry_1 = require("../utils/retry");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const SKILLS_LOCK_FILENAME = "skills-lock.json";
+const DEFAULT_SKILL_SOURCE_REPO = "vercel-labs/agent-skills";
+const NPX_COMMAND = process.platform === "win32" ? "npx.cmd" : "npx";
+const SOURCE_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const COMMAND_TIMEOUT_MS = 120000;
+const COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
+function stringifyCommandResult(result) {
+    return `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
+}
+async function runSkillsCommand(args, label) {
+    return (0, retry_1.retryAsync)(async () => {
+        return execFileAsync(NPX_COMMAND, ["skills", ...args], {
+            timeout: COMMAND_TIMEOUT_MS,
+            maxBuffer: COMMAND_MAX_BUFFER,
+            shell: process.platform === "win32",
+        });
+    }, { label, shouldRetry: retry_1.isTransientError });
+}
+function isValidSource(source) {
+    return SOURCE_PATTERN.test(source);
+}
+function getCandidateSkillsLockPaths() {
+    const cwdPath = node_path_1.default.resolve(process.cwd(), SKILLS_LOCK_FILENAME);
+    const homePath = node_path_1.default.resolve(node_os_1.default.homedir(), SKILLS_LOCK_FILENAME);
+    const homeConfigPaths = [
+        node_path_1.default.resolve(node_os_1.default.homedir(), ".config", "skills", SKILLS_LOCK_FILENAME),
+        node_path_1.default.resolve(node_os_1.default.homedir(), ".config", "skillhub", SKILLS_LOCK_FILENAME),
+        node_path_1.default.resolve(node_os_1.default.homedir(), ".skills", SKILLS_LOCK_FILENAME),
+    ];
+    const winAppData = process.env.APPDATA;
+    const winLocalAppData = process.env.LOCALAPPDATA;
+    const windowsConfigPaths = [
+        ...(winAppData
+            ? [node_path_1.default.resolve(winAppData, "skills", SKILLS_LOCK_FILENAME)]
+            : []),
+        ...(winLocalAppData
+            ? [node_path_1.default.resolve(winLocalAppData, "skills", SKILLS_LOCK_FILENAME)]
+            : []),
+    ];
+    return [cwdPath, homePath, ...homeConfigPaths, ...windowsConfigPaths];
+}
+function parseSkillsLock(raw) {
+    const parsed = JSON.parse(raw);
+    const extractSkills = (items) => {
+        return items.map((item) => {
+            if (typeof item === "string") {
+                return { name: item, source: DEFAULT_SKILL_SOURCE_REPO };
+            }
+            if (typeof item === "object" && item !== null) {
+                const objectItem = item;
+                const name = typeof objectItem.name === "string"
+                    ? objectItem.name
+                    : typeof objectItem.skill === "string"
+                        ? objectItem.skill
+                        : String(item);
+                const source = typeof objectItem.source === "string"
+                    ? objectItem.source
+                    : typeof objectItem.repo === "string"
+                        ? objectItem.repo
+                        : DEFAULT_SKILL_SOURCE_REPO;
+                return { name, source };
+            }
+            return { name: String(item), source: DEFAULT_SKILL_SOURCE_REPO };
+        });
+    };
+    if (Array.isArray(parsed?.skills)) {
+        return extractSkills(parsed.skills);
+    }
+    if (Array.isArray(parsed)) {
+        return extractSkills(parsed);
+    }
+    if (Array.isArray(parsed?.installedSkills)) {
+        return extractSkills(parsed.installedSkills);
+    }
+    return [];
+}
+function parseSkillsListOutput(output) {
+    const cleaned = output.replace(/\x1b\[[0-9;]*m/g, "");
+    const lines = cleaned.split(/\r?\n/).map((line) => line.trim());
+    const skills = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line === "Global Skills")
+            continue;
+        if (line.startsWith("Agents:"))
+            continue;
+        if (line.startsWith("No project skills found"))
+            continue;
+        if (line.startsWith("Try listing global skills"))
+            continue;
+        if (line.startsWith("No global skills found"))
+            continue;
+        if (line.startsWith("Try listing project skills without -g"))
+            continue;
+        const [name] = line.split(/\s+/);
+        if (!name)
+            continue;
+        if (name.includes("\\") || name.includes("/") || name.includes("~"))
+            continue;
+        skills.push({ name, source: DEFAULT_SKILL_SOURCE_REPO });
+    }
+    return (0, syncCore_1.normalizeSkills)(skills);
+}
+async function tryReadSkillsLock(lockPath) {
+    try {
+        const raw = await promises_1.default.readFile(lockPath, "utf-8");
+        return parseSkillsLock(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function getLocalSkills() {
+    const listResult = await runSkillsCommand(["list", "-g"], "skills list -g");
+    const listOutput = stringifyCommandResult(listResult);
+    if (listOutput.includes("No global skills found") ||
+        listOutput.includes("Try listing project skills without -g")) {
+        return [];
+    }
+    const fromList = parseSkillsListOutput(listOutput);
+    if (fromList.length > 0) {
+        return fromList;
+    }
+    const lockResult = await runSkillsCommand(["generate-lock"], "skills generate-lock");
+    const lockOutput = stringifyCommandResult(lockResult);
+    const candidatePaths = getCandidateSkillsLockPaths();
+    for (const lockPath of candidatePaths) {
+        const parsed = await tryReadSkillsLock(lockPath);
+        if (parsed) {
+            return (0, syncCore_1.normalizeSkills)(parsed);
+        }
+    }
+    if (lockOutput.includes("No installed skills found") ||
+        listOutput.includes("No project skills found")) {
+        return [];
+    }
+    throw new Error([
+        "Unable to construct local skills list.",
+        "- skills list -g output:",
+        listOutput,
+        "",
+        `- Searched ${SKILLS_LOCK_FILENAME} paths:`,
+        ...candidatePaths.map((p) => `  - ${p}`),
+        "",
+        "- npx skills generate-lock output:",
+        lockOutput,
+    ].join("\n"));
+}
+async function installSkills(skills, options = {}) {
+    const succeeded = [];
+    const failed = [];
+    for (const skill of skills) {
+        if (!isValidSource(skill.source)) {
+            const reason = `Invalid source "${skill.source}". Expected owner/repo format.`;
+            failed.push({ skill, reason });
+            if (options.verbose) {
+                console.warn(`Skill install failed: ${skill.name} (from ${skill.source})`);
+                console.warn(`  - ${reason}`);
+            }
+            continue;
+        }
+        try {
+            const result = await runSkillsCommand(["add", skill.source, "--skill", skill.name, "--global", "--yes"], `skills add ${skill.source} --skill ${skill.name}`);
+            const output = stringifyCommandResult(result);
+            if (options.verbose && output) {
+                console.log(output);
+            }
+            succeeded.push(skill);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            failed.push({ skill, reason });
+            if (options.verbose) {
+                console.warn(`Skill install failed: ${skill.name} (from ${skill.source})`);
+                console.warn(`  - ${reason}`);
+            }
+        }
+    }
+    return { succeeded, failed };
+}

package/dist/utils/output.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitOutput = emitOutput;
+function emitOutput(payload, asJson, formatText) {
+    if (asJson) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(formatText(payload));
+}

package/dist/utils/retry.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransientError = isTransientError;
+exports.retryAsync = retryAsync;
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_INITIAL_DELAY_MS = 300;
+const DEFAULT_FACTOR = 3;
+const TRANSIENT_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "EAI_AGAIN",
+    "ENOTFOUND",
+    "ESOCKETTIMEDOUT",
+    "ERR_SOCKET_CONNECTION_TIMEOUT",
+    "ABORT_ERR",
+    "ERR_STREAM_PREMATURE_CLOSE",
+]);
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function isTransientError(error) {
+    const candidate = error;
+    if (typeof candidate.status === "number") {
+        return candidate.status === 429 || candidate.status >= 500;
+    }
+    if (candidate.code && TRANSIENT_ERROR_CODES.has(candidate.code)) {
+        return true;
+    }
+    const message = `${candidate.message ?? ""}`.toLowerCase();
+    return (message.includes("timeout") ||
+        message.includes("timed out") ||
+        message.includes("network") ||
+        message.includes("socket hang up") ||
+        message.includes("temporarily unavailable") ||
+        message.includes("econnreset"));
+}
+async function retryAsync(fn, options = {}) {
+    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const initialDelayMs = options.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+    const factor = options.factor ?? DEFAULT_FACTOR;
+    const shouldRetry = options.shouldRetry ?? isTransientError;
+    let delayMs = initialDelayMs;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            const canRetry = attempt < maxAttempts && shouldRetry(error);
+            if (!canRetry) {
+                const labelPrefix = options.label ? `${options.label} failed` : "Operation failed";
+                throw new Error(`${labelPrefix} after ${attempt} attempt(s): ${getErrorMessage(error)}`);
+            }
+            await sleep(delayMs);
+            delayMs *= factor;
+        }
+    }
+    throw new Error(getErrorMessage(lastError));
+}

package/package.json

@@ -1,48 +1,55 @@
-{
-  "name": "@yonpark/skillhub-cli",
-  "version": "0.1.3",
-  "description": "SkillHub CLI - sync skills with GitHub Gist",
-  "bin": {
-    "skillhub": "bin/skillhub.js"
-  },
-  "main": "dist/index.js",
-  "type": "commonjs",
-  "scripts": {
-    "build": "tsc && tsc-alias",
-    "start": "node dist/index.js",
-    "prepare": "npm run build"
-  },
-  "files": [
-    "dist",
-    "bin",
-    "README.md"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yw9142/skillhub-cli.git"
-  },
-  "keywords": [
-    "cli",
-    "skills",
-    "agent",
-    "gist",
-    "sync"
-  ],
-  "author": "",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "@octokit/rest": "^20.0.2",
-    "commander": "^11.1.0",
-    "conf": "^12.0.0",
-    "inquirer": "^9.2.12"
-  },
-  "devDependencies": {
-    "@types/node": "^20.11.10",
-    "@types/inquirer": "^9.0.7",
-    "tsc-alias": "^1.8.8",
-    "typescript": "^5.3.3"
-  }
-}
+{
+  "name": "@yonpark/skillhub-cli",
+  "version": "0.2.0",
+  "description": "SkillHub CLI - sync skills with GitHub Gist",
+  "bin": {
+    "skillhub": "bin/skillhub.js"
+  },
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "prepare": "npm run build",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:ci": "vitest run",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "changeset publish --access public"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yw9142/skillhub-cli.git"
+  },
+  "keywords": [
+    "cli",
+    "skills",
+    "agent",
+    "gist",
+    "sync"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@octokit/rest": "^20.0.2",
+    "commander": "^11.1.0",
+    "conf": "^12.0.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.7",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.10",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^5.3.3",
+    "vitest": "^2.1.8"
+  }
+}