requestshield 0.1.3 → 0.1.4

package/src/commands/agent-setup.mjs

@@ -1,185 +1,185 @@
-// @ts-check
-
-import { cp, lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { createInterface } from "node:readline/promises";
-import { CliError } from "../errors.mjs";
-import { detectAgents } from "../agent-detector.mjs";
-import { getAsset, isSea } from "node:sea";
-
-const skillAsset = "requestshield-skill.md";
-
-/**
- * @param {{ agent?: "codex" | "claude", force: boolean }} options
- * @param {{ env?: NodeJS.ProcessEnv, homeDir?: string, log: (message: string) => void, sourceDir?: string, executablePath?: string, detectAgents?: () => Promise<Array<"codex" | "claude">>, selectAgent?: (detected: Array<"codex" | "claude">) => Promise<"codex" | "claude"> }} deps
- */
-export async function setupAgent(options, deps) {
-  const agent = await resolveAgent(options.agent, deps);
-  const homeDir = deps.homeDir ?? os.homedir();
-
-  // Codex and Claude discover personal skills from different directories.
-  const skillsRoot = agent === "codex"
-    ? path.join(homeDir, ".agents", "skills")
-    : path.join(homeDir, ".claude", "skills");
-  const destination = path.join(skillsRoot, "requestshield");
-  await mkdir(skillsRoot, { recursive: true });
-
-  const exists = await pathExists(destination);
-  if (exists && !options.force) {
-    throw new CliError(`RequestShield skill already exists at ${destination}; use --force to replace it`, {
-      code: "SKILL_EXISTS",
-      exitCode: 2,
-    });
-  }
-
-  // Copy into a staging directory so an interrupted copy cannot leave a
-  // partially installed skill at the final destination.
-  const staging = path.join(skillsRoot, `.requestshield-${randomUUID()}.tmp`);
-  const backup = `${destination}.${randomUUID()}.backup`;
-  try {
-    if (deps.sourceDir) {
-      // Tests and alternate packagers can provide an explicit skill source.
-      await cp(deps.sourceDir, staging, {
-        recursive: true,
-        errorOnExist: true,
-      });
-    } else if (isSea()) {
-      // A single-executable build reads the skill from its embedded assets.
-      await mkdir(staging);
-
-      await writeFile(
-          path.join(staging, "SKILL.md"),
-          Buffer.from(getAsset(skillAsset)),
-      );
-    } else {
-      // Source, npm, and on-disk CJS builds keep the skill beside the program.
-      //
-      // src/main.mjs                 -> ../skills/requestshield
-      // dist/requestshield.cjs      -> ../skills/requestshield
-      // npm link and global npm installs expose a symlink in their bin folder.
-      // Follow it before resolving the adjacent packaged skills directory.
-      const executable = await realpath(deps.executablePath ?? process.argv[1]);
-      const executableDir = path.dirname(executable);
-      const source = path.resolve(
-          executableDir,
-          "../skills/requestshield",
-      );
-
-      await cp(source, staging, {
-        recursive: true,
-        errorOnExist: true,
-      });
-    }
-
-    // Keep the old installation recoverable until the staged copy is in place.
-    if (exists) await rename(destination, backup);
-    await rename(staging, destination);
-    if (exists) await rm(backup, { recursive: true, force: true });
-  } catch (error) {
-    await rm(staging, { recursive: true, force: true });
-    if (await pathExists(backup)) {
-      await rm(destination, { recursive: true, force: true });
-      await rename(backup, destination);
-    }
-    throw error;
-  }
-  const agentLabel = agent === "codex" ? "Codex" : "Claude";
-  deps.log(`Installed RequestShield skill for ${agentLabel} at ${destination}`);
-  deps.log(`Restart ${agentLabel} or start a new task before using the skill.`);
-}
-
-/**
- * Explicit selection bypasses detection. Automatic setup selects a single
- * detected agent or asks the user when both agents are present.
- *
- * @param {"codex" | "claude" | undefined} requested
- * @param {{ env?: NodeJS.ProcessEnv, homeDir?: string, detectAgents?: () => Promise<Array<"codex" | "claude">>, selectAgent?: (detected: Array<"codex" | "claude">) => Promise<"codex" | "claude"> }} deps
- * @returns {Promise<"codex" | "claude">}
- */
-async function resolveAgent(requested, deps) {
-  // A command-line choice is authoritative and avoids probing the machine.
-  if (requested) return requested;
-
-  const detected = deps.detectAgents
-    ? await deps.detectAgents()
-    : await detectAgents({ env: deps.env, homeDir: deps.homeDir });
-
-  if (detected.length === 1) return detected[0];
-  if (detected.length === 0) {
-    throw new CliError(
-      [
-        "No supported coding agent detected.",
-        "",
-        "Choose one explicitly:",
-        "  requestshield agent setup --codex",
-        "  requestshield agent setup --claude",
-      ].join("\n"),
-      { code: "AGENT_NOT_FOUND", exitCode: 2 },
-    );
-  }
-
-  // Never choose silently when both agents are present. Interactive users get
-  // a prompt; non-interactive callers receive a stable conflict error.
-  const selectAgent = deps.selectAgent ?? promptForAgent;
-  const selected = await selectAgent(detected);
-  if (!detected.includes(selected)) {
-    throw new CliError(`Selected agent is not available: ${selected}`, {
-      code: "INVALID_AGENT",
-      exitCode: 2,
-    });
-  }
-  return selected;
-}
-
-/**
- * Ask an interactive user which detected agent should receive the skill.
- *
- * @returns {Promise<"codex" | "claude">}
- */
-async function promptForAgent() {
-  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
-    throw new CliError(
-      [
-        "Multiple coding agents detected.",
-        "",
-        "Choose one explicitly:",
-        "  requestshield agent setup --codex",
-        "  requestshield agent setup --claude",
-      ].join("\n"),
-      { code: "INSTALL_CONFLICT", exitCode: 2 },
-    );
-  }
-
-  const prompt = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  try {
-    process.stdout.write(
-      "Multiple coding agents detected.\n\n  1. Codex\n  2. Claude\n\n",
-    );
-    while (true) {
-      const answer = (await prompt.question("Select an agent [1-2]: "))
-        .trim()
-        .toLowerCase();
-      if (answer === "1" || answer === "codex") return "codex";
-      if (answer === "2" || answer === "claude") return "claude";
-      process.stdout.write("Enter 1 for Codex or 2 for Claude.\n");
-    }
-  } finally {
-    prompt.close();
-  }
-}
-
-/** @param {string} target */
-async function pathExists(target) {
-  try {
-    await lstat(target);
-    return true;
-  } catch (error) {
-    if (/** @type {NodeJS.ErrnoException} */ (error).code === "ENOENT") return false;
-    throw error;
-  }
-}
+// @ts-check
+
+import { cp, lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { CliError } from "../errors.mjs";
+import { detectAgents } from "../agent-detector.mjs";
+import { getAsset, isSea } from "node:sea";
+
+const skillAsset = "requestshield-skill.md";
+
+/**
+ * @param {{ agent?: "codex" | "claude", force: boolean }} options
+ * @param {{ env?: NodeJS.ProcessEnv, homeDir?: string, log: (message: string) => void, sourceDir?: string, executablePath?: string, detectAgents?: () => Promise<Array<"codex" | "claude">>, selectAgent?: (detected: Array<"codex" | "claude">) => Promise<"codex" | "claude"> }} deps
+ */
+export async function setupAgent(options, deps) {
+  const agent = await resolveAgent(options.agent, deps);
+  const homeDir = deps.homeDir ?? os.homedir();
+
+  // Codex and Claude discover personal skills from different directories.
+  const skillsRoot = agent === "codex"
+    ? path.join(homeDir, ".agents", "skills")
+    : path.join(homeDir, ".claude", "skills");
+  const destination = path.join(skillsRoot, "requestshield");
+  await mkdir(skillsRoot, { recursive: true });
+
+  const exists = await pathExists(destination);
+  if (exists && !options.force) {
+    throw new CliError(`RequestShield skill already exists at ${destination}; use --force to replace it`, {
+      code: "SKILL_EXISTS",
+      exitCode: 2,
+    });
+  }
+
+  // Copy into a staging directory so an interrupted copy cannot leave a
+  // partially installed skill at the final destination.
+  const staging = path.join(skillsRoot, `.requestshield-${randomUUID()}.tmp`);
+  const backup = `${destination}.${randomUUID()}.backup`;
+  try {
+    if (deps.sourceDir) {
+      // Tests and alternate packagers can provide an explicit skill source.
+      await cp(deps.sourceDir, staging, {
+        recursive: true,
+        errorOnExist: true,
+      });
+    } else if (isSea()) {
+      // A single-executable build reads the skill from its embedded assets.
+      await mkdir(staging);
+
+      await writeFile(
+          path.join(staging, "SKILL.md"),
+          Buffer.from(getAsset(skillAsset)),
+      );
+    } else {
+      // Source, npm, and on-disk CJS builds keep the skill beside the program.
+      //
+      // src/main.mjs                 -> ../skills/requestshield
+      // dist/requestshield.cjs      -> ../skills/requestshield
+      // npm link and global npm installs expose a symlink in their bin folder.
+      // Follow it before resolving the adjacent packaged skills directory.
+      const executable = await realpath(deps.executablePath ?? process.argv[1]);
+      const executableDir = path.dirname(executable);
+      const source = path.resolve(
+          executableDir,
+          "../skills/requestshield",
+      );
+
+      await cp(source, staging, {
+        recursive: true,
+        errorOnExist: true,
+      });
+    }
+
+    // Keep the old installation recoverable until the staged copy is in place.
+    if (exists) await rename(destination, backup);
+    await rename(staging, destination);
+    if (exists) await rm(backup, { recursive: true, force: true });
+  } catch (error) {
+    await rm(staging, { recursive: true, force: true });
+    if (await pathExists(backup)) {
+      await rm(destination, { recursive: true, force: true });
+      await rename(backup, destination);
+    }
+    throw error;
+  }
+  const agentLabel = agent === "codex" ? "Codex" : "Claude";
+  deps.log(`Installed RequestShield skill for ${agentLabel} at ${destination}`);
+  deps.log(`Restart ${agentLabel} or start a new task before using the skill.`);
+}
+
+/**
+ * Explicit selection bypasses detection. Automatic setup selects a single
+ * detected agent or asks the user when both agents are present.
+ *
+ * @param {"codex" | "claude" | undefined} requested
+ * @param {{ env?: NodeJS.ProcessEnv, homeDir?: string, detectAgents?: () => Promise<Array<"codex" | "claude">>, selectAgent?: (detected: Array<"codex" | "claude">) => Promise<"codex" | "claude"> }} deps
+ * @returns {Promise<"codex" | "claude">}
+ */
+async function resolveAgent(requested, deps) {
+  // A command-line choice is authoritative and avoids probing the machine.
+  if (requested) return requested;
+
+  const detected = deps.detectAgents
+    ? await deps.detectAgents()
+    : await detectAgents({ env: deps.env, homeDir: deps.homeDir });
+
+  if (detected.length === 1) return detected[0];
+  if (detected.length === 0) {
+    throw new CliError(
+      [
+        "No supported coding agent detected.",
+        "",
+        "Choose one explicitly:",
+        "  requestshield agent setup --codex",
+        "  requestshield agent setup --claude",
+      ].join("\n"),
+      { code: "AGENT_NOT_FOUND", exitCode: 2 },
+    );
+  }
+
+  // Never choose silently when both agents are present. Interactive users get
+  // a prompt; non-interactive callers receive a stable conflict error.
+  const selectAgent = deps.selectAgent ?? promptForAgent;
+  const selected = await selectAgent(detected);
+  if (!detected.includes(selected)) {
+    throw new CliError(`Selected agent is not available: ${selected}`, {
+      code: "INVALID_AGENT",
+      exitCode: 2,
+    });
+  }
+  return selected;
+}
+
+/**
+ * Ask an interactive user which detected agent should receive the skill.
+ *
+ * @returns {Promise<"codex" | "claude">}
+ */
+async function promptForAgent() {
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+    throw new CliError(
+      [
+        "Multiple coding agents detected.",
+        "",
+        "Choose one explicitly:",
+        "  requestshield agent setup --codex",
+        "  requestshield agent setup --claude",
+      ].join("\n"),
+      { code: "INSTALL_CONFLICT", exitCode: 2 },
+    );
+  }
+
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    process.stdout.write(
+      "Multiple coding agents detected.\n\n  1. Codex\n  2. Claude\n\n",
+    );
+    while (true) {
+      const answer = (await prompt.question("Select an agent [1-2]: "))
+        .trim()
+        .toLowerCase();
+      if (answer === "1" || answer === "codex") return "codex";
+      if (answer === "2" || answer === "claude") return "claude";
+      process.stdout.write("Enter 1 for Codex or 2 for Claude.\n");
+    }
+  } finally {
+    prompt.close();
+  }
+}
+
+/** @param {string} target */
+async function pathExists(target) {
+  try {
+    await lstat(target);
+    return true;
+  } catch (error) {
+    if (/** @type {NodeJS.ErrnoException} */ (error).code === "ENOENT") return false;
+    throw error;
+  }
+}

package/src/commands/update-check.mjs

@@ -0,0 +1,139 @@
+// @ts-check
+
+import readline from "node:readline/promises";
+import { spawn } from "node:child_process";
+import { stdin, stdout } from "node:process";
+import { CliError } from "../errors.mjs";
+
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+
+/**
+ * @param {{ currentVersion: string, packageName: string, log: (message: string) => void, fetchImpl?: typeof fetch, confirm?: () => Promise<boolean>, install?: (packageName: string, version: string) => Promise<void> }} options
+ */
+export async function checkForUpdate(options) {
+  const latestVersion = await fetchLatestVersion(
+    options.packageName,
+    options.fetchImpl ?? fetch,
+  );
+
+  options.log(`Current version: ${options.currentVersion}`);
+  options.log(`Latest version: ${latestVersion}`);
+
+  if (compareVersions(latestVersion, options.currentVersion) <= 0) {
+    options.log("RequestShield is already up to date.");
+    return;
+  }
+
+  const accepted = await (options.confirm ?? confirmUpdate)(latestVersion);
+  if (!accepted) {
+    options.log("Update cancelled.");
+    return;
+  }
+
+  options.log(`Updating RequestShield to ${latestVersion}...`);
+  await (options.install ?? installWithNpm)(options.packageName, latestVersion);
+  options.log(`RequestShield ${latestVersion} was installed successfully.`);
+  options.log("Open a new terminal before running RequestShield again.");
+}
+
+/** @param {string} packageName @param {typeof fetch} fetchImpl */
+async function fetchLatestVersion(packageName, fetchImpl) {
+  const url = `${DEFAULT_REGISTRY}/${encodeURIComponent(packageName)}/latest`;
+  let response;
+  try {
+    response = await fetchImpl(url, { signal: AbortSignal.timeout(15_000) });
+  } catch (error) {
+    throw new CliError(`Could not check the latest RequestShield version: ${messageOf(error)}`, {
+      code: "UPDATE_CHECK_FAILED",
+      exitCode: 7,
+    });
+  }
+
+  if (!response.ok) {
+    throw new CliError(`Could not check the latest RequestShield version: HTTP ${response.status}`, {
+      code: "UPDATE_CHECK_FAILED",
+      exitCode: 7,
+    });
+  }
+
+  const body = await response.json();
+  const version = body && typeof body === "object" ? Reflect.get(body, "version") : undefined;
+  if (typeof version !== "string" || !parseVersion(version)) {
+    throw new CliError("The npm registry returned an invalid RequestShield version", {
+      code: "INVALID_UPDATE_RESPONSE",
+    });
+  }
+  return version;
+}
+
+/** @param {string} latestVersion */
+async function confirmUpdate(latestVersion) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new CliError(`RequestShield ${latestVersion} is available, but confirmation requires an interactive terminal`, {
+      code: "UPDATE_CONFIRMATION_REQUIRED",
+      exitCode: 2,
+    });
+  }
+  const prompt = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await prompt.question(`Update to RequestShield ${latestVersion}? (y/N): `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    prompt.close();
+  }
+}
+
+/** @param {string} packageName @param {string} version */
+async function installWithNpm(packageName, version) {
+  await new Promise((resolve, reject) => {
+    const child = spawn("npm", ["install", "--global", `${packageName}@${version}`], {
+      shell: process.platform === "win32",
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    child.once("error", (error) => {
+      reject(new CliError(`Could not start npm: ${error.message}`, {
+        code: "UPDATE_FAILED",
+        exitCode: 1,
+      }));
+    });
+    child.once("exit", (code) => {
+      if (code === 0) resolve(undefined);
+      else reject(new CliError(`npm update failed with exit code ${code ?? "unknown"}`, {
+        code: "UPDATE_FAILED",
+        exitCode: 1,
+      }));
+    });
+  });
+}
+
+/** @param {string} left @param {string} right */
+function compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) throw new CliError("RequestShield has an invalid semantic version");
+  for (let index = 0; index < 3; index++) {
+    if (a.numbers[index] !== b.numbers[index]) return a.numbers[index] - b.numbers[index];
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (a.prerelease === undefined) return 1;
+  if (b.prerelease === undefined) return -1;
+  return a.prerelease.localeCompare(b.prerelease, "en", { numeric: true });
+}
+
+/** @param {string} value */
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
+  if (!match) return undefined;
+  return {
+    numbers: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4],
+  };
+}
+
+/** @param {unknown} error */
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export { compareVersions };

package/src/main.mjs

@@ -1,25 +1,25 @@
 #!/usr/bin/env node
-// @ts-check
-
-import { run } from "./cli.mjs";
-import { CliError } from "./errors.mjs";
-
-async function main() {
-    try {
-        await run(process.argv.slice(2));
-    } catch (error) {
-        const message =
-            error instanceof Error
-                ? error.message
-                : String(error);
-
-        console.error(`requestshield: ${message}`);
-
-        process.exitCode =
-            error instanceof CliError
-                ? error.exitCode
-                : 1;
-    }
-}
-
-void main();
+// @ts-check
+
+import { run } from "./cli.mjs";
+import { CliError } from "./errors.mjs";
+
+async function main() {
+    try {
+        await run(process.argv.slice(2));
+    } catch (error) {
+        const message =
+            error instanceof Error
+                ? error.message
+                : String(error);
+
+        console.error(`requestshield: ${message}`);
+
+        process.exitCode =
+            error instanceof CliError
+                ? error.exitCode
+                : 1;
+    }
+}
+
+void main();