@orchagent/cli 0.3.31 → 0.3.34

package/dist/lib/skill-resolve.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSkills = resolveSkills;
+const api_1 = require("./api");
+function parseSkillRef(ref) {
+    const [namePart, versionPart] = ref.split('@');
+    const version = versionPart?.trim() || 'latest';
+    const segments = namePart.split('/');
+    if (segments.length !== 2 || !segments[0] || !segments[1]) {
+        throw new Error(`Invalid skill reference: ${ref}. Expected format: org/name[@version]`);
+    }
+    return { org: segments[0], name: segments[1], version };
+}
+/**
+ * Download a single skill's content.
+ * Tries public endpoint first, falls back to authenticated for private skills.
+ * Returns null if the skill can't be found.
+ */
+async function downloadSkill(config, org, name, version) {
+    // Try public download endpoint first
+    try {
+        return await (0, api_1.publicRequest)(config, `/public/agents/${org}/${name}/${version}/download`);
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404) {
+            // Non-404 errors (network, 500, etc.) - rethrow
+            throw err;
+        }
+    }
+    // Public not found - try authenticated endpoint for private skills
+    if (!config.apiKey) {
+        return null;
+    }
+    try {
+        const userOrg = await (0, api_1.getOrg)(config);
+        if (userOrg.slug !== org) {
+            return null;
+        }
+        const agents = await (0, api_1.listMyAgents)(config);
+        const matching = agents.filter(a => a.name === name && a.type === 'skill');
+        if (matching.length === 0) {
+            return null;
+        }
+        let target;
+        if (version === 'latest') {
+            target = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+        }
+        else {
+            const found = matching.find(a => a.version === version);
+            if (!found)
+                return null;
+            target = found;
+        }
+        return {
+            name: target.name,
+            version: target.version,
+            description: target.description,
+            prompt: target.prompt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve an array of skill references to their full content.
+ * Fetches each skill from the API and returns resolved skills with prompts.
+ * Skills that can't be fetched are skipped with a warning.
+ */
+async function resolveSkills(config, skillRefs, onWarning) {
+    const resolved = [];
+    for (const ref of skillRefs) {
+        let parsed;
+        try {
+            parsed = parseSkillRef(ref);
+        }
+        catch {
+            onWarning?.(`Skipping invalid skill reference: ${ref}`);
+            continue;
+        }
+        try {
+            const skill = await downloadSkill(config, parsed.org, parsed.name, parsed.version);
+            if (!skill || !skill.prompt) {
+                onWarning?.(`Could not resolve skill '${ref}' (not found or empty)`);
+                continue;
+            }
+            resolved.push({
+                ref,
+                name: skill.name,
+                description: skill.description,
+                prompt: skill.prompt,
+            });
+        }
+        catch (err) {
+            onWarning?.(`Could not fetch skill '${ref}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return resolved;
+}

package/dist/lib/update-notifier.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Lightweight CLI update notifier.
+ *
+ * Design goals:
+ *   1. NEVER crash or block the CLI — every call is wrapped in try/catch
+ *   2. Zero npm dependencies — uses only Node built-ins (https, fs, path, os)
+ *   3. Works on Node 14+ — avoids fetch(), AbortController, and other modern APIs
+ *   4. Non-blocking — the HTTP check uses req.unref() so it won't prevent process exit
+ *   5. Cached — checks npm registry at most once per 24 hours
+ *
+ * Flow:
+ *   - On startup: read ~/.orchagent/update-check.json (sync, ~1ms)
+ *   - If cache is stale (>24h): fire off a background HTTPS GET to registry, write result
+ *   - After command completes: if cached version > current version, print one-line notice
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+exports.printUpdateNotification = printUpdateNotification;
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const PACKAGE_NAME = '@orchagent/cli';
+const CACHE_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
+const CACHE_PATH = path_1.default.join(CACHE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REQUEST_TIMEOUT_MS = 5000;
+// ── Cache I/O ──────────────────────────────────────────────────────────
+function readCache() {
+    try {
+        const raw = fs_1.default.readFileSync(CACHE_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.latest === 'string' && typeof parsed.checkedAt === 'number') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(latest) {
+    try {
+        fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+        fs_1.default.writeFileSync(CACHE_PATH, JSON.stringify({ latest, checkedAt: Date.now() }));
+    }
+    catch {
+        // Best-effort — silently ignore write failures
+    }
+}
+function isCacheStale(cache) {
+    if (!cache)
+        return true;
+    return Date.now() - cache.checkedAt > CHECK_INTERVAL_MS;
+}
+// ── Version comparison ─────────────────────────────────────────────────
+function isNewer(latest, current) {
+    const a = latest.split('.').map(Number);
+    const b = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) > (b[i] || 0))
+            return true;
+        if ((a[i] || 0) < (b[i] || 0))
+            return false;
+    }
+    return false;
+}
+// ── Background check ───────────────────────────────────────────────────
+function triggerBackgroundCheck() {
+    try {
+        const url = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+        const req = https_1.default.get(url, { timeout: REQUEST_TIMEOUT_MS }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume(); // drain
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (typeof parsed.latest === 'string') {
+                        writeCache(parsed.latest);
+                    }
+                }
+                catch {
+                    // Malformed JSON — ignore
+                }
+            });
+        });
+        req.on('error', () => { });
+        req.on('timeout', () => { req.destroy(); });
+        // Don't keep the process alive waiting for this response
+        req.on('socket', (socket) => { socket.unref(); });
+    }
+    catch {
+        // Spawn/setup failure — ignore
+    }
+}
+// ── Public API ──────────────────────────────────────────────────────────
+/** State captured at startup; used later by printUpdateNotification(). */
+let cachedLatest = null;
+/**
+ * Call once at CLI startup. Reads the cache (sync, fast) and fires off
+ * a background registry check if the cache is stale. Never throws.
+ */
+function checkForUpdates() {
+    try {
+        // Respect opt-out
+        if (process.env.NO_UPDATE_NOTIFIER)
+            return;
+        const cache = readCache();
+        if (cache) {
+            cachedLatest = cache.latest;
+        }
+        if (isCacheStale(cache)) {
+            triggerBackgroundCheck();
+        }
+    }
+    catch {
+        // Absolutely never crash
+    }
+}
+/**
+ * Call after the command finishes. Prints a one-line update notice to
+ * stderr if a newer version is available. Never throws.
+ */
+function printUpdateNotification() {
+    try {
+        if (!cachedLatest)
+            return;
+        const current = package_json_1.default.version;
+        if (isNewer(cachedLatest, current)) {
+            process.stderr.write(`\nUpdate available: v${current} → v${cachedLatest}\n` +
+                `Run \`npm update -g @orchagent/cli\` to update\n`);
+        }
+    }
+    catch {
+        // Absolutely never crash
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.31",
+  "version": "0.3.34",
   "description": "Command-line interface for the orchagent AI agent marketplace",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",