@o861runners/nmp 1.26.13-0.11255

package/src/core/publisher.js

@@ -0,0 +1,314 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { NpmRegistry } from "../registries/npm.js";
+import { GitHubRegistry } from "../registries/github.js";
+import { GiteaRegistry } from "../registries/gitea.js";
+import { SupabaseRegistry } from "../registries/supabase.js";
+import { PocketBaseRegistry } from "../registries/pocketbase.js";
+import chalk from "chalk";
+import ora from "ora";
+
+const REGISTRY_TYPES = {
+  npm: NpmRegistry,
+  github: GitHubRegistry,
+  gitea: GiteaRegistry,
+  supabase: SupabaseRegistry,
+  pocketbase: PocketBaseRegistry,
+};
+
+export class Publisher {
+  constructor(config, options = {}) {
+    this.config = config;
+    this.options = options;
+    this.registries = this.initRegistries();
+    this.tmpDir = path.join(process.cwd(), ".npm-multi-publish-tmp");
+  }
+
+  /**
+   * Initialize registries từ config
+   */
+  initRegistries() {
+    const registries = [];
+
+    for (const [name, regConfig] of Object.entries(this.config.registries || {})) {
+      // Skip disabled
+      if (!regConfig.enabled) {
+        console.log(chalk.gray(`○ ${name} (disabled)`));
+        continue;
+      }
+
+      // Filter by --target
+      if (this.options.targets && !this.options.targets.includes(name)) {
+        continue;
+      }
+
+      const RegistryClass = REGISTRY_TYPES[regConfig.type];
+      if (!RegistryClass) {
+        console.warn(chalk.yellow(`⚠️  Unknown registry type: ${regConfig.type}`));
+        continue;
+      }
+
+      registries.push(new RegistryClass(name, regConfig, this.config));
+    }
+
+    if (registries.length === 0) {
+      throw new Error("No enabled registries found");
+    }
+
+    return registries;
+  }
+
+  /**
+   * Generate version: 1.yy.mmdd.1hhMM
+   * @returns {string} Version string
+   *
+   * Examples:
+   * - 30/01/2026 15:45 → "1.26.0130.11545"
+   * - 15/12/2026 09:30 → "1.26.1215.10930"
+   */
+  generateVersion() {
+    const now = new Date();
+    const yy = String(now.getFullYear()).slice(-2);
+    const mm = String(now.getMonth() + 1).padStart(2, "0");
+    const dd = String(now.getDate()).padStart(2, "0");
+    const hh = String(now.getHours()).padStart(2, "0");
+    const MM = String(now.getMinutes()).padStart(2, "0");
+
+    return `1.${yy}.${mm}${dd}.1${hh}${MM}`;
+  }
+
+  /**
+   * Create package.json for specific registry
+   * @param {object} registry - Registry instance
+   * @param {object} originalPkg - Original package.json content
+   * @returns {object} { pkgPath: string, pkg: object }
+   *
+   * This creates a registry-specific package.json with:
+   * - New auto-generated version
+   * - Registry-specific package name (with scope if applicable)
+   */
+  async createRegistryPackage(registry, originalPkg) {
+    const registryPkgPath = path.join(this.tmpDir, `package-${registry.name}.json`);
+    const newVersion = this.generateVersion();
+
+    // Clone package.json
+    const registryPkg = { ...originalPkg };
+
+    // Update version
+    registryPkg.version = newVersion;
+
+    console.log(JSON.stringify({ registry, originalPkg, registryPkg }, null, 2));
+
+    // Update package name based on registry config
+    if (registry.config.scope) {
+      // Remove existing scope if any
+      const baseName = registryPkg.name.replace(/^@[^/]+\//, "");
+      registryPkg.name = `${registry.config.scope}/${baseName}`;
+    }
+
+    if (registry.config.package_name && registry.config.package_name + "" !== "") {
+      registryPkg.name = registry.config.package_name;
+    }
+
+    // Write registry-specific package.json
+    fs.writeFileSync(registryPkgPath, JSON.stringify(registryPkg, null, 2));
+
+    return { pkgPath: registryPkgPath, pkg: registryPkg };
+  }
+
+  /**
+   * Pack package for specific registry
+   * @param {object} registry - Registry instance
+   * @param {string} pkgPath - Path to registry-specific package.json
+   * @returns {string} Path to created .tgz file
+   *
+   * Flow:
+   * 1. Backup original package.json
+   * 2. Replace with registry-specific package.json
+   * 3. Run npm pack
+   * 4. Rename .tgz with registry name prefix
+   * 5. Restore original package.json
+   */
+  async packForRegistry(registry, pkgPath) {
+    const spinner = ora(`Packing for ${registry.name}...`).start();
+
+    try {
+      // Backup original package.json
+      const originalPkgPath = path.join(process.cwd(), "package.json");
+      const backupPkgPath = path.join(this.tmpDir, "package.json.backup");
+      fs.copyFileSync(originalPkgPath, backupPkgPath);
+
+      // Replace with registry-specific package.json
+      fs.copyFileSync(pkgPath, originalPkgPath);
+
+      // Pack
+      const packOutput = execSync("npm pack --json", { encoding: "utf-8" });
+      const packInfo = JSON.parse(packOutput)[0];
+      const artifactPath = packInfo.filename;
+
+      // Move to registry-specific directory with registry name prefix
+      const registryArtifactPath = path.join(this.tmpDir, `${registry.name}-${packInfo.filename}`);
+      fs.renameSync(artifactPath, registryArtifactPath);
+
+      // Restore original package.json
+      fs.copyFileSync(backupPkgPath, originalPkgPath);
+
+      spinner.succeed(`Package created for ${registry.name}`);
+      console.log(chalk.gray(`   Name: ${packInfo.name}@${packInfo.version}`));
+      console.log(chalk.gray(`   Size: ${(packInfo.size / 1024).toFixed(2)} KB`));
+      console.log(chalk.gray(`   File: ${registryArtifactPath}`));
+
+      return registryArtifactPath;
+    } catch (error) {
+      spinner.fail(`Pack failed for ${registry.name}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Main execution flow
+   */
+  async run() {
+    console.log(chalk.bold("\n🚀 NPM Multi-Registry Publisher\n"));
+
+    // Create temp directory
+    if (!fs.existsSync(this.tmpDir)) {
+      fs.mkdirSync(this.tmpDir, { recursive: true });
+    }
+
+    // 1. Build (if needed)
+    if (!this.options.skipBuild && this.config.build?.command) {
+      const spinner = ora("Building package...").start();
+      try {
+        execSync(this.config.build.command, { stdio: "pipe" });
+        spinner.succeed("Build completed");
+      } catch (error) {
+        spinner.fail("Build failed");
+        throw error;
+      }
+    }
+
+    // 2. Read original package.json
+    const originalPkg = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+    console.log(chalk.bold(`\n📦 Original package: ${originalPkg.name}@${originalPkg.version}\n`));
+
+    // 3. Validate all registries
+    console.log(chalk.bold("📋 Validating registries...\n"));
+    for (const registry of this.registries) {
+      try {
+        await registry.validate();
+        console.log(chalk.green(`✓ ${registry.name}`));
+      } catch (error) {
+        console.log(chalk.red(`✗ ${registry.name}: ${error.message}`));
+        throw error;
+      }
+    }
+
+    console.log("");
+
+    // 4. Authenticate all
+    console.log(chalk.bold("🔑 Authenticating...\n"));
+    for (const registry of this.registries) {
+      try {
+        await registry.authenticate();
+        console.log(chalk.green(`✓ ${registry.name}`));
+      } catch (error) {
+        console.log(chalk.red(`✗ ${registry.name}: ${error.message}`));
+        throw error;
+      }
+    }
+
+    console.log("");
+
+    // 5. Create and publish to each registry
+    console.log(chalk.bold("📦 Creating packages and publishing...\n"));
+    const results = [];
+
+    for (const registry of this.registries) {
+      if (this.options.dryRun) {
+        console.log(chalk.cyan(`[DRY RUN] ${registry.name}`));
+        results.push({
+          registry: registry.name,
+          success: true,
+          dryRun: true,
+        });
+      } else {
+        try {
+          // Create registry-specific package
+          const { pkgPath, pkg } = await this.createRegistryPackage(registry, originalPkg);
+          console.log(chalk.blue(`📝 Package name for ${registry.name}: ${pkg.name}@${pkg.version}`));
+
+          // Pack for registry
+          const artifactPath = await this.packForRegistry(registry, pkgPath);
+
+          // Publish
+          const result = await registry.publish(artifactPath);
+          results.push({
+            registry: registry.name,
+            packageName: pkg.name,
+            version: pkg.version,
+            ...result,
+          });
+
+          if (result.success) {
+            console.log(chalk.green(`✓ ${registry.name} - ${pkg.name}@${pkg.version}`));
+          } else {
+            console.log(chalk.red(`✗ ${registry.name}: ${result.error}`));
+          }
+        } catch (error) {
+          results.push({
+            registry: registry.name,
+            success: false,
+            error: error.message,
+          });
+          console.log(chalk.red(`✗ ${registry.name}: ${error.message}`));
+        }finally{
+          
+        }
+
+        console.log("");
+      }
+    }
+
+    // 6. Cleanup
+    for (const registry of this.registries) {
+      await registry.cleanup();
+    }
+
+    // 7. Summary
+    this.printSummary(results);
+
+    return results;
+  }
+
+  /**
+   * Print summary table
+   */
+  printSummary(results) {
+    console.log(chalk.bold("📊 Summary:\n"));
+
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success && !r.dryRun);
+
+    for (const result of results) {
+      const icon = result.dryRun ? "○" : result.success ? "✅" : "❌";
+      const status = result.dryRun ? chalk.cyan("[DRY RUN]") : result.success ? chalk.green("[SUCCESS]") : chalk.red("[FAILED]");
+
+      const pkgInfo = result.packageName && result.version ? ` - ${result.packageName}@${result.version}` : "";
+
+      console.log(`${icon} ${result.registry}${pkgInfo} ${status}`);
+
+      if (result.url) {
+        console.log(chalk.gray(`   URL: ${result.url}`));
+      }
+
+      if (result.error && !result.success) {
+        console.log(chalk.red(`   Error: ${result.error}`));
+      }
+    }
+
+    console.log("");
+    console.log(chalk.bold(`Total: ${results.length} | Success: ${successful.length} | Failed: ${failed.length}`));
+  }
+}

package/src/core/registry.js

@@ -0,0 +1,42 @@
+/**
+ * Base class cho tất cả registry publishers
+ */
+export class BaseRegistry {
+  constructor(name, config, globalConfig) {
+    this.name = name;
+    this.config = config;
+    this.globalConfig = globalConfig;
+  }
+
+  /**
+   * Validate registry config
+   * @throws {Error} nếu config không hợp lệ
+   */
+  async validate() {
+    throw new Error('validate() must be implemented');
+  }
+
+  /**
+   * Authenticate với registry
+   * @throws {Error} nếu auth fail
+   */
+  async authenticate() {
+    throw new Error('authenticate() must be implemented');
+  }
+
+  /**
+   * Publish package
+   * @param {string} artifactPath - Path to .tgz file
+   * @returns {object} - {success: boolean, error?: string}
+   */
+  async publish(artifactPath) {
+    throw new Error('publish() must be implemented');
+  }
+
+  /**
+   * Cleanup (xóa temp files, .npmrc...)
+   */
+  async cleanup() {
+    // Optional override
+  }
+}

package/src/registries/gitea.js

@@ -0,0 +1,44 @@
+import { NpmRegistry } from "./npm.js";
+import { BaseRegistry } from "../core/registry.js";
+
+export class GiteaRegistry extends BaseRegistry {
+  async validate() {
+    if (!this.config.url) {
+      throw new Error("Gitea registry requires url");
+    }
+    if (!this.config.owner) {
+      throw new Error("Gitea registry requires owner");
+    }
+    if (!this.config.token) {
+      throw new Error("Gitea registry requires token");
+    }
+  }
+
+  async authenticate() {
+    // Gitea Packages API format: {url}/api/packages/{owner}/npm
+    const baseUrl = this.config.url.replace(/\/$/, "");
+    this.config.registry = `${baseUrl}/api/packages/${this.config.owner}/npm`;
+    this.config.scope = `@${this.config.owner}`;
+  }
+
+  async publish(artifactPath) {
+    // Delegate to NPM publisher
+    const npmPublisher = new NpmRegistry(
+      this.name,
+      {
+        ...this.config,
+        registry: this.config.registry,
+        token: this.config.token,
+        access: this.config.access || "public",
+        scope: this.config.scope,
+      },
+      this.globalConfig,
+    );
+
+    await npmPublisher.authenticate();
+    const result = await npmPublisher.publish(artifactPath);
+    await npmPublisher.cleanup();
+
+    return result;
+  }
+}

package/src/registries/github.js

@@ -0,0 +1,39 @@
+import { NpmRegistry } from "./npm.js";
+import { BaseRegistry } from "../core/registry.js";
+
+export class GitHubRegistry extends BaseRegistry {
+  async validate() {
+    if (!this.config.owner || !this.config.repo) {
+      throw new Error("GitHub registry requires owner and repo");
+    }
+    if (!this.config.token) {
+      throw new Error("GitHub registry requires token");
+    }
+  }
+
+  async authenticate() {
+    // GitHub Packages sử dụng npm registry
+    this.config.registry = "https://npm.pkg.github.com";
+    this.config.scope = `@${this.config.owner}`;
+  }
+
+  async publish(artifactPath) {
+    // Delegate to NPM publisher với GitHub registry config
+    const npmPublisher = new NpmRegistry(
+      this.name,
+      {
+        registry: this.config.registry,
+        token: this.config.token,
+        access: "public", // GitHub Packages luôn là restricted
+        scope: this.config.scope,
+      },
+      this.globalConfig,
+    );
+
+    await npmPublisher.authenticate();
+    const result = await npmPublisher.publish(artifactPath);
+    await npmPublisher.cleanup();
+
+    return result;
+  }
+}

package/src/registries/npm.js

@@ -0,0 +1,90 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { BaseRegistry } from "../core/registry.js";
+import { buildNpmArgs } from "../utils/npm-args.js";
+
+export class NpmRegistry extends BaseRegistry {
+  constructor(name, config, globalConfig) {
+    super(name, config, globalConfig);
+    this.npmrcPath = null;
+  }
+
+  async validate() {
+    // Apply default registry nếu chưa có
+    if (!this.config.registry) {
+      this.config.registry = this.globalConfig.defaults?.registry || "https://registry.npmjs.org";
+    }
+
+    if (!this.config.token) {
+      throw new Error(`NPM registry "${this.name}" missing token`);
+    }
+  }
+
+  async authenticate() {
+    // Tạo .npmrc tạm trong temp directory
+    const tmpDir = path.join(process.cwd(), ".npm-multi-publish-tmp");
+    if (!fs.existsSync(tmpDir)) {
+      fs.mkdirSync(tmpDir, { recursive: true });
+    }
+
+    this.npmrcPath = path.join(tmpDir, `.npmrc-${this.name}`);
+
+    // Parse registry hostname
+    const registryUrl = new URL(this.config.registry);
+    const registryHost = `//${registryUrl.host}${registryUrl.pathname}`;
+    let npmrcContent = ``;
+    if (this.config.type === "gitea") {
+      npmrcContent += `${this.config.scope}:registry=${registryUrl}/` + `\n`;
+      npmrcContent += `registry=${registryUrl}/` + `\n`;
+      npmrcContent += `always-auth=true` + `\n`;
+      npmrcContent += `strict-ssl=true` + `\n`;
+    }
+    npmrcContent += `${registryHost.replace(/\/$/, "")}/:_authToken=${this.config.token}\n`;
+
+    fs.writeFileSync(this.npmrcPath, npmrcContent, { encoding: "utf8" });
+  }
+
+  async publish(artifactPath) {
+    const args = buildNpmArgs(this.config, this.globalConfig);
+    // Add userconfig flag
+    args.push("--userconfig", this.npmrcPath);
+    // Add artifact path
+    args.push(artifactPath);
+
+    // Parse registry hostname
+    const registryUrl = new URL(this.config.registry);
+    const registryHost = `//${registryUrl.host}${registryUrl.pathname}`;
+
+    // Use custom .npmrc
+    const env = {
+      ...process.env,
+      NPM_CONFIG_USERCONFIG: this.npmrcPath,
+      [`npm_config_${registryHost.replace(/[^a-zA-Z0-9]/g, "_")}_auth_token`]: this.config.authToken,
+    };
+
+    const command = `npm ${args.join(" ")}`;
+
+    console.log(`📦 Publishing to ${this.name}...`);
+    console.log(`   Registry: ${this.config.registry}`);
+
+    try {
+      execSync(command, {
+        stdio: "inherit",
+        // env,
+      });
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+
+  async cleanup() {
+    if (this.npmrcPath && fs.existsSync(this.npmrcPath)) {
+      fs.unlinkSync(this.npmrcPath);
+    }
+  }
+}

package/src/registries/pocketbase.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import fetch from 'node-fetch';
+import FormData from 'form-data';
+import { BaseRegistry } from '../core/registry.js';
+
+export class PocketBaseRegistry extends BaseRegistry {
+  async validate() {
+    if (!this.config.url) {
+      throw new Error('PocketBase registry requires url');
+    }
+    if (!this.config.collection) {
+      throw new Error('PocketBase registry requires collection');
+    }
+    if (!this.config.email && !this.config.token) {
+      throw new Error('PocketBase registry requires email/password or token');
+    }
+  }
+
+  async authenticate() {
+    // If token provided, use it directly
+    if (this.config.token) {
+      this.authToken = this.config.token;
+      return;
+    }
+
+    // Otherwise authenticate with email/password
+    if (!this.config.email || !this.config.password) {
+      throw new Error('PocketBase requires email and password for authentication');
+    }
+
+    const response = await fetch(
+      `${this.config.url}/api/admins/auth-with-password`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          identity: this.config.email,
+          password: this.config.password,
+        }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`PocketBase auth failed: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    this.authToken = data.token;
+  }
+
+  async publish(artifactPath) {
+    const fileName = path.basename(artifactPath);
+    const fileStream = fs.createReadStream(artifactPath);
+
+    const form = new FormData();
+    form.append('file', fileStream);
+    form.append('name', fileName);
+
+    console.log(`📦 Uploading to PocketBase...`);
+    console.log(`   Collection: ${this.config.collection}`);
+    console.log(`   File: ${fileName}`);
+
+    try {
+      const response = await fetch(
+        `${this.config.url}/api/collections/${this.config.collection}/records`,
+        {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${this.authToken}`,
+            ...form.getHeaders(),
+          },
+          body: form,
+        }
+      );
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Upload failed: ${error}`);
+      }
+
+      const data = await response.json();
+
+      // Generate file URL
+      const fileUrl = `${this.config.url}/api/files/${this.config.collection}/${data.id}/${data.file}`;
+      console.log(`   File URL: ${fileUrl}`);
+
+      return {
+        success: true,
+        url: fileUrl,
+        recordId: data.id,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+}