dominds 1.26.0 → 1.26.2

package/dist/server/dominds-self-update-restart-helper.js

@@ -1,305 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const net_1 = __importDefault(require("net"));
-const time_1 = require("@longrun-ai/kernel/utils/time");
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === 'string');
-}
-function readString(value, key) {
-    const candidate = value[key];
-    if (typeof candidate !== 'string' || candidate.trim() === '') {
-        throw new Error(`Invalid Dominds restart helper payload: ${key} must be a non-empty string`);
-    }
-    return candidate;
-}
-function readNumber(value, key) {
-    const candidate = value[key];
-    if (typeof candidate !== 'number' || !Number.isFinite(candidate)) {
-        throw new Error(`Invalid Dominds restart helper payload: ${key} must be a finite number`);
-    }
-    return candidate;
-}
-function readPositiveInteger(value, key) {
-    const candidate = readNumber(value, key);
-    if (!Number.isInteger(candidate) || candidate <= 0) {
-        throw new Error(`Invalid Dominds restart helper payload: ${key} must be a positive integer`);
-    }
-    return candidate;
-}
-function readPort(value, key) {
-    const candidate = readPositiveInteger(value, key);
-    if (candidate > 65535) {
-        throw new Error(`Invalid Dominds restart helper payload: ${key} must be <= 65535`);
-    }
-    return candidate;
-}
-function parsePayload(raw) {
-    if (typeof raw !== 'string' || raw.trim() === '') {
-        throw new Error('Missing Dominds restart helper payload');
-    }
-    const parsed = JSON.parse(raw);
-    if (!isRecord(parsed)) {
-        throw new Error('Invalid Dominds restart helper payload: expected an object');
-    }
-    const args = parsed['args'];
-    if (!isStringArray(args)) {
-        throw new Error('Invalid Dominds restart helper payload: args must be a string array');
-    }
-    const stdioMode = parsed['stdioMode'];
-    if (stdioMode !== 'inherit' && stdioMode !== 'ignore') {
-        throw new Error('Invalid Dominds restart helper payload: stdioMode must be inherit or ignore');
-    }
-    return {
-        command: readString(parsed, 'command'),
-        args,
-        cwd: readString(parsed, 'cwd'),
-        host: readString(parsed, 'host'),
-        port: readPort(parsed, 'port'),
-        retiringPid: readPositiveInteger(parsed, 'retiringPid'),
-        forceKillAfterMs: readPositiveInteger(parsed, 'forceKillAfterMs'),
-        probeIntervalMs: readPositiveInteger(parsed, 'probeIntervalMs'),
-        portReleaseTimeoutMs: readPositiveInteger(parsed, 'portReleaseTimeoutMs'),
-        stdioMode,
-        traceFile: readString(parsed, 'traceFile'),
-        debugDir: readString(parsed, 'debugDir'),
-    };
-}
-function trace(payload, event, details = {}) {
-    const record = {
-        ...details,
-        event,
-        capturedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-        helperPid: process.pid,
-        platform: process.platform,
-    };
-    try {
-        fs_1.default.mkdirSync(payload.debugDir, { recursive: true });
-        fs_1.default.appendFileSync(payload.traceFile, `${JSON.stringify(record)}\n`, 'utf8');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Failed to write Dominds restart helper trace: ${message}`);
-    }
-}
-function isPortBusy(payload) {
-    return new Promise((resolve) => {
-        const socket = net_1.default.createConnection({ host: payload.host, port: payload.port });
-        let settled = false;
-        const finish = (busy) => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            resolve(busy);
-        };
-        socket.once('connect', () => finish(true));
-        socket.once('error', () => finish(false));
-        socket.setTimeout(1000, () => finish(true));
-    });
-}
-function getErrorCode(error) {
-    return isRecord(error) && typeof error['code'] === 'string' ? error['code'] : '';
-}
-function assertValidRetiringPid(payload) {
-    if (!Number.isInteger(payload.retiringPid) || payload.retiringPid <= 0) {
-        throw new Error(`Invalid retiring Dominds pid for restart: ${String(payload.retiringPid)}`);
-    }
-    if (payload.retiringPid === process.pid) {
-        throw new Error(`Refusing to kill restart helper pid ${String(process.pid)}`);
-    }
-}
-function isRetiringProcessAlive(payload) {
-    assertValidRetiringPid(payload);
-    try {
-        process.kill(payload.retiringPid, 0);
-        return true;
-    }
-    catch (error) {
-        const code = getErrorCode(error);
-        if (code === 'ESRCH')
-            return false;
-        if (code === 'EPERM')
-            return true;
-        throw error;
-    }
-}
-async function delayMs(ms) {
-    await new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-async function waitForRetiringProcessExit(payload, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (!isRetiringProcessAlive(payload))
-            return true;
-        await delayMs(payload.probeIntervalMs);
-    }
-    return false;
-}
-async function waitForPortReleaseUntil(payload, deadline) {
-    let consecutiveReady = 0;
-    while (Date.now() < deadline) {
-        if (!(await isPortBusy(payload))) {
-            consecutiveReady += 1;
-            if (consecutiveReady >= 2)
-                return true;
-        }
-        else {
-            consecutiveReady = 0;
-        }
-        await delayMs(payload.probeIntervalMs);
-    }
-    return false;
-}
-async function runBestEffortKiller(payload, command, args) {
-    await new Promise((resolve) => {
-        trace(payload, 'helper.force_kill.spawn', { command, args });
-        const killer = (0, child_process_1.spawn)(command, [...args], {
-            stdio: payload.stdioMode,
-            windowsHide: payload.stdioMode !== 'inherit',
-        });
-        killer.once('error', (error) => {
-            trace(payload, 'helper.force_kill.error', { message: error.message });
-            resolve();
-        });
-        killer.once('exit', (code, signal) => {
-            trace(payload, 'helper.force_kill.exit', { code, signal });
-            resolve();
-        });
-    });
-}
-async function forceKillRetiringProcess(payload) {
-    assertValidRetiringPid(payload);
-    try {
-        process.kill(payload.retiringPid, 'SIGKILL');
-    }
-    catch (error) {
-        const code = getErrorCode(error);
-        if (code === 'ESRCH')
-            return;
-        if (process.platform !== 'win32')
-            throw error;
-    }
-    if (process.platform === 'win32') {
-        await runBestEffortKiller(payload, 'taskkill.exe', ['/PID', String(payload.retiringPid), '/F']);
-    }
-}
-async function runRestartHelper(payload) {
-    const detached = payload.stdioMode !== 'inherit';
-    trace(payload, 'helper.start', {
-        command: payload.command,
-        args: payload.args,
-        cwd: payload.cwd,
-        host: payload.host,
-        port: payload.port,
-        retiringPid: payload.retiringPid,
-        detached,
-        stdioMode: payload.stdioMode,
-        forceKillAfterMs: payload.forceKillAfterMs,
-        portReleaseTimeoutMs: payload.portReleaseTimeoutMs,
-        probeIntervalMs: payload.probeIntervalMs,
-    });
-    const forceKillDeadline = Date.now() + payload.forceKillAfterMs;
-    trace(payload, 'helper.wait_retiring_process_exit.start', {
-        retiringPid: payload.retiringPid,
-        timeoutMs: payload.forceKillAfterMs,
-    });
-    const exitedGracefully = await waitForRetiringProcessExit(payload, payload.forceKillAfterMs);
-    trace(payload, 'helper.wait_retiring_process_exit.finish', {
-        retiringPid: payload.retiringPid,
-        exited: exitedGracefully,
-    });
-    if (!exitedGracefully) {
-        trace(payload, 'helper.force_kill.start', { retiringPid: payload.retiringPid });
-        await forceKillRetiringProcess(payload);
-        trace(payload, 'helper.force_kill.finish', { retiringPid: payload.retiringPid });
-        trace(payload, 'helper.wait_retiring_process_exit_after_kill.start', {
-            retiringPid: payload.retiringPid,
-            timeoutMs: payload.portReleaseTimeoutMs,
-        });
-        const exitedAfterKill = await waitForRetiringProcessExit(payload, payload.portReleaseTimeoutMs);
-        trace(payload, 'helper.wait_retiring_process_exit_after_kill.finish', {
-            retiringPid: payload.retiringPid,
-            exited: exitedAfterKill,
-        });
-        if (!exitedAfterKill) {
-            throw new Error(`Dominds retiring process is still alive after force-killing pid ${String(payload.retiringPid)}`);
-        }
-    }
-    const portReleaseDeadline = Math.max(forceKillDeadline, Date.now() + payload.portReleaseTimeoutMs);
-    trace(payload, 'helper.wait_port_release.start', {
-        host: payload.host,
-        port: payload.port,
-        deadlineMsFromNow: portReleaseDeadline - Date.now(),
-    });
-    const portReleased = await waitForPortReleaseUntil(payload, portReleaseDeadline);
-    trace(payload, 'helper.wait_port_release.finish', {
-        host: payload.host,
-        port: payload.port,
-        released: portReleased,
-    });
-    if (!portReleased) {
-        throw new Error(`Dominds restart port is still busy after retiring pid ${String(payload.retiringPid)} exited; port=${String(payload.host)}:${String(payload.port)}`);
-    }
-    trace(payload, 'helper.spawn_new_process.start', {
-        command: payload.command,
-        args: payload.args,
-        cwd: payload.cwd,
-        detached,
-        stdioMode: payload.stdioMode,
-    });
-    const child = (0, child_process_1.spawn)(payload.command, [...payload.args], {
-        cwd: payload.cwd,
-        env: process.env,
-        detached,
-        stdio: payload.stdioMode,
-        shell: false,
-        windowsHide: payload.stdioMode !== 'inherit',
-    });
-    if (detached)
-        child.unref();
-    await new Promise((resolve, reject) => {
-        child.once('error', (error) => {
-            trace(payload, 'helper.spawn_new_process.error', {
-                command: payload.command,
-                args: payload.args,
-                cwd: payload.cwd,
-                message: error.message,
-                stack: error.stack ?? null,
-            });
-            reject(error);
-        });
-        child.once('spawn', resolve);
-    });
-    trace(payload, 'helper.spawn_new_process.finish', { childPid: child.pid ?? null });
-    trace(payload, 'helper.exit', { code: 0 });
-}
-async function main() {
-    let payload = null;
-    try {
-        payload = parsePayload(process.argv[2]);
-        await runRestartHelper(payload);
-        process.exit(0);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const stack = error instanceof Error ? (error.stack ?? null) : null;
-        if (payload !== null) {
-            trace(payload, 'helper.error', { message, stack });
-        }
-        console.error(message);
-        process.exit(1);
-    }
-}
-if (require.main === module) {
-    void main();
-}