@loopress/cli 0.22.0 → 0.24.0

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

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

package/dist/commands/acf/diff.js

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

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

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

package/dist/commands/api/diff.js

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

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

@@ -1,12 +1,2 @@
-import { LoopressCommand } from '../../lib/base.js';
-type ApiFile = {
-    content: string;
-    filename: string;
-};
-export default class List extends LoopressCommand {
-    static description: string;
-    static enableJsonFlag: boolean;
-    static examples: string[];
-    run(): Promise<ApiFile[]>;
-}
-export {};
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").ListFilesCommand>;
+export default _default;

package/dist/commands/api/list.js

@@ -1,20 +1,2 @@
-import { LoopressCommand } from '../../lib/base.js';
-import { pluralize } from '../../utils/pluralize.js';
-export default class List extends LoopressCommand {
-    static description = 'List custom API route files from WordPress';
-    static enableJsonFlag = true;
-    static examples = ['$ lps api list'];
-    async run() {
-        const files = await this.wp.get('loopress/v1/api-files');
-        if (files.length === 0) {
-            this.log('No API route files found');
-            return files;
-        }
-        this.log(`Found ${pluralize(files.length, 'route file')}:`);
-        this.log('');
-        for (const file of files) {
-            this.log(`  ${file.filename}`);
-        }
-        return files;
-    }
-}
+import { API_FILES_RESOURCE, resourceListCommand } from '../../lib/php-files-command.js';
+export default resourceListCommand(API_FILES_RESOURCE);

package/dist/commands/api/pull.d.ts

@@ -1,20 +1,2 @@
-import { LoopressCommand } from '../../lib/base.js';
-type PullResult = {
-    orphans: string[];
-    pulled: string[];
-    status: 'dry-run' | 'success';
-};
-export default class Pull extends LoopressCommand {
-    static args: {
-        path: 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<PullResult>;
-}
-export {};
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").PullFilesCommand>;
+export default _default;

package/dist/commands/api/pull.js

@@ -1,53 +1,2 @@
-import { Args } from '@oclif/core';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { LoopressCommand } from '../../lib/base.js';
-import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
-import { pluralize } from '../../utils/pluralize.js';
-export default class Pull extends LoopressCommand {
-    static args = {
-        path: Args.string({ description: 'Path to api directory (overrides project config)' }),
-    };
-    static description = 'Pull custom API route files from WordPress';
-    static enableJsonFlag = true;
-    static examples = ['$ lps api pull', '$ lps api pull --path ./api'];
-    static flags = {
-        ...LoopressCommand.dryRunFlag,
-        ...LoopressCommand.yesFlag,
-    };
-    async run() {
-        const { args } = await this.parse(Pull);
-        const { url } = this.siteConfig;
-        const path = this.resolveApiPath(args.path);
-        this.log(`Pulling API routes from ${url}`);
-        this.log(`API path: ${path}`);
-        const files = await this.wp.get('loopress/v1/api-files');
-        // A `<filename>.php` no longer present remotely belongs to a route deleted on WordPress
-        // (push itself stays additive-only, but pull already cleans up locally, same as
-        // `snippet pull`).
-        const orphans = await findOrphanedFiles(path, new Set(files.map((file) => file.filename)), {
-            extensions: ['.php'],
-            key: basenameKey,
-            recursive: true,
-        });
-        const pulled = files.map((file) => file.filename);
-        await this.pullDirectory(path, files, orphans, {
-            alwaysCreateDir: true,
-            dryRunMessage: `Would pull ${pluralize(files.length, 'route file')} to ${path}`,
-            orphanReason: 'whose route no longer exists on WordPress',
-            pulledMessage: `Pulled ${pluralize(files.length, 'route file')} to ${path}`,
-            title: (file) => file.filename,
-            async write(file, writeDir) {
-                const filePath = join(writeDir, `${file.filename}.php`);
-                // filename can contain '/' (a path-param route, e.g. invoice-pdf/[order_id]):
-                // writeFile() doesn't create parent directories on its own the way mkdir()'s
-                // recursive option does above for the top-level path.
-                await mkdir(dirname(filePath), { recursive: true });
-                await writeFile(filePath, file.content);
-            },
-        });
-        if (this.dryRun)
-            return { orphans, pulled, status: 'dry-run' };
-        return { orphans, pulled, status: 'success' };
-    }
-}
+import { API_FILES_RESOURCE, resourcePullCommand } from '../../lib/php-files-command.js';
+export default resourcePullCommand(API_FILES_RESOURCE);

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

@@ -1,22 +1,2 @@
-import { PushCommand } from '../../lib/push-command.js';
-type PushResult = {
-    pushed: string[];
-    status: 'dry-run' | 'success';
-};
-export default class Push extends PushCommand {
-    static args: {
-        path: 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 loadFiles;
-    private pushFile;
-    private syncApiRoutes;
-}
-export {};
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").PushFilesCommand>;
+export default _default;

package/dist/commands/api/push.js

@@ -1,116 +1,2 @@
-import { Args } from '@oclif/core';
-import { relative, sep } from 'node:path';
-import { authManager } from '../../config/auth.manager.js';
-import { ApiClient } from '../../lib/api-client.js';
-import { loadFiles as loadDirectoryFiles } from '../../lib/load-files.js';
-import { PushCommand } from '../../lib/push-command.js';
-import { pluralize } from '../../utils/pluralize.js';
-// Mirrors the server's own allowlist (wordpress-plugin ApiFilesController::isValidFilename()):
-// filename is sent as a body param (not a URL path segment: a nested path can contain '/' and
-// '[]', and depending on a server to handle a percent-encoded slash in a URL path correctly is
-// exactly the kind of hosting-environment variance Loopress can't assume away), but validating
-// client-side first still turns a malformed name into an accurate error and skips a network
-// round-trip that could only ever fail.
-const FILENAME_PATTERN = /^(?:[a-z0-9-]+|\[[A-Za-z_]\w*\])(?:\/(?:[a-z0-9-]+|\[[A-Za-z_]\w*\]))*$/;
-// Mirrors the server's own check (wordpress-plugin FileWriter::DECLARE_PATTERN /
-// withGuard()): the server rejects both an absent declare(strict_types=1); and one that
-// appears more than once (it needs a single unambiguous insertion point for the ABSPATH
-// guard). Matching that "exactly once" rule here too, not just presence, so a file that
-// would still fail server-side doesn't falsely pass this earlier check.
-const DECLARE_PATTERN = /declare\s*\(\s*strict_types\s*=\s*1\s*\)\s*;/g;
-export default class Push extends PushCommand {
-    static args = {
-        path: Args.string({ description: 'Path to api directory (overrides project config)' }),
-    };
-    static description = 'Push custom API route files to WordPress';
-    static enableJsonFlag = true;
-    static examples = ['$ lps api push', '$ lps api push --path ./api'];
-    static flags = {
-        ...PushCommand.dryRunFlag,
-        ...PushCommand.yesFlag,
-    };
-    async run() {
-        const { args } = await this.parse(Push);
-        const { url } = this.siteConfig;
-        const path = this.resolveApiPath(args.path);
-        this.log(`Pushing API routes to ${url}`);
-        this.log(`API path: ${path}`);
-        const files = await this.loadFiles(path);
-        this.log(`Found ${pluralize(files.length, 'route file')} to push`);
-        const pushed = [];
-        await this.runPushTasks(files, (file) => file.filename, async (file, task) => {
-            await this.pushFile(file, task);
-            pushed.push(file.filename);
-        });
-        if (this.failedCount > 0) {
-            this.error(`${pluralize(this.failedCount, 'route file')} failed to push.`);
-        }
-        if (this.dryRun)
-            return { pushed, status: 'dry-run' };
-        await this.recordSuccess();
-        await this.syncApiRoutes(files.map((file) => file.filename));
-        this.log('All API routes pushed.');
-        return { pushed, status: 'success' };
-    }
-    async loadFiles(path) {
-        return loadDirectoryFiles(path, {
-            extension: '.php',
-            onSkip: (message) => { this.warn(message); },
-            // relative()'s separator is OS-specific ('\\' on Windows); the server only ever expects
-            // '/', same as any URL or import path.
-            parse: (raw, filePath) => ({
-                content: raw,
-                filename: relative(path, filePath).slice(0, -'.php'.length).split(sep).join('/'),
-            }),
-            recursive: true,
-        });
-    }
-    async pushFile(file, task) {
-        if (!FILENAME_PATTERN.test(file.filename)) {
-            const message = `Invalid filename "${file.filename}": 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")`;
-            this.reportTaskFailure(message, new Error(message), task);
-        }
-        const declareCount = file.content.match(DECLARE_PATTERN)?.length ?? 0;
-        if (declareCount !== 1) {
-            const reason = declareCount === 0 ? 'is missing' : 'appears more than once';
-            const message = `${file.filename}.php: "declare(strict_types=1);" ${reason}, it must appear exactly once as the first statement`;
-            this.reportTaskFailure(message, new Error(message), task);
-        }
-        if (this.dryRun) {
-            if (task)
-                task.output = `[dry-run] Would push: ${file.filename}`;
-            return;
-        }
-        try {
-            const result = await this.wp.put('loopress/v1/api-files', {
-                content: file.content,
-                filename: file.filename,
-            });
-            if (task) {
-                task.output =
-                    result.syntax_check === 'skipped'
-                        ? `Pushed: ${file.filename} (syntax check skipped, unavailable on this host)`
-                        : `Pushed: ${file.filename}`;
-            }
-        }
-        catch (error) {
-            this.reportTaskFailure(`Failed to push ${file.filename}: ${error.message}`, error, task);
-        }
-    }
-    // Best-effort report of the current file list to the Loopress cloud, purely for console
-    // visibility (see obsidian/Product/API and Console Backlog.md, US-18): the routes are already
-    // live on WordPress by this point, this can never block or fail the push itself, same
-    // reasoning as `recordDeployment` in PushCommand.
-    async syncApiRoutes(filenames) {
-        const token = process.env.LOOPRESS_TOKEN ?? authManager.getAuth()?.token;
-        const environmentId = this.siteConfig.apiEnvironmentId;
-        if (!token || !environmentId)
-            return;
-        try {
-            await new ApiClient(token).put('api-routes', { environmentId, filenames });
-        }
-        catch {
-            // non-blocking: reporting the route list must never interrupt the push flow
-        }
-    }
-}
+import { API_FILES_RESOURCE, resourcePushCommand } from '../../lib/php-files-command.js';
+export default resourcePushCommand(API_FILES_RESOURCE);

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

@@ -0,0 +1,17 @@
+import { LoopressCommand } from '../../lib/base.js';
+type RemoteApp = {
+    buildId: null | string;
+    committed: boolean;
+    deployedAt: null | string;
+    fileCount: number;
+    name: string;
+    routing: null | string;
+    totalBytes: number;
+};
+export default class List extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<RemoteApp[]>;
+}
+export {};

package/dist/commands/app/list.js

@@ -0,0 +1,35 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { pluralize } from '../../utils/pluralize.js';
+function humanBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+export default class List extends LoopressCommand {
+    static description = 'List single-page apps deployed to WordPress';
+    static enableJsonFlag = true;
+    static examples = ['$ lps app list'];
+    async run() {
+        const apps = await this.wp.get('loopress/v1/apps');
+        this.log(`Apps (${apps.length}):`);
+        if (apps.length === 0) {
+            this.log('  (none)');
+            return apps;
+        }
+        for (const app of apps) {
+            this.log(`  ${app.name}`);
+            if (app.committed) {
+                this.log(`     Build:  ${app.buildId ?? '(unknown)'}`);
+                this.log(`     Files:  ${pluralize(app.fileCount, 'file')}, ${humanBytes(app.totalBytes)}`);
+                if (app.deployedAt)
+                    this.log(`     Deployed: ${app.deployedAt}`);
+            }
+            else {
+                this.log('     (uploaded but never committed, run `lps app push` to finish)');
+            }
+        }
+        return apps;
+    }
+}

package/dist/commands/{page → app}/pull.d.ts

@@ -1,12 +1,11 @@
 import { LoopressCommand } from '../../lib/base.js';
-type PulledPage = {
-    id: number;
-    title: string;
+type PulledApp = {
+    files: number;
+    name: string;
 };
 type PullResult = {
     orphans: string[];
-    pulled: PulledPage[];
-    skipped: number;
+    pulled: PulledApp[];
     status: 'dry-run' | 'success';
 };
 export default class Pull extends LoopressCommand {
@@ -21,5 +20,8 @@ export default class Pull extends LoopressCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PullResult>;
+    private findOrphanApps;
+    private pullApp;
+    private removeOrphanApps;
 }
 export {};

package/dist/commands/app/pull.js

@@ -0,0 +1,94 @@
+import { confirm } from '@inquirer/prompts';
+import { Args } from '@oclif/core';
+import { Buffer } from 'node:buffer';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { APP_CONFIG_FILENAME } from '../../lib/app-manifest.js';
+import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to apps directory (overrides project config)' }),
+    };
+    static description = 'Pull single-page app bundles from WordPress into local files';
+    static enableJsonFlag = true;
+    static examples = ['$ lps app pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const path = this.resolveAppsPath(args.path);
+        this.log(`Pulling apps from ${url}`);
+        this.log(`Apps path: ${path}`);
+        const remoteApps = await this.wp.get('loopress/v1/apps');
+        const pullable = remoteApps.filter((app) => app.committed);
+        const orphans = await this.findOrphanApps(path, new Set(pullable.map((app) => app.name)));
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${pluralize(pullable.length, 'app')} to ${path}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${pluralize(orphans.length, 'local app')}: ${orphans.join(', ')}`);
+            }
+            return { orphans, pulled: pullable.map((app) => ({ files: 0, name: app.name })), status: 'dry-run' };
+        }
+        const pulled = [];
+        for (const app of pullable) {
+            pulled.push(await this.pullApp(path, app.name));
+        }
+        await this.removeOrphanApps(path, orphans);
+        this.log(`Pulled ${pluralize(pulled.length, 'app')} to ${path}`);
+        return { orphans, pulled, status: 'success' };
+    }
+    async findOrphanApps(path, keep) {
+        let entries;
+        try {
+            entries = await readdir(path, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .filter((name) => existsSync(join(path, name, APP_CONFIG_FILENAME)) && !keep.has(name));
+    }
+    async pullApp(path, name) {
+        const manifest = await this.wp.get(`loopress/v1/apps/${name}/manifest`);
+        const distDir = join(path, name, 'dist');
+        for (const file of manifest.files) {
+            const { content } = await this.wp.get(`loopress/v1/apps/${name}/asset?path=${encodeURIComponent(file.path)}`);
+            const target = join(distDir, file.path);
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, Buffer.from(content, 'base64'));
+        }
+        await writeFile(join(path, name, APP_CONFIG_FILENAME), JSON.stringify({ assetsDir: 'dist', mountSelector: manifest.mountSelector, name: manifest.name, routing: manifest.routing }, null, 2) + '\n');
+        this.log(`  ${name}: ${pluralize(manifest.files.length, 'file')} (build ${manifest.buildId})`);
+        return { files: manifest.files.length, name };
+    }
+    async removeOrphanApps(path, orphans) {
+        if (orphans.length === 0)
+            return;
+        const description = `${pluralize(orphans.length, 'local app')} no longer on WordPress: ${orphans.join(', ')}`;
+        if (!this.yes && isInteractive()) {
+            const isProceed = await confirm({ default: true, message: `Remove ${description}?` });
+            if (!isProceed) {
+                this.log(`Kept ${description}`);
+                return;
+            }
+        }
+        for (const name of orphans)
+            await rm(join(path, name), { force: true, recursive: true });
+        if (this.yes || isInteractive()) {
+            this.log(`Removed ${description}`);
+        }
+        else {
+            this.warn(`Removed ${description}`);
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import { PushCommand } from '../../lib/push-command.js';
+type PushedApp = {
+    buildId: string;
+    name: string;
+    uploaded: number;
+};
+type PushResult = {
+    pushed: PushedApp[];
+    status: 'dry-run' | 'success';
+};
+export default class Push extends PushCommand {
+    static args: {
+        name: 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 appDirNames;
+    private pushApp;
+    private remoteFiles;
+    private uploadAsset;
+}
+export {};

package/dist/commands/app/push.js

@@ -0,0 +1,130 @@
+import { Args } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { APP_CONFIG_FILENAME, diffFiles, loadAppManifest, } from '../../lib/app-manifest.js';
+import { PushCommand } from '../../lib/push-command.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class Push extends PushCommand {
+    static args = {
+        name: Args.string({ description: 'Push only this app (defaults to every app in the directory)' }),
+    };
+    static description = 'Push built single-page app bundles to WordPress. Each app is an `apps/<name>/` directory holding a loopress.app.json and a built dist/ folder. Only files whose content changed are uploaded.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps app push', '$ lps app push search'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveAppsPath();
+        this.log(`Pushing apps to ${url}`);
+        this.log(`Apps path: ${path}`);
+        const dirNames = await this.appDirNames(path, args.name);
+        this.log(`Found ${pluralize(dirNames.length, 'app')} to push`);
+        const pushed = [];
+        await this.runPushTasks(dirNames, (dirName) => dirName, async (dirName, task) => {
+            const result = await this.pushApp(join(path, dirName), dirName, task);
+            if (result)
+                pushed.push(result);
+        });
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'app')} failed to push.`);
+        }
+        if (this.dryRun)
+            return { pushed, status: 'dry-run' };
+        await this.recordSuccess();
+        this.log('All apps pushed.');
+        return { pushed, status: 'success' };
+    }
+    async appDirNames(path, only) {
+        let entries;
+        try {
+            entries = await readdir(path, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                this.error(`Apps directory not found: ${path}. Create ${join(path, '<name>', APP_CONFIG_FILENAME)} first.`);
+            }
+            throw error;
+        }
+        const names = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .filter((name) => existsSync(join(path, name, APP_CONFIG_FILENAME)))
+            .sort((a, b) => a.localeCompare(b));
+        if (only) {
+            if (!names.includes(only)) {
+                this.error(`No app "${only}" in ${path} (looked for ${join(only, APP_CONFIG_FILENAME)}).`);
+            }
+            return [only];
+        }
+        if (names.length === 0) {
+            this.error(`No apps found in ${path}. Each app needs a ${APP_CONFIG_FILENAME} and a built dist/ folder.`);
+        }
+        return names;
+    }
+    async pushApp(appDir, dirName, task) {
+        let manifest;
+        let distDir;
+        try {
+            ;
+            ({ distDir, manifest } = await loadAppManifest(appDir, dirName));
+        }
+        catch (error) {
+            this.reportTaskFailure(`${dirName}: ${error.message}`, error, task);
+        }
+        const remote = await this.remoteFiles(manifest.name);
+        const changed = diffFiles(manifest.files, remote);
+        if (this.dryRun) {
+            if (task) {
+                task.output =
+                    changed.length === 0
+                        ? `[dry-run] ${manifest.name}: up to date (build ${manifest.buildId})`
+                        : `[dry-run] ${manifest.name}: would upload ${pluralize(changed.length, 'file')}, then commit build ${manifest.buildId}`;
+            }
+            return undefined;
+        }
+        for (const [index, file] of changed.entries()) {
+            if (task)
+                task.output = `${manifest.name}: uploading ${file.path} (${index + 1}/${changed.length})`;
+            await this.uploadAsset(manifest.name, distDir, file);
+        }
+        try {
+            await this.wp.post(`loopress/v1/apps/${manifest.name}/commit`, manifest);
+        }
+        catch (error) {
+            this.reportTaskFailure(`${manifest.name}: commit failed: ${error.message}`, error, task);
+        }
+        if (task) {
+            task.output =
+                changed.length === 0
+                    ? `${manifest.name}: already up to date (build ${manifest.buildId})`
+                    : `${manifest.name}: uploaded ${pluralize(changed.length, 'file')}, committed build ${manifest.buildId}`;
+        }
+        return { buildId: manifest.buildId, name: manifest.name, uploaded: changed.length };
+    }
+    async remoteFiles(name) {
+        try {
+            const remote = await this.wp.get(`loopress/v1/apps/${name}/manifest`);
+            return remote.files ?? [];
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return [];
+            throw error;
+        }
+    }
+    async uploadAsset(name, distDir, file) {
+        const content = (await readFile(join(distDir, file.path))).toString('base64');
+        try {
+            await this.wp.put(`loopress/v1/apps/${name}/assets`, { content, encoding: 'base64', path: file.path });
+        }
+        catch (error) {
+            this.reportTaskFailure(`${name}: failed to upload ${file.path}: ${error.message}`, error);
+        }
+    }
+}

package/dist/commands/app/remove.d.ts

@@ -0,0 +1,20 @@
+import { LoopressCommand } from '../../lib/base.js';
+type RemoveResult = {
+    deleted: boolean;
+    name: string;
+    status: 'aborted' | 'dry-run' | 'success';
+};
+export default class Remove extends LoopressCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, 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<RemoveResult>;
+}
+export {};