@loopress/cli 0.22.0 → 0.23.0

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 {};

package/dist/commands/app/remove.js

@@ -0,0 +1,42 @@
+import { confirm } from '@inquirer/prompts';
+import { Args } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+import { isInteractive } from '../../lib/interactive.js';
+export default class Remove extends LoopressCommand {
+    static args = {
+        name: Args.string({ description: 'App to remove from WordPress', required: true }),
+    };
+    static description = 'Remove a single-page app from WordPress: deletes its bundle from wp-content/loopress/apps/ and unregisters the shortcode. Local files are left untouched.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps app remove search'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Remove);
+        const { name } = args;
+        const { url } = this.siteConfig;
+        if (this.dryRun) {
+            this.log(`[dry-run] Would delete app "${name}" from ${url}`);
+            return { deleted: false, name, status: 'dry-run' };
+        }
+        await guardProductionPush({
+            dryRun: this.dryRun,
+            error: (message) => this.error(message),
+            siteConfig: this.siteConfig,
+            yes: this.yes,
+        });
+        if (!this.yes && isInteractive()) {
+            const isProceed = await confirm({ default: false, message: `Delete app "${name}" from ${url}?` });
+            if (!isProceed) {
+                this.log('Aborted.');
+                return { deleted: false, name, status: 'aborted' };
+            }
+        }
+        await this.wp.delete(`loopress/v1/apps/${name}`);
+        this.log(`Removed app "${name}" from ${url}`);
+        return { deleted: true, name, status: 'success' };
+    }
+}

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

@@ -9,6 +9,7 @@ export default class ComposerPush extends PushCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/composer/push.js

@@ -1,53 +1,77 @@
+import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { isTimeoutError } from '../../lib/wp-client.js';
-// A cold composer install easily exceeds the global 30s timeout of WpClient.
-const COMPOSER_SYNC_TIMEOUT_MS = 600_000;
+import { parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
+// Split a composer.json `require` map into the three intent namespaces the sync endpoint
+// understands. `composer/installers` is owned by the server scaffold, never sent.
+function toIntent(require) {
+    const intent = { libraries: {}, plugins: {}, themes: {} };
+    for (const [name, constraint] of Object.entries(require)) {
+        if (name === 'composer/installers')
+            continue;
+        if (name.startsWith('wpackagist-plugin/')) {
+            intent.plugins[name.slice('wpackagist-plugin/'.length)] = constraint;
+        }
+        else if (name.startsWith('wpackagist-theme/')) {
+            intent.themes[name.slice('wpackagist-theme/'.length)] = constraint;
+        }
+        else {
+            intent.libraries[name] = constraint;
+        }
+    }
+    return intent;
+}
 export default class ComposerPush extends PushCommand {
-    static description = 'Push composer.json and composer.lock to WordPress and run composer install';
+    static description = 'Push composer.json (and composer.lock, if present) to WordPress and run Composer';
     static enableJsonFlag = true;
     static examples = ['$ lps composer push', '$ lps composer push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
         ...PushCommand.yesFlag,
+        force: Flags.boolean({ default: false, description: 'Allow downgrades and take over plugins/themes installed outside Loopress' }),
     };
     async run() {
         const { url } = this.siteConfig;
+        const { flags } = await this.parse(ComposerPush);
+        const { force } = flags;
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         const composerLockPath = join(process.cwd(), this.rootDir, 'composer.lock');
         if (!existsSync(composerJsonPath)) {
-            this.error(`No composer.json found at ${composerJsonPath}`);
+            this.error(`No composer.json found at ${composerJsonPath}. Run \`lps composer init\` first.`);
         }
-        const composerJsonRaw = await readFile(composerJsonPath, 'utf8');
-        const parsed = JSON.parse(composerJsonRaw);
-        const packageCount = Object.keys(parsed.require ?? {}).length;
+        const parsed = JSON.parse(await readFile(composerJsonPath, 'utf8'));
+        const require = parsed.require ?? {};
+        const packageCount = Object.keys(require).length;
+        const intent = toIntent(require);
         const hasLock = existsSync(composerLockPath);
-        const composerLockRaw = hasLock ? await readFile(composerLockPath, 'utf8') : null;
+        const lock = hasLock ? await readFile(composerLockPath, 'utf8') : null;
         this.log(`Pushing composer.json (${packageCount} ${packageCount === 1 ? 'package' : 'packages'}) to ${url}`);
-        if (composerLockRaw) {
+        if (lock)
             this.log('  + composer.lock included (reproducible install)');
-        }
-        else {
+        else
             this.warn('No composer.lock found. The server will resolve versions freely.');
-        }
         if (this.dryRun)
             return { hasLock, packageCount, status: 'dry-run' };
-        this.log('Running composer install on the server, this can take a few minutes...');
+        this.log('Running Composer on the server, this can take a few minutes...');
+        let response;
         try {
-            await this.wp.post('loopress/v1/composer/sync', {
-                composerJson: composerJsonRaw,
-                composerLock: composerLockRaw,
-            }, { timeoutMs: COMPOSER_SYNC_TIMEOUT_MS });
+            response = await this.wp.post('loopress/v1/composer/sync', { force, intent, lock }, { timeoutMs: SYNC_TIMEOUT_MS });
         }
         catch (error) {
+            if (parseCollisions(error)) {
+                this.error('Plugins or themes are installed outside Loopress. Re-run with --force to take them over.');
+            }
             if (isTimeoutError(error)) {
-                this.error(`${error.message} The composer install may still be running on the server.`);
+                this.error(`${error.message} The Composer run may still be in progress on the server.`);
             }
             throw error;
         }
-        this.log('composer install completed on the server.');
+        if (response.output.trim())
+            this.log(response.output.trim());
+        this.log('Composer run completed on the server.');
         await this.recordSuccess();
         return { hasLock, packageCount, status: 'success' };
     }

package/dist/commands/init.js

@@ -18,6 +18,7 @@ const FEATURES = [
     { dir: 'forms', key: 'formDir', label: 'Forms' },
     { dir: 'pages', key: 'pageDir', label: 'Pages' },
     { dir: 'api', key: 'apiDir', label: 'Custom API routes' },
+    { dir: 'apps', key: 'appsDir', label: 'Single-page apps' },
 ];
 export default class Init extends Command {
     static description = 'Initialize a loopress.json config file in the current directory';

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

@@ -6,6 +6,7 @@ export default class Add extends LoopressCommand {
     static description: string;
     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>;

package/dist/commands/plugin/add.js

@@ -1,32 +1,42 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { LoopressCommand } from '../../lib/base.js';
 import { writeLocalConfig } from '../../utils/loopress-config.js';
+import { isExactVersion } from '../../utils/version.js';
 export default class Add extends LoopressCommand {
     static args = {
         slug: Args.string({ description: 'Plugin slug on WordPress.org', required: true }),
     };
     static description = 'Add a WordPress.org plugin to loopress.json';
-    static examples = ['$ lps plugin add woocommerce', '$ lps plugin add contact-form-7 --dry-run'];
+    static examples = [
+        '$ lps plugin add woocommerce',
+        '$ lps plugin add woocommerce --version 9.4.2',
+        '$ lps plugin add contact-form-7 --dry-run',
+    ];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        version: Flags.string({ description: 'Exact version to pin (default: "latest", tracked on every push)' }),
     };
     async run() {
-        const { args } = await this.parse(Add);
+        const { args, flags } = await this.parse(Add);
         const { slug } = args;
+        const version = flags.version ?? 'latest';
+        if (version !== 'latest' && !isExactVersion(version)) {
+            this.error(`--version must be an exact version like 9.4.2, not a Composer constraint. Got "${version}".`);
+        }
         const existing = this.localConfig.plugins ?? {};
-        if (existing[slug] === 'latest') {
-            this.log(`${slug} is already in loopress.json, nothing to do.`);
+        if (existing[slug] === version) {
+            this.log(`${slug} is already pinned to ${version} in loopress.json, nothing to do.`);
             return;
         }
         const isUpdated = existing[slug] !== undefined;
         if (this.dryRun) {
-            this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} in loopress.json`);
+            this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} (${version}) in loopress.json`);
             return;
         }
         await writeLocalConfig({
             ...this.localConfig,
-            plugins: { ...existing, [slug]: 'latest' },
+            plugins: { ...existing, [slug]: version },
         });
-        this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug}`);
+        this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug} (${version}). Run \`lps plugin push\` to apply.`);
     }
 }

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

@@ -0,0 +1,30 @@
+import { LoopressCommand } from '../../lib/base.js';
+type Advisory = {
+    cve?: string;
+    fixedIn?: string;
+    score?: number;
+    severity?: string;
+    slug: string;
+    title: string;
+};
+type HealthNote = {
+    message: string;
+    slug: string;
+};
+type AuditResult = {
+    advisories: Advisory[];
+    health: HealthNote[];
+    status: 'clean' | 'issues';
+};
+export default class Audit extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<AuditResult>;
+    private auditOne;
+    private fetchHealth;
+    private fetchVulnerabilities;
+    private report;
+}
+export {};