@matthesketh/fleet 1.0.0

package/dist/commands/git.js

@@ -0,0 +1,278 @@
+import { load, findApp } from '../core/registry.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { getGitStatus, getProjectRoot, gitAdd, gitCommit, gitCheckout, gitPush, } from '../core/git.js';
+import { detectScenario, describeOnboardPlan, executeOnboard } from '../core/git-onboard.js';
+import * as github from '../core/github.js';
+import { confirm } from '../ui/confirm.js';
+import { c, heading, table, success, error, info, warn } from '../ui/output.js';
+function requireApp(name) {
+    const reg = load();
+    const app = findApp(reg, name);
+    if (!app)
+        throw new AppNotFoundError(name);
+    return { reg, app };
+}
+function root(composePath) {
+    return getProjectRoot(composePath);
+}
+export async function gitCommand(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    switch (sub) {
+        case 'status': return gitStatusCmd(rest);
+        case 'onboard': return gitOnboardCmd(rest);
+        case 'onboard-all': return gitOnboardAllCmd(rest);
+        case 'branch': return gitBranchCmd(rest);
+        case 'commit': return gitCommitCmd(rest);
+        case 'push': return gitPushCmd(rest);
+        case 'pr': return gitPrCmd(rest);
+        case 'release': return gitReleaseCmd(rest);
+        default:
+            error('Usage: fleet git <status|onboard|onboard-all|branch|commit|push|pr|release>');
+            process.exit(1);
+    }
+}
+function gitStatusCmd(args) {
+    const json = args.includes('--json');
+    const appName = args.find(a => !a.startsWith('-'));
+    const reg = load();
+    if (appName) {
+        const app = findApp(reg, appName);
+        if (!app)
+            throw new AppNotFoundError(appName);
+        const r = root(app.composePath);
+        const status = getGitStatus(r);
+        if (json) {
+            process.stdout.write(JSON.stringify({ app: app.name, root: r, ...status }, null, 2) + '\n');
+            return;
+        }
+        heading(`Git: ${app.name}`);
+        info(`root: ${r}`);
+        info(`initialised: ${status.initialised}`);
+        if (status.initialised) {
+            info(`branch: ${status.branch} | branches: ${status.branches.join(', ')}`);
+            info(`remote: ${status.remoteUrl || 'none'}`);
+            info(`clean: ${status.clean}`);
+            if (!status.clean)
+                info(`staged: ${status.staged}  modified: ${status.modified}  untracked: ${status.untracked}`);
+            if (status.ahead || status.behind)
+                info(`ahead: ${status.ahead}  behind: ${status.behind}`);
+        }
+        info(`onboarded: ${app.gitOnboardedAt || 'no'}`);
+        return;
+    }
+    const results = reg.apps.map(app => ({
+        name: app.name,
+        status: getGitStatus(root(app.composePath)),
+        onboarded: app.gitOnboardedAt,
+    }));
+    if (json) {
+        process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+        return;
+    }
+    heading(`Git Status (${results.length} apps)`);
+    const rows = results.map(r => {
+        const s = r.status;
+        const state = !s.initialised
+            ? `${c.red}no git${c.reset}`
+            : s.clean ? `${c.green}clean${c.reset}` : `${c.yellow}dirty${c.reset}`;
+        const ob = r.onboarded ? `${c.green}yes${c.reset}` : `${c.dim}no${c.reset}`;
+        return [`${c.bold}${r.name}${c.reset}`, s.branch || '-', state, ob];
+    });
+    table(['APP', 'BRANCH', 'STATE', 'ONBOARDED'], rows);
+    process.stdout.write('\n');
+}
+async function gitOnboardCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const yes = args.includes('-y') || args.includes('--yes');
+    const appName = args.find(a => !a.startsWith('-'));
+    if (!appName) {
+        error('Usage: fleet git onboard <app> [--dry-run] [-y]');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const r = root(app.composePath);
+    const status = getGitStatus(r);
+    const scenario = detectScenario(status);
+    if (dryRun) {
+        heading(`Onboard plan: ${app.name} (${scenario})`);
+        info(`root: ${r}`);
+        describeOnboardPlan(scenario, app.name, status).forEach((s, i) => info(`${i + 1}. ${s}`));
+        warn('dry run - no changes made');
+        return;
+    }
+    if (!yes && !await confirm(`Onboard ${app.name} (${scenario})? This will create a GitHub repo and push code.`)) {
+        info('cancelled');
+        return;
+    }
+    const result = executeOnboard(scenario, r, app.name, app.name, status);
+    heading(`Onboarded: ${app.name}`);
+    result.steps.forEach(s => success(s));
+    info(`repo: ${result.repoUrl}`);
+}
+async function gitOnboardAllCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const yes = args.includes('-y') || args.includes('--yes');
+    const reg = load();
+    const todo = reg.apps.filter(a => !a.gitOnboardedAt);
+    if (todo.length === 0) {
+        info('all apps already onboarded');
+        return;
+    }
+    heading(`Onboard ${todo.length} apps`);
+    for (const app of todo) {
+        const r = root(app.composePath);
+        const status = getGitStatus(r);
+        const scenario = detectScenario(status);
+        if (dryRun) {
+            info(`\n${c.bold}${app.name}${c.reset} (${scenario})`);
+            describeOnboardPlan(scenario, app.name, status).forEach((s, i) => info(`  ${i + 1}. ${s}`));
+            continue;
+        }
+        if (!yes && !await confirm(`Onboard ${app.name} (${scenario})?`)) {
+            warn(`skipped ${app.name}`);
+            continue;
+        }
+        try {
+            const result = executeOnboard(scenario, r, app.name, app.name, status);
+            success(`${app.name}: onboarded (${result.scenario})`);
+        }
+        catch (err) {
+            error(`${app.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (dryRun)
+        warn('\ndry run - no changes made');
+}
+function gitBranchCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const positional = args.filter(a => !a.startsWith('-'));
+    const appName = positional[0];
+    const branchName = positional[1];
+    const fromIdx = args.indexOf('--from');
+    const from = fromIdx >= 0 ? args[fromIdx + 1] : 'develop';
+    if (!appName || !branchName) {
+        error('Usage: fleet git branch <app> <name> [--from develop]');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const r = root(app.composePath);
+    if (dryRun) {
+        info(`would checkout ${from}, create branch ${branchName}, and push`);
+        return;
+    }
+    gitCheckout(r, from);
+    gitCheckout(r, branchName, true);
+    gitPush(r, branchName, true);
+    success(`created and pushed branch ${branchName} from ${from}`);
+}
+function gitCommitCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const appName = args.find(a => !a.startsWith('-') && a !== '-m');
+    const msgIdx = args.indexOf('-m');
+    const message = msgIdx >= 0 ? args[msgIdx + 1] : '';
+    if (!appName || !message) {
+        error('Usage: fleet git commit <app> -m "message"');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const r = root(app.composePath);
+    if (dryRun) {
+        info(`would stage all and commit: "${message}"`);
+        return;
+    }
+    gitAdd(r);
+    gitCommit(r, message);
+    success(`committed: ${message}`);
+}
+function gitPushCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const appName = args.find(a => !a.startsWith('-'));
+    if (!appName) {
+        error('Usage: fleet git push <app>');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const r = root(app.composePath);
+    const status = getGitStatus(r);
+    if (dryRun) {
+        info(`would push branch ${status.branch}`);
+        return;
+    }
+    gitPush(r, status.branch, true);
+    success(`pushed ${status.branch}`);
+}
+function gitPrCmd(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    switch (sub) {
+        case 'create': return gitPrCreateCmd(rest);
+        case 'list': return gitPrListCmd(rest);
+        default:
+            error('Usage: fleet git pr <create|list>');
+            process.exit(1);
+    }
+}
+function gitPrCreateCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const appName = args.find(a => !a.startsWith('-'));
+    const titleIdx = args.indexOf('--title');
+    const title = titleIdx >= 0 ? args[titleIdx + 1] : '';
+    const baseIdx = args.indexOf('--base');
+    const base = baseIdx >= 0 ? args[baseIdx + 1] : 'develop';
+    if (!appName || !title) {
+        error('Usage: fleet git pr create <app> --title "..." [--base develop]');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const r = root(app.composePath);
+    const status = getGitStatus(r);
+    if (dryRun) {
+        info(`would create PR: "${title}" (${status.branch} -> ${base})`);
+        return;
+    }
+    const pr = github.createPullRequest(app.name, { title, head: status.branch, base });
+    success(`created PR #${pr.number}: ${pr.url}`);
+}
+function gitPrListCmd(args) {
+    const json = args.includes('--json');
+    const appName = args.find(a => !a.startsWith('-'));
+    if (!appName) {
+        error('Usage: fleet git pr list <app> [--json]');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const prs = github.listPullRequests(app.name);
+    if (json) {
+        process.stdout.write(JSON.stringify(prs, null, 2) + '\n');
+        return;
+    }
+    if (prs.length === 0) {
+        info('no open pull requests');
+        return;
+    }
+    heading(`Pull Requests: ${app.name} (${prs.length} open)`);
+    const rows = prs.map(pr => [
+        `${c.bold}#${pr.number}${c.reset}`, pr.title, `${pr.head} -> ${pr.base}`, pr.url,
+    ]);
+    table(['PR', 'TITLE', 'BRANCHES', 'URL'], rows);
+    process.stdout.write('\n');
+}
+function gitReleaseCmd(args) {
+    const dryRun = args.includes('--dry-run');
+    const appName = args.find(a => !a.startsWith('-'));
+    const titleIdx = args.indexOf('--title');
+    const title = titleIdx >= 0 ? args[titleIdx + 1] : '';
+    if (!appName) {
+        error('Usage: fleet git release <app> [--title "..."]');
+        process.exit(1);
+    }
+    const { app } = requireApp(appName);
+    const prTitle = title || `Release: ${app.name}`;
+    if (dryRun) {
+        info(`would create PR: "${prTitle}" (develop -> main)`);
+        return;
+    }
+    const pr = github.createPullRequest(app.name, { title: prTitle, head: 'develop', base: 'main' });
+    success(`created release PR #${pr.number}: ${pr.url}`);
+}

package/dist/commands/health.d.ts

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

package/dist/commands/health.js

@@ -0,0 +1,60 @@
+import { load, findApp } from '../core/registry.js';
+import { checkHealth, checkAllHealth } from '../core/health.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { c, icon, heading, table } from '../ui/output.js';
+export function healthCommand(args) {
+    const json = args.includes('--json');
+    const appName = args.find(a => !a.startsWith('-'));
+    const reg = load();
+    if (appName) {
+        const app = findApp(reg, appName);
+        if (!app)
+            throw new AppNotFoundError(appName);
+        const result = checkHealth(app);
+        if (json) {
+            process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+            return;
+        }
+        heading(`Health: ${app.name}`);
+        const sIcon = result.systemd.ok ? icon.ok : icon.err;
+        process.stdout.write(`  Systemd:    ${sIcon} ${result.systemd.state}\n`);
+        for (const ct of result.containers) {
+            const cIcon = ct.running ? icon.ok : icon.err;
+            process.stdout.write(`  Container:  ${cIcon} ${ct.name} (${ct.health})\n`);
+        }
+        if (result.http) {
+            const hIcon = result.http.ok ? icon.ok : icon.err;
+            const detail = result.http.ok ? `${result.http.status}` : (result.http.error ?? 'failed');
+            process.stdout.write(`  HTTP:       ${hIcon} ${detail}\n`);
+        }
+        const oColor = result.overall === 'healthy' ? c.green
+            : result.overall === 'degraded' ? c.yellow : c.red;
+        process.stdout.write(`  Overall:    ${oColor}${result.overall}${c.reset}\n\n`);
+        return;
+    }
+    const results = checkAllHealth(reg.apps);
+    if (json) {
+        process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+        return;
+    }
+    heading('Health Check');
+    const rows = results.map(r => {
+        const oIcon = r.overall === 'healthy' ? icon.ok
+            : r.overall === 'degraded' ? icon.warn : icon.err;
+        const sIcon = r.systemd.ok ? icon.ok : icon.err;
+        const cOk = r.containers.filter(ct => ct.running).length;
+        const cTotal = r.containers.length;
+        const httpStatus = r.http
+            ? (r.http.ok ? `${icon.ok} ${r.http.status}` : `${icon.err} fail`)
+            : `${c.dim}-${c.reset}`;
+        return [
+            `${c.bold}${r.app}${c.reset}`,
+            `${sIcon} ${r.systemd.state}`,
+            `${cOk}/${cTotal}`,
+            httpStatus,
+            `${oIcon} ${r.overall}`,
+        ];
+    });
+    table(['APP', 'SYSTEMD', 'CONTAINERS', 'HTTP', 'OVERALL'], rows);
+    process.stdout.write('\n');
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { load, save } from '../core/registry.js';
+import { discoverServices, parseServiceFile, readServiceFile } from '../core/systemd.js';
+import { listContainers, getContainersByCompose } from '../core/docker.js';
+import { listSites, readConfig, extractPortFromConfig, extractDomainsFromConfig } from '../core/nginx.js';
+import { heading, success, info } from '../ui/output.js';
+const SKIP_SERVICES = ['docker-databases'];
+export function initCommand(args) {
+    const json = args.includes('--json');
+    heading('Fleet Init - Auto-discovering apps');
+    const reg = load();
+    const services = discoverServices();
+    const containers = listContainers();
+    const sites = listSites();
+    info(`Found ${services.length} docker compose services`);
+    info(`Found ${containers.length} running containers`);
+    info(`Found ${sites.length} nginx sites`);
+    let added = 0;
+    for (const serviceName of services) {
+        if (SKIP_SERVICES.includes(serviceName))
+            continue;
+        const content = readServiceFile(serviceName);
+        if (!content)
+            continue;
+        const parsed = parseServiceFile(content);
+        if (!parsed.workingDirectory)
+            continue;
+        const composePath = parsed.workingDirectory;
+        const composeFile = parsed.composeFile;
+        const composeContainers = getContainersByCompose(composePath, composeFile);
+        const port = detectPort(composePath, composeFile, composeContainers, containers);
+        const domains = detectDomains(serviceName, sites, port);
+        const usesSharedDb = detectSharedDb(composePath, composeFile);
+        const type = detectType(composePath, composeFile, domains);
+        const displayName = detectDisplayName(serviceName, content);
+        const app = {
+            name: serviceName,
+            displayName,
+            composePath,
+            composeFile,
+            serviceName,
+            domains,
+            port,
+            usesSharedDb,
+            type,
+            containers: composeContainers.length > 0 ? composeContainers : [serviceName],
+            dependsOnDatabases: parsed.dependsOnDatabases,
+            registeredAt: new Date().toISOString(),
+        };
+        const existing = reg.apps.findIndex(a => a.name === serviceName);
+        if (existing >= 0) {
+            const prev = reg.apps[existing];
+            if (prev.healthPath)
+                app.healthPath = prev.healthPath;
+            if (prev.gitRepo)
+                app.gitRepo = prev.gitRepo;
+            if (prev.gitRemoteUrl)
+                app.gitRemoteUrl = prev.gitRemoteUrl;
+            if (prev.gitOnboardedAt)
+                app.gitOnboardedAt = prev.gitOnboardedAt;
+            if (prev.secretsManaged)
+                app.secretsManaged = prev.secretsManaged;
+            reg.apps[existing] = app;
+        }
+        else {
+            reg.apps.push(app);
+        }
+        added++;
+        success(`${serviceName} (${composePath})`);
+    }
+    save(reg);
+    if (json) {
+        process.stdout.write(JSON.stringify(reg, null, 2) + '\n');
+    }
+    else {
+        info(`Registered ${added} apps`);
+        success('Init complete');
+    }
+}
+function detectPort(composePath, composeFile, composeContainers, allContainers) {
+    const file = composeFile ?? 'docker-compose.yml';
+    const fullPath = `${composePath}/${file}`;
+    if (existsSync(fullPath)) {
+        const content = readFileSync(fullPath, 'utf-8');
+        const portsRe = new RegExp('ports:\\s*\\n\\s*-\\s*"?(\\d+)' + ':(\\d+)"?');
+        const portMatch = content.match(portsRe);
+        if (portMatch) {
+            return parseInt(portMatch[1], 10);
+        }
+        const localhostMatch = content.match(/127\.0\.0\.1:(\d+):/);
+        if (localhostMatch) {
+            return parseInt(localhostMatch[1], 10);
+        }
+    }
+    for (const name of composeContainers) {
+        const ct = allContainers.find(c => c.name === name);
+        if (ct?.ports) {
+            const portMatch = ct.ports.match(/(?:0\.0\.0\.0|127\.0\.0\.1):(\d+)->/);
+            if (portMatch)
+                return parseInt(portMatch[1], 10);
+        }
+    }
+    return null;
+}
+function detectDomains(serviceName, sites, port) {
+    for (const site of sites) {
+        const config = readConfig(site.domain);
+        if (!config)
+            continue;
+        if (port) {
+            const configPort = extractPortFromConfig(config);
+            if (configPort === port) {
+                return extractDomainsFromConfig(config);
+            }
+        }
+        if (config.toLowerCase().includes(serviceName)) {
+            return extractDomainsFromConfig(config);
+        }
+    }
+    return [];
+}
+function detectSharedDb(composePath, composeFile) {
+    const file = composeFile ?? 'docker-compose.yml';
+    const fullPath = `${composePath}/${file}`;
+    if (!existsSync(fullPath))
+        return false;
+    const content = readFileSync(fullPath, 'utf-8');
+    return content.includes('databases') && content.includes('external: true');
+}
+function detectType(composePath, composeFile, domains) {
+    const file = composeFile ?? 'docker-compose.yml';
+    const fullPath = `${composePath}/${file}`;
+    if (existsSync(fullPath)) {
+        const content = readFileSync(fullPath, 'utf-8');
+        if (content.includes('next') || content.includes('Next'))
+            return 'nextjs';
+    }
+    if (domains.length > 0) {
+        for (const domain of domains) {
+            const config = readConfig(domain);
+            if (!config)
+                continue;
+            if (config.includes('try_files') && config.includes('index.html'))
+                return 'spa';
+            if (config.includes('_next/'))
+                return 'nextjs';
+        }
+        return 'proxy';
+    }
+    return 'service';
+}
+function detectDisplayName(serviceName, serviceContent) {
+    const descMatch = serviceContent.match(/Description=(.+?)(?:\s+Docker| Service| Container)/);
+    if (descMatch)
+        return descMatch[1].trim();
+    return serviceName;
+}

package/dist/commands/install-mcp.d.ts

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

package/dist/commands/install-mcp.js

@@ -0,0 +1,55 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { success, info, warn } from '../ui/output.js';
+const FLEET_DIST = resolve(join(import.meta.dirname, '..', '..', 'dist', 'index.js'));
+function getClaudeConfigPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || '/root';
+    return join(home, '.claude.json');
+}
+function loadConfig(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export async function installMcpCommand(args) {
+    const uninstall = args.includes('--uninstall');
+    const configPath = getClaudeConfigPath();
+    const config = loadConfig(configPath);
+    if (uninstall) {
+        if (config.mcpServers?.fleet) {
+            delete config.mcpServers.fleet;
+            if (Object.keys(config.mcpServers).length === 0) {
+                delete config.mcpServers;
+            }
+            writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+            success('Removed fleet MCP server from Claude Code');
+        }
+        else {
+            info('fleet MCP server not configured — nothing to remove');
+        }
+        return;
+    }
+    if (!existsSync(FLEET_DIST)) {
+        warn('dist/index.js not found — run "npm run build" first');
+    }
+    config.mcpServers = config.mcpServers || {};
+    const existed = !!config.mcpServers.fleet;
+    config.mcpServers.fleet = {
+        command: 'node',
+        args: [FLEET_DIST, 'mcp'],
+    };
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    if (existed) {
+        success('Updated fleet MCP server in Claude Code');
+    }
+    else {
+        success('Installed fleet MCP server to Claude Code');
+    }
+    info(`Config: ${configPath}`);
+    info(`Server: node ${FLEET_DIST} mcp`);
+}

package/dist/commands/list.d.ts

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

package/dist/commands/list.js

@@ -0,0 +1,20 @@
+import { load } from '../core/registry.js';
+import { c, heading, table } from '../ui/output.js';
+export function listCommand(args) {
+    const json = args.includes('--json');
+    const reg = load();
+    if (json) {
+        process.stdout.write(JSON.stringify(reg.apps, null, 2) + '\n');
+        return;
+    }
+    heading(`Registered Apps (${reg.apps.length})`);
+    const rows = reg.apps.map(app => [
+        `${c.bold}${app.name}${c.reset}`,
+        app.serviceName,
+        app.port?.toString() ?? '-',
+        app.type,
+        app.domains.join(', ') || '-',
+    ]);
+    table(['NAME', 'SERVICE', 'PORT', 'TYPE', 'DOMAINS'], rows);
+    process.stdout.write('\n');
+}

package/dist/commands/logs.d.ts

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

package/dist/commands/logs.js

@@ -0,0 +1,32 @@
+import { load, findApp } from '../core/registry.js';
+import { getContainerLogs } from '../core/docker.js';
+import { execLive } from '../core/exec.js';
+import { AppNotFoundError } from '../core/errors.js';
+import { error } from '../ui/output.js';
+export function logsCommand(args) {
+    const follow = args.includes('-f') || args.includes('--follow');
+    const nIdx = args.indexOf('-n');
+    const lines = nIdx >= 0 ? parseInt(args[nIdx + 1], 10) || 100 : 100;
+    const appName = args.find(a => !a.startsWith('-') && (nIdx < 0 || args.indexOf(a) !== nIdx + 1));
+    if (!appName) {
+        error('Usage: fleet logs <app> [-f] [-n <lines>]');
+        process.exit(1);
+    }
+    const reg = load();
+    const app = findApp(reg, appName);
+    if (!app)
+        throw new AppNotFoundError(appName);
+    const container = app.containers[0];
+    if (!container) {
+        error(`No containers registered for ${app.name}`);
+        process.exit(1);
+    }
+    if (follow) {
+        const code = execLive('docker', ['logs', '-f', '--tail', lines.toString(), container]);
+        process.exit(code);
+    }
+    else {
+        const output = getContainerLogs(container, lines);
+        process.stdout.write(output + '\n');
+    }
+}

package/dist/commands/nginx.d.ts

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