kennel 0.2.13 → 0.2.16

package/dist/cli/src/shared/project-config.js

@@ -1,26 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { nearestFile } from './path.js';
-export const DEFAULT_PROJECT_CONFIG = 'raggle.json';
-function targetDirectory(targetPath) {
-    const target = resolve(targetPath);
-    if (existsSync(target) && statSync(target).isFile())
-        return dirname(target);
-    return target;
-}
-export function projectConfigPath(targetPath, configFile = DEFAULT_PROJECT_CONFIG) {
-    if (!configFile.trim())
-        throw new Error('config file name is required');
-    if (configFile.includes('/') || configFile.includes('\\') || isAbsolute(configFile)) {
-        const configPath = isAbsolute(configFile)
-            ? configFile
-            : resolve(targetDirectory(targetPath), configFile);
-        if (existsSync(configPath) && statSync(configPath).isFile())
-            return configPath;
-        throw new Error(`No ${configFile} found from ${resolve(targetPath)}`);
-    }
-    const configPath = nearestFile(targetPath, configFile);
-    if (configPath)
-        return configPath;
-    throw new Error(`No ${configFile} found from ${resolve(targetPath)} upward`);
-}

package/dist/cli/src/site/dev.d.ts

@@ -1,10 +0,0 @@
-export type DevOptions = {
-    targetPath: string;
-    port: string;
-    script: string | null;
-    configFile: string;
-    dryRun: boolean;
-    extra: string[];
-};
-export declare function splitDevArgs(input: string[]): DevOptions;
-export declare function dev(input: string[]): void;

package/dist/cli/src/site/dev.js

@@ -1,126 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { readJson } from '../shared/json.js';
-import { normalizeHostname, slugifyHostname } from '../shared/path.js';
-import { DEFAULT_PROJECT_CONFIG, projectConfigPath } from '../shared/project-config.js';
-import { commandLine } from '../shared/process.js';
-import { detectedPlatform, displayBasePath, rendererDevCommand, } from './renderers.js';
-export function splitDevArgs(input) {
-    const options = {
-        targetPath: '.',
-        port: '5180',
-        script: null,
-        configFile: DEFAULT_PROJECT_CONFIG,
-        dryRun: false,
-        extra: [],
-    };
-    const args = [...input];
-    const passthrough = args.indexOf('--');
-    if (passthrough !== -1) {
-        options.extra = args.splice(passthrough + 1);
-        args.pop();
-    }
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '--dry-run') {
-            options.dryRun = true;
-            continue;
-        }
-        if (arg === '--port') {
-            options.port = args[index + 1];
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--port=')) {
-            options.port = arg.slice('--port='.length);
-            continue;
-        }
-        if (arg === '--script') {
-            options.script = args[index + 1];
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--script=')) {
-            options.script = arg.slice('--script='.length);
-            continue;
-        }
-        if (arg === '--config') {
-            options.configFile = args[index + 1] ?? '';
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--config=')) {
-            options.configFile = arg.slice('--config='.length);
-            continue;
-        }
-        if (arg.startsWith('-'))
-            throw new Error(`Unknown dev option: ${arg}`);
-        options.targetPath = arg;
-    }
-    if (!options.port)
-        throw new Error('dev requires a port');
-    if (!options.configFile)
-        throw new Error('dev requires a config file name');
-    return options;
-}
-function localDevHost(config, rawName) {
-    const dev = config.dev && typeof config.dev === 'object' && !Array.isArray(config.dev) ? config.dev : {};
-    const host = normalizeHostname(dev.host ?? dev.hostname ?? config.host ?? config.hostname);
-    if (host)
-        return host;
-    const label = slugifyHostname(rawName);
-    if (!label)
-        throw new Error(`Could not derive a local hostname from "${rawName}"`);
-    return `${label}.localhost`;
-}
-function devRoot(configRoot, config) {
-    const dev = config.dev && typeof config.dev === 'object' && !Array.isArray(config.dev) ? config.dev : {};
-    const root = dev.root ?? config.devRoot;
-    if (typeof root !== 'string' || root.trim() === '')
-        return configRoot;
-    return resolve(configRoot, root);
-}
-function devToolRoot(configRoot, config) {
-    const dev = config.dev && typeof config.dev === 'object' && !Array.isArray(config.dev) ? config.dev : {};
-    const root = dev.toolRoot;
-    if (typeof root !== 'string' || root.trim() === '')
-        return null;
-    return resolve(configRoot, root);
-}
-function devScript(config) {
-    const dev = config.dev && typeof config.dev === 'object' && !Array.isArray(config.dev) ? config.dev : {};
-    if (typeof dev.script !== 'string' || dev.script.trim() === '')
-        return null;
-    return dev.script;
-}
-export function dev(input) {
-    const options = splitDevArgs(input);
-    const configPath = projectConfigPath(options.targetPath, options.configFile);
-    const configRoot = dirname(configPath);
-    const config = readJson(configPath);
-    const root = devRoot(configRoot, config);
-    const packagePath = join(root, 'package.json');
-    if (!existsSync(packagePath))
-        throw new Error(`No package.json found for ${configPath} dev root ${root}`);
-    const pkg = readJson(packagePath);
-    const rawName = config.name ?? config.project?.name ?? pkg.name ?? config.title;
-    if (typeof rawName !== 'string' || rawName.trim() === '') {
-        throw new Error(`${configPath} must define name, or package.json must define name`);
-    }
-    const host = localDevHost(config, rawName);
-    const scriptArgs = ['--host', host, '--port', options.port, ...options.extra];
-    const script = options.script ?? devScript(config);
-    const platform = script ? 'script' : detectedPlatform(root, pkg);
-    const toolRoot = devToolRoot(configRoot, config) ?? root;
-    const child = rendererDevCommand(root, pkg, platform, { script }, scriptArgs, toolRoot);
-    console.log(commandLine(child.command, child.args));
-    console.log(`http://${host}:${options.port}${displayBasePath(config)}`);
-    if (options.dryRun)
-        return;
-    const result = spawnSync(child.command, child.args, {
-        cwd: child.cwd ?? root,
-        stdio: 'inherit',
-    });
-    process.exit(result.status ?? 1);
-}

package/dist/cli/src/site/extension.d.ts

@@ -1,8 +0,0 @@
-export declare function extensionInstall(): Promise<void>;
-export type PreviewTarget = {
-    file?: string;
-    root: string;
-};
-export declare function previewTarget(url: string): Promise<PreviewTarget>;
-export declare function previewUrl(port: number, target: PreviewTarget): string;
-export declare function extensionHost(): void;

package/dist/cli/src/site/extension.js

@@ -1,113 +0,0 @@
-import { spawn } from 'node:child_process';
-import { chmod, mkdir, stat, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:net';
-import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { setTimeout } from 'node:timers/promises';
-import { previewKind } from './kinds.js';
-import { createKennelClient } from '../core/api-client.js';
-const id = 'popoljjjgainhgpkcdhmneegopeibgom';
-const name = 'com.raggle.kennel';
-export async function extensionInstall() {
-    const home = homedir();
-    const directory = join(home, '.kennel', 'native');
-    const host = join(directory, 'kennel-extension-host');
-    const script = resolve(dirname(fileURLToPath(import.meta.url)), '../../bin/kennel-native.mjs');
-    const manifests = [
-        join(home, 'Library/Application Support/Google/Chrome/NativeMessagingHosts'),
-        join(home, 'Library/Application Support/Chromium/NativeMessagingHosts'),
-    ];
-    await mkdir(directory, { recursive: true });
-    await writeFile(host, `#!/bin/sh\nexec "${process.execPath}" "${script}"\n`);
-    await chmod(host, 0o755);
-    for (const folder of manifests) {
-        await mkdir(folder, { recursive: true });
-        await writeFile(join(folder, `${name}.json`), JSON.stringify({
-            name,
-            description: 'Open local files in the Kennel folder viewer.',
-            path: host,
-            type: 'stdio',
-            allowed_origins: [`chrome-extension://${id}/`],
-        }, null, 2));
-    }
-    console.log(`Installed the Kennel Chrome bridge for ${id}`);
-}
-async function available(port) {
-    return new Promise((done) => {
-        const server = createServer();
-        server.once('error', () => done(false));
-        server.listen(port, '127.0.0.1', () => server.close(() => done(true)));
-    });
-}
-async function current(port) {
-    const client = createKennelClient({ baseUrl: `http://127.0.0.1:${port}` });
-    return client.documents('/').then(body => body.root).catch(() => undefined);
-}
-export async function previewTarget(url) {
-    if (!url.startsWith('file:'))
-        throw new Error('Kennel accepts a local file or folder URL');
-    const path = fileURLToPath(url);
-    const details = await stat(path);
-    if (details.isDirectory())
-        return { root: resolve(path) };
-    if (!details.isFile())
-        throw new Error('Kennel accepts a local file or folder');
-    if (!previewKind(path)) {
-        throw new Error('Kennel accepts Markdown, HTML, text, image, code, table, or email files');
-    }
-    return { file: basename(path), root: dirname(path) };
-}
-export function previewUrl(port, target) {
-    const url = new URL(`http://127.0.0.1:${port}/`);
-    if (target.file)
-        url.searchParams.set('document', target.file);
-    return url.href;
-}
-async function open(url) {
-    const target = await previewTarget(url);
-    for (let port = 5173; port <= 5199; port += 1) {
-        if ((await current(port)) === target.root) {
-            return previewUrl(port, target);
-        }
-        if (!(await available(port)))
-            continue;
-        const cli = resolve(dirname(fileURLToPath(import.meta.url)), '../../bin/kennel.mjs');
-        spawn(process.execPath, [cli, target.root, '--port', String(port)], {
-            detached: true,
-            stdio: 'ignore',
-        }).unref();
-        for (let attempt = 0; attempt < 50; attempt += 1) {
-            await setTimeout(100);
-            if ((await current(port)) === target.root) {
-                return previewUrl(port, target);
-            }
-        }
-        throw new Error('Kennel could not start the folder viewer');
-    }
-    throw new Error('Kennel could not find a free port');
-}
-function send(value) {
-    const body = Buffer.from(JSON.stringify(value));
-    const header = Buffer.alloc(4);
-    header.writeUInt32LE(body.length);
-    process.stdout.write(Buffer.concat([header, body]));
-}
-export function extensionHost() {
-    let input = Buffer.alloc(0);
-    process.stdin.on('data', (chunk) => {
-        input = Buffer.concat([input, chunk]);
-        while (input.length >= 4) {
-            const length = input.readUInt32LE(0);
-            if (input.length < length + 4)
-                return;
-            const message = JSON.parse(input.subarray(4, length + 4).toString());
-            input = input.subarray(length + 4);
-            if (typeof message.url !== 'string') {
-                send({ error: 'The file URL is missing' });
-                continue;
-            }
-            void open(message.url).then((url) => send({ url }), (error) => send({ error: error instanceof Error ? error.message : 'Kennel failed' }));
-        }
-    });
-}

package/dist/cli/src/site/folder-icons.d.ts

@@ -1,46 +0,0 @@
-export type IconMediaType = 'image/jpeg' | 'image/png';
-export type IconAsset = {
-    mediaType: IconMediaType;
-    source: 'local' | 'favicon';
-    url: string;
-};
-/**
- * Optional fallback for folders without a local icon (external website
- * favicon, data URL, ...). Receives the folder and the shared asset record
- * and returns a new asset key when it produced an asset.
- */
-export type FolderIconFallback = (folder: string, assets: Record<string, IconAsset>) => Promise<string | undefined>;
-/**
- * Folder icons are served as immutable, content-addressed assets, so the
- * cap is generous: it only guards against pathological files, not normal
- * photos that happen to be named icon.png (e.g. a 700 KiB folder photo).
- */
-export declare const maxIconBytes: number;
-export declare function assetKey(value: Buffer): string;
-export declare function encodeBase64Url(value: string): string;
-export declare function decodeBase64Url(value: string): string;
-export declare function iconUrl(folder: string, hash: string, mediaType: IconMediaType): string;
-/**
- * Nearest ancestor icon for a folder, walking up parent directories so
- * nested folders inherit the closest icon above them. The bundled
- * `@raggle-ai/local` does not export the ancestor-aware discovery helper
- * yet, so the walk is implemented here over `discoverProjectIcon`.
- */
-export declare function discoverAncestorIcon(folder: string): string | undefined;
-export declare function folderIcon(folder: string, assets: Record<string, IconAsset>, assetFiles: Map<string, {
-    mediaType: IconMediaType;
-    path: string;
-}>, fallback?: FolderIconFallback): Promise<string | undefined>;
-/**
- * Attach the nearest ancestor icon to each workspace breadcrumb so the
- * client can render folder icons in the header and breadcrumb dropdown.
- * Icons are registered as immutable assets served by `/api/folders/...`.
- */
-export declare function workspaceBreadcrumbIcons<B extends {
-    path: string;
-}>(breadcrumbs: B[], assetFiles: Map<string, {
-    mediaType: IconMediaType;
-    path: string;
-}>, assets?: Record<string, IconAsset>): Promise<Array<B & {
-    icon?: Pick<IconAsset, 'mediaType' | 'url'>;
-}>>;

package/dist/cli/src/site/folder-icons.js

@@ -1,86 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFile, stat } from 'node:fs/promises';
-import { dirname, extname } from 'node:path';
-import { discoverProjectIcon } from '@raggle-ai/local';
-/**
- * Folder icons are served as immutable, content-addressed assets, so the
- * cap is generous: it only guards against pathological files, not normal
- * photos that happen to be named icon.png (e.g. a 700 KiB folder photo).
- */
-export const maxIconBytes = 4 * 1024 * 1024;
-const iconTypes = new Map([
-    ['.jpeg', 'image/jpeg'],
-    ['.jpg', 'image/jpeg'],
-    ['.png', 'image/png'],
-]);
-const iconExtensions = new Map([
-    ['image/jpeg', 'jpg'],
-    ['image/png', 'png'],
-]);
-export function assetKey(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-export function encodeBase64Url(value) {
-    return Buffer.from(value, 'utf8')
-        .toString('base64')
-        .replaceAll('+', '-')
-        .replaceAll('/', '_')
-        .replaceAll('=', '');
-}
-export function decodeBase64Url(value) {
-    const padded = `${value}${'='.repeat((4 - (value.length % 4)) % 4)}`;
-    return Buffer.from(padded.replaceAll('-', '+').replaceAll('_', '/'), 'base64').toString('utf8');
-}
-export function iconUrl(folder, hash, mediaType) {
-    return `/api/folders/${encodeBase64Url(folder)}/assets/${hash}.${iconExtensions.get(mediaType)}`;
-}
-/**
- * Nearest ancestor icon for a folder, walking up parent directories so
- * nested folders inherit the closest icon above them. The bundled
- * `@raggle-ai/local` does not export the ancestor-aware discovery helper
- * yet, so the walk is implemented here over `discoverProjectIcon`.
- */
-export function discoverAncestorIcon(folder) {
-    let current = folder;
-    while (true) {
-        const icon = discoverProjectIcon(current);
-        if (icon)
-            return icon;
-        const parent = dirname(current);
-        if (parent === current)
-            return undefined;
-        current = parent;
-    }
-}
-export async function folderIcon(folder, assets, assetFiles, fallback) {
-    const icon = discoverAncestorIcon(folder);
-    const mediaType = icon ? iconTypes.get(extname(icon).toLowerCase()) : null;
-    const details = icon && mediaType ? await stat(icon).catch(() => undefined) : undefined;
-    if (!icon || !mediaType || !details?.size || details.size > maxIconBytes) {
-        return fallback ? await fallback(folder, assets) : undefined;
-    }
-    const data = await readFile(icon);
-    const hash = assetKey(data);
-    const key = `local:${hash}`;
-    assetFiles.set(hash, { mediaType, path: icon });
-    assets[key] = {
-        mediaType,
-        source: 'local',
-        url: iconUrl(folder, hash, mediaType),
-    };
-    return key;
-}
-/**
- * Attach the nearest ancestor icon to each workspace breadcrumb so the
- * client can render folder icons in the header and breadcrumb dropdown.
- * Icons are registered as immutable assets served by `/api/folders/...`.
- */
-export async function workspaceBreadcrumbIcons(breadcrumbs, assetFiles, assets = {}) {
-    return Promise.all(breadcrumbs.map(async (crumb) => {
-        const iconAssetKey = await folderIcon(crumb.path, assets, assetFiles);
-        const icon = iconAssetKey ? assets[iconAssetKey] : undefined;
-        return icon
-            ? { ...crumb, icon: { mediaType: icon.mediaType, url: icon.url } }
-            : crumb;
-    }));
-}

package/dist/cli/src/site/hot-viewer.d.ts

@@ -1,2 +0,0 @@
-import type { ViewerOptions } from './viewer.js';
-export declare function hotViewer(options: ViewerOptions): Promise<void>;

package/dist/cli/src/site/hot-viewer.js

@@ -1,238 +0,0 @@
-import { execFile, execFileSync, spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { createConnection } from 'node:net';
-import { tmpdir } from 'node:os';
-import { dirname, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createKennelClient } from '../core/api-client.js';
-import { hotKernelKey, readExternalPlugins } from '../plugins/external.js';
-function sourceRoot() {
-    return resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
-}
-async function viewerStatus(url) {
-    return createKennelClient({ baseUrl: url }).health({ signal: AbortSignal.timeout(1_000) })
-        .then((body) => body.viewer === 'kennel-vite' || body.viewer === 'kennel-core'
-        ? { viewer: body.viewer, kernelKey: body.kernelKey }
-        : 'other')
-        .catch((error) => {
-        // HTTP rejection means a different service owns the port; connection and
-        // timeout failures mean the viewer is unavailable, so startup may retry.
-        return error instanceof Error && 'status' in error && typeof error.status === 'number'
-            ? 'other' : 'unavailable';
-    });
-}
-async function runningViewer(url, attempts = 1, waitOnOther = false) {
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-        const status = await viewerStatus(url);
-        if (typeof status === 'object')
-            return status;
-        if (status === 'other' && !waitOnOther)
-            return undefined;
-        if (attempt + 1 < attempts)
-            await new Promise((done) => setTimeout(done, 250));
-    }
-    return undefined;
-}
-async function portOpen(host, port) {
-    return new Promise((done) => {
-        const socket = createConnection({ host, port: Number(port) });
-        let settled = false;
-        const finish = (open) => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            done(open);
-        };
-        socket.once('connect', () => finish(true));
-        socket.once('error', () => finish(false));
-        socket.setTimeout(250, () => finish(false));
-    });
-}
-function startupLock(host, port) {
-    const name = `${host}-${port}`.replaceAll(/[^a-zA-Z0-9.-]/g, '-');
-    return resolve(tmpdir(), `kennel-hot-viewer-${name}.lock`);
-}
-function openUrl(url) {
-    const command = process.platform === 'darwin' ? '/usr/bin/open' : process.platform === 'win32' ? 'explorer.exe' : 'xdg-open';
-    execFile(command, [url], (error) => {
-        if (error)
-            console.error(`Could not open browser: ${error.message}`);
-    });
-}
-function lanHost() {
-    const route = execFileSync('/sbin/route', ['-n', 'get', 'default'], {
-        encoding: 'utf8',
-    });
-    const device = route.match(/interface:\s+(\S+)/)?.[1];
-    if (!device)
-        throw new Error('kennel could not find the local network interface');
-    const host = execFileSync('/usr/sbin/ipconfig', ['getifaddr', device], {
-        encoding: 'utf8',
-    }).trim();
-    if (!host)
-        throw new Error(`kennel could not find an address for ${device}`);
-    return host;
-}
-async function acquireLock(path) {
-    const token = randomUUID();
-    return mkdir(path)
-        .then(async () => {
-        await writeFile(resolve(path, 'owner'), token);
-        return token;
-    })
-        .catch((error) => {
-        if (error instanceof Error && 'code' in error && error.code === 'EEXIST')
-            return undefined;
-        return Promise.reject(error);
-    });
-}
-async function releaseLock(path, token) {
-    const owner = await readFile(resolve(path, 'owner'), 'utf8').catch(() => '');
-    if (owner !== token)
-        return;
-    await rm(path, { force: true, recursive: true });
-}
-export async function hotViewer(options) {
-    if (options.tailscale) {
-        throw new Error('The hot viewer is not available through Tailscale. Use kennel serve for remote access.');
-    }
-    const root = sourceRoot();
-    const config = resolve(root, 'apps/web/vite.config.ts');
-    if (!existsSync(config)) {
-        throw new Error('The hot viewer requires a Kennel source checkout.');
-    }
-    const args = [
-        'run',
-        '--filter',
-        '@raggle-ai/web',
-        'dev',
-        '--',
-        '--host',
-        options.host,
-        '--port',
-        options.port,
-        '--strictPort',
-    ];
-    const baseQuery = new URLSearchParams({ folder: options.root });
-    const openPath = options.target
-        ? `/?${new URLSearchParams({
-            folder: options.root,
-            document: relative(options.root, options.target),
-            ...(options.watch ? { watch: '1' } : {}),
-        })}`
-        : options.openPath ?? `/?${baseQuery}`;
-    const url = `http://${options.host}:${options.port}`;
-    const displayHost = options.lan ? lanHost() : options.host;
-    // The LAN address is computed before the server starts so the Vite config
-    // (allowedHosts + the API host guard) accepts the phone's Host header.
-    const viewerHosts = [displayHost, 'localhost', '127.0.0.1'].join(',');
-    const viewerUrl = `http://${displayHost}:${options.port}${openPath}`;
-    console.log(`Kennel hot viewer: ${viewerUrl}`);
-    if (options.dryRun) {
-        console.log(`bun ${[...args, ...(options.open ? ['--open', openPath] : [])].join(' ')}`);
-        return;
-    }
-    const plugins = readExternalPlugins();
-    // Must match the key apps/web/scripts/dev.mjs gives Vite as KENNEL_KERNEL_KEY.
-    const expectedKey = plugins.length > 0 ? hotKernelKey(plugins) : 'core';
-    // Reuse only a Vite viewer that serves the same plugin set. Anything else on
-    // the port is stale for this kernel and must be restarted, never reused.
-    const reuse = (running) => {
-        const restart = 'Stop that viewer (Ctrl+C in its terminal) and run this command again, or select another port.';
-        if (running.viewer !== 'kennel-vite') {
-            throw new Error(`Port ${options.port} runs the static Kennel viewer, not the hot viewer. ${restart}`);
-        }
-        if (running.kernelKey !== expectedKey) {
-            throw new Error(`The Kennel hot viewer on port ${options.port} uses kernel ${running.kernelKey}, `
-                + `but the installed plugins need kernel ${expectedKey}. ${restart}`);
-        }
-        if (options.open) {
-            // Do not stack another tab: the viewer is already open. Print the URL
-            // so the caller can still get to it deliberately.
-            console.log(`Kennel hot viewer is already running at ${viewerUrl}`);
-        }
-        else {
-            console.log('Kennel hot viewer is already running. Reusing it.');
-        }
-    };
-    const status = await viewerStatus(url);
-    if (typeof status === 'object') {
-        reuse(status);
-        return;
-    }
-    if (status === 'other') {
-        throw new Error(`Port ${options.port} is used by another service. Stop it or select another port.`);
-    }
-    if (await portOpen(options.host, options.port)) {
-        const running = await runningViewer(url, 20, true);
-        if (running) {
-            reuse(running);
-            return;
-        }
-        throw new Error(`Port ${options.port} is used by another service. Stop it or select another port.`);
-    }
-    const lock = startupLock(options.host, options.port);
-    let token = await acquireLock(lock);
-    if (!token) {
-        const running = await runningViewer(url, 40, true);
-        if (running) {
-            reuse(running);
-            return;
-        }
-        await rm(lock, { force: true, recursive: true });
-        token = await acquireLock(lock);
-    }
-    if (!token)
-        throw new Error(`Could not acquire the hot viewer startup lock for port ${options.port}.`);
-    const running = await runningViewer(url);
-    if (running) {
-        await releaseLock(lock, token);
-        reuse(running);
-        return;
-    }
-    console.log(`bun ${args.join(' ')}`);
-    if (options.open)
-        args.push('--open', openPath);
-    const child = spawn('bun', args, {
-        cwd: root,
-        env: {
-            ...process.env,
-            // Explicit remote bindings (--lan) switch the Vite plugins into
-            // remote mode: realpath root scope, host actions disabled, ACP off.
-            // KENNEL_VIEWER_HOSTS tells the config which Host headers are legit
-            // (DNS-rebinding guard; loopback is always allowed).
-            KENNEL_VIEWER_ROOT: options.root,
-            KENNEL_VIEWER_REMOTE: options.lan ? '1' : '0',
-            KENNEL_VIEWER_HOSTS: viewerHosts,
-            // Single-file pop mode: the plugin locks document reads to exactly this
-            // file (siblings are not previewable in the hot viewer either).
-            ...(options.target ? { KENNEL_VIEWER_TARGET: options.target } : {}),
-            LC_ALL: 'en_GB.UTF-8',
-        },
-        stdio: 'inherit',
-    });
-    await new Promise((done, fail) => {
-        child.once('error', fail);
-        child.once('exit', async (code, signal) => {
-            if (code === 0 || signal === 'SIGINT' || signal === 'SIGTERM') {
-                done();
-                return;
-            }
-            const existing = await runningViewer(url, 20, true);
-            if (existing) {
-                try {
-                    reuse(existing);
-                    done();
-                }
-                catch (error) {
-                    fail(error);
-                }
-                return;
-            }
-            fail(new Error(`Kennel hot viewer stopped with exit code ${code ?? 'unknown'}`));
-        });
-    }).finally(() => releaseLock(lock, token));
-}

package/dist/cli/src/site/kinds.d.ts

@@ -1 +0,0 @@
-export * from "@raggle-ai/kennel-preview/kinds";

package/dist/cli/src/site/kinds.js

@@ -1 +0,0 @@
-export * from "@raggle-ai/kennel-preview/kinds";

package/dist/cli/src/site/mail.d.ts

@@ -1 +0,0 @@
-export declare function mail(args: string[]): Promise<void>;