import { createTestRegistry } from "../test-utils/channel-plugins.js";

import type { HeartbeatDeps } from "./heartbeat-runner.js";

export type HeartbeatSessionSeed = {

type HeartbeatSessionSeed = {

sessionId?: string;

updatedAt?: number;

lastChannel: string;

lastProvider: string;

lastTo: string;

};

export type HeartbeatReplyFn = NonNullable<HeartbeatDeps["getReplyFromConfig"]>;

type HeartbeatReplyFn = NonNullable<HeartbeatDeps["getReplyFromConfig"]>;

export type HeartbeatReplySpy = ReturnType<typeof vi.fn<HeartbeatReplyFn>>;

export function createHeartbeatReplySpy(): HeartbeatReplySpy {

function createHeartbeatReplySpy(): HeartbeatReplySpy {

const replySpy: HeartbeatReplySpy = vi.fn<HeartbeatReplyFn>();

replySpy.mockResolvedValue({ text: "ok" });

return replySpy;

import { type ArchiveLogger, extractArchive, fileExists, resolvePackedRootDir } from "./archive.js";

import { withTempDir } from "./install-source-utils.js";

export type ExistingInstallPathResult =

type ExistingInstallPathResult =

| {

ok: true;

resolvedPath: string;

export type InstallMode = "install" | "update";

type InstallMode = "install" | "update";

export type InstallModeOptions<TLogger> = {

type InstallModeOptions<TLogger> = {

logger?: TLogger;

mode?: InstallMode;

dryRun?: boolean;

};

export type TimedInstallModeOptions<TLogger> = InstallModeOptions<TLogger> & {

type TimedInstallModeOptions<TLogger> = InstallModeOptions<TLogger> & {

timeoutMs?: number;

};

import { pickPrimaryLanIPv4, resolveGatewayBindHost } from "../gateway/net.js";

import { pickPrimaryTailnetIPv4 } from "./tailnet.js";

export function summarizeDisplayNetworkError(error: unknown): string {

function summarizeDisplayNetworkError(error: unknown): string {

if (error instanceof Error) {

const message = error.message.trim();

if (message) {

return "network interface discovery failed";

}

export function fallbackBindHostForDisplay(

bindMode: GatewayBindMode,

customBindHost?: string,

): string {

function fallbackBindHostForDisplay(bindMode: GatewayBindMode, customBindHost?: string): string {

if (bindMode === "lan") {

return "0.0.0.0";

}

import os from "node:os";

export type NetworkInterfacesSnapshot = ReturnType<typeof os.networkInterfaces>;

export type NetworkInterfaceFamily = "IPv4" | "IPv6";

export type ExternalNetworkInterfaceAddress = {

type NetworkInterfaceFamily = "IPv4" | "IPv6";

type ExternalNetworkInterfaceAddress = {

name: string;

address: string;

family: NetworkInterfaceFamily;

export type NodeApprovalScope = "operator.pairing" | "operator.write" | "operator.admin";

export const OPERATOR_PAIRING_SCOPE: NodeApprovalScope = "operator.pairing";

export const OPERATOR_WRITE_SCOPE: NodeApprovalScope = "operator.write";

export const OPERATOR_ADMIN_SCOPE: NodeApprovalScope = "operator.admin";

const OPERATOR_PAIRING_SCOPE: NodeApprovalScope = "operator.pairing";

const OPERATOR_WRITE_SCOPE: NodeApprovalScope = "operator.write";

const OPERATOR_ADMIN_SCOPE: NodeApprovalScope = "operator.admin";

export function resolveNodePairApprovalScopes(commands: unknown): NodeApprovalScope[] {

const normalized = Array.isArray(commands)

import { rejectPendingPairingRequest } from "./pairing-pending.js";

import { generatePairingToken, verifyPairingToken } from "./pairing-token.js";

export type NodeDeclaredSurface = {

type NodeDeclaredSurface = {

nodeId: string;

displayName?: string;

platform?: string;

remoteIp?: string;

};

export type NodeApprovedSurface = NodeDeclaredSurface;

type NodeApprovedSurface = NodeDeclaredSurface;

export type NodePairingRequestInput = NodeDeclaredSurface & {

silent?: boolean;

ts: number;

};

export type NodePairingPendingEntry = NodePairingPendingRequest & {

type NodePairingPendingEntry = NodePairingPendingRequest & {

requiredApproveScopes: NodeApprovalScope[];

};

lastSeenReason?: string;

};

export type NodePairingList = {

type NodePairingList = {

pending: NodePairingPendingEntry[];

paired: NodePairingPairedNode[];

};

warn?: (payload: TPayload) => void;

};

export type ResolveNpmIntegrityDriftResult<TPayload> = {

type ResolveNpmIntegrityDriftResult<TPayload> = {

integrityDrift?: NpmIntegrityDrift;

proceed: boolean;

payload?: TPayload;

parseRegistryNpmSpec,

} from "./npm-registry-spec.js";

export type NpmSpecArchiveInstallFlowResult<TResult extends { ok: boolean }> =

type NpmSpecArchiveInstallFlowResult<TResult extends { ok: boolean }> =

| {

ok: false;

error: string;

import os from "node:os";

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

export type OsSummary = {

type OsSummary = {

platform: NodeJS.Platform;

arch: string;

release: string;