@kaelio/ktx 0.5.0 → 0.7.0

package/dist/managed-python-command.test.js

@@ -1,262 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createManagedPythonSemanticLayerComputePort, ensureManagedPythonCommandRuntime, managedRuntimeInstallCommand, runtimeInstallPolicyFromFlags, } from './managed-python-command.js';
-function makeIo() {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-function layout() {
-    return {
-        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',
-    };
-}
-function manifest(features = ['core']) {
-    return {
-        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,
-        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 readyStatus(features = ['core']) {
-    return {
-        kind: 'ready',
-        detail: 'Runtime ready at /runtime/0.2.0',
-        layout: layout(),
-        manifest: manifest(features),
-    };
-}
-function missingStatus() {
-    return {
-        kind: 'missing',
-        detail: 'No runtime manifest at /runtime/0.2.0/manifest.json',
-        layout: layout(),
-    };
-}
-function installResult(features = ['core']) {
-    const installedManifest = manifest(features);
-    return {
-        status: 'installed',
-        layout: layout(),
-        asset: {
-            manifest: installedManifest.asset,
-            wheelPath: '/assets/python/kaelio_ktx-0.2.0-py3-none-any.whl',
-            requiresPython: { specifier: '>=3.13', minimumVersion: '3.13' },
-        },
-        manifest: installedManifest,
-    };
-}
-function makeSpinnerEvents() {
-    const events = [];
-    const spinner = vi.fn(() => ({
-        start: (msg) => events.push(`start:${msg}`),
-        message: (msg) => events.push(`message:${msg}`),
-        stop: (msg) => events.push(`stop:${msg}`),
-        error: (msg) => events.push(`error:${msg}`),
-    }));
-    return { events, spinner };
-}
-describe('managedRuntimeInstallCommand', () => {
-    it('prints the exact command for each managed runtime feature', () => {
-        expect(managedRuntimeInstallCommand('core')).toBe('ktx admin runtime install --yes');
-        expect(managedRuntimeInstallCommand('local-embeddings')).toBe('ktx admin runtime install --feature local-embeddings --yes');
-    });
-});
-describe('runtimeInstallPolicyFromFlags', () => {
-    it('maps command flags to managed runtime install policies', () => {
-        expect(runtimeInstallPolicyFromFlags({})).toBe('prompt');
-        expect(runtimeInstallPolicyFromFlags({ yes: false })).toBe('prompt');
-        expect(runtimeInstallPolicyFromFlags({ yes: true })).toBe('auto');
-        expect(runtimeInstallPolicyFromFlags({ input: false })).toBe('never');
-    });
-    it('rejects conflicting runtime install flags', () => {
-        expect(() => runtimeInstallPolicyFromFlags({ yes: true, input: false })).toThrow('Choose only one runtime install mode: --yes or --no-input');
-    });
-});
-describe('createManagedPythonSemanticLayerComputePort', () => {
-    it('uses non-animated runtime setup status by default', async () => {
-        const io = makeIo();
-        await expect(ensureManagedPythonCommandRuntime({
-            cliVersion: '0.2.0',
-            installPolicy: 'auto',
-            io: io.io,
-            readStatus: vi.fn(async () => missingStatus()),
-            installRuntime: vi.fn(async () => installResult(['local-embeddings'])),
-            feature: 'local-embeddings',
-        })).resolves.toMatchObject({
-            layout: { versionDir: '/runtime/0.2.0' },
-        });
-        expect(io.stderr()).toContain('Installing KTX Python runtime (local-embeddings) with uv...');
-        expect(io.stderr()).toContain('KTX Python runtime ready: /runtime/0.2.0');
-        expect(io.stderr().match(/Installing KTX Python runtime/g)).toHaveLength(1);
-    });
-    it('shows runtime installation progress with the CLI spinner', async () => {
-        const io = makeIo();
-        const { events, spinner } = makeSpinnerEvents();
-        const options = {
-            cliVersion: '0.2.0',
-            installPolicy: 'auto',
-            io: io.io,
-            readStatus: vi.fn(async () => missingStatus()),
-            installRuntime: vi.fn(async () => installResult(['local-embeddings'])),
-            feature: 'local-embeddings',
-            spinner,
-        };
-        await expect(ensureManagedPythonCommandRuntime(options)).resolves.toMatchObject({
-            layout: { versionDir: '/runtime/0.2.0' },
-        });
-        expect(events).toEqual([
-            'start:Installing KTX Python runtime (local-embeddings) with uv...',
-            'stop:KTX Python runtime ready: /runtime/0.2.0',
-        ]);
-    });
-    it('uses the managed ktx-daemon executable when the runtime is ready', async () => {
-        const io = makeIo();
-        const compute = { query: vi.fn(), validateSources: vi.fn(), generateSources: vi.fn() };
-        const createPythonCompute = vi.fn(() => compute);
-        await expect(createManagedPythonSemanticLayerComputePort({
-            cliVersion: '0.2.0',
-            installPolicy: 'never',
-            io: io.io,
-            readStatus: vi.fn(async () => readyStatus()),
-            installRuntime: vi.fn(),
-            createPythonCompute,
-        })).resolves.toBe(compute);
-        expect(createPythonCompute).toHaveBeenCalledWith({
-            command: '/runtime/0.2.0/.venv/bin/ktx-daemon',
-            args: [],
-        });
-        expect(io.stderr()).toBe('');
-    });
-    it('fails with a preparation command when input is disabled and the runtime is missing', async () => {
-        const io = makeIo();
-        const installRuntime = vi.fn();
-        await expect(createManagedPythonSemanticLayerComputePort({
-            cliVersion: '0.2.0',
-            installPolicy: 'never',
-            io: io.io,
-            readStatus: vi.fn(async () => missingStatus()),
-            installRuntime,
-        })).rejects.toThrow('KTX Python runtime is required for this command. Run: ktx admin runtime install --yes');
-        expect(installRuntime).not.toHaveBeenCalled();
-    });
-    it('installs the core runtime without prompting when policy is auto', async () => {
-        const io = makeIo();
-        const { events, spinner } = makeSpinnerEvents();
-        const compute = { query: vi.fn(), validateSources: vi.fn(), generateSources: vi.fn() };
-        const createPythonCompute = vi.fn(() => compute);
-        const installRuntime = vi.fn(async () => installResult());
-        await expect(createManagedPythonSemanticLayerComputePort({
-            cliVersion: '0.2.0',
-            installPolicy: 'auto',
-            io: io.io,
-            readStatus: vi.fn(async () => missingStatus()),
-            installRuntime,
-            createPythonCompute,
-            spinner,
-        })).resolves.toBe(compute);
-        expect(installRuntime).toHaveBeenCalledWith({
-            cliVersion: '0.2.0',
-            features: ['core'],
-            force: false,
-        });
-        expect(events).toEqual([
-            'start:Installing KTX Python runtime (core) with uv...',
-            'stop:KTX Python runtime ready: /runtime/0.2.0',
-        ]);
-    });
-    it('prompts before installing when policy is prompt', async () => {
-        const io = makeIo();
-        const { events, spinner } = makeSpinnerEvents();
-        const confirmInstall = vi.fn(async () => true);
-        const installRuntime = vi.fn(async () => installResult());
-        await createManagedPythonSemanticLayerComputePort({
-            cliVersion: '0.2.0',
-            installPolicy: 'prompt',
-            io: io.io,
-            readStatus: vi.fn(async () => missingStatus()),
-            installRuntime,
-            createPythonCompute: vi.fn(() => ({ query: vi.fn(), validateSources: vi.fn(), generateSources: vi.fn() })),
-            confirmInstall,
-            spinner,
-        });
-        expect(confirmInstall).toHaveBeenCalledWith('KTX needs to install the core Python runtime. This downloads Python dependencies with uv. Continue?', io.io);
-        expect(installRuntime).toHaveBeenCalledWith({
-            cliVersion: '0.2.0',
-            features: ['core'],
-            force: false,
-        });
-        expect(events).toContainEqual('start:Installing KTX Python runtime (core) with uv...');
-    });
-    it('uses injected runtime confirmation instead of reading process TTY directly', async () => {
-        const io = makeIo();
-        const { events, spinner } = makeSpinnerEvents();
-        const compute = { query: vi.fn(), validateSources: vi.fn(), generateSources: vi.fn() };
-        const installRuntime = vi.fn(async () => installResult());
-        const confirmInstall = vi.fn(async () => true);
-        await expect(createManagedPythonSemanticLayerComputePort({
-            cliVersion: '0.2.0',
-            installPolicy: 'prompt',
-            io: io.io,
-            readStatus: async () => missingStatus(),
-            installRuntime,
-            confirmInstall,
-            createPythonCompute: () => compute,
-            spinner,
-        })).resolves.toBe(compute);
-        expect(confirmInstall).toHaveBeenCalledWith('KTX needs to install the core Python runtime. This downloads Python dependencies with uv. Continue?', io.io);
-        expect(events).toContainEqual('start:Installing KTX Python runtime (core) with uv...');
-    });
-    it('can decide default runtime prompting from injected io capabilities', async () => {
-        const io = makeIo();
-        Object.assign(io.io.stdout, { isTTY: false });
-        await expect(createManagedPythonSemanticLayerComputePort({
-            cliVersion: '0.2.0',
-            installPolicy: 'prompt',
-            io: io.io,
-            readStatus: async () => missingStatus(),
-            installRuntime: vi.fn(),
-            createPythonCompute: () => ({ query: vi.fn(), validateSources: vi.fn(), generateSources: vi.fn() }),
-        })).rejects.toThrow('KTX Python runtime installation was cancelled');
-    });
-});

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

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

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

@@ -1,360 +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 { readManagedPythonDaemonStatus, startManagedPythonDaemon, stopAllManagedPythonDaemons, stopManagedPythonDaemon, } from './managed-python-daemon.js';
-function layout(root) {
-    const projectDir = join(root, 'project');
-    return {
-        cliVersion: '0.2.0',
-        runtimeRoot: join(root, 'runtime'),
-        versionDir: join(root, 'runtime', '0.2.0'),
-        venvDir: join(root, 'runtime', '0.2.0', '.venv'),
-        manifestPath: join(root, 'runtime', '0.2.0', 'manifest.json'),
-        installLogPath: join(root, 'runtime', '0.2.0', 'install.log'),
-        assetDir: join(root, 'assets', 'python'),
-        assetManifestPath: join(root, 'assets', 'python', 'manifest.json'),
-        pythonPath: join(root, 'runtime', '0.2.0', '.venv', 'bin', 'python'),
-        daemonPath: join(root, 'runtime', '0.2.0', '.venv', 'bin', 'ktx-daemon'),
-        projectDir,
-        daemonStateDir: join(projectDir, '.ktx', 'runtime'),
-        daemonStatePath: join(projectDir, '.ktx', 'runtime', 'daemon.json'),
-        daemonStdoutPath: join(projectDir, '.ktx', 'runtime', 'daemon.stdout.log'),
-        daemonStderrPath: join(projectDir, '.ktx', 'runtime', 'daemon.stderr.log'),
-    };
-}
-function installLayout(root) {
-    const { projectDir: _projectDir, daemonStateDir: _d, daemonStatePath: _ds, daemonStdoutPath: _so, daemonStderrPath: _se, ...rest } = layout(root);
-    return rest;
-}
-function manifest(root, features = ['core']) {
-    const runtimeLayout = layout(root);
-    return {
-        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,
-        python: {
-            executable: runtimeLayout.pythonPath,
-            daemonExecutable: runtimeLayout.daemonPath,
-        },
-        installLog: runtimeLayout.installLogPath,
-    };
-}
-function installResult(root, features = ['core']) {
-    return {
-        status: 'ready',
-        layout: installLayout(root),
-        asset: {
-            manifest: manifest(root, features).asset,
-            wheelPath: join(root, 'assets', 'python', 'kaelio_ktx-0.2.0-py3-none-any.whl'),
-            requiresPython: { specifier: '>=3.13', minimumVersion: '3.13' },
-        },
-        manifest: manifest(root, features),
-    };
-}
-function makeFetch(version = '0.2.0') {
-    return vi.fn(async () => ({
-        ok: true,
-        status: 200,
-        json: async () => ({ status: 'healthy', version }),
-        text: async () => '',
-    }));
-}
-function makeSpawn(pid = 4242) {
-    return vi.fn((_command, _args, _options) => ({
-        pid,
-        unref: vi.fn(),
-    }));
-}
-function runningState(root, overrides = {}) {
-    const runtimeLayout = layout(root);
-    return {
-        schemaVersion: 1,
-        pid: 4242,
-        host: '127.0.0.1',
-        port: 58731,
-        version: '0.2.0',
-        features: ['core'],
-        startedAt: '2026-05-11T00:00:00.000Z',
-        stdoutLog: runtimeLayout.daemonStdoutPath,
-        stderrLog: runtimeLayout.daemonStderrPath,
-        ...overrides,
-    };
-}
-function daemonOptionsBase(root) {
-    return {
-        cliVersion: '0.2.0',
-        projectDir: layout(root).projectDir,
-        runtimeRoot: join(root, 'runtime'),
-    };
-}
-describe('KTX daemon lifecycle', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-managed-daemon-'));
-    });
-    afterEach(async () => {
-        vi.unstubAllEnvs();
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('reports stopped when no daemon state exists', async () => {
-        const status = await readManagedPythonDaemonStatus({
-            ...daemonOptionsBase(tempDir),
-            processAlive: vi.fn(() => false),
-            fetch: makeFetch(),
-        });
-        expect(status.kind).toBe('stopped');
-        expect(status.detail).toContain('No daemon state');
-    });
-    it('starts ktx-daemon serve-http, waits for health, and writes state', async () => {
-        const spawnDaemon = makeSpawn(5555);
-        const installRuntime = vi.fn(async () => installResult(tempDir));
-        const result = await startManagedPythonDaemon({
-            ...daemonOptionsBase(tempDir),
-            features: ['core'],
-            installRuntime,
-            spawnDaemon,
-            fetch: makeFetch(),
-            allocatePort: vi.fn(async () => 61234),
-            now: () => new Date('2026-05-11T00:00:00.000Z'),
-            pollIntervalMs: 1,
-        });
-        expect(result.status).toBe('started');
-        expect(result.baseUrl).toBe('http://127.0.0.1:61234');
-        expect(installRuntime).toHaveBeenCalledWith({
-            cliVersion: '0.2.0',
-            runtimeRoot: join(tempDir, 'runtime'),
-            features: ['core'],
-            force: false,
-        });
-        expect(spawnDaemon).toHaveBeenCalledWith(layout(tempDir).daemonPath, ['serve-http', '--host', '127.0.0.1', '--port', '61234'], expect.objectContaining({
-            detached: true,
-            env: expect.objectContaining({ KTX_DAEMON_VERSION: '0.2.0' }),
-        }));
-        expect(JSON.parse(await readFile(layout(tempDir).daemonStatePath, 'utf8'))).toMatchObject({
-            pid: 5555,
-            port: 61234,
-            version: '0.2.0',
-            features: ['core'],
-            stdoutLog: layout(tempDir).daemonStdoutPath,
-            stderrLog: layout(tempDir).daemonStderrPath,
-        });
-    });
-    it('sanitizes IPv6 CIDR entries from child NO_PROXY env', async () => {
-        vi.stubEnv('NO_PROXY', 'localhost,fd07:b51a:cc66:f0::/64,127.0.0.0/8');
-        vi.stubEnv('no_proxy', '::1,fd00::/8,*.orb.local');
-        const spawnDaemon = makeSpawn(5555);
-        await startManagedPythonDaemon({
-            ...daemonOptionsBase(tempDir),
-            features: ['local-embeddings'],
-            installRuntime: vi.fn(async () => installResult(tempDir, ['core', 'local-embeddings'])),
-            spawnDaemon,
-            fetch: makeFetch(),
-            allocatePort: vi.fn(async () => 61234),
-            now: () => new Date('2026-05-11T00:00:00.000Z'),
-            pollIntervalMs: 1,
-        });
-        const env = vi.mocked(spawnDaemon).mock.calls[0]?.[2].env;
-        expect(env?.NO_PROXY).toBe('localhost,127.0.0.0/8,::1,*.orb.local');
-        expect(env?.no_proxy).toBe(env?.NO_PROXY);
-    });
-    it('makes a final health probe before reporting startup failure', async () => {
-        const spawnDaemon = makeSpawn(5556);
-        const installRuntime = vi.fn(async () => installResult(tempDir));
-        const fetch = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('fetch failed'))
-            .mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => ({ status: 'healthy', version: '0.2.0' }),
-            text: async () => '',
-        });
-        const result = await startManagedPythonDaemon({
-            ...daemonOptionsBase(tempDir),
-            features: ['core'],
-            installRuntime,
-            spawnDaemon,
-            fetch,
-            allocatePort: vi.fn(async () => 61234),
-            now: () => new Date('2026-05-11T00:00:00.000Z'),
-            startupTimeoutMs: 5,
-            pollIntervalMs: 20,
-        });
-        expect(result.status).toBe('started');
-        expect(fetch).toHaveBeenCalledTimes(2);
-        expect(JSON.parse(await readFile(layout(tempDir).daemonStatePath, 'utf8'))).toMatchObject({
-            pid: 5556,
-            port: 61234,
-            version: '0.2.0',
-        });
-    });
-    it('reuses a healthy daemon with the requested feature set', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir), null, 2)}\n`);
-        const spawnDaemon = makeSpawn(9999);
-        const result = await startManagedPythonDaemon({
-            ...daemonOptionsBase(tempDir),
-            features: ['core'],
-            installRuntime: vi.fn(async () => installResult(tempDir)),
-            spawnDaemon,
-            fetch: makeFetch(),
-            processAlive: vi.fn(() => true),
-            pollIntervalMs: 1,
-        });
-        expect(result.status).toBe('reused');
-        expect(result.baseUrl).toBe('http://127.0.0.1:58731');
-        expect(spawnDaemon).not.toHaveBeenCalled();
-    });
-    it('starts a fresh daemon when the previous state is stale', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir, { version: '0.1.0' }), null, 2)}\n`);
-        const result = await startManagedPythonDaemon({
-            ...daemonOptionsBase(tempDir),
-            features: ['core'],
-            installRuntime: vi.fn(async () => installResult(tempDir)),
-            spawnDaemon: makeSpawn(6666),
-            fetch: makeFetch(),
-            processAlive: vi.fn(() => true),
-            killProcess: vi.fn(),
-            allocatePort: vi.fn(async () => 61235),
-            now: () => new Date('2026-05-11T00:00:00.000Z'),
-            pollIntervalMs: 1,
-        });
-        expect(result.status).toBe('started');
-        expect(JSON.parse(await readFile(layout(tempDir).daemonStatePath, 'utf8'))).toMatchObject({
-            pid: 6666,
-            port: 61235,
-            version: '0.2.0',
-        });
-    });
-    it('stops a recorded daemon and removes the state file', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir), null, 2)}\n`);
-        const killProcess = vi.fn();
-        const result = await stopManagedPythonDaemon({
-            ...daemonOptionsBase(tempDir),
-            processAlive: vi.fn(() => true),
-            killProcess,
-        });
-        expect(result.status).toBe('stopped');
-        expect(killProcess).toHaveBeenCalledWith(4242);
-        await expect(readFile(layout(tempDir).daemonStatePath, 'utf8')).rejects.toThrow();
-    });
-    it('stops the recorded daemon for this project and removes the state file', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir), null, 2)}\n`);
-        const alive = new Set([4242]);
-        const killProcess = vi.fn((pid) => {
-            alive.delete(pid);
-        });
-        const result = await stopAllManagedPythonDaemons({
-            ...daemonOptionsBase(tempDir),
-            listProcesses: vi.fn(async () => []),
-            processAlive: vi.fn((pid) => alive.has(pid)),
-            killProcess,
-            stopGraceMs: 0,
-        });
-        expect(result.failed).toHaveLength(0);
-        expect(result.stopped.map((entry) => entry.pid)).toEqual([4242]);
-        expect(killProcess).toHaveBeenCalledWith(4242, 'SIGTERM');
-        await expect(readFile(layout(tempDir).daemonStatePath, 'utf8')).rejects.toThrow();
-    });
-    it('removes stale state when the recorded daemon process is no longer alive', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir), null, 2)}\n`);
-        const result = await stopAllManagedPythonDaemons({
-            ...daemonOptionsBase(tempDir),
-            listProcesses: vi.fn(async () => []),
-            processAlive: vi.fn(() => false),
-            killProcess: vi.fn(),
-            stopGraceMs: 0,
-        });
-        expect(result.stopped).toHaveLength(0);
-        expect(result.stale.map((entry) => entry.pid)).toEqual([4242]);
-        await expect(readFile(layout(tempDir).daemonStatePath, 'utf8')).rejects.toThrow();
-    });
-    it('deduplicates a daemon found by state and process scan, preferring state metadata', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir), null, 2)}\n`);
-        const alive = new Set([4242]);
-        const killProcess = vi.fn((pid) => {
-            alive.delete(pid);
-        });
-        const result = await stopAllManagedPythonDaemons({
-            ...daemonOptionsBase(tempDir),
-            listProcesses: vi.fn(async () => [
-                { pid: 4242, command: 'uv run ktx-daemon serve-http --host 127.0.0.1 --port 61234' },
-            ]),
-            processAlive: vi.fn((pid) => alive.has(pid)),
-            killProcess,
-            stopGraceMs: 0,
-        });
-        expect(result.stopped).toHaveLength(1);
-        expect(result.stopped[0]).toMatchObject({
-            pid: 4242,
-            source: 'state',
-            url: 'http://127.0.0.1:58731',
-        });
-        expect(killProcess).toHaveBeenCalledTimes(1);
-    });
-    it('stops unrecorded ktx-daemon serve-http processes from process scan results', async () => {
-        const alive = new Set([3333, 5555]);
-        const killProcess = vi.fn((pid) => {
-            alive.delete(pid);
-        });
-        const result = await stopAllManagedPythonDaemons({
-            ...daemonOptionsBase(tempDir),
-            listProcesses: vi.fn(async () => [
-                { pid: 3333, command: 'uv run ktx-daemon serve-http --host 127.0.0.1 --port 8765' },
-                { pid: 4444, command: 'node server.js --port 8765' },
-                { pid: 5555, command: 'grep ktx-daemon serve-http --port 8765' },
-            ]),
-            processAlive: vi.fn((pid) => alive.has(pid)),
-            killProcess,
-            stopGraceMs: 0,
-        });
-        expect(result.failed).toHaveLength(0);
-        expect(result.stopped).toEqual([
-            expect.objectContaining({
-                pid: 3333,
-                source: 'process',
-                url: 'http://127.0.0.1:8765',
-            }),
-        ]);
-        expect(killProcess).toHaveBeenCalledWith(3333, 'SIGTERM');
-        expect(killProcess).not.toHaveBeenCalledWith(4444, expect.anything());
-        expect(killProcess).not.toHaveBeenCalledWith(5555, expect.anything());
-    });
-    it('reports a failed stop when TERM and KILL leave a daemon running', async () => {
-        await mkdir(layout(tempDir).daemonStateDir, { recursive: true });
-        await writeFile(layout(tempDir).daemonStatePath, `${JSON.stringify(runningState(tempDir), null, 2)}\n`);
-        const result = await stopAllManagedPythonDaemons({
-            ...daemonOptionsBase(tempDir),
-            listProcesses: vi.fn(async () => []),
-            processAlive: vi.fn(() => true),
-            killProcess: vi.fn(),
-            stopGraceMs: 0,
-        });
-        expect(result.stopped).toHaveLength(0);
-        expect(result.failed).toEqual([
-            expect.objectContaining({
-                pid: 4242,
-                detail: 'Process still running after SIGKILL',
-            }),
-        ]);
-        expect(await readFile(layout(tempDir).daemonStatePath, 'utf8')).toContain('"pid": 4242');
-    });
-});

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

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