@entrinsik/vite-plugin-informer 2.7.0 → 2.11.0

package/src/deploy.js

@@ -1,5 +1,7 @@
 import { createClient } from './client.js';
 import { collectAppFiles } from './assemble.js';
+import { describeServer, planDeploy } from './compat.js';
+import { loadManifest } from './dev-dependencies.js';
 import { readFile } from 'node:fs/promises';
 import { basename, dirname } from 'node:path';
 
@@ -22,6 +24,20 @@ const CHUNK_THRESHOLD = 512 * 1024; // 512KB
  */
 export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, description, icon, id }) {
     const api = createClient({ baseUrl, apiKey, user, pass });
+    const projectRoot = dirname(distDir);
+
+    // 0. Assemble and version-check before touching the app. Both steps below
+    //    are destructive — the snapshot rotates and _clear empties the library —
+    //    so a missing dist/ or a refused version floor has to surface here,
+    //    while the deployed app is still whole.
+    const collected = await collectAppFiles({ distDir, projectRoot });
+    const server = await describeServer(api);
+    const plan = planDeploy({ server, files: collected, manifest: await loadManifest(projectRoot) });
+
+    for (const warning of plan.warnings) {
+        console.warn(`  ! ${warning}`);
+    }
+    if (plan.refusal) throw new Error(plan.refusal);
 
     let entity = null;
     let naturalId = null;
@@ -104,12 +120,14 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
     console.log('Clearing existing files...');
     await api.post(`${entityPath}/files/_clear`);
 
-    // 6. Upload the app-library file set: dist output at the library root, plus
-    //    informer.yaml / data-access.yaml and the server/tools/mcp/migrations/webhooks
-    //    source trees. Sourced from the shared collectAppFiles() so a deploy and a
-    //    marketplace publish package byte-identical contents.
+    // 6. Upload the app-library file set assembled in step 0: dist output at the
+    //    library root, plus informer.yaml / data-access.yaml and the
+    //    server/tools/mcp/migrations/webhooks/embeddings source trees, less any
+    //    tree this server is too old to keep out of browsers (see compat.js).
+    //    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) });
+    const files = plan.files;
 
     for (const { abs, rel } of files) {
         const content = await readFile(abs);
@@ -136,45 +154,9 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
         }
     }
 
-    // 12. Deploy: run migrations + scan/bundle server routes + webhooks + tools + agents
+    // 12. Deploy: run migrations + scan/bundle server routes + webhooks + embeddings + tools + agents
     if (apiPrefix === 'apps') {
-        try {
-            console.log('Deploying...');
-            const result = await api.post(`${entityPath}/_deploy`);
-            if (result) {
-                if (result.migrated && result.migrated.length > 0) {
-                    console.log(`  Ran ${result.migrated.length} migration(s): ${result.migrated.join(', ')}`);
-                }
-                if (result.routes && result.routes.length > 0) {
-                    console.log(`  Registered ${result.routes.length} server route(s):`);
-                    for (const r of result.routes) {
-                        console.log(`    ${r}`);
-                    }
-                }
-                if (result.webhooks && result.webhooks.length > 0) {
-                    console.log(`  Registered ${result.webhooks.length} webhook(s):`);
-                    for (const r of result.webhooks) {
-                        console.log(`    ${r}`);
-                    }
-                }
-                if (result.tools && result.tools.length > 0) {
-                    console.log(`  Registered ${result.tools.length} tool(s): ${result.tools.join(', ')}`);
-                }
-                if (result.mcpTools && result.mcpTools.length > 0) {
-                    console.log(`  Registered ${result.mcpTools.length} MCP tool(s): ${result.mcpTools.join(', ')}`);
-                }
-                if (result.agents && result.agents.length > 0) {
-                    console.log(`  Deployed ${result.agents.length} agent(s): ${result.agents.join(', ')}`);
-                }
-            }
-        } catch (err) {
-            if (err.status === 404) {
-                // Server may not support _deploy yet — ignore
-            } else {
-                const detail = err.body || err.message;
-                console.error(`  Deploy failed: ${detail}`);
-            }
-        }
+        await runServerDeploy(api, entityPath);
     }
 
     // 13. Print URL and return UUID for saving
@@ -188,6 +170,97 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
     return { id: entity.id, url: entityUrl };
 }
 
+/**
+ * POST `_deploy`: run migrations, scan/bundle server routes, webhooks, tools and
+ * agents, and claim the app as platform-managed.
+ *
+ * Exported for its own tests. This is the step whose failure modes are silent —
+ * everything it does is invisible in the CLI output when it doesn't happen.
+ *
+ * @param {{post: (path: string, body?: unknown) => Promise<unknown>}} api
+ * @param {string} entityPath e.g. `apps/my-app`
+ */
+export async function runServerDeploy(api, entityPath) {
+    try {
+        console.log('Deploying...');
+        // `managed: true` claims the app as platform-managed (origin
+        // 'deployed'), which locks builder editing so a UI edit can't drift
+        // from this project. Opt-in: the server leaves an app editable when the
+        // flag is absent, so the GO admin panel's Redeploy and the builder's
+        // Save can share this route without converting user-built apps. See
+        // app/routes/deploy.js.
+        const result = await api.post(`${entityPath}/_deploy`, { managed: true });
+        if (result === null) {
+            // api.post turns a 404 into null instead of throwing, so this is the
+            // only place it can be caught. Files uploaded, but migrations, server
+            // routes, webhooks and the managed claim did NOT run — and a missing
+            // route is far more often a wrong app id or a proxy path rewrite than
+            // a server too old to have _deploy. Falling through here prints
+            // "Published ..." and exits 0 on a half-finished deploy.
+            throw new Error(
+                `Deploy endpoint not found at ${entityPath}/_deploy. The app may not exist on this server, `
+                + `the path may be rewritten by a proxy, or the server may predate _deploy. `
+                + `Files were uploaded, but migrations, server routes and the managed claim did not run.`
+            );
+        }
+        if (result.migrated && result.migrated.length > 0) {
+            console.log(`  Ran ${result.migrated.length} migration(s): ${result.migrated.join(', ')}`);
+        }
+        if (result.routes && result.routes.length > 0) {
+            console.log(`  Registered ${result.routes.length} server route(s):`);
+            for (const r of result.routes) {
+                console.log(`    ${r}`);
+            }
+        }
+        if (result.webhooks && result.webhooks.length > 0) {
+            console.log(`  Registered ${result.webhooks.length} webhook(s):`);
+            for (const r of result.webhooks) {
+                console.log(`    ${r}`);
+            }
+        }
+        if (result.channelHandlers && result.channelHandlers.length > 0) {
+            console.log(`  Registered ${result.channelHandlers.length} channel handler(s):`);
+            for (const c of result.channelHandlers) {
+                console.log(`    ${c}`);
+            }
+        }
+        if (result.channels && result.channels.length > 0) {
+            console.log(`  Relaying events to ${result.channels.length} channel(s): ${result.channels.join(', ')}`);
+        }
+        if (result.tools && result.tools.length > 0) {
+            console.log(`  Registered ${result.tools.length} tool(s): ${result.tools.join(', ')}`);
+        }
+        if (result.mcpTools && result.mcpTools.length > 0) {
+            console.log(`  Registered ${result.mcpTools.length} MCP tool(s): ${result.mcpTools.join(', ')}`);
+        }
+        if (result.agents && result.agents.length > 0) {
+            console.log(`  Deployed ${result.agents.length} agent(s): ${result.agents.join(', ')}`);
+        }
+        // Advisory findings the server accumulated. The deploy still
+        // succeeded — but silently dropping these leaves authors debugging
+        // mystery responses the server already diagnosed for them.
+        if (result.routeShadowWarnings && result.routeShadowWarnings.length > 0) {
+            console.warn(`  ⚠ ${result.routeShadowWarnings.length} route shadow warning(s):`);
+            for (const w of result.routeShadowWarnings) {
+                console.warn(`    ${w}`);
+            }
+        }
+        if (result.partialFailures && result.partialFailures.length > 0) {
+            console.warn(`  ⚠ ${result.partialFailures.length} non-fatal deploy phase failure(s):`);
+            for (const f of result.partialFailures) {
+                console.warn(`    [${f.phase}] ${f.error}`);
+            }
+        }
+        return result;
+    } catch (err) {
+        // Rethrow: a failed deploy is a failed publish. Logging and falling
+        // through prints "Published ... files" and exits 0, so CI goes green on
+        // an app whose migrations never ran. bin/deploy.js turns this into exit 1.
+        const detail = err.body || err.message;
+        throw new Error(`Deploy failed: ${detail}`);
+    }
+}
+
 function formatSize(bytes) {
     if (bytes < 1024) return `${bytes} B`;
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;

package/src/dev-bag.js

@@ -0,0 +1,185 @@
+import { loadManifest, manifestBlock, buildDevContext, buildDevCrypto, buildDevMessaging, normalizeFetchPath } from './dev-dependencies.js';
+import { createDevChannels, createDevEmit } from './dev-channels.js';
+import { devPlatform } from './dev-platform.js';
+
+/**
+ * The part of the dev handler bag every surface shares — `server/` routes and
+ * `channels/` handlers alike: the platform services (`query`, `fetch`, the
+ * typed dependency `context`, `emit`, `broadcast`, `notify`, `email`,
+ * `crypto`, `markdown`, `log`, `env`, `platform`). Each surface adds only its
+ * own inbound members (`request` + `respond` for HTTP, `channel` + `payload`
+ * for channels), the same split the prod sandbox's buildInvokeScript makes.
+ */
+
+// embed() is present on a real install even without the embeddings
+// capability, where it throws a written explanation. Mirroring that here
+// keeps the dev failure the same lesson as the deployed one, instead of a
+// bare "embed is not a function" that reads like a missing binding.
+export const embed = async () => {
+    throw new Error('embed() is not available in the dev mirror: the embeddings capability needs a real Informer (platform.capabilities.embeddings is false)');
+};
+
+// Cap dev proxy calls at 30s so a hung upstream fails loudly instead of
+// hanging the handler.
+const FETCH_TIMEOUT_MS = 30000;
+
+/** log(message, data) + log.debug/info/warn/error — the sandbox log surface, to the terminal. */
+export function buildDevLog(prefix = '[app-log]') {
+    const logCall = (level, message, data) => {
+        const msg = typeof message === 'string' ? message : JSON.stringify(message);
+        const args = [`${prefix} [${level}] ${msg}`];
+        if (data) args.push(data);
+        console.log(...args);
+    };
+    return Object.assign(
+        (message, data) => logCall('info', message, data),
+        {
+            debug: (message, data) => logCall('debug', message, data),
+            info: (message, data) => logCall('info', message, data),
+            warn: (message, data) => logCall('warn', message, data),
+            error: (message, data) => logCall('error', message, data)
+        }
+    );
+}
+
+/** The viewer identity dev handlers see — the same object the page gets as window.__INFORMER__.user. */
+export function buildDevUser(user) {
+    return {
+        username: (user && user.username) || 'dev',
+        displayName: (user && user.displayName) || 'Local Developer',
+        email: (user && user.email) || null,
+        timezone: (user && user.timezone) || null
+    };
+}
+
+/**
+ * Build the shared services once per dev server and the per-invocation bag
+ * on demand.
+ *
+ * @param {Object} opts
+ * @param {string} opts.serverOrigin - Informer server origin
+ * @param {string} opts.authHeader - Basic or Bearer auth header for /api calls
+ * @param {string|null} opts.devWorkspaceId - workspace datasource id for query()
+ * @param {string} opts.projectRoot - app project root
+ * @param {Object} [opts.devBindings] - dev bindings for `target: app` / `target: pack` deps
+ * @param {string|null} [opts.appToken] - INFORMER_APP_TOKEN for cross-app request()
+ * @param {ReturnType<typeof createDevChannels>} [opts.channels] - the dev channels hub
+ * @param {string} [opts.logPrefix] - prefix for notify/email/emit console lines
+ * @returns {{ query: Function, apiFetch: Function, build: () => Promise<{ manifest: Object, bag: Object }> }}
+ */
+export function createDevBagBuilder({ serverOrigin, authHeader, devWorkspaceId, projectRoot, devBindings = {}, appToken = null, channels = createDevChannels(), logPrefix = '[app]' }) {
+    // query() implementation — proxies to the workspace _sql endpoint
+    async function query(sql, params) {
+        if (!devWorkspaceId) {
+            throw new Error('query() requires INFORMER_DEV_WORKSPACE. Run: npx informer-workspace init');
+        }
+
+        const resp = await globalThis.fetch(`${serverOrigin}/api/datasources/${devWorkspaceId}/_sql`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: authHeader },
+            body: JSON.stringify({ sql, params: params || [] })
+        });
+
+        if (!resp.ok) {
+            const err = await resp.json().catch(() => ({}));
+            const detail = err.message || resp.statusText;
+            throw new Error(`query() failed: ${resp.status} ${detail} (${serverOrigin}/api/datasources/${devWorkspaceId}/_sql)`);
+        }
+
+        const data = await resp.json();
+        return data.rows;
+    }
+
+    // fetch() implementation — proxies API calls to the Informer server
+    async function fetchAs(auth, path, opts = {}) {
+        const method = (opts.method || 'GET').toUpperCase();
+        // Same strict canonicalization as prod (app-sandbox.js normalizeFetchPath);
+        // reject non-canonical shapes here instead of silently accepting them.
+        const apiPath = normalizeFetchPath(path);
+        if (!apiPath) {
+            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: auth, 'Content-Type': 'application/json', ...(opts.headers || {}) }
+        };
+
+        if (opts.body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
+            fetchOpts.body = JSON.stringify(opts.body);
+        }
+
+        // Read the stream exactly once — `.json()` consumes/locks the body, so a
+        // `.text()` fallback would throw "Body is unusable" on any non-JSON
+        // response (auth-bounce HTML, proxy error page). Parse in memory
+        // instead — same as prod's unwrapInject.
+        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) {
+            // Transport failure or timeout — fetch throws (TypeError 'fetch failed'
+            // with the real reason on err.cause, or a TimeoutError). Return a
+            // synthetic 502 so the dependency layer names it (dep + url + cause)
+            // rather than a bare unhandled "fetch failed".
+            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 = JSON.parse(text); } catch { body = text; }
+        return { status, body, contentType };
+    }
+
+    async function apiFetch(path, opts = {}) {
+        return await fetchAs(authHeader, path, opts);
+    }
+
+    // Cross-app request() targets /api/apps/<id>/view/_/<path>, whose auth accepts
+    // only the token/session strategies — NOT basic auth. In API-key mode the
+    // INFORMER_API_KEY Bearer already satisfies that, so reuse it; under basic
+    // auth a separate API token (INFORMER_APP_TOKEN) is required, and without one
+    // the app proxy's request() throws a pointed error instead of a bare 401.
+    // appFetch also stamps x-informer-app-depth:1 so the target runs one hop deep
+    // and enforces the same one-hop guard it does in production.
+    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;
+
+    // notify/email — delivery is a console-logged no-op in dev, but the
+    // required-field validation mirrors prod so an app that passes here
+    // won't 500 in production.
+    const { notify, email } = buildDevMessaging(logPrefix);
+    const log = buildDevLog();
+    // markdown helper — passthrough in dev (production uses `marked`)
+    const markdown = (text) => text;
+
+    /**
+     * The shared bag for one invocation. The manifest is parsed per call
+     * (deps, env and channels all come from that one read) so edits to
+     * informer.yaml take effect without a dev-server restart.
+     */
+    async function build() {
+        const manifest = await loadManifest(projectRoot);
+        const deps = manifestBlock(manifest, 'dependencies');
+        const context = buildDevContext({ deps, apiFetch, devBindings, appFetch });
+        const env = manifestBlock(manifest, 'env');
+
+        // emit() writes no app_event row in dev, but still relays a listed
+        // event to its `channels:` channel; broadcast() publishes a live
+        // frame to the page (see dev-channels.js).
+        const emit = createDevEmit({ channels, manifestChannels: manifestBlock(manifest, 'channels'), logPrefix: '[app-event]' });
+        const { broadcast } = channels;
+
+        return {
+            manifest,
+            bag: { context, query, fetch: apiFetch, emit, broadcast, notify, email, embed, crypto: buildDevCrypto(), markdown, log, env, platform: devPlatform() }
+        };
+    }
+
+    return { query, apiFetch, build };
+}