@pagepocket/cli 0.11.1 → 0.12.0

package/dist/commands/archive.js

@@ -3,14 +3,14 @@ import { pathToFileURL } from "node:url";
 import { Args, Command, Flags } from "@oclif/core";
 import { ga, ns, PagePocket } from "@pagepocket/lib";
 import chalk from "chalk";
-import { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
 import { ConfigService } from "../services/config-service.js";
+import { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
 import { readBuiltinStrategy, listBuiltinStrategyNames } from "../services/strategy/builtin-strategy-registry.js";
-import { StrategyService } from "../services/strategy/strategy-service.js";
 import { normalizeStrategyUnits } from "../services/strategy/strategy-normalize.js";
-import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
-import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
+import { StrategyService } from "../services/strategy/strategy-service.js";
 import { UnitStore } from "../services/units/unit-store.js";
+import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
+import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
 import { uniq } from "../utils/array.js";
 import { withSpinner } from "../utils/with-spinner.js";
 const buildMissingStrategyError = (input) => {
@@ -46,15 +46,15 @@ const resolveStrategy = (input) => {
 };
 const assertNoDuplicateUnitIds = (input) => {
     const seen = new Set();
-    const dup = input.units.find((u) => {
-        if (seen.has(u.id)) {
+    const duplicateUnit = input.units.find((unit) => {
+        if (seen.has(unit.id)) {
             return true;
         }
-        seen.add(u.id);
+        seen.add(unit.id);
         return false;
     });
-    if (dup) {
-        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
+    if (duplicateUnit) {
+        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${duplicateUnit.id}`);
     }
 };
 const loadInstalledStrategyUnits = async (input) => {
@@ -64,8 +64,8 @@ const loadInstalledStrategyUnits = async (input) => {
     const strategyFile = strategyService.readStrategy(input.strategyName);
     const normalized = normalizeStrategyUnits(strategyFile);
     const installed = unitStore.readInstalledDependencyVersions();
-    const drift = normalized.flatMap((u) => {
-        const pinned = parsePinnedSpec(u.ref);
+    const drift = normalized.flatMap((unit) => {
+        const pinned = parsePinnedSpec(unit.ref);
         const installedVersion = installed[pinned.name];
         if (!installedVersion || installedVersion !== pinned.version) {
             return [
@@ -80,15 +80,15 @@ const loadInstalledStrategyUnits = async (input) => {
     });
     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}`;
+            .map((driftItem) => {
+            const installedText = typeof driftItem.installed === "string" ? driftItem.installed : "(not installed)";
+            return `${driftItem.name}: pinned ${driftItem.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)));
+    const units = await Promise.all(normalized.map(async (unit) => unitStore.instantiateFromRef(unit.ref, unit.args)));
     assertNoDuplicateUnitIds({
         strategyName: input.strategyName,
         units
@@ -112,9 +112,9 @@ const instantiateBuiltinUnit = async (input) => {
 };
 const loadBuiltinStrategyUnits = async (input) => {
     const normalized = normalizeStrategyUnits(input.strategyFile);
-    const units = await Promise.all(normalized.map(async (u) => instantiateBuiltinUnit({
-        ref: u.ref,
-        args: u.args
+    const units = await Promise.all(normalized.map(async (unit) => instantiateBuiltinUnit({
+        ref: unit.ref,
+        args: unit.args
     })));
     assertNoDuplicateUnitIds({
         strategyName: input.strategyName,

package/dist/commands/plugin/set.js

@@ -38,9 +38,7 @@ export default class PluginSetCommand extends Command {
         const configService = new ConfigService();
         configService.ensureConfigFileExists();
         const config = configService.readConfigOrDefault();
-        const targetIndex = config.plugins.findIndex((entry) => {
-            return (typeof entry === "string" ? entry : entry.name) === targetName;
-        });
+        const targetIndex = config.plugins.findIndex((entry) => (typeof entry === "string" ? entry : entry.name) === targetName);
         if (targetIndex < 0) {
             this.log(chalk.gray(`Plugin not found in config: ${targetName}`));
             return;

package/dist/commands/strategy/doctor.js

@@ -6,15 +6,15 @@ export default class StrategyDoctorCommand extends Command {
     async run() {
         const service = new StrategyService();
         const report = service.doctor();
-        report.conflicts.forEach((c) => {
-            this.log(chalk.red(`[CONFLICT] ${c.name}`));
-            Object.entries(c.versions).forEach(([version, strategies]) => {
+        report.conflicts.forEach((conflict) => {
+            this.log(chalk.red(`[CONFLICT] ${conflict.name}`));
+            Object.entries(conflict.versions).forEach(([version, strategies]) => {
                 this.log(chalk.red(`  ${version}: ${strategies.join(", ")}`));
             });
         });
-        report.drift.forEach((d) => {
-            this.log(chalk.yellow(`[DRIFT] ${d.strategy}`));
-            d.items.forEach((item) => {
+        report.drift.forEach((drift) => {
+            this.log(chalk.yellow(`[DRIFT] ${drift.strategy}`));
+            drift.items.forEach((item) => {
                 const installed = typeof item.installed === "string" ? item.installed : "(not installed)";
                 this.log(chalk.yellow(`  ${item.name}: pinned ${item.pinned}, installed ${installed}`));
             });

package/dist/commands/strategy/ls.js

@@ -1,22 +1,39 @@
 import { Command } from "@oclif/core";
-import { listBuiltinStrategyNames } from "../../services/strategy/builtin-strategy-registry.js";
+import chalk from "chalk";
+import { listBuiltinStrategyNames, readBuiltinStrategy } from "../../services/strategy/builtin-strategy-registry.js";
+import { normalizeStrategyUnits } from "../../services/strategy/strategy-normalize.js";
 import { StrategyService } from "../../services/strategy/strategy-service.js";
 import { uniq } from "../../utils/array.js";
+const formatStrategy = (name, strategyFile) => {
+    const units = normalizeStrategyUnits(strategyFile);
+    const pipeline = units.map((unit) => unit.ref).join(" -> ");
+    return pipeline.length > 0 ? `${name}${chalk.dim(`(${pipeline})`)}` : name;
+};
 export default class StrategyLsCommand extends Command {
     static description = "List available strategies.";
     async run() {
         const service = new StrategyService();
         service.ensureConfigFileExists();
-        const builtin = listBuiltinStrategyNames();
-        const installed = service.listInstalledStrategyNames();
-        const names = uniq([...builtin, ...installed])
-            .map((n) => n.trim())
-            .filter((n) => n.length > 0)
-            .sort((a, b) => a.localeCompare(b));
+        const builtinNames = listBuiltinStrategyNames();
+        const installedNames = service.listInstalledStrategyNames();
+        const names = uniq([...builtinNames, ...installedNames])
+            .map((name) => name.trim())
+            .filter((name) => name.length > 0)
+            .sort((left, right) => left.localeCompare(right));
         if (names.length === 0) {
             this.log("No strategies available.");
             return;
         }
-        names.forEach((n) => this.log(n));
+        for (const name of names) {
+            const strategyFile = installedNames.includes(name)
+                ? service.readStrategy(name)
+                : readBuiltinStrategy(name);
+            if (strategyFile) {
+                this.log(formatStrategy(name, strategyFile));
+            }
+            else {
+                this.log(name);
+            }
+        }
     }
 }

package/dist/services/config-service.js

@@ -15,8 +15,8 @@ export class ConfigService {
     }
     getConfigDir() {
         if (process.platform === "win32") {
-            const p = envPaths(this.appName, { suffix: "" });
-            return p.config;
+            const envPathsResult = envPaths(this.appName, { suffix: "" });
+            return envPathsResult.config;
         }
         const homeDir = os.homedir();
         const xdgConfigHome = process.env.XDG_CONFIG_HOME;
@@ -24,8 +24,8 @@ export class ConfigService {
         return path.join(base, this.appName);
     }
     getDataDir() {
-        const p = envPaths(this.appName, { suffix: "" });
-        return p.data;
+        const envPathsResult = envPaths(this.appName, { suffix: "" });
+        return envPathsResult.data;
     }
     getConfigPath() {
         return path.join(this.getConfigDir(), "config.json");
@@ -73,13 +73,13 @@ export class ConfigService {
                 }
                 return undefined;
             })
-                .filter((x) => typeof x !== "undefined")
+                .filter((pluginEntry) => typeof pluginEntry !== "undefined")
             : [];
         const strategiesRaw = value.strategies;
         const strategies = Array.isArray(strategiesRaw)
             ? strategiesRaw
-                .map((x) => (typeof x === "string" ? x.trim() : ""))
-                .filter((x) => x.length > 0)
+                .map((strategyName) => (typeof strategyName === "string" ? strategyName.trim() : ""))
+                .filter((strategyName) => strategyName.length > 0)
             : [];
         const packsRaw = value.strategyPacks;
         const strategyPacks = Array.isArray(packsRaw)
@@ -98,7 +98,7 @@ export class ConfigService {
                 }
                 return undefined;
             })
-                .filter((x) => Boolean(x))
+                .filter((strategyPackEntry) => Boolean(strategyPackEntry))
             : [];
         return {
             plugins,

package/dist/services/plugin-installer.js

@@ -7,16 +7,16 @@ import { spawnSync } from "node:child_process";
  */
 const tryInstallWithFallback = (installDir, packageSpec) => {
     const tryRun = (cmd, args) => {
-        const r = spawnSync(cmd, args, {
+        const result = spawnSync(cmd, args, {
             cwd: installDir,
             stdio: "inherit",
             shell: false
         });
-        if (r.error) {
-            return { ok: false, error: r.error };
+        if (result.error) {
+            return { ok: false, error: result.error };
         }
-        if (typeof r.status === "number" && r.status !== 0) {
-            return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+        if (typeof result.status === "number" && result.status !== 0) {
+            return { ok: false, error: new Error(`${cmd} exited with code ${result.status}`) };
         }
         return { ok: true };
     };
@@ -51,16 +51,16 @@ export const uninstallPluginPackage = (store, input) => {
     store.ensurePluginPackageJson();
     const installDir = store.getInstallDir();
     const tryRun = (cmd, args) => {
-        const r = spawnSync(cmd, args, {
+        const result = spawnSync(cmd, args, {
             cwd: installDir,
             stdio: "inherit",
             shell: false
         });
-        if (r.error) {
-            return { ok: false, error: r.error };
+        if (result.error) {
+            return { ok: false, error: result.error };
         }
-        if (typeof r.status === "number" && r.status !== 0) {
-            return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+        if (typeof result.status === "number" && result.status !== 0) {
+            return { ok: false, error: new Error(`${cmd} exited with code ${result.status}`) };
         }
         return { ok: true };
     };

package/dist/services/plugin-store.js

@@ -15,17 +15,13 @@ export const normalizePluginConfigEntry = (entry) => {
     };
 };
 export const getPluginNameFromSpec = (spec) => spec.name;
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const isCallable = (value) => {
-    return typeof value === "function";
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isCallable = (value) => 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");
+    return Object.values(value).every((entryValue) => typeof entryValue === "string");
 };
 export class PluginStore {
     configService;
@@ -80,11 +76,13 @@ export class PluginStore {
             if (!json.ok || !json.value || typeof json.value !== "object") {
                 return { name: pluginName };
             }
-            const o = json.value;
+            const packageJsonRecord = json.value;
             return {
-                name: typeof o.name === "string" ? o.name : pluginName,
-                description: typeof o.description === "string" ? o.description : undefined,
-                version: typeof o.version === "string" ? o.version : undefined
+                name: typeof packageJsonRecord.name === "string" ? packageJsonRecord.name : pluginName,
+                description: typeof packageJsonRecord.description === "string"
+                    ? packageJsonRecord.description
+                    : undefined,
+                version: typeof packageJsonRecord.version === "string" ? packageJsonRecord.version : undefined
             };
         }
         catch {
@@ -146,7 +144,7 @@ export class PluginStore {
         this.configService.writeConfig(next);
     }
     hasPlugin(config, pluginName) {
-        return config.plugins.some((e) => getPluginNameFromSpec(normalizePluginConfigEntry(e)) === pluginName);
+        return config.plugins.some((pluginEntry) => getPluginNameFromSpec(normalizePluginConfigEntry(pluginEntry)) === pluginName);
     }
     addPluginToConfig(config, entry) {
         const spec = normalizePluginConfigEntry(entry);
@@ -157,7 +155,7 @@ export class PluginStore {
     }
     removePluginFromConfig(config, pluginName) {
         const before = config.plugins;
-        const after = before.filter((e) => getPluginNameFromSpec(normalizePluginConfigEntry(e)) !== pluginName);
+        const after = before.filter((pluginEntry) => getPluginNameFromSpec(normalizePluginConfigEntry(pluginEntry)) !== pluginName);
         return {
             config: { ...config, plugins: after },
             removed: after.length !== before.length

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

@@ -1,23 +1,14 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
+import { MemoryCache } from "@pagepocket/shared";
 import { readStrategiesFromPackRoot } from "./strategy-pack-read.js";
-const readBuiltinStrategiesUnsafe = () => {
-    const req = createRequire(import.meta.url);
-    const pkgJsonPath = req.resolve("@pagepocket/builtin-strategy/package.json");
-    const packRoot = path.dirname(pkgJsonPath);
-    return readStrategiesFromPackRoot(packRoot);
-};
-export const readBuiltinStrategies = () => {
-    try {
-        return readBuiltinStrategiesUnsafe();
-    }
-    catch {
-        return [];
-    }
-};
-export const listBuiltinStrategyNames = () => {
-    return readBuiltinStrategies().map((strategy) => strategy.name);
-};
-export const readBuiltinStrategy = (name) => {
-    return readBuiltinStrategies().find((strategy) => strategy.name === name);
-};
+const BUILTIN_KEY = "builtin";
+const cache = new MemoryCache();
+const resolveBuiltinPackRoot = () => {
+    const require = createRequire(import.meta.url);
+    const packageJsonPath = require.resolve("@pagepocket/builtin-strategy/package.json");
+    return path.dirname(packageJsonPath);
+};
+const loadBuiltinStrategies = () => cache.getOrSet(BUILTIN_KEY, () => readStrategiesFromPackRoot(resolveBuiltinPackRoot()));
+export const listBuiltinStrategyNames = () => loadBuiltinStrategies().map((strategy) => strategy.name);
+export const readBuiltinStrategy = (name) => loadBuiltinStrategies().find((strategy) => strategy.name === name);

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

@@ -1,12 +1,12 @@
 import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 export const collectWantedVersions = (strategies) => {
     const wanted = {};
-    for (const s of strategies) {
-        for (const u of s.units) {
-            const pinned = parsePinnedSpec(u.ref);
+    for (const strategy of strategies) {
+        for (const unit of strategy.units) {
+            const pinned = parsePinnedSpec(unit.ref);
             wanted[pinned.name] ??= {};
             wanted[pinned.name][pinned.version] ??= [];
-            wanted[pinned.name][pinned.version].push(s.name);
+            wanted[pinned.name][pinned.version].push(strategy.name);
         }
     }
     return wanted;
@@ -23,8 +23,8 @@ export const computeConflicts = (wanted) => {
     return conflicts;
 };
 export const computeDrift = (input) => {
-    const items = input.units.flatMap((u) => {
-        const pinned = parsePinnedSpec(u.ref);
+    const items = input.units.flatMap((unit) => {
+        const pinned = parsePinnedSpec(unit.ref);
         const installedVersion = input.installed[pinned.name];
         if (!installedVersion || installedVersion !== pinned.version) {
             return [

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

@@ -1,7 +1,7 @@
 import { uniq } from "../../utils/array.js";
-export const listStrategyNamesFromConfig = (config) => {
-    return uniq((config.strategies ?? []).map((s) => s.trim()).filter((s) => s.length > 0));
-};
+export const listStrategyNamesFromConfig = (config) => uniq((config.strategies ?? [])
+    .map((strategyName) => strategyName.trim())
+    .filter((strategyName) => strategyName.length > 0));
 export const requireStrategyInstalled = (config, name) => {
     const installed = listStrategyNamesFromConfig(config);
     if (!installed.includes(name)) {
@@ -13,6 +13,6 @@ export const withStrategyInConfig = (config, name) => {
     return { ...config, strategies };
 };
 export const withoutStrategyInConfig = (config, name) => {
-    const strategies = (config.strategies ?? []).filter((s) => s !== name);
+    const strategies = (config.strategies ?? []).filter((strategyName) => strategyName !== name);
     return { ...config, strategies };
 };

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

@@ -1,10 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { parseJson } from "../../utils/parse-json.js";
 import { isUrlLike } from "../../utils/normalize-argv.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+import { parseJson } from "../../utils/parse-json.js";
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStrategyFile = (value) => {
     if (!isRecord(value)) {
         return false;

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

@@ -1,9 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseJson } from "../../utils/parse-json.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStrategyFile = (value) => {
     if (!isRecord(value)) {
         return false;
@@ -23,12 +21,8 @@ const isStrategyFile = (value) => {
     }
     return true;
 };
-export const getStrategiesDir = (configService) => {
-    return path.join(configService.getConfigDir(), "strategies");
-};
-export const getStrategyPath = (configService, name) => {
-    return path.join(getStrategiesDir(configService), `${name}.json`);
-};
+export const getStrategiesDir = (configService) => path.join(configService.getConfigDir(), "strategies");
+export const getStrategyPath = (configService, name) => path.join(getStrategiesDir(configService), `${name}.json`);
 export const readStrategyFile = (filePath) => {
     const text = fs.readFileSync(filePath, "utf8");
     const parsed = parseJson(text);

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

@@ -1,20 +1,18 @@
 import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isJsonValue = (value) => {
     if (value === null) {
         return true;
     }
-    const t = typeof value;
-    if (t === "string" || t === "number" || t === "boolean") {
+    const valueType = typeof value;
+    if (valueType === "string" || valueType === "number" || valueType === "boolean") {
         return true;
     }
     if (Array.isArray(value)) {
-        return value.every((v) => isJsonValue(v));
+        return value.every((item) => isJsonValue(item));
     }
     if (isRecord(value)) {
-        return Object.values(value).every((v) => isJsonValue(v));
+        return Object.values(value).every((entryValue) => isJsonValue(entryValue));
     }
     return false;
 };

package/dist/services/strategy/strategy-pack-read.js

@@ -1,9 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseJson } from "../../utils/parse-json.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStrategyFile = (value) => {
     if (!isRecord(value)) {
         return false;
@@ -30,7 +28,7 @@ export const readStrategiesFromPackRoot = (packRoot) => {
     }
     const fileNames = fs
         .readdirSync(strategiesDir)
-        .filter((f) => f.endsWith(".strategy.json"))
+        .filter((fileName) => fileName.endsWith(".strategy.json"))
         .sort((a, b) => a.localeCompare(b));
     return fileNames.map((fileName) => {
         const filePath = path.join(strategiesDir, fileName);

package/dist/services/strategy/strategy-pack-store.js

@@ -1,7 +1,7 @@
 import path from "node:path";
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 import { installPinnedPackage } from "../user-packages/user-package-installer.js";
 import { updatePackageToLatest } from "../user-packages/user-package-installer.js";
-import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 import { UserPackageStore } from "../user-packages/user-package-store.js";
 const STRATEGY_PACKS_KIND = "strategy-packs";
 const STRATEGY_PACKS_PACKAGE_JSON_NAME = "pagepocket-user-strategy-packs";

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

@@ -1,8 +1,8 @@
 import fs from "node:fs";
+import { uniq } from "../../utils/array.js";
 import { ConfigService } from "../config-service.js";
-import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 import { UnitStore } from "../units/unit-store.js";
-import { uniq } from "../../utils/array.js";
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 import { collectWantedVersions, computeConflicts, computeDrift, ensureNoInstalledVersionConflicts } from "./strategy-analyze.js";
 import { listStrategyNamesFromConfig, requireStrategyInstalled, withStrategyInConfig, withoutStrategyInConfig } from "./strategy-config.js";
 import { fetchStrategyFile } from "./strategy-fetch.js";
@@ -55,8 +55,8 @@ export class StrategyService {
             if (strategies.length === 0) {
                 throw new Error(`No *.strategy.json found in package: ${pinned.spec}`);
             }
-            const allUnits = strategies.flatMap((s) => normalizeStrategyUnits(s));
-            const refs = uniq(allUnits.map((u) => u.ref));
+            const allUnits = strategies.flatMap((strategy) => normalizeStrategyUnits(strategy));
+            const refs = uniq(allUnits.map((unit) => unit.ref));
             ensureNoInstalledVersionConflicts(this.unitStore.readInstalledDependencyVersions(), refs);
             refs.forEach((ref) => this.unitStore.installPinned(ref));
             const installedStrategies = [];
@@ -73,13 +73,13 @@ export class StrategyService {
                 writeJsonAtomic(strategyPath, toWrite);
                 installedStrategies.push(name);
             });
-            const nextConfig = installedStrategies.reduce((acc, s) => withStrategyInConfig(acc, s), config);
+            const nextConfig = installedStrategies.reduce((configAccumulator, strategyName) => withStrategyInConfig(configAccumulator, strategyName), config);
             const existing = nextConfig.strategyPacks ?? [];
-            const filtered = existing.filter((x) => {
-                if (typeof x === "string") {
-                    return x.trim().length > 0;
+            const filtered = existing.filter((packEntry) => {
+                if (typeof packEntry === "string") {
+                    return packEntry.trim().length > 0;
                 }
-                return x.name !== pinned.name;
+                return packEntry.name !== pinned.name;
             });
             const strategyPacks = [
                 ...filtered,
@@ -93,7 +93,7 @@ export class StrategyService {
         }
         const { strategy, source } = await fetchStrategyFile(sourceTrimmed);
         const normalizedUnits = normalizeStrategyUnits(strategy);
-        const refs = uniq(normalizedUnits.map((u) => u.ref));
+        const refs = uniq(normalizedUnits.map((unit) => unit.ref));
         const strategyPath = this.getStrategyPath(strategy.name);
         if (!input.force && fs.existsSync(strategyPath)) {
             throw new Error(`Strategy already exists: ${strategy.name}`);
@@ -128,15 +128,15 @@ export class StrategyService {
         const installed = this.unitStore.readInstalledDependencyVersions();
         if (opts?.packageOnly) {
             const packageNames = uniq(names
-                .flatMap((n) => normalizeStrategyUnits(this.readStrategy(n)).map((u) => parsePinnedSpec(u.ref).name))
-                .filter((x) => x.trim().length > 0));
+                .flatMap((strategyName) => normalizeStrategyUnits(this.readStrategy(strategyName)).map((unit) => parsePinnedSpec(unit.ref).name))
+                .filter((packageName) => packageName.trim().length > 0));
             packageNames.forEach((pkg) => {
                 this.unitStore.updateToLatest(pkg);
             });
             const afterInstalled = this.unitStore.readInstalledDependencyVersions();
-            const afterStrategies = listStrategyNamesFromConfig(config).map((n) => ({
-                name: n,
-                units: normalizeStrategyUnits(this.readStrategy(n))
+            const afterStrategies = listStrategyNamesFromConfig(config).map((strategyName) => ({
+                name: strategyName,
+                units: normalizeStrategyUnits(this.readStrategy(strategyName))
             }));
             const wanted = collectWantedVersions(afterStrategies);
             const conflicts = computeConflicts(wanted);
@@ -144,8 +144,12 @@ export class StrategyService {
                 throw new Error(`Strategy version conflicts detected (${conflicts.length}). Run 'pp strategy doctor' for details.`);
             }
             const drift = afterStrategies
-                .map((s) => computeDrift({ strategyName: s.name, units: s.units, installed: afterInstalled }))
-                .filter((d) => d.items.length > 0);
+                .map((strategy) => computeDrift({
+                strategyName: strategy.name,
+                units: strategy.units,
+                installed: afterInstalled
+            }))
+                .filter((drift) => drift.items.length > 0);
             if (drift.length > 0) {
                 throw new Error("Strategy drift detected after --package-only update. Run 'pp strategy doctor'.");
             }
@@ -153,23 +157,23 @@ export class StrategyService {
         }
         const nextStrategies = [];
         const npmPacksToUpdate = new Set();
-        for (const n of names) {
-            const current = this.readStrategy(n);
+        for (const strategyName of names) {
+            const current = this.readStrategy(strategyName);
             const src = current.source;
             if (!src) {
-                throw new Error(`Strategy ${n} has no source. Re-add it with a URL/path source to enable update.`);
+                throw new Error(`Strategy ${strategyName} has no source. Re-add it with a URL/path source to enable update.`);
             }
             if (src.type === "npm") {
                 npmPacksToUpdate.add(src.value);
                 continue;
             }
             const fetched = await fetchStrategyFile(src.value);
-            if (fetched.strategy.name !== n) {
-                throw new Error(`Strategy name mismatch while updating ${n}: got ${fetched.strategy.name}`);
+            if (fetched.strategy.name !== strategyName) {
+                throw new Error(`Strategy name mismatch while updating ${strategyName}: got ${fetched.strategy.name}`);
             }
             const file = { ...fetched.strategy, source: fetched.source };
             const units = normalizeStrategyUnits(file);
-            nextStrategies.push({ name: n, file, units });
+            nextStrategies.push({ name: strategyName, file, units });
         }
         if (npmPacksToUpdate.size > 0) {
             const specs = [...npmPacksToUpdate];
@@ -180,18 +184,18 @@ export class StrategyService {
             const installedPackVersions = this.packStore.readInstalledDependencyVersions();
             const updatedSpecs = specs.map((spec) => {
                 const pinned = parsePinnedSpec(spec);
-                const v = installedPackVersions[pinned.name];
-                if (!v) {
+                const installedVersion = installedPackVersions[pinned.name];
+                if (!installedVersion) {
                     throw new Error(`Strategy pack not installed after update: ${pinned.name}`);
                 }
-                return `${pinned.name}@${v}`;
+                return `${pinned.name}@${installedVersion}`;
             });
             const updatedFiles = [];
             updatedSpecs.forEach((spec) => {
                 const pinned = parsePinnedSpec(spec);
                 const root = this.packStore.resolvePackRoot(pinned.name);
-                const files = readStrategiesFromPackRoot(root).map((f) => ({
-                    ...f,
+                const files = readStrategiesFromPackRoot(root).map((strategyFile) => ({
+                    ...strategyFile,
                     source: { type: "npm", value: spec }
                 }));
                 updatedFiles.push(...files);
@@ -202,11 +206,11 @@ export class StrategyService {
             });
             const nextConfig = this.configService.readConfigOrDefault();
             const existing = nextConfig.strategyPacks ?? [];
-            const filtered = existing.filter((x) => {
-                if (typeof x === "string") {
-                    return x.trim().length > 0;
+            const filtered = existing.filter((packEntry) => {
+                if (typeof packEntry === "string") {
+                    return packEntry.trim().length > 0;
                 }
-                return !updatedSpecs.some((spec) => parsePinnedSpec(spec).name === x.name);
+                return !updatedSpecs.some((spec) => parsePinnedSpec(spec).name === packEntry.name);
             });
             const packsNext = [
                 ...filtered,
@@ -217,26 +221,26 @@ export class StrategyService {
             ];
             this.configService.writeConfig({ ...nextConfig, strategyPacks: packsNext });
         }
-        const allOtherNames = listStrategyNamesFromConfig(config).filter((n) => !names.includes(n));
-        const otherStrategies = allOtherNames.map((n) => ({
-            name: n,
-            units: normalizeStrategyUnits(this.readStrategy(n))
+        const allOtherNames = listStrategyNamesFromConfig(config).filter((strategyName) => !names.includes(strategyName));
+        const otherStrategies = allOtherNames.map((strategyName) => ({
+            name: strategyName,
+            units: normalizeStrategyUnits(this.readStrategy(strategyName))
         }));
         const wanted = collectWantedVersions([
             ...otherStrategies,
-            ...nextStrategies.map((s) => ({ name: s.name, units: s.units }))
+            ...nextStrategies.map((strategy) => ({ name: strategy.name, units: strategy.units }))
         ]);
         const conflicts = computeConflicts(wanted);
         if (conflicts.length > 0) {
             throw new Error(`Strategy version conflicts detected (${conflicts.length}). Run 'pp strategy doctor' for details.`);
         }
-        const refs = uniq(nextStrategies.flatMap((s) => s.units.map((u) => u.ref)));
+        const refs = uniq(nextStrategies.flatMap((strategy) => strategy.units.map((unit) => unit.ref)));
         ensureNoInstalledVersionConflicts(installed, refs);
         refs.forEach((ref) => {
             this.unitStore.installPinned(ref);
         });
-        nextStrategies.forEach((s) => {
-            writeJsonAtomic(this.getStrategyPath(s.name), s.file);
+        nextStrategies.forEach((strategy) => {
+            writeJsonAtomic(this.getStrategyPath(strategy.name), strategy.file);
         });
     }
     pinStrategy(name) {
@@ -246,23 +250,28 @@ export class StrategyService {
         const file = this.readStrategy(name);
         const units = normalizeStrategyUnits(file);
         const installed = this.unitStore.readInstalledDependencyVersions();
-        const pinnedUnits = units.map((u) => {
-            const pinned = parsePinnedSpec(u.ref);
-            const v = installed[pinned.name];
-            if (!v) {
+        const pinnedUnits = units.map((unit) => {
+            const pinned = parsePinnedSpec(unit.ref);
+            const installedVersion = installed[pinned.name];
+            if (!installedVersion) {
                 throw new Error(`Unit package is not installed: ${pinned.name}`);
             }
-            const nextRef = `${pinned.name}@${v}`;
-            return u.args.length === 0 ? nextRef : { ref: nextRef, args: u.args };
+            const nextRef = `${pinned.name}@${installedVersion}`;
+            return unit.args.length === 0 ? nextRef : { ref: nextRef, args: unit.args };
         });
         const others = listStrategyNamesFromConfig(config)
-            .filter((n) => n !== name)
-            .map((n) => ({ name: n, units: normalizeStrategyUnits(this.readStrategy(n)) }));
+            .filter((strategyName) => strategyName !== name)
+            .map((strategyName) => ({
+            name: strategyName,
+            units: normalizeStrategyUnits(this.readStrategy(strategyName))
+        }));
         const nextWanted = collectWantedVersions([
             ...others,
             {
                 name,
-                units: pinnedUnits.map((x) => typeof x === "string" ? { ref: x, args: [] } : { ref: x.ref, args: x.args ?? [] })
+                units: pinnedUnits.map((pinnedUnit) => typeof pinnedUnit === "string"
+                    ? { ref: pinnedUnit, args: [] }
+                    : { ref: pinnedUnit.ref, args: pinnedUnit.args ?? [] })
             }
         ]);
         const conflicts = computeConflicts(nextWanted);
@@ -283,15 +292,15 @@ export class StrategyService {
         const config = this.configService.readConfigOrDefault();
         const names = listStrategyNamesFromConfig(config);
         const installed = this.unitStore.readInstalledDependencyVersions();
-        const strategies = names.map((n) => ({
-            name: n,
-            units: normalizeStrategyUnits(this.readStrategy(n))
+        const strategies = names.map((strategyName) => ({
+            name: strategyName,
+            units: normalizeStrategyUnits(this.readStrategy(strategyName))
         }));
         const wanted = collectWantedVersions(strategies);
         const conflicts = computeConflicts(wanted);
         const drift = strategies
-            .map((s) => computeDrift({ strategyName: s.name, units: s.units, installed }))
-            .filter((d) => d.items.length > 0);
+            .map((strategy) => computeDrift({ strategyName: strategy.name, units: strategy.units, installed }))
+            .filter((drift) => drift.items.length > 0);
         return { conflicts, drift };
     }
 }

package/dist/services/units/unit-store.js

@@ -1,5 +1,5 @@
-import { installPinnedPackage, updatePackageToLatest } from "../user-packages/user-package-installer.js";
 import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
+import { installPinnedPackage, updatePackageToLatest } from "../user-packages/user-package-installer.js";
 import { UserPackageStore } from "../user-packages/user-package-store.js";
 import { isUnitLike, resolveUnitConstructor } from "./unit-validate.js";
 const UNITS_KIND = "units";

package/dist/services/units/unit-validate.js

@@ -1,9 +1,5 @@
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const isCallable = (value) => {
-    return typeof value === "function";
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isCallable = (value) => typeof value === "function";
 export const isUnitLike = (value) => {
     if (!isRecord(value)) {
         return false;
@@ -35,7 +31,8 @@ export const resolveUnitConstructor = (mod) => {
     if (typeof mod.default === "function") {
         return mod.default;
     }
-    const fallback = Object.values(mod).find((v) => typeof v === "function" && v.name?.endsWith("Unit"));
+    const fallback = Object.values(mod).find((exportedValue) => typeof exportedValue === "function" &&
+        exportedValue.name?.endsWith("Unit"));
     if (typeof fallback === "function") {
         return fallback;
     }

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

@@ -1,12 +1,8 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const isExactSemver = (value) => {
-    return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value);
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isExactSemver = (value) => /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value);
 export const parsePinnedSpec = (input) => {
     const trimmed = input.trim();
     if (!trimmed) {

package/dist/services/user-packages/user-package-installer.js

@@ -6,16 +6,16 @@ const toError = (value) => {
     return new Error(String(value));
 };
 const tryRun = (cwd, cmd, args) => {
-    const r = spawnSync(cmd, args, {
+    const result = spawnSync(cmd, args, {
         cwd,
         stdio: "inherit",
         shell: false
     });
-    if (r.error) {
-        return { ok: false, error: toError(r.error) };
+    if (result.error) {
+        return { ok: false, error: toError(result.error) };
     }
-    if (typeof r.status === "number" && r.status !== 0) {
-        return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+    if (typeof result.status === "number" && result.status !== 0) {
+        return { ok: false, error: new Error(`${cmd} exited with code ${result.status}`) };
     }
     return { ok: true };
 };

package/dist/services/user-packages/user-package-store.js

@@ -3,14 +3,12 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseJson } from "../../utils/parse-json.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStringRecord = (value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;
     }
-    return Object.values(value).every((v) => typeof v === "string");
+    return Object.values(value).every((entryValue) => typeof entryValue === "string");
 };
 export class UserPackageStore {
     configService;
@@ -55,11 +53,13 @@ export class UserPackageStore {
             if (!json.ok || !isRecord(json.value)) {
                 return { name: packageName };
             }
-            const o = json.value;
+            const packageJsonRecord = json.value;
             return {
-                name: typeof o.name === "string" ? o.name : packageName,
-                description: typeof o.description === "string" ? o.description : undefined,
-                version: typeof o.version === "string" ? o.version : undefined
+                name: typeof packageJsonRecord.name === "string" ? packageJsonRecord.name : packageName,
+                description: typeof packageJsonRecord.description === "string"
+                    ? packageJsonRecord.description
+                    : undefined,
+                version: typeof packageJsonRecord.version === "string" ? packageJsonRecord.version : undefined
             };
         }
         catch {

package/dist/utils/array.js

@@ -1,3 +1 @@
-export const uniq = (items) => {
-    return [...new Set(items)];
-};
+export const uniq = (items) => [...new Set(items)];

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

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 export const parsePluginSpec = (spec) => {
     const trimmed = spec.trim();

package/dist/view.js

@@ -31,8 +31,8 @@ export const createViewServer = async (args) => {
         });
     });
     const server = await new Promise((resolve, reject) => {
-        const s = app.listen(args.port, args.host, () => resolve(s));
-        s.on("error", reject);
+        const httpServer = app.listen(args.port, args.host, () => resolve(httpServer));
+        httpServer.on("error", reject);
     });
     const address = server.address();
     const port = typeof address === "object" && address ? address.port : args.port;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagepocket/cli",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "CLI for capturing offline snapshots of web pages.",
   "type": "module",
   "main": "dist/index.js",
@@ -22,22 +22,25 @@
     "koa-static": "^5.0.0",
     "npm-package-arg": "^13.0.2",
     "ora": "^9.0.0",
-    "@pagepocket/build-snapshot-unit": "0.11.1",
-    "@pagepocket/capture-http-cdp-unit": "0.11.1",
-    "@pagepocket/capture-http-puppeteer-unit": "0.11.1",
-    "@pagepocket/capture-http-lighterceptor-unit": "0.11.1",
-    "@pagepocket/builtin-strategy": "0.11.1",
-    "@pagepocket/contracts": "0.11.1",
-    "@pagepocket/lib": "0.11.1",
-    "@pagepocket/plugin-yt-dlp": "0.11.1",
-    "@pagepocket/single-file-unit": "0.11.1",
-    "@pagepocket/write-down-unit": "0.11.1"
+    "@pagepocket/main-content-unit": "0.12.0",
+    "@pagepocket/build-snapshot-unit": "0.12.0",
+    "@pagepocket/capture-http-cdp-unit": "0.12.0",
+    "@pagepocket/capture-http-lighterceptor-unit": "0.12.0",
+    "@pagepocket/capture-http-puppeteer-unit": "0.12.0",
+    "@pagepocket/contracts": "0.12.0",
+    "@pagepocket/builtin-strategy": "0.12.0",
+    "@pagepocket/lib": "0.12.0",
+    "@pagepocket/plugin-yt-dlp": "0.12.0",
+    "@pagepocket/shared": "0.12.0",
+    "@pagepocket/single-file-unit": "0.12.0",
+    "@pagepocket/write-down-unit": "0.12.0"
   },
   "devDependencies": {
     "@types/koa": "^2.15.0",
     "@types/koa-send": "^4.1.5",
     "@types/koa-static": "^4.0.4",
     "@types/node": "^20.11.30",
+    "rimraf": "^6.0.1",
     "tsx": "^4.19.3",
     "typescript": "^5.4.5"
   },
@@ -50,7 +53,7 @@
     }
   },
   "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
+    "build": "rimraf dist && tsc",
     "start": "node dist/index.js",
     "test": "pnpm build && tsx --test specs/*.spec.ts"
   }