@loopress/cli 0.21.0 → 0.23.0

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

@@ -1,10 +1,10 @@
 import { LoopressCommand } from '../../lib/base.js';
 export default class List extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<Record<string, Array<Record<string, unknown>>>>;
 }

package/dist/commands/acf/list.js

@@ -3,9 +3,9 @@ import { LoopressCommand } from '../../lib/base.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class List extends LoopressCommand {
     static description = 'List ACF field groups, post types, taxonomies, and options pages from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps acf list', '$ lps acf list --type field-groups'];
     static flags = {
-        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
         type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
     };
     async run() {
@@ -15,10 +15,6 @@ export default class List extends LoopressCommand {
         for (const type of types) {
             byType[type] = await this.wp.get(acfEndpoint(type));
         }
-        if (flags.json) {
-            this.log(JSON.stringify(byType, null, 2));
-            return;
-        }
         for (const type of types) {
             const objects = byType[type];
             this.log(`${type} (${objects.length}):`);
@@ -33,5 +29,6 @@ export default class List extends LoopressCommand {
             }
             this.log('');
         }
+        return byType;
     }
 }

package/dist/commands/acf/pull.js

@@ -1,6 +1,5 @@
 import { Args, Flags } from '@oclif/core';
-import { Listr } from 'listr2';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
 import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
@@ -39,27 +38,15 @@ export default class Pull extends LoopressCommand {
             extensions: ['.json'],
             key: basenameKey,
         });
-        if (this.dryRun) {
-            this.log(`[dry-run] Would pull ${withKey.length} ${type} to ${dir}`);
-            if (orphans.length > 0) {
-                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
-            }
+        await this.pullDirectory(dir, withKey, orphans, {
+            dryRunMessage: `Would pull ${withKey.length} ${type} to ${dir}`,
+            orphanReason: `in ${dir} no longer present on WordPress`,
+            pulledMessage: `Pulled ${withKey.length} ${type} to ${dir}`,
+            title: (object) => getAcfKey(object),
+            write: async (object, writeDir) => writeFile(join(writeDir, `${getAcfKey(object)}.json`), JSON.stringify(object, null, 2) + '\n'),
+        });
+        if (this.dryRun)
             return;
-        }
-        if (withKey.length > 0)
-            await mkdir(dir, { recursive: true });
-        await new Listr(withKey.map((object) => {
-            const key = getAcfKey(object);
-            return {
-                async task(_ctx, task) {
-                    await writeFile(join(dir, `${key}.json`), JSON.stringify(object, null, 2) + '\n');
-                    task.output = `Pulled: ${key}`;
-                },
-                title: `Pull ${key}`,
-            };
-        })).run();
-        await this.removeOrphanedFiles(dir, orphans, `in ${dir} no longer present on WordPress`);
-        this.log(`Pulled ${withKey.length} ${type} to ${dir}`);
         if (skipped > 0) {
             this.warn(`${skipped} ${type} skipped because they have no key`);
         }

package/dist/commands/acf/push.js

@@ -1,9 +1,9 @@
 import { Args, Flags } from '@oclif/core';
-import { Listr } from 'listr2';
 import { join } from 'node:path';
 import { loadFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
+import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to ACF directory (overrides project config)' }),
@@ -26,7 +26,7 @@ export default class Push extends PushCommand {
             await this.pushType(type, path);
         }
         if (this.failedCount > 0) {
-            this.error(`${this.failedCount} ACF object${this.failedCount === 1 ? '' : 's'} failed to push.`);
+            this.error(`${pluralize(this.failedCount, 'ACF object')} failed to push.`);
         }
         if (this.dryRun)
             return;
@@ -71,9 +71,6 @@ export default class Push extends PushCommand {
         if (objects.length === 0)
             return;
         this.log(`Found ${objects.length} ${type} to push`);
-        await new Listr(objects.map((object) => ({
-            task: async (_ctx, task) => this.pushObject(type, object, task),
-            title: `Push ${getAcfKey(object) ?? '(unknown)'}`,
-        })), { concurrent: false, exitOnError: false }).run();
+        await this.runPushTasks(objects, (object) => getAcfKey(object) ?? '(unknown)', async (object, task) => this.pushObject(type, object, task));
     }
 }

package/dist/commands/api/list.js

@@ -1,4 +1,5 @@
 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;
@@ -9,7 +10,7 @@ export default class List extends LoopressCommand {
             this.log('No API route files found');
             return files;
         }
-        this.log(`Found ${files.length} route file${files.length === 1 ? '' : 's'}:`);
+        this.log(`Found ${pluralize(files.length, 'route file')}:`);
         this.log('');
         for (const file of files) {
             this.log(`  ${file.filename}`);

package/dist/commands/api/publish.js

@@ -1,10 +1,9 @@
 import { Args, Command } from '@oclif/core';
 import { basename, join } from 'node:path';
-import { authManager } from '../../config/auth.manager.js';
-import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
 import { loadFiles } from '../../lib/load-files.js';
-import { readLocalConfig } from '../../utils/loopress-config.js';
+import { resolveLinkedProject } from '../../lib/resolve-linked-project.js';
+import { pluralize } from '../../utils/pluralize.js';
 // Publishes to the Loopress api (not a WordPress site), so this does not extend
 // `LoopressCommand`/`PushCommand`: those force an environment to be resolved, but publishing
 // for cross-project sharing doesn't need one, same reasoning as `snippet publish`. An API route
@@ -20,22 +19,7 @@ export default class Publish extends Command {
     static examples = ['$ lps api publish', '$ lps api publish --path ./api'];
     async run() {
         const { args } = await this.parse(Publish);
-        const token = process.env.LOOPRESS_TOKEN ?? authManager.getAuth()?.token;
-        if (!token) {
-            this.error('Not logged in. Run `lps login` first.');
-        }
-        const localConfig = await readLocalConfig();
-        const projectId = localConfig.projectId ?? configManager.getCurrentProject()?.id;
-        if (!projectId) {
-            this.error('No project configured. Run `lps project config` first.');
-        }
-        const project = configManager.getProject(projectId);
-        if (!project) {
-            this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
-        }
-        if (!project.apiProjectId) {
-            this.error(`Project "${project.name}" is not linked to your Loopress account yet. Run \`lps project push\` first.`);
-        }
+        const { apiProjectId, localConfig, token } = await resolveLinkedProject((message) => this.error(message));
         const path = args.path ?? join(localConfig.rootDir ?? '.', localConfig.apiDir ?? 'api');
         this.log(`Publishing API routes from ${path}`);
         const files = await loadFiles(path, {
@@ -45,16 +29,16 @@ export default class Publish extends Command {
         });
         const api = new ApiClient(token);
         try {
-            await api.post(`projects/${project.apiProjectId}/api-routes/publish/upsert`, {
+            await api.post(`projects/${apiProjectId}/api-routes/publish/upsert`, {
                 routes: files,
             });
-            await api.post(`projects/${project.apiProjectId}/api-routes/publish/prune`, {
+            await api.post(`projects/${apiProjectId}/api-routes/publish/prune`, {
                 filenames: files.map((file) => file.filename),
             });
         }
         catch (error) {
             this.error(error.message);
         }
-        this.log(`Published ${files.length} route${files.length === 1 ? '' : 's'} to your Loopress account.`);
+        this.log(`Published ${pluralize(files.length, 'route')} to your Loopress account.`);
     }
 }

package/dist/commands/api/pull.js

@@ -1,9 +1,9 @@
 import { Args } from '@oclif/core';
-import { Listr } from 'listr2';
 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)' }),
@@ -31,28 +31,23 @@ export default class Pull extends LoopressCommand {
             recursive: true,
         });
         const pulled = files.map((file) => file.filename);
-        if (this.dryRun) {
-            this.log(`[dry-run] Would pull ${files.length} route file${files.length === 1 ? '' : 's'} to ${path}`);
-            if (orphans.length > 0) {
-                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} whose route no longer exists on WordPress: ${orphans.join(', ')}`);
-            }
-            return { orphans, pulled, status: 'dry-run' };
-        }
-        await mkdir(path, { recursive: true });
-        await new Listr(files.map((file) => ({
-            async task(_ctx, task) {
-                const filePath = join(path, `${file.filename}.php`);
+        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);
-                task.output = `Pulled: ${file.filename}`;
             },
-            title: `Pull ${file.filename}`,
-        })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
-        await this.removeOrphanedFiles(path, orphans, 'whose route no longer exists on WordPress');
-        this.log(`Pulled ${files.length} route file${files.length === 1 ? '' : 's'} to ${path}`);
+        });
+        if (this.dryRun)
+            return { orphans, pulled, status: 'dry-run' };
         return { orphans, pulled, status: 'success' };
     }
 }

package/dist/commands/api/push.js

@@ -1,10 +1,10 @@
 import { Args } from '@oclif/core';
-import { Listr } from 'listr2';
 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
@@ -36,17 +36,14 @@ export default class Push extends PushCommand {
         this.log(`Pushing API routes to ${url}`);
         this.log(`API path: ${path}`);
         const files = await this.loadFiles(path);
-        this.log(`Found ${files.length} route file${files.length === 1 ? '' : 's'} to push`);
+        this.log(`Found ${pluralize(files.length, 'route file')} to push`);
         const pushed = [];
-        await new Listr(files.map((file) => ({
-            task: async (_ctx, task) => {
-                await this.pushFile(file, task);
-                pushed.push(file.filename);
-            },
-            title: `Push ${file.filename}`,
-        })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        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(`${this.failedCount} route file${this.failedCount === 1 ? '' : 's'} failed to push.`);
+            this.error(`${pluralize(this.failedCount, 'route file')} failed to push.`);
         }
         if (this.dryRun)
             return { pushed, status: 'dry-run' };

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/app/pull.d.ts

@@ -0,0 +1,27 @@
+import { LoopressCommand } from '../../lib/base.js';
+type PulledApp = {
+    files: number;
+    name: string;
+};
+type PullResult = {
+    orphans: string[];
+    pulled: PulledApp[];
+    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>;
+    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 {};