launcher.ts

import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { execFile } from 'child_process';
import { createHash, randomUUID } from 'crypto';
import { promisify } from 'util';
import { AgentConfig, SessionManifest, identifier } from './protocol';
import { atomicJson } from './journal';
import { hostNodeRuntime, NodeRuntime } from './nodeExecutable';
import { prepareSupervisor } from './supervisor';
import { ensureStorageDirectory, prepareStorage, storageError } from './storage';
import { installSessRuntime } from './backends/sessPreparation';
export { prepareStorage } from './storage';

const run = promisify(execFile);

export function defaultStorage(platform = process.platform, home = os.homedir(), environment = process.env): string {
    const xdg = environment.XDG_STATE_HOME;
    // XDG paths must be absolute; an empty value is equivalent to being unset.
    if (xdg && path.isAbsolute(xdg)) { return path.join(xdg, 'vscode-r', 'interactive'); }
    const legacy = path.join(home, '.local', 'state', 'vscode-r', 'interactive');
    // Keep existing agents and their on-disk paths discoverable without moving live storage.
    if (platform !== 'darwin' || fs.existsSync(legacy)) { return legacy; }
    return path.join(home, 'Library', 'Application Support', 'vscode-r', 'interactive');
}

export function discoverSessions(root: string): SessionManifest[] {
    let names: string[];
    try { names = fs.readdirSync(root); }
    catch (error) {
        if ((error as NodeJS.ErrnoException).code === 'ENOENT') { return []; }
        throw storageError(root, error);
    }
    const sessions: SessionManifest[] = [];
    for (const name of names) {
        if (name === 'runtimes') { continue; }
        try {
            identifier(name);
            const file = path.join(root, name, 'manifest.json');
            const stat = fs.lstatSync(file);
            if (stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid())) { continue; }
            const manifest = JSON.parse(fs.readFileSync(file, 'utf8')) as SessionManifest;
            if (manifest.id !== name || manifest.host !== os.hostname()) { continue; }
            sessions.push(manifest);
        } catch { /* Ignore partial, foreign, and unrecognized registry entries. */ }
    }
    return sessions.sort((a, b) => b.created - a.created);
}

/** Cheap rejection of stale registry entries; a socket still needs an authenticated probe. */
export function hasSessionEndpoint(manifest: SessionManifest): boolean {
    if (!Number.isSafeInteger(manifest.agentPid) || manifest.agentPid <= 0 ||
        typeof manifest.endpoint !== 'string' || !path.isAbsolute(manifest.endpoint)) { return false; }
    try {
        process.kill(manifest.agentPid, 0);
        return fs.statSync(manifest.endpoint).isSocket();
    } catch { return false; }
}

/** Shell quoting is used only for tmux/system service launch commands, never for R code. */
export function shellQuote(value: string): string { return `'${value.replace(/'/g, `'"'"'`)}'`; }

/** Debugger auto-attach must not make the persistent agent part of the editor's debug session. */
export function agentEnvironment(environment = process.env): NodeJS.ProcessEnv {
    const result = { ...environment };
    delete result.ELECTRON_RUN_AS_NODE;
    if (result.VSCODE_INSPECTOR_OPTIONS) {
        delete result.NODE_OPTIONS;
        delete result.VSCODE_INSPECTOR_OPTIONS;
    }
    return result;
}

/** Only the Electron launcher and agent need this flag, not their R children. */
export function nodeEnvironment(runtime: NodeRuntime, environment = process.env): NodeJS.ProcessEnv {
    const result = agentEnvironment(environment);
    if (runtime.electron) { result.ELECTRON_RUN_AS_NODE = '1'; }
    return result;
}

/** Agent bundles are cached independently of any R backend or package library. */
export function installAgentBundle(extensionPath: string, root: string): string {
    prepareStorage(root);
    const bytes = fs.readFileSync(path.join(extensionPath, 'dist', 'interactive-agent.js'));
    const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 20);
    const agent = path.join(root, 'runtimes', `agent-${hash}.cjs`);
    if (!fs.existsSync(agent)) {
        const temporary = `${agent}.${randomUUID()}.tmp`;
        try { fs.writeFileSync(temporary, bytes, { mode: 0o600 }); fs.renameSync(temporary, agent); }
        finally { fs.rmSync(temporary, { force: true }); }
    }
    return agent;
}

/** Convenience for existing callers preparing the shipped sess backend. */
export async function installRuntime(extensionPath: string, root: string, rPath: string,
    log: (text: string) => void): Promise<{ library: string; resources: string; agent: string }> {
    const runtime = await installSessRuntime(extensionPath, root, rPath, log);
    return { ...runtime, agent: installAgentBundle(extensionPath, root) };
}

/** Validate before building a runtime or stopping a session for restart. */
export async function prepareNodeRuntime(directory: string, runtime = hostNodeRuntime()): Promise<NodeRuntime> {
    const node = runtime.executable;
    const help = 'Set r.interactive.nodePath to a Node.js 18+ executable on the R host, or clear it to use VS Code\'s runtime. Reload VS Code to refresh the automatic runtime; repair or update VS Code (VS Code Server on a remote host) if needed.';
    let version: string;
    try {
        version = (await run(node, ['-p', 'process.versions.node'], { env: nodeEnvironment(runtime), cwd: directory, timeout: 5000 })).stdout.trim();
    } catch (error) { throw new Error(`Cannot run the Node.js runtime “${node}”. ${help}`, { cause: error }); }
    const major = /^(\d+)\.\d+\.\d+(?:[-+].*)?$/.exec(version)?.[1];
    if (!major || Number(major) < 18) {
        throw new Error(`The session agent requires Node.js 18 or newer; “${node}” reported “${version}”. ${help}`);
    }
    return runtime;
}

export async function launchAgent(config: AgentConfig, agent: string, runtime = hostNodeRuntime(),
    log: (text: string) => void = () => undefined): Promise<SessionManifest> {
    const supervisor = prepareSupervisor(config.supervision, config.directory);
    runtime = await prepareNodeRuntime(config.directory, runtime);
    const node = runtime.executable;
    ensureStorageDirectory(config.storage, path.dirname(config.storage));
    const file = path.join(config.storage, 'config.json');
    const env = nodeEnvironment(runtime);
    config.supervision = supervisor.kind;
    atomicJson(file, config);
    if (supervisor.kind !== 'detached') {
        const args = supervisor.kind === 'tmux'
            ? ['new-session', '-d', '-s', `vscode-r-${config.id.slice(0, 8)}-${config.generation.slice(0, 8)}`,
                `${runtime.electron ? 'ELECTRON_RUN_AS_NODE=1 ' : ''}exec ${[node, agent, file].map(shellQuote).join(' ')} >>${shellQuote(path.join(config.storage, 'agent.log'))} 2>&1`]
            : ['--user', '--collect', '--unit', `vscode-r-${config.id}-${config.generation}`,
                ...(runtime.electron ? ['--setenv=ELECTRON_RUN_AS_NODE=1'] : []), '--', node, agent, file];
        try { await run(supervisor.executable, args, { env, cwd: config.directory, timeout: 10000 }); }
        catch (error) {
            // A failed command may already have started an agent. Falling back now
            // could create two R processes using the same session registry.
            throw new Error(`Could not start the ${supervisor.kind} session supervisor. Check ${supervisor.kind === 'systemd' ? 'the systemd user service' : 'tmux'} on the R host, ` +
                `or set r.interactive.supervision to "detached". ${String(error)}`, { cause: error });
        }
    } else {
        if (supervisor.notice) {
            log(supervisor.notice);
            fs.appendFileSync(path.join(config.storage, 'agent.log'), `${supervisor.notice}\n`, { mode: 0o600 });
        }
        // setsid/unref alone leaves the agent in the extension host's process tree.
        // Wait for a short-lived launcher to exit so tree-based editor/debugger cleanup
        // cannot reach the agent. The agent owns its log and has no inherited IPC or stdio.
        const bootstrap = `
            const fs = require('fs');
            const log = fs.openSync(${JSON.stringify(path.join(config.storage, 'agent.log'))}, 'a', 0o600);
            const child = require('child_process').spawn(process.execPath, process.argv.slice(1),
                { detached: true, stdio: ['ignore', log, log] });
            child.once('error', error => { console.error(error); process.exitCode = 1; });
            child.unref();
            fs.closeSync(log);
        `;
        await run(node, ['-e', bootstrap, agent, file], { env });
    }
    const deadline = Date.now() + 30000;
    while (Date.now() < deadline) {
        try {
            const manifest = JSON.parse(fs.readFileSync(path.join(config.storage, 'manifest.json'), 'utf8')) as SessionManifest;
            if (manifest.generation === config.generation) { return manifest; }
        } catch { /* Atomic manifest is published after the endpoints are ready. */ }
        await new Promise(resolve => setTimeout(resolve, 100));
    }
    throw new Error(`Session agent did not become ready. See ${path.join(config.storage, 'agent.log')}`);
}

export function newIdentity(): { id: string; generation: string } { return { id: randomUUID(), generation: randomUUID() }; }