@pagepocket/cli 0.9.2 → 0.11.0

package/dist/commands/archive.js

@@ -1,86 +1,208 @@
 "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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_module_1 = require("node:module");
+const node_url_1 = require("node:url");
 const core_1 = require("@oclif/core");
-const build_snapshot_unit_1 = require("@pagepocket/build-snapshot-unit");
-const capture_http_cdp_unit_1 = require("@pagepocket/capture-http-cdp-unit");
-const capture_http_lighterceptor_unit_1 = require("@pagepocket/capture-http-lighterceptor-unit");
-const capture_http_puppeteer_unit_1 = require("@pagepocket/capture-http-puppeteer-unit");
 const lib_1 = require("@pagepocket/lib");
-const single_file_unit_1 = require("@pagepocket/single-file-unit");
-const write_down_unit_1 = require("@pagepocket/write-down-unit");
 const chalk_1 = __importDefault(require("chalk"));
 const load_configured_plugins_1 = require("../services/load-configured-plugins");
-const network_observer_unit_1 = require("../units/network-observer-unit");
+const config_service_1 = require("../services/config-service");
+const builtin_strategy_registry_1 = require("../services/strategy/builtin-strategy-registry");
+const strategy_service_1 = require("../services/strategy/strategy-service");
+const strategy_normalize_1 = require("../services/strategy/strategy-normalize");
+const parse_pinned_spec_1 = require("../services/user-packages/parse-pinned-spec");
+const unit_validate_1 = require("../services/units/unit-validate");
+const unit_store_1 = require("../services/units/unit-store");
+const array_1 = require("../utils/array");
 const with_spinner_1 = require("../utils/with-spinner");
-const MAX_STATUS_URL_LENGTH = 80;
-const formatStatusUrl = (url) => {
-    if (url.length <= MAX_STATUS_URL_LENGTH) {
-        return url;
+const buildMissingStrategyError = (input) => {
+    const available = (0, array_1.uniq)([...input.installedNames, ...(0, builtin_strategy_registry_1.listBuiltinStrategyNames)()])
+        .filter((name) => name.trim().length > 0)
+        .sort((left, right) => left.localeCompare(right));
+    const suffix = available.length > 0 ? ` Available strategies: ${available.join(", ")}` : " No strategies found.";
+    return new Error(`Strategy not found: ${input.strategyName}.${suffix}`);
+};
+const resolveStrategy = (input) => {
+    const installedNames = input.strategyService.listInstalledStrategyNames();
+    if (installedNames.includes(input.strategyName)) {
+        return {
+            name: input.strategyName,
+            strategyFile: input.strategyService.readStrategy(input.strategyName),
+            source: "installed"
+        };
+    }
+    const builtin = (0, builtin_strategy_registry_1.readBuiltinStrategy)(input.strategyName);
+    if (builtin) {
+        return {
+            name: input.strategyName,
+            strategyFile: builtin,
+            source: "builtin"
+        };
+    }
+    throw buildMissingStrategyError({
+        strategyName: input.strategyName,
+        installedNames
+    });
+};
+const assertNoDuplicateUnitIds = (input) => {
+    const seen = new Set();
+    const dup = input.units.find((u) => {
+        if (seen.has(u.id)) {
+            return true;
+        }
+        seen.add(u.id);
+        return false;
+    });
+    if (dup) {
+        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
+    }
+};
+const loadInstalledStrategyUnits = async (input) => {
+    const strategyService = new strategy_service_1.StrategyService(input.configService);
+    const unitStore = new unit_store_1.UnitStore(input.configService);
+    strategyService.ensureConfigFileExists();
+    const strategyFile = strategyService.readStrategy(input.strategyName);
+    const normalized = (0, strategy_normalize_1.normalizeStrategyUnits)(strategyFile);
+    const installed = unitStore.readInstalledDependencyVersions();
+    const drift = normalized.flatMap((u) => {
+        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref);
+        const installedVersion = installed[pinned.name];
+        if (!installedVersion || installedVersion !== pinned.version) {
+            return [
+                {
+                    name: pinned.name,
+                    pinned: pinned.version,
+                    installed: installedVersion
+                }
+            ];
+        }
+        return [];
+    });
+    if (drift.length > 0) {
+        const details = drift
+            .map((d) => {
+            const installedText = typeof d.installed === "string" ? d.installed : "(not installed)";
+            return `${d.name}: pinned ${d.pinned}, installed ${installedText}`;
+        })
+            .join("; ");
+        throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
+            `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
+    }
+    const units = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
+    });
+    return units;
+};
+const instantiateBuiltinUnit = async (input) => {
+    const req = (0, node_module_1.createRequire)(__filename);
+    const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(input.ref);
+    const resolved = req.resolve(pinned.name);
+    const mod = (await Promise.resolve(`${(0, node_url_1.pathToFileURL)(resolved).href}`).then(s => __importStar(require(s))));
+    const def = mod.default;
+    if (typeof def !== "function") {
+        throw new Error(`Unit ${pinned.name} must default export a constructor.`);
+    }
+    const ctor = def;
+    const instance = new ctor(...input.args);
+    if (!(0, unit_validate_1.isUnitLike)(instance)) {
+        throw new Error(`Unit ${pinned.name} default export did not construct a Unit.`);
     }
-    return `${url.slice(0, MAX_STATUS_URL_LENGTH - 3)}...`;
+    return instance;
+};
+const loadBuiltinStrategyUnits = async (input) => {
+    const normalized = (0, strategy_normalize_1.normalizeStrategyUnits)(input.strategyFile);
+    const units = await Promise.all(normalized.map(async (u) => instantiateBuiltinUnit({
+        ref: u.ref,
+        args: u.args
+    })));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
+    });
+    return units;
+};
+const loadStrategyUnits = async (input) => {
+    if (input.strategy.source === "installed") {
+        return loadInstalledStrategyUnits({
+            strategyName: input.strategy.name,
+            configService: input.configService
+        });
+    }
+    return loadBuiltinStrategyUnits({
+        strategyName: input.strategy.name,
+        strategyFile: input.strategy.strategyFile
+    });
 };
 class ArchiveCommand extends core_1.Command {
     async run() {
         const { args, flags } = await this.parse(ArchiveCommand);
         const targetUrl = args.url;
-        const outputFlag = flags.output ? flags.output.trim() : undefined;
-        const emit = flags.emit;
-        const type = flags.type;
-        const overwrite = flags.overwrite === true;
-        const triggerActions = (flags.action ?? []);
-        const runtime = flags.runtime;
         const timeoutMs = typeof flags.timeout === "number" ? flags.timeout : undefined;
         const maxDurationMs = typeof flags.maxDuration === "number" ? flags.maxDuration : undefined;
-        const headers = {
-            "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
-            accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-            "accept-language": "en-US,en;q=0.9",
-            referer: targetUrl
-        };
+        const strategyName = typeof flags.strategy === "string" ? flags.strategy.trim() : undefined;
         const pagepocket = lib_1.PagePocket.fromURL(targetUrl);
-        if (type === "single-file" && emit === "zip") {
-            throw new Error("--type single-file is not compatible with --emit zip (single-file is a directory output)");
-        }
         const result = await (0, with_spinner_1.withSpinner)(async (spinner) => {
             {
-                const writeDownOptions = {
-                    type: emit,
-                    outputPath: outputFlag ?? process.cwd(),
-                    overwrite
-                };
-                const captureUnit = runtime === "puppeteer"
-                    ? new capture_http_puppeteer_unit_1.CaptureHttpPuppeteerUnit({ triggerActions })
-                    : runtime === "lighterceptor"
-                        ? new capture_http_lighterceptor_unit_1.CaptureHttpLighterceptorUnit({ headers, triggerActions })
-                        : new capture_http_cdp_unit_1.CaptureHttpCdpUnit({ triggerActions });
-                const units = [
-                    new network_observer_unit_1.NetworkObserverUnit({
-                        onRequest: (event) => {
-                            spinner.text = `Freezing page (${formatStatusUrl(event.url)})`;
-                        }
-                    }),
-                    captureUnit,
-                    new build_snapshot_unit_1.BuildSnapshotUnit()
-                ];
-                if (type === "single-file") {
-                    units.push(new single_file_unit_1.SingleFileUnit());
-                }
-                units.push(new write_down_unit_1.WriteDownUnit(writeDownOptions));
-                const entryTarget = runtime === "cdp"
-                    ? (() => {
-                        const tabId = flags.tabId;
-                        if (typeof tabId !== "number") {
-                            throw new Error("--tabId is required when --runtime cdp");
-                        }
-                        return lib_1.PagePocket.fromCDPTab(tabId);
-                    })()
-                    : pagepocket;
+                const configService = new config_service_1.ConfigService();
+                const name = strategyName && strategyName.length > 0 ? strategyName : "default";
+                const strategyService = new strategy_service_1.StrategyService(configService);
+                strategyService.ensureConfigFileExists();
+                const strategy = resolveStrategy({
+                    strategyName: name,
+                    strategyService
+                });
+                const units = await loadStrategyUnits({
+                    strategy,
+                    configService
+                });
+                const entryTarget = pagepocket;
+                const strategyFile = strategy.strategyFile;
+                const captureOptions = strategyFile.pipeline.captureOptions;
+                const effectiveTimeoutMs = typeof timeoutMs === "number" ? timeoutMs : captureOptions?.timeoutMs;
+                const effectiveMaxDurationMs = typeof maxDurationMs === "number" ? maxDurationMs : captureOptions?.maxDurationMs;
                 const result = await entryTarget.capture({
-                    timeoutMs,
-                    maxDurationMs,
+                    ...(typeof effectiveTimeoutMs === "number" ? { timeoutMs: effectiveTimeoutMs } : {}),
+                    ...(typeof effectiveMaxDurationMs === "number"
+                        ? { maxDurationMs: effectiveMaxDurationMs }
+                        : {}),
                     blacklist: [...lib_1.ga, ...lib_1.ns],
                     units,
                     plugins: await (0, load_configured_plugins_1.loadConfiguredPlugins)().catch(() => [])
@@ -109,47 +231,17 @@ ArchiveCommand.flags = {
     help: core_1.Flags.help({
         char: "h"
     }),
-    output: core_1.Flags.string({
-        char: "o",
-        description: "Output directory"
-    }),
-    emit: core_1.Flags.string({
-        description: "Output format",
-        options: ["raw", "zip"],
-        default: "raw"
-    }),
-    type: core_1.Flags.string({
-        description: "Snapshot type",
-        options: ["directory", "single-file"],
-        default: "directory"
-    }),
-    overwrite: core_1.Flags.boolean({
-        description: "Overwrite existing output directory instead of suffixing",
-        default: false
-    }),
-    action: core_1.Flags.string({
-        char: "a",
-        description: "Trigger action to run during/after capture (repeatable). Use -a multiple times to run multiple actions.",
-        options: Object.values({ HOVER: "HOVER", SCROLL_TO_END: "SCROLL_TO_END" }),
-        multiple: true
-    }),
-    runtime: core_1.Flags.string({
-        char: "r",
-        description: "Interceptor runtime to use",
-        options: ["lighterceptor", "puppeteer", "cdp"],
-        default: "puppeteer"
-    }),
-    tabId: core_1.Flags.integer({
-        description: "CDP tabId (required when --runtime cdp)"
-    }),
     timeout: core_1.Flags.integer({
         char: "t",
         description: "Network idle duration in milliseconds before capture stops",
-        default: 5000
+        required: false
     }),
     maxDuration: core_1.Flags.integer({
         description: "Hard max capture duration in milliseconds",
-        default: 60000
+        required: false
+    }),
+    strategy: core_1.Flags.string({
+        description: "Run an installed or built-in strategy (unit pipeline) by name"
     })
 };
 exports.default = ArchiveCommand;

package/dist/commands/strategy/add.js

@@ -0,0 +1,34 @@
+"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 {
+    async run() {
+        const { args, flags } = await this.parse(StrategyAddCommand);
+        const service = new strategy_service_1.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}`));
+        });
+        out.installedRefs.forEach((ref) => {
+            this.log(chalk_1.default.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

@@ -0,0 +1,34 @@
+"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 {
+    async run() {
+        const service = new strategy_service_1.StrategyService();
+        const report = service.doctor();
+        report.conflicts.forEach((c) => {
+            this.log(chalk_1.default.red(`[CONFLICT] ${c.name}`));
+            Object.entries(c.versions).forEach(([version, strategies]) => {
+                this.log(chalk_1.default.red(`  ${version}: ${strategies.join(", ")}`));
+            });
+        });
+        report.drift.forEach((d) => {
+            this.log(chalk_1.default.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}`));
+            });
+        });
+        if (report.conflicts.length === 0 && report.drift.length === 0) {
+            this.log(chalk_1.default.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,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const builtin_strategy_registry_1 = require("../../services/strategy/builtin-strategy-registry");
+const strategy_service_1 = require("../../services/strategy/strategy-service");
+const array_1 = require("../../utils/array");
+class StrategyLsCommand extends core_1.Command {
+    async run() {
+        const service = new strategy_service_1.StrategyService();
+        service.ensureConfigFileExists();
+        const builtin = (0, builtin_strategy_registry_1.listBuiltinStrategyNames)();
+        const installed = service.listInstalledStrategyNames();
+        const names = (0, array_1.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));
+    }
+}
+StrategyLsCommand.description = "List available strategies.";
+exports.default = StrategyLsCommand;

package/dist/commands/strategy/pin.js

@@ -0,0 +1,21 @@
+"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 {
+    async run() {
+        const { args } = await this.parse(StrategyPinCommand);
+        const service = new strategy_service_1.StrategyService();
+        service.pinStrategy(args.name);
+        this.log(chalk_1.default.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

@@ -0,0 +1,21 @@
+"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 {
+    async run() {
+        const { args } = await this.parse(StrategyRemoveCommand);
+        const service = new strategy_service_1.StrategyService();
+        service.removeStrategy(args.name);
+        this.log(chalk_1.default.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

@@ -0,0 +1,34 @@
+"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 {
+    async run() {
+        const { args, flags } = await this.parse(StrategyUpdateCommand);
+        const service = new strategy_service_1.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_1.default.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/services/config-service.js

@@ -10,7 +10,9 @@ 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: []
+    plugins: [],
+    strategies: [],
+    strategyPacks: []
 };
 class ConfigService {
     constructor(appName = "pagepocket") {
@@ -57,27 +59,57 @@ class ConfigService {
             return defaultConfig;
         }
         const pluginsRaw = value.plugins;
-        if (!Array.isArray(pluginsRaw)) {
-            return defaultConfig;
-        }
-        const plugins = pluginsRaw
-            .map((entry) => {
-            if (typeof entry === "string") {
-                return entry;
-            }
-            if (this.isObject(entry) && typeof entry.name === "string") {
-                const spec = "spec" in entry && typeof entry.spec === "string" ? entry.spec : undefined;
-                const options = "options" in entry ? entry.options : undefined;
-                return {
-                    name: entry.name,
-                    ...(typeof spec === "undefined" ? {} : { spec }),
-                    ...(typeof options === "undefined" ? {} : { options })
-                };
-            }
-            return undefined;
-        })
-            .filter((x) => typeof x !== "undefined");
-        return { plugins };
+        const plugins = Array.isArray(pluginsRaw)
+            ? pluginsRaw
+                .map((entry) => {
+                if (typeof entry === "string") {
+                    return entry;
+                }
+                if (this.isObject(entry) && typeof entry.name === "string") {
+                    const spec = "spec" in entry && typeof entry.spec === "string"
+                        ? entry.spec
+                        : undefined;
+                    const options = "options" in entry ? entry.options : undefined;
+                    return {
+                        name: entry.name,
+                        ...(typeof spec === "undefined" ? {} : { spec }),
+                        ...(typeof options === "undefined" ? {} : { options })
+                    };
+                }
+                return undefined;
+            })
+                .filter((x) => typeof x !== "undefined")
+            : [];
+        const strategiesRaw = value.strategies;
+        const strategies = Array.isArray(strategiesRaw)
+            ? strategiesRaw
+                .map((x) => (typeof x === "string" ? x.trim() : ""))
+                .filter((x) => x.length > 0)
+            : [];
+        const packsRaw = value.strategyPacks;
+        const strategyPacks = Array.isArray(packsRaw)
+            ? packsRaw
+                .map((entry) => {
+                if (typeof entry === "string") {
+                    return entry.trim();
+                }
+                if (this.isObject(entry) &&
+                    typeof entry.name === "string" &&
+                    typeof entry.spec === "string") {
+                    return {
+                        name: entry.name.trim(),
+                        spec: entry.spec.trim()
+                    };
+                }
+                return undefined;
+            })
+                .filter((x) => Boolean(x))
+            : [];
+        return {
+            plugins,
+            strategies,
+            strategyPacks
+        };
     }
     readConfig() {
         const configPath = this.getConfigPath();

package/dist/services/strategy/builtin-strategy-registry.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBuiltinStrategy = exports.listBuiltinStrategyNames = exports.readBuiltinStrategies = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
+const strategy_pack_read_1 = require("./strategy-pack-read");
+const readBuiltinStrategiesUnsafe = () => {
+    const req = (0, node_module_1.createRequire)(__filename);
+    const pkgJsonPath = req.resolve("@pagepocket/builtin-strategy/package.json");
+    const packRoot = node_path_1.default.dirname(pkgJsonPath);
+    return (0, strategy_pack_read_1.readStrategiesFromPackRoot)(packRoot);
+};
+const readBuiltinStrategies = () => {
+    try {
+        return readBuiltinStrategiesUnsafe();
+    }
+    catch {
+        return [];
+    }
+};
+exports.readBuiltinStrategies = readBuiltinStrategies;
+const listBuiltinStrategyNames = () => {
+    return (0, exports.readBuiltinStrategies)().map((strategy) => strategy.name);
+};
+exports.listBuiltinStrategyNames = listBuiltinStrategyNames;
+const readBuiltinStrategy = (name) => {
+    return (0, exports.readBuiltinStrategies)().find((strategy) => strategy.name === name);
+};
+exports.readBuiltinStrategy = readBuiltinStrategy;