@cantemizyurek/skillz 0.1.8 → 0.1.10

package/dist/index.cjs

@@ -11282,6 +11282,262 @@ var scopeSchema = external_exports.enum(SCOPE_VALUES);
 // src/index.ts
 var import_commander = require("commander");
 
+// package.json
+var package_default = {
+  name: "@cantemizyurek/skillz",
+  version: "0.1.9",
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist"
+  ],
+  type: "module",
+  bin: {
+    skillz: "./dist/index.cjs"
+  },
+  main: "./dist/index.cjs",
+  types: "./dist/index.d.cts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.cts",
+      default: "./dist/index.cjs"
+    }
+  },
+  scripts: {
+    dev: "tsx src/index.ts",
+    build: "tsup src/index.ts --format cjs --dts --sourcemap --clean",
+    lint: "tsc --noEmit",
+    test: "vitest run"
+  },
+  dependencies: {
+    "@inquirer/prompts": "^7.3.2",
+    "@vercel/blob": "^0.27.0",
+    commander: "^13.1.0",
+    tar: "^7.4.3",
+    "tar-stream": "^3.1.7"
+  },
+  devDependencies: {
+    "@cantemizyurek/shared": "workspace:*",
+    "@types/node": "^22.13.9",
+    tsup: "^8.4.0",
+    tsx: "^4.19.3",
+    typescript: "^5.7.0",
+    vitest: "^3.0.7"
+  }
+};
+
+// src/auto-update.ts
+var DEFAULT_AUTO_UPDATE_INTERVAL_HOURS = 24;
+var MIN_AUTO_UPDATE_INTERVAL_HOURS = 1;
+var MAX_AUTO_UPDATE_INTERVAL_HOURS = 24 * 30;
+function resolveAutoUpdateSettings(config) {
+  return {
+    enabled: typeof config.autoUpdateEnabled === "boolean" ? config.autoUpdateEnabled : true,
+    intervalHours: normalizeAutoUpdateInterval(config.autoUpdateIntervalHours),
+    lastCheckedAt: typeof config.autoUpdateLastCheckedAt === "string" ? config.autoUpdateLastCheckedAt : void 0
+  };
+}
+function shouldRunAutoUpdateNow(config, now = /* @__PURE__ */ new Date()) {
+  const settings = resolveAutoUpdateSettings(config);
+  if (!settings.enabled) {
+    return false;
+  }
+  if (!settings.lastCheckedAt) {
+    return true;
+  }
+  const lastCheckedAt = new Date(settings.lastCheckedAt);
+  if (Number.isNaN(lastCheckedAt.getTime())) {
+    return true;
+  }
+  const elapsedMs = now.getTime() - lastCheckedAt.getTime();
+  if (elapsedMs < 0) {
+    return true;
+  }
+  return elapsedMs >= settings.intervalHours * 60 * 60 * 1e3;
+}
+function parseAutoUpdateIntervalHours(input) {
+  const parsed = Number(input);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+    throw new Error("Auto-update interval must be an integer number of hours");
+  }
+  if (parsed < MIN_AUTO_UPDATE_INTERVAL_HOURS || parsed > MAX_AUTO_UPDATE_INTERVAL_HOURS) {
+    throw new Error(
+      `Auto-update interval must be between ${MIN_AUTO_UPDATE_INTERVAL_HOURS} and ${MAX_AUTO_UPDATE_INTERVAL_HOURS} hours`
+    );
+  }
+  return parsed;
+}
+function normalizeAutoUpdateInterval(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) {
+    return DEFAULT_AUTO_UPDATE_INTERVAL_HOURS;
+  }
+  const rounded = Math.round(input);
+  if (rounded < MIN_AUTO_UPDATE_INTERVAL_HOURS) {
+    return MIN_AUTO_UPDATE_INTERVAL_HOURS;
+  }
+  if (rounded > MAX_AUTO_UPDATE_INTERVAL_HOURS) {
+    return MAX_AUTO_UPDATE_INTERVAL_HOURS;
+  }
+  return rounded;
+}
+
+// src/cli-self-update.ts
+var import_node_child_process = require("child_process");
+var NPM_REGISTRY_BASE_URL = "https://registry.npmjs.org";
+var SUPPORTED_PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+async function runCliSelfUpdate(input) {
+  const latestVersion = await fetchLatestPackageVersion(input.packageName);
+  if (!shouldUpdateCli(input.currentVersion, latestVersion)) {
+    return {
+      latestVersion,
+      updated: false
+    };
+  }
+  const manager = await resolveInstalledPackageManager(
+    input.preferredPackageManager ?? null
+  );
+  if (!manager) {
+    throw new Error(
+      "No supported package manager found (pnpm, npm, yarn, bun)"
+    );
+  }
+  const installCommand = buildSelfUpdateInstallCommand(manager, input.packageName);
+  await runCommand(installCommand.command, installCommand.args);
+  return {
+    latestVersion,
+    updated: true,
+    manager
+  };
+}
+async function fetchLatestPackageVersion(packageName) {
+  const encodedPackageName = encodeURIComponent(packageName);
+  const response = await fetch(
+    `${NPM_REGISTRY_BASE_URL}/${encodedPackageName}/latest`,
+    {
+      method: "GET",
+      headers: {
+        accept: "application/json"
+      }
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Failed to check latest CLI version (status ${response.status})`
+    );
+  }
+  const body = await response.json();
+  return typeof body.version === "string" ? body.version : null;
+}
+function shouldUpdateCli(currentVersion, latestVersion) {
+  if (!latestVersion) {
+    return false;
+  }
+  return isSemverGreater(latestVersion, currentVersion);
+}
+function resolvePreferredPackageManager(env) {
+  const explicit = env.SKILLZ_AUTO_UPDATE_MANAGER?.trim().toLowerCase();
+  if (explicit && isPackageManager(explicit)) {
+    return explicit;
+  }
+  const userAgentManager = parsePackageManagerFromUserAgent(
+    env.npm_config_user_agent
+  );
+  if (userAgentManager) {
+    return userAgentManager;
+  }
+  return null;
+}
+function parsePackageManagerFromUserAgent(userAgent) {
+  if (!userAgent) {
+    return null;
+  }
+  const normalized = userAgent.trim().toLowerCase();
+  for (const manager of SUPPORTED_PACKAGE_MANAGERS) {
+    if (normalized.startsWith(`${manager}/`)) {
+      return manager;
+    }
+  }
+  return null;
+}
+function buildSelfUpdateInstallCommand(manager, packageName) {
+  const packageSpecifier = `${packageName}@latest`;
+  switch (manager) {
+    case "pnpm":
+      return {
+        command: "pnpm",
+        args: ["add", "-g", packageSpecifier]
+      };
+    case "npm":
+      return {
+        command: "npm",
+        args: ["install", "-g", packageSpecifier]
+      };
+    case "yarn":
+      return {
+        command: "yarn",
+        args: ["global", "add", packageSpecifier]
+      };
+    case "bun":
+      return {
+        command: "bun",
+        args: ["add", "-g", packageSpecifier]
+      };
+    default: {
+      const _exhaustiveCheck = manager;
+      throw new Error(`Unsupported package manager: ${_exhaustiveCheck}`);
+    }
+  }
+}
+async function resolveInstalledPackageManager(preferred) {
+  if (preferred && await commandExists(preferred)) {
+    return preferred;
+  }
+  for (const manager of SUPPORTED_PACKAGE_MANAGERS) {
+    if (await commandExists(manager)) {
+      return manager;
+    }
+  }
+  return null;
+}
+async function commandExists(command) {
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process.spawn)(command, ["--version"], {
+      stdio: "ignore"
+    });
+    child.once("error", () => {
+      resolve(false);
+    });
+    child.once("exit", (code) => {
+      resolve(typeof code === "number" && code === 0);
+    });
+  });
+}
+async function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      stdio: "inherit"
+    });
+    child.once("error", (error) => {
+      reject(error);
+    });
+    child.once("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(
+        new Error(
+          `${command} ${args.join(" ")} failed with exit code ${code ?? "unknown"}`
+        )
+      );
+    });
+  });
+}
+function isPackageManager(value) {
+  return SUPPORTED_PACKAGE_MANAGERS.includes(value);
+}
+
 // src/client.ts
 var RegistryClient = class {
   constructor(baseUrl, token) {
@@ -11421,9 +11677,9 @@ var import_node_process = __toESM(require("process"), 1);
 var import_prompts = require("@inquirer/prompts");
 
 // src/git.ts
-var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
 async function detectRepoRoot(cwd) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
@@ -11763,9 +12019,82 @@ async function upsertManifestEntry(entry) {
   await saveManifest(manifest);
 }
 
+// src/update.ts
+async function updateInstalledSkills(input) {
+  if (!input.config.token) {
+    throw new Error("Not logged in. Run skillz login.");
+  }
+  const candidateGroups = groupManifestEntriesBySource(input.entries);
+  let updatedCount = 0;
+  for (const group of candidateGroups) {
+    const installed = group[0];
+    if (installed.registryBaseUrl !== input.expectedRegistryBaseUrl) {
+      if (!input.skipRegistryMismatchLogs) {
+        input.onMessage?.(
+          `Skipping ${installed.namespace}/${installed.name} because it belongs to ${installed.registryBaseUrl}`
+        );
+      }
+      continue;
+    }
+    const client = new RegistryClient(installed.registryBaseUrl, input.config.token);
+    const versions = await client.skillVersions(installed.namespace, installed.name);
+    const latestVersion = versions.versions[0]?.version;
+    if (!latestVersion || !group.some((entry) => isSemverGreater(latestVersion, entry.version))) {
+      continue;
+    }
+    const sourcePath = installed.sourceInstallPath ?? installed.installPath;
+    const writePath = await resolveInstallWritePath(sourcePath);
+    await downloadAndInstallSkill(
+      client,
+      {
+        namespace: installed.namespace,
+        name: installed.name
+      },
+      latestVersion,
+      writePath
+    );
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const entry of group) {
+      entry.version = latestVersion;
+      entry.installedAt = updatedAt;
+    }
+    updatedCount += group.length;
+    input.onMessage?.(
+      `Updated ${installed.namespace}/${installed.name} to ${latestVersion} (${group.map((entry) => entry.agent).join(", ")})`
+    );
+  }
+  if (updatedCount > 0) {
+    await saveManifest(input.manifest);
+  }
+  return {
+    updatedCount
+  };
+}
+function groupManifestEntriesBySource(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const sourcePath = entry.sourceInstallPath ?? entry.installPath;
+    const key = [
+      entry.registryBaseUrl,
+      entry.namespace,
+      entry.name,
+      sourcePath
+    ].join("::");
+    const group = grouped.get(key);
+    if (group) {
+      group.push(entry);
+    } else {
+      grouped.set(key, [entry]);
+    }
+  }
+  return Array.from(grouped.values());
+}
+
 // src/index.ts
+var CLI_VERSION = typeof package_default.version === "string" ? package_default.version : "0.0.0";
+var CLI_PACKAGE_NAME = typeof package_default.name === "string" ? package_default.name : "@cantemizyurek/skillz";
 var program = new import_commander.Command();
-program.name("skillz").description("Private Skills Registry CLI").option("--registry <url>", "registry base URL");
+program.name("skillz").description("Private Skills Registry CLI").version(CLI_VERSION, "-V, --version", "display Skillz CLI version").option("--registry <url>", "registry base URL");
 program.command("register").description("Register a user account using an invite code").option("--invite <code>", "invite code").option("--username <username>", "username").option("--password <password>", "password").action(async (options2, command) => {
   const { client } = await makeClient(command, false);
   const inviteCode = options2.invite ?? await (0, import_prompts2.input)({ message: "Invite code" });
@@ -11810,6 +12139,104 @@ program.command("whoami").description("Show current authenticated user").action(
   const me = await client.whoami();
   console.log(`${me.user.username} (${me.user.role})`);
 });
+program.command("version").description("Show CLI version and auto-update settings").action(async () => {
+  const config = await loadConfig();
+  const autoUpdate = resolveAutoUpdateSettings(config);
+  console.log(`skillz ${CLI_VERSION}`);
+  console.log(
+    `Auto updates: ${autoUpdate.enabled ? "enabled" : "disabled"} (every ${autoUpdate.intervalHours}h)`
+  );
+  console.log(`Last auto-update check: ${autoUpdate.lastCheckedAt ?? "never"}`);
+});
+program.command("auto-update").description("Configure automatic CLI self-updates").option("--enable", "enable automatic updates").option("--disable", "disable automatic updates").option(
+  "--interval-hours <hours>",
+  "check interval in hours (1-720)",
+  parseAutoUpdateIntervalHours
+).option("--check-now", "run the auto-update check immediately").action(async (options2) => {
+  if (options2.enable && options2.disable) {
+    throw new Error("Use either --enable or --disable, not both");
+  }
+  const config = await loadConfig();
+  const nextConfig = {
+    ...config
+  };
+  let changed = false;
+  if (options2.enable) {
+    nextConfig.autoUpdateEnabled = true;
+    changed = true;
+  } else if (options2.disable) {
+    nextConfig.autoUpdateEnabled = false;
+    changed = true;
+  }
+  if (typeof options2.intervalHours === "number") {
+    nextConfig.autoUpdateIntervalHours = options2.intervalHours;
+    changed = true;
+  }
+  if (changed) {
+    await saveConfig(nextConfig);
+  }
+  let lastCheckedAt = nextConfig.autoUpdateLastCheckedAt;
+  if (options2.checkNow) {
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const result = await runCliSelfUpdate({
+        packageName: CLI_PACKAGE_NAME,
+        currentVersion: CLI_VERSION,
+        preferredPackageManager: resolvePreferredPackageManager(import_node_process2.default.env)
+      });
+      if (result.updated) {
+        console.log(
+          `Updated skillz CLI to ${result.latestVersion} using ${result.manager}.`
+        );
+        console.log("Re-run your command to use the new version.");
+      } else {
+        console.log(
+          `skillz CLI is already up to date (${result.latestVersion ?? CLI_VERSION}).`
+        );
+      }
+    } finally {
+      await saveConfig({
+        ...nextConfig,
+        autoUpdateLastCheckedAt: checkedAt
+      });
+      lastCheckedAt = checkedAt;
+    }
+  }
+  const resolved = resolveAutoUpdateSettings({
+    ...nextConfig,
+    autoUpdateLastCheckedAt: lastCheckedAt
+  });
+  console.log(
+    `Auto updates: ${resolved.enabled ? "enabled" : "disabled"} (every ${resolved.intervalHours}h)`
+  );
+  console.log(`Last auto-update check: ${resolved.lastCheckedAt ?? "never"}`);
+});
+program.command("self-update").description("Update skillz CLI to the latest published version").action(async () => {
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const result = await runCliSelfUpdate({
+      packageName: CLI_PACKAGE_NAME,
+      currentVersion: CLI_VERSION,
+      preferredPackageManager: resolvePreferredPackageManager(import_node_process2.default.env)
+    });
+    if (result.updated) {
+      console.log(
+        `Updated skillz CLI to ${result.latestVersion} using ${result.manager}.`
+      );
+      console.log("Re-run your command to use the new version.");
+      return;
+    }
+    console.log(
+      `skillz CLI is already up to date (${result.latestVersion ?? CLI_VERSION}).`
+    );
+  } finally {
+    const config = await loadConfig();
+    await saveConfig({
+      ...config,
+      autoUpdateLastCheckedAt: checkedAt
+    });
+  }
+});
 program.command("list").description("List skills by download count (descending)").argument("[namespace]", "optional namespace").action(async (namespaceInput, _options, command) => {
   const { client } = await makeClient(command, true);
   const namespace = namespaceInput ? namespaceSchema.parse(namespaceInput) : void 0;
@@ -11979,51 +12406,17 @@ program.command("update").description("Update installed skills").argument("[name
     console.log("No matching installed skills to update.");
     return;
   }
-  if (!config.token) {
-    throw new Error("Not logged in. Run skillz login.");
-  }
-  const candidateGroups = groupManifestEntriesBySource(candidates);
-  let updatedCount = 0;
-  for (const group of candidateGroups) {
-    const installed = group[0];
-    if (installed.registryBaseUrl !== resolveRegistryBaseUrl(command, config)) {
-      console.log(
-        `Skipping ${installed.namespace}/${installed.name} because it belongs to ${installed.registryBaseUrl}`
-      );
-      continue;
-    }
-    const client = new RegistryClient(installed.registryBaseUrl, config.token);
-    const versions = await client.skillVersions(installed.namespace, installed.name);
-    const latestVersion = versions.versions[0]?.version;
-    if (!latestVersion || !group.some((entry) => isSemverGreater(latestVersion, entry.version))) {
-      continue;
-    }
-    const sourcePath = installed.sourceInstallPath ?? installed.installPath;
-    const writePath = await resolveInstallWritePath(sourcePath);
-    await downloadAndInstallSkill(
-      client,
-      {
-        namespace: installed.namespace,
-        name: installed.name
-      },
-      latestVersion,
-      writePath
-    );
-    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    for (const entry of group) {
-      entry.version = latestVersion;
-      entry.installedAt = updatedAt;
-    }
-    updatedCount += group.length;
-    console.log(
-      `Updated ${installed.namespace}/${installed.name} to ${latestVersion} (${group.map((entry) => entry.agent).join(", ")})`
-    );
-  }
+  const { updatedCount } = await updateInstalledSkills({
+    config,
+    expectedRegistryBaseUrl: resolveRegistryBaseUrl(command, config),
+    manifest,
+    entries: candidates,
+    onMessage: (message) => console.log(message)
+  });
   if (updatedCount === 0) {
     console.log("All matching skills are already up to date.");
     return;
   }
-  await saveManifest(manifest);
   console.log(`Updated ${updatedCount} skill(s).`);
 });
 program.command("publish").description("Publish a skill folder").argument("<path-to-skill-folder>", "path to the skill folder").requiredOption("--version <x.y.z>", "version to publish").action(async (skillPath, options2, command) => {
@@ -12045,6 +12438,9 @@ invitesCommand.command("create").description("Create a single-use invite code (a
   const invite = await client.createInvite();
   console.log(invite.inviteCode);
 });
+program.hook("preAction", async (_thisCommand, actionCommand) => {
+  await maybeRunAutoUpdate(actionCommand);
+});
 program.parseAsync(import_node_process2.default.argv).catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`Error: ${message}`);
@@ -12124,24 +12520,66 @@ function truncateText(value, maxLength) {
 function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
-function groupManifestEntriesBySource(entries) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const sourcePath = entry.sourceInstallPath ?? entry.installPath;
-    const key = [
-      entry.registryBaseUrl,
-      entry.namespace,
-      entry.name,
-      sourcePath
-    ].join("::");
-    const group = grouped.get(key);
-    if (group) {
-      group.push(entry);
-    } else {
-      grouped.set(key, [entry]);
+async function maybeRunAutoUpdate(actionCommand) {
+  if (isAutoUpdateDisabledByEnv() || shouldSkipAutoUpdate(actionCommand)) {
+    return;
+  }
+  const config = await loadConfig();
+  if (!shouldRunAutoUpdateNow(config)) {
+    return;
+  }
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const result = await runCliSelfUpdate({
+      packageName: CLI_PACKAGE_NAME,
+      currentVersion: CLI_VERSION,
+      preferredPackageManager: resolvePreferredPackageManager(import_node_process2.default.env)
+    });
+    if (result.updated) {
+      console.log(
+        `[auto-update] Updated skillz CLI to ${result.latestVersion} using ${result.manager}.`
+      );
+      console.log("[auto-update] Re-run your command to use the new version.");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Auto-update check failed: ${message}`);
+  } finally {
+    await saveConfig({
+      ...config,
+      autoUpdateLastCheckedAt: checkedAt
+    });
+  }
+}
+function shouldSkipAutoUpdate(command) {
+  const blocked = /* @__PURE__ */ new Set([
+    "auto-update",
+    "help",
+    "login",
+    "logout",
+    "register",
+    "self-update",
+    "update",
+    "version"
+  ]);
+  const commandPath = resolveCommandPath(command);
+  return commandPath.some((name) => blocked.has(name));
+}
+function resolveCommandPath(command) {
+  const pathParts = [];
+  let cursor = command;
+  while (cursor && cursor.parent) {
+    const name = cursor.name();
+    if (name) {
+      pathParts.push(name);
     }
+    cursor = cursor.parent;
   }
-  return Array.from(grouped.values());
+  return pathParts.reverse();
+}
+function isAutoUpdateDisabledByEnv() {
+  const rawValue = import_node_process2.default.env.SKILLZ_AUTO_UPDATE?.trim().toLowerCase();
+  return rawValue === "0" || rawValue === "false" || rawValue === "off" || rawValue === "no";
 }
 /*! Bundled license information: