@loopress/cli 0.25.0 → 0.27.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

@@ -4,7 +4,7 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { isInteractive } from '../lib/interactive.js';
-import { writeLocalConfig } from '../utils/loopress-config.js';
+import { ensureLfGitattributes, writeLocalConfig } from '../utils/loopress-config.js';
 // WordPress.org slugs for the two snippet plugins the Loopress WordPress plugin supports
 // (see SnippetModule.php, which wires up both providers and auto-detects the active one).
 const SNIPPET_PROVIDERS = [
@@ -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';
@@ -67,6 +68,7 @@ export default class Init extends Command {
                 config[feature.key] = feature.dir;
         }
         await writeLocalConfig(config);
+        const isGitattributesUpdated = await ensureLfGitattributes();
         let isProviderAdded = false;
         if (providerChoice !== '__none__') {
             try {
@@ -88,6 +90,9 @@ export default class Init extends Command {
         if (isProviderAdded) {
             this.log(`  Plugin:   ${providerChoice}`);
         }
+        if (isGitattributesUpdated) {
+            this.log('✓ .gitattributes: LF line endings, so files match across macOS, Linux and Windows');
+        }
         this.log('\n→ Next: run `lps snippet pull` to fetch what is already on the site, or `lps doctor` to verify the connection.');
     }
     // When nothing is configured yet, the useful path is configuring a project right here, not

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, frontPageNote, 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}${frontPageNote(result)}`;
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${page.slug}: ${error.message}`, error, task);
+        }
+    }
+}

package/dist/commands/plugin/add.d.ts

@@ -1,13 +1,20 @@
 import { LoopressCommand } from '../../lib/base.js';
+type AddResult = {
+    slug: string;
+    status: 'added' | 'dry-run' | 'unchanged' | 'updated';
+    version: string;
+};
 export default class Add extends LoopressCommand {
     static args: {
         slug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<AddResult>;
 }
+export {};

package/dist/commands/plugin/add.js

@@ -7,6 +7,7 @@ export default class Add extends LoopressCommand {
         slug: Args.string({ description: 'Plugin slug on WordPress.org', required: true }),
     };
     static description = 'Add a WordPress.org plugin to loopress.json';
+    static enableJsonFlag = true;
     static examples = [
         '$ lps plugin add woocommerce',
         '$ lps plugin add woocommerce --version 9.4.2',
@@ -26,17 +27,18 @@ export default class Add extends LoopressCommand {
         const existing = this.localConfig.plugins ?? {};
         if (existing[slug] === version) {
             this.log(`${slug} is already pinned to ${version} in loopress.json, nothing to do.`);
-            return;
+            return { slug, status: 'unchanged', version };
         }
         const isUpdated = existing[slug] !== undefined;
         if (this.dryRun) {
             this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} (${version}) in loopress.json`);
-            return;
+            return { slug, status: 'dry-run', version };
         }
         await writeLocalConfig({
             ...this.localConfig,
             plugins: { ...existing, [slug]: version },
         });
         this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug} (${version}). Run \`lps plugin push\` to apply.`);
+        return { slug, status: isUpdated ? 'updated' : 'added', version };
     }
 }

package/dist/commands/promote.js

@@ -3,6 +3,7 @@ import { Args, Command } from '@oclif/core';
 import { configManager } from '../config/project-config.manager.js';
 import { LoopressCommand } from '../lib/base.js';
 import { isInteractive } from '../lib/interactive.js';
+import { stdoutToStderr } from '../lib/json-delegation.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 export default class Promote extends Command {
     static args = {
@@ -30,14 +31,14 @@ export default class Promote extends Command {
             await this.confirmPromotion(from.name, to.name, to.url, yes);
         this.log(`\n=== Pulling from ${from.name} (${from.url}) ===`);
         try {
-            await this.config.runCommand('pull', this.delegateArgv(from.name, dryRun));
+            await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('pull', this.delegateArgv(from.name, dryRun)));
         }
         catch (error) {
             // A partial pull must never be pushed onward: stop before touching <to>.
             this.error(`Pull from ${from.name} failed, ${to.name} left untouched: ${error.message}`);
         }
         this.log(`\n=== Pushing to ${to.name} (${to.url}) ===`);
-        await this.config.runCommand('push', this.delegateArgv(to.name, dryRun));
+        await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', this.delegateArgv(to.name, dryRun)));
         this.log(dryRun ? `\n[dry-run] ${from.name} would be promoted to ${to.name}.` : `\n${from.name} promoted to ${to.name}.`);
         return { from: from.name, status: dryRun ? 'dry-run' : 'promoted', to: to.name };
     }

package/dist/commands/pull.js

@@ -1,4 +1,5 @@
 import { LoopressCommand } from '../lib/base.js';
+import { stdoutToStderr } from '../lib/json-delegation.js';
 import { pluralize } from '../utils/pluralize.js';
 // composer before plugins: `plugin:pull` reads the local composer.json to skip
 // Composer-managed plugins, so it needs the freshly pulled one. The rest write to independent
@@ -29,7 +30,7 @@ export default class Pull extends LoopressCommand {
         for (const target of PULL_TARGETS) {
             this.log(`\n→ Pulling ${target.label}...`);
             try {
-                await this.config.runCommand(target.commandId, this.buildArgv(target));
+                await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand(target.commandId, this.buildArgv(target)));
                 this.log(`✓ ${target.label} pulled`);
                 results.push({ label: target.label, status: 'pulled' });
             }
@@ -41,7 +42,10 @@ export default class Pull extends LoopressCommand {
             }
         }
         if (this.failedCount > 0) {
-            this.error(`${pluralize(this.failedCount, 'resource')} failed to pull.`);
+            // Each failure's own reason, not just the count: under --json the per-resource lines above
+            // never reach stdout, and this message is all an MCP caller or a script gets to see.
+            const failures = results.filter((result) => result.status === 'failed').map((result) => `${result.label}: ${result.error}`);
+            this.error(`${pluralize(this.failedCount, 'resource')} failed to pull. ${failures.join('; ')}`);
         }
         this.log('\nAll resources pulled.');
         return { results };

package/dist/commands/push.js

@@ -1,5 +1,6 @@
 import { LoopressCommand } from '../lib/base.js';
 import { guardProductionPush } from '../lib/guard-production-push.js';
+import { stdoutToStderr } from '../lib/json-delegation.js';
 import { pluralize } from '../utils/pluralize.js';
 // Dependency-ish order: code first (plugins, composer), then the ACF definitions content
 // relies on, then content itself.
@@ -10,13 +11,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 = {
@@ -31,7 +33,7 @@ export default class Push extends LoopressCommand {
         for (const target of PUSH_TARGETS) {
             this.log(`\n→ Pushing ${target.label}...`);
             try {
-                await this.config.runCommand(target.commandId, argv);
+                await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand(target.commandId, argv));
                 this.log(`✓ ${target.label} pushed`);
                 results.push({ label: target.label, status: 'pushed' });
             }
@@ -43,7 +45,10 @@ export default class Push extends LoopressCommand {
             }
         }
         if (this.failedCount > 0) {
-            this.error(`${pluralize(this.failedCount, 'resource')} failed to push.`);
+            // Each failure's own reason, not just the count: under --json the per-resource lines above
+            // never reach stdout, and this message is all an MCP caller or a script gets to see.
+            const failures = results.filter((result) => result.status === 'failed').map((result) => `${result.label}: ${result.error}`);
+            this.error(`${pluralize(this.failedCount, 'resource')} failed to push. ${failures.join('; ')}`);
         }
         this.log('\nAll resources pushed.');
         return { results };

package/dist/commands/theme/add.d.ts

@@ -1,13 +1,20 @@
 import { LoopressCommand } from '../../lib/base.js';
+type AddResult = {
+    slug: string;
+    status: 'added' | 'dry-run' | 'unchanged' | 'updated';
+    version: string;
+};
 export default class Add extends LoopressCommand {
     static args: {
         slug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<AddResult>;
 }
+export {};

package/dist/commands/theme/add.js

@@ -7,6 +7,7 @@ export default class Add extends LoopressCommand {
         slug: Args.string({ description: 'Theme slug on WordPress.org', required: true }),
     };
     static description = 'Add a WordPress.org theme to loopress.json';
+    static enableJsonFlag = true;
     static examples = ['$ lps theme add generatepress', '$ lps theme add generatepress --version 3.4.0'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -22,14 +23,15 @@ export default class Add extends LoopressCommand {
         const existing = this.localConfig.themes ?? {};
         if (existing[slug] === version) {
             this.log(`${slug} is already pinned to ${version}, nothing to do.`);
-            return;
+            return { slug, status: 'unchanged', version };
         }
         const isUpdated = existing[slug] !== undefined;
         if (this.dryRun) {
             this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} (${version})`);
-            return;
+            return { slug, status: 'dry-run', version };
         }
         await writeLocalConfig({ ...this.localConfig, themes: { ...existing, [slug]: version } });
         this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug} (${version}). Run \`lps theme push\` to apply.`);
+        return { slug, status: isUpdated ? 'updated' : 'added', version };
     }
 }

package/dist/lib/api-client.js

@@ -43,11 +43,34 @@ function formatApiError(error, url, timeoutMs) {
     if (status === 401) {
         return `Not logged in or session expired on ${url}. Run \`lps login\` again.`;
     }
+    const reason = nestErrorMessage(err.response?.body);
     if (status === 403) {
-        return `Request rejected (${status}) on ${url}: ${err.response?.body ?? err.message}`;
+        return `Request rejected (${status}) on ${url}: ${reason ?? err.response?.body ?? err.message}`;
+    }
+    // Any other API refusal (a 400 validation error, a 409 conflict) carries its explanation in
+    // the body; got's own message ("Request failed with status code 400") never does.
+    if (status !== undefined && reason) {
+        return `Request failed (${status}) on ${url}: ${reason}`;
     }
     if (err.name === 'TimeoutError') {
         return `Request timed out after ${timeoutMs / 1000}s on ${url}. Check your network connection, or the Loopress API may be temporarily unreachable.`;
     }
     return err.message ?? String(error);
 }
+// NestJS's HttpException body: `{statusCode, message, error}`, where `message` is a list for a
+// ValidationPipe failure (one entry per invalid field).
+function nestErrorMessage(body) {
+    if (!body)
+        return undefined;
+    try {
+        const { message } = JSON.parse(body);
+        if (typeof message === 'string' && message.trim())
+            return message;
+        if (Array.isArray(message) && message.length > 0)
+            return message.join('; ');
+    }
+    catch {
+        // not JSON (a proxy's HTML error page): nothing to extract
+    }
+    return undefined;
+}

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' | 'hooks' | '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', 'hooks', '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,8 @@ 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' },
+        hooks: { commandId: 'hook:push', path: join(rootDir, localConfig.hooksDir ?? 'hooks'), type: 'hooks' },
+        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/json-delegation.d.ts

@@ -0,0 +1 @@
+export declare function stdoutToStderr<T>(enabled: boolean, work: () => Promise<T>): Promise<T>;

package/dist/lib/json-delegation.js

@@ -0,0 +1,18 @@
+// `lps push`/`pull`/`promote --json` must put exactly one JSON document on stdout: that's what
+// the MCP server (and any script) parses. The resource commands they delegate to aren't in JSON
+// mode themselves, so their progress lines and Listr renderers would land on stdout ahead of it.
+// While `enabled`, their stdout goes to stderr instead: still visible to a human, out of the
+// JSON. Patching the stream's write is the one place every writer goes through (oclif's
+// ux.stdout, Listr's renderers, a stray console.log).
+export async function stdoutToStderr(enabled, work) {
+    if (!enabled)
+        return work();
+    const original = process.stdout.write;
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+    try {
+        return await work();
+    }
+    finally {
+        process.stdout.write = original;
+    }
+}

package/dist/lib/load-snippets.js

@@ -70,7 +70,7 @@ async function loadSnippet(path, file, onSkip) {
     };
 }
 // Shared by `snippet push` (pushes to the project's own WordPress site) and `snippet publish`
-// (publishes to the Loopress api as a shared source) — both read the same local `snippets/`
+// (publishes to the Loopress api as a shared source): both read the same local `snippets/`
 // directory the same way. `onSkip` is optional so callers that don't care about per-file
 // warnings (e.g. `snippet publish`) can ignore them; skipped files are simply left out either way.
 export async function loadSnippets(path, onSkip) {

package/dist/lib/php-files-command.js

@@ -341,9 +341,10 @@ export const API_FILES_RESOURCE = {
     emptyListMessage: 'No API route files found',
     endpoint: 'loopress/v1/api-files',
     // Mirrors ApiFilesController::isValidFilename(): kebab-case segments or a bracketed dynamic
-    // segment like [order_id], joined by '/'.
-    filenamePattern: /^(?:[a-z0-9-]+|\[[A-Za-z_]\w*\])(?:\/(?:[a-z0-9-]+|\[[A-Za-z_]\w*\]))*$/,
-    invalidFilenameHint: 'each path segment must be lowercase letters, digits, and hyphens, or a bracketed dynamic segment like "[order_id]" (e.g. "invoice-pdf/[order_id].php")',
+    // segment like [order_id], joined by '/', and never a root "index" (api/index.php is
+    // reserved; a nested orders/index.php is the /orders route).
+    filenamePattern: /^(?!index$)(?:[a-z0-9-]+|\[[A-Za-z_]\w*\])(?:\/(?:[a-z0-9-]+|\[[A-Za-z_]\w*\]))*$/,
+    invalidFilenameHint: 'each path segment must be lowercase letters, digits, and hyphens, or a bracketed dynamic segment like "[order_id]" (e.g. "invoice-pdf/[order_id].php"), and a root "index.php" is reserved: name the file, or nest it (orders/index.php is the /orders route)',
     label: 'API routes',
     listDescription: 'List custom API route files from WordPress',
     noun: 'route file',

package/dist/lib/readdir-tolerant.js

@@ -1,4 +1,4 @@
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
 export async function readdirTolerant(dir, options) {
     try {
@@ -16,10 +16,20 @@ export async function readdirTolerant(dir, options) {
 // never the OS separator: callers match these identities against server-sent filenames
 // (which are always '/'-joined) or embed them in an API payload, so a Windows run must
 // produce the exact same strings as a POSIX one. ENOENT on `dir` itself yields no files,
-// same tolerance as readdirTolerant.
+// same tolerance as readdirTolerant. A symlink to a file counts as that file (a project can
+// link a route in from a shared checkout); a broken one, or one to a directory, is skipped.
 export async function walkFiles(dir) {
     const entries = await readdirTolerant(dir, { recursive: true, withFileTypes: true });
-    return entries
-        .filter((entry) => entry.isFile())
-        .map((entry) => relative(dir, join(entry.parentPath, entry.name)).split(sep).join('/'));
+    const files = [];
+    for (const entry of entries) {
+        const path = join(entry.parentPath, entry.name);
+        if (entry.isFile() || (entry.isSymbolicLink() && (await isFile(path))))
+            files.push(relative(dir, path).split(sep).join('/'));
+    }
+    return files;
+}
+async function isFile(path) {
+    return stat(path)
+        .then((s) => s.isFile())
+        .catch(() => false);
 }

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/snapshot-store.js

@@ -49,6 +49,7 @@ export async function writeSnapshot(options) {
     const { afterState, beforeState, environment, resource, retain = SNAPSHOT_RETENTION, rootDir } = options;
     const dir = snapshotsDir(rootDir, resource, environment);
     await mkdir(dir, { recursive: true });
+    await ignoreCacheDirInGit(rootDir);
     const snapshot = {
         afterState: stateToRecord(afterState),
         beforeState: stateToRecord(beforeState),
@@ -72,6 +73,19 @@ export async function writeSnapshot(options) {
     await pruneSnapshots(rootDir, resource, environment, retain);
     return String(id);
 }
+// `.loopress/` lives inside the user's project and holds the environment's full remote state
+// (snippet code, form definitions, option values): a `git add .` must never pick it up. The
+// directory ignores itself, the way `.pytest_cache` does, instead of relying on every project
+// to add it to its own .gitignore. `wx` so a hand-edited file is never overwritten.
+async function ignoreCacheDirInGit(rootDir) {
+    try {
+        await writeFile(join(rootDir, '.loopress', '.gitignore'), '# Written by the Loopress CLI: local rollback snapshots, never commit them.\n*\n', { flag: 'wx' });
+    }
+    catch (error) {
+        if (!isEexist(error))
+            throw error;
+    }
+}
 // Newest first. A missing snapshots directory (never pushed, or pruned to nothing) reads as
 // "no snapshots", not an error, the same ENOENT tolerance every resource-state provider gives
 // a never-pulled local directory.