@xbrowser/cli 0.14.0

package/dist/chunk-FF5WHQHN.js

@@ -0,0 +1,135 @@
+// src/config.ts
+import { existsSync, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+
+// src/utils/json-file.ts
+import { readFileSync, writeFileSync } from "fs";
+function readJsonFile(filePath, defaultValue) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+
+// src/config.ts
+function getConfigFile() {
+  return join(homedir() || tmpdir(), ".xbrowser", "config.json");
+}
+function loadConfig() {
+  const configFile = getConfigFile();
+  if (!existsSync(configFile)) return {};
+  return readJsonFile(configFile, {});
+}
+function saveConfig(config) {
+  const dir = join(homedir() || tmpdir(), ".xbrowser");
+  const configFile = getConfigFile();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync2(configFile, JSON.stringify(config, null, 2), "utf-8");
+}
+function getConfigValue(key) {
+  return loadConfig()[key];
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}
+var DEFAULT_MARKETPLACE_URL = "https://marketplace.xbrowser.dev";
+var DEFAULT_REGISTRY_URL = "https://xbrowser.dev";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org";
+var NPM_SCOPE = "@xbrowser/";
+function getMarketplaceUrl() {
+  return process.env.XBROWSER_MARKETPLACE_URL || getConfigValue("marketplaceUrl") || DEFAULT_MARKETPLACE_URL;
+}
+function getRegistryUrl(options = {}, fallbackRegistry) {
+  return options["registry"] || process.env.XBROWSER_REGISTRY || fallbackRegistry || DEFAULT_REGISTRY_URL;
+}
+function resolveNpmPackageName(name) {
+  if (name.startsWith("@")) return name;
+  return `${NPM_SCOPE}${name}`;
+}
+var NPM_NAME_ALIASES = {
+  "1688": "alibaba-1688"
+};
+function generateNpmCandidates(name) {
+  if (name.startsWith("@")) return [name];
+  const resolved = NPM_NAME_ALIASES[name] ?? name;
+  return [
+    `${NPM_SCOPE}xbrowser-plugin-${resolved}`,
+    `${NPM_SCOPE}${resolved}`,
+    `xbrowser-plugin-${resolved}`
+  ];
+}
+async function resolveNpmPackageWithFallback(name) {
+  const candidates = generateNpmCandidates(name);
+  for (const candidate of candidates) {
+    try {
+      const encoded = encodeURIComponent(candidate);
+      const res = await fetch(`${NPM_REGISTRY_URL}/${encoded}`);
+      if (res.ok) return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return resolveNpmPackageName(name);
+}
+
+// src/utils/proxy-fetch.ts
+var patched = false;
+async function ensureProxyFetch() {
+  if (patched) return;
+  patched = true;
+  if (process.env.https_proxy && !process.env.HTTPS_PROXY) {
+    process.env.HTTPS_PROXY = process.env.https_proxy;
+  }
+  if (process.env.http_proxy && !process.env.HTTP_PROXY) {
+    process.env.HTTP_PROXY = process.env.http_proxy;
+  }
+  if (process.env.all_proxy && !process.env.ALL_PROXY) {
+    process.env.ALL_PROXY = process.env.all_proxy;
+  }
+  const proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY || process.env.all_proxy || process.env.ALL_PROXY;
+  if (!proxyUrl) return;
+  try {
+    const undici = await import("undici");
+    const EnvHttpProxyAgent = undici.EnvHttpProxyAgent;
+    const uFetch = undici.fetch;
+    const UFormData = undici.FormData;
+    if (EnvHttpProxyAgent && uFetch && UFormData) {
+      const agent = new EnvHttpProxyAgent();
+      globalThis.fetch = ((input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const body = init?.body;
+        if (body instanceof globalThis.FormData && !(body instanceof UFormData)) {
+          const ufd = new UFormData();
+          body.forEach((value, key) => {
+            if (value instanceof Blob) {
+              ufd.append(key, value, value.name || "file");
+            } else {
+              ufd.append(key, value);
+            }
+          });
+          return uFetch(url, { ...init, body: ufd, dispatcher: agent });
+        }
+        return uFetch(url, { ...init, dispatcher: agent });
+      });
+    }
+  } catch {
+  }
+}
+
+export {
+  readJsonFile,
+  loadConfig,
+  getConfigValue,
+  setConfigValue,
+  NPM_REGISTRY_URL,
+  NPM_SCOPE,
+  getMarketplaceUrl,
+  getRegistryUrl,
+  resolveNpmPackageWithFallback,
+  ensureProxyFetch
+};

package/dist/chunk-HINTG75P.js

@@ -0,0 +1,77 @@
+import {
+  readJsonFile
+} from "./chunk-FF5WHQHN.js";
+
+// src/plugin/metadata-parser.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var PluginMetadataParser = class {
+  static XBROWSER_KEYWORDS = ["xbrowser", "xbrowser-plugin"];
+  static parseFromPackageJson(pluginPath) {
+    const packageJsonPath = resolve(pluginPath, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      return null;
+    }
+    const packageJson = readJsonFile(packageJsonPath, null);
+    if (!packageJson) return null;
+    if (!packageJson.xbrowser) {
+      return null;
+    }
+    const xbrowser = packageJson.xbrowser;
+    const metadata = {
+      id: xbrowser.id || packageJson.name,
+      name: xbrowser.name || packageJson.name,
+      description: xbrowser.description || packageJson.description || "",
+      version: xbrowser.version || packageJson.version || "1.0.0",
+      author: xbrowser.author || this.extractAuthor(packageJson.author),
+      homepage: xbrowser.homepage || packageJson.homepage,
+      commands: xbrowser.commands,
+      sites: xbrowser.sites,
+      tags: xbrowser.tags,
+      screenshot: xbrowser.screenshot,
+      license: xbrowser.license || packageJson.license
+    };
+    return metadata;
+  }
+  static isXBrowserPlugin(packageJson) {
+    if (packageJson.xbrowser) {
+      return true;
+    }
+    const keywords = packageJson.keywords;
+    if (!keywords) return false;
+    return this.XBROWSER_KEYWORDS.some((kw) => keywords.includes(kw));
+  }
+  static fromNPMResult(result) {
+    const author = typeof result.author === "string" ? result.author : result.author?.name || "Unknown";
+    return {
+      id: result.name,
+      name: result.name.replace(/^xbrowser-plugin-/, "").replace(/^@[^/]+\//, ""),
+      description: result.description || "",
+      version: result.version,
+      author,
+      homepage: result.homepage || result.links?.homepage,
+      tags: result.keywords,
+      license: ""
+    };
+  }
+  static extractAuthor(author) {
+    if (typeof author === "string") return author;
+    if (typeof author === "object" && author !== null) {
+      const authorObj = author;
+      return authorObj.name || "Unknown";
+    }
+    return "Unknown";
+  }
+  static validateMetadata(metadata) {
+    const errors = [];
+    if (!metadata.id) errors.push("id is required");
+    if (!metadata.name) errors.push("name is required");
+    if (!metadata.description) errors.push("description is required");
+    if (!metadata.version) errors.push("version is required");
+    return errors;
+  }
+};
+
+export {
+  PluginMetadataParser
+};