@pagepocket/cli 0.10.1 → 0.11.0

package/dist/commands/archive.js

@@ -1,20 +1,99 @@
 "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 lib_1 = require("@pagepocket/lib");
 const chalk_1 = __importDefault(require("chalk"));
 const load_configured_plugins_1 = require("../services/load-configured-plugins");
 const config_service_1 = require("../services/config-service");
-const read_installed_package_version_1 = require("../services/strategy/read-installed-package-version");
+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 loadStrategyUnits = async (input) => {
+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();
@@ -45,19 +124,52 @@ const loadStrategyUnits = async (input) => {
         throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
             `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
     }
-    const loadedUnits = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
-    const seen = new Set();
-    const dup = loadedUnits.find((u) => {
-        if (seen.has(u.id)) {
-            return true;
-        }
-        seen.add(u.id);
-        return false;
+    const units = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
     });
-    if (dup) {
-        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
+    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.`);
     }
-    return loadedUnits;
+    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 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() {
@@ -73,20 +185,16 @@ class ArchiveCommand extends core_1.Command {
                 const name = strategyName && strategyName.length > 0 ? strategyName : "default";
                 const strategyService = new strategy_service_1.StrategyService(configService);
                 strategyService.ensureConfigFileExists();
-                const installedNames = strategyService.listInstalledStrategyNames();
-                if (installedNames.length === 0) {
-                    const v = (0, read_installed_package_version_1.readInstalledPackageVersion)("@pagepocket/builtin-strategy");
-                    await strategyService.addStrategy({
-                        source: `@pagepocket/builtin-strategy@${v}`,
-                        force: false
-                    });
-                }
-                const units = await loadStrategyUnits({
+                const strategy = resolveStrategy({
                     strategyName: name,
+                    strategyService
+                });
+                const units = await loadStrategyUnits({
+                    strategy,
                     configService
                 });
                 const entryTarget = pagepocket;
-                const strategyFile = strategyService.readStrategy(name);
+                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;
@@ -133,7 +241,7 @@ ArchiveCommand.flags = {
         required: false
     }),
     strategy: core_1.Flags.string({
-        description: "Run an installed strategy (unit pipeline) by name"
+        description: "Run an installed or built-in strategy (unit pipeline) by name"
     })
 };
 exports.default = ArchiveCommand;

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/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;

package/dist/services/strategy/strategy-analyze.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureNoInstalledVersionConflicts = exports.computeDrift = exports.computeConflicts = exports.collectWantedVersions = exports.uniq = void 0;
+exports.ensureNoInstalledVersionConflicts = exports.computeDrift = exports.computeConflicts = exports.collectWantedVersions = void 0;
 const parse_pinned_spec_1 = require("../user-packages/parse-pinned-spec");
-const uniq = (xs) => [...new Set(xs)];
-exports.uniq = uniq;
 const collectWantedVersions = (strategies) => {
     var _a, _b, _c;
     const wanted = {};

package/dist/services/strategy/strategy-config.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withoutStrategyInConfig = exports.withStrategyInConfig = exports.requireStrategyInstalled = exports.listStrategyNamesFromConfig = void 0;
-const uniq = (xs) => [...new Set(xs)];
+const array_1 = require("../../utils/array");
 const listStrategyNamesFromConfig = (config) => {
-    return uniq((config.strategies ?? []).map((s) => s.trim()).filter((s) => s.length > 0));
+    return (0, array_1.uniq)((config.strategies ?? []).map((s) => s.trim()).filter((s) => s.length > 0));
 };
 exports.listStrategyNamesFromConfig = listStrategyNamesFromConfig;
 const requireStrategyInstalled = (config, name) => {
@@ -14,7 +14,7 @@ const requireStrategyInstalled = (config, name) => {
 };
 exports.requireStrategyInstalled = requireStrategyInstalled;
 const withStrategyInConfig = (config, name) => {
-    const strategies = uniq([...(config.strategies ?? []), name]);
+    const strategies = (0, array_1.uniq)([...(config.strategies ?? []), name]);
     return { ...config, strategies };
 };
 exports.withStrategyInConfig = withStrategyInConfig;

package/dist/services/strategy/strategy-service.js

@@ -8,6 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const config_service_1 = require("../config-service");
 const parse_pinned_spec_1 = require("../user-packages/parse-pinned-spec");
 const unit_store_1 = require("../units/unit-store");
+const array_1 = require("../../utils/array");
 const strategy_analyze_1 = require("./strategy-analyze");
 const strategy_config_1 = require("./strategy-config");
 const strategy_fetch_1 = require("./strategy-fetch");
@@ -58,7 +59,7 @@ class StrategyService {
                 throw new Error(`No *.strategy.json found in package: ${pinned.spec}`);
             }
             const allUnits = strategies.flatMap((s) => (0, strategy_normalize_1.normalizeStrategyUnits)(s));
-            const refs = (0, strategy_analyze_1.uniq)(allUnits.map((u) => u.ref));
+            const refs = (0, array_1.uniq)(allUnits.map((u) => u.ref));
             (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(this.unitStore.readInstalledDependencyVersions(), refs);
             refs.forEach((ref) => this.unitStore.installPinned(ref));
             const installedStrategies = [];
@@ -95,7 +96,7 @@ class StrategyService {
         }
         const { strategy, source } = await (0, strategy_fetch_1.fetchStrategyFile)(sourceTrimmed);
         const normalizedUnits = (0, strategy_normalize_1.normalizeStrategyUnits)(strategy);
-        const refs = (0, strategy_analyze_1.uniq)(normalizedUnits.map((u) => u.ref));
+        const refs = (0, array_1.uniq)(normalizedUnits.map((u) => u.ref));
         const strategyPath = this.getStrategyPath(strategy.name);
         if (!input.force && node_fs_1.default.existsSync(strategyPath)) {
             throw new Error(`Strategy already exists: ${strategy.name}`);
@@ -129,7 +130,7 @@ class StrategyService {
         }
         const installed = this.unitStore.readInstalledDependencyVersions();
         if (opts?.packageOnly) {
-            const packageNames = (0, strategy_analyze_1.uniq)(names
+            const packageNames = (0, array_1.uniq)(names
                 .flatMap((n) => (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n)).map((u) => (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref).name))
                 .filter((x) => x.trim().length > 0));
             packageNames.forEach((pkg) => {
@@ -232,7 +233,7 @@ class StrategyService {
         if (conflicts.length > 0) {
             throw new Error(`Strategy version conflicts detected (${conflicts.length}). Run 'pp strategy doctor' for details.`);
         }
-        const refs = (0, strategy_analyze_1.uniq)(nextStrategies.flatMap((s) => s.units.map((u) => u.ref)));
+        const refs = (0, array_1.uniq)(nextStrategies.flatMap((s) => s.units.map((u) => u.ref)));
         (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(installed, refs);
         refs.forEach((ref) => {
             this.unitStore.installPinned(ref);

package/dist/services/user-packages/parse-pinned-spec.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePinnedSpec = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
 const isRecord = (value) => {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 };
@@ -12,7 +17,8 @@ const parsePinnedSpec = (input) => {
     if (!trimmed) {
         throw new Error("package spec is empty");
     }
-    const npa = require("npm-package-arg");
+    const req = (0, node_module_1.createRequire)(typeof __filename === "string" ? __filename : node_path_1.default.join(process.cwd(), "package.json"));
+    const npa = req("npm-package-arg");
     const parsed = npa(trimmed);
     if (!isRecord(parsed)) {
         throw new Error(`Invalid package spec: ${trimmed}`);

package/dist/utils/array.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniq = void 0;
+const uniq = (items) => {
+    return [...new Set(items)];
+};
+exports.uniq = uniq;

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

@@ -1,12 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePluginSpec = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
 const parsePluginSpec = (spec) => {
     const trimmed = spec.trim();
     if (!trimmed) {
         throw new Error("plugin spec is empty");
     }
-    const npa = require("npm-package-arg");
+    const req = (0, node_module_1.createRequire)(typeof __filename === "string" ? __filename : node_path_1.default.join(process.cwd(), "package.json"));
+    const npa = req("npm-package-arg");
     const parsed = npa(trimmed);
     if (!parsed || typeof parsed.name !== "string" || !parsed.name) {
         throw new Error(`Invalid plugin spec: ${trimmed}`);

package/package.json

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

package/dist/services/strategy/read-installed-package-version.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readInstalledPackageVersion = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const parse_json_1 = require("../../utils/parse-json");
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const readInstalledPackageVersion = (packageName) => {
-    const req = globalThis.require;
-    if (!req) {
-        throw new Error("require is not available in this runtime");
-    }
-    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
-    const text = node_fs_1.default.readFileSync(pkgJsonPath, "utf8");
-    const parsed = (0, parse_json_1.parseJson)(text);
-    if (!parsed.ok) {
-        throw parsed.error;
-    }
-    if (!isRecord(parsed.value) || typeof parsed.value.version !== "string") {
-        throw new Error(`Failed to read package version: ${packageName}`);
-    }
-    return parsed.value.version;
-};
-exports.readInstalledPackageVersion = readInstalledPackageVersion;