@pagepocket/cli 0.9.1 → 0.10.1

package/dist/commands/archive.js

@@ -4,83 +4,97 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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 read_installed_package_version_1 = require("../services/strategy/read-installed-package-version");
+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_store_1 = require("../services/units/unit-store");
 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 loadStrategyUnits = 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 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;
+    });
+    if (dup) {
+        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
     }
-    return `${url.slice(0, MAX_STATUS_URL_LENGTH - 3)}...`;
+    return loadedUnits;
 };
 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());
+                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 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
+                    });
                 }
-                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 units = await loadStrategyUnits({
+                    strategyName: name,
+                    configService
+                });
+                const entryTarget = pagepocket;
+                const strategyFile = strategyService.readStrategy(name);
+                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 +123,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 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/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/read-installed-package-version.js

@@ -0,0 +1,28 @@
+"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;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNoInstalledVersionConflicts = exports.computeDrift = exports.computeConflicts = exports.collectWantedVersions = exports.uniq = 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 = {};
+    for (const s of strategies) {
+        for (const u of s.units) {
+            const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref);
+            wanted[_a = pinned.name] ?? (wanted[_a] = {});
+            (_b = wanted[pinned.name])[_c = pinned.version] ?? (_b[_c] = []);
+            wanted[pinned.name][pinned.version].push(s.name);
+        }
+    }
+    return wanted;
+};
+exports.collectWantedVersions = collectWantedVersions;
+const computeConflicts = (wanted) => {
+    const conflicts = [];
+    for (const [name, versions] of Object.entries(wanted)) {
+        const uniqueVersions = Object.keys(versions);
+        if (uniqueVersions.length <= 1) {
+            continue;
+        }
+        conflicts.push({ name, versions });
+    }
+    return conflicts;
+};
+exports.computeConflicts = computeConflicts;
+const computeDrift = (input) => {
+    const items = input.units.flatMap((u) => {
+        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref);
+        const installedVersion = input.installed[pinned.name];
+        if (!installedVersion || installedVersion !== pinned.version) {
+            return [
+                {
+                    name: pinned.name,
+                    pinned: pinned.version,
+                    installed: installedVersion
+                }
+            ];
+        }
+        return [];
+    });
+    return { strategy: input.strategyName, items };
+};
+exports.computeDrift = computeDrift;
+const ensureNoInstalledVersionConflicts = (installed, refs) => {
+    const byName = {};
+    for (const ref of refs) {
+        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(ref);
+        const already = byName[pinned.name];
+        if (already && already !== pinned.version) {
+            throw new Error(`Strategy contains conflicting versions for ${pinned.name}: ${already} vs ${pinned.version}`);
+        }
+        byName[pinned.name] = pinned.version;
+    }
+    for (const [name, version] of Object.entries(byName)) {
+        const installedVersion = installed[name];
+        if (installedVersion && installedVersion !== version) {
+            throw new Error(`Version conflict for ${name}: installed ${installedVersion}, strategy requires ${version}. ` +
+                "This CLI stores only one version per package name.");
+        }
+    }
+};
+exports.ensureNoInstalledVersionConflicts = ensureNoInstalledVersionConflicts;

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

@@ -0,0 +1,25 @@
+"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 listStrategyNamesFromConfig = (config) => {
+    return uniq((config.strategies ?? []).map((s) => s.trim()).filter((s) => s.length > 0));
+};
+exports.listStrategyNamesFromConfig = listStrategyNamesFromConfig;
+const requireStrategyInstalled = (config, name) => {
+    const installed = (0, exports.listStrategyNamesFromConfig)(config);
+    if (!installed.includes(name)) {
+        throw new Error(`Strategy not installed: ${name}`);
+    }
+};
+exports.requireStrategyInstalled = requireStrategyInstalled;
+const withStrategyInConfig = (config, name) => {
+    const strategies = uniq([...(config.strategies ?? []), name]);
+    return { ...config, strategies };
+};
+exports.withStrategyInConfig = withStrategyInConfig;
+const withoutStrategyInConfig = (config, name) => {
+    const strategies = (config.strategies ?? []).filter((s) => s !== name);
+    return { ...config, strategies };
+};
+exports.withoutStrategyInConfig = withoutStrategyInConfig;

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchStrategyFile = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const parse_json_1 = require("../../utils/parse-json");
+const normalize_argv_1 = require("../../utils/normalize-argv");
+const isRecord = (value) => {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const isStrategyFile = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.schemaVersion !== 1) {
+        return false;
+    }
+    if (typeof value.name !== "string" || value.name.trim().length === 0) {
+        return false;
+    }
+    const pipeline = value.pipeline;
+    if (!isRecord(pipeline)) {
+        return false;
+    }
+    if (!Array.isArray(pipeline.units)) {
+        return false;
+    }
+    return true;
+};
+const readTextFromPath = (p) => {
+    const full = node_path_1.default.resolve(p);
+    return node_fs_1.default.readFileSync(full, "utf8");
+};
+const fetchStrategyFile = async (input) => {
+    const raw = input.trim();
+    if (!raw) {
+        throw new Error("strategy source is empty");
+    }
+    if ((0, normalize_argv_1.isUrlLike)(raw)) {
+        const url = new URL(raw);
+        if (url.protocol !== "https:" && url.protocol !== "http:") {
+            throw new Error(`Unsupported strategy URL protocol: ${url.protocol}`);
+        }
+        const res = await fetch(url.toString());
+        if (!res.ok) {
+            throw new Error(`Failed to fetch strategy: ${res.status} ${res.statusText}`);
+        }
+        const text = await res.text();
+        const parsed = (0, parse_json_1.parseJson)(text);
+        if (!parsed.ok) {
+            throw parsed.error;
+        }
+        if (!isStrategyFile(parsed.value)) {
+            throw new Error(`Invalid strategy JSON from URL: ${url.toString()}`);
+        }
+        return { strategy: parsed.value, source: { type: "url", value: url.toString() } };
+    }
+    const text = readTextFromPath(raw);
+    const parsed = (0, parse_json_1.parseJson)(text);
+    if (!parsed.ok) {
+        throw parsed.error;
+    }
+    if (!isStrategyFile(parsed.value)) {
+        throw new Error(`Invalid strategy JSON from file: ${raw}`);
+    }
+    return { strategy: parsed.value, source: { type: "file", value: node_path_1.default.resolve(raw) } };
+};
+exports.fetchStrategyFile = fetchStrategyFile;