@karmaniverous/smoz 0.2.6 → 0.2.8

package/dist/cli/index.cjs

@@ -5,10 +5,10 @@ var fs = require('node:fs');
 var path = require('node:path');
 var commander = require('commander');
 var packageDirectory = require('package-directory');
-var node_url = require('node:url');
 var chokidar = require('chokidar');
 var node_child_process = require('node:child_process');
 var os = require('node:os');
+var node_url = require('node:url');
 var node_process = require('node:process');
 var promises = require('node:readline/promises');
 
@@ -348,10 +348,19 @@ const spawnOffline = (root, cmd, verbose) => {
         env: baseEnv,
     });
     const prefix = '[offline] ';
+    let announced = false;
     const emit = (buf) => {
         const text = buf.toString('utf8');
         if (verbose)
             process.stdout.write(prefix + text);
+        // Detect the actual listening URL and announce it once to avoid "0" confusion.
+        const m = text.match(/listening on (https?:\/\/(?:localhost|127\.0\.0\.1):\d+)/i);
+        const url = m?.[1];
+        if (url && !announced) {
+            announced = true;
+            // Print a concise, canonical URL line.
+            process.stdout.write(`[dev] offline: ${url}\n`);
+        }
     };
     const emitErr = (buf) => {
         const text = buf.toString('utf8');
@@ -533,6 +542,153 @@ const runRegister = async (root) => {
     return { wrote };
 };
 
+const inferDefaultStage = (root, verbose) => {
+    // Prefer “dev”; explicit --stage overrides remain available.
+    if (verbose)
+        console.log('[dev] inferring stage: dev (explicit --stage overrides)');
+    return 'dev';
+};
+const seedEnvForStage = async (root, stage, verbose) => {
+    // Best effort: import the app config to read declared env keys and concrete values.
+    // Preserve existing process.env values; only seed when unset.
+    try {
+        const appConfigUrl = node_url.pathToFileURL(path.resolve(root, 'app', 'config', 'app.config.ts')).href;
+        // Dynamically import the TS module under tsx
+        const mod = (await import(appConfigUrl));
+        const app = mod.app;
+        const stages = mod.stages;
+        const globalKeys = Array.isArray(app?.global?.envKeys)
+            ? app.global.envKeys
+            : [];
+        const stageKeys = Array.isArray(app?.stage?.envKeys)
+            ? app.stage.envKeys
+            : [];
+        const globalParams = (stages?.default).params ?? {};
+        const stageParams = (stages?.[stage]).params ?? {};
+        const seedPair = (key, from) => {
+            if (key in process.env)
+                return;
+            const val = from[key];
+            if (val === undefined)
+                return;
+            if (typeof val === 'string') {
+                process.env[key] = val;
+                if (verbose)
+                    console.log(`[dev] env: ${key}=${val}`);
+                return;
+            }
+            if (typeof val === 'number' || typeof val === 'boolean') {
+                const v = String(val);
+                process.env[key] = v;
+                if (verbose)
+                    console.log(`[dev] env: ${key}=${v}`);
+                return;
+            }
+            // Non-primitive; skip to avoid [object Object] surprise.
+            if (verbose)
+                console.log(`[dev] env: skip ${key} (non-primitive)`);
+        };
+        for (const k of globalKeys) {
+            if (typeof k === 'string') {
+                seedPair(k, globalParams);
+            }
+        }
+        for (const k of stageKeys) {
+            if (typeof k === 'string') {
+                seedPair(k, stageParams);
+            }
+        }
+        // Ensure STAGE itself is present as a last resort
+        if (!process.env.STAGE) {
+            process.env.STAGE = stage;
+            if (verbose)
+                console.log(`[dev] env: STAGE=${stage}`);
+        }
+    }
+    catch {
+        // Fallback: seed STAGE only
+        if (!process.env.STAGE) {
+            process.env.STAGE = stage;
+            if (verbose)
+                console.log(`[dev] env: STAGE=${stage}`);
+        }
+    }
+};
+
+const resolveTsxCommand = (root, tsEntry) => {
+    const localCli = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
+    if (fs.existsSync(localCli)) {
+        // Normalize to POSIX separators for cross-platform comparisons (tests)
+        const localCliPosix = localCli.split(path.sep).join('/');
+        return {
+            cmd: process.execPath,
+            args: [localCliPosix, tsEntry],
+            shell: false,
+        };
+    }
+    const probe = node_child_process.spawnSync(process.platform === 'win32' ? 'tsx.cmd' : 'tsx', ['--version'], { shell: true });
+    if (typeof probe.status === 'number' && probe.status === 0) {
+        return {
+            cmd: process.platform === 'win32' ? 'tsx.cmd' : 'tsx',
+            args: [tsEntry],
+            shell: true,
+        };
+    }
+    throw new Error('Inline requires tsx. Install it with "npm i -D tsx", or run "smoz dev -l offline".');
+};
+const resolveInlineEntry = (pkgRoot) => {
+    const compiled = path.resolve(pkgRoot, 'dist', 'mjs', 'cli', 'inline-server.js');
+    if (fs.existsSync(compiled))
+        return { entry: compiled, kind: 'compiled' };
+    const tsPath = path.resolve(pkgRoot, 'src', 'cli', 'local', 'inline.server', 'index.ts');
+    return { entry: tsPath, kind: 'ts' };
+};
+const launchInline = async (root, opts) => {
+    // Resolve the installed smoz package root robustly (works from compiled CLI and tsx ESM):
+    // Prefer __dirname when available (CJS), otherwise derive from import.meta.url (ESM).
+    const here = typeof __dirname === 'string'
+        ? __dirname
+        : path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+    const pkgRoot = packageDirectory.packageDirectorySync({ cwd: here }) ?? process.cwd();
+    const { entry } = resolveInlineEntry(pkgRoot);
+    const makeTsx = () => {
+        const { cmd, args, shell } = resolveTsxCommand(root, entry);
+        return node_child_process.spawn(cmd, args, {
+            cwd: root,
+            stdio: 'inherit',
+            shell,
+            // Enable tsconfig paths for "@/..." during TS fallback.
+            env: {
+                ...process.env,
+                TSX_TSCONFIG_PATHS: '1',
+                SMOZ_STAGE: opts.stage,
+                SMOZ_PORT: String(opts.port),
+                SMOZ_VERBOSE: opts.verbose ? '1' : '',
+            },
+        });
+    };
+    let child = makeTsx();
+    const close = async () => new Promise((resolve) => {
+        // If the process has already exited (exitCode set), resolve immediately.
+        if (child.exitCode !== null) {
+            resolve();
+            return;
+        }
+        child.once('exit', () => {
+            resolve();
+        });
+        child.kill('SIGTERM');
+        setTimeout(() => {
+            resolve();
+        }, 1500);
+    });
+    const restart = async () => {
+        await close();
+        child = makeTsx();
+    };
+    return { close, restart };
+};
+
 const runDev = async (root, opts) => {
     const verbose = !!opts.verbose;
     const stage = typeof opts.stage === 'string'
@@ -547,7 +703,7 @@ const runDev = async (root, opts) => {
             console.warn('[dev] env seeding warning:', e.message);
     }
     const modeInitial = opts.local;
-    let mode = modeInitial;
+    const mode = modeInitial;
     const port = typeof opts.port === 'number' ? opts.port : 0;
     if (verbose) {
         console.log(`[dev] options: register=${String(opts.register)} ` +
@@ -633,16 +789,8 @@ const runDev = async (root, opts) => {
         offline = await launchOffline(root, { stage, port, verbose });
     }
     else if (mode === 'inline') {
-        try {
-            inlineChild = await launchInline(root, { stage, port, verbose });
-        }
-        catch (e) {
-            const msg = e.message;
-            console.warn('[dev] inline unavailable:', msg);
-            console.warn('[dev] Falling back to serverless-offline.');
-            mode = 'offline';
-            offline = await launchOffline(root, { stage, port, verbose });
-        }
+        // Hard error on failure; no fallback to offline.
+        inlineChild = await launchInline(root, { stage, port, verbose });
     }
     // Watch sources
     const globs = [
@@ -677,154 +825,6 @@ const runDev = async (root, opts) => {
         });
     });
 };
-const inferDefaultStage = (root, verbose) => {
-    // Prefer “dev”; if app.config.ts is available and we can inspect it cheaply later, expand behavior.
-    // For now, return 'dev' (explicit selection via --stage remains available).
-    if (verbose)
-        console.log('[dev] inferring stage: dev (explicit --stage overrides)');
-    return 'dev';
-};
-const seedEnvForStage = async (root, stage, verbose) => {
-    // Best effort: import the app config to read declared env keys and concrete values.
-    // Preserve existing process.env values; only seed when unset.
-    try {
-        const appConfigUrl = node_url.pathToFileURL(path.resolve(root, 'app', 'config', 'app.config.ts')).href;
-        // Dynamically import the TS module under tsx
-        const mod = (await import(appConfigUrl));
-        const app = mod.app;
-        const stages = mod.stages;
-        const globalKeys = Array.isArray(app?.global?.envKeys)
-            ? app.global.envKeys
-            : [];
-        const stageKeys = Array.isArray(app?.stage?.envKeys)
-            ? app.stage.envKeys
-            : [];
-        const globalParams = (stages?.default).params ?? {};
-        const stageParams = (stages?.[stage]).params ?? {};
-        const seedPair = (key, from) => {
-            if (key in process.env)
-                return;
-            const val = from[key];
-            if (val === undefined)
-                return;
-            if (typeof val === 'string') {
-                process.env[key] = val;
-                if (verbose)
-                    console.log(`[dev] env: ${key}=${val}`);
-                return;
-            }
-            if (typeof val === 'number' || typeof val === 'boolean') {
-                const v = String(val);
-                process.env[key] = v;
-                if (verbose)
-                    console.log(`[dev] env: ${key}=${v}`);
-                return;
-            }
-            // Non-primitive; skip to avoid [object Object] surprise.
-            if (verbose)
-                console.log(`[dev] env: skip ${key} (non-primitive)`);
-        };
-        for (const k of globalKeys) {
-            if (typeof k === 'string') {
-                seedPair(k, globalParams);
-            }
-        }
-        for (const k of stageKeys) {
-            if (typeof k === 'string') {
-                seedPair(k, stageParams);
-            }
-        }
-        // Ensure STAGE itself is present as a last resort
-        if (!process.env.STAGE) {
-            process.env.STAGE = stage;
-            if (verbose)
-                console.log(`[dev] env: STAGE=${stage}`);
-        }
-    }
-    catch {
-        // Fallback: seed STAGE only
-        if (!process.env.STAGE) {
-            process.env.STAGE = stage;
-            if (verbose)
-                console.log(`[dev] env: STAGE=${stage}`);
-        }
-    }
-};
-// Inline local runner: spawn tsx to run a TS server script.
-const launchInline = async (root, opts) => {
-    const { spawn, spawnSync } = await import('node:child_process');
-    const path = await import('node:path');
-    const fs = await import('node:fs');
-    // Resolve packaged inline server from the project root so this works
-    // both when running the built CLI and via tsx on sources.
-    const entry = path.resolve(root, 'dist', 'mjs', 'cli', 'inline-server.js');
-    if (!fs.existsSync(entry)) {
-        throw new Error('inline server entry missing in package (dist/mjs/cli/inline-server.js)');
-    }
-    // Prefer project-local tsx; otherwise probe PATH for tsx availability
-    const tsxCli = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
-    let cmd;
-    let args;
-    let useShell = false;
-    let tsxAvailable = false;
-    if (fs.existsSync(tsxCli)) {
-        tsxAvailable = true;
-        cmd = process.execPath;
-        // Pass the TSX CLI script followed by our entry. On Windows, avoid
-        // putting unknown flags before the script to prevent Node from treating
-        // them as its own options. Enable tsconfig-paths via env only.
-        args = [tsxCli, entry];
-    }
-    else {
-        // Probe PATH: tsx --version
-        const probe = spawnSync(process.platform === 'win32' ? 'tsx.cmd' : 'tsx', ['--version'], { shell: true });
-        if (typeof probe.status === 'number' && probe.status === 0)
-            tsxAvailable = true;
-        cmd = process.platform === 'win32' ? 'tsx.cmd' : 'tsx';
-        // Invoke tsx from PATH with just the script entry; rely on
-        // TSX_TSCONFIG_PATHS=1 in the environment for path alias resolution.
-        args = [entry];
-        useShell = true;
-    }
-    if (!tsxAvailable) {
-        throw new Error('tsx not found (required for inline). Install "tsx" as a devDependency or use --local offline.');
-    }
-    const spawnChild = () => spawn(cmd, args, {
-        cwd: root,
-        stdio: 'inherit',
-        shell: useShell,
-        // Enable tsconfig paths resolution for "@/..." via environment;
-        // avoids passing CLI flags that can confuse Node on Windows.
-        // Keep additional SMOZ_* env for server configuration.
-        env: {
-            ...process.env,
-            TSX_TSCONFIG_PATHS: '1',
-            SMOZ_STAGE: opts.stage,
-            SMOZ_PORT: String(opts.port),
-            SMOZ_VERBOSE: opts.verbose ? '1' : '',
-        },
-    });
-    let child = spawnChild();
-    const close = async () => new Promise((resolve) => {
-        // If the process has already exited (exitCode set), resolve immediately.
-        if (child.exitCode !== null) {
-            resolve();
-            return;
-        }
-        child.once('exit', () => {
-            resolve();
-        });
-        child.kill('SIGTERM');
-        setTimeout(() => {
-            resolve();
-        }, 1500);
-    });
-    const restart = async () => {
-        await close();
-        child = spawnChild();
-    };
-    return { close, restart };
-};
 
 const writeIfAbsent = async (outFile, content) => {
     if (fs.existsSync(outFile))

package/package.json

@@ -181,5 +181,5 @@
     "templates:lint": "eslint --fix -c templates/default/eslint.config.ts \"templates/default/**/*.{ts,tsx,js,jsx}\" \"templates/default/eslint.config.ts\""
   },
   "type": "module",
-  "version": "0.2.6"
+  "version": "0.2.8"
 }