@rigkit/cli 0.2.9 → 0.2.11

package/src/project.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { discoverProjectConfigs, resolveConfigPaths } from "./project.ts";
 
 describe("CLI project resolution", () => {
-  test("resolves -chdir to that directory's rig.config.ts", () => {
+  test("resolves --chdir to that directory's rig.config.ts", () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
     mkdirSync(join(cwd, "example"));
     writeFileSync(join(cwd, "example", "rig.config.ts"), "export default {}\n");
@@ -15,7 +15,7 @@ describe("CLI project resolution", () => {
     expect(paths.configPath).toBe(join(cwd, "example", "rig.config.ts"));
   });
 
-  test("resolves -config project root from the config dirname", () => {
+  test("resolves --config project root from the config dirname", () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-"));
     const paths = resolveConfigPaths({ cwd, config: "machines/platform.ts" });
 
@@ -40,7 +40,7 @@ describe("CLI project resolution", () => {
     writeFileSync(join(cwd, "web.rig.config.ts"), "export default {}\n");
 
     expect(() => resolveConfigPaths({ cwd })).toThrow(
-      /Found named Rigkit configs[\s\S]*api\.rig\.config\.ts[\s\S]*web\.rig\.config\.ts[\s\S]*rig -chdir=\. -config=api\.rig\.config\.ts <command>/,
+      /Found named Rigkit configs[\s\S]*api\.rig\.config\.ts[\s\S]*web\.rig\.config\.ts[\s\S]*rig --chdir=\. --config=api\.rig\.config\.ts <command>/,
     );
   });
 

package/src/project.ts

@@ -159,7 +159,7 @@ function appendConfigFilesHint(
   options: { commandCwd: string; hint?: ConfigFilesHint },
 ): string {
   const hint = options.hint;
-  if (!hint) return `${message} Run "rig init" or pass -config=<file>.`;
+  if (!hint) return `${message} Run "rig init" or pass --config=<file>.`;
 
   const configFile = hint.files[0]!;
   const configPath = displayPath(options.commandCwd, join(hint.dir, configFile));
@@ -171,8 +171,8 @@ function appendConfigFilesHint(
     ...hint.files.map((file) => `- ${file}`),
     "",
     "Choose one explicitly:",
-    `  rig -config=${configPath} <command>`,
-    `  rig -chdir=${projectDir} -config=${configFile} <command>`,
+    `  rig --config=${configPath} <command>`,
+    `  rig --chdir=${projectDir} --config=${configFile} <command>`,
   ].join("\n");
 }
 

package/src/update-check.ts

@@ -0,0 +1,224 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { defaultRigkitHome } from "@rigkit/runtime-client";
+import * as ui from "./ui.ts";
+
+type NoticeStream = {
+  isTTY?: boolean;
+  write(chunk: string): unknown;
+};
+
+type LatestRelease = {
+  version: string;
+  tag?: string;
+  installerUrl?: string;
+  releaseUrl?: string;
+};
+
+type UpdateCache = {
+  checkedAt: string;
+  updateUrl: string;
+  latest?: LatestRelease;
+};
+
+type UpdateCheckOptions = {
+  commandName?: string;
+  json: boolean;
+  currentVersion: string;
+  stream?: NoticeStream;
+};
+
+const DEFAULT_UPDATE_URL = "https://www.rigkit.dev/latest.json";
+const DEFAULT_INSTALL_URL = "https://www.rigkit.dev/install";
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 900;
+
+export async function maybePrintUpdateNotice(options: UpdateCheckOptions): Promise<void> {
+  const stream = options.stream ?? process.stderr;
+  if (!shouldCheckForUpdates(options, stream)) return;
+
+  const updateUrl = process.env.RIGKIT_UPDATE_URL?.trim() || DEFAULT_UPDATE_URL;
+  const latest = await resolveLatestRelease(updateUrl);
+  if (!latest || !isNewerVersion(latest.version, options.currentVersion)) return;
+
+  stream.write(renderUpdateNotice({
+    currentVersion: options.currentVersion,
+    latest,
+  }));
+}
+
+function shouldCheckForUpdates(options: UpdateCheckOptions, stream: NoticeStream): boolean {
+  if (options.json) return false;
+  if (options.commandName === "completion") return false;
+
+  const mode = normalizeUpdateCheckMode(process.env.RIGKIT_UPDATE_CHECK);
+  if (mode === "off") return false;
+  if (mode === "force") return true;
+  if (process.env.CI) return false;
+  return Boolean(stream.isTTY);
+}
+
+function normalizeUpdateCheckMode(value: string | undefined): "auto" | "force" | "off" {
+  switch (value?.trim().toLowerCase()) {
+    case "0":
+    case "false":
+    case "no":
+    case "off":
+      return "off";
+    case "1":
+    case "true":
+    case "yes":
+    case "on":
+    case "force":
+    case "always":
+      return "force";
+    default:
+      return "auto";
+  }
+}
+
+async function resolveLatestRelease(updateUrl: string): Promise<LatestRelease | undefined> {
+  const cached = readUpdateCache(updateUrl);
+  if (cached && isFreshCache(cached)) return cached.latest;
+
+  const latest = await fetchLatestRelease(updateUrl);
+  if (latest) {
+    writeUpdateCache({ checkedAt: new Date().toISOString(), updateUrl, latest });
+    return latest;
+  }
+
+  return cached?.latest;
+}
+
+function readUpdateCache(updateUrl: string): UpdateCache | undefined {
+  const path = updateCachePath();
+  if (!existsSync(path)) return undefined;
+
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as UpdateCache;
+    if (parsed.updateUrl !== updateUrl || !parsed.latest?.version) return undefined;
+    return parsed;
+  } catch {
+    return undefined;
+  }
+}
+
+function isFreshCache(cache: UpdateCache): boolean {
+  const checkedAt = Date.parse(cache.checkedAt);
+  if (!Number.isFinite(checkedAt)) return false;
+  return Date.now() - checkedAt < CHECK_INTERVAL_MS;
+}
+
+async function fetchLatestRelease(updateUrl: string): Promise<LatestRelease | undefined> {
+  const timeoutMs = updateTimeoutMs();
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(updateUrl, {
+      headers: { "Accept": "application/json" },
+      signal: controller.signal,
+    });
+    if (!response.ok) return undefined;
+
+    const body = await response.json() as Partial<LatestRelease>;
+    if (typeof body.version !== "string" || body.version.trim() === "") return undefined;
+    return {
+      version: body.version.trim(),
+      tag: typeof body.tag === "string" ? body.tag : undefined,
+      installerUrl: typeof body.installerUrl === "string" ? body.installerUrl : undefined,
+      releaseUrl: typeof body.releaseUrl === "string" ? body.releaseUrl : undefined,
+    };
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function writeUpdateCache(cache: UpdateCache): void {
+  const path = updateCachePath();
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(cache, null, 2)}\n`);
+  } catch {
+    // Update checks are advisory. Cache failures should never affect a command.
+  }
+}
+
+function updateCachePath(): string {
+  return join(defaultRigkitHome(), "update-check.json");
+}
+
+function updateTimeoutMs(): number {
+  const parsed = Number(process.env.RIGKIT_UPDATE_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
+}
+
+function renderUpdateNotice(input: { currentVersion: string; latest: LatestRelease }): string {
+  const installUrl = input.latest.installerUrl || DEFAULT_INSTALL_URL;
+  return [
+    "",
+    `${ui.warn("!")} ${ui.bold(`rig ${input.latest.version} is available`)} ${ui.dim(`(current ${input.currentVersion})`)}`,
+    ui.hint(`update with: curl -fsSL ${installUrl} | sh`),
+  ].join("\n") + "\n";
+}
+
+function isNewerVersion(candidate: string, current: string): boolean {
+  const parsedCandidate = parseSemver(candidate);
+  const parsedCurrent = parseSemver(current);
+  if (!parsedCandidate || !parsedCurrent) return false;
+  return compareSemver(parsedCandidate, parsedCurrent) > 0;
+}
+
+type Semver = {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease: string[];
+};
+
+function parseSemver(value: string): Semver | undefined {
+  const match = value.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!match) return undefined;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : [],
+  };
+}
+
+function compareSemver(left: Semver, right: Semver): number {
+  for (const key of ["major", "minor", "patch"] as const) {
+    const delta = left[key] - right[key];
+    if (delta !== 0) return delta;
+  }
+
+  if (left.prerelease.length === 0 && right.prerelease.length > 0) return 1;
+  if (left.prerelease.length > 0 && right.prerelease.length === 0) return -1;
+
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === undefined && rightPart === undefined) return 0;
+    if (leftPart === undefined) return -1;
+    if (rightPart === undefined) return 1;
+
+    const leftNumeric = /^\d+$/.test(leftPart);
+    const rightNumeric = /^\d+$/.test(rightPart);
+    if (leftNumeric && rightNumeric) {
+      const delta = Number(leftPart) - Number(rightPart);
+      if (delta !== 0) return delta;
+      continue;
+    }
+    if (leftNumeric) return -1;
+    if (rightNumeric) return 1;
+
+    const delta = leftPart.localeCompare(rightPart);
+    if (delta !== 0) return delta;
+  }
+
+  return 0;
+}

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_CLI_VERSION = "0.2.9";
+export const RIGKIT_CLI_VERSION = "0.2.11";