@entrinsik/vite-plugin-informer 2.3.0 → 2.4.0

package/bin/deploy.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
-import dotenv from 'dotenv';
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { deploy } from '../src/deploy.js';
+import { loadEnv, parseModeArg } from '../src/env.js';
 
-dotenv.config();
+const mode = parseModeArg(process.argv);
+loadEnv({ mode });
 
 const baseUrl = process.env.INFORMER_URL;
 const apiKey = process.env.INFORMER_API_KEY;

package/bin/workspace.js

@@ -1,22 +1,28 @@
 #!/usr/bin/env node
 
-import dotenv from 'dotenv';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { createClient } from '../src/client.js';
+import { loadEnv, envWritePath, parseModeArg } from '../src/env.js';
 import { init, migrate, reset } from '../src/workspace.js';
 
-dotenv.config();
+const mode = parseModeArg(process.argv);
+loadEnv({ mode });
 
-const command = process.argv[2];
+// Strip --mode <value> from argv before parsing the command
+const args = process.argv.slice(2).filter((arg, i, arr) => arg !== '--mode' && arr[i - 1] !== '--mode');
+const command = args[0];
 
 if (!command || !['init', 'migrate', 'reset'].includes(command)) {
-    console.error('Usage: informer-workspace <init|migrate|reset>');
+    console.error('Usage: informer-workspace <init|migrate|reset> [--mode <name>]');
     console.error('');
     console.error('Commands:');
     console.error('  init      Create a dev workspace datasource and run migrations');
     console.error('  migrate   Run pending migrations against the dev workspace');
     console.error('  reset     Drop all tables and re-run all migrations');
+    console.error('');
+    console.error('Options:');
+    console.error('  --mode <name>  Load .env.<name> (e.g. --mode test, --mode production)');
     process.exit(1);
 }
 
@@ -33,7 +39,7 @@ if (!baseUrl || (!apiKey && (!user || !pass))) {
 
 const api = createClient({ baseUrl, apiKey, user, pass });
 const migrationsDir = resolve('migrations');
-const envPath = resolve('.env');
+const envPath = envWritePath({ mode });
 
 try {
     if (command === 'init') {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@entrinsik/vite-plugin-informer",
-    "version": "2.3.0",
+    "version": "2.4.0",
     "description": "Vite plugin and deploy tool for Informer App development",
     "repository": {
         "type": "git",

package/src/agent-dev.js

@@ -1,3 +1,4 @@
+import { createHmac } from 'node:crypto';
 import { readFile, readdir, stat, access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parse as parseUrl } from 'node:url';
@@ -192,6 +193,33 @@ export function createAgentMiddleware(viteServer, { serverOrigin, authHeader, de
         return { ok: true };
     }
 
+    // crypto helper — mirrors the sandbox's crypto.hmac()
+    const cryptoHelper = {
+        hmac(algorithm, key, data, encoding) {
+            return createHmac(algorithm, key).update(data).digest(encoding || 'hex');
+        }
+    };
+
+    // log helper — mirrors sandbox log(message, data) + log.info/warn/error/debug
+    const logCall = (level, message, data) => {
+        const msg = typeof message === 'string' ? message : JSON.stringify(message);
+        const args = [`[app-log] [${level}] ${msg}`];
+        if (data) args.push(data);
+        console.log(...args);
+    };
+    const log = 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)
+        }
+    );
+
+    // markdown helper — passthrough in dev (production uses `marked`)
+    const markdown = (text) => text;
+
     return async function agentDevMiddleware(req, res, next) {
         try {
             const parsed = parseUrl(req.url, true);
@@ -366,7 +394,7 @@ export function createAgentMiddleware(viteServer, { serverOrigin, authHeader, de
 
                         if (tool) {
                             try {
-                                result = await tool.handler(tc.input, { query, fetch: apiFetch, emit, context: triggerEvent });
+                                result = await tool.handler(tc.input, { query, fetch: apiFetch, emit, crypto: cryptoHelper, markdown, log, context: triggerEvent });
                             } catch (err) {
                                 console.error(`[agent-dev] Tool "${tc.name}" failed:`, err.message);
                                 result = { error: err.message };

package/src/env.js

@@ -0,0 +1,86 @@
+import dotenv from 'dotenv';
+import { existsSync } from 'node:fs';
+import { resolve, dirname, parse as parsePath } from 'node:path';
+
+/**
+ * Build an ordered list of .env file paths for dotenv to load.
+ *
+ * Priority (first match wins in dotenv):
+ *   1. <cwd>/.env.<mode>   (mode-specific, e.g. .env.test)
+ *   2. <cwd>/.env          (local defaults)
+ *   3. <parent>/.env.<mode> (walk up for monorepo shared config)
+ *   4. <parent>/.env
+ *   ... continues up to first parent that contains a .env file
+ *
+ * When mode is 'development' (Vite default), mode-specific files are skipped
+ * since .env already serves that purpose.
+ *
+ * @param {{ mode?: string, cwd?: string }} options
+ * @returns {string[]} Ordered file paths (may include non-existent files — dotenv ignores those)
+ */
+export function buildEnvPaths({ mode, cwd } = {}) {
+    const dir = cwd || process.cwd();
+    const useMode = mode && mode !== 'development';
+
+    // Local project .env files (highest priority)
+    const paths = [];
+    if (useMode) paths.push(resolve(dir, `.env.${mode}`));
+    paths.push(resolve(dir, '.env'));
+
+    // Walk up to parent directories for monorepo fallback
+    let current = dirname(dir);
+    const { root } = parsePath(dir);
+
+    while (current !== root) {
+        if (useMode) paths.push(resolve(current, `.env.${mode}`));
+        paths.push(resolve(current, '.env'));
+
+        // Stop at the first ancestor that has any .env file
+        const hasEnv = useMode
+            ? existsSync(resolve(current, `.env.${mode}`)) || existsSync(resolve(current, '.env'))
+            : existsSync(resolve(current, '.env'));
+
+        if (hasEnv) break;
+
+        current = dirname(current);
+    }
+
+    return paths;
+}
+
+/**
+ * Load environment variables using mode-aware, parent-walking dotenv paths.
+ *
+ * @param {{ mode?: string, cwd?: string }} options
+ */
+export function loadEnv({ mode, cwd } = {}) {
+    const paths = buildEnvPaths({ mode, cwd });
+    dotenv.config({ path: paths });
+}
+
+/**
+ * Determine the .env file path to write workspace IDs into.
+ * Writes to .env.<mode> when a non-default mode is active, otherwise .env.
+ *
+ * @param {{ mode?: string, cwd?: string }} options
+ * @returns {string}
+ */
+export function envWritePath({ mode, cwd } = {}) {
+    const dir = cwd || process.cwd();
+    const useMode = mode && mode !== 'development';
+    return resolve(dir, useMode ? `.env.${mode}` : '.env');
+}
+
+/**
+ * Parse --mode <name> from a process.argv array.
+ *
+ * @param {string[]} argv
+ * @returns {string|null}
+ */
+export function parseModeArg(argv) {
+    const idx = argv.indexOf('--mode');
+    if (idx !== -1 && idx + 1 < argv.length) {
+        return argv[idx + 1];
+    }
+    return null;
+}

package/src/index.js

@@ -1,8 +1,8 @@
-import dotenv from 'dotenv';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { createClient } from './client.js';
+import { loadEnv, envWritePath } from './env.js';
 import { createMiddleware as createServerRoutes } from './server-routes.js';
 import { createAgentMiddleware } from './agent-dev.js';
 import { init, migrate } from './workspace.js';
@@ -23,12 +23,14 @@ export default function informer(options = {}) {
     let authHeader = null;
     let serverOrigin = null;
     let devWorkspaceId = null;
+    let activeMode = null;
 
     return {
         name: 'vite-plugin-informer',
 
-        config(_, { command }) {
-            dotenv.config();
+        config(_, { command, mode }) {
+            activeMode = mode;
+            loadEnv({ mode });
 
             isDev = command === 'serve';
 
@@ -57,7 +59,8 @@ export default function informer(options = {}) {
                                 changeOrigin: true,
                                 headers: {
                                     Authorization: authHeader
-                                }
+                                },
+                                ...options.proxy
                             }
                         }
                     };
@@ -106,7 +109,7 @@ export default function informer(options = {}) {
                             api,
                             slug,
                             migrationsDir,
-                            envPath: resolve(projectRoot, '.env')
+                            envPath: envWritePath({ mode: activeMode })
                         });
                         devWorkspaceId = result.workspaceId;
                     }

package/src/server-routes.js

@@ -237,6 +237,32 @@ export function createMiddleware(viteServer, { serverOrigin, authHeader, devWork
                 }
             };
 
+            // log helper — mirrors sandbox log(message, data) + log.info/warn/error/debug
+            const logCall = (level, message, data) => {
+                const msg = typeof message === 'string' ? message : JSON.stringify(message);
+                const args = [`[app-log] [${level}] ${msg}`];
+                if (data) args.push(data);
+                console.log(...args);
+            };
+            const log = 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)
+                }
+            );
+
+            // markdown helper — passthrough in dev (production uses `marked`)
+            const markdown = (text) => text;
+
+            // emit helper — no-op in dev (logs to console)
+            const emit = (event, payload) => {
+                console.log(`[app-event] emit("${event}",`, JSON.stringify(payload), ')');
+                return { ok: true };
+            };
+
             // Build request context
             const request = {
                 method: req.method.toUpperCase(),
@@ -266,7 +292,7 @@ export function createMiddleware(viteServer, { serverOrigin, authHeader, devWork
             }
 
             // Call handler
-            const result = await handler({ query, fetch: apiFetch, respond, crypto: cryptoHelper, env: {}, request });
+            const result = await handler({ query, fetch: apiFetch, respond, emit, crypto: cryptoHelper, markdown, log, env: {}, request });
 
             // If respond() was already called, the response is already sent
             if (responded) return;

package/src/workspace.js

@@ -1,5 +1,5 @@
 import { readdir, readFile, writeFile, access } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, basename } from 'node:path';
 
 /**
  * Execute raw SQL against a workspace datasource via the _sql route.
@@ -122,7 +122,7 @@ export async function init({ api, slug, migrationsDir, envPath }) {
     }
 
     await writeFile(envPath, envContent);
-    console.log(`Saved INFORMER_DEV_WORKSPACE=${workspaceId} to .env`);
+    console.log(`Saved INFORMER_DEV_WORKSPACE=${workspaceId} to ${basename(envPath)}`);
 
     return { workspaceId, ...result };
 }