@pmate/cli 0.21.19 → 0.22.0

package/dist/index.d.ts

@@ -738,6 +738,7 @@ type AppCommandArgs = {
     type: Command.App;
     action: "icon";
     id: string;
+    subAction?: "export";
     preset?: "android" | "ios";
     width?: number;
     height?: number;
@@ -746,6 +747,19 @@ type AppCommandArgs = {
     outDir?: string;
     baseUrl?: string;
     json: boolean;
+} | {
+    type: Command.App;
+    action: "icon-add";
+    id: string;
+    name: string;
+    filePath?: string;
+    width?: number;
+    height?: number;
+    format?: "png" | "webp" | "svg" | "ico";
+    output?: string;
+    force: boolean;
+    baseUrl?: string;
+    json: boolean;
 };
 type ServiceCommandArgs = {
     type: Command.Service;

package/dist/index.js

@@ -17252,6 +17252,8 @@ var IOS_ICON_SPECS = [
   { width: 1024, height: 1024, name: "app-store" }
 ];
 var pngToIco = require("png-to-ico").default;
+var APP_ICON_VARIANT_KEY_PATTERN = /^[a-z0-9]+$/;
+var DATA_URL_PATTERN = /^data:([^;,]+);base64,([a-z0-9+/=]+)$/i;
 function normalizeAppIcon(icon, cwd) {
   if (typeof icon !== "string" || !icon.trim()) {
     throw new Error("App icon must be a non-empty http(s) URL.");
@@ -17276,8 +17278,46 @@ function prepareAppPayload(payload, cwd) {
   if (normalized.icon !== void 0) {
     normalized.icon = normalizeAppIcon(normalized.icon, cwd);
   }
+  if (normalized.icons !== void 0) {
+    normalized.icons = normalizeAppIconVariants(normalized.icons);
+  }
   return normalized;
 }
+function normalizeAppIconVariants(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("App icons must be an object map of variant names to asset references.");
+  }
+  const entries = Object.entries(input);
+  const normalized = Object.fromEntries(
+    entries.map(([key, value]) => [validateAppIconVariantKey(key), normalizeAppIconVariantValue(value)])
+  );
+  return normalized;
+}
+function validateAppIconVariantKey(key) {
+  const trimmed = key.trim();
+  if (!trimmed) {
+    throw new Error("App icon variant name is required.");
+  }
+  if (!APP_ICON_VARIANT_KEY_PATTERN.test(trimmed)) {
+    throw new Error(
+      `Invalid app icon variant name "${key}". Use lowercase letters and digits only, for example webp512x512.`
+    );
+  }
+  return trimmed;
+}
+function normalizeAppIconVariantValue(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("App icon variant value must be a non-empty URL or image data URL.");
+  }
+  const trimmed = value.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+  if (isSupportedImageDataUrl(trimmed)) {
+    return trimmed;
+  }
+  throw new Error("App icon variant value must be an http(s) URL or a supported image data URL.");
+}
 function createAppIconExportPlans(input) {
   const { namespace, objectId } = parseNamespacedRef(input.id, {
     entityLabel: "app ref"
@@ -17324,6 +17364,30 @@ async function exportAppIcon(icon, plans) {
     (0, import_node_fs15.writeFileSync)(plan.outputPath, bytes);
   }
 }
+async function renderAppIconVariant(input) {
+  const svg = await resolveAppIconSvg(input.icon);
+  const bytes = await renderAppIcon(svg, input.width, input.height, input.format);
+  let outputPath;
+  if (input.output) {
+    outputPath = import_node_path20.default.resolve(input.cwd, input.output);
+    (0, import_node_fs15.mkdirSync)(import_node_path20.default.dirname(outputPath), { recursive: true });
+    (0, import_node_fs15.writeFileSync)(outputPath, bytes);
+  }
+  return {
+    value: createImageDataUrl(bytes, input.format),
+    ...outputPath ? { outputPath } : {}
+  };
+}
+function loadAppIconVariantFile(filePath, cwd) {
+  const absolutePath = import_node_path20.default.resolve(cwd, filePath);
+  const format = inferVariantFormatFromPath(absolutePath);
+  const bytes = (0, import_node_fs15.readFileSync)(absolutePath);
+  return {
+    value: createImageDataUrl(bytes, format),
+    format,
+    absolutePath
+  };
+}
 async function resolveAppIconSvg(icon) {
   const trimmed = icon.trim();
   if (looksLikeSvgMarkup(trimmed)) {
@@ -17366,6 +17430,44 @@ async function renderAppIcon(svg, width, height, format) {
 function looksLikeSvgMarkup(value) {
   return /<svg[\s>]/i.test(value);
 }
+function inferVariantFormatFromPath(filePath) {
+  const ext = import_node_path20.default.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".png":
+      return "png";
+    case ".webp":
+      return "webp";
+    case ".svg":
+      return "svg";
+    case ".ico":
+      return "ico";
+    default:
+      throw new Error(`Unsupported app icon variant file extension "${ext || "(none)"}". Use .png, .webp, .svg, or .ico.`);
+  }
+}
+function createImageDataUrl(bytes, format) {
+  return `data:${mimeTypeForIconFormat(format)};base64,${bytes.toString("base64")}`;
+}
+function mimeTypeForIconFormat(format) {
+  switch (format) {
+    case "png":
+      return "image/png";
+    case "webp":
+      return "image/webp";
+    case "svg":
+      return "image/svg+xml";
+    case "ico":
+      return "image/x-icon";
+  }
+}
+function isSupportedImageDataUrl(value) {
+  const match = value.match(DATA_URL_PATTERN);
+  if (!match) {
+    return false;
+  }
+  const mimeType = match[1]?.toLowerCase();
+  return mimeType === "image/png" || mimeType === "image/webp" || mimeType === "image/svg+xml" || mimeType === "image/x-icon";
+}
 
 // src/commands/AppCommandHandler.ts
 init_namespacedRef();
@@ -17399,7 +17501,11 @@ var AppCommandHandler = class {
           "GET",
           pathname
         );
-        this.renderJson(record, true);
+        if (args.action === "view") {
+          this.renderView(record);
+        } else {
+          this.renderJson(record, true);
+        }
         return;
       }
       case "create": {
@@ -17463,6 +17569,46 @@ var AppCommandHandler = class {
         );
         return;
       }
+      case "icon-add": {
+        const pathname = this.buildAppPath(args.id);
+        const record = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          pathname
+        );
+        const name = validateAppIconVariantKey(args.name);
+        const existingIcons = record.icons || {};
+        if (existingIcons[name] && !args.force) {
+          throw new Error(`App icon variant "${name}" already exists for ${args.id}. Re-run with --force to overwrite it.`);
+        }
+        const source = args.filePath ? loadAppIconVariantFile(args.filePath, process.cwd()) : await this.renderIconVariantFromApp(record, args);
+        const updatedIcons = {
+          ...existingIcons,
+          [name]: source.value
+        };
+        const updatedRecord = await this.request(
+          baseUrl,
+          token,
+          "PUT",
+          pathname,
+          {
+            icons: updatedIcons
+          }
+        );
+        ui.success(`Updated icon variant ${name} for ${args.id}`);
+        this.renderJson(
+          {
+            id: args.id,
+            name,
+            ..."absolutePath" in source ? { filePath: source.absolutePath } : {},
+            ..."outputPath" in source && source.outputPath ? { outputPath: source.outputPath } : {},
+            icons: updatedRecord.icons || updatedIcons
+          },
+          args.json
+        );
+        return;
+      }
       case "delete": {
         const pathname = this.buildAppPath(args.id);
         const record = await this.request(
@@ -17593,12 +17739,53 @@ var AppCommandHandler = class {
     }
     ui.plain(JSON.stringify(value, null, 2));
   }
+  renderView(record) {
+    const appId = formatNamespacedDisplayId(record.namespace, record.id);
+    ui.plain(`App: ${appId}`);
+    ui.plain(`Name: ${record.name}`);
+    ui.plain(`Status: ${record.status}`);
+    if (record.icon) {
+      ui.plain(`Icon: ${record.icon}`);
+    }
+    if (record.icons && Object.keys(record.icons).length > 0) {
+      ui.plain("Icons:");
+      for (const [name, value] of Object.entries(record.icons).sort(
+        ([left], [right]) => left.localeCompare(right)
+      )) {
+        ui.plain(`  ${name}: ${value}`);
+      }
+    }
+    if (record.deploys && Object.keys(record.deploys).length > 0) {
+      ui.plain("Deploys:");
+      for (const [platform, serviceRef] of Object.entries(record.deploys)) {
+        if (serviceRef) {
+          ui.plain(`  ${platform}: ${serviceRef}`);
+        }
+      }
+    }
+  }
   buildAppPath(appId) {
     const { namespace, objectId } = parseNamespacedRef(appId, {
       entityLabel: "app ref"
     });
     return `/apps/${encodeURIComponent(namespace)}/${encodeURIComponent(objectId)}`;
   }
+  async renderIconVariantFromApp(record, args) {
+    if (!record.icon) {
+      throw new Error(`App icon is missing for ${args.id}`);
+    }
+    if (!args.width || !args.height) {
+      throw new Error("App icon add export requires an explicit size.");
+    }
+    return renderAppIconVariant({
+      icon: record.icon,
+      width: args.width,
+      height: args.height,
+      format: args.format || "png",
+      output: args.output,
+      cwd: process.cwd()
+    });
+  }
 };
 function readNamespaceFromPayload(payload) {
   if (!payload || typeof payload !== "object") {
@@ -20699,6 +20886,97 @@ function parseAppArgs(tokens) {
     return { type: "app" /* App */, action, id, baseUrl, json };
   }
   if (action === "icon") {
+    const nextToken = rest[0];
+    if (nextToken === "add") {
+      rest.shift();
+      const rawRef2 = rest.shift();
+      const name = rest.shift();
+      if (!rawRef2 || rawRef2.startsWith("-") || !name || name.startsWith("-")) {
+        throw new Error(
+          "Usage: app icon add <ns:objectId> <name> (--file <path> | (--size <w>x<h>|--<w>x<h>) [--format <png|webp|svg|ico>] [--output <path>]) [--force] [--base-url <url>] [--json]"
+        );
+      }
+      const id2 = parseNamespacedRef(rawRef2, {
+        entityLabel: "app ref"
+      }).fullId;
+      let width2;
+      let height2;
+      let format2;
+      let output2;
+      let filePath;
+      let force = false;
+      while (rest.length > 0) {
+        const token = rest.shift();
+        const inlineSize = parseInlineSizeToken(token);
+        if (inlineSize) {
+          if (filePath || width2 || height2) {
+            throw new Error("App icon add source already set. Use either --file or one explicit size.");
+          }
+          width2 = inlineSize.width;
+          height2 = inlineSize.height;
+          continue;
+        }
+        switch (token) {
+          case "--file":
+            if (filePath || width2 || height2) {
+              throw new Error("App icon add source already set. Use either --file or one explicit size.");
+            }
+            filePath = requireValue5(rest, token);
+            break;
+          case "--size": {
+            if (filePath || width2 || height2) {
+              throw new Error("App icon add source already set. Use either --file or one explicit size.");
+            }
+            const size = parseSizeValue(requireValue5(rest, token));
+            width2 = size.width;
+            height2 = size.height;
+            break;
+          }
+          case "--format": {
+            const value = requireValue5(rest, token);
+            if (value !== "png" && value !== "webp" && value !== "svg" && value !== "ico") {
+              throw new Error(`Invalid app icon format "${value}". Use png, webp, svg, or ico.`);
+            }
+            format2 = value;
+            break;
+          }
+          case "--output":
+            output2 = requireValue5(rest, token);
+            break;
+          case "--force":
+            force = true;
+            break;
+          case "--base-url":
+            baseUrl = requireValue5(rest, token);
+            break;
+          case "--json":
+            json = true;
+            break;
+          default:
+            throw new Error(`Unknown app icon add option: ${token}`);
+        }
+      }
+      if (!filePath && (!width2 || !height2)) {
+        throw new Error("Missing app icon add source. Use --file <path>, --size <w>x<h>, or --<w>x<h>.");
+      }
+      if (filePath && format2) {
+        throw new Error("App icon add with --file infers format from the file extension. Remove --format.");
+      }
+      return {
+        type: "app" /* App */,
+        action: "icon-add",
+        id: id2,
+        name,
+        filePath,
+        width: width2,
+        height: height2,
+        format: format2,
+        output: output2,
+        force,
+        baseUrl,
+        json
+      };
+    }
     const rawRef = rest.shift();
     if (!rawRef || rawRef.startsWith("-")) {
       throw new Error(
@@ -20789,6 +21067,7 @@ function parseAppArgs(tokens) {
     return {
       type: "app" /* App */,
       action,
+      subAction: "export",
       id,
       preset,
       width,
@@ -22475,6 +22754,8 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  icon <ns:objectId> --android --out-dir <path> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  icon <ns:objectId> --ios --out-dir <path> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  icon <ns:objectId> (--size <w>x<h>|--<w>x<h>) --output <path> [--format <png|webp|svg|ico>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  icon add <ns:objectId> <name> --file <path> [--force] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  icon add <ns:objectId> <name> (--size <w>x<h>|--<w>x<h>) [--format <png|webp|svg|ico>] [--output <path>] [--force] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  delete <ns:objectId> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  default base URL: https://apps-api.pmate.chat")}`,
   `  ${import_chalk4.default.cyan("service")}          Manage service registry entries via apps-api`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.21.19",
+  "version": "0.22.0",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {