@loopress/cli 0.25.0 → 0.26.0

package/dist/commands/diff.js

@@ -7,7 +7,7 @@ const RESOURCES = [...RESOURCE_STATE_PROVIDERS.map((provider) => provider.resour
 export default class Diff extends DiffCommand {
     static description = [
         'Show what differs between your local tracked files and a WordPress environment, or between two environments.',
-        'Covers snippets, forms, ACF, API routes, Hooks, SEO, Options, Menus, Theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
+        'Covers snippets, forms, ACF, API routes, Hooks, pages, SEO, Options, Menus, Theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
         'Exit code: 0 in sync, 1 on drift, 2 when a resource could not be compared, so it doubles as a CI drift gate.',
     ].join(' ');
     static enableJsonFlag = true;

package/dist/commands/init.js

@@ -20,6 +20,7 @@ const FEATURES = [
     { dir: 'api', key: 'apiDir', label: 'Custom API routes' },
     { dir: 'hooks', key: 'hooksDir', label: 'Hooks (actions, filters, cron)' },
     { dir: 'apps', key: 'appsDir', label: 'Single-page apps' },
+    { dir: 'pages', key: 'pageDir', label: 'Static pages' },
 ];
 export default class Init extends Command {
     static description = 'Initialize a loopress.json config file in the current directory';

package/dist/commands/page/diff.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/diff-command.js").DiffCommand;
+export default _default;

package/dist/commands/page/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('page', {
+    description: 'Show what differs in static pages between your local files and a WordPress environment, or between two environments',
+    pathNoun: 'pages directory',
+});

package/dist/commands/page/list.d.ts

@@ -0,0 +1,8 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { type RemotePage } from '../../utils/page-format.js';
+export default class List extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<Array<Omit<RemotePage, 'html'>>>;
+}

package/dist/commands/page/list.js

@@ -0,0 +1,22 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { PAGES_ENDPOINT } from '../../utils/page-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class List extends LoopressCommand {
+    static description = 'List the static pages managed by Loopress on WordPress';
+    static enableJsonFlag = true;
+    static examples = ['$ lps page list'];
+    async run() {
+        const pages = await this.wp.get(PAGES_ENDPOINT);
+        // The HTML is only needed by `page diff`, it would drown the JSON output here.
+        const listed = pages.map(({ html: _html, ...page }) => page);
+        if (listed.length === 0) {
+            this.log('No pages managed by Loopress');
+            return listed;
+        }
+        this.log(`Found ${pluralize(listed.length, 'page')}:`);
+        this.log('');
+        for (const page of listed)
+            this.log(`  ${page.slug}  ${page.status}  ${page.link}`);
+        return listed;
+    }
+}

package/dist/commands/page/push.d.ts

@@ -0,0 +1,20 @@
+import { PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    pushed: string[];
+    status: 'dry-run' | 'success';
+};
+export default class Push extends PushCommand {
+    static args: {
+        slug: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<PushResult>;
+    private pushPage;
+}
+export {};

package/dist/commands/page/push.js

@@ -0,0 +1,60 @@
+import { Args } from '@oclif/core';
+import { PushCommand } from '../../lib/push-command.js';
+import { formatPageProblems, PAGES_ENDPOINT, readLocalPages } from '../../utils/page-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+import { resolveResourceDir } from '../../utils/resource-dirs.js';
+export default class Push extends PushCommand {
+    static args = {
+        slug: Args.string({ description: 'Push only this page (its file name without .html). Pushes every page when omitted.' }),
+    };
+    static description = 'Push static HTML pages (pages/<slug>.html) to WordPress. The `status` header (draft or publish, draft by default) is applied on every push.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps page push', '$ lps page push legal-notice', '$ lps page push --dry-run'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const path = resolveResourceDir('page', this.localConfig);
+        this.log(`Pushing pages to ${this.siteConfig.url}`);
+        this.log(`Pages path: ${path}`);
+        const { pages, problems } = await readLocalPages(path);
+        if (problems.length > 0) {
+            this.error(`Nothing was pushed, fix these pages first:\n  ${formatPageProblems(problems)}`);
+        }
+        const selected = args.slug === undefined ? pages : pages.filter((page) => page.slug === args.slug);
+        if (args.slug !== undefined && selected.length === 0) {
+            this.error(`No page "${args.slug}" in ${path} (expected ${args.slug}.html).`);
+        }
+        this.log(`Found ${pluralize(selected.length, 'page')} to push`);
+        const pushed = [];
+        await this.runPushTasks(selected, (page) => page.slug, async (page, task) => {
+            await this.pushPage(page, task);
+            pushed.push(page.slug);
+        });
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'page')} failed to push.`);
+        }
+        if (this.dryRun)
+            return { pushed, status: 'dry-run' };
+        await this.recordSuccess();
+        this.log('All pages pushed.');
+        return { pushed, status: 'success' };
+    }
+    async pushPage(page, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${page.slug} (${page.status})`;
+            return;
+        }
+        try {
+            const result = await this.wp.put(PAGES_ENDPOINT, page);
+            if (task)
+                task.output = `Pushed: ${page.slug} (${result.status}) ${result.link}`;
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${page.slug}: ${error.message}`, error, task);
+        }
+    }
+}

package/dist/commands/push.js

@@ -10,13 +10,14 @@ const PUSH_TARGETS = [
     { commandId: 'api:push', label: 'API routes' },
     { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
+    { commandId: 'page:push', label: 'pages' },
     { commandId: 'seo:push', label: 'SEO' },
     { commandId: 'menu:push', label: 'menus' },
     { commandId: 'option:push', label: 'options' },
     { commandId: 'snippet:push', label: 'snippets' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, menus, options, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, pages, SEO, menus, options, and snippets, to WordPress';
     static enableJsonFlag = true;
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {

package/dist/lib/dev-watch.d.ts

@@ -1,5 +1,5 @@
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
-export type ResourceType = 'api' | 'plugins' | 'snippets';
+export type ResourceType = 'api' | 'pages' | 'plugins' | 'snippets';
 export declare const RESOURCE_TYPES: ResourceType[];
 export type WatchTarget = {
     commandId: string;

package/dist/lib/dev-watch.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { join, sep } from 'node:path';
-export const RESOURCE_TYPES = ['snippets', 'api', 'plugins'];
+export const RESOURCE_TYPES = ['snippets', 'pages', 'api', 'plugins'];
 // `only` narrows the default set, `skip` then removes from whatever that set is, same
 // precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
 export function resolveResourceTypes(only, skip = []) {
@@ -15,6 +15,7 @@ export function buildWatchTargets(types, localConfig, cwd) {
     const rootDir = join(cwd, localConfig.rootDir ?? '.');
     const candidates = {
         api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
+        pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), type: 'pages' },
         plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
         snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
     };

package/dist/lib/resource-state.js

@@ -4,6 +4,7 @@ import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../utils/acf-format.js
 import { FORM_ENDPOINT, getFormId } from '../utils/form-format.js';
 import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT } from '../utils/menu-format.js';
 import { optionEndpoint, parseLocalOption } from '../utils/option-format.js';
+import { formatPageProblems, PAGES_ENDPOINT, readLocalPages } from '../utils/page-format.js';
 import { DEFAULT_POST_TYPES, SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, } from '../utils/seo-format.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../utils/snippet-format.js';
 import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, THEME_STYLES_FILE_SUFFIX, } from '../utils/theme-styles-format.js';
@@ -194,6 +195,28 @@ const hookProvider = phpFilesProvider({
     resource: 'hook',
     title: 'Hooks',
 });
+// ---- Pages ------------------------------------------------------------------------------
+// Keyed by slug (the page's identity on both sides). `link` is server-derived and never
+// compared. A local problem (a `.php` in pages/, a bad header) fails the whole resource rather
+// than hiding that page, the same stop-everything stance as `page push`.
+function canonicalPage(page) {
+    return { html: page.html, status: page.status, title: page.title };
+}
+const pageProvider = {
+    dirKind: 'page',
+    async local(dir) {
+        const { pages, problems } = await readLocalPages(dir);
+        if (problems.length > 0)
+            throw new Error(formatPageProblems(problems));
+        return new Map(pages.map((page) => [page.slug, canonicalPage(page)]));
+    },
+    async remote(wp) {
+        const pages = await wp.get(PAGES_ENDPOINT);
+        return new Map(pages.map((page) => [page.slug, canonicalPage(page)]));
+    },
+    resource: 'page',
+    title: 'Pages',
+};
 // ---- SEO --------------------------------------------------------------------------------
 function canonicalRedirect(redirect) {
     return omit(redirect, REDIRECT_VOLATILE_KEYS);
@@ -403,6 +426,7 @@ export const RESOURCE_STATE_PROVIDERS = [
     acfProvider,
     apiProvider,
     hookProvider,
+    pageProvider,
     seoProvider,
     menuProvider,
     optionsProvider,

package/dist/lib/validate-local.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
+import { readLocalPages } from '../utils/page-format.js';
 import { parseType } from '../utils/snippet-format.js';
 import { loadSnippets } from './load-snippets.js';
 import { readdirTolerant } from './readdir-tolerant.js';
@@ -13,6 +14,7 @@ const DEFAULT_DIR = {
     formDir: 'forms',
     hooksDir: 'hooks',
     menuDir: 'menus',
+    pageDir: 'pages',
     seoDir: 'seo',
     snippetsDir: 'snippets',
 };
@@ -38,6 +40,9 @@ export async function validateLocal(cwd) {
     checked += await checkSnippets(resolve('snippetsDir'), problems);
     checked += await checkPhpDir(resolve('apiDir'), problems, 'API route file is empty');
     checked += await checkPhpDir(resolve('hooksDir'), problems, 'Hook file is empty');
+    const pages = await readLocalPages(resolve('pageDir'));
+    checked += pages.pages.length + pages.problems.length;
+    problems.push(...pages.problems);
     return { checked, problems, valid: problems.length === 0 };
 }
 // Recursive: both api/ and hooks/ files can live in a nested path-segment directory

package/dist/types/project-config.generated.d.ts

@@ -35,6 +35,10 @@ export interface LoopressProjectConfiguration {
      * Directory where single-page app bundles are read from and written to, relative to rootDir. Each subdirectory is one app: a loopress.app.json plus a built dist/ folder.
      */
     appsDir?: string;
+    /**
+     * Directory where static HTML pages (one <slug>.html per WordPress page, managed by Loopress) are read from, relative to rootDir.
+     */
+    pageDir?: string;
     /**
      * Directory where explicitly tracked WordPress options (wp_options rows) are read from and written to, relative to rootDir. Only options added via `lps option add` live here, this is never the whole options table.
      */

package/dist/utils/page-format.d.ts

@@ -0,0 +1,27 @@
+export declare const PAGES_ENDPOINT = "loopress/v1/pages";
+export declare const PAGE_SLUG_PATTERN: RegExp;
+export declare const PAGE_STATUSES: readonly ["draft", "publish"];
+export type PageStatus = (typeof PAGE_STATUSES)[number];
+export type Page = {
+    fullWidth: boolean;
+    hideTitle: boolean;
+    html: string;
+    slug: string;
+    status: PageStatus;
+    template: string;
+    title: string;
+};
+export type RemotePage = Page & {
+    link: string;
+};
+export type PageProblem = {
+    file: string;
+    message: string;
+};
+export declare function formatPageProblems(problems: PageProblem[]): string;
+export declare function titleFromSlug(slug: string): string;
+export declare function parsePageFile(slug: string, raw: string): Page;
+export declare function readLocalPages(dir: string): Promise<{
+    pages: Page[];
+    problems: PageProblem[];
+}>;

package/dist/utils/page-format.js

@@ -0,0 +1,111 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+export const PAGES_ENDPOINT = 'loopress/v1/pages';
+// Mirrored server-side in PagesController. No leading, trailing or doubled hyphen: WordPress's
+// sanitize_title() would rewrite those, and the page would no longer match its file name.
+export const PAGE_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export const PAGE_STATUSES = ['draft', 'publish'];
+const HEADER_KEYS = ['title', 'status', 'full-width', 'hide-title', 'template'];
+function parseBoolean(key, value) {
+    if (value === undefined)
+        return false;
+    if (value !== 'true' && value !== 'false')
+        throw new Error(`"${key}" must be "true" or "false", got "${value}"`);
+    return value === 'true';
+}
+export function formatPageProblems(problems) {
+    return problems.map((problem) => `${problem.file}: ${problem.message}`).join('\n  ');
+}
+// `legal-notice` -> `Legal notice`.
+export function titleFromSlug(slug) {
+    const words = slug.split('-').filter(Boolean).join(' ');
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+// A page file is plain HTML, optionally opened by an HTML comment of `key: value` lines:
+//
+//   <!--
+//   title: Legal notice
+//   status: publish
+//   template: page-no-title
+//   -->
+//
+// A comment rather than YAML front matter so the file stays valid HTML, previewable as is in a
+// browser. The header is stripped from what gets pushed. Throws on an unknown key or status so a
+// typo never silently falls back to a default. `template` is the active theme's own template
+// slug (a block theme's templates/<slug>.html, or a classic theme's page-<slug>.php); unlike
+// `status`, it's never validated here, an unknown slug just makes WordPress fall back to the
+// default template, the same silent no-op as `full-width`/`hide-title` on a theme that doesn't
+// support them.
+export function parsePageFile(slug, raw) {
+    const header = /^\s*<!--([\s\S]*?)-->\r?\n?/.exec(raw);
+    const meta = {};
+    if (header) {
+        for (const line of header[1].split(/\r?\n/)) {
+            if (line.trim() === '')
+                continue;
+            const colon = line.indexOf(':');
+            if (colon === -1)
+                throw new Error(`header line "${line.trim()}" is not a "key: value" pair`);
+            const key = line.slice(0, colon).trim();
+            if (!HEADER_KEYS.includes(key))
+                throw new Error(`unknown header key "${key}" (allowed: ${HEADER_KEYS.join(', ')})`);
+            meta[key] = line.slice(colon + 1).trim();
+        }
+    }
+    const status = meta.status ?? 'draft';
+    if (!PAGE_STATUSES.includes(status)) {
+        throw new Error(`status "${status}" is not one of ${PAGE_STATUSES.join(', ')}`);
+    }
+    return {
+        fullWidth: parseBoolean('full-width', meta['full-width']),
+        hideTitle: parseBoolean('hide-title', meta['hide-title']),
+        html: header ? raw.slice(header[0].length) : raw,
+        slug,
+        status: status,
+        template: meta.template ?? '',
+        title: meta.title || titleFromSlug(slug),
+    };
+}
+// Reads every page of `dir` and reports every problem at once instead of skipping bad files
+// like the other resources do: a page push is declarative, so anything unexpected in the
+// directory (a `.php`, a subdirectory, a bad header) must stop it before any network call.
+// Dotfiles (.DS_Store, editor droppings) are ignored. A missing directory is "no pages".
+export async function readLocalPages(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { pages: [], problems: [] };
+        throw error;
+    }
+    const pages = [];
+    const problems = [];
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const filePath = join(dir, entry.name);
+        if (!entry.isFile()) {
+            problems.push({ file: filePath, message: `subdirectories are not supported, keep every page at the top of ${dir}` });
+            continue;
+        }
+        if (extname(entry.name) !== '.html') {
+            problems.push({ file: filePath, message: `only .html files are allowed in ${dir}` });
+            continue;
+        }
+        const slug = basename(entry.name, '.html');
+        if (!PAGE_SLUG_PATTERN.test(slug)) {
+            problems.push({ file: filePath, message: 'the file name must be lowercase letters and digits separated by single hyphens (e.g. "legal-notice.html")' });
+            continue;
+        }
+        try {
+            pages.push(parsePageFile(slug, await readFile(filePath, 'utf8')));
+        }
+        catch (error) {
+            problems.push({ file: filePath, message: error.message });
+        }
+    }
+    return { pages, problems };
+}

package/dist/utils/resource-dirs.d.ts

@@ -7,6 +7,7 @@ export declare const RESOURCE_DIR_DEFAULTS: {
     readonly hooks: "hooks";
     readonly menu: "menus";
     readonly options: "options";
+    readonly page: "pages";
     readonly seo: "seo";
     readonly snippets: "snippets";
     readonly themeStyles: "theme";

package/dist/utils/resource-dirs.js

@@ -9,6 +9,7 @@ export const RESOURCE_DIR_DEFAULTS = {
     hooks: 'hooks',
     menu: 'menus',
     options: 'options',
+    page: 'pages',
     seo: 'seo',
     snippets: 'snippets',
     themeStyles: 'theme',
@@ -21,6 +22,7 @@ const CONFIG_KEY = {
     hooks: 'hooksDir',
     menu: 'menuDir',
     options: 'optionsDir',
+    page: 'pageDir',
     seo: 'seoDir',
     snippets: 'snippetsDir',
     themeStyles: 'themeStylesDir',