@matthesketh/fleet 1.0.0

package/dist/commands/nginx.js

@@ -0,0 +1,94 @@
+import * as nginxCore from '../core/nginx.js';
+import { generateNginxConfig } from '../templates/nginx.js';
+import { FleetError } from '../core/errors.js';
+import { c, heading, table, success, error, info, warn } from '../ui/output.js';
+import { confirm } from '../ui/confirm.js';
+export async function nginxCommand(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    switch (sub) {
+        case 'add': return nginxAdd(rest);
+        case 'remove': return nginxRemove(rest);
+        case 'list': return nginxList(rest);
+        default:
+            error('Usage: fleet nginx <add|remove|list>');
+            process.exit(1);
+    }
+}
+async function nginxAdd(args) {
+    const dryRun = args.includes('--dry-run');
+    const yes = args.includes('-y') || args.includes('--yes');
+    const domain = args.find(a => !a.startsWith('-'));
+    const portIdx = args.indexOf('--port');
+    const port = portIdx >= 0 ? parseInt(args[portIdx + 1], 10) : null;
+    const typeIdx = args.indexOf('--type');
+    const type = (typeIdx >= 0 ? args[typeIdx + 1] : 'proxy');
+    if (!domain || !port) {
+        error('Usage: fleet nginx add <domain> --port <port> [--type proxy|spa|nextjs]');
+        process.exit(1);
+    }
+    const existing = nginxCore.readConfig(domain);
+    if (existing) {
+        throw new FleetError(`Config already exists for ${domain}`);
+    }
+    const config = generateNginxConfig({ domain, port, type });
+    if (dryRun) {
+        info('Generated config:');
+        process.stdout.write(config + '\n');
+        warn('Dry run - no changes made');
+        return;
+    }
+    nginxCore.installConfig(domain, config);
+    info(`Installed ${domain}.conf`);
+    const test = nginxCore.testConfig();
+    if (!test.ok) {
+        error(`Nginx config test failed: ${test.output}`);
+        nginxCore.removeConfig(domain);
+        error('Config removed due to test failure');
+        process.exit(1);
+    }
+    success('Nginx config test passed');
+    if (nginxCore.reload()) {
+        success(`Nginx reloaded - ${domain} is live`);
+    }
+    else {
+        warn('Failed to reload nginx - reload manually');
+    }
+    info(`Run certbot to add SSL: certbot --nginx -d ${domain} -d www.${domain}`);
+}
+async function nginxRemove(args) {
+    const yes = args.includes('-y') || args.includes('--yes');
+    const domain = args.find(a => !a.startsWith('-'));
+    if (!domain) {
+        error('Usage: fleet nginx remove <domain>');
+        process.exit(1);
+    }
+    if (!yes && !await confirm(`Remove nginx config for ${domain}?`)) {
+        info('Cancelled');
+        return;
+    }
+    if (nginxCore.removeConfig(domain)) {
+        success(`Removed ${domain}.conf`);
+        nginxCore.reload();
+        success('Nginx reloaded');
+    }
+    else {
+        error(`Config not found for ${domain}`);
+    }
+}
+function nginxList(args) {
+    const json = args.includes('--json');
+    const sites = nginxCore.listSites();
+    if (json) {
+        process.stdout.write(JSON.stringify(sites, null, 2) + '\n');
+        return;
+    }
+    heading(`Nginx Sites (${sites.length})`);
+    const rows = sites.map(s => [
+        `${c.bold}${s.domain}${c.reset}`,
+        s.enabled ? `${c.green}enabled${c.reset}` : `${c.dim}disabled${c.reset}`,
+        s.ssl ? `${c.green}ssl${c.reset}` : `${c.dim}no ssl${c.reset}`,
+    ]);
+    table(['DOMAIN', 'STATUS', 'SSL'], rows);
+    process.stdout.write('\n');
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1 @@
+export declare function removeCommand(args: string[]): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,28 @@
+import { load, save, findApp, removeApp } from '../core/registry.js';
+import { stopService, disableService } from '../core/systemd.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { success, error, info, warn } from '../ui/output.js';
+import { confirm } from '../ui/confirm.js';
+export async function removeCommand(args) {
+    const yes = args.includes('-y') || args.includes('--yes');
+    const appName = args.find(a => !a.startsWith('-'));
+    if (!appName) {
+        error('Usage: fleet remove <app>');
+        process.exit(1);
+    }
+    const reg = load();
+    const app = findApp(reg, appName);
+    if (!app)
+        throw new AppNotFoundError(appName);
+    if (!yes && !await confirm(`Remove ${app.name}? This will stop and disable the service.`)) {
+        info('Cancelled');
+        return;
+    }
+    info(`Stopping ${app.serviceName}...`);
+    stopService(app.serviceName);
+    info(`Disabling ${app.serviceName}...`);
+    disableService(app.serviceName);
+    save(removeApp(reg, app.name));
+    success(`Removed ${app.name} from registry`);
+    warn('Service file not deleted - remove manually if needed');
+}

package/dist/commands/restart.d.ts

@@ -0,0 +1 @@
+export declare function restartCommand(args: string[]): void;

package/dist/commands/restart.js

@@ -0,0 +1,22 @@
+import { load, findApp } from '../core/registry.js';
+import { restartService } from '../core/systemd.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { success, error } from '../ui/output.js';
+export function restartCommand(args) {
+    const appName = args[0];
+    if (!appName) {
+        error('Usage: fleet restart <app>');
+        process.exit(1);
+    }
+    const reg = load();
+    const app = findApp(reg, appName);
+    if (!app)
+        throw new AppNotFoundError(appName);
+    if (restartService(app.serviceName)) {
+        success(`Restarted ${app.name}`);
+    }
+    else {
+        error(`Failed to restart ${app.name}`);
+        process.exit(1);
+    }
+}

package/dist/commands/secrets.d.ts

@@ -0,0 +1 @@
+export declare function secretsCommand(args: string[]): Promise<void>;

package/dist/commands/secrets.js

@@ -0,0 +1,268 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { SecretsError } from '../core/errors.js';
+import { load, findApp } from '../core/registry.js';
+import { initVault, loadManifest, listSecrets } from '../core/secrets.js';
+import { setSecret, getSecret, importEnvFile, importDbSecrets, exportApp, unsealAll, sealFromRuntime, rotateKey, getStatus, detectDrift, } from '../core/secrets-ops.js';
+import { restoreVaultFile } from '../core/secrets.js';
+import { generateUnsealService } from '../templates/unseal.js';
+import { validateApp, validateAll } from '../core/secrets-validate.js';
+import { confirm } from '../ui/confirm.js';
+import { c, heading, table, success, error, info, warn } from '../ui/output.js';
+const DB_SECRETS_DIR = '/home/matt/docker-databases/secrets';
+export async function secretsCommand(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    switch (sub) {
+        case 'init': return secretsInit();
+        case 'list': return secretsList(rest);
+        case 'set': return secretsSet(rest);
+        case 'get': return secretsGet(rest);
+        case 'import': return secretsImport(rest);
+        case 'export': return secretsExport(rest);
+        case 'seal': return secretsSeal(rest);
+        case 'unseal': return secretsUnseal();
+        case 'rotate': return secretsRotate(rest);
+        case 'validate': return secretsValidate(rest);
+        case 'status': return secretsStatus(rest);
+        case 'drift': return secretsDrift(rest);
+        case 'restore': return secretsRestore(rest);
+        case 'seal-runtime': return secretsSeal(rest);
+        default:
+            error('Usage: fleet secrets <init|list|set|get|import|export|seal|unseal|rotate|validate|status|drift|restore>');
+            process.exit(1);
+    }
+}
+function secretsInit() {
+    const pubkey = initVault();
+    success(`Vault initialised`);
+    info(`Public key: ${pubkey}`);
+    const serviceContent = generateUnsealService();
+    const servicePath = '/etc/systemd/system/fleet-unseal.service';
+    writeFileSync(servicePath, serviceContent);
+    execSync('systemctl daemon-reload');
+    execSync('systemctl enable fleet-unseal');
+    success('Installed fleet-unseal.service');
+}
+function secretsList(args) {
+    const json = args.includes('--json');
+    const appName = args.find(a => !a.startsWith('-'));
+    if (appName) {
+        const secrets = listSecrets(appName);
+        if (json) {
+            process.stdout.write(JSON.stringify(secrets, null, 2) + '\n');
+            return;
+        }
+        heading(`Secrets: ${appName} (${secrets.length})`);
+        const rows = secrets.map(s => [s.key, `${c.dim}${s.maskedValue}${c.reset}`]);
+        table(['KEY', 'VALUE'], rows);
+        process.stdout.write('\n');
+        return;
+    }
+    const manifest = loadManifest();
+    const entries = Object.entries(manifest.apps);
+    if (json) {
+        process.stdout.write(JSON.stringify(manifest.apps, null, 2) + '\n');
+        return;
+    }
+    heading(`Managed Secrets (${entries.length} apps)`);
+    const rows = entries.map(([name, entry]) => [
+        `${c.bold}${name}${c.reset}`,
+        entry.type,
+        String(entry.keyCount),
+        entry.lastSealedAt.substring(0, 19).replace('T', ' '),
+    ]);
+    table(['APP', 'TYPE', 'KEYS', 'LAST SEALED'], rows);
+    process.stdout.write('\n');
+}
+function secretsSet(args) {
+    const [app, key, ...valueParts] = args;
+    const value = valueParts.join(' ');
+    if (!app || !key || !value) {
+        error('Usage: fleet secrets set <app> <KEY> <VALUE>');
+        process.exit(1);
+    }
+    setSecret(app, key, value);
+    success(`Set ${key} for ${app}`);
+}
+function secretsGet(args) {
+    const [app, key] = args;
+    if (!app || !key) {
+        error('Usage: fleet secrets get <app> <KEY>');
+        process.exit(1);
+    }
+    const val = getSecret(app, key);
+    if (val === null) {
+        error(`Key not found: ${key}`);
+        process.exit(1);
+    }
+    process.stdout.write(val + '\n');
+}
+function secretsImport(args) {
+    const app = args.find(a => !a.startsWith('-'));
+    const pathArg = args[1] && !args[1].startsWith('-') ? args[1] : null;
+    if (!app) {
+        error('Usage: fleet secrets import <app> [path]');
+        process.exit(1);
+    }
+    if (app === 'docker-databases') {
+        const dir = pathArg || DB_SECRETS_DIR;
+        const count = importDbSecrets(app, dir);
+        success(`Imported ${count} secret files from ${dir}`);
+        return;
+    }
+    const reg = load();
+    const entry = findApp(reg, app);
+    let envPath;
+    if (pathArg) {
+        envPath = pathArg;
+    }
+    else if (entry) {
+        envPath = join(entry.composePath, '.env');
+    }
+    else {
+        throw new SecretsError(`App not in registry and no path given: ${app}`);
+    }
+    const count = importEnvFile(app, envPath);
+    success(`Imported ${count} keys from ${envPath}`);
+}
+function secretsExport(args) {
+    const app = args[0];
+    if (!app) {
+        error('Usage: fleet secrets export <app>');
+        process.exit(1);
+    }
+    process.stdout.write(exportApp(app));
+}
+function secretsUnseal() {
+    unsealAll();
+    const manifest = loadManifest();
+    const count = Object.keys(manifest.apps).length;
+    success(`Unsealed ${count} apps to /run/fleet-secrets/`);
+}
+function secretsSeal(args) {
+    const app = args.find(a => !a.startsWith('-')) || undefined;
+    const sealed = sealFromRuntime(app);
+    for (const a of sealed) {
+        success(`Sealed ${a}`);
+    }
+}
+async function secretsRotate(args) {
+    const yes = args.includes('-y') || args.includes('--yes');
+    if (!yes && !await confirm('Rotate age key? This will re-encrypt all secrets.')) {
+        info('Cancelled');
+        return;
+    }
+    const result = rotateKey();
+    success(`Key rotated`);
+    info(`Old: ${result.oldPubkey}`);
+    info(`New: ${result.newPubkey}`);
+    info(`Re-encrypted ${result.appsRotated.length} apps`);
+    warn('Run "fleet secrets unseal" to update runtime secrets');
+}
+function secretsValidate(args) {
+    const json = args.includes('--json');
+    const appName = args.find(a => !a.startsWith('-'));
+    const results = appName ? [validateApp(appName)] : validateAll();
+    if (json) {
+        process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+        return;
+    }
+    heading('Secrets Validation');
+    let failures = 0;
+    for (const r of results) {
+        if (r.missing.length === 0 && r.extra.length === 0) {
+            if (r.ok) {
+                info(`${c.green}ok${c.reset}  ${r.app}`);
+            }
+            continue;
+        }
+        if (r.missing.length > 0) {
+            failures++;
+            error(`${r.app}: missing from vault: ${r.missing.join(', ')}`);
+        }
+        if (r.extra.length > 0) {
+            warn(`${r.app}: extra in vault (not in compose): ${r.extra.join(', ')}`);
+        }
+    }
+    process.stdout.write('\n');
+    if (failures > 0) {
+        error(`${failures} app(s) have missing secrets`);
+        process.exit(1);
+    }
+    success('All secrets validated');
+}
+function secretsStatus(args) {
+    const json = args.includes('--json');
+    const status = getStatus();
+    if (json) {
+        process.stdout.write(JSON.stringify(status, null, 2) + '\n');
+        return;
+    }
+    heading('Secrets Status');
+    const stateLabel = status.initialized
+        ? `${c.green}initialised${c.reset}`
+        : `${c.red}not initialised${c.reset}`;
+    const sealLabel = status.sealed
+        ? `${c.yellow}sealed${c.reset}`
+        : `${c.green}unsealed${c.reset}`;
+    info(`Vault: ${stateLabel}`);
+    info(`State: ${sealLabel}`);
+    info(`Key:   ${status.keyPath}`);
+    info(`Vault: ${status.vaultDir}`);
+    info(`Runtime: ${status.runtimeDir}`);
+    info(`Apps: ${status.appCount} | Keys: ${status.totalKeys}`);
+    process.stdout.write('\n');
+}
+function secretsDrift(args) {
+    const json = args.includes('--json');
+    const appName = args.find(a => !a.startsWith('-')) || undefined;
+    const results = detectDrift(appName);
+    if (json) {
+        process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+        return;
+    }
+    heading('Vault / Runtime Drift');
+    let hasDrift = false;
+    for (const r of results) {
+        if (r.status === 'in-sync') {
+            info(`${c.green}in-sync${c.reset}  ${r.app}`);
+            continue;
+        }
+        if (r.status === 'missing-runtime') {
+            warn(`${r.app}: no runtime secrets (sealed or never unsealed)`);
+            continue;
+        }
+        hasDrift = true;
+        error(`${r.app}: drifted`);
+        if (r.addedKeys.length > 0)
+            info(`  added at runtime: ${r.addedKeys.join(', ')}`);
+        if (r.removedKeys.length > 0)
+            info(`  removed at runtime: ${r.removedKeys.join(', ')}`);
+        if (r.changedKeys.length > 0)
+            info(`  changed at runtime: ${r.changedKeys.join(', ')}`);
+    }
+    process.stdout.write('\n');
+    if (hasDrift) {
+        warn('Run "fleet secrets seal" to persist runtime changes to vault');
+        warn('Run "fleet secrets unseal" to revert runtime to vault state');
+    }
+    else {
+        success('No drift detected');
+    }
+}
+function secretsRestore(args) {
+    const app = args.find(a => !a.startsWith('-'));
+    if (!app) {
+        error('Usage: fleet secrets restore <app>');
+        process.exit(1);
+    }
+    const ok = restoreVaultFile(app);
+    if (!ok) {
+        error(`No backup found for ${app}`);
+        process.exit(1);
+    }
+    success(`Restored vault backup for ${app}`);
+    info('Run "fleet secrets unseal" to apply to runtime');
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(args: string[]): void;

package/dist/commands/start.js

@@ -0,0 +1,22 @@
+import { load, findApp } from '../core/registry.js';
+import { startService } from '../core/systemd.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { success, error } from '../ui/output.js';
+export function startCommand(args) {
+    const appName = args[0];
+    if (!appName) {
+        error('Usage: fleet start <app>');
+        process.exit(1);
+    }
+    const reg = load();
+    const app = findApp(reg, appName);
+    if (!app)
+        throw new AppNotFoundError(appName);
+    if (startService(app.serviceName)) {
+        success(`Started ${app.name}`);
+    }
+    else {
+        error(`Failed to start ${app.name}`);
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,14 @@
+export interface StatusData {
+    apps: Array<{
+        name: string;
+        service: string;
+        systemd: string;
+        containers: string;
+        health: string;
+    }>;
+    totalApps: number;
+    healthy: number;
+    unhealthy: number;
+}
+export declare function getStatusData(): StatusData;
+export declare function statusCommand(args: string[]): void;

package/dist/commands/status.js

@@ -0,0 +1,70 @@
+import { load } from '../core/registry.js';
+import { getMultipleServiceStatuses, systemdAvailable } from '../core/systemd.js';
+import { listContainers } from '../core/docker.js';
+import { c, icon, heading, table, info } from '../ui/output.js';
+export function getStatusData() {
+    const reg = load();
+    const containers = listContainers();
+    const hasSystemd = systemdAvailable();
+    const serviceStatuses = hasSystemd
+        ? getMultipleServiceStatuses(reg.apps.map(a => a.serviceName))
+        : new Map();
+    const apps = reg.apps.map(app => {
+        const svc = serviceStatuses.get(app.serviceName) ?? null;
+        const appContainers = containers.filter(ct => app.containers.some(name => ct.name === name));
+        const allHealthy = appContainers.length > 0 &&
+            appContainers.every(ct => ct.health === 'healthy' || ct.health === 'none');
+        const allRunning = appContainers.every(ct => ct.status.startsWith('Up'));
+        let health;
+        if (svc && !svc.active) {
+            // systemd says service is not active — it's down
+            health = 'down';
+        }
+        else if (appContainers.length === 0) {
+            health = 'unknown';
+        }
+        else if (allHealthy && allRunning) {
+            health = 'healthy';
+        }
+        else {
+            health = 'degraded';
+        }
+        return {
+            name: app.name,
+            service: app.serviceName,
+            systemd: svc?.state ?? 'n/a',
+            containers: `${appContainers.filter(ct => ct.status.startsWith('Up')).length}/${app.containers.length}`,
+            health,
+        };
+    });
+    return {
+        apps,
+        totalApps: apps.length,
+        healthy: apps.filter(a => a.health === 'healthy').length,
+        unhealthy: apps.filter(a => a.health !== 'healthy').length,
+    };
+}
+export function statusCommand(args) {
+    const json = args.includes('--json');
+    const data = getStatusData();
+    if (json) {
+        process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+        return;
+    }
+    heading('Fleet Dashboard');
+    info(`${data.totalApps} apps | ${c.green}${data.healthy} healthy${c.reset} | ${data.unhealthy > 0 ? c.red : c.dim}${data.unhealthy} unhealthy${c.reset}`);
+    const rows = data.apps.map(app => {
+        const healthIcon = app.health === 'healthy' ? icon.ok
+            : app.health === 'degraded' ? icon.warn
+                : icon.err;
+        const systemdColor = app.systemd === 'active' ? c.green : c.red;
+        return [
+            `${c.bold}${app.name}${c.reset}`,
+            `${systemdColor}${app.systemd}${c.reset}`,
+            app.containers,
+            `${healthIcon} ${app.health}`,
+        ];
+    });
+    table(['APP', 'SYSTEMD', 'CONTAINERS', 'HEALTH'], rows);
+    process.stdout.write('\n');
+}

package/dist/commands/stop.d.ts

@@ -0,0 +1 @@
+export declare function stopCommand(args: string[]): void;

package/dist/commands/stop.js

@@ -0,0 +1,22 @@
+import { load, findApp } from '../core/registry.js';
+import { stopService } from '../core/systemd.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { success, error } from '../ui/output.js';
+export function stopCommand(args) {
+    const appName = args[0];
+    if (!appName) {
+        error('Usage: fleet stop <app>');
+        process.exit(1);
+    }
+    const reg = load();
+    const app = findApp(reg, appName);
+    if (!app)
+        throw new AppNotFoundError(appName);
+    if (stopService(app.serviceName)) {
+        success(`Stopped ${app.name}`);
+    }
+    else {
+        error(`Failed to stop ${app.name}`);
+        process.exit(1);
+    }
+}

package/dist/commands/watchdog.d.ts

@@ -0,0 +1 @@
+export declare function watchdogCommand(_args: string[]): Promise<void>;

package/dist/commands/watchdog.js

@@ -0,0 +1,100 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { load } from '../core/registry.js';
+import { checkAllHealth } from '../core/health.js';
+import { getServiceStatus } from '../core/systemd.js';
+import { error, success, warn } from '../ui/output.js';
+const TELEGRAM_CONFIG_PATH = '/etc/fleet/telegram.json';
+function loadTelegramConfig() {
+    if (!existsSync(TELEGRAM_CONFIG_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(TELEGRAM_CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function sendTelegram(config, message) {
+    try {
+        const url = `https://api.telegram.org/bot${config.botToken}/sendMessage`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                chat_id: config.chatId,
+                text: message,
+                parse_mode: 'HTML',
+            }),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function getHostname() {
+    try {
+        return readFileSync('/etc/hostname', 'utf-8').trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export async function watchdogCommand(_args) {
+    const failures = [];
+    const hostname = getHostname();
+    // check docker-databases systemd status
+    const dbStatus = getServiceStatus('docker-databases');
+    if (!dbStatus.active) {
+        failures.push(`docker-databases: systemd ${dbStatus.state}`);
+    }
+    // check all registered apps
+    const reg = load();
+    const results = checkAllHealth(reg.apps);
+    for (const r of results) {
+        if (r.overall === 'down') {
+            failures.push(`${r.app}: down (systemd: ${r.systemd.state})`);
+        }
+        else if (r.overall === 'degraded') {
+            const reasons = [];
+            if (!r.systemd.ok)
+                reasons.push(`systemd: ${r.systemd.state}`);
+            const deadContainers = r.containers.filter(c => !c.running).map(c => c.name);
+            if (deadContainers.length > 0)
+                reasons.push(`containers down: ${deadContainers.join(', ')}`);
+            if (r.http && !r.http.ok)
+                reasons.push('http check failed');
+            failures.push(`${r.app}: degraded (${reasons.join('; ')})`);
+        }
+    }
+    if (failures.length === 0) {
+        success(`All ${results.length + 1} services healthy`);
+        return;
+    }
+    const summary = `${failures.length} service(s) unhealthy`;
+    warn(summary);
+    for (const f of failures) {
+        error(`  ${f}`);
+    }
+    // send telegram alert
+    const config = loadTelegramConfig();
+    if (!config) {
+        warn('No telegram config at /etc/fleet/telegram.json — alert not sent');
+        process.exit(1);
+    }
+    const message = [
+        `<b>fleet watchdog alert</b>`,
+        `<b>host:</b> ${hostname}`,
+        `<b>failures:</b> ${failures.length}`,
+        '',
+        ...failures.map(f => `- ${f}`),
+    ].join('\n');
+    const sent = await sendTelegram(config, message);
+    if (sent) {
+        success('Telegram alert sent');
+    }
+    else {
+        error('Failed to send Telegram alert');
+    }
+    process.exit(1);
+}

package/dist/core/docker.d.ts

@@ -0,0 +1,15 @@
+export interface ContainerInfo {
+    name: string;
+    status: string;
+    health: string;
+    ports: string;
+    image: string;
+    uptime: string;
+}
+export declare function listContainers(): ContainerInfo[];
+export declare function getContainersByCompose(composePath: string, composeFile: string | null): string[];
+export declare function getContainerLogs(container: string, lines?: number): string;
+export declare function composeBuild(composePath: string, composeFile: string | null, appName?: string): boolean;
+export declare function composeUp(composePath: string, composeFile: string | null): boolean;
+export declare function composeDown(composePath: string, composeFile: string | null): boolean;
+export declare function inspectContainer(name: string): Record<string, unknown> | null;