} from "../infra/exec-inline-eval.js";

import { buildNodeShellCommand } from "../infra/node-shell.js";

import { parsePreparedSystemRunPayload } from "../infra/system-run-approval-context.js";

import { formatExecCommand, resolveSystemRunCommandRequest } from "../infra/system-run-command.js";

import { normalizeNullableString } from "../shared/string-coerce.js";

import type { ExecuteNodeHostCommandParams } from "./bash-tools.exec-host-node.js";

import type { ExecToolDetails } from "./bash-tools.exec-types.js";

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

argv: string[];

env: Record<string, string> | undefined;

invokeTimeoutMs: number;

supportsSystemRunPrepare: boolean;

};

export type PreparedNodeRun = {

throw err;

}

const nodeInfo = nodes.find((entry) => entry.nodeId === nodeId);

const supportsSystemRun = Array.isArray(nodeInfo?.commands)

? nodeInfo?.commands?.includes("system.run")

: false;

const declaredCommands = Array.isArray(nodeInfo?.commands) ? nodeInfo.commands : [];

const supportsSystemRun = declaredCommands.includes("system.run");

if (!supportsSystemRun) {

throw new Error(

"exec host=node requires a node that supports system.run (companion app or node host).",

1000 +

5_000,

),

supportsSystemRunPrepare: declaredCommands.includes("system.run.prepare"),

};

}

request: ExecuteNodeHostCommandParams;

target: NodeExecutionTarget;

}): Promise<PreparedNodeRun> {

if (!params.target.supportsSystemRunPrepare) {

return buildLocalPreparedNodeRun(params);

}

const prepareRaw = await callGatewayTool(

"node.invoke",

{ timeoutMs: 15_000 },

};

}

function buildLocalPreparedNodeRun(params: {

request: ExecuteNodeHostCommandParams;

target: NodeExecutionTarget;

}): PreparedNodeRun {

const command = resolveSystemRunCommandRequest({

command: params.target.argv,

rawCommand: params.request.command,

});

if (!command.ok) {

throw new Error(command.message);

}

if (command.argv.length === 0) {

throw new Error("command required");

}

const commandText = formatExecCommand(command.argv);

const previewText = command.previewText?.trim();

const commandPreview = previewText && previewText !== commandText ? previewText : null;

const plan = {

argv: [...command.argv],

cwd: normalizeNullableString(params.request.workdir),

commandText,

commandPreview,

agentId: normalizeNullableString(params.request.agentId),

sessionKey: normalizeNullableString(params.request.sessionKey),

} satisfies SystemRunApprovalPlan;

return {

plan,

argv: plan.argv,

rawCommand: plan.commandText,

cwd: plan.cwd ?? params.request.workdir,

agentId: plan.agentId ?? params.request.agentId,

sessionKey: plan.sessionKey ?? params.request.sessionKey,

};

}

export async function analyzeNodeApprovalRequirement(params: {

request: ExecuteNodeHostCommandParams;

target: NodeExecutionTarget;