chofex-cli 0.1.177 → 0.1.178

package/README.md

@@ -30,15 +30,25 @@ chofex challenge test --challenge broken-agent --source ./scheduler.js
 chofex challenge evaluate --challenge broken-agent --source ./scheduler.js
 chofex challenge ranking --challenge broken-agent
 chofex confirm
+chofex badge
+chofex badge regenerate
 ```
 
 `chofex update` and `chofex upgrade` are interchangeable; both update the CLI
 to the latest published version.
 
+Las copias instaladas también consultan npm cada vez que se inicia `chofex` e
+instalan una versión publicada más reciente antes de ejecutar el comando. Si
+npm o la red no están disponibles temporalmente, se continúa con la versión
+actual. Usa `CHOFEX_AUTO_UPDATE=0` para desactivar esta comprobación.
+
 `chofex register` collects and submits an application with full name, role,
 optional phone number, bio, portfolio URL, shipped project, LinkedIn and GitHub
 URLs, and Terms and Conditions. Use `--input` to submit a completed JSON
 application.
+After attendance confirmation, `chofex badge regenerate` updates the public
+badge name, one-line description, picture, and QR destination without changing
+the submitted application.
 The technical challenges do not block submission, but every challenge winner must submit
 an application before being accepted. Top results receive a direct pass; other
 scores give organizers another review metric.

package/dist/index.js

@@ -27645,6 +27645,7 @@ var require_throttleit = __commonJS((exports, module) => {
 
 // src/index.ts
 import { readFileSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 // ../../node_modules/@effect/platform-node/dist/NodeRuntime.js
 var exports_NodeRuntime = {};
 __export(exports_NodeRuntime, {
@@ -59191,10 +59192,25 @@ var BadgeStatus = exports_Schema.Literals([
   "completed",
   "failed"
 ]);
+var BadgeProfileSchema = exports_Schema.Struct({
+  fullName: nonBlank(200),
+  oneLiner: nonBlank(30),
+  linkUrl: url,
+  placement: exports_Schema.String
+});
 var BadgeResultSchema = exports_Schema.Struct({
   status: BadgeStatus,
-  url: exports_Schema.optional(exports_Schema.String)
+  url: exports_Schema.optional(exports_Schema.String),
+  profile: exports_Schema.optional(BadgeProfileSchema)
 });
+var badgeRegenerationInputFields = {
+  fullName: nonBlank(200),
+  oneLiner: nonBlank(30),
+  linkUrl: url,
+  pictureSource: exports_Schema.optional(PictureSource)
+};
+var BadgeRegenerationInput = exports_Schema.Struct(badgeRegenerationInputFields);
+var badgeRegenerationInputFieldNames = Object.keys(badgeRegenerationInputFields);
 var PictureUploadSchema = exports_Schema.Struct({
   url: exports_Schema.String,
   contentType: PictureContentType,
@@ -59732,6 +59748,7 @@ var register = (options, input) => request3(options, "/api/v1/registrations", {
 var getCurrentUser = (options) => request3(options, "/api/v1/me", { method: "GET" }, decodeCurrentUser);
 var getRegistration = (options) => request3(options, "/api/v1/registration", { method: "GET" }, decodeRegistrationResult);
 var getBadge = (options) => request3(options, "/api/v1/badge", { method: "GET" }, decodeBadgeResult);
+var regenerateBadge = (options, input) => request3(options, "/api/v1/badge", { method: "PATCH", body: JSON.stringify(input) }, decodeBadgeResult);
 var confirmAttendance = (options, input) => request3(options, "/api/v1/registration/attendance", { method: "PUT", body: JSON.stringify(input) }, decodeRegistrationResult);
 var beginPictureUpload = (options, input) => request3(options, "/api/v1/profile-picture", { method: "POST", body: JSON.stringify(input) }, decodePictureUploadGrant);
 var completePictureUpload = (options, input) => request3(options, "/api/v1/profile-picture", { method: "PUT", body: JSON.stringify(input) }, decodePictureUpload);
@@ -60489,10 +60506,15 @@ var createChallengeScaffold = exports_Effect.fn("createChallengeScaffold")(funct
 });
 
 // src/cli-root.ts
+var rootValueFlagNames = {
+  apiUrl: "api-url",
+  output: "output",
+  token: "token"
+};
 var root = exports_Command.make("chofex").pipe(exports_Command.withSharedFlags({
-  apiUrl: exports_Flag.string("api-url").pipe(exports_Flag.withDefault(config.apiUrl), exports_Flag.withDescription("Chofex API base URL")),
-  output: exports_Flag.choice("output", ["human", "json"]).pipe(exports_Flag.withDefault("human"), exports_Flag.withDescription("Output format")),
-  token: exports_Flag.string("token").pipe(exports_Flag.optional, exports_Flag.withDescription("Clerk OAuth token (prefer CHOFEX_TOKEN to avoid shell history)"))
+  apiUrl: exports_Flag.string(rootValueFlagNames.apiUrl).pipe(exports_Flag.withDefault(config.apiUrl), exports_Flag.withDescription("Chofex API base URL")),
+  output: exports_Flag.choice(rootValueFlagNames.output, ["human", "json"]).pipe(exports_Flag.withDefault("human"), exports_Flag.withDescription("Output format")),
+  token: exports_Flag.string(rootValueFlagNames.token).pipe(exports_Flag.optional, exports_Flag.withDescription("Clerk OAuth token (prefer CHOFEX_TOKEN to avoid shell history)"))
 }), exports_Command.withDescription(`Register for and manage your ${eventName} application`));
 
 // src/output.ts
@@ -60614,7 +60636,13 @@ var requirementsOnlyText = (result3) => requirementsText(result3);
 var badgeText = (result3) => {
   if (result3.url)
     return result3.url;
-  return "You don't have a badge yet.";
+  if (result3.status === "pending" || result3.status === "running") {
+    return "Tu carnet se está generando.";
+  }
+  if (result3.status === "failed") {
+    return "No se pudo generar tu carnet. Ejecuta `chofex badge regenerate` para intentarlo de nuevo.";
+  }
+  return "Todavía no tienes un carnet.";
 };
 
 // src/challenge-commands.ts
@@ -61365,6 +61393,34 @@ var picturePathInput = (suppliedPath) => {
   }
   return exports_Prompt.run(requiredText("Path to a JPEG, PNG, or WebP picture (5 MB maximum)", exports_Schema.String.pipe(exports_Schema.check(exports_Schema.isMinLength(1))))).pipe(exports_Effect.mapError(() => cliError("PROMPT_CANCELLED", "Interactive input was cancelled")));
 };
+var badgeProfileInput = (path4, defaults2, pictures) => {
+  const interactive = exports_Effect.gen(function* () {
+    const publicFields = yield* exports_Prompt.run(exports_Prompt.all({
+      fullName: requiredText("Nombre impreso en el carnet", exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(200))), defaults2.fullName),
+      oneLiner: requiredText("Presentación de una línea", exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(30))), defaults2.oneLiner),
+      linkUrl: requiredText("Destino del QR", exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(2048))), defaults2.linkUrl)
+    }));
+    const pictureChoices = [{ title: "Mantener mi foto actual", value: "keep" }];
+    if (pictures.clerkPictureUrl) {
+      pictureChoices.push({ title: "Usar mi foto de Clerk", value: "clerk" });
+    }
+    if (pictures.githubUrl) {
+      pictureChoices.push({ title: "Usar mi foto de GitHub", value: "github" });
+    }
+    pictureChoices.push({
+      title: "Subir otra foto",
+      value: "upload"
+    });
+    const pictureChoice = yield* exports_Prompt.run(exports_Prompt.select({
+      message: "Foto impresa en el carnet",
+      choices: pictureChoices
+    }));
+    if (pictureChoice === "keep")
+      return publicFields;
+    return { ...publicFields, pictureSource: pictureChoice };
+  });
+  return inputOrInteractive(path4, interactive).pipe(exports_Effect.flatMap((input) => decode2(BadgeRegenerationInput, input, badgeRegenerationInputFieldNames)));
+};
 
 // src/picture-upload.ts
 import { readFile as readFile5, stat as stat3 } from "node:fs/promises";
@@ -63033,13 +63089,14 @@ var uploadPicture = exports_Effect.fn("uploadPicture")(function* (options, path4
 import { spawn as spawn3 } from "node:child_process";
 import { mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join3, relative, sep } from "node:path";
 var cliPackageName = "chofex-cli";
 var upgradeVersion = "latest";
-var npmUpgradeArguments = (cacheDirectory) => [
+var npmRegistryUrl = `https://registry.npmjs.org/${cliPackageName}/latest`;
+var npmUpgradeArguments = (cacheDirectory, version) => [
   "install",
   "--global",
-  `${cliPackageName}@${upgradeVersion}`,
+  `${cliPackageName}@${version}`,
   "--force",
   "--prefer-online",
   `--cache=${cacheDirectory}`
@@ -63047,22 +63104,32 @@ var npmUpgradeArguments = (cacheDirectory) => [
 var runProcess = (executable, arguments_, input) => new Promise((resolve4, reject) => {
   const stdin = input === undefined ? "ignore" : "pipe";
   const child = spawn3(executable, arguments_, {
-    stdio: [stdin, "ignore", "pipe"]
+    stdio: [stdin, "pipe", "pipe"]
   });
+  let stdout = "";
   let stderr = "";
+  const stdoutStream = child.stdout;
   const stderrStream = child.stderr;
-  if (stderrStream === null) {
+  if (stdoutStream === null || stderrStream === null) {
     child.kill();
-    reject(new Error(`Could not capture stderr from ${executable}`));
+    reject(new Error(`Could not capture output from ${executable}`));
     return;
   }
+  stdoutStream.setEncoding("utf8");
+  stdoutStream.on("data", (chunk) => {
+    stdout += chunk;
+  });
   stderrStream.setEncoding("utf8");
   stderrStream.on("data", (chunk) => {
     stderr += chunk;
   });
   child.on("error", reject);
   child.on("close", (exitCode) => {
-    resolve4({ exitCode: exitCode ?? 1, stderr: stderr.trim() });
+    resolve4({
+      exitCode: exitCode ?? 1,
+      stdout: stdout.trim(),
+      stderr: stderr.trim()
+    });
   });
   if (input !== undefined) {
     const stdinStream = child.stdin;
@@ -63079,7 +63146,7 @@ var runNpm = (arguments_) => {
   return runProcess(executable, arguments_);
 };
 var installerUrl = "https://hacktheandes.com/install";
-var runInstaller = async (installDirectory) => {
+var runInstaller = async (installDirectory, version) => {
   const response = await fetch(installerUrl);
   if (!response.ok) {
     throw new Error(`installer download returned HTTP ${response.status}`);
@@ -63088,6 +63155,8 @@ var runInstaller = async (installDirectory) => {
   const arguments_ = [
     "-s",
     "--",
+    "--version",
+    version,
     "--install-dir",
     installDirectory,
     "--no-modify-path"
@@ -63107,22 +63176,160 @@ var assertSuccessful = (result3, program) => {
   throw new Error(`${program} exited with code ${result3.exitCode}${detail}`);
 };
 var upgradeCli = async (options = {}) => {
+  const version = options.version ?? upgradeVersion;
   const standalone = options.standalone ?? isStandaloneExecutable();
   if (standalone) {
     const runner2 = options.installerRunner ?? runInstaller;
-    const result3 = await runner2(dirname2(process.execPath));
+    const result3 = await runner2(dirname2(process.execPath), version);
     assertSuccessful(result3, "installer");
     return;
   }
   const runner = options.npmRunner ?? runNpm;
   const cacheDirectory = await mkdtemp2(join3(tmpdir2(), "chofex-npm-cache-"));
   try {
-    const result3 = await runner(npmUpgradeArguments(cacheDirectory));
+    const result3 = await runner(npmUpgradeArguments(cacheDirectory, version));
     assertSuccessful(result3, "npm");
   } finally {
     await rm2(cacheDirectory, { recursive: true, force: true });
   }
 };
+var parseVersion = (version) => {
+  const match9 = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (match9 === null)
+    throw new Error(`Invalid CLI version: ${version}`);
+  return {
+    core: [Number(match9[1]), Number(match9[2]), Number(match9[3])],
+    prerelease: match9[4]?.split(".") ?? []
+  };
+};
+var comparePrereleaseIdentifier = (left, right) => {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : undefined;
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : undefined;
+  if (leftNumber !== undefined && rightNumber !== undefined) {
+    return leftNumber - rightNumber;
+  }
+  if (leftNumber !== undefined)
+    return -1;
+  if (rightNumber !== undefined)
+    return 1;
+  return left.localeCompare(right);
+};
+var compareVersions = (left, right) => {
+  const parsedLeft = parseVersion(left);
+  const parsedRight = parseVersion(right);
+  const [leftMajor, leftMinor, leftPatch] = parsedLeft.core;
+  const [rightMajor, rightMinor, rightPatch] = parsedRight.core;
+  for (const difference3 of [
+    leftMajor - rightMajor,
+    leftMinor - rightMinor,
+    leftPatch - rightPatch
+  ]) {
+    if (difference3 !== 0)
+      return difference3;
+  }
+  if (parsedLeft.prerelease.length === 0) {
+    return parsedRight.prerelease.length === 0 ? 0 : 1;
+  }
+  if (parsedRight.prerelease.length === 0)
+    return -1;
+  const identifierCount = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+  for (let index2 = 0;index2 < identifierCount; index2 += 1) {
+    const leftIdentifier = parsedLeft.prerelease[index2];
+    const rightIdentifier = parsedRight.prerelease[index2];
+    if (leftIdentifier === undefined)
+      return -1;
+    if (rightIdentifier === undefined)
+      return 1;
+    const difference3 = comparePrereleaseIdentifier(leftIdentifier, rightIdentifier);
+    if (difference3 !== 0)
+      return difference3;
+  }
+  return 0;
+};
+var fetchLatestVersion = async () => {
+  const response = await fetch(npmRegistryUrl, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!response.ok) {
+    throw new Error(`npm registry returned HTTP ${response.status}`);
+  }
+  const metadata = await response.json();
+  if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || typeof metadata.version !== "string") {
+    throw new Error("npm registry returned an invalid package version");
+  }
+  parseVersion(metadata.version);
+  return metadata.version;
+};
+var autoUpdateCli = async (currentVersion, options = {}) => {
+  const latestVersion = await (options.fetchLatestVersion ?? fetchLatestVersion)();
+  if (compareVersions(latestVersion, currentVersion) <= 0) {
+    return { status: "current", version: currentVersion };
+  }
+  const upgrade = options.upgrade ?? ((version) => upgradeCli({ version }));
+  await upgrade(latestVersion);
+  return {
+    status: "updated",
+    previousVersion: currentVersion,
+    version: latestVersion
+  };
+};
+var npmGlobalNodeModulesPath = async (runner = runNpm) => {
+  const result3 = await runner(["root", "--global"]);
+  assertSuccessful(result3, "npm");
+  if (!result3.stdout)
+    throw new Error("npm did not report its global root");
+  return result3.stdout;
+};
+var pathIsInside = (parent, child) => {
+  const pathFromParent = relative(parent, child);
+  return pathFromParent !== "" && pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep}`) && !isAbsolute(pathFromParent);
+};
+var rootFlagsWithValues = new Set(Object.values(rootValueFlagNames).map((name) => `--${name}`));
+var requestedCommand = (arguments_) => {
+  for (let index2 = 0;index2 < arguments_.length; index2 += 1) {
+    const argument = arguments_[index2];
+    if (argument === undefined)
+      continue;
+    if (rootFlagsWithValues.has(argument)) {
+      index2 += 1;
+      continue;
+    }
+    if (argument.startsWith("-"))
+      continue;
+    return argument;
+  }
+  return;
+};
+var shouldAutoUpdateCli = async ({
+  arguments: arguments_,
+  entryPath,
+  environmentValue,
+  globalNodeModulesPath,
+  npmRunner,
+  standalone
+}) => {
+  if (environmentValue === "0" || environmentValue === "false")
+    return false;
+  const command = requestedCommand(arguments_);
+  if (command === "update" || command === "upgrade") {
+    return false;
+  }
+  if (standalone)
+    return true;
+  if (!entryPath.split(/[\\/]/).includes("node_modules"))
+    return false;
+  const npmRoot = globalNodeModulesPath ?? await npmGlobalNodeModulesPath(npmRunner);
+  return pathIsInside(join3(npmRoot, cliPackageName), entryPath);
+};
+var runUpdatedCli = () => new Promise((resolve4, reject) => {
+  const child = spawn3(process.execPath, process.argv.slice(1), {
+    env: { ...process.env, CHOFEX_AUTO_UPDATE: "0" },
+    stdio: "inherit"
+  });
+  child.on("error", reject);
+  child.on("close", (exitCode) => resolve4(exitCode ?? 1));
+});
 
 // src/commands.ts
 var inputFlag2 = exports_Flag.string("input").pipe(exports_Flag.optional, exports_Flag.withDescription("Read JSON from a file, or use - for stdin"));
@@ -63209,12 +63416,50 @@ var requirementsCommand = exports_Command.make("requirements", {}, exports_Effec
   });
   yield* execute(options.output, operation, requirementsOnlyText, registrationLookupErrorText);
 })).pipe(exports_Command.withDescription("Show information you still need to provide"));
+var badgeRegenerateCommand = exports_Command.make("regenerate", {
+  input: inputFlag2,
+  picture: exports_Flag.string("picture").pipe(exports_Flag.optional, exports_Flag.withDescription("Ruta a una foto JPEG, PNG o WebP (máximo 5 MB)"))
+}, exports_Effect.fn("badgeRegenerateCommand")(function* ({ input, picture }) {
+  const options = yield* root;
+  const operation = exports_Effect.gen(function* () {
+    const inputPath = exports_Option.getOrUndefined(input);
+    if (options.output === "json" && inputPath === undefined) {
+      return yield* exports_Effect.fail(cliError("INPUT_REQUIRED", "El modo JSON requiere --input <archivo> o --input -"));
+    }
+    const token = exports_Option.getOrUndefined(options.token);
+    const client = { apiUrl: options.apiUrl, token };
+    const badge = yield* getBadge(client);
+    if (!badge.data.profile) {
+      return yield* exports_Effect.fail(cliError("INVALID_APPLICATION_STATE", "Confirma tu asistencia antes de regenerar tu carnet"));
+    }
+    const [current, currentUser] = yield* exports_Effect.all([
+      getRegistration(client),
+      getCurrentUser(client)
+    ]);
+    const body = yield* badgeProfileInput(inputPath, badge.data.profile, {
+      clerkPictureUrl: currentUser.data.clerkPictureUrl,
+      githubUrl: current.data.registration.githubUrl
+    });
+    const picturePath = exports_Option.getOrUndefined(picture);
+    if (body.pictureSource === "upload") {
+      if (options.output === "json" && picturePath === undefined) {
+        return yield* exports_Effect.fail(cliError("PICTURE_PATH_REQUIRED", "Usa --picture <ruta> cuando pictureSource es upload"));
+      }
+      const path4 = yield* picturePathInput(picturePath);
+      yield* uploadPicture(client, path4);
+    } else if (picturePath) {
+      return yield* exports_Effect.fail(cliError("UNEXPECTED_PICTURE_PATH", "--picture solo se puede usar cuando pictureSource es upload"));
+    }
+    return yield* regenerateBadge(client, body);
+  });
+  yield* execute(options.output, operation, badgeText);
+})).pipe(exports_Command.withDescription("Actualiza la foto, el nombre, la presentación y el enlace QR del carnet"));
 var badgeCommand = exports_Command.make("badge", {}, exports_Effect.fn("badgeCommand")(function* () {
   const options = yield* root;
   const token = exports_Option.getOrUndefined(options.token);
   const operation = getBadge({ apiUrl: options.apiUrl, token });
   yield* execute(options.output, operation, badgeText);
-})).pipe(exports_Command.withDescription("Show your generated participant badge"));
+})).pipe(exports_Command.withDescription("Muestra o regenera tu carnet de participante"), exports_Command.withSubcommands([badgeRegenerateCommand]));
 var confirmCommand = exports_Command.make("confirm", {
   input: inputFlag2,
   picture: exports_Flag.string("picture").pipe(exports_Flag.optional, exports_Flag.withDescription("Path to a JPEG, PNG, or WebP picture (5 MB max)"))
@@ -63649,4 +63894,37 @@ var programForArguments = () => {
   }
   return commandProgram;
 };
-programForArguments().pipe(exports_Effect.provide(exports_NodeServices.layer), (program) => exports_NodeRuntime.runMain(program, { disableErrorReporting: true }));
+var runAutomaticUpdate = async () => {
+  try {
+    const standalone = isStandaloneExecutable();
+    const enabled = await shouldAutoUpdateCli({
+      arguments: arguments_,
+      entryPath: fileURLToPath2(import.meta.url),
+      environmentValue: process.env.CHOFEX_AUTO_UPDATE,
+      standalone
+    });
+    if (!enabled)
+      return "continue";
+    const result3 = await autoUpdateCli(cliVersion);
+    if (result3.status === "current")
+      return "continue";
+    process.stderr.write(`${cliPackageName} se actualizó de ${result3.previousVersion} a ${result3.version}.
+`);
+    if (standalone && process.platform === "win32") {
+      process.stderr.write(`La actualización se aplicará cuando termine este comando.
+`);
+      return "continue";
+    }
+    process.exitCode = await runUpdatedCli();
+    return "command-completed";
+  } catch {
+    process.stderr.write(`No se pudo comprobar o instalar una actualización de ${cliPackageName}; se continuará con ${cliVersion}.
+`);
+    return "continue";
+  }
+};
+exports_Effect.promise(runAutomaticUpdate).pipe(exports_Effect.flatMap((outcome) => {
+  if (outcome === "command-completed")
+    return exports_Effect.void;
+  return programForArguments();
+}), exports_Effect.provide(exports_NodeServices.layer), (program) => exports_NodeRuntime.runMain(program, { disableErrorReporting: true }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chofex-cli",
-  "version": "0.1.177",
+  "version": "0.1.178",
   "description": "Command-line client for Hack the Andes",
   "type": "module",
   "bin": {