import type { ConnectParams } from "../../packages/gateway-protocol/src/index.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import {

normalizeNodeApprovalSurfaceList,

sameNodeApprovalSurfaceSet,

sameNodePermissionSurface,

} from "../infra/node-pairing-surface.js";

import type {

NodePairingPairedNode,

NodePairingRequestInput,

RequestNodePairingResult,

} from "../infra/node-pairing.js";

import { normalizeArrayBackedTrimmedStringList } from "../shared/string-normalization.js";

import {

normalizeDeclaredNodeCommands,

resolveNodeCommandAllowlist,

});

}

function normalizeApprovalSurfaceList(value: readonly string[] | undefined): string[] {

return normalizeArrayBackedTrimmedStringList(value) ?? [];

}

function sameApprovalSurfaceSet(

left: readonly string[] | undefined,

right: readonly string[] | undefined,

): boolean {

const normalizedLeft = new Set(normalizeApprovalSurfaceList(left));

const normalizedRight = new Set(normalizeApprovalSurfaceList(right));

if (normalizedLeft.size !== normalizedRight.size) {

return false;

}

for (const entry of normalizedLeft) {

if (!normalizedRight.has(entry)) {

return false;

}

}

return true;

}

function normalizePermissionMap(

value: Record<string, boolean> | undefined,

): Record<string, boolean> | undefined {

return entries.length > 0 ? Object.fromEntries(entries) : undefined;

}

function samePermissions(

left: Record<string, boolean> | undefined,

right: Record<string, boolean> | undefined,

): boolean {

const leftEntries = Object.entries(left ?? {}).toSorted(([leftKey], [rightKey]) =>

leftKey.localeCompare(rightKey),

);

const rightEntries = Object.entries(right ?? {}).toSorted(([leftKey], [rightKey]) =>

leftKey.localeCompare(rightKey),

);

if (leftEntries.length !== rightEntries.length) {

return false;

}

return leftEntries.every(([key, value], index) => {

const rightEntry = rightEntries[index];

return rightEntry !== undefined && rightEntry[0] === key && rightEntry[1] === value;

});

}

function intersectApprovalSurfaceList(params: {

approved: readonly string[] | undefined;

declared: readonly string[];

}): string[] {

const approved = new Set(normalizeApprovalSurfaceList(params.approved));

return normalizeApprovalSurfaceList(params.declared).filter((entry) => approved.has(entry));

const approved = new Set(normalizeNodeApprovalSurfaceList(params.approved));

return normalizeNodeApprovalSurfaceList(params.declared).filter((entry) => approved.has(entry));

}

function intersectPermissionSurface(params: {

: [],

allowlist: pairingAllowlist,

});

const declaredCaps = normalizeApprovalSurfaceList(params.connectParams.caps);

const declaredCaps = normalizeNodeApprovalSurfaceList(params.connectParams.caps);

const declaredPermissions = normalizePermissionMap(params.connectParams.permissions);

if (!params.pairedNode) {

pairedCommands: params.pairedNode.commands,

allowlist: runtimeAllowlist,

});

const approvedCaps = normalizeApprovalSurfaceList(params.pairedNode.caps);

const approvedCaps = normalizeNodeApprovalSurfaceList(params.pairedNode.caps);

const approvedPermissions = normalizePermissionMap(params.pairedNode.permissions);

const hasCommandUpgrade = declared.some((command) => !approvedCommands.includes(command));

const hasCapabilityChange = !sameApprovalSurfaceSet(params.pairedNode.caps, declaredCaps);

const hasPermissionChange = !samePermissions(params.pairedNode.permissions, declaredPermissions);

const hasCapabilityChange = !sameNodeApprovalSurfaceSet(params.pairedNode.caps, declaredCaps);

const hasPermissionChange = !sameNodePermissionSurface(

params.pairedNode.permissions,

declaredPermissions,

);

const effectiveApprovedDeclaredCaps = intersectApprovalSurfaceList({

approved: approvedCaps,

declared: declaredCaps,