@kaelio/ktx 0.5.0 → 0.7.0

package/dist/local-adapters.test.js

@@ -1,166 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { loadKtxProject } from './context/project/project.js';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { createKtxCliLocalIngestAdapters } from './local-adapters.js';
-function sqlAnalysisStub() {
-    return {
-        async analyzeForFingerprint(sql) {
-            return {
-                fingerprint: 'fp',
-                normalizedSql: sql,
-                tablesTouched: [],
-                literalSlots: [],
-            };
-        },
-        async analyzeBatch() {
-            return new Map();
-        },
-        async validateReadOnly() {
-            return { ok: true };
-        },
-    };
-}
-async function writeProject(projectDir, body) {
-    await writeFile(join(projectDir, 'ktx.yaml'), body, 'utf-8');
-}
-describe('CLI local ingest adapters', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-cli-local-adapters-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('registers Postgres historic SQL from connection context query history', async () => {
-        await writeProject(tempDir, [
-            'connections:',
-            '  warehouse:',
-            '    driver: postgres',
-            '    url: env:WAREHOUSE_DATABASE_URL',
-            '    readonly: true',
-            '    context:',
-            '      queryHistory:',
-            '        enabled: true',
-            'ingest:',
-            '  adapters:',
-            '    - historic-sql',
-            '',
-        ].join('\n'));
-        const project = await loadKtxProject({ projectDir: tempDir });
-        const adapters = createKtxCliLocalIngestAdapters(project, {
-            historicSqlConnectionId: 'warehouse',
-            sqlAnalysis: sqlAnalysisStub(),
-        });
-        expect(adapters.find((adapter) => adapter.source === 'historic-sql')?.skillNames).toEqual([
-            'historic_sql_table_digest',
-            'historic_sql_patterns',
-        ]);
-    });
-    it('registers BigQuery historic SQL from the requested connection', async () => {
-        await writeProject(tempDir, [
-            'connections:',
-            '  bq:',
-            '    driver: bigquery',
-            '    dataset_id: analytics',
-            '    location: us',
-            '    credentials_json: \'{"project_id":"demo-project"}\'',
-            '    context:',
-            '      queryHistory:',
-            '        enabled: true',
-            'ingest:',
-            '  adapters:',
-            '    - historic-sql',
-            '',
-        ].join('\n'));
-        const project = await loadKtxProject({ projectDir: tempDir });
-        const adapters = createKtxCliLocalIngestAdapters(project, {
-            historicSqlConnectionId: 'bq',
-            sqlAnalysis: sqlAnalysisStub(),
-        });
-        expect(adapters.find((adapter) => adapter.source === 'historic-sql')?.skillNames).toEqual([
-            'historic_sql_table_digest',
-            'historic_sql_patterns',
-        ]);
-    });
-    it('registers Snowflake historic SQL from the requested connection', async () => {
-        await writeProject(tempDir, [
-            'connections:',
-            '  sf:',
-            '    driver: snowflake',
-            '    account: acct',
-            '    warehouse: wh',
-            '    database: ANALYTICS',
-            '    schema_name: PUBLIC',
-            '    username: reader',
-            '    password: env:SNOWFLAKE_PASSWORD',
-            '    context:',
-            '      queryHistory:',
-            '        enabled: true',
-            'ingest:',
-            '  adapters:',
-            '    - historic-sql',
-            '',
-        ].join('\n'));
-        const project = await loadKtxProject({ projectDir: tempDir });
-        const adapters = createKtxCliLocalIngestAdapters(project, {
-            historicSqlConnectionId: 'sf',
-            sqlAnalysis: sqlAnalysisStub(),
-        });
-        expect(adapters.find((adapter) => adapter.source === 'historic-sql')?.skillNames).toEqual([
-            'historic_sql_table_digest',
-            'historic_sql_patterns',
-        ]);
-    });
-    it('resolves BigQuery credentials_json from a file: reference for query history ingest', async () => {
-        const credentialsPath = join(tempDir, 'credentials.json');
-        await writeFile(credentialsPath, JSON.stringify({ project_id: 'demo-project' }), 'utf-8');
-        await writeProject(tempDir, [
-            'connections:',
-            '  bq:',
-            '    driver: bigquery',
-            '    dataset_id: analytics',
-            '    location: us',
-            `    credentials_json: 'file:${credentialsPath}'`,
-            '    context:',
-            '      queryHistory:',
-            '        enabled: true',
-            'ingest:',
-            '  adapters:',
-            '    - historic-sql',
-            '',
-        ].join('\n'));
-        const project = await loadKtxProject({ projectDir: tempDir });
-        const adapters = createKtxCliLocalIngestAdapters(project, {
-            historicSqlConnectionId: 'bq',
-            sqlAnalysis: sqlAnalysisStub(),
-        });
-        expect(adapters.find((adapter) => adapter.source === 'historic-sql')?.skillNames).toEqual([
-            'historic_sql_table_digest',
-            'historic_sql_patterns',
-        ]);
-    });
-    it('uses query-history wording for public BigQuery capability errors', async () => {
-        await writeProject(tempDir, [
-            'connections:',
-            '  bq:',
-            '    driver: bigquery',
-            '    readonly: true',
-            '    dataset_id: analytics',
-            '    credentials_json: "{}"',
-            '    context:',
-            '      queryHistory:',
-            '        enabled: true',
-            'ingest:',
-            '  adapters:',
-            '    - historic-sql',
-            '',
-        ].join('\n'));
-        const project = await loadKtxProject({ projectDir: tempDir });
-        expect(() => createKtxCliLocalIngestAdapters(project, {
-            historicSqlConnectionId: 'bq',
-            sqlAnalysis: sqlAnalysisStub(),
-        })).toThrow('Query history BigQuery connection requires credentials_json.project_id');
-    });
-});

package/dist/local-scan-connectors.test.d.ts

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

package/dist/local-scan-connectors.test.js

@@ -1,92 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { initKtxProject, loadKtxProject } from './context/project/project.js';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createKtxCliScanConnector } from './local-scan-connectors.js';
-const bigQueryMock = vi.hoisted(() => ({
-    constructorInputs: [],
-}));
-vi.mock('./connectors/bigquery/connector.js', () => ({
-    isKtxBigQueryConnectionConfig: (connection) => String(connection?.driver ?? '').toLowerCase() === 'bigquery',
-    KtxBigQueryScanConnector: class {
-        id;
-        driver = 'bigquery';
-        constructor(options) {
-            bigQueryMock.constructorInputs.push(options);
-            this.id = `bigquery:${options.connectionId}`;
-        }
-    },
-}));
-describe('createKtxCliScanConnector', () => {
-    let tempDir;
-    beforeEach(async () => {
-        bigQueryMock.constructorInputs.length = 0;
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-cli-scan-connector-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('creates a native sqlite connector from standalone config', async () => {
-        await initKtxProject({ projectDir: tempDir });
-        await writeFile(join(tempDir, 'ktx.yaml'), [
-            'connections:',
-            '  warehouse:',
-            '    driver: sqlite',
-            '    path: warehouse.db',
-            '',
-        ].join('\n'), 'utf-8');
-        const project = await loadKtxProject({ projectDir: tempDir });
-        const connector = await createKtxCliScanConnector(project, 'warehouse');
-        expect(connector.id).toBe('sqlite:warehouse');
-        expect(connector.driver).toBe('sqlite');
-    });
-    it('passes canonical BigQuery YAML scan limits through to the connector', async () => {
-        await initKtxProject({ projectDir: tempDir });
-        await writeFile(join(tempDir, 'ktx.yaml'), [
-            'connections:',
-            '  warehouse:',
-            '    driver: bigquery',
-            '    dataset_id: analytics',
-            '    max_bytes_billed: "987654321"',
-            '    job_timeout_ms: 30000',
-            '',
-        ].join('\n'), 'utf-8');
-        const project = await loadKtxProject({ projectDir: tempDir });
-        const connector = await createKtxCliScanConnector(project, 'warehouse');
-        expect(connector.id).toBe('bigquery:warehouse');
-        expect(connector.driver).toBe('bigquery');
-        expect(bigQueryMock.constructorInputs).toEqual([
-            expect.objectContaining({
-                connectionId: 'warehouse',
-                connection: expect.objectContaining({
-                    max_bytes_billed: '987654321',
-                    job_timeout_ms: 30000,
-                }),
-            }),
-        ]);
-        expect(bigQueryMock.constructorInputs[0]).not.toHaveProperty('maxBytesBilled');
-    });
-    it('rejects daemon-only fallback driver configs at config parse time', async () => {
-        await initKtxProject({ projectDir: tempDir });
-        await writeFile(join(tempDir, 'ktx.yaml'), [
-            'connections:',
-            '  warehouse:',
-            '    driver: duckdb',
-            '    path: warehouse.duckdb',
-            '',
-        ].join('\n'), 'utf-8');
-        await expect(loadKtxProject({ projectDir: tempDir })).rejects.toThrow(/connections\.warehouse\.driver:.*Invalid discriminator value/);
-    });
-    it('rejects connection blocks with no driver field at config parse time', async () => {
-        await initKtxProject({ projectDir: tempDir });
-        await writeFile(join(tempDir, 'ktx.yaml'), [
-            'connections:',
-            '  warehouse:',
-            '    type: postgres',
-            '    url: postgresql://example/db',
-            '',
-        ].join('\n'), 'utf-8');
-        await expect(loadKtxProject({ projectDir: tempDir })).rejects.toThrow(/connections\.warehouse\.driver:.*Invalid discriminator value/);
-    });
-});

package/dist/managed-local-embeddings.test.d.ts

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

package/dist/managed-local-embeddings.test.js

@@ -1,229 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, tryUseManagedLocalEmbeddingsDaemon, } from './managed-local-embeddings.js';
-function makeIo() {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-function runtime() {
-    return {
-        layout: {
-            cliVersion: '0.2.0',
-            runtimeRoot: '/runtime',
-            versionDir: '/runtime/0.2.0',
-            venvDir: '/runtime/0.2.0/.venv',
-            manifestPath: '/runtime/0.2.0/manifest.json',
-            installLogPath: '/runtime/0.2.0/install.log',
-            assetDir: '/assets/python',
-            assetManifestPath: '/assets/python/manifest.json',
-            pythonPath: '/runtime/0.2.0/.venv/bin/python',
-            daemonPath: '/runtime/0.2.0/.venv/bin/ktx-daemon',
-        },
-        manifest: {
-            schemaVersion: 1,
-            cliVersion: '0.2.0',
-            installedAt: '2026-05-11T00:00:00.000Z',
-            asset: {
-                schemaVersion: 1,
-                distributionName: 'kaelio-ktx',
-                normalizedName: 'kaelio_ktx',
-                version: '0.2.0',
-                wheel: {
-                    file: 'kaelio_ktx-0.2.0-py3-none-any.whl',
-                    sha256: 'a'.repeat(64),
-                    bytes: 123,
-                },
-            },
-            features: ['core', 'local-embeddings'],
-            python: {
-                executable: '/runtime/0.2.0/.venv/bin/python',
-                daemonExecutable: '/runtime/0.2.0/.venv/bin/ktx-daemon',
-            },
-            installLog: '/runtime/0.2.0/install.log',
-        },
-    };
-}
-function daemonResult(status = 'reused') {
-    return {
-        status,
-        layout: {
-            ...runtime().layout,
-            projectDir: '/work/proj',
-            daemonStateDir: '/work/proj/.ktx/runtime',
-            daemonStatePath: '/work/proj/.ktx/runtime/daemon.json',
-            daemonStdoutPath: '/work/proj/.ktx/runtime/daemon.stdout.log',
-            daemonStderrPath: '/work/proj/.ktx/runtime/daemon.stderr.log',
-        },
-        baseUrl: 'http://127.0.0.1:61234',
-        state: {
-            schemaVersion: 1,
-            pid: 12345,
-            host: '127.0.0.1',
-            port: 61234,
-            version: '0.2.0',
-            features: ['core', 'local-embeddings'],
-            startedAt: '2026-05-11T00:00:00.000Z',
-            stdoutLog: '/work/proj/.ktx/runtime/daemon.stdout.log',
-            stderrLog: '/work/proj/.ktx/runtime/daemon.stderr.log',
-        },
-    };
-}
-describe('managedLocalEmbeddingHealthConfig', () => {
-    it('uses the active KTX daemon URL for the immediate health check', () => {
-        expect(managedLocalEmbeddingHealthConfig({
-            baseUrl: 'http://127.0.0.1:61234',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-        })).toEqual({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-            sentenceTransformers: { baseURL: 'http://127.0.0.1:61234', pathPrefix: '' },
-        });
-    });
-});
-describe('ensureManagedLocalEmbeddingsDaemon', () => {
-    it('ensures the local-embeddings feature and starts the KTX daemon', async () => {
-        const io = makeIo();
-        const ensureRuntime = vi.fn(async () => runtime());
-        const startDaemon = vi.fn(async () => daemonResult('started'));
-        await expect(ensureManagedLocalEmbeddingsDaemon({
-            cliVersion: '0.2.0',
-            projectDir: '/work/proj',
-            installPolicy: 'auto',
-            io: io.io,
-            ensureRuntime,
-            startDaemon,
-        })).resolves.toEqual({
-            baseUrl: 'http://127.0.0.1:61234',
-            stdoutLog: '/work/proj/.ktx/runtime/daemon.stdout.log',
-            stderrLog: '/work/proj/.ktx/runtime/daemon.stderr.log',
-        });
-        expect(ensureRuntime).toHaveBeenCalledWith({
-            cliVersion: '0.2.0',
-            installPolicy: 'auto',
-            io: io.io,
-            feature: 'local-embeddings',
-        });
-        expect(startDaemon).toHaveBeenCalledWith({
-            cliVersion: '0.2.0',
-            projectDir: '/work/proj',
-            features: ['local-embeddings'],
-            force: false,
-        });
-        expect(io.stderr()).toContain('Started KTX daemon: http://127.0.0.1:61234');
-    });
-    it('reuses an already running daemon without reporting a new start', async () => {
-        const io = makeIo();
-        await ensureManagedLocalEmbeddingsDaemon({
-            cliVersion: '0.2.0',
-            projectDir: '/work/proj',
-            installPolicy: 'prompt',
-            io: io.io,
-            ensureRuntime: vi.fn(async () => runtime()),
-            startDaemon: vi.fn(async () => daemonResult('reused')),
-        });
-        expect(io.stderr()).toContain('Using KTX daemon: http://127.0.0.1:61234');
-    });
-});
-describe('tryUseManagedLocalEmbeddingsDaemon', () => {
-    it('returns the daemon when one is running and healthy', async () => {
-        const readStatus = vi.fn(async () => ({
-            kind: 'running',
-            detail: 'ok',
-            layout: {},
-            state: {
-                schemaVersion: 1,
-                pid: 123,
-                host: '127.0.0.1',
-                port: 4321,
-                version: '0.5.0',
-                features: ['local-embeddings'],
-                startedAt: '2026-05-21T00:00:00Z',
-                stdoutLog: '/tmp/stdout.log',
-                stderrLog: '/tmp/stderr.log',
-            },
-            baseUrl: 'http://127.0.0.1:4321',
-        }));
-        const result = await tryUseManagedLocalEmbeddingsDaemon({
-            cliVersion: '0.5.0',
-            projectDir: '/work/proj',
-            readStatus,
-        });
-        expect(result).toEqual({
-            baseUrl: 'http://127.0.0.1:4321',
-            stdoutLog: '/tmp/stdout.log',
-            stderrLog: '/tmp/stderr.log',
-        });
-        expect(readStatus).toHaveBeenCalledWith({
-            cliVersion: '0.5.0',
-            projectDir: '/work/proj',
-        });
-    });
-    it('returns null when no daemon state exists', async () => {
-        const readStatus = vi.fn(async () => ({
-            kind: 'stopped',
-            detail: 'no state',
-            layout: {},
-        }));
-        const result = await tryUseManagedLocalEmbeddingsDaemon({
-            cliVersion: '0.5.0',
-            projectDir: '/work/proj',
-            readStatus,
-        });
-        expect(result).toBeNull();
-    });
-    it('returns null when daemon is stale', async () => {
-        const readStatus = vi.fn(async () => ({
-            kind: 'stale',
-            detail: 'process gone',
-            layout: {},
-        }));
-        const result = await tryUseManagedLocalEmbeddingsDaemon({
-            cliVersion: '0.5.0',
-            projectDir: '/work/proj',
-            readStatus,
-        });
-        expect(result).toBeNull();
-    });
-    it('rejects daemons that do not advertise local-embeddings', async () => {
-        const readStatus = vi.fn(async () => ({
-            kind: 'running',
-            detail: 'ok',
-            layout: {},
-            state: {
-                schemaVersion: 1,
-                pid: 123,
-                host: '127.0.0.1',
-                port: 4321,
-                version: '0.5.0',
-                features: ['core'],
-                startedAt: '2026-05-21T00:00:00Z',
-                stdoutLog: '/tmp/stdout.log',
-                stderrLog: '/tmp/stderr.log',
-            },
-            baseUrl: 'http://127.0.0.1:4321',
-        }));
-        const result = await tryUseManagedLocalEmbeddingsDaemon({
-            cliVersion: '0.5.0',
-            projectDir: '/work/proj',
-            readStatus,
-        });
-        expect(result).toBeNull();
-    });
-});

package/dist/managed-mcp-daemon.test.d.ts

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

package/dist/managed-mcp-daemon.test.js

@@ -1,187 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mcpDaemonLayout, readKtxMcpDaemonStatus, startKtxMcpDaemon, stopKtxMcpDaemon, } from './managed-mcp-daemon.js';
-function child(pid = 4242) {
-    return { pid, unref: vi.fn() };
-}
-function state(projectDir, overrides = {}) {
-    return {
-        schemaVersion: 1,
-        pid: 4242,
-        host: '127.0.0.1',
-        port: 7878,
-        tokenAuth: false,
-        projectDir,
-        startedAt: '2026-05-14T00:00:00.000Z',
-        logPath: join(projectDir, '.ktx/logs/mcp.log'),
-        ...overrides,
-    };
-}
-describe('managed MCP daemon lifecycle', () => {
-    let tempDir;
-    let projectDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-mcp-daemon-'));
-        projectDir = join(tempDir, 'project');
-        await mkdir(projectDir, { recursive: true });
-    });
-    afterEach(async () => {
-        vi.unstubAllEnvs();
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('uses the spec state and log paths', () => {
-        expect(mcpDaemonLayout(projectDir)).toEqual({
-            statePath: join(projectDir, '.ktx/mcp.json'),
-            logPath: join(projectDir, '.ktx/logs/mcp.log'),
-        });
-    });
-    it('starts a detached child and writes state without the token value', async () => {
-        const spawnDaemon = vi.fn(() => child(5555));
-        await startKtxMcpDaemon({
-            projectDir,
-            cliVersion: '0.0.0-test',
-            host: '0.0.0.0',
-            port: 7879,
-            token: 'secret-token',
-            allowedHosts: ['mcp.example.test'],
-            allowedOrigins: ['https://mcp.example.test'],
-            binPath: '/repo/packages/cli/dist/bin.js',
-            spawnDaemon,
-            processAlive: vi.fn(() => false),
-            portAvailable: vi.fn(async () => true),
-            now: () => new Date('2026-05-14T00:00:00.000Z'),
-        });
-        expect(spawnDaemon).toHaveBeenCalledWith(process.execPath, [
-            '/repo/packages/cli/dist/bin.js',
-            '--project-dir',
-            projectDir,
-            'mcp',
-            'serve-internal',
-            '--host',
-            '0.0.0.0',
-            '--port',
-            '7879',
-            '--allowed-host',
-            'mcp.example.test',
-            '--allowed-origin',
-            'https://mcp.example.test',
-        ], expect.objectContaining({
-            detached: true,
-            env: expect.objectContaining({ KTX_MCP_TOKEN: 'secret-token' }),
-        }));
-        expect(JSON.stringify(JSON.parse(await readFile(join(projectDir, '.ktx/mcp.json'), 'utf8')))).not.toContain('secret-token');
-    });
-    it('sanitizes IPv6 CIDR entries from child NO_PROXY env', async () => {
-        vi.stubEnv('NO_PROXY', 'localhost,fd07:b51a:cc66:f0::/64');
-        vi.stubEnv('no_proxy', '::1,fd00::/8,*.orb.local');
-        const spawnDaemon = vi.fn(() => child(5555));
-        await startKtxMcpDaemon({
-            projectDir,
-            cliVersion: '0.0.0-test',
-            host: '127.0.0.1',
-            port: 7879,
-            allowedHosts: [],
-            allowedOrigins: [],
-            binPath: '/repo/packages/cli/dist/bin.js',
-            spawnDaemon,
-            processAlive: vi.fn(() => false),
-            portAvailable: vi.fn(async () => true),
-            now: () => new Date('2026-05-14T00:00:00.000Z'),
-        });
-        const env = spawnDaemon.mock.calls[0]?.[2].env;
-        if (!env) {
-            throw new Error('Expected MCP daemon spawn env');
-        }
-        expect(env.NO_PROXY).toBe('localhost,::1,*.orb.local');
-        expect(env.no_proxy).toBe(env.NO_PROXY);
-    });
-    it('returns already-running without spawning when the daemon is alive at the same host/port', async () => {
-        await mkdir(join(projectDir, '.ktx'), { recursive: true });
-        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
-        const spawnDaemon = vi.fn(() => child(9999));
-        const result = await startKtxMcpDaemon({
-            projectDir,
-            cliVersion: '0.0.0-test',
-            host: '127.0.0.1',
-            port: 7878,
-            allowedHosts: [],
-            allowedOrigins: [],
-            binPath: '/repo/packages/cli/dist/bin.js',
-            spawnDaemon,
-            processAlive: vi.fn(() => true),
-            portAvailable: vi.fn(async () => true),
-        });
-        expect(result.status).toBe('already-running');
-        expect(result.url).toBe('http://127.0.0.1:7878/mcp');
-        expect(result.state.pid).toBe(4242);
-        expect(spawnDaemon).not.toHaveBeenCalled();
-    });
-    it('throws when the recorded daemon uses a different host or port', async () => {
-        await mkdir(join(projectDir, '.ktx'), { recursive: true });
-        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
-        const spawnDaemon = vi.fn(() => child(9999));
-        await expect(startKtxMcpDaemon({
-            projectDir,
-            cliVersion: '0.0.0-test',
-            host: '127.0.0.1',
-            port: 9000,
-            allowedHosts: [],
-            allowedOrigins: [],
-            binPath: '/repo/packages/cli/dist/bin.js',
-            spawnDaemon,
-            processAlive: vi.fn(() => true),
-            portAvailable: vi.fn(async () => true),
-        })).rejects.toThrow(/different configuration[\s\S]*ktx mcp stop/);
-        expect(spawnDaemon).not.toHaveBeenCalled();
-    });
-    it('throws when token-auth presence differs from the recorded daemon', async () => {
-        await mkdir(join(projectDir, '.ktx'), { recursive: true });
-        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir, { tokenAuth: false }), null, 2)}\n`);
-        const spawnDaemon = vi.fn(() => child(9999));
-        await expect(startKtxMcpDaemon({
-            projectDir,
-            cliVersion: '0.0.0-test',
-            host: '127.0.0.1',
-            port: 7878,
-            token: 'secret-token',
-            allowedHosts: [],
-            allowedOrigins: [],
-            binPath: '/repo/packages/cli/dist/bin.js',
-            spawnDaemon,
-            processAlive: vi.fn(() => true),
-            portAvailable: vi.fn(async () => true),
-        })).rejects.toThrow(/different configuration/);
-        expect(spawnDaemon).not.toHaveBeenCalled();
-    });
-    it('reports running when the process is alive and health passes', async () => {
-        await mkdir(join(projectDir, '.ktx'), { recursive: true });
-        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
-        const status = await readKtxMcpDaemonStatus({
-            projectDir,
-            processAlive: vi.fn(() => true),
-            fetchHealth: vi.fn(async () => ({ ok: true, body: { status: 'ok', projectDir, port: 7878 } })),
-        });
-        expect(status.kind).toBe('running');
-        if (status.kind !== 'running') {
-            throw new Error(`Expected running status, received ${status.kind}`);
-        }
-        expect(status.url).toBe('http://127.0.0.1:7878/mcp');
-    });
-    it('stops a recorded daemon and removes state', async () => {
-        await mkdir(join(projectDir, '.ktx'), { recursive: true });
-        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
-        const alive = new Set([4242]);
-        const killProcess = vi.fn((pid) => alive.delete(pid));
-        await expect(stopKtxMcpDaemon({
-            projectDir,
-            processAlive: vi.fn((pid) => alive.has(pid)),
-            killProcess,
-            stopGraceMs: 1,
-            pollIntervalMs: 1,
-        })).resolves.toEqual({ status: 'stopped' });
-        expect(killProcess).toHaveBeenCalledWith(4242, 'SIGTERM');
-        await expect(readFile(join(projectDir, '.ktx/mcp.json'), 'utf8')).rejects.toThrow();
-    });
-});

package/dist/managed-python-command.test.d.ts

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