import os from "node:os";

import path from "node:path";

import { beforeEach, describe, expect, it, vi } from "vitest";

import { normalizeConfigPatchReplacePath } from "../config/patch-replace-paths.js";

import { GatewayClientRequestError } from "../gateway/client.js";

import { readRestartSentinel } from "../infra/restart-sentinel.js";

import { testing as restartTesting } from "../infra/restart.js";

import { withEnvAsync } from "../test-utils/env.js";

import { normalizeConfigPatchReplacePath } from "../config/patch-replace-paths.js";

import { createGatewayTool } from "./tools/gateway-tool.js";

import { callGatewayTool } from "./tools/gateway.js";

});

expect(restartSignalKillCalls()).toHaveLength(0);

const sentinelPath = path.join(stateDir, "restart-sentinel.json");

const raw = await fs.readFile(sentinelPath, "utf-8");

const parsed = JSON.parse(raw) as {

payload?: { kind?: string; doctorHint?: string | null };

};

expect(parsed.payload?.kind).toBe("restart");

expect(parsed.payload?.doctorHint).toBe(

const sentinel = await readRestartSentinel();

expect(sentinel?.payload.kind).toBe("restart");

expect(sentinel?.payload.doctorHint).toBe(

"Recommended follow-up: run openclaw --profile isolated doctor --non-interactive in a terminal or approvals-capable OpenClaw surface.",

);

},

it("distinguishes explicit terminal array consent from indexed consent", () => {

expect(normalizeConfigPatchReplacePath("bindings[]")).toBe("bindings");

expect(normalizeConfigPatchReplacePath("bindings[0]")).toBe("bindings[0]");

expect(normalizeConfigPatchReplacePath("agents.list[0].skills")).toBe(

"agents.list[].skills",

);

expect(normalizeConfigPatchReplacePath("agents.list[0].skills")).toBe("agents.list[].skills");

expect(normalizeConfigPatchReplacePath(normalizeConfigPatchReplacePath("bindings[]"))).toBe(

"bindings",

);

expect(

normalizeConfigPatchReplacePath(normalizeConfigPatchReplacePath("bindings[0]")),

).toBe("bindings[0]");

expect(normalizeConfigPatchReplacePath(normalizeConfigPatchReplacePath("bindings[0]"))).toBe(

"bindings[0]",

);

});

it("rejects config.patch when it changes safe bin approval paths", async () => {

formatDoctorNonInteractiveHintMock,

isRestartEnabledMock,

callGatewayToolMock,

removeRestartSentinelFileMock,

clearRestartSentinelMock,

scheduleGatewaySigusr1RestartMock,

writeRestartSentinelMock,

} = vi.hoisted(() => ({

() =>

"Recommended follow-up: run openclaw doctor --non-interactive in a terminal or approvals-capable OpenClaw surface.",

),

writeRestartSentinelMock: vi.fn(async (_payload: RestartSentinelPayload) => "/tmp/restart"),

removeRestartSentinelFileMock: vi.fn(async (_path: string | null | undefined) => undefined),

writeRestartSentinelMock: vi.fn(async (_payload: RestartSentinelPayload) => undefined),

clearRestartSentinelMock: vi.fn(async () => undefined),

scheduleGatewaySigusr1RestartMock: vi.fn((_opts?: ScheduleGatewayRestartArgs) => ({

ok: true,

pid: 123,

return {

...actual,

formatDoctorNonInteractiveHint: formatDoctorNonInteractiveHintMock,

removeRestartSentinelFile: removeRestartSentinelFileMock,

clearRestartSentinel: clearRestartSentinelMock,

writeRestartSentinel: writeRestartSentinelMock,

};

});

"Recommended follow-up: run openclaw doctor --non-interactive in a terminal or approvals-capable OpenClaw surface.",

);

writeRestartSentinelMock.mockReset();

writeRestartSentinelMock.mockResolvedValue("/tmp/restart");

removeRestartSentinelFileMock.mockClear();

writeRestartSentinelMock.mockResolvedValue(undefined);

clearRestartSentinelMock.mockClear();

scheduleGatewaySigusr1RestartMock.mockReset();

scheduleGatewaySigusr1RestartMock.mockReturnValue({

ok: true,

await scheduledArgs.emitHooks?.beforeEmit?.();

await scheduledArgs.emitHooks?.afterEmitRejected?.();

expect(removeRestartSentinelFileMock).toHaveBeenCalledWith("/tmp/restart");

expect(clearRestartSentinelMock).toHaveBeenCalledOnce();

});

it("uses the runtime session for update.run continuation routing (#86742)", async () => {

import { GatewayClientRequestError } from "../../gateway/client.js";

import {

buildRestartSuccessContinuation,

clearRestartSentinel,

formatDoctorNonInteractiveHint,

removeRestartSentinelFile,

type RestartSentinelPayload,

writeRestartSentinel,

} from "../../infra/restart-sentinel.js";

log.info(

`gateway tool: restart requested (delayMs=${delayMs ?? "default"}, reason=${reason ?? "none"})`,

);

let sentinelPath: string | null = null;

let sentinelWritten = false;

const scheduled = scheduleGatewaySigusr1Restart({

delayMs,

reason,

sessionKey,

emitHooks: {

beforeEmit: async () => {

sentinelPath = await writeRestartSentinel(payload);

await writeRestartSentinel(payload);

sentinelWritten = true;

},

afterEmitRejected: async () => {

await removeRestartSentinelFile(sentinelPath);

if (sentinelWritten) {

await clearRestartSentinel();

}

},

},

});

type ScheduleGatewayRestartArgs = Parameters<typeof scheduleGatewaySigusr1Restart>[0];

const mocks = vi.hoisted(() => ({

unlink: vi.fn(async (_path: string) => undefined),

clearRestartSentinel: vi.fn(async () => undefined),

isRestartEnabled: vi.fn(() => true),

extractDeliveryInfo: vi.fn(() => ({

deliveryContext: {

() =>

"Recommended follow-up: run openclaw doctor --non-interactive in a terminal or approvals-capable OpenClaw surface.",

),

writeRestartSentinel: vi.fn(async (_payload: RestartSentinelPayload) => "/tmp/sentinel.json"),

writeRestartSentinel: vi.fn(async (_payload: RestartSentinelPayload) => undefined),

scheduleGatewaySigusr1Restart: vi.fn((_opts?: ScheduleGatewayRestartArgs) => ({

scheduled: true,

})),

triggerOpenClawRestart: vi.fn(() => ({ ok: true, method: "launchctl" })),

}));

vi.mock("node:fs/promises", () => ({

default: {

unlink: mocks.unlink,

},

unlink: mocks.unlink,

}));

vi.mock("../../config/commands.flags.js", () => ({

isRestartEnabled: mocks.isRestartEnabled,

}));

);

return {

...actual,

clearRestartSentinel: mocks.clearRestartSentinel,

formatDoctorNonInteractiveHint: mocks.formatDoctorNonInteractiveHint,

writeRestartSentinel: mocks.writeRestartSentinel,

};

beforeEach(() => {

mocks.isRestartEnabled.mockReset();

mocks.isRestartEnabled.mockReturnValue(true);

mocks.unlink.mockClear();

mocks.clearRestartSentinel.mockClear();

mocks.extractDeliveryInfo.mockClear();

mocks.formatDoctorNonInteractiveHint.mockClear();

mocks.writeRestartSentinel.mockClear();

expect(mocks.triggerOpenClawRestart).not.toHaveBeenCalled();

});

it("removes the success sentinel when fallback restart fails", async () => {

it("clears the success sentinel when fallback restart fails", async () => {

mocks.triggerOpenClawRestart.mockReturnValueOnce({

ok: false,

method: "launchctl",

const result = await handleRestartCommand(restartCommandParams(), true);

expect(result?.reply?.text).toContain("Restart failed");

expect(mocks.unlink).toHaveBeenCalledWith("/tmp/sentinel.json");

expect(mocks.clearRestartSentinel).toHaveBeenCalledOnce();

});

});

import type { SessionBindingRecord } from "../../infra/outbound/session-binding-service.js";

import {

buildRestartSuccessContinuation,

clearRestartSentinel,

formatDoctorNonInteractiveHint,

removeRestartSentinelFile,

type RestartSentinelPayload,

writeRestartSentinel,

} from "../../infra/restart-sentinel.js";

const hasSigusr1Listener = process.listenerCount("SIGUSR1") > 0;

const sentinelPayload = buildRestartCommandSentinel(params);

if (hasSigusr1Listener) {

let sentinelPath: string | null = null;

let sentinelWritten = false;

scheduleGatewaySigusr1Restart({

reason: "/restart",

// Sibling session-routing guard: /restart writes a session-scoped sentinel

emitHooks: sentinelPayload

? {

beforeEmit: async () => {

sentinelPath = await writeRestartSentinel(sentinelPayload);

await writeRestartSentinel(sentinelPayload);

sentinelWritten = true;

},

afterEmitRejected: async () => {

await removeRestartSentinelFile(sentinelPath);

if (sentinelWritten) {

await clearRestartSentinel();

}

},

}

: undefined,

},

};

}

let sentinelPath: string | null = null;

let sentinelWritten = false;

try {

if (sentinelPayload) {

sentinelPath = await writeRestartSentinel(sentinelPayload);

await writeRestartSentinel(sentinelPayload);

sentinelWritten = true;

}

} catch (err) {

logVerbose(`failed to write /restart sentinel: ${String(err)}`);

}

const restartMethod = triggerOpenClawRestart();

if (!restartMethod.ok) {

await removeRestartSentinelFile(sentinelPath);

if (sentinelWritten) {

await clearRestartSentinel();

}

const detail = restartMethod.detail ? ` Details: ${restartMethod.detail}` : "";

return {

shouldContinue: false,

const updateCliShared = await import("./update-cli/shared.js");

const { ensureGitCheckout, resolveGitInstallDir } = updateCliShared;

const { spawnSync } = await import("node:child_process");

const { readRestartSentinel } = await import("../infra/restart-sentinel.js");

function requireValue<T>(value: T | undefined, label: string): T {

if (value === undefined) {

},

);

const raw = await fs.readFile(path.join(stateDir, "restart-sentinel.json"), "utf-8");

const sentinel = JSON.parse(raw) as {

payload?: {

status?: string;

message?: string | null;

continuation?: { kind?: string; message?: string };

stats?: { mode?: string; after?: { version?: string | null } };

};

};

expect(sentinel.payload?.status).toBe("ok");

expect(sentinel.payload?.message).toBe("Update requested from the agent.");

expect(sentinel.payload?.continuation).toEqual({

const sentinel = await readRestartSentinel({

OPENCLAW_STATE_DIR: stateDir,

} as NodeJS.ProcessEnv);

expect(sentinel?.payload.status).toBe("ok");

expect(sentinel?.payload.message).toBe("Update requested from the agent.");

expect(sentinel?.payload.continuation).toEqual({

kind: "agentTurn",

message: "Check the running version and finish the update report.",

});

expect(sentinel.payload?.stats?.mode).toBe("npm");

expect(sentinel.payload?.stats?.after?.version).toBe("2026.4.24");

expect(sentinel?.payload.stats?.mode).toBe("npm");

expect(sentinel?.payload.stats?.after?.version).toBe("2026.4.24");

});

it("marks the control-plane update sentinel failed when restart health verification fails", async () => {

},

);

const raw = await fs.readFile(path.join(stateDir, "restart-sentinel.json"), "utf-8");

const sentinel = JSON.parse(raw) as {

payload?: {

status?: string;

continuation?: unknown;

stats?: { reason?: string | null };

};

};

expect(sentinel.payload?.status).toBe("error");

expect(sentinel.payload?.stats?.reason).toBe("restart-unhealthy");

expect(sentinel.payload?.continuation).toBeUndefined();

const sentinel = await readRestartSentinel({

OPENCLAW_STATE_DIR: stateDir,

} as NodeJS.ProcessEnv);

expect(sentinel?.payload.status).toBe("error");

expect(sentinel?.payload.stats?.reason).toBe("restart-unhealthy");

expect(sentinel?.payload.continuation).toBeUndefined();

expect(defaultRuntime.exit).toHaveBeenCalledWith(1);

});

};

}

async function tryWriteRestartSentinelPayload(

payload: RestartSentinelPayload,

): Promise<string | null> {

async function tryWriteRestartSentinelPayload(payload: RestartSentinelPayload): Promise<boolean> {

try {

return await writeRestartSentinel(payload);

await writeRestartSentinel(payload);

return true;

} catch {

return null;

return false;

}

}

context?: GatewayRequestContext;

}): Promise<{

payload: RestartSentinelPayload;

sentinelPath: string | null;

sentinelPersisted: boolean;

restart: ReturnType<typeof scheduleGatewaySigusr1Restart> | undefined;

}> {

const { sessionKey, note, restartDelayMs, deliveryContext, threadId } =

threadId,

note,

});

const sentinelPath = await tryWriteRestartSentinelPayload(payload);

const sentinelPersisted = await tryWriteRestartSentinelPayload(payload);

const restart = shouldScheduleDirectConfigRestart({

changedPaths: params.changedPaths,

nextConfig: params.nextConfig,

`${params.mode} restart coalesced ${formatControlPlaneActor(params.actor)} delayMs=${restart.delayMs}`,

);

}

return { payload, sentinelPath, restart };

return { payload, sentinelPersisted, restart };

}

coalesced: false,

}));

const restartSentinelMocks = vi.hoisted(() => ({

writeRestartSentinel: vi.fn(async (_payload: RestartSentinelPayload) => {

return "/tmp/restart-sentinel.json";

}),

writeRestartSentinel: vi.fn(async (_payload: RestartSentinelPayload) => undefined),

}));

vi.mock("../../config/config.js", async () => {

uiHints: ConfigRedactionHints;

}): Promise<void> {

clearConfigSchemaResponseCache();

const { payload, sentinelPath, restart } = await resolveGatewayConfigRestartWriteResult({

const { payload, sentinelPersisted, restart } = await resolveGatewayConfigRestartWriteResult({

requestParams: params.requestParams,

kind: params.kind,

mode: params.mode,

config: redactConfigObject(params.writeResult.config, params.uiHints),

restart,

sentinel: {

path: sentinelPath,

persisted: sentinelPersisted,

payload,

},

},