@flui-cloud/cli 0.0.1

package/lib/cli/src/commands/node/remove.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_node_service_1 = require("../../lib/services/cli-node.service");
+const resolve_cluster_1 = require("../../lib/resolve-cluster");
+const POLL_INTERVAL_MS = 4000;
+const MAX_WAIT_MS = 300_000; // 5 min
+class NodeRemove extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(NodeRemove);
+        const spinner = (0, ora_1.default)(`Queuing remove-worker for node ${args.nodeId}...`).start();
+        let service;
+        let clusterEntity;
+        try {
+            const resolved = await (0, resolve_cluster_1.resolveCluster)(flags.cluster);
+            clusterEntity = resolved.entity;
+            service = await cli_node_service_1.CliNodeService.create(resolved.id);
+        }
+        catch (error) {
+            spinner.fail('Setup failed');
+            console.log(chalk_1.default.red(`\n  Error: ${error.message}\n`));
+            this.exit(1);
+        }
+        // Pre-check: resolve node and guard against master removal
+        let nodes;
+        try {
+            nodes = await service.listNodes();
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch node list');
+            console.log(chalk_1.default.red(`\n  Error: ${error.message}\n`));
+            this.exit(1);
+        }
+        const target = nodes.find((n) => n.id === args.nodeId);
+        if (!target) {
+            spinner.fail('Node not found');
+            console.log(chalk_1.default.red(`\n  Node "${args.nodeId}" not found in this cluster.\n`));
+            console.log(chalk_1.default.dim('  Run `flui node list` to see available node IDs.\n'));
+            this.exit(1);
+        }
+        if (target.nodeType === 'master') {
+            this.refuseMasterRemoval(spinner, target, nodes, clusterEntity, flags.cluster);
+        }
+        let result;
+        try {
+            result = await service.removeWorker(args.nodeId);
+        }
+        catch (error) {
+            spinner.fail('Failed to queue operation');
+            const msg = error.response?.data?.message ?? error.message;
+            console.log(chalk_1.default.red(`\n  Error: ${msg}\n`));
+            this.exit(1);
+        }
+        spinner.succeed('Remove operation queued');
+        console.log('');
+        console.log(`  ${chalk_1.default.bold('Operation ID:')} ${result.operation_id}`);
+        console.log(`  ${chalk_1.default.bold('Estimated:')}    ${result.estimated_duration}`);
+        console.log('');
+        if (flags['no-wait']) {
+            console.log(chalk_1.default.dim('  Use `flui node list` to check when the node is gone.\n'));
+            return;
+        }
+        await this.waitForRemoval(service, result.operation_id);
+    }
+    refuseMasterRemoval(spinner, target, nodes, clusterEntity, clusterFlag) {
+        spinner.fail('Cannot remove the master node');
+        const workers = nodes.filter((n) => n.nodeType === 'worker');
+        const isObservability = clusterEntity.metadata?.isObservabilityCluster === true;
+        console.log('');
+        console.log(chalk_1.default.yellow(`  "${target.serverName}" is the master node of cluster "${clusterEntity.name}".`));
+        if (workers.length > 0) {
+            console.log(chalk_1.default.yellow(`  There ${workers.length === 1 ? 'is' : 'are'} still ${workers.length} worker node(s) running.`));
+            console.log('');
+            console.log(chalk_1.default.dim('  To scale down, remove the workers first:'));
+            const clusterSuffix = clusterFlag ? ` --cluster ${clusterFlag}` : '';
+            for (const w of workers) {
+                console.log(chalk_1.default.dim(`    flui node remove ${w.id}${clusterSuffix}`));
+            }
+        }
+        console.log('');
+        console.log(chalk_1.default.dim('  To destroy the entire cluster (master + all workers):'));
+        console.log(isObservability
+            ? chalk_1.default.cyan('    flui env destroy')
+            : chalk_1.default.cyan(`    flui cluster destroy ${clusterEntity.name}`));
+        console.log('');
+        this.exit(1);
+    }
+    async waitForRemoval(service, operationId) {
+        console.log(chalk_1.default.dim(`  Draining and deleting node… (up to ${MAX_WAIT_MS / 60000} min)`));
+        console.log('');
+        const waitSpinner = (0, ora_1.default)('Draining node…').start();
+        const started = Date.now();
+        while (Date.now() - started < MAX_WAIT_MS) {
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+            const done = await this.pollNodeRemoval(service, operationId, waitSpinner);
+            if (done)
+                return;
+        }
+        waitSpinner.warn('Timed out waiting for operation');
+        console.log(chalk_1.default.yellow(`\n  Operation ${operationId} is still running.`));
+        console.log(chalk_1.default.dim('  Run `flui node list` to check status when it completes.\n'));
+    }
+    async pollNodeRemoval(service, operationId, waitSpinner) {
+        try {
+            const op = await service.getOperationStatus(operationId);
+            const pct = op.totalSteps > 0
+                ? Math.round((op.currentStepIndex / op.totalSteps) * 100)
+                : 0;
+            waitSpinner.text = `Draining and deleting… ${pct}% (step ${op.currentStepIndex}/${op.totalSteps})`;
+            if (op.status === 'COMPLETED') {
+                const warned = op.metadata?.warnings?.some((w) => w.code === 'DRAIN_FAILED');
+                if (warned) {
+                    waitSpinner.warn(chalk_1.default.yellow('Node removed (drain failed — PDB may have blocked eviction)'));
+                }
+                else {
+                    waitSpinner.succeed(chalk_1.default.green('Node removed successfully'));
+                }
+                console.log('');
+                console.log(chalk_1.default.dim('  Run `flui node list` to see the updated node list.\n'));
+                return true;
+            }
+            if (op.status === 'FAILED') {
+                waitSpinner.fail('Operation failed');
+                const errorMsg = op.metadata?.error ?? 'Unknown error';
+                console.log(chalk_1.default.red(`\n  Error: ${errorMsg}\n`));
+                this.exit(1);
+            }
+        }
+        catch {
+            /* polling error — keep trying */
+        }
+        return false;
+    }
+}
+NodeRemove.description = 'Cordon, drain and remove a worker node from the cluster. Cannot remove the master.';
+NodeRemove.examples = [
+    '<%= config.bin %> <%= command.id %> <node-id>',
+    '<%= config.bin %> <%= command.id %> <node-id> --no-wait',
+];
+NodeRemove.args = {
+    nodeId: core_1.Args.string({
+        description: 'Node ID to remove (from `flui node list`)',
+        required: true,
+    }),
+};
+NodeRemove.flags = {
+    cluster: core_1.Flags.string({
+        char: 'c',
+        description: 'Cluster name or ID (default: auto-detect when only one cluster exists)',
+    }),
+    'no-wait': core_1.Flags.boolean({
+        description: 'Return immediately after queuing the operation',
+        default: false,
+    }),
+};
+exports.default = NodeRemove;

package/lib/cli/src/commands/reconcile.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class Reconcile extends Command {
+    static readonly description = "Reconcile CLI state with API (DNS configuration)";
+    static readonly examples: string[];
+    static readonly flags: {
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        'api-url': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Display reconciliation results
+     */
+    private displayResults;
+    /**
+     * Format reconciliation type label
+     */
+    private formatTypeLabel;
+}

package/lib/cli/src/commands/reconcile.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const reconciliation_service_1 = require("../lib/services/reconciliation.service");
+const config_storage_1 = require("../lib/config-storage");
+const nip_base_domain_util_1 = require("../lib/nip-base-domain.util");
+const cli_cluster_repository_1 = require("../lib/repositories/cli-cluster.repository");
+class Reconcile extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Reconcile);
+        let spinner = (0, ora_1.default)('Initializing reconciliation...').start();
+        try {
+            const configStorage = new config_storage_1.ConfigStorage();
+            let apiUrl = flags['api-url'] || configStorage.getApiUrl();
+            if (!flags['api-url'] && !apiUrl) {
+                const clusterRepo = new cli_cluster_repository_1.CliClusterRepository();
+                const cluster = await clusterRepo.findOne({
+                    where: { metadata: { isObservabilityCluster: true } },
+                });
+                if (cluster?.masterIpAddress) {
+                    const base = (0, nip_base_domain_util_1.buildNipBaseDomain)(cluster.masterIpAddress, cluster.nipHostnameToken);
+                    apiUrl = `https://api.${base}/api/v1`;
+                    configStorage.saveApiUrl(apiUrl);
+                    spinner.text = `Auto-detected API URL: ${apiUrl}`;
+                }
+            }
+            if (!apiUrl) {
+                spinner.fail('API URL is not configured for this context');
+                console.log(chalk_1.default.yellow('\nRun `flui env create` to provision a cluster, or set it manually:\n  flui config set api-url https://api.example.com/api/v1\n'));
+                this.exit(1);
+            }
+            spinner.text = 'Connecting to API...';
+            // Parse reconciliation types
+            const types = flags.type.map((t) => t.toLowerCase());
+            // Dry run mode
+            if (flags['dry-run']) {
+                spinner.succeed('Connected to API');
+                console.log(chalk_1.default.cyan('\n🔍 Dry Run Mode - No changes will be made\n'));
+                console.log(chalk_1.default.dim(`   API URL: ${apiUrl}`));
+                console.log(chalk_1.default.dim(`   Types: ${types.includes(reconciliation_service_1.ReconciliationType.ALL) ? 'all (dns)' : types.join(', ')}`));
+                console.log('');
+            }
+            spinner.text = 'Starting reconciliation...';
+            // Execute reconciliation
+            const reconciliationService = new reconciliation_service_1.ReconciliationService(apiUrl);
+            const { results, allSuccess } = await reconciliationService.reconcile({
+                types,
+                dryRun: flags['dry-run'],
+                apiUrl,
+            });
+            spinner.stop();
+            // Save reconciliation state to cluster metadata (skip for dry-run)
+            if (!flags['dry-run']) {
+                try {
+                    const clusterRepo = new cli_cluster_repository_1.CliClusterRepository();
+                    const cluster = await clusterRepo.findOne({
+                        where: { metadata: { isObservabilityCluster: true } },
+                    });
+                    if (cluster) {
+                        cluster.metadata = {
+                            ...cluster.metadata,
+                            reconciliation: {
+                                status: allSuccess ? 'completed' : 'partial',
+                                completedAt: new Date().toISOString(),
+                                results: results.map((r) => ({
+                                    type: r.type,
+                                    success: r.success,
+                                    message: r.message,
+                                })),
+                            },
+                        };
+                        await clusterRepo.save(cluster);
+                    }
+                }
+                catch {
+                    // Ignore metadata save errors
+                }
+            }
+            // Display results
+            this.displayResults(results, flags['dry-run']);
+            // Exit with appropriate code
+            if (allSuccess) {
+                console.log(chalk_1.default.green(`\n✓ All reconciliations ${flags['dry-run'] ? 'would complete' : 'completed'} successfully!\n`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`\n⚠ Some reconciliations ${flags['dry-run'] ? 'would fail' : 'failed'}. See details above.\n`));
+                this.exit(1);
+            }
+        }
+        catch (error) {
+            spinner.fail('Reconciliation failed');
+            console.log(chalk_1.default.red(`\n✗ Error: ${error.message}\n`));
+            if (error.stack) {
+                console.log(chalk_1.default.dim(error.stack));
+            }
+            this.exit(1);
+        }
+    }
+    /**
+     * Display reconciliation results
+     */
+    displayResults(results, dryRun) {
+        console.log(chalk_1.default.bold(`\n${dryRun ? '🔍 Reconciliation Preview' : '📊 Reconciliation Results'}`));
+        console.log(chalk_1.default.dim('─'.repeat(60)));
+        for (const result of results) {
+            const icon = result.success ? '✓' : '✗';
+            const color = result.success ? chalk_1.default.green : chalk_1.default.red;
+            const typeLabel = this.formatTypeLabel(result.type);
+            console.log(color(`\n${icon} ${typeLabel}`));
+            console.log(chalk_1.default.dim(`   ${result.message}`));
+            if (result.details) {
+                console.log(chalk_1.default.dim('   Details:'));
+                if (Array.isArray(result.details)) {
+                    for (const detail of result.details) {
+                        const detailIcon = detail.success ? '  ✓' : '  ✗';
+                        const detailColor = detail.success ? chalk_1.default.green : chalk_1.default.yellow;
+                        console.log(detailColor(`   ${detailIcon} ${detail.message}`));
+                    }
+                }
+                else {
+                    for (const [key, value] of Object.entries(result.details)) {
+                        console.log(chalk_1.default.dim(`     ${key}: ${value}`));
+                    }
+                }
+            }
+            if (result.error && !result.success) {
+                console.log(chalk_1.default.red(`   Error: ${result.error}`));
+            }
+        }
+        console.log(chalk_1.default.dim('\n' + '─'.repeat(60)));
+    }
+    /**
+     * Format reconciliation type label
+     */
+    formatTypeLabel(type) {
+        const labels = {
+            [reconciliation_service_1.ReconciliationType.DNS]: 'DNS Configuration',
+            [reconciliation_service_1.ReconciliationType.ALL]: 'All Resources',
+        };
+        return labels[type] || type;
+    }
+}
+Reconcile.description = 'Reconcile CLI state with API (DNS configuration)';
+Reconcile.examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --type dns',
+    '<%= config.bin %> <%= command.id %> --dry-run',
+];
+Reconcile.flags = {
+    type: core_1.Flags.string({
+        char: 't',
+        description: 'Reconciliation type(s) to execute (default: all)',
+        options: ['dns', 'all'],
+        multiple: true,
+        default: ['all'],
+    }),
+    'api-url': core_1.Flags.string({
+        description: 'Flui API URL (default: from config or http://localhost:3000/api/v1)',
+        required: false,
+    }),
+    'dry-run': core_1.Flags.boolean({
+        description: 'Show what would be reconciled without making changes',
+        default: false,
+    }),
+};
+exports.default = Reconcile;

package/lib/cli/src/commands/repo/connect.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class RepoConnect extends Command {
+    static readonly description: string;
+    static readonly examples: string[];
+    static readonly args: {
+        repo: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private handleImportResult;
+    private printImportError;
+    private pickInteractively;
+}

package/lib/cli/src/commands/repo/connect.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_client_1 = require("../../lib/api-client");
+const config_storage_1 = require("../../lib/config-storage");
+const prompts_1 = require("../../lib/prompts");
+function formatErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+class RepoConnect extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(RepoConnect);
+        const configStorage = new config_storage_1.ConfigStorage();
+        const apiUrl = configStorage.getApiUrlOrThrow();
+        const apiKey = configStorage.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run `flui auth login` first.', { exit: 1 });
+        }
+        const api = new api_client_1.ApiClient({ baseUrl: apiUrl, apiKey });
+        const target = args.repo ?? (await this.pickInteractively(api));
+        if (!target) {
+            console.log(chalk_1.default.dim('\n  Cancelled.\n'));
+            return;
+        }
+        if (!/^[^/]+\/[^/]+$/.test(target)) {
+            this.error(`Invalid repository name "${target}". Expected format: owner/repo`, { exit: 1 });
+        }
+        const spinner = (0, ora_1.default)(`Connecting ${chalk_1.default.bold(target)}…`).start();
+        try {
+            const result = await api.post('/repositories/import', {
+                repositoryIds: [target],
+            });
+            this.handleImportResult(spinner, target, result);
+        }
+        catch (error) {
+            spinner.fail('Failed to connect repository');
+            this.printImportError(error);
+            this.exit(1);
+        }
+    }
+    handleImportResult(spinner, target, result) {
+        const errors = result?.errors ?? [];
+        const skipped = result?.skipped ?? 0;
+        const imported = result?.imported ?? 0;
+        if (errors.length > 0) {
+            spinner.fail(`Could not connect ${target}`);
+            for (const err of errors) {
+                console.log(chalk_1.default.red(`  ${err}`));
+            }
+            console.log(chalk_1.default.dim('\n  If the repository is private or was just created, the GitHub App may not yet ' +
+                'have access to it. Add it on github.com/settings/installations and retry.\n'));
+            this.exit(1);
+        }
+        if (skipped > 0 && imported === 0) {
+            spinner.succeed(`${target} was already connected`);
+        }
+        else {
+            spinner.succeed(`Connected ${target}`);
+        }
+    }
+    printImportError(error) {
+        if (error instanceof api_client_1.ApiError && error.statusCode === 404) {
+            console.log(chalk_1.default.yellow('\n  No active GitHub connection. Run `flui integration connect github` first.\n'));
+            return;
+        }
+        const msg = formatErrorMessage(error);
+        console.log(chalk_1.default.red(`  ${msg}`));
+        if (msg.includes('Cannot read properties')) {
+            console.log(chalk_1.default.dim('\n  Unexpected API response shape. Run `flui repo list` to check whether the ' +
+                'repository was actually imported despite the error.\n'));
+        }
+    }
+    async pickInteractively(api) {
+        if (!process.stdin.isTTY) {
+            this.error('Repository name is required in non-interactive mode. ' +
+                'Pass it as an argument: `flui repo connect <owner/repo>`.', { exit: 1 });
+        }
+        const spinner = (0, ora_1.default)('Fetching repositories from GitHub…').start();
+        let available;
+        try {
+            available = await api.get('/repositories/available');
+            spinner.stop();
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch repositories');
+            if (error instanceof api_client_1.ApiError && error.statusCode === 404) {
+                console.log(chalk_1.default.yellow('\n  No active GitHub connection. Run `flui integration connect github` first.\n'));
+            }
+            else {
+                console.log(chalk_1.default.red(`  ${error.message}`));
+            }
+            this.exit(1);
+        }
+        if (available.length === 0) {
+            console.log(chalk_1.default.dim('\n  No repositories available to connect (all are already connected, ' +
+                'or the GitHub App has no repos selected on its installation).\n'));
+            return undefined;
+        }
+        const choice = await (0, prompts_1.selectWithArrows)(`Select a repository to connect:`, available.map((r) => ({
+            label: `${r.fullName}${r.description ? chalk_1.default.dim(' — ' + r.description.slice(0, 60)) : ''}`,
+        })));
+        if (choice === -1)
+            return undefined;
+        return available[choice].fullName;
+    }
+}
+RepoConnect.description = 'Connect (import) a GitHub repository into your Flui account so it can be deployed with `flui deploy`. ' +
+    'Pass the full name `owner/repo`, or omit it for an interactive picker over the repositories accessible via your GitHub integration.';
+RepoConnect.examples = [
+    '<%= config.bin %> <%= command.id %> acme/my-app',
+    '<%= config.bin %> <%= command.id %>',
+];
+RepoConnect.args = {
+    repo: core_1.Args.string({
+        description: 'Full repository name `owner/repo`. Omit to pick interactively.',
+        required: false,
+    }),
+};
+exports.default = RepoConnect;

package/lib/cli/src/commands/repo/disconnect.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class RepoDisconnect extends Command {
+    static readonly description = "Disconnect a repository from your Flui account. Requires admin privileges. Does not delete the repository on GitHub.";
+    static readonly examples: string[];
+    static readonly args: {
+        repo: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static readonly flags: {
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/cli/src/commands/repo/disconnect.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_client_1 = require("../../lib/api-client");
+const config_storage_1 = require("../../lib/config-storage");
+const prompts_1 = require("../../lib/prompts");
+class RepoDisconnect extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(RepoDisconnect);
+        const configStorage = new config_storage_1.ConfigStorage();
+        const apiUrl = configStorage.getApiUrlOrThrow();
+        const apiKey = configStorage.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run `flui auth login` first.', { exit: 1 });
+        }
+        const api = new api_client_1.ApiClient({ baseUrl: apiUrl, apiKey });
+        const all = await api
+            .get('/repositories')
+            .catch((err) => {
+            this.error(`Failed to look up repositories: ${err.message}`, { exit: 1 });
+        });
+        const match = all?.find((r) => r.repositoryFullName === args.repo);
+        if (!match) {
+            this.error(`Repository "${args.repo}" is not connected. Run \`flui repo list\` to see what is.`, { exit: 1 });
+        }
+        if (!flags.yes) {
+            const ok = await (0, prompts_1.confirmPrompt)(`Disconnect ${chalk_1.default.bold(args.repo)} from Flui?`, false);
+            if (!ok) {
+                console.log(chalk_1.default.dim('\n  Cancelled.\n'));
+                return;
+            }
+        }
+        const spinner = (0, ora_1.default)(`Disconnecting ${args.repo}…`).start();
+        try {
+            await api.delete(`/repositories/${match.id}`);
+            spinner.succeed(`Disconnected ${args.repo}`);
+        }
+        catch (error) {
+            spinner.fail('Failed to disconnect repository');
+            if (error instanceof api_client_1.ApiError && error.statusCode === 403) {
+                console.log(chalk_1.default.yellow('  Admin privileges required for this operation.'));
+            }
+            else {
+                console.log(chalk_1.default.red(`  ${error.message}`));
+            }
+            this.exit(1);
+        }
+    }
+}
+RepoDisconnect.description = 'Disconnect a repository from your Flui account. Requires admin privileges. Does not delete the repository on GitHub.';
+RepoDisconnect.examples = [
+    '<%= config.bin %> <%= command.id %> acme/my-app',
+    '<%= config.bin %> <%= command.id %> acme/my-app --yes',
+];
+RepoDisconnect.args = {
+    repo: core_1.Args.string({
+        description: 'Full repository name `owner/repo`',
+        required: true,
+    }),
+};
+RepoDisconnect.flags = {
+    yes: core_1.Flags.boolean({
+        char: 'y',
+        description: 'Skip the confirmation prompt',
+        default: false,
+    }),
+};
+exports.default = RepoDisconnect;

package/lib/cli/src/commands/repo/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class RepoList extends Command {
+    static readonly description = "List repositories connected to your Flui account.";
+    static readonly examples: string[];
+    static readonly flags: {
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/cli/src/commands/repo/list.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const api_client_1 = require("../../lib/api-client");
+const config_storage_1 = require("../../lib/config-storage");
+class RepoList extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(RepoList);
+        const configStorage = new config_storage_1.ConfigStorage();
+        const apiUrl = configStorage.getApiUrlOrThrow();
+        const apiKey = configStorage.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run `flui auth login` first.', { exit: 1 });
+        }
+        const api = new api_client_1.ApiClient({ baseUrl: apiUrl, apiKey });
+        let repos;
+        try {
+            repos = await api.get('/repositories');
+        }
+        catch (error) {
+            this.error(`Failed to list repositories: ${error.message}`, {
+                exit: 1,
+            });
+        }
+        if (flags.output === 'json') {
+            console.log(JSON.stringify(repos, null, 2));
+            return;
+        }
+        if (repos.length === 0) {
+            console.log(chalk_1.default.dim('\n  No repositories connected.'));
+            console.log(chalk_1.default.dim('  Connect one with `flui repo connect <owner/repo>` ' +
+                '(or `flui integration connect github` first if GitHub is not yet connected).\n'));
+            return;
+        }
+        const refW = Math.max(...repos.map((r) => r.repositoryFullName.length), 4);
+        const langW = Math.max(...repos.map((r) => (r.language ?? '-').length), 4);
+        console.log('');
+        console.log(`  ${chalk_1.default.bold('REPOSITORY'.padEnd(refW))}  ${chalk_1.default.bold('BRANCH'.padEnd(8))}  ${chalk_1.default.bold('LANG'.padEnd(langW))}  ${chalk_1.default.bold('AUTO-DEPLOY')}`);
+        console.log(`  ${'─'.repeat(refW)}  ${'─'.repeat(8)}  ${'─'.repeat(langW)}  ${'─'.repeat(11)}`);
+        for (const r of repos) {
+            const autoDeploy = r.autoDeployEnabled
+                ? chalk_1.default.green('on')
+                : chalk_1.default.dim('off');
+            console.log(`  ${r.repositoryFullName.padEnd(refW)}  ${r.defaultBranch.padEnd(8)}  ${(r.language ?? '-').padEnd(langW)}  ${autoDeploy}`);
+        }
+        console.log('');
+    }
+}
+RepoList.description = 'List repositories connected to your Flui account.';
+RepoList.examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --output json',
+];
+RepoList.flags = {
+    output: core_1.Flags.string({
+        char: 'o',
+        description: 'Output format',
+        options: ['text', 'json'],
+        default: 'text',
+    }),
+};
+exports.default = RepoList;