@pmate/cli 0.21.18 → 0.22.0

package/dist/index.d.ts

@@ -349,6 +349,23 @@ type RoleCommandArgs = {
     json: boolean;
 };
 type AccountCommandArgs = {
+    type: Command.Account;
+    action: "list";
+    page?: number;
+    pageSize?: number;
+    mobile?: string;
+    nickName?: string;
+    baseUrl?: string;
+    json: boolean;
+} | {
+    type: Command.Account;
+    action: "app-users";
+    app: string;
+    page?: number;
+    pageSize?: number;
+    baseUrl?: string;
+    json: boolean;
+} | {
     type: Command.Account;
     action: "view";
     account?: string;
@@ -721,6 +738,7 @@ type AppCommandArgs = {
     type: Command.App;
     action: "icon";
     id: string;
+    subAction?: "export";
     preset?: "android" | "ios";
     width?: number;
     height?: number;
@@ -729,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") {
@@ -19221,6 +19408,28 @@ var AccountCommandHandler = class {
   async handle(args) {
     const token = this.readToken();
     switch (args.action) {
+      case "list": {
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const result = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          `/accounts?${this.buildAccountListQuery(args)}`
+        );
+        this.renderAccountList(result, args.json);
+        return;
+      }
+      case "app-users": {
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const result = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          `/accounts/app-users/${encodeURIComponent(args.app)}?${this.buildPagedQuery(args)}`
+        );
+        this.renderAccountAppUsers(result, args.json);
+        return;
+      }
       case "view": {
         const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
         const result = await this.request(
@@ -19362,6 +19571,20 @@ var AccountCommandHandler = class {
     if (args.nickName) params.set("nickName", args.nickName);
     return params.toString();
   }
+  buildAccountListQuery(args) {
+    const params = new URLSearchParams();
+    if (args.page) params.set("page", String(args.page));
+    if (args.pageSize) params.set("pageSize", String(args.pageSize));
+    if (args.mobile) params.set("mobile", args.mobile);
+    if (args.nickName) params.set("nickName", args.nickName);
+    return params.toString();
+  }
+  buildPagedQuery(args) {
+    const params = new URLSearchParams();
+    if (args.page) params.set("page", String(args.page));
+    if (args.pageSize) params.set("pageSize", String(args.pageSize));
+    return params.toString();
+  }
   buildRoleBindingsQuery(args) {
     const params = new URLSearchParams();
     params.set("account", args.account);
@@ -19440,6 +19663,44 @@ var AccountCommandHandler = class {
       });
     }
   }
+  renderAccountList(result, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(result, null, 2));
+      return;
+    }
+    this.renderAccountView(result.items, false);
+    if (result.items.length > 0) {
+      ui.info(`page ${result.page}`, {
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+        hasNext: result.hasNext
+      });
+    }
+  }
+  renderAccountAppUsers(result, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.items.length === 0) {
+      ui.warn("No app users found.");
+      return;
+    }
+    for (const item of result.items) {
+      ui.info(item.account.id, {
+        mobile: item.account.mobile,
+        nickNames: item.nickNames,
+        roles: item.roles.map((role) => `${role.namespace}/${role.role}`),
+        sources: item.sources
+      });
+    }
+    ui.info(`page ${result.page}`, {
+      pageSize: result.pageSize,
+      total: result.total,
+      totalPages: result.totalPages,
+      hasNext: result.hasNext
+    });
+  }
   renderJson(value, asJson) {
     if (!asJson) {
       return;
@@ -20625,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(
@@ -20715,6 +21067,7 @@ function parseAppArgs(tokens) {
     return {
       type: "app" /* App */,
       action,
+      subAction: "export",
       id,
       preset,
       width,
@@ -21514,7 +21867,93 @@ function parseAccountArgs(tokens) {
   const rest = [...tokens];
   const action = rest.shift();
   if (!action) {
-    throw new Error("Missing account action. Use: account view|role");
+    throw new Error("Missing account action. Use: account list|view|app-users|role");
+  }
+  if (action === "list") {
+    let mobile;
+    let nickName;
+    let page;
+    let pageSize;
+    let baseUrl2;
+    let json2 = false;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--mobile":
+          mobile = requireValue8(rest, token);
+          break;
+        case "--nickname":
+        case "--nickName":
+          nickName = requireValue8(rest, token);
+          break;
+        case "--page":
+          page = parsePositiveInt(requireValue8(rest, token), token);
+          break;
+        case "--page-size":
+          pageSize = parsePositiveInt(requireValue8(rest, token), token);
+          break;
+        case "--base-url":
+          baseUrl2 = requireValue8(rest, token);
+          break;
+        case "--json":
+          json2 = true;
+          break;
+        default:
+          throw new Error(`Unknown account list option: ${token}`);
+      }
+    }
+    if (mobile && nickName) {
+      throw new Error(
+        "Usage: account list [--page <n>] [--page-size <n>] [--mobile <mobile> | --nickname <nickname>] [--base-url <url>] [--json]"
+      );
+    }
+    return {
+      type: "account" /* Account */,
+      action: "list",
+      page,
+      pageSize,
+      mobile,
+      nickName,
+      baseUrl: baseUrl2,
+      json: json2
+    };
+  }
+  if (action === "app-users") {
+    const app = parseNamespacedRef(requireValue8(rest, "app-users"), {
+      entityLabel: "app ref"
+    }).fullId;
+    let page;
+    let pageSize;
+    let baseUrl2;
+    let json2 = false;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--page":
+          page = parsePositiveInt(requireValue8(rest, token), token);
+          break;
+        case "--page-size":
+          pageSize = parsePositiveInt(requireValue8(rest, token), token);
+          break;
+        case "--base-url":
+          baseUrl2 = requireValue8(rest, token);
+          break;
+        case "--json":
+          json2 = true;
+          break;
+        default:
+          throw new Error(`Unknown account app-users option: ${token}`);
+      }
+    }
+    return {
+      type: "account" /* Account */,
+      action: "app-users",
+      app,
+      page,
+      pageSize,
+      baseUrl: baseUrl2,
+      json: json2
+    };
   }
   if (action === "view") {
     let account2;
@@ -21737,6 +22176,13 @@ function requireValue8(tokens, optionName) {
   }
   return value;
 }
+function parsePositiveInt(value, optionName) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${optionName} must be a positive integer`);
+  }
+  return parsed;
+}
 
 // src/orgCommandParser.ts
 init_namespacedRef();
@@ -22265,7 +22711,9 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  definition create <role> [--display-name <name>] [--description <text>] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  default base URL: https://auth-api-v2.pmate.chat")}`,
   `  ${import_chalk4.default.cyan("account")}          View accounts and manage account role bindings`,
+  `  ${import_chalk4.default.gray("                  list [--page <n>] [--page-size <n>] [--mobile <mobile> | --nickname <nickname>] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  view (--account <id> | --mobile <mobile> | --nickname <nickname>) [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  app-users <ns:app> [--page <n>] [--page-size <n>] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  role list --account <id> [--namespace <ns>] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  role add --account <id> --namespace <ns> --role <role> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  role remove --account <id> --namespace <ns> --role <role> [--base-url <url>] [--json]")}`,
@@ -22306,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`,
@@ -23913,7 +24363,7 @@ function parseRandomArgs(tokens) {
         mode = "easy";
         break;
       case "--length":
-        length = parsePositiveInt(requireValue12(rest, token), token);
+        length = parsePositiveInt2(requireValue12(rest, token), token);
         seenLength = true;
         break;
       case "--charset": {
@@ -23928,10 +24378,10 @@ function parseRandomArgs(tokens) {
         break;
       }
       case "--count":
-        count = parsePositiveInt(requireValue12(rest, token), token);
+        count = parsePositiveInt2(requireValue12(rest, token), token);
         break;
       case "--words":
-        words = parsePositiveInt(requireValue12(rest, token), token);
+        words = parsePositiveInt2(requireValue12(rest, token), token);
         seenWords = true;
         break;
       case "--digits":
@@ -23980,7 +24430,7 @@ function requireValue12(tokens, optionName) {
 function decodeEscapedNewlines(value) {
   return value.replace(/(?<!\\)\\r\\n/g, "\n").replace(/(?<!\\)\\n/g, "\n").replace(/(?<!\\)\\r/g, "\n");
 }
-function parsePositiveInt(value, optionName) {
+function parsePositiveInt2(value, optionName) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error(`Invalid ${optionName} value: ${value}`);

package/package.json

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