@gurulu/cli 0.1.0

package/dist/commands/login.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Phase 18.5 W2 — `gurulu login`.
+ *
+ * Rewritten from the Phase 8 legacy command. Authenticates against
+ * `POST /api/cli/verify-key`, persists the credentials into a profile,
+ * and prints a short summary fetched from `GET /api/cli/me`.
+ *
+ * The old login command lived in this same file, but nothing outside this
+ * package imports it directly — `src/index.ts` is the only caller.
+ */
+export interface LoginArgs {
+    profile?: string;
+    email?: string;
+    secretKey?: string;
+    noInteractive?: boolean;
+    useKeychain?: boolean;
+    apiBase?: string;
+    apiKey?: string;
+}
+export declare function loginCommand(args: LoginArgs): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Phase 18.5 W2 — `gurulu login`.
+ *
+ * Rewritten from the Phase 8 legacy command. Authenticates against
+ * `POST /api/cli/verify-key`, persists the credentials into a profile,
+ * and prints a short summary fetched from `GET /api/cli/me`.
+ *
+ * The old login command lived in this same file, but nothing outside this
+ * package imports it directly — `src/index.ts` is the only caller.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+function parseKeyFormat(key) {
+    if (!key)
+        return { valid: false, type: null };
+    const m = key.match(/^(gsk|gpk)_(live|test)_([A-Za-z0-9]+)$/);
+    if (!m)
+        return { valid: false, type: null };
+    if (m[3].length < 24)
+        return { valid: false, type: null };
+    return { valid: true, type: m[1] === 'gsk' ? 'sk' : 'pk' };
+}
+async function promptHidden(question) {
+    // Best-effort secret input. Does not echo while typing when stdin is a TTY.
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        stdout.write(question);
+        const isTTY = !!stdin.isTTY;
+        if (!isTTY) {
+            // Non-TTY: fall back to visible readline.
+            const readline = require('readline');
+            const rl = readline.createInterface({ input: stdin, output: stdout });
+            rl.question('', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+            return;
+        }
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let buf = '';
+        const onData = (ch) => {
+            for (const c of ch) {
+                if (c === '\n' || c === '\r' || c === '\u0004') {
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    stdin.removeListener('data', onData);
+                    stdout.write('\n');
+                    resolve(buf.trim());
+                    return;
+                }
+                if (c === '\u0003') {
+                    // Ctrl+C
+                    stdin.setRawMode(false);
+                    stdout.write('\n');
+                    process.exit(130);
+                }
+                if (c === '\u007f' || c === '\b') {
+                    if (buf.length > 0) {
+                        buf = buf.slice(0, -1);
+                        stdout.write('\b \b');
+                    }
+                }
+                else {
+                    buf += c;
+                    stdout.write('*');
+                }
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+async function loginCommand(args) {
+    const profileName = args.profile || 'personal';
+    let email = args.email || process.env.GURULU_EMAIL;
+    let secretKey = args.secretKey || args.apiKey || process.env.GURULU_SECRET_KEY;
+    if (!email) {
+        if (args.noInteractive) {
+            (0, ui_1.error)('Email required. Use --email or set GURULU_EMAIL.');
+            process.exit(1);
+        }
+        email = await (0, ui_1.prompt)('? Email: ');
+    }
+    if (!secretKey) {
+        if (args.noInteractive) {
+            (0, ui_1.error)('Secret key required. Use --secret-key or set GURULU_SECRET_KEY.');
+            process.exit(1);
+        }
+        secretKey = await promptHidden('? Secret key (gsk_...): ');
+    }
+    const parsed = parseKeyFormat(secretKey || '');
+    if (!parsed.valid || parsed.type !== 'sk') {
+        (0, ui_1.error)('Invalid key format. Expected gsk_live_... or gsk_test_...');
+        process.exit(1);
+    }
+    const apiBase = args.apiBase || (0, config_1.defaultApiBase)();
+    (0, ui_1.info)('[•] Verifying credentials...');
+    let verify;
+    try {
+        const res = await (0, api_client_1.cliApi)('/api/cli/verify-key', {
+            method: 'POST',
+            skipAuth: true,
+            body: JSON.stringify({ email, secret_key: secretKey }),
+            preloadedProfile: {
+                name: profileName,
+                email: email,
+                secret_key: secretKey,
+                api_base: apiBase,
+                source: 'env',
+            },
+        });
+        if (res.status === 401) {
+            (0, ui_1.error)('Invalid email or key.');
+            process.exit(1);
+        }
+        if (res.status === 429) {
+            (0, ui_1.error)('Too many attempts. Try again in 5 minutes.');
+            process.exit(1);
+        }
+        verify = await res.json();
+        if (!res.ok || !verify?.ok) {
+            (0, ui_1.error)(`Login failed: ${verify?.message || 'unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        (0, ui_1.error)(`Login failed: ${err.message}`);
+        process.exit(1);
+    }
+    // Persist to profile.
+    const { storedInKeychain } = await (0, config_1.saveProfile)(profileName, { email: email, secret_key: secretKey, api_base: apiBase }, { useKeychain: args.useKeychain ?? (0, config_1.isKeychainAvailable)() });
+    // Summary from /me (non-fatal if it fails).
+    let me = null;
+    try {
+        me = await (0, api_client_1.cliApiJson)('/api/cli/me', {
+            preloadedProfile: {
+                name: profileName,
+                email: email,
+                secret_key: secretKey,
+                api_base: apiBase,
+                source: 'file',
+            },
+        });
+    }
+    catch {
+        /* ignore */
+    }
+    const tenantName = verify.tenant?.name || '—';
+    const plan = verify.tenant?.plan || 'free';
+    const tenantId = verify.tenant?.id || '';
+    (0, ui_1.success)(`Authenticated as ${email} · ${tenantName} (${plan} plan)`);
+    if (tenantId)
+        (0, ui_1.info)(`  Tenant:  ${tenantId}`);
+    if (me) {
+        const sites = Array.isArray(me.sites) ? me.sites.length : 0;
+        const keys = Array.isArray(me.apiKeys) ? me.apiKeys.length : 0;
+        const live = (me.apiKeys || []).filter((k) => k.mode === 'live').length;
+        const test = (me.apiKeys || []).filter((k) => k.mode === 'test').length;
+        (0, ui_1.info)(`  Sites:   ${sites} active`);
+        (0, ui_1.info)(`  API keys: ${keys} (${live} live, ${test} test)`);
+    }
+    (0, ui_1.info)('');
+    (0, ui_1.info)(`Config saved to ${(0, ui_1.dim)(storedInKeychain ? `~/.gurulu/config.json + macOS Keychain` : `~/.gurulu/config.json`)}`);
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Phase 18.5 W2 — `gurulu logout`. Removes a stored profile (or all with
+ * --all). Non-interactive unless --yes is passed.
+ */
+export interface LogoutArgs {
+    profile?: string;
+    all?: boolean;
+    yes?: boolean;
+}
+export declare function logoutCommand(args: LogoutArgs): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Phase 18.5 W2 — `gurulu logout`. Removes a stored profile (or all with
+ * --all). Non-interactive unless --yes is passed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logoutCommand = logoutCommand;
+const config_1 = require("../config");
+const ui_1 = require("../utils/ui");
+async function logoutCommand(args) {
+    if (args.all) {
+        if (!args.yes) {
+            const answer = await (0, ui_1.prompt)('? Remove ALL stored profiles? [y/N] ');
+            if (!answer.toLowerCase().startsWith('y')) {
+                (0, ui_1.info)('Aborted.');
+                return;
+            }
+        }
+        const removed = await (0, config_1.deleteAllProfiles)();
+        (0, ui_1.success)(`Removed ${removed.length} profile(s).`);
+        return;
+    }
+    const name = args.profile || 'personal';
+    const stored = (0, config_1.getStoredProfile)(name);
+    if (!stored) {
+        (0, ui_1.error)(`Profile '${name}' not found.`);
+        process.exit(1);
+    }
+    if (!args.yes) {
+        const answer = await (0, ui_1.prompt)(`? Remove profile '${name}' (${stored.email})? [y/N] `);
+        if (!answer.toLowerCase().startsWith('y')) {
+            (0, ui_1.info)('Aborted.');
+            return;
+        }
+    }
+    const ok = await (0, config_1.deleteProfile)(name);
+    if (ok)
+        (0, ui_1.success)(`Profile '${name}' removed.`);
+    else
+        (0, ui_1.error)(`Failed to remove profile '${name}'.`);
+}

package/dist/commands/playground.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Phase 19.5 W2 B9 — `gurulu playground list`.
+ */
+export interface PlaygroundArgs {
+    action?: string;
+    status?: string;
+    limit?: number;
+    json?: boolean;
+    profile?: string;
+}
+export declare function playgroundCommand(args: PlaygroundArgs): Promise<void>;

package/dist/commands/playground.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Phase 19.5 W2 B9 — `gurulu playground list`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playgroundCommand = playgroundCommand;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function playgroundCommand(args) {
+    const action = args.action || 'list';
+    switch (action) {
+        case 'list':
+            return listCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown playground action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu playground [list]');
+            process.exit(1);
+    }
+}
+async function listCmd(args) {
+    const qs = new URLSearchParams();
+    if (args.status)
+        qs.set('status', args.status);
+    if (args.limit)
+        qs.set('limit', String(args.limit));
+    const path = `/api/cli/playground/sessions${qs.toString() ? `?${qs.toString()}` : ''}`;
+    const body = await (0, api_client_1.cliApiJson)(path, { profile: args.profile });
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    const rows = body.sessions || [];
+    if (rows.length === 0) {
+        (0, ui_1.info)('No playground sessions.');
+        return;
+    }
+    process.stdout.write(['ID', 'SITE', 'STATUS', 'STARTED', 'VERIFICATIONS'].join('\t') + '\n');
+    for (const s of rows) {
+        process.stdout.write([
+            s.id,
+            s.siteName || s.siteId,
+            s.status,
+            String(s.startedAt),
+            String(s.verificationsCount ?? 0),
+        ].join('\t') + '\n');
+    }
+}

package/dist/commands/sites.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Phase 18.5 W2 — `gurulu sites ...` subcommands.
+ *
+ * Resolves name-or-id arguments against `GET /api/cli/sites` first so users
+ * can pass either form. All commands tolerate --json and support --yes for
+ * non-interactive use.
+ */
+export interface SitesArgs {
+    action?: string;
+    target?: string;
+    name?: string;
+    domain?: string;
+    json?: boolean;
+    yes?: boolean;
+    archived?: boolean;
+    profile?: string;
+}
+export declare function sitesCommand(args: SitesArgs): Promise<void>;

package/dist/commands/sites.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Phase 18.5 W2 — `gurulu sites ...` subcommands.
+ *
+ * Resolves name-or-id arguments against `GET /api/cli/sites` first so users
+ * can pass either form. All commands tolerate --json and support --yes for
+ * non-interactive use.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sitesCommand = sitesCommand;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function listSites(profile) {
+    const body = await (0, api_client_1.cliApiJson)('/api/cli/sites', { profile });
+    return body.sites || [];
+}
+async function resolveSiteId(target, profile) {
+    if (!target)
+        throw new Error('site name or id required');
+    const sites = await listSites(profile);
+    const byId = sites.find((s) => s.id === target);
+    if (byId)
+        return byId.id;
+    const byName = sites.find((s) => s.name === target);
+    if (byName)
+        return byName.id;
+    const prefix = sites.find((s) => s.id.startsWith(target));
+    if (prefix)
+        return prefix.id;
+    throw new Error(`Site '${target}' not found.`);
+}
+async function sitesCommand(args) {
+    const action = args.action || 'list';
+    switch (action) {
+        case 'list':
+            return listCmd(args);
+        case 'create':
+            return createCmd(args);
+        case 'show':
+            return showCmd(args);
+        case 'delete':
+            return deleteCmd(args);
+        case 'rotate-token':
+            return rotateCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown sites action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu sites [list|create|show|delete|rotate-token]');
+            process.exit(1);
+    }
+}
+async function listCmd(args) {
+    const sites = await listSites(args.profile);
+    if (args.json) {
+        process.stdout.write(JSON.stringify(sites, null, 2) + '\n');
+        return;
+    }
+    if (sites.length === 0) {
+        (0, ui_1.info)('No sites yet. Run `gurulu sites create --name ... --domain ...`');
+        return;
+    }
+    process.stdout.write(['NAME', 'ID', 'DOMAIN', 'CREATED'].join('\t') + '\n');
+    for (const s of sites) {
+        process.stdout.write([s.name || '-', s.id, s.domain, new Date(s.createdAt).toISOString().slice(0, 10)].join('\t') + '\n');
+    }
+}
+async function createCmd(args) {
+    if (!args.domain) {
+        (0, ui_1.error)('--domain is required.');
+        process.exit(1);
+    }
+    const body = await (0, api_client_1.cliApiJson)('/api/cli/sites', {
+        method: 'POST',
+        profile: args.profile,
+        json: { name: args.name, domain: args.domain },
+    });
+    const site = body.site;
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    (0, ui_1.success)('Site created');
+    process.stdout.write(`  ID:              ${site.id}\n`);
+    process.stdout.write(`  Name:            ${site.name || '-'}\n`);
+    process.stdout.write(`  Domain:          ${site.domain}\n`);
+    process.stdout.write(`  Publishable key: ${site.publishableKey}\n\n`);
+    (0, ui_1.info)('Add to your site:');
+    process.stdout.write(`\n    <script src="https://gurulu.io/t.js" data-gurulu-site-id="${site.id}" data-gurulu-publishable-key="${site.publishableKey}" async></script>\n\n`);
+    (0, ui_1.info)(`Or run: ${(0, ui_1.dim)(`gurulu install --site ${site.name || site.id}`)}`);
+}
+async function showCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu sites show <name-or-id>');
+        process.exit(1);
+    }
+    const id = await resolveSiteId(args.target, args.profile);
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${encodeURIComponent(id)}`, {
+        profile: args.profile,
+    });
+    const site = body.site;
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    process.stdout.write(`Site:            ${site.name || '-'}\n`);
+    process.stdout.write(`ID:              ${site.id}\n`);
+    process.stdout.write(`Domain:          ${site.domain}\n`);
+    process.stdout.write(`Publishable key: ${site.publishableKey}\n`);
+    process.stdout.write(`Created:         ${site.createdAt}\n`);
+}
+async function deleteCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu sites delete <name-or-id>');
+        process.exit(1);
+    }
+    const id = await resolveSiteId(args.target, args.profile);
+    if (!args.yes) {
+        const ans = await (0, ui_1.prompt)(`? Delete site '${args.target}'? [y/N] `);
+        if (!ans.toLowerCase().startsWith('y')) {
+            (0, ui_1.info)('Aborted.');
+            return;
+        }
+    }
+    await (0, api_client_1.cliApiJson)(`/api/cli/sites/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+        profile: args.profile,
+    });
+    (0, ui_1.success)(`Site '${args.target}' deleted.`);
+}
+async function rotateCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu sites rotate-token <name-or-id>');
+        process.exit(1);
+    }
+    const id = await resolveSiteId(args.target, args.profile);
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${encodeURIComponent(id)}/rotate-token`, { method: 'POST', profile: args.profile, json: {} });
+    (0, ui_1.warn)(`Rotating publishable key for '${args.target}'`);
+    process.stdout.write(`  New: ${body.publishableKey}\n`);
+    (0, ui_1.warn)('Update your <script> tag before the 24h grace window expires.');
+}

package/dist/commands/sourcemap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `gurulu sourcemap upload` — Upload source maps for error deobfuscation.
+ *
+ * Reads all `.map` files from the specified directory and POSTs them to
+ * `/api/errors/sourcemaps` with Bearer auth. The server stores them on
+ * disk for later stack trace deobfuscation (follow-up task).
+ *
+ * Usage:
+ *   gurulu sourcemap upload --release v1.0.0 --dir .next/static/
+ */
+import { loadActiveProfile } from '../config';
+export interface SourcemapArgs {
+    action?: string;
+    release?: string;
+    dir?: string;
+    site?: string;
+    profile?: string;
+    json?: boolean;
+}
+export declare function sourcemapCommand(args: SourcemapArgs): Promise<void>;
+export declare const _loadActiveProfile: typeof loadActiveProfile;

package/dist/commands/sourcemap.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * `gurulu sourcemap upload` — Upload source maps for error deobfuscation.
+ *
+ * Reads all `.map` files from the specified directory and POSTs them to
+ * `/api/errors/sourcemaps` with Bearer auth. The server stores them on
+ * disk for later stack trace deobfuscation (follow-up task).
+ *
+ * Usage:
+ *   gurulu sourcemap upload --release v1.0.0 --dir .next/static/
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._loadActiveProfile = void 0;
+exports.sourcemapCommand = sourcemapCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const api_client_1 = require("../api-client");
+const config_1 = require("../config");
+const ui_1 = require("../utils/ui");
+async function sourcemapCommand(args) {
+    const action = args.action || 'upload';
+    if (action !== 'upload') {
+        (0, ui_1.error)(`Unknown sourcemap action: ${action}`);
+        (0, ui_1.info)('Usage: gurulu sourcemap upload --release <version> --dir <path>');
+        process.exit(1);
+    }
+    return uploadCmd(args);
+}
+function findMapFiles(dir) {
+    const results = [];
+    function walk(d) {
+        const entries = fs.readdirSync(d, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(d, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.name.endsWith('.map')) {
+                results.push(full);
+            }
+        }
+    }
+    walk(dir);
+    return results;
+}
+async function uploadCmd(args) {
+    if (!args.release) {
+        (0, ui_1.error)('Missing --release flag. Example: gurulu sourcemap upload --release v1.0.0 --dir .next/static/');
+        process.exit(1);
+    }
+    if (!args.dir) {
+        (0, ui_1.error)('Missing --dir flag. Example: gurulu sourcemap upload --release v1.0.0 --dir .next/static/');
+        process.exit(1);
+    }
+    const dir = path.resolve(args.dir);
+    if (!fs.existsSync(dir)) {
+        (0, ui_1.error)(`Directory not found: ${dir}`);
+        process.exit(1);
+    }
+    const mapFiles = findMapFiles(dir);
+    if (mapFiles.length === 0) {
+        (0, ui_1.error)(`No .map files found in ${dir}`);
+        process.exit(1);
+    }
+    (0, ui_1.info)(`Uploading ${mapFiles.length} source maps for ${args.release}...`);
+    // Resolve siteId from profile config
+    const profile = await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    const siteId = args.site || profile.site_id;
+    if (!siteId) {
+        (0, ui_1.error)('Missing --site flag or default site in profile. Use: gurulu sourcemap upload --site <site-id> ...');
+        process.exit(1);
+    }
+    // Build FormData
+    const formData = new FormData();
+    formData.append('release', args.release);
+    formData.append('siteId', siteId);
+    for (const filePath of mapFiles) {
+        const content = fs.readFileSync(filePath);
+        const fileName = path.basename(filePath);
+        const blob = new Blob([content], { type: 'application/json' });
+        formData.append(fileName, blob, fileName);
+    }
+    const res = await (0, api_client_1.cliApi)('/api/errors/sourcemaps', {
+        method: 'POST',
+        body: formData,
+        profile: args.profile,
+        // Do not set content-type — fetch will add multipart boundary automatically
+        headers: {},
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: 'Unknown error' }));
+        (0, ui_1.error)(`Upload failed (${res.status}): ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const result = await res.json();
+    if (args.json) {
+        process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+        return;
+    }
+    (0, ui_1.success)(`${result.uploaded} source maps uploaded for release ${args.release}`);
+    process.stdout.write((0, ui_1.dim)(`  Site: ${result.siteId}\n`));
+    process.stdout.write((0, ui_1.dim)(`  Path: ${result.path}\n`));
+}
+exports._loadActiveProfile = config_1.loadActiveProfile;

package/dist/commands/status.d.ts

@@ -0,0 +1,7 @@
+interface StatusArgs {
+    site?: string;
+    json?: boolean;
+    profile?: string;
+}
+export declare function statusCommand(args: StatusArgs): Promise<void>;
+export {};