@entrinsik/vite-plugin-informer 2.5.0 → 2.6.0-beta.0

package/bin/publish.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import { readFile, access, readdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { collectAppFiles } from '../src/assemble.js';
+import { extractNotes } from '../src/changelog.js';
+import { publish } from '../src/publish.js';
+import { loadEnv, parseModeArg } from '../src/env.js';
+
+const mode = parseModeArg(process.argv);
+loadEnv({ mode });
+
+// --- Target + auth. You already have API keys sorted — just point these at the
+//     License Manager that fronts the marketplace cloud-api. ---
+const marketplaceUrl = process.env.INFORMER_MARKETPLACE_URL;
+const token = process.env.INFORMER_PUBLISH_TOKEN || process.env.INFORMER_API_KEY;
+
+if (!marketplaceUrl || !token) {
+    console.error('Missing required environment variables.');
+    console.error('  INFORMER_MARKETPLACE_URL=https://<license-manager-host>/cloud-api');
+    console.error('  INFORMER_PUBLISH_TOKEN=lmpub_<vendor publish key>');
+    process.exit(1);
+}
+
+// --- App + listing metadata from package.json "informer" block ---
+const projectRoot = resolve('.');
+let pkg;
+try {
+    pkg = JSON.parse(await readFile(join(projectRoot, 'package.json'), 'utf8'));
+} catch {
+    console.error('Could not read package.json in current directory.');
+    process.exit(1);
+}
+
+const inf = pkg.informer || {};
+const name = inf.name || pkg.name;
+const slug = inf.slug || defaultSlug(name);
+
+// Version: prefer the git tag (CI: GITHUB_REF_NAME=vX.Y.Z), then --version, then package.json.
+const version = argValue('--version') || tagVersion(process.env.GITHUB_REF_NAME) || pkg.version;
+
+if (!name || !slug || !version) {
+    console.error('Need a name, slug, and version. Set package.json "informer.name"/"informer.slug" and tag a release (vX.Y.Z) or pass --version.');
+    process.exit(1);
+}
+
+// Release notes: the section for this version, else the cumulative Unreleased block.
+const changeNotes = await extractNotes(join(projectRoot, 'CHANGELOG.md'), version);
+
+// Provenance (GitHub Actions). All optional — best-effort audit trail.
+const sourceRepo = process.env.GITHUB_REPOSITORY || undefined;
+const sourceCommit = process.env.GITHUB_SHA || undefined;
+const ciRun = process.env.GITHUB_RUN_ID
+    ? `${process.env.GITHUB_SERVER_URL || 'https://github.com'}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+    : undefined;
+
+// Assemble the same file set a deploy produces.
+let files;
+try {
+    files = await collectAppFiles({ distDir: join(projectRoot, 'dist'), projectRoot });
+} catch (err) {
+    console.error(err.message);
+    process.exit(1);
+}
+
+const icon = await resolveIcon(projectRoot, inf.icon);
+const screenshots = await resolveScreenshots(projectRoot, inf.screenshots);
+const channel = version.includes('-') ? 'beta' : 'stable';
+
+console.log(`Publishing ${name} v${version} (${channel}) — ${files.length} files${screenshots.length ? `, ${screenshots.length} screenshot${screenshots.length === 1 ? '' : 's'}` : ''}${changeNotes ? '' : ' — no release notes found'}`);
+
+try {
+    const result = await publish({
+        marketplaceUrl,
+        token,
+        files,
+        icon,
+        screenshots,
+        fields: {
+            name,
+            slug,
+            version,
+            shortDescription: inf.shortDescription,
+            description: inf.description || pkg.description,
+            categories: inf.categories,
+            documentationUrl: inf.documentationUrl,
+            requires: inf.requires,
+            metadata: inf.metadata,
+            changeNotes,
+            sourceRepo,
+            sourceCommit,
+            ciRun
+        }
+    });
+    console.log(`Published ${slug} v${version} (${result.channel || channel}).`);
+} catch (err) {
+    console.error(err.message);
+    process.exit(1);
+}
+
+// --- helpers ---
+
+function argValue(flag) {
+    const i = process.argv.indexOf(flag);
+    return i !== -1 && process.argv[i + 1] ? process.argv[i + 1] : undefined;
+}
+
+function tagVersion(ref) {
+    return ref ? ref.replace(/^v/, '') : undefined;
+}
+
+function defaultSlug(value) {
+    if (!value) return undefined;
+    const base = value.startsWith('@') && value.includes('/') ? value.split('/')[1] : value;
+    return base.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+async function resolveIcon(root, configured) {
+    const candidates = [configured, 'favicon.svg', join('public', 'favicon.svg'), join('dist', 'favicon.svg')].filter(Boolean);
+    for (const rel of candidates) {
+        const abs = resolve(root, rel);
+        try {
+            await access(abs);
+            return { abs, filename: rel.split(/[/\\]/).pop() };
+        } catch {
+            // try next candidate
+        }
+    }
+    return undefined;
+}
+
+// Collect listing screenshots from a `screenshots/` directory (override via
+// package.json informer.screenshots), ordered by filename. Returns
+// [{abs, filename}] for the publisher to upload; empty when none exist.
+async function resolveScreenshots(root, configuredDir) {
+    const dir = resolve(root, configuredDir || 'screenshots');
+    let names;
+    try {
+        names = await readdir(dir);
+    } catch {
+        return []; // no screenshots directory — nothing to upload
+    }
+    return names
+        .filter(n => /\.(png|jpe?g|webp|gif)$/i.test(n))
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }))
+        .map(n => ({ abs: join(dir, n), filename: n }));
+}

package/package.json

@@ -1,15 +1,12 @@
 {
     "name": "@entrinsik/vite-plugin-informer",
-    "version": "2.5.0",
+    "version": "2.6.0-beta.0",
     "description": "Vite plugin and deploy tool for Informer App development",
     "repository": {
         "type": "git",
         "url": "https://github.com/entrinsik-org/i5.git",
         "directory": "packages/vite-plugin-informer"
     },
-    "publishConfig": {
-        "registry": "https://docker.entrinsik.com/repository/entNPM/"
-    },
     "author": "Entrinsik Inc.",
     "license": "UNLICENSED",
     "type": "module",
@@ -24,10 +21,12 @@
             "default": "./src/index.js"
         },
         "./deploy": "./src/deploy.js",
+        "./publish": "./src/publish.js",
         "./workspace": "./src/workspace.js"
     },
     "bin": {
         "informer-deploy": "./bin/deploy.js",
+        "informer-publish": "./bin/publish.js",
         "informer-init": "./bin/init.js",
         "informer-workspace": "./bin/workspace.js",
         "create-magic-report": "./bin/init.js"

package/src/assemble.js

@@ -0,0 +1,87 @@
+import { readdir, stat, access } from 'node:fs/promises';
+import { join, relative, posix } from 'node:path';
+
+/**
+ * The canonical set of files that make up a deployable Informer app library.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for what an app "is" on disk, shared by
+ * both `informer-deploy` (uploads each file to a live instance) and
+ * `informer-publish` (tars the same set for the marketplace). Keeping the
+ * enumeration in one place is what guarantees a published artifact is
+ * byte-identical to what a normal deploy produces.
+ *
+ * Layout rule: the Vite build output (`dist/`) lands at the library ROOT
+ * (index.html, assets/…), while the source trees keep their directory prefix
+ * (server/…, tools/…) — matching how an app's library is structured in Informer.
+ */
+const ROOT_CONFIG_FILES = ['informer.yaml', 'data-access.yaml'];
+const SOURCE_DIRS = ['migrations', 'tools', 'server', 'webhooks'];
+
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/** Recursively walk a directory, returning absolute file paths (not dirs). */
+async function walkDir(dir) {
+    const results = [];
+    const items = await readdir(dir);
+    for (const item of items) {
+        const full = join(dir, item);
+        const s = await stat(full);
+        if (s.isDirectory()) {
+            results.push(...await walkDir(full));
+        } else {
+            results.push(full);
+        }
+    }
+    return results;
+}
+
+/** Normalise a path to forward slashes for use as a library/tar entry name. */
+function toLibraryPath(p) {
+    return posix.normalize(p.split('\\').join('/'));
+}
+
+/**
+ * Collect every file that belongs in the app library, each as { abs, rel },
+ * where `rel` is the path it should occupy in the library (and in the tar).
+ *
+ * @param {{ distDir: string, projectRoot: string }} opts
+ * @returns {Promise<Array<{ abs: string, rel: string }>>}
+ */
+export async function collectAppFiles({ distDir, projectRoot }) {
+    if (!await exists(distDir)) {
+        throw new Error(`Build output not found at "${distDir}" — run the build first.`);
+    }
+
+    const files = [];
+
+    // dist/** -> library root
+    for (const abs of await walkDir(distDir)) {
+        files.push({ abs, rel: toLibraryPath(relative(distDir, abs)) });
+    }
+
+    // root config files -> library root
+    for (const name of ROOT_CONFIG_FILES) {
+        const abs = join(projectRoot, name);
+        if (await exists(abs)) files.push({ abs, rel: name });
+    }
+
+    // source trees -> keep their prefix (server/…, migrations/…, tools/…, webhooks/…)
+    for (const dir of SOURCE_DIRS) {
+        const root = join(projectRoot, dir);
+        if (!await exists(root)) continue;
+        for (const abs of await walkDir(root)) {
+            files.push({ abs, rel: toLibraryPath(relative(projectRoot, abs)) });
+        }
+    }
+
+    return files;
+}
+
+export { ROOT_CONFIG_FILES, SOURCE_DIRS };

package/src/changelog.js

@@ -0,0 +1,39 @@
+import { readFile } from 'node:fs/promises';
+
+/**
+ * Extract release notes for a version from a Keep-a-Changelog style CHANGELOG.md.
+ *
+ * Looks for the section header whose name matches `version` (e.g. `## [1.4.0]`,
+ * `## 1.4.0`, `## v1.4.0`); if absent, falls back to `## [Unreleased]`. Returns
+ * the section body trimmed, or '' if nothing matches / the file is missing.
+ *
+ * This is what makes the dual notes flow work: betas ship the cumulative
+ * `Unreleased` block, while a stable release promotes `Unreleased` to a
+ * versioned heading before tagging so its exact section is matched.
+ *
+ * @param {string} changelogPath
+ * @param {string} version
+ * @returns {Promise<string>}
+ */
+export async function extractNotes(changelogPath, version) {
+    let text;
+    try {
+        text = await readFile(changelogPath, 'utf8');
+    } catch {
+        return '';
+    }
+    return sectionBody(text, version) ?? sectionBody(text, 'Unreleased') ?? '';
+}
+
+/** Body of the first `## [name]` / `## name` section, up to the next `## `. */
+function sectionBody(text, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const header = new RegExp(`^##\\s+\\[?v?${escaped}\\]?.*$`, 'im');
+    const match = header.exec(text);
+    if (!match) return null;
+
+    const after = text.slice(match.index + match[0].length);
+    const next = after.search(/^##\s/m);
+    const body = (next === -1 ? after : after.slice(0, next)).trim();
+    return body || null;
+}

package/src/deploy.js

@@ -1,6 +1,7 @@
 import { createClient } from './client.js';
-import { readdir, readFile, stat, access } from 'node:fs/promises';
-import { join, relative, posix, basename, dirname } from 'node:path';
+import { collectAppFiles } from './assemble.js';
+import { readFile } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
 
 const TEXT_EXTENSIONS = new Set([
     '.html', '.css', '.js', '.mjs', '.json', '.svg',
@@ -10,9 +11,6 @@ const TEXT_EXTENSIONS = new Set([
 // Files above this size use chunked upload via Flow.js protocol
 const CHUNK_THRESHOLD = 512 * 1024; // 512KB
 
-// Config files to upload from project root (if they exist)
-const ROOT_CONFIG_FILES = ['informer.yaml', 'data-access.yaml'];
-
 /**
  * Deploy a built Vite project to Informer as an App.
  *
@@ -106,144 +104,38 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
     console.log('Clearing existing files...');
     await api.post(`${entityPath}/files/_clear`);
 
-    // 6. Upload dist/ contents
-    console.log(`Uploading files from ${distDir}...`);
-    const entries = await walkDir(distDir);
+    // 6. Upload the app-library file set: dist output at the library root, plus
+    //    informer.yaml / data-access.yaml and the server/tools/migrations/webhooks
+    //    source trees. Sourced from the shared collectAppFiles() so a deploy and a
+    //    marketplace publish package byte-identical contents.
+    console.log('Uploading files...');
+    const files = await collectAppFiles({ distDir, projectRoot: dirname(distDir) });
 
-    for (const filePath of entries) {
-        const relPath = posix.normalize(relative(distDir, filePath).split('\\').join('/'));
-        const content = await readFile(filePath);
+    for (const { abs, rel } of files) {
+        const content = await readFile(abs);
 
         if (content.length > CHUNK_THRESHOLD) {
             // Large file: chunked upload via Flow.js protocol
             await api.uploadChunked({
                 entityPath,
-                path: relPath,
+                path: rel,
                 buffer: content,
-                filename: basename(filePath)
+                filename: basename(abs)
             });
-            console.log(`  ${relPath} (${formatSize(content.length)}, chunked)`);
+            console.log(`  ${rel} (${formatSize(content.length)}, chunked)`);
         } else {
             // Small file: direct JSON upload
-            const ext = '.' + relPath.split('.').pop();
+            const ext = '.' + rel.split('.').pop();
             const isText = TEXT_EXTENSIONS.has(ext.toLowerCase());
             const payload = isText
                 ? { content: content.toString('utf8'), encoding: 'utf8' }
                 : { content: content.toString('base64'), encoding: 'base64' };
 
-            await api.put(`${entityPath}/contents/${relPath}`, payload);
-            console.log(`  ${relPath}`);
-        }
-    }
-
-    // 7. Upload config files from project root (informer.yaml, data-access.yaml)
-    const projectRoot = dirname(distDir);
-    let configCount = 0;
-    for (const configFile of ROOT_CONFIG_FILES) {
-        const configPath = join(projectRoot, configFile);
-        try {
-            await access(configPath);
-            const content = await readFile(configPath, 'utf8');
-            await api.put(`${entityPath}/contents/${configFile}`, {
-                content,
-                encoding: 'utf8'
-            });
-            console.log(`  ${configFile} (from project root)`);
-            configCount++;
-        } catch {
-            // File doesn't exist, skip
+            await api.put(`${entityPath}/contents/${rel}`, payload);
+            console.log(`  ${rel}`);
         }
     }
 
-    // 8. Upload migrations/ directory from project root (if it exists)
-    const migrationsDir = join(projectRoot, 'migrations');
-    let migrationsCount = 0;
-    try {
-        await access(migrationsDir);
-        const migrationFiles = await walkDir(migrationsDir);
-        for (const filePath of migrationFiles) {
-            const relPath = posix.normalize(relative(projectRoot, filePath).split('\\').join('/'));
-            const content = await readFile(filePath, 'utf8');
-            await api.put(`${entityPath}/contents/${relPath}`, {
-                content,
-                encoding: 'utf8'
-            });
-            console.log(`  ${relPath} (from project root)`);
-            migrationsCount++;
-        }
-    } catch {
-        // No migrations directory, skip
-    }
-
-    // 9. Upload tools/ directory from project root (if it exists)
-    const toolsDir = join(projectRoot, 'tools');
-    let toolsCount = 0;
-    try {
-        await access(toolsDir);
-        const toolFiles = await walkDir(toolsDir);
-        for (const filePath of toolFiles) {
-            const relPath = posix.normalize(relative(projectRoot, filePath).split('\\').join('/'));
-            const content = await readFile(filePath);
-            const ext = '.' + relPath.split('.').pop();
-            const isText = TEXT_EXTENSIONS.has(ext.toLowerCase());
-            const payload = isText
-                ? { content: content.toString('utf8'), encoding: 'utf8' }
-                : { content: content.toString('base64'), encoding: 'base64' };
-
-            await api.put(`${entityPath}/contents/${relPath}`, payload);
-            console.log(`  ${relPath} (from project root)`);
-            toolsCount++;
-        }
-    } catch {
-        // No tools directory, skip
-    }
-
-    // 10. Upload server/ directory from project root (if it exists)
-    const serverDir = join(projectRoot, 'server');
-    let serverCount = 0;
-    try {
-        await access(serverDir);
-        const serverFiles = await walkDir(serverDir);
-        for (const filePath of serverFiles) {
-            const relPath = posix.normalize(relative(projectRoot, filePath).split('\\').join('/'));
-            const content = await readFile(filePath);
-            const ext = '.' + relPath.split('.').pop();
-            const isText = TEXT_EXTENSIONS.has(ext.toLowerCase());
-            const payload = isText
-                ? { content: content.toString('utf8'), encoding: 'utf8' }
-                : { content: content.toString('base64'), encoding: 'base64' };
-
-            await api.put(`${entityPath}/contents/${relPath}`, payload);
-            console.log(`  ${relPath} (from project root)`);
-            serverCount++;
-        }
-    } catch {
-        // No server directory, skip
-    }
-
-    // 11. Upload webhooks/ directory from project root (if it exists)
-    const webhooksDir = join(projectRoot, 'webhooks');
-    let webhooksCount = 0;
-    try {
-        await access(webhooksDir);
-        const webhookFiles = await walkDir(webhooksDir);
-        for (const filePath of webhookFiles) {
-            const relPath = posix.normalize(relative(projectRoot, filePath).split('\\').join('/'));
-            const content = await readFile(filePath);
-            const ext = '.' + relPath.split('.').pop();
-            const isText = TEXT_EXTENSIONS.has(ext.toLowerCase());
-            const payload = isText
-                ? { content: content.toString('utf8'), encoding: 'utf8' }
-                : { content: content.toString('base64'), encoding: 'base64' };
-
-            await api.put(`${entityPath}/contents/${relPath}`, payload);
-            console.log(`  ${relPath} (from project root)`);
-            webhooksCount++;
-        }
-    } catch {
-        // No webhooks directory, skip
-    }
-
     // 12. Deploy: run migrations + scan/bundle server routes + webhooks + tools + agents
     if (apiPrefix === 'apps') {
         try {
@@ -283,7 +175,7 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
     }
 
     // 13. Print URL and return UUID for saving
-    const totalFiles = entries.length + configCount + migrationsCount + toolsCount + serverCount + webhooksCount;
+    const totalFiles = files.length;
     const base = baseUrl.replace(/\/+$/, '');
     const entityUrl = apiPrefix === 'apps'
         ? `${base}/api/apps/${naturalId}/view`
@@ -293,24 +185,6 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
     return { id: entity.id, url: entityUrl };
 }
 
-/**
- * Recursively walk a directory, returning file paths (not directories).
- */
-async function walkDir(dir) {
-    const results = [];
-    const items = await readdir(dir);
-    for (const item of items) {
-        const full = join(dir, item);
-        const s = await stat(full);
-        if (s.isDirectory()) {
-            results.push(...await walkDir(full));
-        } else {
-            results.push(full);
-        }
-    }
-    return results;
-}
-
 function formatSize(bytes) {
     if (bytes < 1024) return `${bytes} B`;
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;

package/src/publish.js

@@ -0,0 +1,103 @@
+import { mkdtemp, mkdir, copyFile, rm, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileP = promisify(execFile);
+
+class PublishError extends Error {
+    constructor(status, body, url) {
+        super(`Marketplace publish failed: ${status}${body ? ` — ${body}` : ''}${url ? ` (${url})` : ''}`);
+        this.name = 'PublishError';
+        this.status = status;
+        this.body = body;
+        this.url = url;
+    }
+}
+
+export { PublishError };
+
+/**
+ * Stage the assembled files into a temp dir (preserving their library-relative
+ * layout) and tar.gz them. System `tar` keeps the archive format exactly what
+ * the server's node-tar expects; COPYFILE_DISABLE suppresses macOS AppleDouble
+ * (`._*`) junk from leaking into the archive.
+ *
+ * @param {Array<{abs: string, rel: string}>} files
+ * @returns {Promise<Buffer>}
+ */
+async function buildArchive(files) {
+    const stage = await mkdtemp(join(tmpdir(), 'informer-publish-'));
+    const archivePath = `${stage}.tgz`;
+    try {
+        for (const { abs, rel } of files) {
+            const dest = join(stage, rel);
+            await mkdir(dirname(dest), { recursive: true });
+            await copyFile(abs, dest);
+        }
+        await execFileP('tar', ['-czf', archivePath, '-C', stage, '.'], {
+            env: { ...process.env, COPYFILE_DISABLE: '1' }
+        });
+        return await readFile(archivePath);
+    } finally {
+        await rm(stage, { recursive: true, force: true });
+        await rm(archivePath, { force: true });
+    }
+}
+
+/**
+ * Publish an assembled app to the marketplace (License Manager `/packs/publish`).
+ *
+ * @param {Object} opts
+ * @param {string} opts.marketplaceUrl - base URL fronting the cloud-api
+ * @param {string} opts.token - vendor publish token (sent as Bearer)
+ * @param {Array<{abs: string, rel: string}>} opts.files - assembled app files
+ * @param {Object} opts.fields - publish metadata; non-string values are JSON-encoded
+ *   (the endpoint parses categories/requires/metadata as JSON strings)
+ * @param {{abs: string, filename: string}} [opts.icon] - optional listing icon
+ * @returns {Promise<Object>} the publish response
+ */
+export async function publish({ marketplaceUrl, token, files, fields, icon, screenshots = [] }) {
+    const archive = await buildArchive(files);
+
+    const form = new FormData();
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null || value === '') continue;
+        form.append(key, typeof value === 'string' ? value : JSON.stringify(value));
+    }
+    form.append(
+        'archive',
+        new Blob([archive], { type: 'application/gzip' }),
+        `${fields.slug}-${fields.version}.tgz`
+    );
+    if (icon) {
+        const iconBuffer = await readFile(icon.abs);
+        form.append('icon', new Blob([iconBuffer]), icon.filename);
+    }
+    // Listing screenshots — appended in order; the server records sortOrder by
+    // the order parts arrive.
+    for (const shot of screenshots) {
+        const buffer = await readFile(shot.abs);
+        form.append('screenshots', new Blob([buffer]), shot.filename);
+    }
+
+    const url = `${marketplaceUrl.replace(/\/+$/, '')}/packs/publish`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}` },
+        body: form
+    });
+
+    if (!res.ok) {
+        let body = '';
+        try {
+            body = await res.text();
+        } catch {
+            body = '';
+        }
+        throw new PublishError(res.status, body, url);
+    }
+
+    return await res.json();
+}