@pagepocket/cli 0.10.1 → 0.11.1

package/dist/commands/plugin/set.js

@@ -1,13 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const parse_plugin_options_1 = require("../../utils/parse-plugin-options");
-const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { parsePluginOptions } from "../../utils/parse-plugin-options.js";
+import { parsePluginSpec } from "../../utils/parse-plugin-spec.js";
 /**
  * Replace options for a configured plugin and keep its current name/spec.
  *
@@ -27,25 +22,27 @@ const buildUpdatedPluginEntry = (entry, options) => {
         options
     };
 };
-class PluginSetCommand extends core_1.Command {
+export default class PluginSetCommand extends Command {
+    static description = "Update options for an already configured plugin.";
+    static strict = false;
     async run() {
         const [rawName, ...rest] = this.argv;
         if (!rawName) {
             throw new Error("plugin set: missing <plugin-name>");
         }
-        const parsedOptions = (0, parse_plugin_options_1.parsePluginOptions)(rest);
+        const parsedOptions = parsePluginOptions(rest);
         if (parsedOptions.kind === "none") {
             throw new Error("plugin set: provide options with --option or --option-*");
         }
-        const targetName = (0, parse_plugin_spec_1.parsePluginSpec)(rawName).name;
-        const configService = new config_service_1.ConfigService();
+        const targetName = parsePluginSpec(rawName).name;
+        const configService = new ConfigService();
         configService.ensureConfigFileExists();
         const config = configService.readConfigOrDefault();
         const targetIndex = config.plugins.findIndex((entry) => {
             return (typeof entry === "string" ? entry : entry.name) === targetName;
         });
         if (targetIndex < 0) {
-            this.log(chalk_1.default.gray(`Plugin not found in config: ${targetName}`));
+            this.log(chalk.gray(`Plugin not found in config: ${targetName}`));
             return;
         }
         const targetEntry = config.plugins[targetIndex];
@@ -60,9 +57,6 @@ class PluginSetCommand extends core_1.Command {
             ...config,
             plugins: nextPlugins
         });
-        this.log(chalk_1.default.green(`Updated plugin options: ${targetName}`));
+        this.log(chalk.green(`Updated plugin options: ${targetName}`));
     }
 }
-PluginSetCommand.description = "Update options for an already configured plugin.";
-PluginSetCommand.strict = false;
-exports.default = PluginSetCommand;

package/dist/commands/plugin/uninstall.js

@@ -1,29 +1,38 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_installer_1 = require("../../services/plugin-installer");
-const plugin_store_1 = require("../../services/plugin-store");
-const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
-class PluginUninstallCommand extends core_1.Command {
+import { Args, Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { uninstallPluginPackage } from "../../services/plugin-installer.js";
+import { PluginStore } from "../../services/plugin-store.js";
+import { parsePluginSpec } from "../../utils/parse-plugin-spec.js";
+export default class PluginUninstallCommand extends Command {
+    static description = "Uninstall a plugin package from the plugin install directory (optional config removal).";
+    static args = {
+        name: Args.string({
+            description: "npm package name",
+            required: true
+        })
+    };
+    static flags = {
+        fromConfig: Flags.boolean({
+            description: "also remove the plugin from config",
+            aliases: ["from-config"],
+            default: false
+        })
+    };
     async run() {
         const { args, flags } = await this.parse(PluginUninstallCommand);
-        const parsed = (0, parse_plugin_spec_1.parsePluginSpec)(args.name);
+        const parsed = parsePluginSpec(args.name);
         const targetName = parsed.name;
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
         const installedMeta = store.readInstalledPackageMeta(targetName);
         if (!installedMeta) {
-            this.log(chalk_1.default.gray(`Plugin package is not installed: ${targetName}`));
+            this.log(chalk.gray(`Plugin package is not installed: ${targetName}`));
         }
         else {
-            (0, plugin_installer_1.uninstallPluginPackage)(store, { packageName: targetName });
-            this.log(chalk_1.default.green(`Uninstalled plugin package: ${targetName}`));
+            uninstallPluginPackage(store, { packageName: targetName });
+            this.log(chalk.green(`Uninstalled plugin package: ${targetName}`));
         }
         if (!flags.fromConfig) {
             return;
@@ -31,25 +40,10 @@ class PluginUninstallCommand extends core_1.Command {
         const config = configService.readConfigOrDefault();
         const out = store.removePluginFromConfig(config, targetName);
         if (!out.removed) {
-            this.log(chalk_1.default.gray(`Plugin not found in config: ${targetName}`));
+            this.log(chalk.gray(`Plugin not found in config: ${targetName}`));
             return;
         }
         configService.writeConfig(out.config);
-        this.log(chalk_1.default.green(`Removed from config: ${targetName}`));
+        this.log(chalk.green(`Removed from config: ${targetName}`));
     }
 }
-PluginUninstallCommand.description = "Uninstall a plugin package from the plugin install directory (optional config removal).";
-PluginUninstallCommand.args = {
-    name: core_1.Args.string({
-        description: "npm package name",
-        required: true
-    })
-};
-PluginUninstallCommand.flags = {
-    fromConfig: core_1.Flags.boolean({
-        description: "also remove the plugin from config",
-        aliases: ["from-config"],
-        default: false
-    })
-};
-exports.default = PluginUninstallCommand;

package/dist/commands/plugin/update.js

@@ -1,14 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_installer_1 = require("../../services/plugin-installer");
-const plugin_store_1 = require("../../services/plugin-store");
-const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
+import { Args, Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { updatePluginPackageToLatest } from "../../services/plugin-installer.js";
+import { PluginStore, normalizePluginConfigEntry } from "../../services/plugin-store.js";
+import { parsePluginSpec } from "../../utils/parse-plugin-spec.js";
 /**
  * Read configured plugins and return unique package names.
  *
@@ -19,38 +14,37 @@ const getUniqueConfiguredPluginNames = (store) => {
     const config = store.readConfig();
     return [
         ...new Set(config.plugins
-            .map((entry) => (0, plugin_store_1.normalizePluginConfigEntry)(entry).name)
+            .map((entry) => normalizePluginConfigEntry(entry).name)
             .filter((name) => name.trim().length > 0))
     ];
 };
-class PluginUpdateCommand extends core_1.Command {
+export default class PluginUpdateCommand extends Command {
+    static description = "Update one plugin (or all configured plugins) to latest.";
+    static args = {
+        name: Args.string({
+            description: "npm package name (optional; if omitted updates all configured plugins)",
+            required: false
+        })
+    };
     async run() {
         const { args } = await this.parse(PluginUpdateCommand);
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
-        const targetName = args.name ? (0, parse_plugin_spec_1.parsePluginSpec)(args.name).name : undefined;
+        const targetName = args.name ? parsePluginSpec(args.name).name : undefined;
         const configuredNames = getUniqueConfiguredPluginNames(store);
         if (configuredNames.length === 0) {
-            this.log(chalk_1.default.gray("No plugins configured."));
+            this.log(chalk.gray("No plugins configured."));
             return;
         }
         if (targetName && !configuredNames.includes(targetName)) {
-            this.log(chalk_1.default.gray(`Plugin not found in config: ${targetName}`));
+            this.log(chalk.gray(`Plugin not found in config: ${targetName}`));
             return;
         }
         const namesToUpdate = targetName ? [targetName] : configuredNames;
         namesToUpdate.forEach((name) => {
-            (0, plugin_installer_1.updatePluginPackageToLatest)(store, { packageName: name });
-            this.log(chalk_1.default.green(`Updated plugin: ${name}`));
+            updatePluginPackageToLatest(store, { packageName: name });
+            this.log(chalk.green(`Updated plugin: ${name}`));
         });
     }
 }
-PluginUpdateCommand.description = "Update one plugin (or all configured plugins) to latest.";
-PluginUpdateCommand.args = {
-    name: core_1.Args.string({
-        description: "npm package name (optional; if omitted updates all configured plugins)",
-        required: false
-    })
-};
-exports.default = PluginUpdateCommand;

package/dist/commands/strategy/add.js

@@ -1,34 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const strategy_service_1 = require("../../services/strategy/strategy-service");
-class StrategyAddCommand extends core_1.Command {
+import { Args, Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import { StrategyService } from "../../services/strategy/strategy-service.js";
+export default class StrategyAddCommand extends Command {
+    static description = "Install strategies from a file/url OR install a strategy pack from a pinned npm package (applies all *.strategy.json).";
+    static args = {
+        source: Args.string({ description: "strategy file/url OR pinned npm package", required: true })
+    };
+    static flags = {
+        force: Flags.boolean({ description: "overwrite existing strategy", default: false })
+    };
     async run() {
         const { args, flags } = await this.parse(StrategyAddCommand);
-        const service = new strategy_service_1.StrategyService();
+        const service = new StrategyService();
         service.ensureConfigFileExists();
         const out = await service.addStrategy({
             source: args.source,
             force: flags.force === true
         });
         out.installedStrategies.forEach((name) => {
-            this.log(chalk_1.default.green(`Added strategy: ${name}`));
+            this.log(chalk.green(`Added strategy: ${name}`));
         });
         out.installedRefs.forEach((ref) => {
-            this.log(chalk_1.default.green(`Installed unit: ${ref}`));
+            this.log(chalk.green(`Installed unit: ${ref}`));
         });
         void flags;
     }
 }
-StrategyAddCommand.description = "Install strategies from a file/url OR install a strategy pack from a pinned npm package (applies all *.strategy.json).";
-StrategyAddCommand.args = {
-    source: core_1.Args.string({ description: "strategy file/url OR pinned npm package", required: true })
-};
-StrategyAddCommand.flags = {
-    force: core_1.Flags.boolean({ description: "overwrite existing strategy", default: false })
-};
-exports.default = StrategyAddCommand;

package/dist/commands/strategy/doctor.js

@@ -1,34 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const strategy_service_1 = require("../../services/strategy/strategy-service");
-class StrategyDoctorCommand extends core_1.Command {
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import { StrategyService } from "../../services/strategy/strategy-service.js";
+export default class StrategyDoctorCommand extends Command {
+    static description = "Diagnose strategy conflicts and unit package drift.";
     async run() {
-        const service = new strategy_service_1.StrategyService();
+        const service = new StrategyService();
         const report = service.doctor();
         report.conflicts.forEach((c) => {
-            this.log(chalk_1.default.red(`[CONFLICT] ${c.name}`));
+            this.log(chalk.red(`[CONFLICT] ${c.name}`));
             Object.entries(c.versions).forEach(([version, strategies]) => {
-                this.log(chalk_1.default.red(`  ${version}: ${strategies.join(", ")}`));
+                this.log(chalk.red(`  ${version}: ${strategies.join(", ")}`));
             });
         });
         report.drift.forEach((d) => {
-            this.log(chalk_1.default.yellow(`[DRIFT] ${d.strategy}`));
+            this.log(chalk.yellow(`[DRIFT] ${d.strategy}`));
             d.items.forEach((item) => {
                 const installed = typeof item.installed === "string" ? item.installed : "(not installed)";
-                this.log(chalk_1.default.yellow(`  ${item.name}: pinned ${item.pinned}, installed ${installed}`));
+                this.log(chalk.yellow(`  ${item.name}: pinned ${item.pinned}, installed ${installed}`));
             });
         });
         if (report.conflicts.length === 0 && report.drift.length === 0) {
-            this.log(chalk_1.default.green("Strategy doctor checks passed."));
+            this.log(chalk.green("Strategy doctor checks passed."));
             return;
         }
         throw new Error("Strategy doctor checks failed.");
     }
 }
-StrategyDoctorCommand.description = "Diagnose strategy conflicts and unit package drift.";
-exports.default = StrategyDoctorCommand;

package/dist/commands/strategy/ls.js

@@ -0,0 +1,22 @@
+import { Command } from "@oclif/core";
+import { listBuiltinStrategyNames } from "../../services/strategy/builtin-strategy-registry.js";
+import { StrategyService } from "../../services/strategy/strategy-service.js";
+import { uniq } from "../../utils/array.js";
+export default class StrategyLsCommand extends Command {
+    static description = "List available strategies.";
+    async run() {
+        const service = new StrategyService();
+        service.ensureConfigFileExists();
+        const builtin = listBuiltinStrategyNames();
+        const installed = service.listInstalledStrategyNames();
+        const names = uniq([...builtin, ...installed])
+            .map((n) => n.trim())
+            .filter((n) => n.length > 0)
+            .sort((a, b) => a.localeCompare(b));
+        if (names.length === 0) {
+            this.log("No strategies available.");
+            return;
+        }
+        names.forEach((n) => this.log(n));
+    }
+}

package/dist/commands/strategy/pin.js

@@ -1,21 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const strategy_service_1 = require("../../services/strategy/strategy-service");
-class StrategyPinCommand extends core_1.Command {
+import { Args, Command } from "@oclif/core";
+import chalk from "chalk";
+import { StrategyService } from "../../services/strategy/strategy-service.js";
+export default class StrategyPinCommand extends Command {
+    static description = "Pin a strategy file to currently installed unit package versions.";
+    static args = {
+        name: Args.string({ description: "strategy name", required: true })
+    };
     async run() {
         const { args } = await this.parse(StrategyPinCommand);
-        const service = new strategy_service_1.StrategyService();
+        const service = new StrategyService();
         service.pinStrategy(args.name);
-        this.log(chalk_1.default.green(`Pinned strategy: ${args.name}`));
+        this.log(chalk.green(`Pinned strategy: ${args.name}`));
     }
 }
-StrategyPinCommand.description = "Pin a strategy file to currently installed unit package versions.";
-StrategyPinCommand.args = {
-    name: core_1.Args.string({ description: "strategy name", required: true })
-};
-exports.default = StrategyPinCommand;

package/dist/commands/strategy/remove.js

@@ -1,21 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const strategy_service_1 = require("../../services/strategy/strategy-service");
-class StrategyRemoveCommand extends core_1.Command {
+import { Args, Command } from "@oclif/core";
+import chalk from "chalk";
+import { StrategyService } from "../../services/strategy/strategy-service.js";
+export default class StrategyRemoveCommand extends Command {
+    static description = "Remove an installed strategy.";
+    static args = {
+        name: Args.string({ description: "strategy name", required: true })
+    };
     async run() {
         const { args } = await this.parse(StrategyRemoveCommand);
-        const service = new strategy_service_1.StrategyService();
+        const service = new StrategyService();
         service.removeStrategy(args.name);
-        this.log(chalk_1.default.green(`Removed strategy: ${args.name}`));
+        this.log(chalk.green(`Removed strategy: ${args.name}`));
     }
 }
-StrategyRemoveCommand.description = "Remove an installed strategy.";
-StrategyRemoveCommand.args = {
-    name: core_1.Args.string({ description: "strategy name", required: true })
-};
-exports.default = StrategyRemoveCommand;

package/dist/commands/strategy/update.js

@@ -1,34 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const strategy_service_1 = require("../../services/strategy/strategy-service");
-class StrategyUpdateCommand extends core_1.Command {
+import { Args, Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import { StrategyService } from "../../services/strategy/strategy-service.js";
+export default class StrategyUpdateCommand extends Command {
+    static description = "Update a strategy (or all strategies).";
+    static args = {
+        name: Args.string({ description: "strategy name (optional)", required: false })
+    };
+    static flags = {
+        packageOnly: Flags.boolean({
+            description: "update unit packages to latest only",
+            default: false
+        })
+    };
     async run() {
         const { args, flags } = await this.parse(StrategyUpdateCommand);
-        const service = new strategy_service_1.StrategyService();
+        const service = new StrategyService();
         await service.updateStrategy(args.name, { packageOnly: flags.packageOnly === true });
         if (flags.packageOnly) {
-            this.log(chalk_1.default.yellow("WARNING: Updated unit packages without updating strategy files. This may cause version drift."));
-            this.log(chalk_1.default.gray("If drift occurs, fix by updating packages to pinned versions:"));
-            this.log(chalk_1.default.gray(`  pp strategy update${args.name ? ` ${args.name}` : ""}`));
-            this.log(chalk_1.default.gray("Or pin a strategy to installed versions:"));
-            this.log(chalk_1.default.gray(`  pp strategy pin ${args.name ?? "<strategy-name>"}`));
+            this.log(chalk.yellow("WARNING: Updated unit packages without updating strategy files. This may cause version drift."));
+            this.log(chalk.gray("If drift occurs, fix by updating packages to pinned versions:"));
+            this.log(chalk.gray(`  pp strategy update${args.name ? ` ${args.name}` : ""}`));
+            this.log(chalk.gray("Or pin a strategy to installed versions:"));
+            this.log(chalk.gray(`  pp strategy pin ${args.name ?? "<strategy-name>"}`));
         }
-        this.log(chalk_1.default.green("Strategy update completed."));
+        this.log(chalk.green("Strategy update completed."));
     }
 }
-StrategyUpdateCommand.description = "Update a strategy (or all strategies).";
-StrategyUpdateCommand.args = {
-    name: core_1.Args.string({ description: "strategy name (optional)", required: false })
-};
-StrategyUpdateCommand.flags = {
-    packageOnly: core_1.Flags.boolean({
-        description: "update unit packages to latest only",
-        default: false
-    })
-};
-exports.default = StrategyUpdateCommand;

package/dist/commands/view.js

@@ -1,63 +1,57 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_process_1 = __importDefault(require("node:process"));
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const view_1 = require("../view");
-class ViewCommand extends core_1.Command {
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { Args, Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import { createViewServer } from "../view.js";
+export default class ViewCommand extends Command {
+    static description = "Serve a directory via a local static server (SPA fallback to index.html).";
+    static args = {
+        directory: Args.string({
+            description: "Directory to serve (must contain index.html)",
+            required: true
+        })
+    };
+    static flags = {
+        help: Flags.help({
+            char: "h"
+        }),
+        host: Flags.string({
+            description: "Host to bind",
+            default: "127.0.0.1"
+        }),
+        port: Flags.integer({
+            description: "Port to listen on (0 for random)",
+            default: 4173
+        })
+    };
     async run() {
         const { args, flags } = await this.parse(ViewCommand);
-        const rootDir = node_path_1.default.resolve(node_process_1.default.cwd(), args.directory);
-        const indexPath = node_path_1.default.join(rootDir, "index.html");
-        const stat = await node_fs_1.default.promises.stat(rootDir).catch(() => undefined);
+        const rootDir = path.resolve(process.cwd(), args.directory);
+        const indexPath = path.join(rootDir, "index.html");
+        const stat = await fs.promises.stat(rootDir).catch(() => undefined);
         if (!stat || !stat.isDirectory()) {
             throw new Error(`view: directory not found: ${rootDir}`);
         }
-        const indexStat = await node_fs_1.default.promises.stat(indexPath).catch(() => undefined);
+        const indexStat = await fs.promises.stat(indexPath).catch(() => undefined);
         if (!indexStat || !indexStat.isFile()) {
             throw new Error(`view: index.html not found under: ${rootDir}`);
         }
-        const portFromEnv = node_process_1.default.env.PORT ? Number(node_process_1.default.env.PORT) : undefined;
+        const portFromEnv = process.env.PORT ? Number(process.env.PORT) : undefined;
         const port = typeof flags.port === "number"
             ? flags.port
             : typeof portFromEnv === "number"
                 ? portFromEnv
                 : 4173;
         if (!Number.isFinite(port) || port < 0 || port > 65535) {
-            throw new Error(`Invalid --port: ${String(flags.port ?? node_process_1.default.env.PORT)}`);
+            throw new Error(`Invalid --port: ${String(flags.port ?? process.env.PORT)}`);
         }
-        const server = await (0, view_1.createViewServer)({
+        const server = await createViewServer({
             rootDir,
             host: flags.host,
             port
         });
-        this.log(`Serving ${chalk_1.default.cyan(rootDir)}`);
-        this.log(chalk_1.default.green(server.url));
+        this.log(`Serving ${chalk.cyan(rootDir)}`);
+        this.log(chalk.green(server.url));
     }
 }
-ViewCommand.description = "Serve a directory via a local static server (SPA fallback to index.html).";
-ViewCommand.args = {
-    directory: core_1.Args.string({
-        description: "Directory to serve (must contain index.html)",
-        required: true
-    })
-};
-ViewCommand.flags = {
-    help: core_1.Flags.help({
-        char: "h"
-    }),
-    host: core_1.Flags.string({
-        description: "Host to bind",
-        default: "127.0.0.1"
-    }),
-    port: core_1.Flags.integer({
-        description: "Port to listen on (0 for random)",
-        default: 4173
-    })
-};
-exports.default = ViewCommand;

package/dist/index.js

@@ -1,10 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const normalize_argv_1 = require("./utils/normalize-argv");
-(0, core_1.run)((0, normalize_argv_1.normalizeArgv)(process.argv.slice(2))).catch((error) => {
-    const message = error && typeof error.message === "string" ? error.message : String(error);
+import { execute } from "@oclif/core";
+import { normalizeArgv } from "./utils/normalize-argv.js";
+await execute({
+    dir: import.meta.url,
+    args: normalizeArgv(process.argv.slice(2))
+}).catch((error) => {
+    const err = error;
+    const message = err && typeof err.message === "string" ? err.message : String(error);
     console.error(message);
-    const exitCode = error && typeof error.exitCode === "number" ? error.exitCode : 1;
+    const exitCode = err && typeof err.exitCode === "number" ? err.exitCode : 1;
     process.exit(exitCode);
 });

package/dist/lib/filename.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeFilename = void 0;
-const safeFilename = (input) => {
+export const safeFilename = (input) => {
     const trimmed = input.trim();
     if (!trimmed) {
         return "snapshot";
@@ -11,4 +8,3 @@ const safeFilename = (input) => {
         .replace(/^_+|_+$/g, "")
         .slice(0, 120) || "snapshot");
 };
-exports.safeFilename = safeFilename;