@moewolf/moe-icons-cli 0.0.1

package/dist/auth/token-store.js

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+function parseSession(value) {
+    try {
+        const session = JSON.parse(value);
+        return typeof session.accountId === "string" && typeof session.accessToken === "string" &&
+            typeof session.refreshToken === "string" && typeof session.expiresAt === "number" &&
+            typeof session.scope === "string" && typeof session.storedAt === "number"
+            ? session : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * File-backed fallback store (mode 0600). Used only when no OS keychain is
+ * available and the owner approves the fallback. Never logs token values.
+ */
+export function createFileTokenStore(options = {}) {
+    const root = options.rootDir ?? join(homedir(), ".moeicons");
+    const file = join(root, "token-store.json");
+    function readAll() {
+        if (!existsSync(file))
+            return {};
+        try {
+            const raw = JSON.parse(readFileSync(file, "utf8"));
+            if (typeof raw === "object" && raw !== null)
+                return raw;
+        }
+        catch {
+            // corrupt store; treat as empty
+        }
+        return {};
+    }
+    function writeAll(data) {
+        mkdirSync(root, { recursive: true });
+        writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+        chmodSync(file, 0o600);
+    }
+    return {
+        get(accountId) {
+            return readAll()[accountId];
+        },
+        getActive() {
+            return Object.values(readAll()).sort((a, b) => b.storedAt - a.storedAt)[0];
+        },
+        set(session) {
+            const all = readAll();
+            all[session.accountId] = session;
+            writeAll(all);
+        },
+        delete(accountId) {
+            const all = readAll();
+            delete all[accountId];
+            writeAll(all);
+        },
+        clear() { writeAll({}); },
+    };
+}
+/** Use the native credential store when the platform provides a supported CLI. */
+export function createSystemTokenStore(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const run = options.execFile ?? execFileSync;
+    const service = "moeicons";
+    const account = "active-session";
+    const invoke = (command, args, input) => String(run(command, args, { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], ...(input ? { input } : {}) })).trim();
+    let read;
+    let write;
+    let remove;
+    if (platform === "darwin") {
+        read = () => invoke("security", ["find-generic-password", "-s", service, "-a", account, "-w"]);
+        write = (value) => { invoke("security", ["add-generic-password", "-U", "-s", service, "-a", account, "-w", value]); };
+        remove = () => { invoke("security", ["delete-generic-password", "-s", service, "-a", account]); };
+    }
+    else if (platform === "linux") {
+        try {
+            invoke("secret-tool", ["--help"]);
+        }
+        catch {
+            return undefined;
+        }
+        read = () => invoke("secret-tool", ["lookup", "service", service, "account", account]);
+        write = (value) => { invoke("secret-tool", ["store", "--label=Moeicons CLI", "service", service, "account", account], value); };
+        remove = () => { invoke("secret-tool", ["clear", "service", service, "account", account]); };
+    }
+    else if (platform === "win32") {
+        const prefix = "[void][Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime];$v=[Windows.Security.Credentials.PasswordVault]::new();";
+        read = () => invoke("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `${prefix}$c=$v.Retrieve('${service}','${account}');$c.RetrievePassword();[Console]::Out.Write($c.Password)`]);
+        write = (value) => { invoke("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `${prefix}$p=[Console]::In.ReadToEnd();try{$v.Remove($v.Retrieve('${service}','${account}'))}catch{};$v.Add([Windows.Security.Credentials.PasswordCredential]::new('${service}','${account}',$p))`], value); };
+        remove = () => { invoke("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `${prefix}try{$v.Remove($v.Retrieve('${service}','${account}'))}catch{}`]); };
+    }
+    else {
+        return undefined;
+    }
+    const active = () => { try {
+        return parseSession(read());
+    }
+    catch {
+        return undefined;
+    } };
+    return {
+        get: (accountId) => { const value = active(); return value?.accountId === accountId ? value : undefined; },
+        getActive: active,
+        set: (session) => { write(JSON.stringify(session)); },
+        delete: (accountId) => { if (active()?.accountId === accountId) {
+            try {
+                remove();
+            }
+            catch { /* already absent */ }
+        } },
+        clear: () => { try {
+            remove();
+        }
+        catch { /* already absent */ } },
+    };
+}
+/** Redact a session for logging: never expose tokens. */
+export function redactSession(session) {
+    return {
+        accountId: session.accountId,
+        scope: session.scope,
+        expiresAt: session.expiresAt,
+    };
+}

package/dist/catalog/catalog.d.ts

@@ -0,0 +1,32 @@
+export type CatalogStyleGroupType = "outline" | "solid" | "mixed" | "bitmap";
+export type CatalogTier = "free" | "pro";
+export type CatalogFormat = "svg" | "webp" | "png";
+export interface CatalogStyleGroup {
+    readonly id: string;
+    readonly type: CatalogStyleGroupType;
+    readonly tiers: readonly CatalogTier[];
+    readonly formats: readonly CatalogFormat[];
+    readonly imageSizes: readonly number[];
+}
+export interface CatalogIcon {
+    readonly id: string;
+    readonly prefix: string;
+    readonly label: string;
+    readonly aliases: readonly string[];
+    readonly deprecatedAt?: string;
+    readonly replacedBy?: string;
+    readonly availableIn: readonly string[];
+}
+export interface IconCatalog {
+    readonly schemaVersion: 1;
+    readonly catalogVersion: string;
+    readonly sourceVersion: string;
+    readonly sourceCommit: string;
+    readonly generatorCommit: string;
+    readonly styleGroups: readonly CatalogStyleGroup[];
+    readonly icons: readonly CatalogIcon[];
+}
+export declare function parseCatalog(value: unknown): IconCatalog;
+export declare const catalog: IconCatalog;
+export declare function findCatalogStyleGroup(id: string, source?: IconCatalog): CatalogStyleGroup | undefined;
+export declare function findCatalogIcon(id: string, source?: IconCatalog): CatalogIcon | undefined;

package/dist/catalog/catalog.js

@@ -0,0 +1,80 @@
+import bundledCatalog from "./catalog.json" with { type: "json" };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+export function parseCatalog(value) {
+    if (!isRecord(value) || value.schemaVersion !== 1) {
+        throw new Error("unsupported catalog schema; reinstall a compatible moeicons package");
+    }
+    for (const field of ["catalogVersion", "sourceVersion", "sourceCommit", "generatorCommit"]) {
+        if (typeof value[field] !== "string" || value[field].length === 0) {
+            throw new Error(`catalog field ${field} must be a non-empty string`);
+        }
+    }
+    const catalogVersion = value.catalogVersion;
+    const sourceVersion = value.sourceVersion;
+    const sourceCommit = value.sourceCommit;
+    const generatorCommit = value.generatorCommit;
+    if (!Array.isArray(value.styleGroups) || !Array.isArray(value.icons)) {
+        throw new Error("catalog styleGroups and icons must be arrays");
+    }
+    const groups = value.styleGroups.map((group) => {
+        if (!isRecord(group) || typeof group.id !== "string" || typeof group.type !== "string") {
+            throw new Error("catalog style group is invalid");
+        }
+        if (!isStringArray(group.tiers) || !group.tiers.every((tier) => tier === "free" || tier === "pro")) {
+            throw new Error(`catalog style group ${group.id} has invalid tiers`);
+        }
+        if (!isStringArray(group.formats) || !group.formats.every((format) => ["svg", "webp", "png"].includes(format))) {
+            throw new Error(`catalog style group ${group.id} has invalid formats`);
+        }
+        if (!Array.isArray(group.imageSizes) || !group.imageSizes.every((size) => typeof size === "number")) {
+            throw new Error(`catalog style group ${group.id} has invalid imageSizes`);
+        }
+        if (!["outline", "solid", "mixed", "bitmap"].includes(group.type)) {
+            throw new Error(`catalog style group ${group.id} has invalid type`);
+        }
+        return {
+            id: group.id,
+            type: group.type,
+            tiers: group.tiers,
+            formats: group.formats,
+            imageSizes: group.imageSizes,
+        };
+    });
+    const groupIds = new Set(groups.map((group) => group.id));
+    const icons = value.icons.map((icon) => {
+        if (!isRecord(icon) || typeof icon.id !== "string" || typeof icon.prefix !== "string" || typeof icon.label !== "string") {
+            throw new Error("catalog icon is invalid");
+        }
+        if (!isStringArray(icon.aliases) || !isStringArray(icon.availableIn) || !icon.availableIn.every((id) => groupIds.has(id))) {
+            throw new Error(`catalog icon ${icon.id} has invalid availability`);
+        }
+        return {
+            id: icon.id,
+            prefix: icon.prefix,
+            label: icon.label,
+            aliases: icon.aliases,
+            ...(typeof icon.deprecatedAt === "string" ? { deprecatedAt: icon.deprecatedAt } : {}),
+            ...(typeof icon.replacedBy === "string" ? { replacedBy: icon.replacedBy } : {}),
+            availableIn: icon.availableIn,
+        };
+    });
+    return {
+        schemaVersion: 1,
+        catalogVersion,
+        sourceVersion,
+        sourceCommit,
+        generatorCommit,
+        styleGroups: groups,
+        icons,
+    };
+}
+export const catalog = parseCatalog(bundledCatalog);
+export function findCatalogStyleGroup(id, source = catalog) {
+    return source.styleGroups.find((group) => group.id === id);
+}
+export function findCatalogIcon(id, source = catalog) {
+    return source.icons.find((icon) => icon.id === id);
+}