@kaelio/ktx 0.5.0 → 0.7.0

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

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

package/dist/commands/mcp-commands.test.js

@@ -1,111 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { describe, expect, it, vi } from 'vitest';
-import { registerMcpCommands } from './mcp-commands.js';
-function makeContext(overrides = {}) {
-    let exitCode = 0;
-    return {
-        io: {
-            stdout: { write: vi.fn() },
-            stderr: { write: vi.fn() },
-        },
-        deps: {},
-        packageInfo: { name: '@kaelio/ktx', version: '0.0.0-test' },
-        setExitCode: (code) => {
-            exitCode = code;
-        },
-        runInit: vi.fn(),
-        writeDebug: vi.fn(),
-        ...overrides,
-        get exitCode() {
-            return exitCode;
-        },
-    };
-}
-describe('registerMcpCommands', () => {
-    it('registers the public mcp lifecycle commands', () => {
-        const program = new Command().exitOverride();
-        registerMcpCommands(program, makeContext());
-        const mcp = program.commands.find((command) => command.name() === 'mcp');
-        expect(mcp?.commands.map((command) => command.name()).sort()).toEqual([
-            'logs',
-            'serve-internal',
-            'start',
-            'status',
-            'stdio',
-            'stop',
-        ]);
-        expect(mcp?.commands.find((command) => command.name() === 'serve-internal')
-            ?._hidden).toBe(true);
-    });
-    it('rejects non-loopback start without token before spawning', async () => {
-        const program = new Command().exitOverride();
-        const startDaemon = vi.fn();
-        const context = makeContext({ deps: { mcp: { startDaemon } } });
-        registerMcpCommands(program, context);
-        await expect(program.parseAsync(['mcp', 'start', '--host', '0.0.0.0'], { from: 'user' })).rejects.toThrow('Binding KTX MCP to 0.0.0.0 requires --token or KTX_MCP_TOKEN');
-        expect(startDaemon).not.toHaveBeenCalled();
-    });
-    it('prints "already running" when startDaemon reports already-running', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const startDaemon = vi.fn().mockResolvedValue({
-            status: 'already-running',
-            url: 'http://127.0.0.1:7878/mcp',
-            state: {
-                schemaVersion: 1,
-                pid: 4242,
-                host: '127.0.0.1',
-                port: 7878,
-                tokenAuth: false,
-                projectDir: '/tmp/ktx-already',
-                startedAt: '2026-05-14T00:00:00.000Z',
-                logPath: '/tmp/ktx-already/.ktx/logs/mcp.log',
-            },
-        });
-        const context = makeContext({ deps: { mcp: { startDaemon } } });
-        registerMcpCommands(program, context);
-        await program.parseAsync(['--project-dir', '/tmp/ktx-already', 'mcp', 'start'], { from: 'user' });
-        expect(startDaemon).toHaveBeenCalledTimes(1);
-        expect(context.io.stdout.write).toHaveBeenCalledWith([
-            'KTX MCP daemon already running: http://127.0.0.1:7878/mcp',
-            '',
-            'KTX is ready for configured agents.',
-            'Open your agent for this KTX project and ask a data question, for example:',
-            '  "Use KTX to show me the available tables and metrics."',
-            '',
-        ].join('\n'));
-    });
-    it('prints a friendly next step after starting the daemon', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const startDaemon = vi.fn().mockResolvedValue({
-            status: 'started',
-            url: 'http://127.0.0.1:7878/mcp',
-            state: {
-                schemaVersion: 1,
-                pid: 4242,
-                host: '127.0.0.1',
-                port: 7878,
-                tokenAuth: false,
-                projectDir: '/tmp/ktx-started',
-                startedAt: '2026-05-14T00:00:00.000Z',
-                logPath: '/tmp/ktx-started/.ktx/logs/mcp.log',
-            },
-        });
-        const context = makeContext({ deps: { mcp: { startDaemon } } });
-        registerMcpCommands(program, context);
-        await program.parseAsync(['--project-dir', '/tmp/ktx-started', 'mcp', 'start'], { from: 'user' });
-        expect(context.io.stdout.write).toHaveBeenCalledWith(expect.stringContaining('KTX MCP daemon started: http://127.0.0.1:7878/mcp\n\nKTX is ready for configured agents.'));
-        expect(context.io.stdout.write).toHaveBeenCalledWith(expect.stringContaining('"Use KTX to show me the available tables and metrics."'));
-    });
-    it('runs the stdio server with the resolved project directory', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const runStdioServer = vi.fn().mockResolvedValue(undefined);
-        const context = makeContext({ deps: { mcp: { runStdioServer } } });
-        registerMcpCommands(program, context);
-        await expect(program.parseAsync(['--project-dir', '/tmp/ktx6', 'mcp', 'stdio'], { from: 'user' })).resolves.toBe(program);
-        expect(runStdioServer).toHaveBeenCalledWith({
-            projectDir: '/tmp/ktx6',
-            cliVersion: '0.0.0-test',
-            io: context.io,
-        });
-    });
-});

package/dist/commands/sql-commands.test.d.ts

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

package/dist/commands/sql-commands.test.js

@@ -1,68 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { describe, expect, it, vi } from 'vitest';
-import { registerSqlCommands } from './sql-commands.js';
-function makeContext(overrides = {}) {
-    let exitCode = 0;
-    return {
-        io: {
-            stdout: { write: vi.fn() },
-            stderr: { write: vi.fn() },
-        },
-        deps: {},
-        packageInfo: { name: '@kaelio/ktx', version: '0.0.0-test' },
-        setExitCode: (code) => {
-            exitCode = code;
-        },
-        runInit: vi.fn(),
-        writeDebug: vi.fn(),
-        ...overrides,
-        get exitCode() {
-            return exitCode;
-        },
-    };
-}
-describe('registerSqlCommands', () => {
-    it('routes positional SQL through the sql runner', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const sql = vi.fn(async () => 0);
-        const context = makeContext({ deps: { sql } });
-        registerSqlCommands(program, context);
-        await expect(program.parseAsync(['--project-dir', '/tmp/ktx-sql', 'sql', '--connection', 'warehouse', 'select', '1'], { from: 'user' })).resolves.toBe(program);
-        expect(sql).toHaveBeenCalledWith({
-            command: 'execute',
-            projectDir: '/tmp/ktx-sql',
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            maxRows: 1000,
-            output: undefined,
-            json: false,
-            cliVersion: '0.0.0-test',
-        }, context.io);
-    });
-    it('supports the short connection flag', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const sql = vi.fn(async () => 0);
-        const context = makeContext({ deps: { sql } });
-        registerSqlCommands(program, context);
-        await expect(program.parseAsync(['--project-dir', '/tmp/ktx-sql', 'sql', '-c', 'warehouse', 'select 1'], {
-            from: 'user',
-        })).resolves.toBe(program);
-        expect(sql).toHaveBeenCalledWith(expect.objectContaining({ connectionId: 'warehouse', sql: 'select 1' }), context.io);
-    });
-    it('rejects missing SQL before invoking the runner', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const sql = vi.fn(async () => 0);
-        registerSqlCommands(program, makeContext({ deps: { sql } }));
-        await expect(program.parseAsync(['--project-dir', '/tmp/ktx-sql', 'sql', '--connection', 'warehouse'], {
-            from: 'user',
-        })).rejects.toThrow('missing required argument');
-        expect(sql).not.toHaveBeenCalled();
-    });
-    it('rejects maxRows above the CLI cap', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const sql = vi.fn(async () => 0);
-        registerSqlCommands(program, makeContext({ deps: { sql } }));
-        await expect(program.parseAsync(['--project-dir', '/tmp/ktx-sql', 'sql', '--connection', 'warehouse', '--max-rows', '10001', 'select 1'], { from: 'user' })).rejects.toThrow('must be an integer between 1 and 10000');
-        expect(sql).not.toHaveBeenCalled();
-    });
-});

package/dist/connection.test.d.ts

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

package/dist/connection.test.js

@@ -1,426 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { initKtxProject } from './context/project/project.js';
-import { parseKtxProjectConfig, serializeKtxProjectConfig } from './context/project/config.js';
-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: {
-                isTTY: true,
-                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 () => {
-        vi.unstubAllEnvs();
-        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('emits debug telemetry for connection tests without project paths', async () => {
-        vi.stubEnv('KTX_TELEMETRY_DEBUG', '1');
-        vi.stubEnv('CI', '');
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, {
-            warehouse: { driver: 'postgres', url: 'env:DATABASE_URL' },
-        });
-        const { connector } = nativeConnector('postgres');
-        const io = makeIo();
-        const code = await runKtxConnection({ command: 'test', projectDir, connectionId: 'warehouse' }, io.io, {
-            createScanConnector: vi.fn(async () => connector),
-        });
-        expect(code).toBe(0);
-        expect(io.stderr()).toContain('"event":"connection_test"');
-        expect(io.stderr()).toContain('"driver":"postgres"');
-        expect(io.stderr()).not.toContain(projectDir);
-    });
-    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');
-    });
-});

package/dist/connectors/bigquery/connector.test.d.ts

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