@jsonstudio/rcc 0.89.1960 → 0.89.2195

package/dist/cli/commands/launcher-kernel.d.ts

@@ -1,78 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import type { ChildProcess, SpawnOptions } from 'node:child_process';
 import type { Command } from 'commander';
-type Spinner = {
-    start(text?: string): Spinner;
-    succeed(text?: string): void;
-    fail(text?: string): void;
-    warn(text?: string): void;
-    info(text?: string): void;
-    stop(): void;
-    text: string;
-};
-type LoggerLike = {
-    info: (msg: string) => void;
-    warning: (msg: string) => void;
-    success: (msg: string) => void;
-    error: (msg: string) => void;
-};
-export type LauncherCommandContext = {
-    isDevPackage: boolean;
-    isWindows: boolean;
-    defaultDevPort: number;
-    nodeBin: string;
-    createSpinner: (text: string) => Promise<Spinner>;
-    logger: LoggerLike;
-    env: NodeJS.ProcessEnv;
-    rawArgv: string[];
-    fsImpl?: typeof fs;
-    pathImpl?: typeof path;
-    homedir: () => string;
-    cwd?: () => string;
-    sleep: (ms: number) => Promise<void>;
-    fetch: typeof fetch;
-    spawn: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
-    spawnSyncImpl?: typeof spawnSync;
-    getModulesConfigPath: () => string;
-    resolveServerEntryPath: () => string;
-    waitForever: () => Promise<void>;
-    onSignal?: (signal: NodeJS.Signals, cb: () => void) => void;
-    exit: (code: number) => never;
-};
-type LauncherCommandOptions = {
-    port?: string;
-    host: string;
-    url?: string;
-    config?: string;
-    apikey?: string;
-    cwd?: string;
-    model?: string;
-    profile?: string;
-    ensureServer?: boolean;
-    [key: string]: unknown;
-};
-type LauncherSpec = {
-    commandName: string;
-    displayName: string;
-    description: string;
-    binaryOptionFlags: string;
-    binaryOptionName: string;
-    binaryOptionDescription: string;
-    binaryDefault: string;
-    binaryEnvKey?: string;
-    extraKnownOptions: string[];
-    withModelOption?: boolean;
-    withProfileOption?: boolean;
-    buildArgs: (options: LauncherCommandOptions) => string[];
-    buildEnv: (args: {
-        env: NodeJS.ProcessEnv;
-        baseUrl: string;
-        configuredApiKey: string | null;
-        cwd: string;
-    }) => NodeJS.ProcessEnv;
-};
+import type { LauncherCommandContext, LauncherSpec } from './launcher/types.js';
+export type { Spinner, LoggerLike, LauncherCommandContext, LauncherCommandOptions, LauncherSpec, ResolvedServerConnection, ClockClientService, ManagedTmuxSession, TmuxSelfHealPolicy } from './launcher/types.js';
 declare function normalizeOpenAiBaseUrl(baseUrl: string): string;
 export declare function createLauncherCommand(program: Command, ctx: LauncherCommandContext, spec: LauncherSpec): void;
 export { normalizeOpenAiBaseUrl };

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

@@ -6,118 +6,7 @@ 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 };
-    }
-}
+import { resolveBinary, parseServerUrl, resolveTmuxSelfHealPolicy, readConfigApiKey, normalizeConnectHost, toIntegerPort, tryReadConfigHostPort, resolveIntFromEnv } from './launcher/utils.js';
 function resolveServerConnection(ctx, fsImpl, pathImpl, options) {
     let configPath = typeof options.config === 'string' && options.config.trim() ? options.config.trim() : '';
     if (!configPath) {
@@ -392,17 +281,24 @@ async function ensureServerReady(ctx, fsImpl, pathImpl, spinner, options, resolv
 }
 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;
+    const normalizeRequested = typeof requested === 'string' ? requested.trim() : '';
+    if (normalizeRequested) {
+        const resolved = pathImpl.resolve(normalizeRequested);
+        if (!fsImpl.existsSync(resolved)) {
+            throw new Error(`Invalid --cwd: path does not exist: ${resolved}`);
         }
+        const stats = fsImpl.statSync(resolved);
+        if (!stats || typeof stats.isDirectory !== 'function' || !stats.isDirectory()) {
+            throw new Error(`Invalid --cwd: path is not a directory: ${resolved}`);
+        }
+        return resolved;
+    }
+    try {
+        return pathImpl.resolve(getCwd());
     }
     catch {
         return getCwd();
     }
-    return getCwd();
 }
 function isTmuxAvailable(spawnSyncImpl = spawnSync) {
     try {
@@ -466,16 +362,25 @@ function buildShellCommand(tokens) {
     return tokens.map((token) => shellQuote(token)).join(' ');
 }
 function collectChangedEnv(baseEnv, nextEnv) {
-    const out = [];
+    const set = [];
+    const unset = [];
     for (const [key, value] of Object.entries(nextEnv)) {
         if (typeof value !== 'string') {
             continue;
         }
         if (baseEnv[key] !== value) {
-            out.push([key, value]);
+            set.push([key, value]);
         }
     }
-    return out;
+    for (const [key, value] of Object.entries(baseEnv)) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        if (typeof nextEnv[key] === 'undefined') {
+            unset.push(key);
+        }
+    }
+    return { set, unset };
 }
 function sendTmuxSubmitKey(spawnSyncImpl, tmuxTarget, clientType) {
     const type = String(clientType || '').trim().toLowerCase();
@@ -497,6 +402,20 @@ function sendTmuxSubmitKey(spawnSyncImpl, tmuxTarget, clientType) {
             lastError = error instanceof Error ? error.message : String(error ?? `tmux send-keys ${submitKey} failed`);
         }
     }
+    for (const fallback of ['\r', '\n']) {
+        try {
+            const literal = spawnSyncImpl('tmux', ['send-keys', '-t', tmuxTarget, '-l', '--', fallback], { encoding: 'utf8' });
+            if (literal.status === 0) {
+                return { ok: true };
+            }
+            lastError =
+                String(literal.stderr || literal.stdout || 'tmux send-keys literal newline failed').trim()
+                    || 'tmux send-keys literal newline failed';
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error ?? 'tmux send-keys literal newline failed');
+        }
+    }
     return { ok: false, error: lastError || 'tmux send-keys submit failed' };
 }
 function isReusableIdlePaneCommand(command) {
@@ -634,18 +553,58 @@ function createManagedTmuxSession(args) {
     };
 }
 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;
+    const { spawnSyncImpl, tmuxTarget, cwd, command, commandName, commandArgs, envOverrides, selfHealPolicy } = args;
+    const envTokens = [
+        ...envOverrides.unset.flatMap((key) => ['-u', key]),
+        ...envOverrides.set.map(([key, value]) => `${key}=${value}`)
+    ];
+    const baseCommand = buildShellCommand(['env', ...envTokens, command, ...commandArgs]);
+    // Keep the managed tmux session alive when the client process exits.
+    // Session cleanup is handled by managed heartbeat/reaper logic, not by inline shell self-kill.
+    const shellCommand = (() => {
+        if (!selfHealPolicy.enabled || selfHealPolicy.maxRetries <= 0) {
+            return `cd -- ${shellQuote(cwd)} && ${baseCommand}`;
+        }
+        const safeCommandName = shellQuote(commandName || command || 'client');
+        const loopBody = [
+            `${baseCommand}`,
+            '__rcc_exit=$?',
+            'if [ "$__rcc_exit" -eq 0 ] || [ "$__rcc_exit" -eq 130 ] || [ "$__rcc_exit" -eq 143 ]; then exit "$__rcc_exit"; fi',
+            'if [ "$__rcc_try" -ge "$__rcc_max" ]; then exit "$__rcc_exit"; fi',
+            '__rcc_try=$((__rcc_try + 1))',
+            `echo "[routecodex][self-heal] ${safeCommandName} exited with code $__rcc_exit; retry $__rcc_try/$__rcc_max in $__rcc_delay s" >&2`,
+            'sleep "$__rcc_delay"'
+        ].join('; ');
+        return [
+            `cd -- ${shellQuote(cwd)} || exit 1`,
+            '__rcc_try=0',
+            `__rcc_max=${selfHealPolicy.maxRetries}`,
+            `__rcc_delay=${selfHealPolicy.retryDelaySec}`,
+            `while true; do ${loopBody}; done`
+        ].join('; ');
+    })();
+    try {
+        // Prefer respawn-pane for deterministic execution in managed sessions.
+        // This avoids flaky "typed but not submitted" behavior from send-keys on some terminals.
+        const respawn = spawnSyncImpl('tmux', ['respawn-pane', '-k', '-t', tmuxTarget, shellCommand], { encoding: 'utf8' });
+        if (respawn.status === 0) {
+            return true;
+        }
+    }
+    catch {
+        // fallback to send-keys injection
+    }
     try {
+        // Best-effort exit copy-mode before injecting and submitting shell command.
+        spawnSyncImpl('tmux', ['send-keys', '-t', tmuxTarget, '-X', 'cancel'], { encoding: 'utf8' });
+        // Reset any stale partially-typed command in reusable panes before injecting.
+        // This prevents duplicated/concatenated command lines when previous launches failed to submit.
+        spawnSyncImpl('tmux', ['send-keys', '-t', tmuxTarget, 'C-u'], { encoding: 'utf8' });
         const literal = spawnSyncImpl('tmux', ['send-keys', '-t', tmuxTarget, '-l', '--', shellCommand], { encoding: 'utf8' });
         if (literal.status !== 0) {
             return false;
         }
-        const submit = sendTmuxSubmitKey(spawnSyncImpl, tmuxTarget);
+        const submit = sendTmuxSubmitKey(spawnSyncImpl, tmuxTarget, commandName);
         return submit.ok;
     }
     catch {
@@ -681,7 +640,7 @@ function sendJson(res, status, payload) {
     res.end(body);
 }
 async function startClockClientService(args) {
-    const { ctx, resolved, tmuxTarget, spawnSyncImpl, clientType, managedTmuxSession, getManagedProcessState } = args;
+    const { ctx, resolved, workdir, tmuxTarget, spawnSyncImpl, clientType, managedTmuxSession, getManagedProcessState } = args;
     const daemonId = (() => {
         try {
             return `clockd_${crypto.randomUUID()}`;
@@ -782,31 +741,67 @@ async function startClockClientService(args) {
                 headers: { 'content-type': 'application/json' },
                 body: JSON.stringify(payload)
             });
-            return response.ok;
+            return { ok: response.ok, status: response.status };
         }
         catch {
-            return false;
+            return { ok: false, status: 0 };
+        }
+    };
+    const reRegisterBackoffMs = resolveIntFromEnv(ctx.env.ROUTECODEX_CLOCK_CLIENT_REREGISTER_BACKOFF_MS ?? ctx.env.RCC_CLOCK_CLIENT_REREGISTER_BACKOFF_MS, 1500, 200, 60_000);
+    let registerInFlight = null;
+    let lastRegisterAttemptAtMs = 0;
+    const registerDaemon = async () => {
+        if (registerInFlight) {
+            return await registerInFlight;
+        }
+        registerInFlight = (async () => {
+            lastRegisterAttemptAtMs = Date.now();
+            const result = await post('/daemon/clock-client/register', {
+                daemonId,
+                tmuxSessionId,
+                sessionId: tmuxSessionId,
+                workdir,
+                clientType,
+                ...(normalizedTmuxTarget ? { tmuxTarget: normalizedTmuxTarget } : {}),
+                managedTmuxSession,
+                callbackUrl,
+                ...normalizeManagedProcessPayload()
+            });
+            return result.ok;
+        })();
+        try {
+            return await registerInFlight;
+        }
+        finally {
+            registerInFlight = null;
         }
     };
     const syncHeartbeat = async () => {
-        return await post('/daemon/clock-client/heartbeat', {
+        const heartbeat = await post('/daemon/clock-client/heartbeat', {
             daemonId,
             tmuxSessionId,
             sessionId: tmuxSessionId,
+            workdir,
             managedTmuxSession,
             ...normalizeManagedProcessPayload()
         });
+        if (heartbeat.ok) {
+            return true;
+        }
+        const shouldReRegister = heartbeat.status === 404
+            || heartbeat.status === 410
+            || heartbeat.status === 0
+            || heartbeat.status >= 500;
+        if (!shouldReRegister) {
+            return false;
+        }
+        const allowImmediateReRegister = heartbeat.status === 404 || heartbeat.status === 410;
+        if (!allowImmediateReRegister && Date.now() - lastRegisterAttemptAtMs < reRegisterBackoffMs) {
+            return false;
+        }
+        return await registerDaemon();
     };
-    const registered = await post('/daemon/clock-client/register', {
-        daemonId,
-        tmuxSessionId,
-        sessionId: tmuxSessionId,
-        clientType,
-        ...(normalizedTmuxTarget ? { tmuxTarget: normalizedTmuxTarget } : {}),
-        managedTmuxSession,
-        callbackUrl,
-        ...normalizeManagedProcessPayload()
-    });
+    const registered = await registerDaemon();
     if (!registered) {
         if (server) {
             try {
@@ -923,6 +918,7 @@ export function createLauncherCommand(program, ctx, spec) {
             const baseUrl = `${resolved.protocol}://${resolved.connectHost}${resolved.portPart}${resolved.basePath}`;
             const currentCwd = resolveWorkingDirectory(ctx, fsImpl, pathImpl, options.cwd);
             const spawnSyncImpl = ctx.spawnSyncImpl ?? spawnSync;
+            const tmuxSelfHealPolicy = resolveTmuxSelfHealPolicy(ctx.env);
             const toolArgs = spec.buildArgs(options);
             const knownOptions = new Set([
                 '--port',
@@ -1016,6 +1012,7 @@ export function createLauncherCommand(program, ctx, spec) {
             const clockClientService = await startClockClientService({
                 ctx,
                 resolved,
+                workdir: currentCwd,
                 tmuxTarget,
                 spawnSyncImpl,
                 clientType: spec.commandName,
@@ -1071,9 +1068,10 @@ export function createLauncherCommand(program, ctx, spec) {
                         tmuxTarget: managedTmuxSession.tmuxTarget,
                         cwd: currentCwd,
                         command: resolvedBinary,
+                        commandName: spec.commandName,
                         commandArgs: toolArgs,
                         envOverrides,
-                        managedSessionName: managedTmuxSession.sessionName
+                        selfHealPolicy: tmuxSelfHealPolicy
                     });
                     if (!launched) {
                         managedTmuxSession.stop();