@moewolf/moe-icons-cli 0.0.1

package/dist/core/update-policy.js

@@ -0,0 +1,27 @@
+const VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-(alpha|beta))?$/;
+export function parseVersion(value) {
+    const match = VERSION.exec(value);
+    if (!match)
+        return undefined;
+    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]), channel: match[4] ?? "stable" };
+}
+export function decideUpdate(input) {
+    if (input.installedTier !== input.remoteTier)
+        return { kind: "refuse", reason: "tier-mismatch" };
+    const local = parseVersion(input.installedVersion);
+    const remote = parseVersion(input.remoteVersion);
+    if (!local || !remote)
+        return { kind: "refuse", reason: "invalid-version" };
+    if (local.channel !== remote.channel)
+        return { kind: "refuse", reason: "channel-mismatch" };
+    const comparison = remote.major - local.major || remote.minor - local.minor || remote.patch - local.patch;
+    if (comparison === 0)
+        return { kind: "current" };
+    return comparison > 0 ? { kind: "update" } : { kind: "refuse", reason: "downgrade" };
+}
+/** Recheck the downloaded candidate immediately before commit to prevent TOCTOU. */
+export function verifyCandidateIdentity(expected, actual) {
+    return expected.tier === actual.tier && expected.version === actual.version &&
+        expected.descriptorSha256 === actual.descriptorSha256 && expected.artifactSha256 === actual.artifactSha256 &&
+        /^[a-f0-9]{64}$/.test(actual.descriptorSha256) && /^[a-f0-9]{64}$/.test(actual.artifactSha256);
+}

package/dist/core/version-service.d.ts

@@ -0,0 +1,26 @@
+export interface PublicTierVersion {
+    readonly version: string;
+    readonly releasedAt: string;
+    readonly descriptorSha256: string;
+}
+export interface PublicLibraryVersions {
+    readonly schemaVersion: 1;
+    readonly free: PublicTierVersion | null;
+    readonly pro: PublicTierVersion | null;
+}
+export declare function fetchLibraryVersions(deps?: {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<PublicLibraryVersions>;
+export declare function fetchMoeiconsVersions(deps?: {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<readonly string[]>;
+/** Keep the interactive startup check cheap when the wizard is opened repeatedly. */
+export declare function fetchMoeiconsVersionsCached(deps?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<readonly string[]>;
+export declare function latestInChannel(current: string, versions: readonly string[]): string | undefined;

package/dist/core/version-service.js

@@ -0,0 +1,71 @@
+import { CliError } from "../errors/index.js";
+import { parseVersion } from "./update-policy.js";
+const LIBRARY_VERSIONS_URL = "https://api.moeicons.com/v1/icon-library/versions";
+const NPM_PACKAGE_URL = "https://registry.npmjs.org/@moewolf%2fmoe-icons-cli";
+const SHA256 = /^[a-f0-9]{64}$/;
+const CLI_VERSION_CACHE_TTL_MS = 5 * 60 * 1_000;
+let cliVersionCache;
+async function fixedFetch(url, fetchFn, signal, timeoutMs = 5_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const abort = () => controller.abort();
+    if (signal?.aborted)
+        controller.abort();
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+        return await fetchFn(url, { method: "GET", headers: { accept: "application/json" }, signal: controller.signal, redirect: "error" });
+    }
+    catch {
+        throw new CliError(signal?.aborted ? "CANCELLED" : "NETWORK_ERROR", signal?.aborted ? "version check cancelled" : "version check failed");
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+    }
+}
+function tier(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const item = value;
+    return typeof item.version === "string" && parseVersion(item.version) && typeof item.releasedAt === "string" &&
+        /^\d{4}-\d{2}-\d{2}T.*Z$/.test(item.releasedAt) && typeof item.descriptorSha256 === "string" && SHA256.test(item.descriptorSha256)
+        ? item : undefined;
+}
+export async function fetchLibraryVersions(deps = {}) {
+    const response = await fixedFetch(LIBRARY_VERSIONS_URL, deps.fetch ?? fetch, deps.signal, deps.timeoutMs);
+    if (!response.ok)
+        throw new CliError("NETWORK_ERROR", `version check failed with ${response.status}`);
+    const value = await response.json();
+    const free = tier(value.free);
+    const pro = tier(value.pro);
+    if (value.schemaVersion !== 1 || free === undefined || pro === undefined || Object.keys(value).some((key) => !["schemaVersion", "free", "pro"].includes(key))) {
+        throw new CliError("VALIDATION_ERROR", "invalid icon library versions response");
+    }
+    return { schemaVersion: 1, free, pro };
+}
+export async function fetchMoeiconsVersions(deps = {}) {
+    const response = await fixedFetch(NPM_PACKAGE_URL, deps.fetch ?? fetch, deps.signal, deps.timeoutMs);
+    if (!response.ok)
+        throw new CliError("NETWORK_ERROR", `CLI version check failed with ${response.status}`);
+    const value = await response.json();
+    if (typeof value.versions !== "object" || value.versions === null || Array.isArray(value.versions))
+        throw new CliError("VALIDATION_ERROR", "invalid npm package metadata");
+    return Object.keys(value.versions).filter((version) => parseVersion(version));
+}
+/** Keep the interactive startup check cheap when the wizard is opened repeatedly. */
+export async function fetchMoeiconsVersionsCached(deps = {}) {
+    if (cliVersionCache && cliVersionCache.expiresAt > Date.now())
+        return cliVersionCache.versions;
+    const versions = await fetchMoeiconsVersions(deps);
+    cliVersionCache = { versions, expiresAt: Date.now() + CLI_VERSION_CACHE_TTL_MS };
+    return versions;
+}
+export function latestInChannel(current, versions) {
+    const parsed = parseVersion(current);
+    if (!parsed)
+        return undefined;
+    return versions.map((version) => ({ version, parsed: parseVersion(version) })).filter((item) => item.parsed?.channel === parsed.channel)
+        .sort((a, b) => (b.parsed.major - a.parsed.major) || (b.parsed.minor - a.parsed.minor) || (b.parsed.patch - a.parsed.patch))[0]?.version;
+}

package/dist/core/wizard.d.ts

@@ -0,0 +1,49 @@
+import type { CommandContext } from "./context.js";
+export type WizardResult = {
+    readonly ok: true;
+    readonly action: "json-hint";
+    readonly message: string;
+} | {
+    readonly ok: true;
+    readonly action: "install";
+    readonly group: "free" | "pro";
+    readonly target: "react" | "vue" | "vanilla" | "assets";
+} | {
+    readonly ok: true;
+    readonly action: "pending";
+    readonly flow: "login";
+} | {
+    readonly ok: true;
+    readonly action: "manage";
+    readonly flow: "reload" | "library-update";
+} | {
+    readonly ok: true;
+    readonly action: "settings";
+    readonly flow: "logout" | "cli-update";
+} | {
+    readonly ok: false;
+    readonly reason: "cancelled";
+};
+export type WizardSessionState = "authenticated" | "signed-out" | "unknown";
+export declare function homeChoices(session: WizardSessionState): readonly [{
+    readonly value: "pro";
+    readonly label: "Install moeicons pro";
+}, {
+    readonly value: "free";
+    readonly label: "Install moeicons free";
+}, {
+    readonly value: "manage";
+    readonly label: "Manage project icons";
+}, ...{
+    value: string;
+    label: string;
+}[], {
+    readonly value: "settings";
+    readonly label: "Settings";
+}];
+/** Wizard state machine. No Clack/Commander/process imports. */
+export declare function runWizardUseCase(context: CommandContext, options: {
+    readonly json: boolean;
+    readonly session?: WizardSessionState;
+    readonly getLibraryStatus?: () => Promise<string>;
+}): Promise<WizardResult>;

package/dist/core/wizard.js

@@ -0,0 +1,71 @@
+import { detectProject } from "../project/detect.js";
+import { CliError } from "../errors/index.js";
+const JSON_HINT = "interactive wizard unavailable in JSON mode; use install/login/account/groups/generate";
+export function homeChoices(session) {
+    return [
+        { value: "pro", label: "Install moeicons pro" },
+        { value: "free", label: "Install moeicons free" },
+        { value: "manage", label: "Manage project icons" },
+        ...(session === "authenticated"
+            ? []
+            : [
+                {
+                    value: "login",
+                    label: session === "unknown" ? "Login (current status unknown)" : "Login",
+                },
+            ]),
+        { value: "settings", label: "Settings" },
+    ];
+}
+/** Wizard state machine. No Clack/Commander/process imports. */
+export async function runWizardUseCase(context, options) {
+    if (options.json) {
+        return { ok: true, action: "json-hint", message: JSON_HINT };
+    }
+    const choice = await context.ui.select("Choose an option", homeChoices(options.session ?? "signed-out"), context.signal);
+    if (choice === undefined)
+        return { ok: false, reason: "cancelled" };
+    if (choice === "login")
+        return { ok: true, action: "pending", flow: "login" };
+    if (choice === "settings") {
+        const setting = await context.ui.select("Settings", [
+            ...(options.session === "authenticated" ? [{ value: "logout", label: "Log out" }] : []),
+            { value: "cli-update", label: "Check for CLI updates" },
+        ], context.signal);
+        return setting === undefined
+            ? { ok: false, reason: "cancelled" }
+            : { ok: true, action: "settings", flow: setting };
+    }
+    const project = detectProject(context.cwd);
+    if (!project)
+        throw new CliError("VALIDATION_ERROR", "no package.json found in the current directory or parents; run inside a project");
+    if (choice === "manage") {
+        const status = await options.getLibraryStatus?.();
+        const management = await context.ui.select("Manage project icons", [
+            { value: "reload", label: "Update project resources" },
+            {
+                value: "library-update",
+                label: `Update icon library version${status ? ` — ${status}` : ""}`,
+            },
+        ], context.signal);
+        return management === undefined
+            ? { ok: false, reason: "cancelled" }
+            : { ok: true, action: "manage", flow: management };
+    }
+    if (choice === "free" || choice === "pro") {
+        const target = await context.ui.select("Choose an output target", [
+            { value: "react", label: "React" },
+            { value: "vue", label: "Vue" },
+            { value: "vanilla", label: "Vanilla" },
+            { value: "assets", label: "Static assets" },
+        ], context.signal);
+        if (target !== "react" && target !== "vue" && target !== "vanilla" && target !== "assets") {
+            return { ok: false, reason: "cancelled" };
+        }
+        const confirmed = await context.ui.confirm(`Install ${choice} ${target} into ${project.root}?`, context.signal);
+        if (confirmed !== true)
+            return { ok: false, reason: "cancelled" };
+        return { ok: true, action: "install", group: choice, target };
+    }
+    throw new CliError("VALIDATION_ERROR", `unknown wizard choice: ${choice}`);
+}

package/dist/errors/errors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Stable error codes and exit-code mapping. CLI processes use exit codes:
+ * 0 success/cancel, 1 validation error, 2 auth error, 3 network error,
+ * 4 not found, 5 unexpected.
+ */
+export type CliErrorCode = "HELP" | "VERSION" | "CANCELLED" | "VALIDATION_ERROR" | "TAILWIND_VERSION_UNSUPPORTED" | "AUTH_ERROR" | "NETWORK_ERROR" | "NOT_FOUND" | "FORBIDDEN" | "NOT_TTY" | "NOT_IMPLEMENTED" | "UNEXPECTED";
+/** Frozen CliErrorCode → process exit code. Register new codes here before use. */
+export declare const CLI_ERROR_EXIT_MAP: {
+    readonly HELP: 0;
+    readonly VERSION: 0;
+    readonly CANCELLED: 0;
+    readonly VALIDATION_ERROR: 1;
+    readonly TAILWIND_VERSION_UNSUPPORTED: 1;
+    readonly NOT_TTY: 1;
+    readonly NOT_IMPLEMENTED: 1;
+    readonly AUTH_ERROR: 2;
+    readonly FORBIDDEN: 2;
+    readonly NETWORK_ERROR: 3;
+    readonly NOT_FOUND: 4;
+    readonly UNEXPECTED: 5;
+};
+export type JsonErrorBody = {
+    readonly ok: false;
+    readonly code: CliErrorCode;
+    readonly message: string;
+};
+export declare class CliError extends Error {
+    readonly code: CliErrorCode;
+    readonly exitCode: number;
+    constructor(code: CliErrorCode, message: string);
+}
+export declare function exitCodeFor(code: CliErrorCode): number;
+export declare function jsonErrorBody(code: CliErrorCode, message: string): JsonErrorBody;
+export declare function isCliError(error: unknown): error is CliError;

package/dist/errors/errors.js

@@ -0,0 +1,39 @@
+/**
+ * Stable error codes and exit-code mapping. CLI processes use exit codes:
+ * 0 success/cancel, 1 validation error, 2 auth error, 3 network error,
+ * 4 not found, 5 unexpected.
+ */
+/** Frozen CliErrorCode → process exit code. Register new codes here before use. */
+export const CLI_ERROR_EXIT_MAP = {
+    HELP: 0,
+    VERSION: 0,
+    CANCELLED: 0,
+    VALIDATION_ERROR: 1,
+    TAILWIND_VERSION_UNSUPPORTED: 1,
+    NOT_TTY: 1,
+    NOT_IMPLEMENTED: 1,
+    AUTH_ERROR: 2,
+    FORBIDDEN: 2,
+    NETWORK_ERROR: 3,
+    NOT_FOUND: 4,
+    UNEXPECTED: 5,
+};
+export class CliError extends Error {
+    code;
+    exitCode;
+    constructor(code, message) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.exitCode = exitCodeFor(code);
+    }
+}
+export function exitCodeFor(code) {
+    return CLI_ERROR_EXIT_MAP[code];
+}
+export function jsonErrorBody(code, message) {
+    return { ok: false, code, message };
+}
+export function isCliError(error) {
+    return error instanceof CliError;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./errors.js";

package/dist/errors/index.js

@@ -0,0 +1 @@
+export * from "./errors.js";

package/dist/generator/cn.d.ts

@@ -0,0 +1,5 @@
+/** Generated helper text for user projects (H1/H2). Versions locked by CLI constants. */
+export declare const CLSX_VERSION_RANGE = "^2.1.1";
+export declare const TAILWIND_MERGE_VERSION_RANGE = "^2.5.2";
+export declare const CN_HELPER_SOURCE = "// Generated by moeicons CLI. Do not edit manually; re-run `moeicons generate`.\nimport { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\nexport function cn(...inputs: ClassValue[]): string {\n  return twMerge(clsx(inputs));\n}\n";
+export declare function sizeToTailwindClass(sizePx: number): string;

package/dist/generator/cn.js

@@ -0,0 +1,14 @@
+/** Generated helper text for user projects (H1/H2). Versions locked by CLI constants. */
+export const CLSX_VERSION_RANGE = "^2.1.1";
+export const TAILWIND_MERGE_VERSION_RANGE = "^2.5.2";
+export const CN_HELPER_SOURCE = `// Generated by moeicons CLI. Do not edit manually; re-run \`moeicons generate\`.
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}
+`;
+export function sizeToTailwindClass(sizePx) {
+    return `w-[${sizePx}px] h-[${sizePx}px]`;
+}

package/dist/generator/generate.d.ts

@@ -0,0 +1,34 @@
+import { type IconCatalog } from "../catalog/catalog.js";
+import type { MoeiconsConfigFile } from "../project/config.js";
+import { toLibraryExportName, toProxyName } from "../core/icon-names.js";
+export { toLibraryExportName, toProxyName };
+/** @deprecated Use toProxyName; kept so existing generator tests keep compiling. */
+export declare const toPascalCase: typeof toProxyName;
+/**
+ * React/Vue proxy generation. Purely returns owned file paths/content for
+ * types, registry, provider/plugin, proxies and barrel exports. Rejects
+ * duplicate PascalCase names and missing fallback. Bitmap themes use local
+ * img wrappers + static asset imports (G1/G4); SVG themes import moe-icons.
+ */
+export interface GeneratedFile {
+    readonly path: string;
+    readonly content: string | Uint8Array;
+}
+export interface GenerationResult {
+    readonly ok: true;
+    readonly files: GeneratedFile[];
+}
+export interface GenerationError {
+    readonly ok: false;
+    readonly errors: string[];
+}
+export type GenerationOutcome = GenerationResult | GenerationError;
+/**
+ * Plan generated files for a config. Returns only owned paths under the config
+ * output dir. Rejects duplicate PascalCase names and a config with no themes.
+ * Theme keys stay logical style themes; bitmap resourceVariantId never becomes a theme.
+ */
+export declare function planGeneratedFiles(config: MoeiconsConfigFile, outputDir: string, options?: {
+    readonly archiveFiles?: Readonly<Record<string, Uint8Array>>;
+    readonly catalog?: IconCatalog;
+}): GenerationOutcome;