// Coordinates gateway restart requests across supported supervisors.

import { spawnSync } from "node:child_process";

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { getRuntimeConfig } from "../config/config.js";

import { resolveStateDir } from "../config/paths.js";

import {

resolveGatewayLaunchAgentLabel,

resolveGatewaySystemdServiceName,

} from "../daemon/constants.js";

import { createSubsystemLogger } from "../logging/subsystem.js";

import { resolveTimerTimeoutMs } from "../shared/number-coercion.js";

import { replaceFileAtomicSync } from "./replace-file.js";

import type { DB as OpenClawStateKyselyDatabase } from "../state/openclaw-state-db.generated.js";

import {

openOpenClawStateDatabase,

runOpenClawStateWriteTransaction,

} from "../state/openclaw-state-db.js";

import {

executeSqliteQuerySync,

executeSqliteQueryTakeFirstSync,

getNodeSqliteKysely,

} from "./kysely-sync.js";

import { cleanStaleGatewayProcessesSync, findGatewayPidsOnPortSync } from "./restart-stale-pids.js";

import type { RestartAttempt } from "./restart.types.js";

import { relaunchGatewayScheduledTask } from "./windows-task-restart.js";

export const DEFAULT_RESTART_DEFERRAL_TIMEOUT_MS = 300_000;

const RESTART_COOLDOWN_MS = 30_000;

const LAUNCHCTL_ALREADY_LOADED_EXIT_CODE = 37;

const GATEWAY_RESTART_INTENT_FILENAME = "gateway-restart-intent.json";

const GATEWAY_RESTART_INTENT_KEY = "gateway-restart";

const GATEWAY_RESTART_INTENT_TTL_MS = 60_000;

const GATEWAY_RESTART_INTENT_MAX_BYTES = 1024;

const restartLog = createSubsystemLogger("restart");

type GatewayRestartIntentDatabase = Pick<OpenClawStateKyselyDatabase, "gateway_restart_intent">;

export { findGatewayPidsOnPortSync };

waitMs?: number;

};

function resolveGatewayRestartIntentPath(env: NodeJS.ProcessEnv = process.env): string {

return path.join(resolveStateDir(env), GATEWAY_RESTART_INTENT_FILENAME);

}

function unlinkGatewayRestartIntentFileSync(intentPath: string): boolean {

try {

const stat = fs.lstatSync(intentPath);

if (!stat.isFile() || stat.nlink > 1) {

return false;

}

fs.unlinkSync(intentPath);

return true;

} catch {

return false;

}

}

function normalizeRestartIntentPid(pid: number | undefined): number | null {

return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : null;

}

}

const env = opts.env ?? process.env;

try {

const intentPath = resolveGatewayRestartIntentPath(env);

const reason = normalizeRestartIntentReason(opts.reason ?? opts.intent?.reason);

const payload: GatewayRestartIntentPayload = {

kind: "gateway-restart",

pid: targetPid,

createdAt: Date.now(),

...(reason ? { reason } : {}),

...(opts.intent?.force ? { force: true } : {}),

...(typeof opts.intent?.waitMs === "number" &&

const waitMs =

typeof opts.intent?.waitMs === "number" &&

Number.isFinite(opts.intent.waitMs) &&

opts.intent.waitMs >= 0

? { waitMs: Math.floor(opts.intent.waitMs) }

: {}),

};

replaceFileAtomicSync({

filePath: intentPath,

content: `${JSON.stringify(payload)}\n`,

mode: 0o600,

tempPrefix: ".gateway-restart-intent",

});

? Math.floor(opts.intent.waitMs)

: null;

const createdAt = Date.now();

runOpenClawStateWriteTransaction(

({ db }) => {

const stateDb = getNodeSqliteKysely<GatewayRestartIntentDatabase>(db);

executeSqliteQuerySync(

db,

stateDb

.insertInto("gateway_restart_intent")

.values({

intent_key: GATEWAY_RESTART_INTENT_KEY,

kind: "gateway-restart",

pid: targetPid,

created_at: createdAt,

reason: reason ?? null,

force: opts.intent?.force ? 1 : null,

wait_ms: waitMs,

updated_at_ms: createdAt,

})

.onConflict((conflict) =>

conflict.column("intent_key").doUpdateSet({

kind: (eb) => eb.ref("excluded.kind"),

pid: (eb) => eb.ref("excluded.pid"),

created_at: (eb) => eb.ref("excluded.created_at"),

reason: (eb) => eb.ref("excluded.reason"),

force: (eb) => eb.ref("excluded.force"),

wait_ms: (eb) => eb.ref("excluded.wait_ms"),

updated_at_ms: (eb) => eb.ref("excluded.updated_at_ms"),

}),

),

);

},

{ env },

);

return true;

} catch (err) {

restartLog.warn(`failed to write gateway restart intent: ${String(err)}`);

}

export function clearGatewayRestartIntentSync(env: NodeJS.ProcessEnv = process.env): void {

unlinkGatewayRestartIntentFileSync(resolveGatewayRestartIntentPath(env));

try {

runOpenClawStateWriteTransaction(

({ db }) => {

const stateDb = getNodeSqliteKysely<GatewayRestartIntentDatabase>(db);

executeSqliteQuerySync(

db,

stateDb

.deleteFrom("gateway_restart_intent")

.where("intent_key", "=", GATEWAY_RESTART_INTENT_KEY),

);

},

{ env },

);

} catch {}

}

function parseGatewayRestartIntent(raw: string): GatewayRestartIntentPayload | null {

function readGatewayRestartIntentPayloadSync(

env: NodeJS.ProcessEnv,

): GatewayRestartIntentPayload | null {

try {

const parsed = JSON.parse(raw) as Partial<GatewayRestartIntentPayload>;

const { db } = openOpenClawStateDatabase({ env });

const stateDb = getNodeSqliteKysely<GatewayRestartIntentDatabase>(db);

const parsed = executeSqliteQueryTakeFirstSync(

db,

stateDb

.selectFrom("gateway_restart_intent")

.select(["kind", "pid", "created_at", "reason", "force", "wait_ms"])

.where("intent_key", "=", GATEWAY_RESTART_INTENT_KEY),

);

if (

parsed.kind === "gateway-restart" &&

parsed?.kind === "gateway-restart" &&

typeof parsed.pid === "number" &&

Number.isFinite(parsed.pid) &&

typeof parsed.createdAt === "number" &&

Number.isFinite(parsed.createdAt) &&

(parsed.reason === undefined || typeof parsed.reason === "string") &&

(parsed.force === undefined || typeof parsed.force === "boolean") &&

(parsed.waitMs === undefined ||

(typeof parsed.waitMs === "number" && Number.isFinite(parsed.waitMs) && parsed.waitMs >= 0))

typeof parsed.created_at === "number" &&

Number.isFinite(parsed.created_at) &&

(parsed.reason === null || typeof parsed.reason === "string") &&

(parsed.force === null ||

(typeof parsed.force === "number" && Number.isFinite(parsed.force))) &&

(parsed.wait_ms === null ||

(typeof parsed.wait_ms === "number" &&

Number.isFinite(parsed.wait_ms) &&

parsed.wait_ms >= 0))

) {

const reason = normalizeRestartIntentReason(parsed.reason);

const reason = normalizeRestartIntentReason(parsed.reason ?? undefined);

return {

kind: "gateway-restart",

pid: parsed.pid,

createdAt: parsed.createdAt,

createdAt: parsed.created_at,

...(reason ? { reason } : {}),

...(parsed.force ? { force: true } : {}),

...(typeof parsed.waitMs === "number" ? { waitMs: Math.floor(parsed.waitMs) } : {}),

...(typeof parsed.wait_ms === "number" ? { waitMs: Math.floor(parsed.wait_ms) } : {}),

};

}

} catch {

env: NodeJS.ProcessEnv = process.env,

now = Date.now(),

): GatewayRestartIntent | null {

const intentPath = resolveGatewayRestartIntentPath(env);

let raw: string;

try {

const stat = fs.lstatSync(intentPath);

if (!stat.isFile() || stat.size > GATEWAY_RESTART_INTENT_MAX_BYTES) {

return null;

}

raw = fs.readFileSync(intentPath, "utf8");

} catch {

return null;

} finally {

clearGatewayRestartIntentSync(env);

}

const payload = parseGatewayRestartIntent(raw);

const payload = readGatewayRestartIntentPayloadSync(env);

clearGatewayRestartIntentSync(env);

if (!payload) {

return null;

}