@jsonstudio/rcc 0.89.1803 → 0.89.1959

package/dist/cli/commands/launcher-kernel.js

@@ -0,0 +1,1194 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createServer } from 'node:http';
+import crypto from 'node:crypto';
+import { LOCAL_HOSTS } from '../../constants/index.js';
+import { encodeClockClientApiKey } from '../../utils/clock-client-token.js';
+import { logProcessLifecycle } from '../../utils/process-lifecycle-logger.js';
+function resolveBinary(options) {
+    const raw = String(options.command || '').trim();
+    if (!raw) {
+        return '';
+    }
+    if (raw.includes('/') || raw.includes('\\')) {
+        return raw;
+    }
+    const candidates = [];
+    try {
+        candidates.push(options.pathImpl.join('/opt/homebrew/bin', raw));
+    }
+    catch {
+        // ignore
+    }
+    try {
+        candidates.push(options.pathImpl.join('/usr/local/bin', raw));
+    }
+    catch {
+        // ignore
+    }
+    try {
+        candidates.push(options.pathImpl.join(options.homedir(), '.local', 'bin', raw));
+    }
+    catch {
+        // ignore
+    }
+    for (const candidate of candidates) {
+        try {
+            if (candidate && options.fsImpl.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return raw;
+}
+function parseServerUrl(raw) {
+    const trimmed = String(raw || '').trim();
+    if (!trimmed) {
+        throw new Error('--url is empty');
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        parsed = new URL(`http://${trimmed}`);
+    }
+    const protocol = parsed.protocol === 'https:' ? 'https' : 'http';
+    const host = parsed.hostname;
+    const hasExplicitPort = Boolean(parsed.port && parsed.port.trim());
+    const port = hasExplicitPort ? Number(parsed.port) : null;
+    const rawPath = typeof parsed.pathname === 'string' ? parsed.pathname : '';
+    const basePath = rawPath && rawPath !== '/' ? rawPath.replace(/\/+$/, '') : '';
+    return { protocol, host, port: Number.isFinite(port) ? port : null, basePath };
+}
+function readConfigApiKey(fsImpl, configPath) {
+    try {
+        if (!configPath || !fsImpl.existsSync(configPath)) {
+            return null;
+        }
+        const txt = fsImpl.readFileSync(configPath, 'utf8');
+        const cfg = JSON.parse(txt);
+        const direct = cfg?.httpserver?.apikey ?? cfg?.modules?.httpserver?.config?.apikey ?? cfg?.server?.apikey;
+        const value = typeof direct === 'string' ? direct.trim() : '';
+        return value ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeConnectHost(host) {
+    const value = String(host || '').toLowerCase();
+    if (value === '0.0.0.0') {
+        return '0.0.0.0';
+    }
+    if (value === '::' || value === '::1' || value === 'localhost') {
+        return '0.0.0.0';
+    }
+    return host || '0.0.0.0';
+}
+function toIntegerPort(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return null;
+}
+function tryReadConfigHostPort(fsImpl, configPath) {
+    if (!configPath || !fsImpl.existsSync(configPath)) {
+        return { host: null, port: null };
+    }
+    try {
+        const configContent = fsImpl.readFileSync(configPath, 'utf8');
+        const config = JSON.parse(configContent);
+        const port = toIntegerPort(config?.httpserver?.port ?? config?.server?.port ?? config?.port);
+        const hostRaw = config?.httpserver?.host ?? config?.server?.host ?? config?.host;
+        const host = typeof hostRaw === 'string' && hostRaw.trim() ? hostRaw.trim() : null;
+        return { host, port };
+    }
+    catch {
+        return { host: null, port: null };
+    }
+}
+function resolveServerConnection(ctx, fsImpl, pathImpl, options) {
+    let configPath = typeof options.config === 'string' && options.config.trim() ? options.config.trim() : '';
+    if (!configPath) {
+        configPath = pathImpl.join(ctx.homedir(), '.routecodex', 'config.json');
+    }
+    let actualProtocol = 'http';
+    let actualPort = toIntegerPort(options.port);
+    let actualHost = typeof options.host === 'string' && options.host.trim() ? options.host.trim() : LOCAL_HOSTS.ANY;
+    let actualBasePath = '';
+    if (typeof options.url === 'string' && options.url.trim()) {
+        const parsed = parseServerUrl(options.url);
+        actualProtocol = parsed.protocol;
+        actualHost = parsed.host || actualHost;
+        actualPort = parsed.port ?? actualPort;
+        actualBasePath = parsed.basePath;
+    }
+    if (!(typeof options.url === 'string' && options.url.trim())) {
+        if (!actualPort) {
+            const configMaybe = tryReadConfigHostPort(fsImpl, configPath);
+            if (configMaybe.port) {
+                actualPort = configMaybe.port;
+            }
+            if (configMaybe.host) {
+                actualHost = configMaybe.host;
+            }
+        }
+        if (!actualPort) {
+            const envPort = toIntegerPort(ctx.env.ROUTECODEX_PORT || ctx.env.RCC_PORT);
+            if (envPort) {
+                actualPort = envPort;
+            }
+        }
+        if (!actualPort && ctx.isDevPackage) {
+            actualPort = ctx.defaultDevPort;
+            ctx.logger.info(`Using dev default port ${actualPort} for routecodex launcher mode`);
+        }
+    }
+    if (!(typeof options.url === 'string' && options.url.trim()) && !actualPort) {
+        throw new Error('Invalid or missing port configuration for RouteCodex server');
+    }
+    const configuredApiKey = (typeof options.apikey === 'string' && options.apikey.trim() ? options.apikey.trim() : null) ??
+        (typeof ctx.env.ROUTECODEX_APIKEY === 'string' && ctx.env.ROUTECODEX_APIKEY.trim()
+            ? ctx.env.ROUTECODEX_APIKEY.trim()
+            : null) ??
+        (typeof ctx.env.RCC_APIKEY === 'string' && ctx.env.RCC_APIKEY.trim() ? ctx.env.RCC_APIKEY.trim() : null) ??
+        readConfigApiKey(fsImpl, configPath);
+    const connectHost = normalizeConnectHost(actualHost);
+    const portPart = actualPort ? `:${actualPort}` : '';
+    const serverUrl = `${actualProtocol}://${connectHost}${portPart}${actualBasePath}`;
+    return {
+        configPath,
+        protocol: actualProtocol,
+        host: actualHost,
+        connectHost,
+        port: actualPort,
+        basePath: actualBasePath,
+        portPart,
+        serverUrl,
+        configuredApiKey
+    };
+}
+async function checkServerReady(ctx, serverUrl, apiKey, timeoutMs = 2500) {
+    try {
+        const headers = apiKey ? { 'x-api-key': apiKey } : undefined;
+        const probe = async (pathSuffix) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await ctx.fetch(`${serverUrl}${pathSuffix}`, {
+                    signal: controller.signal,
+                    method: 'GET',
+                    headers
+                }).catch(() => null);
+                if (!response || !response.ok) {
+                    return { ok: false, body: null };
+                }
+                const body = await response.json().catch(() => null);
+                return { ok: true, body };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        };
+        const readyProbe = await probe('/ready');
+        if (readyProbe.ok) {
+            const status = typeof readyProbe.body?.status === 'string' ? readyProbe.body.status : '';
+            if (status.toLowerCase() === 'ready' || readyProbe.body?.ready === true) {
+                return true;
+            }
+        }
+        const healthProbe = await probe('/health');
+        if (!healthProbe.ok) {
+            return false;
+        }
+        const status = typeof healthProbe.body?.status === 'string' ? healthProbe.body.status.toLowerCase() : '';
+        return status === 'ok' || status === 'ready' || healthProbe.body?.ready === true || healthProbe.body?.pipelineReady === true;
+    }
+    catch {
+        return false;
+    }
+}
+function rotateLogFile(fsImpl, filePath, maxBytes = 8 * 1024 * 1024, maxBackups = 3) {
+    try {
+        if (!fsImpl.existsSync(filePath)) {
+            return;
+        }
+        const stat = fsImpl.statSync(filePath);
+        if (!stat.isFile() || stat.size < maxBytes) {
+            return;
+        }
+        for (let index = maxBackups - 1; index >= 1; index--) {
+            const from = `${filePath}.${index}`;
+            const to = `${filePath}.${index + 1}`;
+            try {
+                if (fsImpl.existsSync(from)) {
+                    if (fsImpl.existsSync(to)) {
+                        fsImpl.unlinkSync(to);
+                    }
+                    fsImpl.renameSync(from, to);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const firstBackup = `${filePath}.1`;
+        if (fsImpl.existsSync(firstBackup)) {
+            try {
+                fsImpl.unlinkSync(firstBackup);
+            }
+            catch {
+                // ignore
+            }
+        }
+        fsImpl.renameSync(filePath, firstBackup);
+    }
+    catch {
+        // ignore rotation failures
+    }
+}
+function ensureServerLogPath(ctx, fsImpl, pathImpl, port) {
+    const logsDir = pathImpl.join(ctx.homedir(), '.routecodex', 'logs');
+    fsImpl.mkdirSync(logsDir, { recursive: true });
+    const logPath = pathImpl.join(logsDir, `server-${port}.log`);
+    rotateLogFile(fsImpl, logPath);
+    return logPath;
+}
+async function ensureServerReady(ctx, fsImpl, pathImpl, spinner, options, resolved) {
+    const alreadyReady = await checkServerReady(ctx, resolved.serverUrl, resolved.configuredApiKey);
+    if (alreadyReady) {
+        return { started: false };
+    }
+    const hasExplicitUrl = typeof options.url === 'string' && options.url.trim().length > 0;
+    if (hasExplicitUrl) {
+        throw new Error('RouteCodex server is not reachable with --url; auto-start is disabled for explicit URLs');
+    }
+    spinner.info('RouteCodex server is not running, starting it in background...');
+    const logPath = ensureServerLogPath(ctx, fsImpl, pathImpl, resolved.port);
+    const logFd = fsImpl.openSync(logPath, 'a');
+    const env = {
+        ...ctx.env,
+        ROUTECODEX_CONFIG: resolved.configPath,
+        ROUTECODEX_CONFIG_PATH: resolved.configPath,
+        ROUTECODEX_PORT: String(resolved.port),
+        RCC_PORT: String(resolved.port)
+    };
+    logProcessLifecycle({
+        event: 'detached_spawn',
+        source: 'cli.launcher.ensureServerReady',
+        details: {
+            role: 'routecodex-server',
+            result: 'attempt',
+            port: resolved.port,
+            command: ctx.nodeBin,
+            args: [ctx.resolveServerEntryPath(), ctx.getModulesConfigPath()],
+            logPath
+        }
+    });
+    try {
+        try {
+            const serverProcess = ctx.spawn(ctx.nodeBin, [ctx.resolveServerEntryPath(), ctx.getModulesConfigPath()], {
+                stdio: ['ignore', logFd, logFd],
+                env,
+                detached: true
+            });
+            logProcessLifecycle({
+                event: 'detached_spawn',
+                source: 'cli.launcher.ensureServerReady',
+                details: {
+                    role: 'routecodex-server',
+                    result: 'success',
+                    port: resolved.port,
+                    command: ctx.nodeBin,
+                    args: [ctx.resolveServerEntryPath(), ctx.getModulesConfigPath()],
+                    childPid: serverProcess.pid ?? null,
+                    logPath
+                }
+            });
+            const onChildError = (error) => {
+                logProcessLifecycle({
+                    event: 'detached_spawn',
+                    source: 'cli.launcher.ensureServerReady',
+                    details: {
+                        role: 'routecodex-server',
+                        result: 'failed',
+                        port: resolved.port,
+                        command: ctx.nodeBin,
+                        args: [ctx.resolveServerEntryPath(), ctx.getModulesConfigPath()],
+                        childPid: serverProcess.pid ?? null,
+                        logPath,
+                        error
+                    }
+                });
+            };
+            if (typeof serverProcess.once === 'function') {
+                serverProcess.once('error', onChildError);
+            }
+            else if (typeof serverProcess.on === 'function') {
+                serverProcess.on('error', onChildError);
+            }
+            try {
+                serverProcess.unref?.();
+            }
+            catch {
+                // ignore
+            }
+        }
+        catch (error) {
+            logProcessLifecycle({
+                event: 'detached_spawn',
+                source: 'cli.launcher.ensureServerReady',
+                details: {
+                    role: 'routecodex-server',
+                    result: 'failed',
+                    port: resolved.port,
+                    command: ctx.nodeBin,
+                    args: [ctx.resolveServerEntryPath(), ctx.getModulesConfigPath()],
+                    logPath,
+                    error
+                }
+            });
+            throw error;
+        }
+    }
+    finally {
+        try {
+            fsImpl.closeSync(logFd);
+        }
+        catch {
+            // ignore
+        }
+    }
+    spinner.text = 'Waiting for RouteCodex server to become ready...';
+    for (let attempt = 0; attempt < 45; attempt++) {
+        await ctx.sleep(1000);
+        const ready = await checkServerReady(ctx, resolved.serverUrl, resolved.configuredApiKey, 1500);
+        if (ready) {
+            return { started: true, logPath };
+        }
+    }
+    logProcessLifecycle({
+        event: 'detached_spawn',
+        source: 'cli.launcher.ensureServerReady',
+        details: {
+            role: 'routecodex-server',
+            result: 'not_ready_timeout',
+            port: resolved.port,
+            logPath
+        }
+    });
+    throw new Error(`RouteCodex server did not become ready in time. Check logs: ${logPath}`);
+}
+function resolveWorkingDirectory(ctx, fsImpl, pathImpl, requested) {
+    const getCwd = ctx.cwd ?? (() => process.cwd());
+    try {
+        const candidate = requested ? String(requested) : getCwd();
+        const resolved = pathImpl.resolve(candidate);
+        if (fsImpl.existsSync(resolved)) {
+            return resolved;
+        }
+    }
+    catch {
+        return getCwd();
+    }
+    return getCwd();
+}
+function isTmuxAvailable(spawnSyncImpl = spawnSync) {
+    try {
+        const result = spawnSyncImpl('tmux', ['-V'], { encoding: 'utf8' });
+        return result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveCurrentTmuxTarget(env, spawnSyncImpl = spawnSync) {
+    const tmuxEnv = typeof env.TMUX === 'string' ? env.TMUX.trim() : '';
+    if (!tmuxEnv) {
+        return null;
+    }
+    try {
+        const result = spawnSyncImpl('tmux', ['display-message', '-p', '#S:#I.#P'], { encoding: 'utf8' });
+        if (result.status !== 0) {
+            return null;
+        }
+        const target = String(result.stdout || '').trim();
+        return target || null;
+    }
+    catch {
+        return null;
+    }
+}
+function isReusableTmuxPaneTarget(spawnSyncImpl, tmuxTarget, cwd) {
+    const normalizedTarget = String(tmuxTarget || '').trim();
+    if (!normalizedTarget) {
+        return false;
+    }
+    const expectedCwd = normalizePathForComparison(cwd);
+    if (!expectedCwd) {
+        return false;
+    }
+    try {
+        const paneResult = spawnSyncImpl('tmux', ['list-panes', '-t', normalizedTarget, '-F', '#{pane_current_command}\t#{pane_current_path}'], { encoding: 'utf8' });
+        if (paneResult.status !== 0) {
+            return false;
+        }
+        const firstLine = String(paneResult.stdout || '')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find(Boolean);
+        if (!firstLine) {
+            return false;
+        }
+        const [command, panePath] = firstLine.split('\t');
+        const normalizedPanePath = normalizePathForComparison(String(panePath || '').trim());
+        return isReusableIdlePaneCommand(String(command || '').trim()) && normalizedPanePath === expectedCwd;
+    }
+    catch {
+        return false;
+    }
+}
+function shellQuote(value) {
+    return `'${String(value ?? '').replace(/'/g, `'"'"'`)}'`;
+}
+function buildShellCommand(tokens) {
+    return tokens.map((token) => shellQuote(token)).join(' ');
+}
+function collectChangedEnv(baseEnv, nextEnv) {
+    const out = [];
+    for (const [key, value] of Object.entries(nextEnv)) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        if (baseEnv[key] !== value) {
+            out.push([key, value]);
+        }
+    }
+    return out;
+}
+function sendTmuxSubmitKey(spawnSyncImpl, tmuxTarget, clientType) {
+    const type = String(clientType || '').trim().toLowerCase();
+    const submitKeys = type === 'codex' || type === 'claude'
+        ? ['Enter', 'C-m', 'KPEnter']
+        : ['Enter', 'C-m'];
+    let lastError = '';
+    for (const submitKey of submitKeys) {
+        try {
+            const result = spawnSyncImpl('tmux', ['send-keys', '-t', tmuxTarget, submitKey], { encoding: 'utf8' });
+            if (result.status === 0) {
+                return { ok: true };
+            }
+            lastError =
+                String(result.stderr || result.stdout || `tmux send-keys ${submitKey} failed`).trim()
+                    || `tmux send-keys ${submitKey} failed`;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error ?? `tmux send-keys ${submitKey} failed`);
+        }
+    }
+    return { ok: false, error: lastError || 'tmux send-keys submit failed' };
+}
+function isReusableIdlePaneCommand(command) {
+    const normalized = String(command || '').trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    return normalized === 'zsh'
+        || normalized === 'bash'
+        || normalized === 'sh'
+        || normalized === 'fish'
+        || normalized === 'nu';
+}
+function normalizeSessionToken(value) {
+    return String(value || '').replace(/[^a-zA-Z0-9_-]+/g, '_') || 'launcher';
+}
+function normalizePathForComparison(candidate) {
+    const raw = String(candidate || '').trim();
+    if (!raw) {
+        return '';
+    }
+    try {
+        const resolved = path.resolve(raw).replace(/[\\/]+$/, '');
+        if (process.platform === 'win32') {
+            return resolved.toLowerCase();
+        }
+        return resolved;
+    }
+    catch {
+        return raw;
+    }
+}
+function findReusableManagedTmuxSession(spawnSyncImpl, cwd, commandName) {
+    const expectedCwd = normalizePathForComparison(cwd);
+    const expectedSessionPrefix = `rcc_${normalizeSessionToken(commandName)}_`;
+    try {
+        const listResult = spawnSyncImpl('tmux', ['list-sessions', '-F', '#S	#{session_attached}'], { encoding: 'utf8' });
+        if (listResult.status !== 0) {
+            return null;
+        }
+        const lines = String(listResult.stdout || '')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        for (const line of lines) {
+            const [sessionName, attachedFlag] = line.split('	');
+            const normalizedName = String(sessionName || '').trim();
+            if (!normalizedName.startsWith(expectedSessionPrefix)) {
+                continue;
+            }
+            if (String(attachedFlag || '').trim() === '1') {
+                continue;
+            }
+            const panesResult = spawnSyncImpl('tmux', [
+                'list-panes',
+                '-t',
+                normalizedName,
+                '-F',
+                '#{session_name}:#{window_index}.#{pane_index}	#{pane_current_command}	#{pane_current_path}'
+            ], { encoding: 'utf8' });
+            if (panesResult.status !== 0) {
+                continue;
+            }
+            const panes = String(panesResult.stdout || '')
+                .split(/\r?\n/)
+                .map((paneLine) => paneLine.trim())
+                .filter(Boolean);
+            for (const pane of panes) {
+                const [target, command, panePath] = pane.split('	');
+                const tmuxTarget = String(target || '').trim();
+                const currentCommand = String(command || '').trim().toLowerCase();
+                const normalizedPanePath = normalizePathForComparison(String(panePath || '').trim());
+                if (!tmuxTarget) {
+                    continue;
+                }
+                if (!isReusableIdlePaneCommand(currentCommand)) {
+                    continue;
+                }
+                if (!normalizedPanePath || normalizedPanePath !== expectedCwd) {
+                    continue;
+                }
+                return { sessionName: normalizedName, tmuxTarget };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function createManagedTmuxSession(args) {
+    const { spawnSyncImpl, cwd, commandName } = args;
+    const reusable = findReusableManagedTmuxSession(spawnSyncImpl, cwd, commandName);
+    if (reusable) {
+        return {
+            sessionName: reusable.sessionName,
+            tmuxTarget: reusable.tmuxTarget,
+            reused: true,
+            stop: () => {
+                try {
+                    spawnSyncImpl('tmux', ['kill-session', '-t', reusable.sessionName], { encoding: 'utf8' });
+                }
+                catch {
+                    // ignore
+                }
+            }
+        };
+    }
+    const sessionName = (() => {
+        const token = normalizeSessionToken(commandName);
+        return `rcc_${token}_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
+    })();
+    try {
+        const result = spawnSyncImpl('tmux', ['new-session', '-d', '-s', sessionName, '-c', cwd], { encoding: 'utf8' });
+        if (result.status !== 0) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    const tmuxTarget = `${sessionName}:0.0`;
+    return {
+        sessionName,
+        tmuxTarget,
+        reused: false,
+        stop: () => {
+            try {
+                spawnSyncImpl('tmux', ['kill-session', '-t', sessionName], { encoding: 'utf8' });
+            }
+            catch {
+                // ignore
+            }
+        }
+    };
+}
+function launchCommandInTmuxPane(args) {
+    const { spawnSyncImpl, tmuxTarget, cwd, command, commandArgs, envOverrides, managedSessionName } = args;
+    const envTokens = envOverrides.map(([key, value]) => `${key}=${value}`);
+    const baseCommand = `cd -- ${shellQuote(cwd)} && ${buildShellCommand(['env', ...envTokens, command, ...commandArgs])}`;
+    const shellCommand = managedSessionName
+        ? `${baseCommand}; __rcc_exit=$?; tmux kill-session -t ${shellQuote(managedSessionName)} >/dev/null 2>&1; exit $__rcc_exit`
+        : baseCommand;
+    try {
+        const literal = spawnSyncImpl('tmux', ['send-keys', '-t', tmuxTarget, '-l', '--', shellCommand], { encoding: 'utf8' });
+        if (literal.status !== 0) {
+            return false;
+        }
+        const submit = sendTmuxSubmitKey(spawnSyncImpl, tmuxTarget);
+        return submit.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function readJsonBody(req) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        req.on('data', (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        });
+        req.on('end', () => {
+            if (!chunks.length) {
+                resolve({});
+                return;
+            }
+            try {
+                const payload = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                resolve(payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : {});
+            }
+            catch {
+                resolve({});
+            }
+        });
+        req.on('error', () => resolve({}));
+    });
+}
+function sendJson(res, status, payload) {
+    const body = JSON.stringify(payload);
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(body);
+}
+async function startClockClientService(args) {
+    const { ctx, resolved, tmuxTarget, spawnSyncImpl, clientType, managedTmuxSession, getManagedProcessState } = args;
+    const daemonId = (() => {
+        try {
+            return `clockd_${crypto.randomUUID()}`;
+        }
+        catch {
+            return `clockd_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+        }
+    })();
+    const normalizedTmuxTarget = String(tmuxTarget || '').trim();
+    const tmuxSessionId = (() => {
+        if (!normalizedTmuxTarget) {
+            return daemonId;
+        }
+        const idx = normalizedTmuxTarget.indexOf(':');
+        const candidate = (idx >= 0 ? normalizedTmuxTarget.slice(0, idx) : normalizedTmuxTarget).trim();
+        return candidate || daemonId;
+    })();
+    let server = null;
+    let callbackUrl = 'http://127.0.0.1:0/inject';
+    if (normalizedTmuxTarget) {
+        server = createServer(async (req, res) => {
+            if (req.method !== 'POST' || req.url !== '/inject') {
+                sendJson(res, 404, { ok: false, message: 'not_found' });
+                return;
+            }
+            const body = await readJsonBody(req);
+            const text = typeof body.text === 'string' ? body.text.trim() : '';
+            if (!text) {
+                sendJson(res, 400, { ok: false, message: 'text is required' });
+                return;
+            }
+            try {
+                const literal = spawnSyncImpl('tmux', ['send-keys', '-t', normalizedTmuxTarget, '-l', '--', text], { encoding: 'utf8' });
+                if (literal.status !== 0) {
+                    sendJson(res, 500, {
+                        ok: false,
+                        message: String(literal.stderr || literal.stdout || 'tmux send-keys failed').trim() || 'tmux send-keys failed'
+                    });
+                    return;
+                }
+                await ctx.sleep(80);
+                const submit = sendTmuxSubmitKey(spawnSyncImpl, normalizedTmuxTarget, clientType);
+                if (!submit.ok) {
+                    sendJson(res, 500, {
+                        ok: false,
+                        message: submit.error
+                    });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, tmuxTarget: normalizedTmuxTarget });
+            }
+            catch (error) {
+                sendJson(res, 500, { ok: false, message: error instanceof Error ? error.message : String(error ?? 'unknown') });
+            }
+        });
+        const port = await new Promise((resolve, reject) => {
+            server?.once('error', reject);
+            server?.listen(0, '127.0.0.1', () => {
+                const address = server?.address();
+                if (!address || typeof address === 'string') {
+                    reject(new Error('failed to resolve clock daemon callback address'));
+                    return;
+                }
+                resolve(address.port);
+            });
+        }).catch(() => 0);
+        if (!port) {
+            try {
+                server.close();
+            }
+            catch {
+                // ignore
+            }
+            return null;
+        }
+        callbackUrl = `http://127.0.0.1:${port}/inject`;
+    }
+    const controlUrl = `${resolved.protocol}://127.0.0.1:${resolved.port}${resolved.basePath}`;
+    const normalizeManagedProcessPayload = () => {
+        const state = typeof getManagedProcessState === 'function' ? getManagedProcessState() : undefined;
+        const managedClientProcess = state?.managedClientProcess === true;
+        const managedClientPid = typeof state?.managedClientPid === 'number' && Number.isFinite(state.managedClientPid) && state.managedClientPid > 0
+            ? Math.floor(state.managedClientPid)
+            : undefined;
+        const managedClientCommandHint = typeof state?.managedClientCommandHint === 'string' && state.managedClientCommandHint.trim()
+            ? state.managedClientCommandHint.trim()
+            : undefined;
+        return {
+            ...(managedClientProcess ? { managedClientProcess: true } : {}),
+            ...(managedClientPid ? { managedClientPid } : {}),
+            ...(managedClientCommandHint ? { managedClientCommandHint } : {})
+        };
+    };
+    const post = async (pathSuffix, payload) => {
+        try {
+            const response = await ctx.fetch(`${controlUrl}${pathSuffix}`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    };
+    const syncHeartbeat = async () => {
+        return await post('/daemon/clock-client/heartbeat', {
+            daemonId,
+            tmuxSessionId,
+            sessionId: tmuxSessionId,
+            managedTmuxSession,
+            ...normalizeManagedProcessPayload()
+        });
+    };
+    const registered = await post('/daemon/clock-client/register', {
+        daemonId,
+        tmuxSessionId,
+        sessionId: tmuxSessionId,
+        clientType,
+        ...(normalizedTmuxTarget ? { tmuxTarget: normalizedTmuxTarget } : {}),
+        managedTmuxSession,
+        callbackUrl,
+        ...normalizeManagedProcessPayload()
+    });
+    if (!registered) {
+        if (server) {
+            try {
+                server.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        return null;
+    }
+    const heartbeat = setInterval(() => {
+        void syncHeartbeat();
+    }, 10_000);
+    heartbeat.unref?.();
+    return {
+        daemonId,
+        tmuxSessionId,
+        ...(normalizedTmuxTarget ? { tmuxTarget: normalizedTmuxTarget } : {}),
+        syncHeartbeat,
+        stop: async () => {
+            clearInterval(heartbeat);
+            await post('/daemon/clock-client/unregister', { daemonId });
+            if (!server) {
+                return;
+            }
+            await new Promise((resolve) => {
+                try {
+                    server?.close(() => resolve());
+                }
+                catch {
+                    resolve();
+                }
+            });
+        }
+    };
+}
+function collectPassThroughArgs(args) {
+    const { rawArgv, commandName, knownOptions, requiredValueOptions, extraArgsFromCommander } = args;
+    const indexCommand = rawArgv.findIndex((token) => token === commandName);
+    const afterCommand = indexCommand >= 0 ? rawArgv.slice(indexCommand + 1) : [];
+    const separatorIndex = afterCommand.indexOf('--');
+    const tail = separatorIndex >= 0 ? afterCommand.slice(separatorIndex + 1) : afterCommand;
+    const passThrough = [];
+    for (let index = 0; index < tail.length; index++) {
+        const token = tail[index];
+        if (knownOptions.has(token)) {
+            if (requiredValueOptions.has(token)) {
+                index += 1;
+            }
+            continue;
+        }
+        if (token.startsWith('--')) {
+            const equalIndex = token.indexOf('=');
+            if (equalIndex > 2) {
+                const optionName = token.slice(0, equalIndex);
+                if (knownOptions.has(optionName)) {
+                    continue;
+                }
+            }
+        }
+        passThrough.push(token);
+    }
+    const merged = [];
+    const seen = new Set();
+    const appendUnique = (values) => {
+        for (const value of values) {
+            if (!seen.has(value)) {
+                seen.add(value);
+                merged.push(value);
+            }
+        }
+    };
+    appendUnique(extraArgsFromCommander);
+    appendUnique(passThrough);
+    return merged;
+}
+function normalizeOpenAiBaseUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    if (trimmed.endsWith('/v1')) {
+        return trimmed;
+    }
+    return `${trimmed}/v1`;
+}
+export function createLauncherCommand(program, ctx, spec) {
+    const fsImpl = ctx.fsImpl ?? fs;
+    const pathImpl = ctx.pathImpl ?? path;
+    const command = program
+        .command(spec.commandName)
+        .description(spec.description)
+        .option('--port <port>', 'RouteCodex server port (overrides config file)')
+        .option('-h, --host <host>', 'RouteCodex server host', LOCAL_HOSTS.ANY)
+        .option('--url <url>', 'RouteCodex base URL (overrides host/port), e.g. https://proxy.example.com')
+        .option('-c, --config <config>', 'RouteCodex configuration file path')
+        .option('--apikey <apikey>', 'RouteCodex server apikey (defaults to httpserver.apikey in config when present)')
+        .option('--cwd <dir>', `Working directory for ${spec.displayName} (defaults to current shell cwd)`)
+        .option('--ensure-server', 'Ensure RouteCodex server is running before launching')
+        .option(spec.binaryOptionFlags, spec.binaryOptionDescription, spec.binaryDefault)
+        .argument('[extraArgs...]', `Additional args to pass through to ${spec.displayName}`)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true);
+    if (spec.withModelOption) {
+        command.option('--model <model>', `Model to use with ${spec.displayName}`);
+    }
+    if (spec.withProfileOption) {
+        command.option('--profile <profile>', `${spec.displayName} profile to use`);
+    }
+    command.action(async (extraArgs = [], options) => {
+        const spinner = await ctx.createSpinner(`Preparing ${spec.displayName} with RouteCodex...`);
+        try {
+            const resolved = resolveServerConnection(ctx, fsImpl, pathImpl, options);
+            const ensureResult = await ensureServerReady(ctx, fsImpl, pathImpl, spinner, options, resolved);
+            spinner.text = `Launching ${spec.displayName}...`;
+            const baseUrl = `${resolved.protocol}://${resolved.connectHost}${resolved.portPart}${resolved.basePath}`;
+            const currentCwd = resolveWorkingDirectory(ctx, fsImpl, pathImpl, options.cwd);
+            const spawnSyncImpl = ctx.spawnSyncImpl ?? spawnSync;
+            const toolArgs = spec.buildArgs(options);
+            const knownOptions = new Set([
+                '--port',
+                '-h',
+                '--host',
+                '--url',
+                '-c',
+                '--config',
+                '--apikey',
+                '--cwd',
+                '--ensure-server',
+                ...spec.extraKnownOptions
+            ]);
+            const requiredValueOptions = new Set([
+                '--port',
+                '-h',
+                '--host',
+                '--url',
+                '-c',
+                '--config',
+                '--apikey',
+                '--cwd',
+                ...spec.extraKnownOptions
+            ]);
+            const passThroughArgs = collectPassThroughArgs({
+                rawArgv: Array.isArray(ctx.rawArgv) ? ctx.rawArgv : [],
+                commandName: spec.commandName,
+                knownOptions,
+                requiredValueOptions,
+                extraArgsFromCommander: Array.isArray(extraArgs) ? extraArgs : []
+            });
+            if (passThroughArgs.length) {
+                toolArgs.push(...passThroughArgs);
+            }
+            const binaryCandidate = (() => {
+                const fromOption = String(options[spec.binaryOptionName] ?? '').trim();
+                if (fromOption) {
+                    return fromOption;
+                }
+                if (spec.binaryEnvKey) {
+                    const fromEnv = String(ctx.env[spec.binaryEnvKey] || '').trim();
+                    if (fromEnv) {
+                        return fromEnv;
+                    }
+                }
+                return spec.binaryDefault;
+            })();
+            const resolvedBinary = resolveBinary({
+                fsImpl,
+                pathImpl,
+                homedir: ctx.homedir,
+                command: binaryCandidate
+            });
+            let managedTmuxSession = null;
+            const tmuxEnabled = isTmuxAvailable(spawnSyncImpl);
+            if (!tmuxEnabled) {
+                ctx.logger.warning('[clock-advanced] tmux not found; advanced clock client service disabled (launcher will continue).');
+            }
+            let tmuxTarget = tmuxEnabled ? resolveCurrentTmuxTarget(ctx.env, spawnSyncImpl) : null;
+            if (tmuxTarget && !isReusableTmuxPaneTarget(spawnSyncImpl, tmuxTarget, currentCwd)) {
+                tmuxTarget = null;
+            }
+            if (tmuxEnabled && !tmuxTarget) {
+                managedTmuxSession = createManagedTmuxSession({
+                    spawnSyncImpl,
+                    cwd: currentCwd,
+                    commandName: spec.commandName
+                });
+                if (managedTmuxSession) {
+                    tmuxTarget = managedTmuxSession.tmuxTarget;
+                    if (managedTmuxSession.reused) {
+                        ctx.logger.info('[clock-advanced] reused existing managed tmux session and rebound launcher automatically.');
+                    }
+                    else {
+                        ctx.logger.info('[clock-advanced] started managed tmux session automatically; no manual tmux setup needed.');
+                    }
+                }
+                else {
+                    ctx.logger.warning('[clock-advanced] failed to start managed tmux session; launcher continues without advanced mode.');
+                }
+            }
+            const managedClientProcessEnabled = !managedTmuxSession;
+            let managedClientPid = null;
+            const managedClientCommandHint = managedClientProcessEnabled ? resolvedBinary : undefined;
+            const reclaimRequiredRaw = String(ctx.env.ROUTECODEX_CLOCK_RECLAIM_REQUIRED
+                ?? ctx.env.RCC_CLOCK_RECLAIM_REQUIRED
+                ?? '1')
+                .trim()
+                .toLowerCase();
+            const reclaimRequired = reclaimRequiredRaw !== '0' && reclaimRequiredRaw !== 'false' && reclaimRequiredRaw !== 'no';
+            const clockClientService = await startClockClientService({
+                ctx,
+                resolved,
+                tmuxTarget,
+                spawnSyncImpl,
+                clientType: spec.commandName,
+                managedTmuxSession: Boolean(managedTmuxSession),
+                getManagedProcessState: () => ({
+                    managedClientProcess: managedClientProcessEnabled,
+                    managedClientPid,
+                    managedClientCommandHint
+                })
+            });
+            if (managedClientProcessEnabled && reclaimRequired && !clockClientService) {
+                throw new Error('clock client registration failed for managed child process; aborting launch to avoid orphan process');
+            }
+            if (tmuxTarget && !clockClientService) {
+                ctx.logger.warning('[clock-advanced] failed to start clock client daemon service; launcher continues without advanced mode.');
+            }
+            const clockAdvancedEnabled = Boolean(clockClientService && tmuxTarget);
+            const clockClientApiKey = clockAdvancedEnabled && clockClientService
+                ? encodeClockClientApiKey(resolved.configuredApiKey || 'rcc-proxy-key', clockClientService.daemonId)
+                : (resolved.configuredApiKey || 'rcc-proxy-key');
+            const toolEnv = spec.buildEnv({
+                env: {
+                    ...ctx.env,
+                    PWD: currentCwd,
+                    RCC_WORKDIR: currentCwd,
+                    ROUTECODEX_WORKDIR: currentCwd,
+                    OPENAI_BASE_URL: normalizeOpenAiBaseUrl(baseUrl),
+                    OPENAI_API_BASE: normalizeOpenAiBaseUrl(baseUrl),
+                    OPENAI_API_BASE_URL: normalizeOpenAiBaseUrl(baseUrl),
+                    OPENAI_API_KEY: clockClientApiKey,
+                    RCC_CLOCK_ADVANCED_ENABLED: clockAdvancedEnabled ? '1' : '0',
+                    ...(clockAdvancedEnabled && clockClientService
+                        ? {
+                            RCC_CLOCK_CLIENT_SESSION_ID: clockClientService.tmuxSessionId,
+                            RCC_CLOCK_CLIENT_TMUX_SESSION_ID: clockClientService.tmuxSessionId,
+                            RCC_CLOCK_CLIENT_DAEMON_ID: clockClientService.daemonId
+                        }
+                        : {})
+                },
+                baseUrl,
+                configuredApiKey: resolved.configuredApiKey,
+                cwd: currentCwd
+            });
+            const shouldUseShell = ctx.isWindows &&
+                !pathImpl.extname(resolvedBinary) &&
+                !resolvedBinary.includes('/') &&
+                !resolvedBinary.includes('\\');
+            const toolProcess = (() => {
+                if (managedTmuxSession) {
+                    const envOverrides = collectChangedEnv(ctx.env, toolEnv);
+                    const launched = launchCommandInTmuxPane({
+                        spawnSyncImpl,
+                        tmuxTarget: managedTmuxSession.tmuxTarget,
+                        cwd: currentCwd,
+                        command: resolvedBinary,
+                        commandArgs: toolArgs,
+                        envOverrides,
+                        managedSessionName: managedTmuxSession.sessionName
+                    });
+                    if (!launched) {
+                        managedTmuxSession.stop();
+                        managedTmuxSession = null;
+                        throw new Error(`Failed to send ${spec.displayName} command to managed tmux session`);
+                    }
+                    return ctx.spawn('tmux', ['attach-session', '-t', managedTmuxSession.sessionName], {
+                        stdio: 'inherit',
+                        env: ctx.env,
+                        cwd: currentCwd
+                    });
+                }
+                return ctx.spawn(resolvedBinary, toolArgs, {
+                    stdio: 'inherit',
+                    env: toolEnv,
+                    cwd: currentCwd,
+                    shell: shouldUseShell
+                });
+            })();
+            managedClientPid = typeof toolProcess.pid === 'number' && Number.isFinite(toolProcess.pid)
+                ? Math.floor(toolProcess.pid)
+                : null;
+            if (clockClientService && managedClientProcessEnabled && managedClientPid) {
+                void clockClientService.syncHeartbeat();
+            }
+            spinner.succeed(`${spec.displayName} launched with RouteCodex proxy`);
+            if (!managedTmuxSession) {
+                ctx.logger.info(`Using RouteCodex server at: ${baseUrl}`);
+                ctx.logger.info(`${spec.displayName} binary: ${resolvedBinary}`);
+                if (ensureResult.started && ensureResult.logPath) {
+                    ctx.logger.info(`RouteCodex auto-start logs: ${ensureResult.logPath}`);
+                }
+                ctx.logger.info(`Working directory for ${spec.displayName}: ${currentCwd}`);
+                ctx.logger.info(`Press Ctrl+C to exit ${spec.displayName}`);
+            }
+            const shutdown = async (signal) => {
+                try {
+                    toolProcess.kill(signal);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    await clockClientService?.stop();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    managedTmuxSession?.stop();
+                }
+                catch {
+                    // ignore
+                }
+                ctx.exit(0);
+            };
+            const onSignal = ctx.onSignal ?? ((signal, cb) => process.on(signal, cb));
+            onSignal('SIGINT', () => {
+                void shutdown('SIGINT');
+            });
+            onSignal('SIGTERM', () => {
+                void shutdown('SIGTERM');
+            });
+            toolProcess.on('error', (error) => {
+                void (async () => {
+                    try {
+                        ctx.logger.error(`Failed to launch ${spec.displayName} (${resolvedBinary}): ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    catch {
+                        // ignore
+                    }
+                    try {
+                        await clockClientService?.stop();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    try {
+                        managedTmuxSession?.stop();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    ctx.exit(1);
+                })();
+            });
+            toolProcess.on('exit', (code, signal) => {
+                void (async () => {
+                    try {
+                        await clockClientService?.stop();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    try {
+                        managedTmuxSession?.stop();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    if (signal) {
+                        ctx.exit(0);
+                        return;
+                    }
+                    ctx.exit(code ?? 0);
+                })();
+            });
+            await ctx.waitForever();
+        }
+        catch (error) {
+            spinner.fail(`Failed to launch ${spec.displayName}`);
+            ctx.logger.error(error instanceof Error ? error.message : String(error));
+            ctx.exit(1);
+        }
+    });
+}
+export { normalizeOpenAiBaseUrl };
+//# sourceMappingURL=launcher-kernel.js.map