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

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/index.d.ts

@@ -1,2 +1,26 @@
 import type { Plugin } from 'vite';
-export default function informer(): Plugin;
+
+/**
+ * Dev-only binding for a `target: app` dependency slot. Points `request()` at
+ * the target app in dev; overrides the manifest `defaultBinding` when both are
+ * present.
+ *
+ * - `app` — the target app (`owner:slug` or UUID). Powers `request()`.
+ *
+ * A bare string is shorthand for `{ app }`.
+ */
+export interface AppDevBinding {
+    app?: string;
+}
+
+export interface InformerPluginOptions {
+    mock?: {
+        report?: { id?: string; name?: string };
+        theme?: 'light' | 'dark';
+        roles?: string[];
+    };
+    devBindings?: Record<string, string | AppDevBinding>;
+    proxy?: Record<string, unknown>;
+}
+
+export default function informer(options?: InformerPluginOptions): Plugin;

package/package.json

@@ -1,15 +1,15 @@
 {
     "name": "@entrinsik/vite-plugin-informer",
-    "version": "2.5.0",
+    "version": "2.6.0-beta.1",
     "description": "Vite plugin and deploy tool for Informer App development",
+    "scripts": {
+        "test": "node --test"
+    },
     "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 +24,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/agent-dev.js

@@ -7,6 +7,10 @@ const parseYaml = yaml.parse;
 
 const MAX_STEPS = 20;
 
+// Cap dev proxy calls at 30s so a hung upstream fails loudly. (The AI _chat
+// stream below uses its own fetch.)
+const FETCH_TIMEOUT_MS = 30000;
+
 /**
  * Read and parse informer.yaml from the project root.
  *
@@ -145,7 +149,7 @@ async function readSSE(response) {
  * @param {Object} opts - Configuration
  * @returns {Function} Connect middleware
  */
-export function createAgentMiddleware(viteServer, { serverOrigin, authHeader, devWorkspaceId, projectRoot }) {
+export function createAgentMiddleware(viteServer, { serverOrigin, authHeader, devWorkspaceId, projectRoot, devBindings, appToken }) {
 
     // query() — proxies to the workspace _sql endpoint (same as server-routes.js)
     async function query(sql, params) {
@@ -169,29 +173,57 @@ export function createAgentMiddleware(viteServer, { serverOrigin, authHeader, de
     }
 
     // fetch() — proxies API calls to the Informer server (same as server-routes.js)
-    async function apiFetch(path, opts = {}) {
+    async function fetchAs(auth, path, opts = {}) {
         const method = (opts.method || 'GET').toUpperCase();
         // Same strict canonicalization as prod (app-sandbox.js normalizeFetchPath).
         const apiPath = normalizeFetchPath(path);
         if (!apiPath) {
-            return { status: 400, body: { error: `Invalid fetch path: ${String(path).slice(0, 80)}` } };
+            return { status: 400, body: { error: `Invalid fetch path: ${String(path).slice(0, 80)}` }, contentType: 'application/json' };
         }
         const url = `${serverOrigin}${apiPath}`;
         const fetchOpts = {
             method,
-            headers: { Authorization: authHeader, 'Content-Type': 'application/json' }
+            headers: { Authorization: auth, 'Content-Type': 'application/json', ...(opts.headers || {}) }
         };
 
-        if (opts.body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+        if (opts.body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
             fetchOpts.body = JSON.stringify(opts.body);
         }
 
-        const resp = await globalThis.fetch(url, fetchOpts);
+        // Read the stream once — `.json()` consumes it, so a `.text()` fallback
+        // would throw "Body is unusable" on any non-JSON response. Transport
+        // failure/timeout → synthetic 502 so the dep layer names it. See server-routes.js.
+        let status, contentType, text;
+        try {
+            const resp = await globalThis.fetch(url, { ...fetchOpts, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+            status = resp.status;
+            contentType = resp.headers.get('content-type') || '';
+            text = await resp.text();
+        } catch (err) {
+            const reason = (err.cause && err.cause.message) || err.message;
+            return { status: 502, body: { message: `fetch to ${url} failed: ${reason}` }, contentType: 'application/json' };
+        }
         let body;
-        try { body = await resp.json(); } catch { body = await resp.text(); }
-        return { status: resp.status, body };
+        try { body = JSON.parse(text); } catch { body = text; }
+        return { status, body, contentType };
     }
 
+    async function apiFetch(path, opts = {}) {
+        return await fetchAs(authHeader, path, opts);
+    }
+
+    // Cross-app request() hits the target's /view/_/ dispatch, which accepts only
+    // the token/session strategies — not basic auth. In API-key mode the
+    // INFORMER_API_KEY Bearer is reused; under basic auth INFORMER_APP_TOKEN is
+    // required. appFetch stamps x-informer-app-depth:1 for the one-hop guard.
+    // See server-routes.js.
+    const appAuth = appToken
+        ? `Bearer ${appToken}`
+        : (authHeader && authHeader.startsWith('Bearer ') ? authHeader : null);
+    const appFetch = appAuth
+        ? async (path, opts = {}) => await fetchAs(appAuth, path, { ...opts, headers: { ...(opts.headers || {}), 'x-informer-app-depth': '1' } })
+        : null;
+
     // emit() — no-op in dev mode (logs to console)
     function emit(event, payload) {
         console.log(`[agent-dev] emit("${event}",`, JSON.stringify(payload), ')');
@@ -287,7 +319,7 @@ export function createAgentMiddleware(viteServer, { serverOrigin, authHeader, de
                 // `context.<slot>.<method>(...)` and `env` work locally and match
                 // the prod sandbox bag.
                 const deps = await loadDependencies(projectRoot);
-                const context = buildDevContext({ deps, apiFetch });
+                const context = buildDevContext({ deps, apiFetch, devBindings, appFetch });
                 const env = await loadAppEnv(projectRoot);
 
                 // Load tool handlers via ssrLoadModule

package/src/assemble.js

@@ -0,0 +1,96 @@
+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', 'lib', 'shared'];
+
+// Entries never worth shipping in an app's server-side library: OS/editor
+// dotfiles (.DS_Store, .env), nested dependency trees, and test files. Applied
+// only to the source-tree dirs (lib/, shared/, etc.) — which use generic names
+// and are walked raw from the project root — not to the Vite dist/ output,
+// where a dot-directory (e.g. .well-known/) can be a real asset.
+const isExcludedSourceEntry = (name) =>
+    name === 'node_modules' || name.startsWith('.') || name.endsWith('.test.js');
+
+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, exclude) {
+    const results = [];
+    const items = await readdir(dir);
+    for (const item of items) {
+        if (exclude && exclude(item)) continue;
+        const full = join(dir, item);
+        const s = await stat(full);
+        if (s.isDirectory()) {
+            results.push(...await walkDir(full, exclude));
+        } 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/…, lib/…, shared/…)
+    for (const dir of SOURCE_DIRS) {
+        const root = join(projectRoot, dir);
+        if (!await exists(root)) continue;
+        for (const abs of await walkDir(root, isExcludedSourceEntry)) {
+            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`;