@pagepocket/cli 0.8.6 → 0.9.1

package/README.md

@@ -39,7 +39,12 @@ Manage configured plugins:
 ```bash
 pp plugin ls
 pp plugin add <plugin-name>
+pp plugin set <plugin-name> [...options]
+pp plugin update [plugin-name]
+pp plugin doctor [plugin-name]
 pp plugin remove <plugin-name>
+pp plugin uninstall <plugin-name> [--from-config]
+pp plugin prune
 ```
 
 Options passing:
@@ -58,6 +63,12 @@ pp plugin add @scope/plugin --option 1 --option 2
 Notes:
 
 - `pp plugin remove` only removes the entry from `config.json` (it does not uninstall the package).
+- `pp plugin set` updates options for an already configured plugin.
+- `pp plugin update <plugin-name>` reinstalls that plugin to `latest`.
+- `pp plugin update` reinstalls all configured plugins to `latest`.
+- `pp plugin doctor` checks plugin install/load health and exits non-zero on failures.
+- `pp plugin uninstall <plugin-name>` removes the installed package; add `--from-config` to also remove config.
+- `pp plugin prune` removes installed packages that are no longer referenced in `config.json`.
 - During `pp archive ...`, the CLI reads `config.json` and tries to load all configured plugins.
   If a plugin fails to load, it will be skipped and the archive will continue.
 

package/dist/commands/plugin/add.js

@@ -8,46 +8,9 @@ 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_options_1 = require("../../utils/parse-plugin-options");
 const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
 const validate_plugin_default_export_1 = require("../../utils/validate-plugin-default-export");
-const parseDynamicOptions = (argv) => {
-    const tokens = argv.filter(Boolean);
-    const pairs = tokens
-        .map((t, i) => ({ t, next: tokens[i + 1] }))
-        .filter(({ t }) => t === "--option" || t.startsWith("--option-"));
-    const object = pairs
-        .filter(({ t }) => t.startsWith("--option-"))
-        .reduce((acc, { t, next }) => {
-        const key = t.slice("--option-".length);
-        if (!key) {
-            throw new Error("--option-* key is empty");
-        }
-        if (typeof next === "undefined" || next.startsWith("-")) {
-            throw new Error(`${t} expects a value`);
-        }
-        return { ...acc, [key]: next };
-    }, {});
-    const arrayValues = pairs
-        .filter(({ t }) => t === "--option")
-        .map(({ next }) => {
-        if (typeof next === "undefined" || next.startsWith("-")) {
-            throw new Error("--option expects a value");
-        }
-        return next;
-    });
-    const hasObject = Object.keys(object).length > 0;
-    const hasArray = arrayValues.length > 0;
-    if (hasObject && hasArray) {
-        throw new Error("Cannot mix --option with --option-* flags");
-    }
-    if (hasObject) {
-        return { kind: "object", value: object };
-    }
-    if (hasArray) {
-        return { kind: "array", value: arrayValues };
-    }
-    return { kind: "none" };
-};
 class PluginAddCommand extends core_1.Command {
     async run() {
         const [name, ...rest] = this.argv;
@@ -67,7 +30,7 @@ class PluginAddCommand extends core_1.Command {
             this.log(chalk_1.default.gray(`Plugin already exists in config: ${parsedSpec.name}`));
             return;
         }
-        const parsed = parseDynamicOptions(rest);
+        const parsed = (0, parse_plugin_options_1.parsePluginOptions)(rest);
         const entry = parsed.kind === "none"
             ? parsedSpec.name
             : parsed.kind === "array"
@@ -90,4 +53,5 @@ class PluginAddCommand extends core_1.Command {
     }
 }
 PluginAddCommand.description = "Install a plugin package, add it to config, and run its optional setup().";
+PluginAddCommand.strict = false;
 exports.default = PluginAddCommand;

package/dist/commands/plugin/doctor.js

@@ -0,0 +1,91 @@
+"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_store_1 = require("../../services/plugin-store");
+const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
+/**
+ * Validate one configured plugin can be loaded and instantiated.
+ *
+ * Usage:
+ * const result = await runDoctorCheck(store, spec);
+ */
+const runDoctorCheck = async (store, spec) => {
+    const installed = Boolean(store.readInstalledPackageMeta(spec.name));
+    if (!installed) {
+        return {
+            plugin: spec.name,
+            installed: false,
+            loadable: false,
+            error: "not installed"
+        };
+    }
+    try {
+        await store.instantiatePluginFromSpec(spec);
+        return {
+            plugin: spec.name,
+            installed: true,
+            loadable: true
+        };
+    }
+    catch (error) {
+        return {
+            plugin: spec.name,
+            installed: true,
+            loadable: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+};
+class PluginDoctorCommand extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(PluginDoctorCommand);
+        const configService = new config_service_1.ConfigService();
+        const store = new plugin_store_1.PluginStore(configService);
+        configService.ensureConfigFileExists();
+        const config = store.readConfig();
+        const targetName = args.name ? (0, parse_plugin_spec_1.parsePluginSpec)(args.name).name : undefined;
+        const configured = config.plugins
+            .map((entry) => (0, plugin_store_1.normalizePluginConfigEntry)(entry))
+            .filter((entry) => {
+            if (!targetName) {
+                return true;
+            }
+            return entry.name === targetName;
+        });
+        if (configured.length === 0) {
+            if (targetName) {
+                this.log(chalk_1.default.gray(`Plugin not found in config: ${targetName}`));
+                return;
+            }
+            this.log(chalk_1.default.gray("No plugins configured."));
+            return;
+        }
+        const checks = await Promise.all(configured.map((entry) => runDoctorCheck(store, entry)));
+        const failed = checks.filter((item) => !item.installed || !item.loadable);
+        checks.forEach((item) => {
+            if (item.installed && item.loadable) {
+                this.log(chalk_1.default.green(`[OK] ${item.plugin}`));
+                return;
+            }
+            this.log(chalk_1.default.red(`[FAIL] ${item.plugin}: ${item.error ?? "unknown error"}`));
+        });
+        if (failed.length === 0) {
+            this.log(chalk_1.default.green("Plugin doctor checks passed."));
+            return;
+        }
+        throw new Error(`${failed.length} plugin(s) failed doctor checks.`);
+    }
+}
+PluginDoctorCommand.description = "Validate configured plugins are installed and loadable.";
+PluginDoctorCommand.args = {
+    name: core_1.Args.string({
+        description: "npm package name (optional; if omitted checks all configured plugins)",
+        required: false
+    })
+};
+exports.default = PluginDoctorCommand;

package/dist/commands/plugin/prune.js

@@ -0,0 +1,43 @@
+"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");
+/**
+ * Get configured plugin names from config.
+ *
+ * Usage:
+ * const names = getConfiguredPluginNames(store);
+ */
+const getConfiguredPluginNames = (store) => {
+    const config = store.readConfig();
+    const names = config.plugins
+        .map((entry) => (0, plugin_store_1.normalizePluginConfigEntry)(entry).name)
+        .filter((name) => name.trim().length > 0);
+    return new Set(names);
+};
+class PluginPruneCommand extends core_1.Command {
+    async run() {
+        const configService = new config_service_1.ConfigService();
+        const store = new plugin_store_1.PluginStore(configService);
+        configService.ensureConfigFileExists();
+        const configured = getConfiguredPluginNames(store);
+        const installed = store.readInstalledDependencyNames();
+        const orphans = installed.filter((name) => !configured.has(name));
+        if (orphans.length === 0) {
+            this.log(chalk_1.default.gray("No orphan plugin packages found."));
+            return;
+        }
+        orphans.forEach((name) => {
+            (0, plugin_installer_1.uninstallPluginPackage)(store, { packageName: name });
+            this.log(chalk_1.default.green(`Pruned plugin package: ${name}`));
+        });
+    }
+}
+PluginPruneCommand.description = "Uninstall plugin packages that are not referenced by config.";
+exports.default = PluginPruneCommand;

package/dist/commands/plugin/set.js

@@ -0,0 +1,68 @@
+"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");
+/**
+ * Replace options for a configured plugin and keep its current name/spec.
+ *
+ * Usage:
+ * const next = buildUpdatedPluginEntry(existingEntry, parsedOptions);
+ */
+const buildUpdatedPluginEntry = (entry, options) => {
+    if (typeof entry === "string") {
+        return {
+            name: entry,
+            options
+        };
+    }
+    return {
+        name: entry.name,
+        ...(typeof entry.spec === "string" ? { spec: entry.spec } : {}),
+        options
+    };
+};
+class PluginSetCommand extends core_1.Command {
+    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);
+        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();
+        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}`));
+            return;
+        }
+        const targetEntry = config.plugins[targetIndex];
+        const nextEntry = buildUpdatedPluginEntry(targetEntry, parsedOptions.value);
+        const nextPlugins = config.plugins.map((entry, idx) => {
+            if (idx === targetIndex) {
+                return nextEntry;
+            }
+            return entry;
+        });
+        configService.writeConfig({
+            ...config,
+            plugins: nextPlugins
+        });
+        this.log(chalk_1.default.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

@@ -0,0 +1,55 @@
+"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 {
+    async run() {
+        const { args, flags } = await this.parse(PluginUninstallCommand);
+        const parsed = (0, parse_plugin_spec_1.parsePluginSpec)(args.name);
+        const targetName = parsed.name;
+        const configService = new config_service_1.ConfigService();
+        const store = new plugin_store_1.PluginStore(configService);
+        configService.ensureConfigFileExists();
+        const installedMeta = store.readInstalledPackageMeta(targetName);
+        if (!installedMeta) {
+            this.log(chalk_1.default.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}`));
+        }
+        if (!flags.fromConfig) {
+            return;
+        }
+        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}`));
+            return;
+        }
+        configService.writeConfig(out.config);
+        this.log(chalk_1.default.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

@@ -0,0 +1,56 @@
+"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");
+/**
+ * Read configured plugins and return unique package names.
+ *
+ * Usage:
+ * const names = getUniqueConfiguredPluginNames(store);
+ */
+const getUniqueConfiguredPluginNames = (store) => {
+    const config = store.readConfig();
+    return [
+        ...new Set(config.plugins
+            .map((entry) => (0, plugin_store_1.normalizePluginConfigEntry)(entry).name)
+            .filter((name) => name.trim().length > 0))
+    ];
+};
+class PluginUpdateCommand extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(PluginUpdateCommand);
+        const configService = new config_service_1.ConfigService();
+        const store = new plugin_store_1.PluginStore(configService);
+        configService.ensureConfigFileExists();
+        const targetName = args.name ? (0, parse_plugin_spec_1.parsePluginSpec)(args.name).name : undefined;
+        const configuredNames = getUniqueConfiguredPluginNames(store);
+        if (configuredNames.length === 0) {
+            this.log(chalk_1.default.gray("No plugins configured."));
+            return;
+        }
+        if (targetName && !configuredNames.includes(targetName)) {
+            this.log(chalk_1.default.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}`));
+        });
+    }
+}
+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/view.js

@@ -14,11 +14,11 @@ class ViewCommand extends core_1.Command {
         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(() => null);
+        const stat = await node_fs_1.default.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(() => null);
+        const indexStat = await node_fs_1.default.promises.stat(indexPath).catch(() => undefined);
         if (!indexStat || !indexStat.isFile()) {
             throw new Error(`view: index.html not found under: ${rootDir}`);
         }

package/dist/services/config-service.js

@@ -8,6 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const env_paths_1 = __importDefault(require("env-paths"));
+const parse_json_1 = require("../utils/parse-json");
 const defaultConfig = {
     plugins: []
 };
@@ -45,7 +46,7 @@ class ConfigService {
         const dir = node_path_1.default.dirname(filePath);
         this.ensureDirExists(dir);
         const tmpPath = `${filePath}.tmp`;
-        node_fs_1.default.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+        node_fs_1.default.writeFileSync(tmpPath, `${JSON.stringify(value, undefined, 2)}\n`, "utf8");
         node_fs_1.default.renameSync(tmpPath, filePath);
     }
     isObject(value) {
@@ -73,33 +74,28 @@ class ConfigService {
                     ...(typeof options === "undefined" ? {} : { options })
                 };
             }
-            return null;
+            return undefined;
         })
-            .filter((x) => x !== null);
+            .filter((x) => typeof x !== "undefined");
         return { plugins };
     }
     readConfig() {
         const configPath = this.getConfigPath();
         const rawText = node_fs_1.default.readFileSync(configPath, "utf8");
-        const parsed = JSON.parse(rawText);
-        return this.normalizeConfig(parsed);
+        const parsed = (0, parse_json_1.parseJson)(rawText);
+        return this.normalizeConfig(parsed.ok ? parsed.value : undefined);
     }
     isConfigFilePresent() {
         return node_fs_1.default.existsSync(this.getConfigPath());
     }
     readConfigOrDefault() {
         const configPath = this.getConfigPath();
-        const text = node_fs_1.default.existsSync(configPath) ? node_fs_1.default.readFileSync(configPath, "utf8") : null;
+        const text = node_fs_1.default.existsSync(configPath) ? node_fs_1.default.readFileSync(configPath, "utf8") : undefined;
         if (!text) {
             return defaultConfig;
         }
-        try {
-            const parsed = JSON.parse(text);
-            return this.normalizeConfig(parsed);
-        }
-        catch {
-            return defaultConfig;
-        }
+        const parsed = (0, parse_json_1.parseJson)(text);
+        return parsed.ok ? this.normalizeConfig(parsed.value) : defaultConfig;
     }
     writeConfig(config) {
         this.writeJsonAtomic(this.getConfigPath(), this.normalizeConfig(config));

package/dist/services/load-configured-plugins.js

@@ -5,6 +5,18 @@ const validate_plugin_default_export_1 = require("../utils/validate-plugin-defau
 const config_service_1 = require("./config-service");
 const plugin_store_1 = require("./plugin-store");
 const loadConfiguredPlugins = async () => {
+    const getErrorMessage = (error) => {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (error && typeof error === "object" && "message" in error) {
+            const msg = error.message;
+            if (typeof msg === "string") {
+                return msg;
+            }
+        }
+        return String(error);
+    };
     const configService = new config_service_1.ConfigService();
     const store = new plugin_store_1.PluginStore(configService);
     configService.ensureConfigFileExists();
@@ -20,18 +32,16 @@ const loadConfiguredPlugins = async () => {
             });
             if (!validation.ok) {
                 console.error(`Skipping plugin ${spec.name}: ${validation.error.message}`);
-                return null;
+                return undefined;
             }
             return validation.plugin;
         }
         catch (e) {
-            const msg = e && typeof e.message === "string"
-                ? e.message
-                : String(e);
+            const msg = getErrorMessage(e);
             console.error(`Failed to load plugin ${spec.name}: ${msg}`);
-            return null;
+            return undefined;
         }
     }));
-    return loaded.filter((x) => x !== null);
+    return loaded.filter((x) => typeof x !== "undefined");
 };
 exports.loadConfiguredPlugins = loadConfiguredPlugins;

package/dist/services/plugin-installer.js

@@ -1,8 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installPluginPackage = void 0;
+exports.uninstallPluginPackage = exports.updatePluginPackageToLatest = exports.installPluginPackage = void 0;
 const node_child_process_1 = require("node:child_process");
+/**
+ * Install a package spec with pnpm first, then fallback to npm.
+ *
+ * Usage:
+ * tryInstallWithFallback("/path/to/plugins", "@scope/plugin@latest");
+ */
+const tryInstallWithFallback = (installDir, packageSpec) => {
+    const tryRun = (cmd, args) => {
+        const r = (0, node_child_process_1.spawnSync)(cmd, args, {
+            cwd: installDir,
+            stdio: "inherit",
+            shell: false
+        });
+        if (r.error) {
+            return { ok: false, error: r.error };
+        }
+        if (typeof r.status === "number" && r.status !== 0) {
+            return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+        }
+        return { ok: true };
+    };
+    const pnpm = tryRun("pnpm", ["add", "--silent", packageSpec]);
+    if (pnpm.ok) {
+        return;
+    }
+    const npm = tryRun("npm", ["install", "--silent", packageSpec]);
+    if (npm.ok) {
+        return;
+    }
+    throw new Error(`Failed to install ${packageSpec}. Ensure pnpm or npm is available.`);
+};
 const installPluginPackage = (store, input) => {
+    store.ensurePluginPackageJson();
+    const installDir = store.getInstallDir();
+    tryInstallWithFallback(installDir, input.packageName);
+};
+exports.installPluginPackage = installPluginPackage;
+const updatePluginPackageToLatest = (store, input) => {
+    store.ensurePluginPackageJson();
+    const installDir = store.getInstallDir();
+    const packageSpec = `${input.packageName}@latest`;
+    tryInstallWithFallback(installDir, packageSpec);
+};
+exports.updatePluginPackageToLatest = updatePluginPackageToLatest;
+/**
+ * Uninstall a package name with pnpm first, then fallback to npm.
+ *
+ * Usage:
+ * uninstallPluginPackage(store, { packageName: "@scope/plugin" });
+ */
+const uninstallPluginPackage = (store, input) => {
     store.ensurePluginPackageJson();
     const installDir = store.getInstallDir();
     const tryRun = (cmd, args) => {
@@ -19,14 +69,14 @@ const installPluginPackage = (store, input) => {
         }
         return { ok: true };
     };
-    const pnpm = tryRun("pnpm", ["add", "--silent", input.packageName]);
+    const pnpm = tryRun("pnpm", ["remove", "--silent", input.packageName]);
     if (pnpm.ok) {
         return;
     }
-    const npm = tryRun("npm", ["install", "--silent", input.packageName]);
+    const npm = tryRun("npm", ["uninstall", "--silent", input.packageName]);
     if (npm.ok) {
         return;
     }
-    throw new Error(`Failed to install ${input.packageName}. Ensure pnpm or npm is available.`);
+    throw new Error(`Failed to uninstall ${input.packageName}. Ensure pnpm or npm is available.`);
 };
-exports.installPluginPackage = installPluginPackage;
+exports.uninstallPluginPackage = uninstallPluginPackage;

package/dist/services/plugin-store.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,6 +41,8 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
+const parse_json_1 = require("../utils/parse-json");
+const validate_plugin_default_export_1 = require("../utils/validate-plugin-default-export");
 const normalizePluginConfigEntry = (entry) => {
     if (typeof entry === "string") {
         return { name: entry };
@@ -21,6 +56,18 @@ const normalizePluginConfigEntry = (entry) => {
 exports.normalizePluginConfigEntry = normalizePluginConfigEntry;
 const getPluginNameFromSpec = (spec) => spec.name;
 exports.getPluginNameFromSpec = getPluginNameFromSpec;
+const isRecord = (value) => {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const isCallable = (value) => {
+    return typeof value === "function";
+};
+const isStringRecord = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((v) => typeof v === "string");
+};
 class PluginStore {
     constructor(configService) {
         this.configService = configService;
@@ -42,7 +89,7 @@ class PluginStore {
             private: true,
             version: "0.0.0"
         };
-        node_fs_1.default.writeFileSync(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`, "utf8");
+        node_fs_1.default.writeFileSync(pkgJsonPath, `${JSON.stringify(pkgJson, undefined, 2)}\n`, "utf8");
         return pkgJsonPath;
     }
     createPluginsRequireFromDir(dirPath) {
@@ -53,7 +100,7 @@ class PluginStore {
                 private: true,
                 version: "0.0.0"
             };
-            node_fs_1.default.writeFileSync(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`, "utf8");
+            node_fs_1.default.writeFileSync(pkgJsonPath, `${JSON.stringify(pkgJson, undefined, 2)}\n`, "utf8");
         }
         return (0, node_module_1.createRequire)(pkgJsonPath);
     }
@@ -69,11 +116,11 @@ class PluginStore {
         try {
             const pkgJsonPath = this.resolveInstalledPackageJsonPath(pluginName);
             const text = node_fs_1.default.readFileSync(pkgJsonPath, "utf8");
-            const json = JSON.parse(text);
-            if (!json || typeof json !== "object") {
+            const json = (0, parse_json_1.parseJson)(text);
+            if (!json.ok || !json.value || typeof json.value !== "object") {
                 return { name: pluginName };
             }
-            const o = json;
+            const o = json.value;
             return {
                 name: typeof o.name === "string" ? o.name : pluginName,
                 description: typeof o.description === "string" ? o.description : undefined,
@@ -81,8 +128,28 @@ class PluginStore {
             };
         }
         catch {
-            return null;
+            return undefined;
+        }
+    }
+    /**
+     * Read top-level dependencies from plugins install `package.json`.
+     *
+     * Usage:
+     * const names = store.readInstalledDependencyNames();
+     */
+    readInstalledDependencyNames() {
+        const pkgJsonPath = this.ensurePluginPackageJson();
+        const text = node_fs_1.default.readFileSync(pkgJsonPath, "utf8");
+        const parsed = (0, parse_json_1.parseJson)(text);
+        if (!parsed.ok || !parsed.value || typeof parsed.value !== "object") {
+            return [];
         }
+        const record = parsed.value;
+        const dependencies = record.dependencies;
+        if (!isStringRecord(dependencies)) {
+            return [];
+        }
+        return Object.keys(dependencies);
     }
     async importPluginModule(pluginName) {
         const req = this.createPluginsRequire();
@@ -90,30 +157,26 @@ class PluginStore {
         return this.importResolvedPath(resolved);
     }
     async importResolvedPath(resolved) {
-        const dynamicImport = new Function("specifier", "return import(specifier)");
-        const mod = await dynamicImport((0, node_url_1.pathToFileURL)(resolved).href);
-        return (mod ?? {});
+        const mod = await Promise.resolve(`${(0, node_url_1.pathToFileURL)(resolved).href}`).then(s => __importStar(require(s)));
+        return isRecord(mod) ? mod : {};
     }
     async instantiatePluginFromSpec(spec) {
         const mod = await this.importPluginModule(spec.name);
-        const defaultExport = mod.default;
-        if (typeof defaultExport !== "function") {
-            throw new Error(`Plugin ${spec.name} has no default export (class/function).`);
-        }
-        const ctor = defaultExport;
-        if (typeof spec.options === "undefined") {
-            return new ctor();
-        }
-        if (Array.isArray(spec.options)) {
-            return new ctor(...spec.options);
+        const result = (0, validate_plugin_default_export_1.validatePluginDefaultExport)({
+            pluginName: spec.name,
+            moduleExports: mod,
+            options: spec.options
+        });
+        if (!result.ok) {
+            throw result.error;
         }
-        return new ctor(spec.options);
+        return result.plugin;
     }
     async runOptionalSetup(pluginName) {
         const mod = await this.importPluginModule(pluginName);
         const setup = mod.setup;
-        if (typeof setup === "function") {
-            await setup();
+        if (isCallable(setup)) {
+            await Promise.resolve(setup());
         }
     }
     readConfig() {

package/dist/utils/normalize-argv.js

@@ -21,12 +21,6 @@ const normalizeArgv = (argv) => {
         return argv;
     }
     const first = argv[0];
-    if (first === "plugin") {
-        const sub = argv[1];
-        if (sub === "ls" || sub === "add" || sub === "remove") {
-            return [`plugin:${sub}`, ...argv.slice(2)];
-        }
-    }
     // If the first token is a URL, treat it as implicit `archive`.
     if (first && (0, exports.isUrlLike)(first)) {
         return ["archive", ...argv];

package/dist/utils/parse-json.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJson = void 0;
+const toErrorMessage = (value) => {
+    if (value instanceof Error) {
+        return value.message;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value && typeof value === "object" && "message" in value) {
+        return String(value.message);
+    }
+    return JSON.stringify(value);
+};
+const parseJson = (text) => {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch (e) {
+        return { ok: false, error: new Error(toErrorMessage(e)) };
+    }
+};
+exports.parseJson = parseJson;

package/dist/utils/parse-plugin-options.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePluginOptions = void 0;
+/**
+ * Parse plugin options from argv tokens.
+ *
+ * Usage:
+ * const parsed = parsePluginOptions(["--option-mode", "strict"]);
+ */
+const parsePluginOptions = (argv) => {
+    const tokens = argv.filter(Boolean);
+    const pairs = tokens
+        .map((t, i) => ({ t, next: tokens[i + 1] }))
+        .filter(({ t }) => t === "--option" || t.startsWith("--option-"));
+    const object = pairs
+        .filter(({ t }) => t.startsWith("--option-"))
+        .reduce((acc, { t, next }) => {
+        const key = t.slice("--option-".length);
+        if (!key) {
+            throw new Error("--option-* key is empty");
+        }
+        if (typeof next === "undefined" || next.startsWith("-")) {
+            throw new Error(`${t} expects a value`);
+        }
+        return { ...acc, [key]: next };
+    }, {});
+    const arrayValues = pairs
+        .filter(({ t }) => t === "--option")
+        .map(({ next }) => {
+        if (typeof next === "undefined" || next.startsWith("-")) {
+            throw new Error("--option expects a value");
+        }
+        return next;
+    });
+    const hasObject = Object.keys(object).length > 0;
+    const hasArray = arrayValues.length > 0;
+    if (hasObject && hasArray) {
+        throw new Error("Cannot mix --option with --option-* flags");
+    }
+    if (hasObject) {
+        return { kind: "object", value: object };
+    }
+    if (hasArray) {
+        return { kind: "array", value: arrayValues };
+    }
+    return { kind: "none" };
+};
+exports.parsePluginOptions = parsePluginOptions;

package/dist/utils/validate-plugin-default-export.js

@@ -2,6 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatePluginDefaultExport = void 0;
 const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isPagePocketPlugin = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (typeof value.name !== "string" || value.name.trim().length === 0) {
+        return false;
+    }
+    if (typeof value.setup !== "function") {
+        return false;
+    }
+    if (typeof value.contribute !== "undefined" && typeof value.contribute !== "function") {
+        return false;
+    }
+    return true;
+};
 const toError = (value) => {
     if (value instanceof Error) {
         return value;
@@ -24,33 +39,12 @@ const validatePluginDefaultExport = (input) => {
             : Array.isArray(options)
                 ? new ctor(...options)
                 : new ctor(options);
-        if (!isRecord(instance)) {
+        if (!isPagePocketPlugin(instance)) {
             return {
                 ok: false,
                 error: new Error(`Plugin ${pluginName} default export did not construct an object.`)
             };
         }
-        const name = instance.name;
-        if (typeof name !== "string" || name.trim().length === 0) {
-            return {
-                ok: false,
-                error: new Error(`Plugin ${pluginName} instance must have a non-empty string 'name'.`)
-            };
-        }
-        const setup = instance.setup;
-        if (typeof setup !== "function") {
-            return {
-                ok: false,
-                error: new Error(`Plugin ${pluginName} instance must implement setup(host).`)
-            };
-        }
-        const contribute = instance.contribute;
-        if (typeof contribute !== "undefined" && typeof contribute !== "function") {
-            return {
-                ok: false,
-                error: new Error(`Plugin ${pluginName} contribute must be a function if provided.`)
-            };
-        }
         return { ok: true, plugin: instance };
     }
     catch (e) {

package/dist/view.js

@@ -11,11 +11,11 @@ const koa_send_1 = __importDefault(require("koa-send"));
 const koa_static_1 = __importDefault(require("koa-static"));
 const createViewServer = async (args) => {
     const indexPath = node_path_1.default.join(args.rootDir, "index.html");
-    const stat = await node_fs_1.default.promises.stat(args.rootDir).catch(() => null);
+    const stat = await node_fs_1.default.promises.stat(args.rootDir).catch(() => undefined);
     if (!stat || !stat.isDirectory()) {
         throw new Error(`view: directory not found: ${args.rootDir}`);
     }
-    const indexStat = await node_fs_1.default.promises.stat(indexPath).catch(() => null);
+    const indexStat = await node_fs_1.default.promises.stat(indexPath).catch(() => undefined);
     if (!indexStat || !indexStat.isFile()) {
         throw new Error(`view: index.html not found under: ${args.rootDir}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagepocket/cli",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "CLI for capturing offline snapshots of web pages.",
   "main": "dist/index.js",
   "bin": {
@@ -21,15 +21,15 @@
     "koa-static": "^5.0.0",
     "npm-package-arg": "^13.0.2",
     "ora": "^9.0.0",
-    "@pagepocket/build-snapshot-unit": "0.8.6",
-    "@pagepocket/capture-http-cdp-unit": "0.8.6",
-    "@pagepocket/capture-http-lighterceptor-unit": "0.8.6",
-    "@pagepocket/capture-http-puppeteer-unit": "0.8.6",
-    "@pagepocket/contracts": "0.8.6",
-    "@pagepocket/lib": "0.8.6",
-    "@pagepocket/plugin-yt-dlp": "0.8.6",
-    "@pagepocket/single-file-unit": "0.8.6",
-    "@pagepocket/write-down-unit": "0.8.6"
+    "@pagepocket/build-snapshot-unit": "0.9.1",
+    "@pagepocket/capture-http-puppeteer-unit": "0.9.1",
+    "@pagepocket/capture-http-lighterceptor-unit": "0.9.1",
+    "@pagepocket/capture-http-cdp-unit": "0.9.1",
+    "@pagepocket/lib": "0.9.1",
+    "@pagepocket/contracts": "0.9.1",
+    "@pagepocket/plugin-yt-dlp": "0.9.1",
+    "@pagepocket/single-file-unit": "0.9.1",
+    "@pagepocket/write-down-unit": "0.9.1"
   },
   "devDependencies": {
     "@types/koa": "^2.15.0",
@@ -41,6 +41,7 @@
   },
   "oclif": {
     "bin": "pp",
+    "topicSeparator": " ",
     "commands": {
       "strategy": "pattern",
       "target": "dist/commands"