@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/dist/connection.js

@@ -0,0 +1,258 @@
+import { DEFAULT_METABASE_CLIENT_CONFIG, DefaultLookerConnectionClientFactory, DefaultMetabaseConnectionClientFactory, NotionClient, createLocalLookerCredentialResolver, metabaseRuntimeConfigFromLocalConnection, testRepoConnection, } from '@ktx/context/ingest';
+import { parseNotionConnectionConfig, resolveNotionConnectionAuthToken } from '@ktx/context/connections';
+import { resolveKtxConfigReference } from '@ktx/context/core';
+import { loadKtxProject } from '@ktx/context/project';
+import { bold, dim, green, red, SYMBOLS } from './io/symbols.js';
+import { createKtxCliScanConnector } from './local-scan-connectors.js';
+import { profileMark } from './startup-profile.js';
+profileMark('module:connection');
+const SUPPORTED_TEST_DRIVERS = [
+    'sqlite',
+    'postgres',
+    'mysql',
+    'clickhouse',
+    'sqlserver',
+    'bigquery',
+    'snowflake',
+    'metabase',
+    'looker',
+    'notion',
+    'dbt',
+    'metricflow',
+    'lookml',
+];
+function normalizedConnectionDriver(project, connectionId) {
+    return String(project.config.connections[connectionId]?.driver ?? '')
+        .trim()
+        .toLowerCase();
+}
+async function testNativeConnection(project, connectionId, createScanConnector) {
+    let connector = null;
+    try {
+        connector = await createScanConnector(project, connectionId);
+        if (!connector.testConnection) {
+            throw new Error(`Connector for "${connectionId}" does not implement testConnection`);
+        }
+        const result = await connector.testConnection();
+        if (!result.success) {
+            throw new Error(result.error ?? 'connection test failed');
+        }
+        return { driver: connector.driver };
+    }
+    finally {
+        if (connector?.cleanup) {
+            await connector.cleanup();
+        }
+    }
+}
+async function createDefaultMetabaseClient(project, connectionId) {
+    const factory = new DefaultMetabaseConnectionClientFactory((metabaseConnectionId) => metabaseRuntimeConfigFromLocalConnection(metabaseConnectionId, project.config.connections[metabaseConnectionId]), DEFAULT_METABASE_CLIENT_CONFIG);
+    return factory.createClient(connectionId);
+}
+async function testMetabaseConnection(project, connectionId, createClient) {
+    let client = null;
+    try {
+        client = await createClient(project, connectionId);
+        const testResult = await client.testConnection();
+        if (!testResult.success) {
+            throw new Error(`Metabase connection test failed: ${testResult.error ?? testResult.message ?? 'unknown error'}`);
+        }
+        const databases = await client.getDatabases();
+        const databaseCount = databases.filter((database) => database.is_sample !== true).length;
+        if (databaseCount === 0) {
+            throw new Error('Metabase auth worked but no usable databases were returned');
+        }
+        return { databaseCount };
+    }
+    finally {
+        await client?.cleanup();
+    }
+}
+async function createDefaultLookerClient(project, connectionId) {
+    const factory = new DefaultLookerConnectionClientFactory(createLocalLookerCredentialResolver(project));
+    return (await factory.createClient(connectionId));
+}
+async function testLookerConnection(project, connectionId, createClient) {
+    const client = await createClient(project, connectionId);
+    const result = await client.testConnection();
+    if (!result.success) {
+        throw new Error(`Looker connection test failed: ${result.error ?? 'unknown error'}`);
+    }
+    const metadata = (result.metadata ?? {});
+    const user = (metadata.displayName ?? metadata.userId ?? 'unknown').trim() || 'unknown';
+    return { user };
+}
+async function createDefaultNotionClient(project, connectionId) {
+    const connection = project.config.connections[connectionId];
+    if (!connection) {
+        throw new Error(`Connection "${connectionId}" is not configured in ktx.yaml`);
+    }
+    const parsed = parseNotionConnectionConfig(connection);
+    const token = await resolveNotionConnectionAuthToken(parsed);
+    return new NotionClient(token);
+}
+function describeNotionBot(bot) {
+    const name = typeof bot.name === 'string' ? bot.name.trim() : '';
+    if (name)
+        return name;
+    const id = typeof bot.id === 'string' ? bot.id.trim() : '';
+    return id || 'unknown';
+}
+async function testNotionConnection(project, connectionId, createClient) {
+    const client = await createClient(project, connectionId);
+    const bot = await client.retrieveBotUser();
+    return { bot: describeNotionBot(bot) };
+}
+function extractGitConnectionFields(project, connectionId, driver) {
+    const connection = project.config.connections[connectionId];
+    if (!connection) {
+        throw new Error(`Connection "${connectionId}" is not configured in ktx.yaml`);
+    }
+    const stringField = (value) => typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+    const record = driver === 'metricflow' && typeof connection.metricflow === 'object' && connection.metricflow !== null
+        ? connection.metricflow
+        : connection;
+    const repoUrl = driver === 'dbt' ? stringField(record.repo_url) : stringField(record.repoUrl);
+    if (!repoUrl) {
+        const field = driver === 'dbt' ? 'repo_url' : 'repoUrl';
+        throw new Error(`Connection "${connectionId}" (driver: ${driver}) is missing ${field}`);
+    }
+    const literalToken = stringField(record.auth_token);
+    const ref = stringField(record.auth_token_ref);
+    const resolvedRef = ref ? resolveKtxConfigReference(ref, process.env) : null;
+    return { repoUrl, authToken: literalToken ?? resolvedRef ?? null };
+}
+async function testGitRepoConnection(project, connectionId, driver, runTest) {
+    const { repoUrl, authToken } = extractGitConnectionFields(project, connectionId, driver);
+    const result = await runTest({ repoUrl, authToken });
+    if (!result.ok) {
+        throw new Error(`${driver} repository check failed: ${result.error}`);
+    }
+    return { repoUrl };
+}
+async function testConnectionByDriver(project, connectionId, deps) {
+    const driver = normalizedConnectionDriver(project, connectionId);
+    if (!driver) {
+        throw new Error(`Connection "${connectionId}" has no \`driver\` field in ktx.yaml`);
+    }
+    if (driver === 'metabase') {
+        const result = await testMetabaseConnection(project, connectionId, deps.createMetabaseClient ?? createDefaultMetabaseClient);
+        return { driver, detailKey: 'Databases', detailValue: String(result.databaseCount) };
+    }
+    if (driver === 'looker') {
+        const result = await testLookerConnection(project, connectionId, deps.createLookerClient ?? createDefaultLookerClient);
+        return { driver, detailKey: 'User', detailValue: result.user };
+    }
+    if (driver === 'notion') {
+        const result = await testNotionConnection(project, connectionId, deps.createNotionClient ?? createDefaultNotionClient);
+        return { driver, detailKey: 'Bot', detailValue: result.bot };
+    }
+    if (driver === 'dbt' || driver === 'metricflow' || driver === 'lookml') {
+        const result = await testGitRepoConnection(project, connectionId, driver, deps.testRepoConnection ?? testRepoConnection);
+        return { driver, detailKey: 'Repo', detailValue: result.repoUrl };
+    }
+    if (driver === 'sqlite' ||
+        driver === 'sqlite3' ||
+        driver === 'postgres' ||
+        driver === 'postgresql' ||
+        driver === 'mysql' ||
+        driver === 'clickhouse' ||
+        driver === 'sqlserver' ||
+        driver === 'bigquery' ||
+        driver === 'snowflake') {
+        const result = await testNativeConnection(project, connectionId, deps.createScanConnector ?? createKtxCliScanConnector);
+        return { driver: result.driver, detailKey: 'Status', detailValue: 'ok' };
+    }
+    throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no test implementation in ktx. Supported: ${SUPPORTED_TEST_DRIVERS.join(', ')}.`);
+}
+function visualWidth(text) {
+    // styleText wraps content in ANSI escape sequences; strip them before measuring.
+    return text.replace(/\[[0-9;]*m/g, '').length;
+}
+function padVisual(text, width) {
+    const pad = width - visualWidth(text);
+    return pad > 0 ? `${text}${' '.repeat(pad)}` : text;
+}
+function renderTestAll(io, rows) {
+    io.stdout.write(`${bold('connection test --all')}\n`);
+    if (rows.length === 0) {
+        io.stdout.write(`\n  No connections configured. Run \`ktx setup\` to add one.\n\n`);
+        return;
+    }
+    io.stdout.write('\n');
+    const okLabel = green('✓ ok');
+    const failLabel = red('✗ failed');
+    const idWidth = Math.max(...rows.map((r) => r.connectionId.length));
+    const driverWidth = Math.max(...rows.map((r) => r.driver.length));
+    const statusWidth = Math.max(visualWidth(okLabel), visualWidth(failLabel));
+    for (const row of rows) {
+        const id = bold(padVisual(row.connectionId, idWidth));
+        const driver = dim(padVisual(row.driver, driverWidth));
+        const status = padVisual(row.ok ? okLabel : failLabel, statusWidth);
+        const detail = dim(row.detail);
+        io.stdout.write(`  ${id}  ${driver}  ${status}  ${detail}\n`);
+    }
+    const failed = rows.filter((r) => !r.ok).length;
+    const passed = rows.length - failed;
+    io.stdout.write('\n');
+    const summary = failed === 0
+        ? `${rows.length} tested ${dim(SYMBOLS.middot)} ${green(`${passed} passed`)}`
+        : `${rows.length} tested ${dim(SYMBOLS.middot)} ${green(`${passed} passed`)} ${dim(SYMBOLS.middot)} ${red(`${failed} failed`)}`;
+    io.stdout.write(`${summary}\n`);
+}
+async function runTestAll(project, io, deps) {
+    const entries = Object.entries(project.config.connections).sort(([a], [b]) => a.localeCompare(b));
+    const rows = await Promise.all(entries.map(async ([connectionId, connection]) => {
+        const declaredDriver = String(connection.driver ?? '').trim().toLowerCase() || 'unknown';
+        try {
+            const outcome = await testConnectionByDriver(project, connectionId, deps);
+            return {
+                connectionId,
+                driver: outcome.driver || declaredDriver,
+                ok: true,
+                detail: `${outcome.detailKey}: ${outcome.detailValue}`,
+            };
+        }
+        catch (error) {
+            return {
+                connectionId,
+                driver: declaredDriver,
+                ok: false,
+                detail: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }));
+    renderTestAll(io, rows);
+    return rows.some((row) => !row.ok) ? 1 : 0;
+}
+export async function runKtxConnection(args, io = process, deps = {}) {
+    try {
+        const project = await loadKtxProject({ projectDir: args.projectDir });
+        if (args.command === 'list') {
+            const entries = Object.entries(project.config.connections).sort(([a], [b]) => a.localeCompare(b));
+            if (entries.length === 0) {
+                io.stdout.write('No connections configured. Run `ktx setup` to add one.\n');
+                return 0;
+            }
+            const idWidth = Math.max('ID'.length, ...entries.map(([id]) => id.length));
+            const driverWidth = Math.max('DRIVER'.length, ...entries.map(([, c]) => (c.driver ?? 'unknown').length));
+            io.stdout.write(`${'ID'.padEnd(idWidth)}  ${'DRIVER'.padEnd(driverWidth)}\n`);
+            for (const [id, connection] of entries) {
+                io.stdout.write(`${id.padEnd(idWidth)}  ${(connection.driver ?? 'unknown').padEnd(driverWidth)}\n`);
+            }
+            return 0;
+        }
+        if (args.command === 'test-all') {
+            return await runTestAll(project, io, deps);
+        }
+        const { driver, detailKey, detailValue } = await testConnectionByDriver(project, args.connectionId, deps);
+        io.stdout.write(`Connection test passed: ${args.connectionId}\n`);
+        io.stdout.write(`Driver: ${driver}\n`);
+        io.stdout.write(`${detailKey}: ${detailValue}\n`);
+        return 0;
+    }
+    catch (error) {
+        io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}

package/dist/connection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/connection.test.js

@@ -0,0 +1,405 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { initKtxProject, parseKtxProjectConfig, serializeKtxProjectConfig } from '@ktx/context/project';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { runKtxConnection } from './connection.js';
+function stripAnsi(s) {
+    return s.replace(/\[[0-9;]*m/g, '');
+}
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+function nativeConnector(driver, testResult = { success: true }) {
+    const testConnection = vi.fn(async () => testResult);
+    const cleanup = vi.fn(async () => undefined);
+    const connector = {
+        id: `${driver}:warehouse`,
+        driver,
+        capabilities: {
+            structuralIntrospection: true,
+            tableSampling: false,
+            columnSampling: false,
+            columnStats: false,
+            readOnlySql: false,
+            nestedAnalysis: false,
+            eventStreamDiscovery: false,
+            formalForeignKeys: false,
+            estimatedRowCounts: false,
+        },
+        introspect: vi.fn(async () => {
+            throw new Error('introspect should not be called from connection test');
+        }),
+        testConnection,
+        cleanup,
+    };
+    return { connector, testConnection, cleanup };
+}
+describe('runKtxConnection', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-cli-connection-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    async function writeConnections(projectDir, connections) {
+        const config = parseKtxProjectConfig(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8'));
+        await writeFile(join(projectDir, 'ktx.yaml'), serializeKtxProjectConfig({ ...config, connections }), 'utf-8');
+    }
+    it('lists configured connections without resolving secrets', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            warehouse: { driver: 'postgres', url: 'env:DATABASE_URL' },
+            docs: { driver: 'notion', auth_token_ref: 'env:NOTION_TOKEN', crawl_mode: 'all_accessible' },
+        });
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'list', projectDir }, io.io)).resolves.toBe(0);
+        expect(io.stdout()).toContain('warehouse');
+        expect(io.stdout()).toContain('postgres');
+        expect(io.stdout()).toContain('docs');
+        expect(io.stdout()).toContain('notion');
+        expect(io.stderr()).toBe('');
+    });
+    it('prints an empty-state message that points at setup instead of removed connection add', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'list', projectDir }, io.io)).resolves.toBe(0);
+        expect(io.stdout()).toContain('No connections configured. Run `ktx setup` to add one.');
+        expect(io.stdout()).not.toContain('ktx connection add');
+    });
+    it('tests a native connection by calling connector.testConnection (not introspect)', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            warehouse: { driver: 'sqlite' },
+        });
+        const { connector, testConnection, cleanup } = nativeConnector('sqlite');
+        const createScanConnector = vi.fn(async () => connector);
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'warehouse' }, io.io, {
+            createScanConnector,
+        })).resolves.toBe(0);
+        expect(createScanConnector).toHaveBeenCalledWith(expect.objectContaining({ projectDir }), 'warehouse');
+        expect(testConnection).toHaveBeenCalledTimes(1);
+        expect(connector.introspect).not.toHaveBeenCalled();
+        expect(cleanup).toHaveBeenCalledTimes(1);
+        expect(io.stdout()).toContain('Connection test passed: warehouse');
+        expect(io.stdout()).toContain('Driver: sqlite');
+        expect(io.stdout()).toContain('Status: ok');
+    });
+    it('reports the connector error and still cleans up when native testConnection fails', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            warehouse: { driver: 'sqlite' },
+        });
+        const { connector, cleanup } = nativeConnector('sqlite', { success: false, error: 'database file is unreadable' });
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'warehouse' }, io.io, {
+            createScanConnector: vi.fn(async () => connector),
+        })).resolves.toBe(1);
+        expect(cleanup).toHaveBeenCalledTimes(1);
+        expect(io.stderr()).toContain('database file is unreadable');
+    });
+    it('tests a configured Metabase connection through the Metabase runtime client', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            prod_metabase: {
+                driver: 'metabase',
+                api_url: 'http://metabase.example.test',
+                api_key: 'mb_test', // pragma: allowlist secret
+            },
+        });
+        const testConnection = vi.fn(async () => ({ success: true }));
+        const getDatabases = vi.fn(async () => [
+            { id: 1, name: 'Analytics', engine: 'postgres', details: {}, is_sample: false },
+            { id: 2, name: 'Sample Database', engine: 'h2', details: {}, is_sample: true },
+        ]);
+        const cleanup = vi.fn(async () => undefined);
+        const createMetabaseClient = vi.fn(async () => ({
+            testConnection,
+            getDatabases,
+            cleanup,
+        }));
+        const createScanConnector = vi.fn(async () => {
+            throw new Error('native scanner should not be used for Metabase');
+        });
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'prod_metabase' }, io.io, {
+            createScanConnector,
+            createMetabaseClient,
+        })).resolves.toBe(0);
+        expect(createScanConnector).not.toHaveBeenCalled();
+        expect(createMetabaseClient).toHaveBeenCalledWith(expect.objectContaining({ projectDir }), 'prod_metabase');
+        expect(testConnection).toHaveBeenCalledTimes(1);
+        expect(getDatabases).toHaveBeenCalledTimes(1);
+        expect(cleanup).toHaveBeenCalledTimes(1);
+        expect(io.stdout()).toContain('Connection test passed: prod_metabase');
+        expect(io.stdout()).toContain('Driver: metabase');
+        expect(io.stdout()).toContain('Databases: 1');
+        expect(io.stderr()).toBe('');
+    });
+    it('tests a Looker connection through the Looker client', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            bi_looker: {
+                driver: 'looker',
+                base_url: 'https://looker.example.test',
+                client_id: 'cid',
+                client_secret: 'csecret', // pragma: allowlist secret
+            },
+        });
+        const testConnection = vi.fn(async () => ({
+            success: true,
+            metadata: { displayName: 'Alice Analyst', userId: '42' },
+        }));
+        const createLookerClient = vi.fn(async () => ({ testConnection }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'bi_looker' }, io.io, { createLookerClient })).resolves.toBe(0);
+        expect(createLookerClient).toHaveBeenCalledWith(expect.objectContaining({ projectDir }), 'bi_looker');
+        expect(testConnection).toHaveBeenCalledTimes(1);
+        expect(io.stdout()).toContain('Connection test passed: bi_looker');
+        expect(io.stdout()).toContain('Driver: looker');
+        expect(io.stdout()).toContain('User: Alice Analyst');
+    });
+    it('falls back to userId when Looker metadata has no display name', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            bi_looker: {
+                driver: 'looker',
+                base_url: 'https://looker.example.test',
+                client_id: 'cid',
+                client_secret: 'csecret', // pragma: allowlist secret
+            },
+        });
+        const createLookerClient = vi.fn(async () => ({
+            testConnection: vi.fn(async () => ({
+                success: true,
+                metadata: { displayName: null, userId: '42' },
+            })),
+        }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'bi_looker' }, io.io, { createLookerClient })).resolves.toBe(0);
+        expect(io.stdout()).toContain('User: 42');
+    });
+    it('reports the Looker error when testConnection fails', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            bi_looker: {
+                driver: 'looker',
+                base_url: 'https://looker.example.test',
+                client_id: 'cid',
+                client_secret: 'csecret', // pragma: allowlist secret
+            },
+        });
+        const createLookerClient = vi.fn(async () => ({
+            testConnection: vi.fn(async () => ({ success: false, error: 'invalid client_id' })),
+        }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'bi_looker' }, io.io, { createLookerClient })).resolves.toBe(1);
+        expect(io.stderr()).toContain('Looker connection test failed: invalid client_id');
+    });
+    it('tests a Notion connection by retrieving the bot user', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            docs: {
+                driver: 'notion',
+                auth_token: 'secret_token', // pragma: allowlist secret
+                crawl_mode: 'all_accessible',
+            },
+        });
+        const retrieveBotUser = vi.fn(async () => ({ id: 'bot-1', name: 'Analytics Bot' }));
+        const createNotionClient = vi.fn(async () => ({ retrieveBotUser }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'docs' }, io.io, { createNotionClient })).resolves.toBe(0);
+        expect(createNotionClient).toHaveBeenCalledWith(expect.objectContaining({ projectDir }), 'docs');
+        expect(retrieveBotUser).toHaveBeenCalledTimes(1);
+        expect(io.stdout()).toContain('Connection test passed: docs');
+        expect(io.stdout()).toContain('Driver: notion');
+        expect(io.stdout()).toContain('Bot: Analytics Bot');
+    });
+    it('falls back to bot id when Notion bot has no name', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            docs: {
+                driver: 'notion',
+                auth_token: 'secret_token', // pragma: allowlist secret
+                crawl_mode: 'all_accessible',
+            },
+        });
+        const createNotionClient = vi.fn(async () => ({
+            retrieveBotUser: vi.fn(async () => ({ id: 'bot-1', name: null })),
+        }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'docs' }, io.io, { createNotionClient })).resolves.toBe(0);
+        expect(io.stdout()).toContain('Bot: bot-1');
+    });
+    it('tests a dbt connection via testRepoConnection (success)', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        process.env.DBT_TOKEN = 'gh_token_abc'; // pragma: allowlist secret
+        await writeConnections(projectDir, {
+            'dbt-main': {
+                driver: 'dbt',
+                repo_url: 'https://github.com/example/dbt-project',
+                auth_token_ref: 'env:DBT_TOKEN',
+            },
+        });
+        const testRepoConnection = vi.fn(async () => ({ ok: true }));
+        const io = makeIo();
+        try {
+            await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'dbt-main' }, io.io, { testRepoConnection })).resolves.toBe(0);
+            expect(testRepoConnection).toHaveBeenCalledWith({
+                repoUrl: 'https://github.com/example/dbt-project',
+                authToken: 'gh_token_abc',
+            });
+            expect(io.stdout()).toContain('Connection test passed: dbt-main');
+            expect(io.stdout()).toContain('Driver: dbt');
+            expect(io.stdout()).toContain('Repo: https://github.com/example/dbt-project');
+        }
+        finally {
+            delete process.env.DBT_TOKEN;
+        }
+    });
+    it('reports the git error when testRepoConnection fails for dbt', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            'dbt-main': {
+                driver: 'dbt',
+                repo_url: 'https://github.com/example/dbt-project',
+            },
+        });
+        const testRepoConnection = vi.fn(async () => ({ ok: false, error: 'fatal: auth failed' }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'dbt-main' }, io.io, { testRepoConnection })).resolves.toBe(1);
+        expect(testRepoConnection).toHaveBeenCalledWith({
+            repoUrl: 'https://github.com/example/dbt-project',
+            authToken: null,
+        });
+        expect(io.stderr()).toContain('dbt repository check failed: fatal: auth failed');
+    });
+    it('tests a LookML connection via testRepoConnection with camelCase repoUrl', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            lookml_main: {
+                driver: 'lookml',
+                repoUrl: 'https://github.com/example/lookml',
+            },
+        });
+        const testRepoConnection = vi.fn(async () => ({ ok: true }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'lookml_main' }, io.io, { testRepoConnection })).resolves.toBe(0);
+        expect(testRepoConnection).toHaveBeenCalledWith({
+            repoUrl: 'https://github.com/example/lookml',
+            authToken: null,
+        });
+        expect(io.stdout()).toContain('Driver: lookml');
+        expect(io.stdout()).toContain('Repo: https://github.com/example/lookml');
+    });
+    it('tests a MetricFlow connection via the nested metricflow block', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            mf_main: {
+                driver: 'metricflow',
+                metricflow: { repoUrl: 'https://github.com/example/metricflow' },
+            },
+        });
+        const testRepoConnection = vi.fn(async () => ({ ok: true }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'mf_main' }, io.io, { testRepoConnection })).resolves.toBe(0);
+        expect(testRepoConnection).toHaveBeenCalledWith({
+            repoUrl: 'https://github.com/example/metricflow',
+            authToken: null,
+        });
+        expect(io.stdout()).toContain('Driver: metricflow');
+    });
+    it('--all: prints a single coherent list with one row per connection', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            warehouse: { driver: 'sqlite' },
+            docs: { driver: 'notion', auth_token: 'secret_token', crawl_mode: 'all_accessible' }, // pragma: allowlist secret
+        });
+        const { connector } = nativeConnector('sqlite');
+        const createScanConnector = vi.fn(async () => connector);
+        const createNotionClient = vi.fn(async () => ({
+            retrieveBotUser: vi.fn(async () => ({ id: 'bot-1', name: 'Docs Bot' })),
+        }));
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test-all', projectDir }, io.io, { createScanConnector, createNotionClient })).resolves.toBe(0);
+        const out = stripAnsi(io.stdout());
+        expect(out).toContain('connection test --all');
+        expect(out).toMatch(/docs\s+notion\s+✓ ok\s+Bot: Docs Bot/);
+        expect(out).toMatch(/warehouse\s+sqlite\s+✓ ok\s+Status: ok/);
+        expect(out).toContain('2 tested');
+        expect(out).toContain('2 passed');
+        expect(out).not.toContain('failed');
+        expect(io.stderr()).toBe('');
+    });
+    it('--all: marks failing connections, keeps passing ones, and returns non-zero', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeConnections(projectDir, {
+            warehouse: { driver: 'sqlite' },
+            broken: { driver: 'sqlite' },
+        });
+        const okConnector = nativeConnector('sqlite').connector;
+        const failConnector = nativeConnector('sqlite', { success: false, error: 'database file is unreadable' }).connector;
+        const createScanConnector = vi.fn(async (_p, connectionId) => connectionId === 'broken' ? failConnector : okConnector);
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test-all', projectDir }, io.io, { createScanConnector })).resolves.toBe(1);
+        const out = stripAnsi(io.stdout());
+        expect(out).toMatch(/broken\s+sqlite\s+✗ failed\s+database file is unreadable/);
+        expect(out).toMatch(/warehouse\s+sqlite\s+✓ ok\s+Status: ok/);
+        expect(out).toContain('1 passed');
+        expect(out).toContain('1 failed');
+        expect(io.stderr()).toBe('');
+    });
+    it('--all: shows an empty-state message when no connections are configured', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test-all', projectDir }, io.io)).resolves.toBe(0);
+        const out = stripAnsi(io.stdout());
+        expect(out).toContain('connection test --all');
+        expect(out).toContain('No connections configured. Run `ktx setup` to add one.');
+    });
+    it('rejects unknown drivers with a helpful error', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir });
+        await writeFile(join(projectDir, 'ktx.yaml'), 'connections:\n  mystery:\n    driver: duckdb\n', 'utf-8');
+        const io = makeIo();
+        await expect(runKtxConnection({ command: 'test', projectDir, connectionId: 'mystery' }, io.io)).resolves.toBe(1);
+        expect(io.stderr()).toContain('connections.mystery.driver');
+        expect(io.stderr()).toContain('postgres');
+    });
+});