evalify-cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -965,8 +965,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path4 = require("path");
-    var fs4 = require("fs");
+    var path5 = require("path");
+    var fs5 = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1898,11 +1898,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path4.resolve(baseDir, baseName);
-          if (fs4.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path4.extname(baseName))) return void 0;
+          const localBin = path5.resolve(baseDir, baseName);
+          if (fs5.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path5.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs4.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1914,21 +1914,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs4.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path4.resolve(
-            path4.dirname(resolvedScriptPath),
+          executableDir = path5.resolve(
+            path5.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path4.basename(
+            const legacyName = path5.basename(
               this._scriptPath,
-              path4.extname(this._scriptPath)
+              path5.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1939,7 +1939,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path4.extname(executableFile));
+        launchWithNode = sourceExt.includes(path5.extname(executableFile));
         let proc;
         if (process3.platform !== "win32") {
           if (launchWithNode) {
@@ -2779,7 +2779,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path4.basename(filename, path4.extname(filename));
+        this._name = path5.basename(filename, path5.extname(filename));
         return this;
       }
       /**
@@ -2793,9 +2793,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path5) {
-        if (path5 === void 0) return this._executableDir;
-        this._executableDir = path5;
+      executableDir(path6) {
+        if (path6 === void 0) return this._executableDir;
+        this._executableDir = path6;
         return this;
       }
       /**
@@ -5613,7 +5613,7 @@ var require_dist = __commonJS({
         });
       };
     }
-    var prompts2 = require_prompts();
+    var prompts3 = require_prompts();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -5664,7 +5664,7 @@ var require_dist = __commonJS({
             var _question2 = question;
             name = _question2.name;
             type = _question2.type;
-            if (prompts2[type] === void 0) {
+            if (prompts3[type] === void 0) {
               throw new Error(`prompt type (${type}) is not defined`);
             }
             if (override2[question.name] !== void 0) {
@@ -5675,7 +5675,7 @@ var require_dist = __commonJS({
               }
             }
             try {
-              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts2[type](question);
+              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts3[type](question);
               answers[name] = answer = yield getFormattedAnswer(question, answer, true);
               quit = yield onSubmit(question, answer, answers);
             } catch (err) {
@@ -5707,7 +5707,7 @@ var require_dist = __commonJS({
     }
     module2.exports = Object.assign(prompt, {
       prompt,
-      prompts: prompts2,
+      prompts: prompts3,
       inject,
       override
     });
@@ -7794,7 +7794,7 @@ var require_prompts2 = __commonJS({
 var require_lib = __commonJS({
   "../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/index.js"(exports2, module2) {
     "use strict";
-    var prompts2 = require_prompts2();
+    var prompts3 = require_prompts2();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -7826,7 +7826,7 @@ var require_lib = __commonJS({
           throw new Error("prompt message is required");
         }
         ({ name, type } = question);
-        if (prompts2[type] === void 0) {
+        if (prompts3[type] === void 0) {
           throw new Error(`prompt type (${type}) is not defined`);
         }
         if (override2[question.name] !== void 0) {
@@ -7837,7 +7837,7 @@ var require_lib = __commonJS({
           }
         }
         try {
-          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts2[type](question);
+          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts3[type](question);
           answers[name] = answer = await getFormattedAnswer(question, answer, true);
           quit = await onSubmit(question, answer, answers);
         } catch (err) {
@@ -7860,7 +7860,7 @@ var require_lib = __commonJS({
     function override(answers) {
       prompt._override = Object.assign({}, answers);
     }
-    module2.exports = Object.assign(prompt, { prompt, prompts: prompts2, inject, override });
+    module2.exports = Object.assign(prompt, { prompt, prompts: prompts3, inject, override });
   }
 });
 
@@ -8394,10 +8394,10 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/format.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.5";
 function header() {
   console.log(source_default.bold.cyan(`
-evalify`) + source_default.dim(` v${VERSION}
+evalify-cli`) + source_default.dim(` v${VERSION}
 `));
 }
 function success(msg) {
@@ -8431,7 +8431,7 @@ var import_node_path = __toESM(require("path"));
 var import_node_os2 = __toESM(require("os"));
 var import_promises = __toESM(require("fs/promises"));
 var import_prompts = __toESM(require_prompts3());
-var REGISTRY_URL = "https://evalify.sh/api/registry";
+var REGISTRY_URL = "https://www.evalify.sh/api/registry";
 async function detectSkills(skillsDir) {
   try {
     const entries = await import_promises.default.readdir(skillsDir, { withFileTypes: true });
@@ -8610,7 +8610,7 @@ async function pull(slug) {
     console.log();
     dim(`Author:   ${pack.author}`);
     dim(`Domain:   ${pack.domain}`);
-    dim(`To validate: evalify validate ${targetDir}`);
+    dim(`To validate: evalify-cli validate ${targetDir}`);
   } catch (err) {
     error(`Failed to write file: ${err.message}`);
   }
@@ -8618,8 +8618,9 @@ async function pull(slug) {
 }
 
 // src/commands/publish.ts
-var import_node_path2 = __toESM(require("path"));
-var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_prompts2 = __toESM(require_prompts3());
 
 // ../packages/frameworks/dist/anthropic-skillcreator-v2.js
 function extractItems(parsed) {
@@ -8810,17 +8811,154 @@ function validateEvalsJson(content) {
   return result;
 }
 
+// src/commands/login.ts
+var import_node_http = __toESM(require("http"));
+var import_node_crypto = __toESM(require("crypto"));
+var import_node_child_process = require("child_process");
+var import_node_path2 = __toESM(require("path"));
+var import_node_os3 = __toESM(require("os"));
+var import_promises2 = __toESM(require("fs/promises"));
+var AUTH_FILE = import_node_path2.default.join(import_node_os3.default.homedir(), ".evalify", "auth.json");
+var REGISTRY_BASE = "https://www.evalify.sh";
+async function readAuth() {
+  try {
+    const content = await import_promises2.default.readFile(AUTH_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function logout() {
+  header();
+  try {
+    await import_promises2.default.rm(AUTH_FILE);
+    success("Logged out");
+  } catch {
+    error("Not logged in");
+  }
+  console.log();
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  (0, import_node_child_process.exec)(`${cmd} "${url}"`);
+}
+async function getValidToken() {
+  const auth = await readAuth();
+  if (!auth) return null;
+  try {
+    const payload = JSON.parse(Buffer.from(auth.access_token.split(".")[1], "base64url").toString());
+    const expiresAt = payload.exp * 1e3;
+    if (Date.now() < expiresAt - 6e4) return auth.access_token;
+  } catch {
+    return auth.access_token;
+  }
+  if (!auth.refresh_token) return null;
+  try {
+    const res = await fetch(`${REGISTRY_BASE}/api/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refresh_token: auth.refresh_token })
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const updated = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token ?? auth.refresh_token,
+      handle: auth.handle
+    };
+    await import_promises2.default.writeFile(AUTH_FILE, JSON.stringify(updated, null, 2));
+    return updated.access_token;
+  } catch {
+    return null;
+  }
+}
+async function login() {
+  header();
+  info("Logging in to Evalify...");
+  console.log();
+  const tokens = await waitForToken();
+  if (!tokens) return;
+  let handle = "";
+  try {
+    const res = await fetch(`${REGISTRY_BASE}/api/auth/me`, {
+      headers: { Authorization: `Bearer ${tokens.access_token}` }
+    });
+    if (res.ok) {
+      const data = await res.json();
+      handle = data.handle ?? "";
+    }
+  } catch {
+  }
+  const authDir = import_node_path2.default.dirname(AUTH_FILE);
+  await import_promises2.default.mkdir(authDir, { recursive: true });
+  await import_promises2.default.writeFile(
+    AUTH_FILE,
+    JSON.stringify({ access_token: tokens.access_token, refresh_token: tokens.refresh_token, handle }, null, 2)
+  );
+  console.log();
+  success(`Logged in${handle ? ` as ${handle}` : ""}`);
+  dim(`Token saved to ${AUTH_FILE}`);
+  console.log();
+}
+function waitForToken() {
+  return new Promise((resolve) => {
+    const state = import_node_crypto.default.randomBytes(16).toString("hex");
+    const server = import_node_http.default.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const returnedState = url.searchParams.get("state");
+      const token = url.searchParams.get("token");
+      const refreshToken = url.searchParams.get("refresh_token");
+      const ok = returnedState === state && !!token;
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(`<!doctype html><html><body style="font-family:sans-serif;padding:2rem;background:#0a0a0a;color:#e4e4e7">
+${ok ? `<h2 style="color:#22c55e">&#10003; Authentication successful</h2><p style="color:#71717a">You can close this tab and return to your terminal.</p>` : `<h2 style="color:#ef4444">&#10007; Authentication failed</h2><p style="color:#71717a">Invalid state. Please try again.</p>`}
+</body></html>`);
+      req.socket.destroy();
+      server.close();
+      if (!ok) {
+        error(returnedState !== state ? "State mismatch \u2014 possible CSRF" : "No token received");
+        resolve(null);
+        return;
+      }
+      resolve({ access_token: token, refresh_token: refreshToken ?? "" });
+    });
+    server.unref();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      const authUrl = `${REGISTRY_BASE}/auth/cli?port=${port}&state=${state}`;
+      dim(`Opening ${authUrl}`);
+      dim("Waiting for authentication...");
+      openBrowser(authUrl);
+    });
+    server.on("error", (err) => {
+      error(`Local server error: ${err.message}`);
+      resolve(null);
+    });
+    setTimeout(() => {
+      server.close();
+      error("Authentication timed out");
+      resolve(null);
+    }, 5 * 60 * 1e3);
+  });
+}
+
 // src/commands/publish.ts
+var REGISTRY_URL2 = "https://www.evalify.sh/api/publish";
 async function findEvalsFile(targetPath) {
-  const stat = await import_promises2.default.stat(targetPath);
+  const stat = await import_promises3.default.stat(targetPath);
   if (stat.isFile()) return targetPath;
   const candidates = [
-    import_node_path2.default.join(targetPath, "evals", "evals.json"),
-    import_node_path2.default.join(targetPath, "evals.json")
+    import_node_path3.default.join(targetPath, "evals", "evals.json"),
+    import_node_path3.default.join(targetPath, "evals.json")
   ];
   for (const candidate of candidates) {
     try {
-      await import_promises2.default.access(candidate);
+      await import_promises3.default.access(candidate);
       return candidate;
     } catch {
     }
@@ -8829,15 +8967,43 @@ async function findEvalsFile(targetPath) {
 }
 async function publish(targetPath) {
   header();
-  const resolvedPath = import_node_path2.default.resolve(process.cwd(), targetPath || ".");
+  let auth = await readAuth();
+  if (!auth) {
+    error("Not logged in");
+    console.log();
+    const { action } = await (0, import_prompts2.default)({
+      type: "select",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        { title: "Login now", value: "login" },
+        { title: "Later", value: "later" }
+      ],
+      initial: 0
+    });
+    if (!action || action === "later") {
+      console.log();
+      dim("Run: evalify-cli login when ready.");
+      console.log();
+      return;
+    }
+    await login();
+    auth = await readAuth();
+    if (!auth) {
+      console.log();
+      return;
+    }
+  }
+  const resolvedPath = import_node_path3.default.resolve(process.cwd(), targetPath || ".");
   try {
-    await import_promises2.default.access(resolvedPath);
+    await import_promises3.default.access(resolvedPath);
   } catch {
-    error(`Path not found: ${targetPath || "."}`);
+    error(`Path not found: ${resolvedPath}`);
+    dim("Pass a path to a folder containing evals.json, or run from that folder.");
     console.log();
     return;
   }
-  info("Publishing eval criteria to registry...");
+  info(`Publishing from ${import_node_path3.default.relative(process.cwd(), resolvedPath) || "."}`);
   console.log();
   const filePath = await findEvalsFile(resolvedPath);
   if (!filePath) {
@@ -8848,8 +9014,8 @@ async function publish(targetPath) {
     console.log();
     return;
   }
-  success(`Found ${import_node_path2.default.relative(process.cwd(), filePath)}`);
-  const content = await import_promises2.default.readFile(filePath, "utf-8");
+  success(`Found ${import_node_path3.default.relative(process.cwd(), filePath)}`);
+  const content = await import_promises3.default.readFile(filePath, "utf-8");
   const result = validateEvalsJson(content);
   if (!result.valid) {
     console.log();
@@ -8863,28 +9029,118 @@ async function publish(targetPath) {
   for (const w of result.warnings) {
     warn(w);
   }
+  const parsed = JSON.parse(content);
+  const displayName = parsed.displayName ?? parsed.skill_name ?? parsed.name ?? "";
+  const slug = parsed.slug ?? displayName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
   console.log();
   console.log(source_default.bold("  Publish summary:"));
   console.log();
-  if (result.summary["skill_name"]) {
-    dim(`Skill:       ${result.summary["skill_name"]}`);
-  }
-  if (result.summary["name"]) {
-    dim(`Name:        ${result.summary["name"]}`);
-  }
-  if (result.summary["version"]) {
-    dim(`Version:     ${result.summary["version"]}`);
-  }
-  if (result.summary["description"]) {
-    dim(`Description: ${result.summary["description"]}`);
-  }
+  dim(`Name:        ${displayName || "(unnamed)"}`);
+  dim(`Slug:        ${slug || "(auto)"}`);
+  dim(`Version:     ${parsed.version ?? "1.0.0"}`);
+  dim(`Domain:      ${parsed.domain ?? "general"}`);
   dim(`Format:      ${getFramework(result.format)?.meta.name ?? result.format}`);
   dim(`Eval count:  ${result.evalCount}`);
-  dim(`File:        ${import_node_path2.default.relative(process.cwd(), filePath)}`);
-  console.log();
-  warn("Dry run \u2014 publishing is not yet connected to the registry");
-  success("File is valid and ready to publish");
+  dim(`Author:      ${auth.handle}`);
   console.log();
+  const { confirm } = await (0, import_prompts2.default)({
+    type: "confirm",
+    name: "confirm",
+    message: "Publish to evalify.sh?",
+    initial: true
+  });
+  if (!confirm) {
+    console.log();
+    dim("Cancelled.");
+    console.log();
+    return;
+  }
+  info("Uploading...");
+  try {
+    const token = await getValidToken();
+    if (!token) {
+      error("Session expired \u2014 run: evalify-cli login");
+      return;
+    }
+    let version = parsed.version ?? "1.0.0";
+    const buildPayload = () => ({
+      slug,
+      displayName,
+      domain: parsed.domain ?? "general",
+      version,
+      tags: parsed.tags ?? [],
+      description: parsed.description ?? "",
+      evals: parsed.evals ?? []
+    });
+    let res = await fetch(REGISTRY_URL2, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(buildPayload())
+    });
+    let data = await res.json();
+    if (res.status === 409 && data.conflict === "version") {
+      console.log();
+      const parts = version.split(".").map(Number);
+      const nextPatch = `${parts[0]}.${parts[1]}.${(parts[2] ?? 0) + 1}`;
+      const { choice } = await (0, import_prompts2.default)({
+        type: "select",
+        name: "choice",
+        message: `Version ${version} is already published. What do you want to do?`,
+        choices: [
+          { title: `Bump to ${nextPatch}`, value: "bump" },
+          { title: "Set manually", value: "manual" },
+          { title: "Cancel", value: "cancel" }
+        ],
+        initial: 0
+      });
+      if (!choice || choice === "cancel") {
+        console.log();
+        dim("Cancelled.");
+        console.log();
+        return;
+      }
+      if (choice === "manual") {
+        const { manualVersion } = await (0, import_prompts2.default)({
+          type: "text",
+          name: "manualVersion",
+          message: "Enter version:",
+          initial: nextPatch
+        });
+        if (!manualVersion) {
+          console.log();
+          dim("Cancelled.");
+          console.log();
+          return;
+        }
+        version = manualVersion.trim();
+      } else {
+        version = nextPatch;
+      }
+      parsed.version = version;
+      await import_promises3.default.writeFile(filePath, JSON.stringify({ ...parsed }, null, 2) + "\n");
+      info(`Uploading v${version}...`);
+      res = await fetch(REGISTRY_URL2, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify(buildPayload())
+      });
+      data = await res.json();
+    }
+    if (!res.ok) {
+      console.log();
+      error(data.error ?? `Server error ${res.status}`);
+      console.log();
+      return;
+    }
+    console.log();
+    success(`Published ${displayName || slug}`);
+    dim(`View at: https://evalify.sh/criteria/${data.slug}`);
+    console.log();
+  } catch (err) {
+    console.log();
+    error(`Failed to publish: ${err.message}`);
+    console.log();
+  }
 }
 
 // src/commands/search.ts
@@ -8902,13 +9158,13 @@ async function search(query) {
   table(results);
   console.log();
   dim(`Showing placeholder results \u2014 registry search not yet connected`);
-  dim(`Use: evalify pull <slug> to download criteria`);
+  dim(`Use: evalify-cli pull <slug> to download criteria`);
   console.log();
 }
 
 // src/commands/validate.ts
-var import_node_path3 = __toESM(require("path"));
-var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path4 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
 var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".json",
   ".md",
@@ -8928,17 +9184,17 @@ var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".toml"
 ]);
 async function findEvalsJson(targetPath) {
-  const stat = await import_promises3.default.stat(targetPath);
+  const stat = await import_promises4.default.stat(targetPath);
   if (stat.isFile()) {
-    return { evalsPath: targetPath, rootDir: import_node_path3.default.dirname(targetPath) };
+    return { evalsPath: targetPath, rootDir: import_node_path4.default.dirname(targetPath) };
   }
   const candidates = [
-    import_node_path3.default.join(targetPath, "evals", "evals.json"),
-    import_node_path3.default.join(targetPath, "evals.json")
+    import_node_path4.default.join(targetPath, "evals", "evals.json"),
+    import_node_path4.default.join(targetPath, "evals.json")
   ];
   for (const candidate of candidates) {
     try {
-      await import_promises3.default.access(candidate);
+      await import_promises4.default.access(candidate);
       return { evalsPath: candidate, rootDir: targetPath };
     } catch {
     }
@@ -8947,19 +9203,19 @@ async function findEvalsJson(targetPath) {
 }
 async function scanCompanionFiles(rootDir, evalsPath, maxDepth = 2) {
   const companions = [];
-  const evalsRelative = import_node_path3.default.relative(rootDir, evalsPath);
+  const evalsRelative = import_node_path4.default.relative(rootDir, evalsPath);
   async function walk(dir, depth) {
     if (depth > maxDepth) return;
-    const entries = await import_promises3.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_promises4.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = import_node_path3.default.join(dir, entry.name);
-      const relativePath = import_node_path3.default.relative(rootDir, fullPath);
+      const fullPath = import_node_path4.default.join(dir, entry.name);
+      const relativePath = import_node_path4.default.relative(rootDir, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
         if (relativePath === evalsRelative) continue;
-        const ext = import_node_path3.default.extname(entry.name).toLowerCase();
+        const ext = import_node_path4.default.extname(entry.name).toLowerCase();
         if (ALLOWED_EXTENSIONS.has(ext)) {
           companions.push(relativePath);
         }
@@ -8984,20 +9240,20 @@ function extractFileRefs(content) {
 }
 async function validate(targetPath) {
   header();
-  const resolvedPath = import_node_path3.default.resolve(process.cwd(), targetPath || ".");
+  const resolvedPath = import_node_path4.default.resolve(process.cwd(), targetPath || ".");
   try {
-    await import_promises3.default.access(resolvedPath);
+    await import_promises4.default.access(resolvedPath);
   } catch {
     error(`Path not found: ${targetPath || "."}`);
     console.log();
     return;
   }
-  const stat = await import_promises3.default.stat(resolvedPath);
+  const stat = await import_promises4.default.stat(resolvedPath);
   const isFolder = stat.isDirectory();
   if (isFolder) {
-    info(`Scanning folder: ${import_node_path3.default.basename(resolvedPath)}/`);
+    info(`Scanning folder: ${import_node_path4.default.basename(resolvedPath)}/`);
   } else {
-    info(`Validating: ${import_node_path3.default.basename(resolvedPath)}`);
+    info(`Validating: ${import_node_path4.default.basename(resolvedPath)}`);
   }
   const found = await findEvalsJson(resolvedPath);
   if (!found) {
@@ -9010,7 +9266,7 @@ async function validate(targetPath) {
     return;
   }
   const { evalsPath, rootDir } = found;
-  const relEvalsPath = import_node_path3.default.relative(process.cwd(), evalsPath);
+  const relEvalsPath = import_node_path4.default.relative(process.cwd(), evalsPath);
   success(`Found ${relEvalsPath}`);
   const companions = isFolder ? await scanCompanionFiles(rootDir, evalsPath) : [];
   if (companions.length > 0) {
@@ -9019,7 +9275,7 @@ async function validate(targetPath) {
       dim(c);
     }
   }
-  const content = await import_promises3.default.readFile(evalsPath, "utf-8");
+  const content = await import_promises4.default.readFile(evalsPath, "utf-8");
   const result = validateEvalsJson(content);
   const fileRefs = extractFileRefs(content);
   if (fileRefs.length > 0) {
@@ -9078,7 +9334,13 @@ async function validate(targetPath) {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("evalify").description("CLI tool for the Evalify eval criteria registry").version(VERSION);
+program2.name("evalify-cli").description("CLI tool for the Evalify eval criteria registry").version(VERSION);
+program2.command("login").description("Authenticate with the Evalify registry").action(async () => {
+  await login();
+});
+program2.command("logout").description("Remove saved credentials").action(async () => {
+  await logout();
+});
 program2.command("pull <slug>").description("Download eval criteria from the registry").action(async (slug) => {
   await pull(slug);
 });
@@ -9091,4 +9353,4 @@ program2.command("search <query>").description("Search the registry for eval cri
 program2.command("validate [path]").description("Validate evals.json from a file or skill folder").action(async (targetPath) => {
   await validate(targetPath);
 });
-program2.parse();
+program2.parseAsync().then(() => process.exit(0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evalify-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI tool for the Evalify eval criteria registry",
   "homepage": "https://evalify.sh",
   "repository": "https://github.com/AppVerse-cc/evalify",

package/src/commands/login.ts

@@ -0,0 +1,181 @@
+import http from "node:http";
+import crypto from "node:crypto";
+import { exec } from "node:child_process";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+import { header, success, info, dim, error } from "../format.js";
+
+const AUTH_FILE = path.join(os.homedir(), ".evalify", "auth.json");
+const REGISTRY_BASE = "https://www.evalify.sh";
+
+export interface AuthData {
+  access_token: string;
+  refresh_token: string;
+  handle: string;
+}
+
+export async function readAuth(): Promise<AuthData | null> {
+  try {
+    const content = await fs.readFile(AUTH_FILE, "utf-8");
+    return JSON.parse(content) as AuthData;
+  } catch {
+    return null;
+  }
+}
+
+export async function logout(): Promise<void> {
+  header();
+  try {
+    await fs.rm(AUTH_FILE);
+    success("Logged out");
+  } catch {
+    error("Not logged in");
+  }
+  console.log();
+}
+
+function openBrowser(url: string): void {
+  const cmd =
+    process.platform === "darwin"
+      ? "open"
+      : process.platform === "win32"
+        ? "start"
+        : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+
+/** Returns a valid (non-expired) access token, refreshing if needed. */
+export async function getValidToken(): Promise<string | null> {
+  const auth = await readAuth();
+  if (!auth) return null;
+
+  // Decode JWT expiry without a library
+  try {
+    const payload = JSON.parse(Buffer.from(auth.access_token.split(".")[1], "base64url").toString());
+    const expiresAt: number = payload.exp * 1000;
+    if (Date.now() < expiresAt - 60_000) return auth.access_token; // still valid
+  } catch {
+    return auth.access_token; // can't decode, try anyway
+  }
+
+  if (!auth.refresh_token) return null;
+
+  // Refresh via evalify.sh refresh endpoint
+  try {
+    const res = await fetch(`${REGISTRY_BASE}/api/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refresh_token: auth.refresh_token }),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const updated: AuthData = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token ?? auth.refresh_token,
+      handle: auth.handle,
+    };
+    await fs.writeFile(AUTH_FILE, JSON.stringify(updated, null, 2));
+    return updated.access_token;
+  } catch {
+    return null;
+  }
+}
+
+export async function login(): Promise<void> {
+  header();
+  info("Logging in to Evalify...");
+  console.log();
+
+  const tokens = await waitForToken();
+  if (!tokens) return;
+
+  // Verify token and fetch handle
+  let handle = "";
+  try {
+    const res = await fetch(`${REGISTRY_BASE}/api/auth/me`, {
+      headers: { Authorization: `Bearer ${tokens.access_token}` },
+    });
+    if (res.ok) {
+      const data = await res.json();
+      handle = data.handle ?? "";
+    }
+  } catch {
+    // non-critical — save token anyway
+  }
+
+  // Save auth
+  const authDir = path.dirname(AUTH_FILE);
+  await fs.mkdir(authDir, { recursive: true });
+  await fs.writeFile(
+    AUTH_FILE,
+    JSON.stringify({ access_token: tokens.access_token, refresh_token: tokens.refresh_token, handle }, null, 2)
+  );
+
+  console.log();
+  success(`Logged in${handle ? ` as ${handle}` : ""}`);
+  dim(`Token saved to ${AUTH_FILE}`);
+  console.log();
+}
+
+function waitForToken(): Promise<{ access_token: string; refresh_token: string } | null> {
+  return new Promise((resolve) => {
+    const state = crypto.randomBytes(16).toString("hex");
+
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+
+      const returnedState = url.searchParams.get("state");
+      const token = url.searchParams.get("token");
+      const refreshToken = url.searchParams.get("refresh_token");
+
+      const ok = returnedState === state && !!token;
+
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(`<!doctype html><html><body style="font-family:sans-serif;padding:2rem;background:#0a0a0a;color:#e4e4e7">
+${ok
+  ? `<h2 style="color:#22c55e">&#10003; Authentication successful</h2><p style="color:#71717a">You can close this tab and return to your terminal.</p>`
+  : `<h2 style="color:#ef4444">&#10007; Authentication failed</h2><p style="color:#71717a">Invalid state. Please try again.</p>`
+}
+</body></html>`);
+
+      req.socket.destroy();
+      server.close();
+
+      if (!ok) {
+        error(returnedState !== state ? "State mismatch — possible CSRF" : "No token received");
+        resolve(null);
+        return;
+      }
+
+      resolve({ access_token: token!, refresh_token: refreshToken ?? "" });
+    });
+
+    server.unref();
+    server.listen(0, "127.0.0.1", () => {
+      const port = (server.address() as { port: number }).port;
+      const authUrl = `${REGISTRY_BASE}/auth/cli?port=${port}&state=${state}`;
+      dim(`Opening ${authUrl}`);
+      dim("Waiting for authentication...");
+      openBrowser(authUrl);
+    });
+
+    server.on("error", (err) => {
+      error(`Local server error: ${err.message}`);
+      resolve(null);
+    });
+
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      server.close();
+      error("Authentication timed out");
+      resolve(null);
+    }, 5 * 60 * 1000);
+  });
+}

package/src/commands/publish.ts

@@ -1,9 +1,13 @@
 import path from "node:path";
 import fs from "node:fs/promises";
 import chalk from "chalk";
+import prompts from "prompts";
 import { getFramework } from "@evalify/frameworks";
 import { header, success, info, dim, error, warn } from "../format.js";
 import { validateEvalsJson } from "../validator.js";
+import { readAuth, getValidToken, login } from "./login.js";
+
+const REGISTRY_URL = "https://www.evalify.sh/api/publish";
 
 async function findEvalsFile(targetPath: string): Promise<string | null> {
   const stat = await fs.stat(targetPath);
@@ -30,17 +34,47 @@ async function findEvalsFile(targetPath: string): Promise<string | null> {
 export async function publish(targetPath?: string): Promise<void> {
   header();
 
+  // Check auth
+  let auth = await readAuth();
+  if (!auth) {
+    error("Not logged in");
+    console.log();
+    const { action } = await prompts({
+      type: "select",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        { title: "Login now", value: "login" },
+        { title: "Later", value: "later" },
+      ],
+      initial: 0,
+    });
+    if (!action || action === "later") {
+      console.log();
+      dim("Run: evalify-cli login when ready.");
+      console.log();
+      return;
+    }
+    await login();
+    auth = await readAuth();
+    if (!auth) {
+      console.log();
+      return;
+    }
+  }
+
   const resolvedPath = path.resolve(process.cwd(), targetPath || ".");
 
   try {
     await fs.access(resolvedPath);
   } catch {
-    error(`Path not found: ${targetPath || "."}`);
+    error(`Path not found: ${resolvedPath}`);
+    dim("Pass a path to a folder containing evals.json, or run from that folder.");
     console.log();
     return;
   }
 
-  info("Publishing eval criteria to registry...");
+  info(`Publishing from ${path.relative(process.cwd(), resolvedPath) || "."}`);
   console.log();
 
   const filePath = await findEvalsFile(resolvedPath);
@@ -73,28 +107,142 @@ export async function publish(targetPath?: string): Promise<void> {
     warn(w);
   }
 
+  const parsed = JSON.parse(content);
+
+  const displayName = parsed.displayName ?? parsed.skill_name ?? parsed.name ?? "";
+  const slug =
+    parsed.slug ??
+    displayName
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+
   console.log();
   console.log(chalk.bold("  Publish summary:"));
   console.log();
-
-  if (result.summary["skill_name"]) {
-    dim(`Skill:       ${result.summary["skill_name"]}`);
-  }
-  if (result.summary["name"]) {
-    dim(`Name:        ${result.summary["name"]}`);
-  }
-  if (result.summary["version"]) {
-    dim(`Version:     ${result.summary["version"]}`);
-  }
-  if (result.summary["description"]) {
-    dim(`Description: ${result.summary["description"]}`);
-  }
+  dim(`Name:        ${displayName || "(unnamed)"}`);
+  dim(`Slug:        ${slug || "(auto)"}`);
+  dim(`Version:     ${parsed.version ?? "1.0.0"}`);
+  dim(`Domain:      ${parsed.domain ?? "general"}`);
   dim(`Format:      ${getFramework(result.format)?.meta.name ?? result.format}`);
   dim(`Eval count:  ${result.evalCount}`);
-  dim(`File:        ${path.relative(process.cwd(), filePath)}`);
-
+  dim(`Author:      ${auth.handle}`);
   console.log();
-  warn("Dry run — publishing is not yet connected to the registry");
-  success("File is valid and ready to publish");
-  console.log();
-}
+
+  const { confirm } = await prompts({
+    type: "confirm",
+    name: "confirm",
+    message: "Publish to evalify.sh?",
+    initial: true,
+  });
+
+  if (!confirm) {
+    console.log();
+    dim("Cancelled.");
+    console.log();
+    return;
+  }
+
+  info("Uploading...");
+
+  try {
+    const token = await getValidToken();
+    if (!token) {
+      error("Session expired — run: evalify-cli login");
+      return;
+    }
+
+    let version = parsed.version ?? "1.0.0";
+
+    const buildPayload = () => ({
+      slug,
+      displayName,
+      domain: parsed.domain ?? "general",
+      version,
+      tags: parsed.tags ?? [],
+      description: parsed.description ?? "",
+      evals: parsed.evals ?? [],
+    });
+
+    let res = await fetch(REGISTRY_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(buildPayload()),
+    });
+
+    let data = await res.json();
+
+    // Version conflict — offer to bump and retry
+    if (res.status === 409 && data.conflict === "version") {
+      console.log();
+      const parts = version.split(".").map(Number);
+      const nextPatch = `${parts[0]}.${parts[1]}.${(parts[2] ?? 0) + 1}`;
+
+      const { choice } = await prompts({
+        type: "select",
+        name: "choice",
+        message: `Version ${version} is already published. What do you want to do?`,
+        choices: [
+          { title: `Bump to ${nextPatch}`, value: "bump" },
+          { title: "Set manually", value: "manual" },
+          { title: "Cancel", value: "cancel" },
+        ],
+        initial: 0,
+      });
+
+      if (!choice || choice === "cancel") {
+        console.log();
+        dim("Cancelled.");
+        console.log();
+        return;
+      }
+
+      if (choice === "manual") {
+        const { manualVersion } = await prompts({
+          type: "text",
+          name: "manualVersion",
+          message: "Enter version:",
+          initial: nextPatch,
+        });
+        if (!manualVersion) {
+          console.log();
+          dim("Cancelled.");
+          console.log();
+          return;
+        }
+        version = manualVersion.trim();
+      } else {
+        version = nextPatch;
+      }
+
+      // Write new version back to evals.json
+      parsed.version = version;
+      await fs.writeFile(filePath, JSON.stringify({ ...parsed }, null, 2) + "\n");
+
+      info(`Uploading v${version}...`);
+
+      res = await fetch(REGISTRY_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify(buildPayload()),
+      });
+      data = await res.json();
+    }
+
+    if (!res.ok) {
+      console.log();
+      error(data.error ?? `Server error ${res.status}`);
+      console.log();
+      return;
+    }
+
+    console.log();
+    success(`Published ${displayName || slug}`);
+    dim(`View at: https://evalify.sh/criteria/${data.slug}`);
+    console.log();
+  } catch (err) {
+    console.log();
+    error(`Failed to publish: ${(err as Error).message}`);
+    console.log();
+  }
+}

package/src/commands/pull.ts

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import prompts from "prompts";
 import { header, success, info, dim, error } from "../format.js";
 
-const REGISTRY_URL = "https://evalify.sh/api/registry";
+const REGISTRY_URL = "https://www.evalify.sh/api/registry";
 
 async function detectSkills(skillsDir: string): Promise<{ name: string; evalCount: number }[]> {
   try {
@@ -235,7 +235,7 @@ export async function pull(slug: string): Promise<void> {
     console.log();
     dim(`Author:   ${pack.author}`);
     dim(`Domain:   ${pack.domain}`);
-    dim(`To validate: evalify validate ${targetDir}`);
+    dim(`To validate: evalify-cli validate ${targetDir}`);
   } catch (err) {
     error(`Failed to write file: ${(err as Error).message}`);
   }

package/src/commands/search.ts

@@ -18,6 +18,6 @@ export async function search(query: string): Promise<void> {
   table(results);
   console.log();
   dim(`Showing placeholder results — registry search not yet connected`);
-  dim(`Use: evalify pull <slug> to download criteria`);
+  dim(`Use: evalify-cli pull <slug> to download criteria`);
   console.log();
 }

package/src/format.ts

@@ -1,9 +1,10 @@
 import chalk from "chalk";
 
-export const VERSION = "0.1.0";
+declare const __PKG_VERSION__: string;
+export const VERSION = __PKG_VERSION__;
 
 export function header(): void {
-  console.log(chalk.bold.cyan(`\nevalify`) + chalk.dim(` v${VERSION}\n`));
+  console.log(chalk.bold.cyan(`\nevalify-cli`) + chalk.dim(` v${VERSION}\n`));
 }
 
 export function success(msg: string): void {

package/src/index.ts

@@ -4,16 +4,31 @@ import { Command } from "commander";
 import { VERSION } from "./format.js";
 import { pull } from "./commands/pull.js";
 import { publish } from "./commands/publish.js";
+import { login, logout } from "./commands/login.js";
 import { search } from "./commands/search.js";
 import { validate } from "./commands/validate.js";
 
 const program = new Command();
 
 program
-  .name("evalify")
+  .name("evalify-cli")
   .description("CLI tool for the Evalify eval criteria registry")
   .version(VERSION);
 
+program
+  .command("login")
+  .description("Authenticate with the Evalify registry")
+  .action(async () => {
+    await login();
+  });
+
+program
+  .command("logout")
+  .description("Remove saved credentials")
+  .action(async () => {
+    await logout();
+  });
+
 program
   .command("pull <slug>")
   .description("Download eval criteria from the registry")
@@ -42,4 +57,4 @@ program
     await validate(targetPath);
   });
 
-program.parse();
+program.parseAsync().then(() => process.exit(0));

package/tsup.config.ts

@@ -1,6 +1,10 @@
 import { defineConfig } from "tsup";
+import { readFileSync } from "node:fs";
+
+const pkg = JSON.parse(readFileSync("./package.json", "utf-8")) as { version: string };
 
 export default defineConfig({
+  define: { __PKG_VERSION__: JSON.stringify(pkg.version) },
   entry: ["src/index.ts"],
   format: ["cjs"],
   platform: "node",