@moewolf/moe-icons-cli 0.0.1 → 0.0.3

package/dist/auth/device-login.js

@@ -1,72 +1,95 @@
-import { createLoginState, createPkcePair } from './pkce.js';
-import { CliError } from '../errors/index.js';
+import { createLoginState, createPkcePair } from "./pkce.js";
+import { parseCreateLoginResponse, parseExchangeLoginResponse, parsePollLoginResponse, } from "./login-schemas.js";
+import { CliError } from "../errors/index.js";
 function assertBrowserUrl(value, expectedOrigin) {
     const url = new URL(value);
-    if (url.origin !== new URL(expectedOrigin).origin || url.pathname !== '/cli-login') {
-        throw new CliError('AUTH_ERROR', 'backend returned an untrusted login URL');
+    if (url.origin !== new URL(expectedOrigin).origin || url.pathname !== "/cli-login") {
+        throw new CliError("AUTH_ERROR", "backend returned an untrusted login URL");
     }
 }
 export async function loginWithDeviceSession(config, deps, signal) {
     const pkce = createPkcePair();
     const state = createLoginState();
-    const created = await deps.request('/v1/cli-login-sessions', {
-        method: 'POST', body: { codeChallenge: pkce.challenge, clientNonce: state.nonce, state: state.state }, ...(signal ? { signal } : {}),
+    const createdRaw = await deps.request("/v1/cli-login-sessions", {
+        method: "POST",
+        body: { codeChallenge: pkce.challenge, clientNonce: state.nonce, state: state.state },
+        stage: "create",
+        ...(signal ? { signal } : {}),
     });
-    assertBrowserUrl(created.data.browserUrl, config.websiteOrigin);
-    if (!Number.isSafeInteger(created.data.intervalSeconds) || created.data.intervalSeconds < 1 || created.data.intervalSeconds > 60) {
-        throw new CliError('AUTH_ERROR', 'backend returned an invalid polling interval');
-    }
-    await deps.openBrowser(created.data.browserUrl);
-    const auth = `Bearer ${created.data.pollingToken}`;
-    const sessionPath = `/v1/cli-login-sessions/${encodeURIComponent(created.data.loginId)}`;
+    const created = parseCreateLoginResponse(createdRaw.data);
+    assertBrowserUrl(created.browserUrl, config.websiteOrigin);
+    await deps.openBrowser(created.browserUrl);
+    const auth = `Bearer ${created.pollingToken}`;
+    const sessionPath = `/v1/cli-login-sessions/${encodeURIComponent(created.loginId)}`;
     try {
-        while (deps.now() < Date.parse(created.data.expiresAt)) {
+        while (deps.now() < Date.parse(created.expiresAt)) {
             if (signal?.aborted)
-                throw new CliError('CANCELLED', 'login cancelled');
-            const polled = await deps.request(sessionPath, { method: 'GET', auth, ...(signal ? { signal } : {}) });
-            if (polled.status === 200 && polled.data.status === 'complete' && polled.data.exchangeCode) {
-                const exchanged = await deps.request(`${sessionPath}/exchange`, {
-                    method: 'POST', auth,
-                    body: { exchangeCode: polled.data.exchangeCode, clientNonce: state.nonce, codeVerifier: pkce.verifier },
+                throw new CliError("CANCELLED", "login cancelled");
+            const polledRaw = await deps.request(sessionPath, {
+                method: "GET",
+                auth,
+                stage: "poll",
+                ...(signal ? { signal } : {}),
+            });
+            const polled = parsePollLoginResponse(polledRaw.data);
+            if (polledRaw.status === 200 && polled.status === "complete" && polled.exchangeCode) {
+                const exchangedRaw = await deps.request(`${sessionPath}/exchange`, {
+                    method: "POST",
+                    auth,
+                    stage: "exchange",
+                    body: {
+                        exchangeCode: polled.exchangeCode,
+                        clientNonce: state.nonce,
+                        codeVerifier: pkce.verifier,
+                    },
                     ...(signal ? { signal } : {}),
                 });
+                const exchanged = parseExchangeLoginResponse(exchangedRaw.data);
                 const stored = {
-                    accountId: exchanged.data.accountId,
-                    accessToken: exchanged.data.accessToken,
-                    refreshToken: exchanged.data.refreshToken,
-                    expiresAt: deps.now() + exchanged.data.expiresIn * 1000,
-                    scope: 'openid profile email offline_access',
+                    accountId: exchanged.accountId,
+                    accessToken: exchanged.accessToken,
+                    refreshToken: exchanged.refreshToken,
+                    expiresAt: deps.now() + exchanged.expiresIn * 1000,
+                    scope: "openid profile email offline_access",
                     storedAt: deps.now(),
                 };
                 deps.tokenStore.set(stored);
                 return stored;
             }
-            await deps.sleep(created.data.intervalSeconds * 1000, signal);
+            await deps.sleep(created.intervalSeconds * 1000, signal);
         }
-        throw new CliError('AUTH_ERROR', 'login session expired');
+        throw new CliError("AUTH_ERROR", "login session expired");
     }
     catch (error) {
         try {
-            await deps.request(sessionPath, { method: 'DELETE', auth });
+            await deps.request(sessionPath, { method: "DELETE", auth, stage: "cleanup" });
+        }
+        catch {
+            /* best effort */
         }
-        catch { /* best effort */ }
         throw error;
     }
 }
 export async function refreshAuth0Session(config, session, deps) {
-    const response = await deps.fetch(`${config.auth0Issuer.replace(/\/$/, '')}/oauth/token`, {
-        method: 'POST', headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ grant_type: 'refresh_token', client_id: config.auth0ClientId, refresh_token: session.refreshToken }),
+    const response = await deps.fetch(`${config.auth0Issuer.replace(/\/$/, "")}/oauth/token`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            grant_type: "refresh_token",
+            client_id: config.auth0ClientId,
+            refresh_token: session.refreshToken,
+        }),
         ...(deps.signal ? { signal: deps.signal } : {}),
     });
-    const body = await response.json();
-    if (!response.ok || typeof body.access_token !== 'string')
-        throw new CliError('AUTH_ERROR', 'Auth0 refresh failed');
+    const body = (await response.json());
+    if (!response.ok || typeof body.access_token !== "string") {
+        throw new CliError("AUTH_ERROR", "Auth0 refresh failed");
+    }
     const updated = {
         ...session,
         accessToken: body.access_token,
-        refreshToken: typeof body.refresh_token === 'string' ? body.refresh_token : session.refreshToken,
-        expiresAt: deps.now() + (typeof body.expires_in === 'number' ? body.expires_in : 3600) * 1000,
+        refreshToken: typeof body.refresh_token === "string" ? body.refresh_token : session.refreshToken,
+        expiresAt: deps.now() + (typeof body.expires_in === "number" ? body.expires_in : 3600) * 1000,
         storedAt: deps.now(),
     };
     deps.tokenStore.set(updated);

package/dist/auth/login-schemas.d.ts

@@ -0,0 +1,24 @@
+export interface CreateLoginResponse {
+    readonly loginId: string;
+    readonly pollingToken: string;
+    readonly browserUrl: string;
+    readonly intervalSeconds: number;
+    readonly expiresAt: string;
+}
+export interface PollLoginResponse {
+    readonly status: "pending" | "complete";
+    readonly exchangeCode?: string;
+}
+export interface ExchangeLoginResponse {
+    readonly accountId: string;
+    readonly accessToken: string;
+    readonly refreshToken: string;
+    readonly expiresIn: number;
+    readonly tokenType: "Bearer";
+}
+/** Validate create-session JSON before opening a browser or storing anything. */
+export declare function parseCreateLoginResponse(data: unknown): CreateLoginResponse;
+/** Validate poll JSON; complete requires a non-empty exchangeCode. */
+export declare function parsePollLoginResponse(data: unknown): PollLoginResponse;
+/** Validate exchange JSON before writing the token store. */
+export declare function parseExchangeLoginResponse(data: unknown): ExchangeLoginResponse;

package/dist/auth/login-schemas.js

@@ -0,0 +1,67 @@
+import { CliError } from "../errors/index.js";
+function asRecord(data, stage) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        throw new CliError("VALIDATION_ERROR", `${stage}: response schema is not an object`);
+    }
+    return data;
+}
+function requireNonEmptyString(record, field, stage) {
+    const value = record[field];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new CliError("VALIDATION_ERROR", `${stage}: missing or invalid ${field}`);
+    }
+    return value;
+}
+/** Validate create-session JSON before opening a browser or storing anything. */
+export function parseCreateLoginResponse(data) {
+    const stage = "login create";
+    const record = asRecord(data, stage);
+    const loginId = requireNonEmptyString(record, "loginId", stage);
+    const pollingToken = requireNonEmptyString(record, "pollingToken", stage);
+    const browserUrl = requireNonEmptyString(record, "browserUrl", stage);
+    const expiresAt = requireNonEmptyString(record, "expiresAt", stage);
+    if (Number.isNaN(Date.parse(expiresAt))) {
+        throw new CliError("VALIDATION_ERROR", `${stage}: expiresAt is not a valid date`);
+    }
+    const intervalSeconds = record.intervalSeconds;
+    if (typeof intervalSeconds !== "number" ||
+        !Number.isSafeInteger(intervalSeconds) ||
+        intervalSeconds < 1 ||
+        intervalSeconds > 60) {
+        throw new CliError("VALIDATION_ERROR", `${stage}: invalid polling interval`);
+    }
+    return { loginId, pollingToken, browserUrl, intervalSeconds, expiresAt };
+}
+/** Validate poll JSON; complete requires a non-empty exchangeCode. */
+export function parsePollLoginResponse(data) {
+    const stage = "login poll";
+    const record = asRecord(data, stage);
+    const status = record.status;
+    if (status !== "pending" && status !== "complete") {
+        throw new CliError("VALIDATION_ERROR", `${stage}: unknown status`);
+    }
+    if (status === "pending") {
+        return { status: "pending" };
+    }
+    const exchangeCode = requireNonEmptyString(record, "exchangeCode", stage);
+    return { status: "complete", exchangeCode };
+}
+/** Validate exchange JSON before writing the token store. */
+export function parseExchangeLoginResponse(data) {
+    const stage = "login exchange";
+    const record = asRecord(data, stage);
+    const accountId = requireNonEmptyString(record, "accountId", stage);
+    const accessToken = requireNonEmptyString(record, "accessToken", stage);
+    const refreshToken = requireNonEmptyString(record, "refreshToken", stage);
+    const expiresIn = record.expiresIn;
+    if (typeof expiresIn !== "number" ||
+        !Number.isSafeInteger(expiresIn) ||
+        expiresIn <= 0 ||
+        Number.isNaN(expiresIn)) {
+        throw new CliError("VALIDATION_ERROR", `${stage}: invalid expiresIn`);
+    }
+    if (record.tokenType !== "Bearer") {
+        throw new CliError("VALIDATION_ERROR", `${stage}: unsupported tokenType`);
+    }
+    return { accountId, accessToken, refreshToken, expiresIn, tokenType: "Bearer" };
+}

package/dist/catalog/catalog.d.ts

@@ -7,11 +7,22 @@ export interface CatalogStyleGroup {
     readonly tiers: readonly CatalogTier[];
     readonly formats: readonly CatalogFormat[];
     readonly imageSizes: readonly number[];
+    /**
+     * MEDIA-FORMAT-V2: canonical bitmap resourceVariantIds declared by the
+     * catalog. This is the exact availability authority; a format/size pair that
+     * is not in this list must fail even when it is inside `formats`/`imageSizes`.
+     */
+    readonly variants?: readonly string[];
 }
 export interface CatalogIcon {
     readonly id: string;
+    readonly name?: string;
     readonly prefix: string;
     readonly label: string;
+    readonly keywords?: readonly string[];
+    readonly categories?: readonly string[];
+    readonly variants?: readonly string[];
+    readonly targets?: readonly string[];
     readonly aliases: readonly string[];
     readonly deprecatedAt?: string;
     readonly replacedBy?: string;

package/dist/catalog/catalog.js

@@ -1,4 +1,5 @@
 import bundledCatalog from "./catalog.json" with { type: "json" };
+import { parseResourceVariantId } from "../core/resource-variant.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
@@ -35,12 +36,38 @@ export function parseCatalog(value) {
         if (!["outline", "solid", "mixed", "bitmap"].includes(group.type)) {
             throw new Error(`catalog style group ${group.id} has invalid type`);
         }
+        if (group.variants !== undefined && !isStringArray(group.variants)) {
+            throw new Error(`catalog style group ${group.id} has invalid variants`);
+        }
+        const groupVariants = group.variants;
+        if (groupVariants && (groupVariants.length === 0 || new Set(groupVariants).size !== groupVariants.length)) {
+            throw new Error(`catalog style group ${group.id} has empty or duplicate variants`);
+        }
+        if (group.type !== "bitmap" && groupVariants !== undefined) {
+            throw new Error(`catalog SVG style group ${group.id} must not declare bitmap variants`);
+        }
+        if (group.type === "bitmap" && groupVariants) {
+            for (const variantId of groupVariants) {
+                let variant;
+                try {
+                    variant = parseResourceVariantId(variantId);
+                }
+                catch {
+                    throw new Error(`catalog style group ${group.id} has inconsistent variant ${variantId}`);
+                }
+                if (variant.styleGroupId !== group.id || !group.formats.includes(variant.format)
+                    || !group.imageSizes.includes(variant.imageSize)) {
+                    throw new Error(`catalog style group ${group.id} has inconsistent variant ${variantId}`);
+                }
+            }
+        }
         return {
             id: group.id,
             type: group.type,
             tiers: group.tiers,
             formats: group.formats,
             imageSizes: group.imageSizes,
+            ...(groupVariants ? { variants: groupVariants } : {}),
         };
     });
     const groupIds = new Set(groups.map((group) => group.id));
@@ -51,10 +78,26 @@ export function parseCatalog(value) {
         if (!isStringArray(icon.aliases) || !isStringArray(icon.availableIn) || !icon.availableIn.every((id) => groupIds.has(id))) {
             throw new Error(`catalog icon ${icon.id} has invalid availability`);
         }
+        const stringArray = (field, name) => {
+            if (field === undefined)
+                return undefined;
+            if (!isStringArray(field))
+                throw new Error(`catalog icon ${String(icon.id)} has invalid ${name}`);
+            return field;
+        };
+        const keywords = stringArray(icon.keywords, "keywords");
+        const categories = stringArray(icon.categories, "categories");
+        const variants = stringArray(icon.variants, "variants");
+        const targets = stringArray(icon.targets, "targets");
         return {
             id: icon.id,
+            ...(typeof icon.name === "string" ? { name: icon.name } : {}),
             prefix: icon.prefix,
             label: icon.label,
+            ...(keywords ? { keywords } : {}),
+            ...(categories ? { categories } : {}),
+            ...(variants ? { variants } : {}),
+            ...(targets ? { targets } : {}),
             aliases: icon.aliases,
             ...(typeof icon.deprecatedAt === "string" ? { deprecatedAt: icon.deprecatedAt } : {}),
             ...(typeof icon.replacedBy === "string" ? { replacedBy: icon.replacedBy } : {}),