@tantawowa/hosanna-tools 3.7.8 → 3.9.0

package/README.md

@@ -189,7 +189,7 @@ Hosanna Tools is a comprehensive CLI toolset for the Hosanna framework that prov
 The CLI commands are organized into logical groups using colon-separated namespacing:
 
 ### Development Commands
-- `run` - Canonical cross-platform app launcher. Requires `--platform` and supports web, Roku, iOS, Apple TV, Android, and Android TV launch targets.
+- `run` - Canonical cross-platform app launcher. Bare interactive runs show one destination picker; explicit platform options support web, Roku, iOS, Apple TV, Android, and Android TV launch targets.
 - `target:list` - List launch targets for humans or agents, including web emulators, sims, and physical devices.
 - `dev:start` - Run dev processes: vite, generator watch, and optional debugger
 - `debugger:start` - Start the command debugger WebSocket proxy (only one debugger is needed for multiple apps; if the port is already in use, a friendly message is shown instead of crashing)
@@ -197,6 +197,8 @@ The CLI commands are organized into logical groups using colon-separated namespa
 Examples:
 
 ```bash
+hst run
+hst run --last
 hst run --platform web
 hst run --platform roku --target emulator
 hst run --platform ios --target emulator
@@ -218,7 +220,9 @@ hst target:list --platform apple-tv --target sim --json
 hst target:list --form-factor tv --json
 ```
 
-`hst run` is platform-explicit by design, so non-interactive agents do not guess between iOS, Apple TV, Android, Android TV, Roku, or web. `--target emulator` starts or reuses the shared Vite/debugger dev services for any platform and opens a profiled DOM runtime URL for interactive runs; use `--device <preset-id>` to override defaults such as `iphone-15`, `pixel-8`, `apple-tv-4k`, `android-tv-1080p`, or `rokufhd`, and use `--no-open` for server-only launches. `--target sim` launches the vendor virtual device for platforms that have one: Apple Simulator for iOS and Apple TV, Android Emulator for Android and Android TV. `--target device` launches or deploys to physical local hardware. `web` and `browser` remain accepted aliases for the web emulator; `simulator` and `simulated` remain accepted aliases for `sim`; `emulated` remains an accepted alias for the web emulator. Device/sim runs record the target and refuse to overwrite a recorded session or safe-to-kill occupied resource in non-interactive mode unless `--replace` is passed. Preferred run defaults live in `.hosanna-tools/run.json`, and preferred devices live in `.hosanna-tools/devices.json` or `~/.hosanna-tools/devices.json`. Legacy `.hs-devices.json` files are still read for compatibility.
+Bare `hst run` in an interactive terminal discovers runnable web previews, vendor simulators, and online physical devices, then presents one flat destination picker. The last selection is placed first, so pressing Enter repeats it; `hst run --last` skips discovery and immediately uses that remembered destination. The selection is stored in the user-level `~/.hosanna-tools/run.json`, preserving existing defaults. Explicit commands remain deterministic, and non-interactive runs never open the picker.
+
+`--target emulator` starts or reuses the shared Vite/debugger dev services for any platform and opens a profiled DOM runtime URL for interactive runs; use `--device <preset-id>` to override defaults such as `iphone-15`, `pixel-8`, `apple-tv-4k`, `android-tv-1080p`, or `rokufhd`, and use `--no-open` for server-only launches. `--target sim` launches the vendor virtual device for platforms that have one: Apple Simulator for iOS and Apple TV, Android Emulator for Android and Android TV. `--target device` launches or deploys to physical local hardware. `web` and `browser` remain accepted aliases for the web emulator; `simulator` and `simulated` remain accepted aliases for `sim`; `emulated` remains an accepted alias for the web emulator. Device/sim runs record the target and refuse to overwrite a recorded session or safe-to-kill occupied resource in non-interactive mode unless `--replace` is passed. Preferred run defaults live in `.hosanna-tools/run.json`, and preferred devices live in `.hosanna-tools/devices.json` or `~/.hosanna-tools/devices.json`. Legacy `.hs-devices.json` files are still read for compatibility.
 
 ### Roku Commands (`roku:*`) - Roku Deployment & Packaging
 - `roku:run` - Deploy a Roku app to a device (supports .zip file or folder)
@@ -269,6 +273,8 @@ Supported inputs include `file/line: pkg:/components/source_0.brs(7475)`, `at ..
 ### Build Config Commands (`build-config`) - Runtime Configuration
 - `build-config:resolve` - Resolve `build-config/base.json`, env/platform overlays, secrets, and optional developer profiles into the canonical runtime `build-config.json`
 
+Production JavaScript bundles strip `console.*` calls by default. Configure this through the normal overlay chain with `build.stripLogs`: set it to `false` in `build-config/prod.json` to retain production logs, or in `build-config/prod.apple.json` / `build-config/prod.web.json` for a platform-only exception. Non-production environments keep logs unless their overlay explicitly enables stripping. Apple `prod` builds use Xcode `Release`; other environments continue to use `Debug`.
+
 Native builds can resolve config immediately before the platform build:
 
 ```bash

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "buildDate": "2026-07-14T21:40:41+00:00",
-  "buildDateISO": "2026-07-14T21:40:41.116Z",
+  "buildDate": "2026-07-15T18:20:21+00:00",
+  "buildDateISO": "2026-07-15T18:20:21.607Z",
   "timeZone": "UTC",
-  "gitHash": "540c18c"
+  "gitHash": "0a46a09"
 }

package/dist/cli.js

@@ -144,10 +144,33 @@ async function runRunPlanCommand(command, args) {
         const executor = await Promise.resolve().then(() => __importStar(require('./run/executor.js')));
         const positionalArgv = rawCommandPositionals(command);
         const format = (args.json || args.format === 'json') ? 'json' : 'text';
+        let flags = runPlanFlagsFromCliArgs(args, format);
+        let chosenDestination;
+        const hasExplicitDestination = positionalArgv.length > 0 ||
+            rawHasFlag('platform') || rawHasFlag('target') || rawHasFlag('device');
+        if (command === 'run' && args.last) {
+            if (hasExplicitDestination) {
+                throw new Error('--last cannot be combined with an explicit platform, target, or device.');
+            }
+            const picker = await Promise.resolve().then(() => __importStar(require('./run/destination-picker.js')));
+            chosenDestination = picker.requireLastRunDestination(process.cwd());
+            flags = Object.assign(Object.assign({}, flags), runDestinationFlags(chosenDestination));
+        }
+        else if (command === 'run' &&
+            !hasExplicitDestination &&
+            !flags.nonInteractive &&
+            !args['dry-run'] &&
+            format === 'text' &&
+            process.stdin.isTTY &&
+            process.stdout.isTTY) {
+            const picker = await Promise.resolve().then(() => __importStar(require('./run/destination-picker.js')));
+            chosenDestination = await picker.chooseRunDestination({ cwd: process.cwd(), env: process.env });
+            flags = Object.assign(Object.assign({}, flags), runDestinationFlags(chosenDestination));
+        }
         const planInput = {
             cwd: process.cwd(),
             argv: positionalArgv,
-            flags: runPlanFlagsFromCliArgs(args, format),
+            flags,
             env: process.env,
         };
         const plan = command === 'build'
@@ -162,6 +185,18 @@ async function runRunPlanCommand(command, args) {
             }
             process.exit(0);
         }
+        if (command === 'run' && !flags.nonInteractive && process.stdin.isTTY) {
+            const destination = chosenDestination !== null && chosenDestination !== void 0 ? chosenDestination : rememberedExplicitDestination(plan, hasExplicitDestination);
+            if (destination) {
+                try {
+                    const config = await Promise.resolve().then(() => __importStar(require('./run/run-config.js')));
+                    config.saveLastRunDestination({ cwd: process.cwd(), destination });
+                }
+                catch (err) {
+                    console.warn(`Unable to remember the run destination: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
         const result = await executor.executeRunPlan(plan);
         if (format === 'json') {
             console.info(JSON.stringify(result, null, 2));
@@ -179,6 +214,21 @@ async function runRunPlanCommand(command, args) {
         process.exit(1);
     }
 }
+function runDestinationFlags(destination) {
+    return {
+        platform: destination.platform,
+        target: destination.target,
+        device: destination.device,
+    };
+}
+function rememberedExplicitDestination(plan, hasExplicitDestination) {
+    if (!hasExplicitDestination)
+        return undefined;
+    const target = plan.resolved.target === 'emulator' ? 'web' : plan.resolved.target;
+    if (target !== 'web' && !plan.resolved.deviceSelector)
+        return undefined;
+    return Object.assign({ platform: plan.resolved.platform, target }, (plan.resolved.deviceSelector ? { device: plan.resolved.deviceSelector } : {}));
+}
 const NATIVE_PLATFORM_CHOICES = ['apple', 'ios', 'apple-tv', 'android', 'android-tv', 'all'];
 function nativeInputFromArgs(args) {
     return {
@@ -1662,7 +1712,7 @@ catch (err) {
     .parserConfiguration({ 'boolean-negation': false, 'populate--': true })
     .positional('platform', {
     type: 'string',
-    describe: 'Launch platform. Defaults from flags, env, .hosanna-tools/run.json, then web.',
+    describe: 'Launch platform. Bare interactive runs show a destination picker; non-interactive runs default to web.',
 })
     .positional('env', {
     type: 'string',
@@ -1714,6 +1764,7 @@ catch (err) {
     .option('open', { type: 'boolean', describe: 'Open the web runtime URL in the default browser; defaults to interactive runs only' })
     .option('no-open', { type: 'boolean', default: false, describe: 'Do not open the default browser for web runtime launches' })
     .option('non-interactive', { type: 'boolean', default: false, describe: 'Fail instead of prompting when a decision is needed' })
+    .option('last', { type: 'boolean', default: false, describe: 'Immediately reuse the last destination selected by an interactive run' })
     .option('json', { type: 'boolean', default: false, describe: 'Print run result as JSON when the command returns' })
     .option('dry-run', { type: 'boolean', default: false, describe: 'Print the resolved RunPlan without executing it' })
     .option('format', { type: 'string', choices: ['text', 'json'], default: 'text', describe: 'Output format for --dry-run and run result' })
@@ -1734,6 +1785,8 @@ catch (err) {
     .option('logs', { type: 'boolean', default: false, describe: 'Enable verbose deploy logging where supported' })
     .option('applySourceMapToPaths', { type: 'boolean', default: true, describe: 'Resolve Roku stack trace paths with source maps during log streaming' })
     .example('$0 run --platform web', 'Start/reuse web dev services for this app')
+    .example('$0 run', 'Choose once from all available web, simulator, and physical-device destinations')
+    .example('$0 run --last', 'Immediately run on the last selected destination')
     .example('$0 run --platform roku --target emulator', 'Start/reuse the Roku TV web emulator')
     .example('$0 run --platform ios --target emulator', 'Start/reuse the iPhone-shaped web emulator profile')
     .example('$0 run --platform android --target emulator --device pixel-8', 'Start/reuse the Android-shaped web emulator profile')