@vividcodeai/embeddedcowork-dev 0.0.3-dev-20260507-b76190e8

package/dist/opencode-config/plugin/lib/request.ts

@@ -0,0 +1,214 @@
+import http from "http"
+import https from "https"
+import { Readable } from "stream"
+
+export type PluginEvent = {
+  type: string
+  properties?: Record<string, unknown>
+}
+
+export type EmbeddedCoworkConfig = {
+  instanceId: string
+  baseUrl: string
+}
+
+export function getEmbeddedCoworkConfig(): EmbeddedCoworkConfig {
+  return {
+    instanceId: requireEnv("EMBEDDEDCOWORK_INSTANCE_ID"),
+    baseUrl: requireEnv("EMBEDDEDCOWORK_BASE_URL"),
+  }
+}
+
+export function createEmbeddedCoworkRequester(config: EmbeddedCoworkConfig) {
+  const rawBaseUrl = (config.baseUrl ?? "").trim()
+  const baseUrl = rawBaseUrl.replace(/\/+$/, "")
+  const pluginBase = `${baseUrl}/workspaces/${encodeURIComponent(config.instanceId)}/plugin`
+  const authorization = buildInstanceAuthorizationHeader()
+
+  const buildUrl = (path: string) => {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path
+    }
+    const normalized = path.startsWith("/") ? path : `/${path}`
+    return `${pluginBase}${normalized}`
+  }
+
+  const buildHeaders = (headers: HeadersInit | undefined, hasBody: boolean): Record<string, string> => {
+    const output: Record<string, string> = normalizeHeaders(headers)
+    output.Authorization = authorization
+    if (hasBody) {
+      output["Content-Type"] = output["Content-Type"] ?? "application/json"
+    }
+    return output
+  }
+
+  const fetchWithAuth = async (path: string, init?: RequestInit): Promise<Response> => {
+    const url = buildUrl(path)
+    const hasBody = init?.body !== undefined
+    const headers = buildHeaders(init?.headers, hasBody)
+
+    // The EmbeddedCowork plugin only talks to the local EmbeddedCowork server.
+    // Use a single request implementation that tolerates custom/self-signed certs
+    // without disabling TLS verification for the whole Node process.
+    return nodeFetch(url, { ...init, headers }, { rejectUnauthorized: false })
+  }
+
+  const requestJson = async <T>(path: string, init?: RequestInit): Promise<T> => {
+    const response = await fetchWithAuth(path, init)
+    if (!response.ok) {
+      const message = await response.text().catch(() => "")
+      throw new Error(message || `Request failed with ${response.status}`)
+    }
+
+    if (response.status === 204) {
+      return undefined as T
+    }
+
+    return (await response.json()) as T
+  }
+
+  const requestVoid = async (path: string, init?: RequestInit): Promise<void> => {
+    const response = await fetchWithAuth(path, init)
+    if (!response.ok) {
+      const message = await response.text().catch(() => "")
+      throw new Error(message || `Request failed with ${response.status}`)
+    }
+  }
+
+  const requestSseBody = async (path: string): Promise<ReadableStream<Uint8Array>> => {
+    const response = await fetchWithAuth(path, { headers: { Accept: "text/event-stream" } })
+    if (!response.ok || !response.body) {
+      throw new Error(`SSE unavailable (${response.status})`)
+    }
+    return response.body as ReadableStream<Uint8Array>
+  }
+
+  return {
+    buildUrl,
+    fetch: fetchWithAuth,
+    requestJson,
+    requestVoid,
+    requestSseBody,
+  }
+}
+
+async function nodeFetch(
+  url: string,
+  init: RequestInit & { headers?: Record<string, string> },
+  tls: { rejectUnauthorized: boolean },
+): Promise<Response> {
+  const parsed = new URL(url)
+  const isHttps = parsed.protocol === "https:"
+  const requestFn = isHttps ? https.request : http.request
+
+  const method = (init.method ?? "GET").toUpperCase()
+  const headers = init.headers ?? {}
+  const body = init.body
+
+  return await new Promise<Response>((resolve, reject) => {
+    const req = requestFn(
+      {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port ? Number(parsed.port) : undefined,
+        path: `${parsed.pathname}${parsed.search}`,
+        method,
+        headers,
+        ...(isHttps ? { rejectUnauthorized: tls.rejectUnauthorized } : {}),
+      },
+      (res) => {
+        const responseHeaders = new Headers()
+        for (const [key, value] of Object.entries(res.headers)) {
+          if (value === undefined) continue
+          if (Array.isArray(value)) {
+            responseHeaders.set(key, value.join(", "))
+          } else {
+            responseHeaders.set(key, String(value))
+          }
+        }
+
+        // Convert Node stream -> Web ReadableStream for Response.
+        const webBody = Readable.toWeb(res) as unknown as ReadableStream<Uint8Array>
+        resolve(new Response(webBody, { status: res.statusCode ?? 0, headers: responseHeaders }))
+      },
+    )
+
+    const signal = init.signal
+    const abort = () => {
+      const err = new Error("Request aborted")
+      ;(err as any).name = "AbortError"
+      req.destroy(err)
+      reject(err)
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        abort()
+        return
+      }
+      signal.addEventListener("abort", abort, { once: true })
+      req.once("close", () => signal.removeEventListener("abort", abort))
+    }
+
+    req.once("error", reject)
+
+    if (body === undefined || body === null) {
+      req.end()
+      return
+    }
+
+    if (typeof body === "string") {
+      req.end(body)
+      return
+    }
+
+    if (body instanceof Uint8Array) {
+      req.end(Buffer.from(body))
+      return
+    }
+
+    if (body instanceof ArrayBuffer) {
+      req.end(Buffer.from(new Uint8Array(body)))
+      return
+    }
+
+    // Fallback for less common BodyInit types.
+    req.end(String(body))
+  })
+}
+
+function requireEnv(key: string): string {
+  const value = process.env[key]
+  if (!value || !value.trim()) {
+    throw new Error(`[EmbeddedCoworkPlugin] Missing required env var ${key}`)
+  }
+  return value
+}
+
+function buildInstanceAuthorizationHeader(): string {
+  const username = requireEnv("OPENCODE_SERVER_USERNAME")
+  const password = requireEnv("OPENCODE_SERVER_PASSWORD")
+  const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64")
+  return `Basic ${token}`
+}
+
+function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> {
+  const output: Record<string, string> = {}
+  if (!headers) return output
+
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      output[key] = value
+    })
+    return output
+  }
+
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      output[key] = value
+    }
+    return output
+  }
+
+  return { ...headers }
+}

package/dist/opencode-config.js

@@ -0,0 +1,15 @@
+import { existsSync } from "fs";
+import { createLogger } from "./logger";
+import { resolveOpencodeTemplateDir } from "./runtime-paths";
+const log = createLogger({ component: "opencode-config" });
+const templateDir = resolveOpencodeTemplateDir(import.meta.url);
+const isDevBuild = Boolean(process.env.EMBEDDEDCOWORK_DEV ?? process.env.CLI_UI_DEV_SERVER);
+export function getOpencodeConfigDir() {
+    if (!existsSync(templateDir)) {
+        throw new Error(`EmbeddedCowork Opencode config template missing at ${templateDir}`);
+    }
+    if (isDevBuild) {
+        log.debug({ templateDir }, "Using Opencode config template directly (dev mode)");
+    }
+    return templateDir;
+}

package/dist/plugins/channel.js

@@ -0,0 +1,40 @@
+export class PluginChannelManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.clients = new Set();
+    }
+    register(workspaceId, reply) {
+        const connection = { workspaceId, reply };
+        this.clients.add(connection);
+        this.logger.debug({ workspaceId }, "Plugin SSE client connected");
+        let closed = false;
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            this.clients.delete(connection);
+            this.logger.debug({ workspaceId }, "Plugin SSE client disconnected");
+        };
+        return { close };
+    }
+    send(workspaceId, event) {
+        for (const client of this.clients) {
+            if (client.workspaceId !== workspaceId)
+                continue;
+            this.write(client.reply, event);
+        }
+    }
+    broadcast(event) {
+        for (const client of this.clients) {
+            this.write(client.reply, event);
+        }
+    }
+    write(reply, event) {
+        try {
+            reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to write plugin SSE event");
+        }
+    }
+}

package/dist/plugins/handlers.js

@@ -0,0 +1,17 @@
+export function handlePluginEvent(workspaceId, event, deps) {
+    switch (event.type) {
+        case "embeddedcowork.pong":
+            deps.logger.debug({ workspaceId, properties: event.properties }, "Plugin pong received");
+            return;
+        default:
+            deps.logger.debug({ workspaceId, eventType: event.type }, "Unhandled plugin event");
+    }
+}
+export function buildPingEvent() {
+    return {
+        type: "embeddedcowork.ping",
+        properties: {
+            ts: Date.now(),
+        },
+    };
+}

package/dist/plugins/voice-mode.js

@@ -0,0 +1,78 @@
+export class VoiceModeManager {
+    constructor(options) {
+        this.options = options;
+        this.enabledConnectionsByInstance = new Map();
+        this.aggregateByInstance = new Map();
+        this.options.connections.subscribe((event) => {
+            if (event.type !== "disconnected")
+                return;
+            this.clearConnection(event.connection);
+        });
+    }
+    setEnabled(instanceId, connection, enabled) {
+        if (enabled && !this.options.connections.isConnected(connection)) {
+            this.options.logger.debug({ instanceId, clientId: connection.clientId, connectionId: connection.connectionId }, "Ignoring voice mode enable for disconnected client connection");
+            return false;
+        }
+        const key = getConnectionKey(connection);
+        const current = this.enabledConnectionsByInstance.get(instanceId) ?? new Set();
+        if (enabled) {
+            current.add(key);
+            this.enabledConnectionsByInstance.set(instanceId, current);
+        }
+        else if (current.delete(key)) {
+            if (current.size === 0) {
+                this.enabledConnectionsByInstance.delete(instanceId);
+            }
+            else {
+                this.enabledConnectionsByInstance.set(instanceId, current);
+            }
+        }
+        this.options.logger.debug({ instanceId, clientId: connection.clientId, connectionId: connection.connectionId, enabled }, "Voice mode updated for client connection");
+        this.publishIfChanged(instanceId);
+        return true;
+    }
+    syncInstance(instanceId) {
+        this.options.channel.send(instanceId, buildVoiceModeEvent(this.isEnabled(instanceId)));
+    }
+    isEnabled(instanceId) {
+        return this.aggregateByInstance.get(instanceId) === true;
+    }
+    clearConnection(connection) {
+        const key = getConnectionKey(connection);
+        for (const [instanceId, enabledConnections] of Array.from(this.enabledConnectionsByInstance.entries())) {
+            if (!enabledConnections.delete(key))
+                continue;
+            if (enabledConnections.size === 0) {
+                this.enabledConnectionsByInstance.delete(instanceId);
+            }
+            this.publishIfChanged(instanceId);
+        }
+    }
+    publishIfChanged(instanceId) {
+        const enabled = (this.enabledConnectionsByInstance.get(instanceId)?.size ?? 0) > 0;
+        const previous = this.aggregateByInstance.get(instanceId) === true;
+        if (enabled === previous)
+            return;
+        if (enabled) {
+            this.aggregateByInstance.set(instanceId, true);
+        }
+        else {
+            this.aggregateByInstance.delete(instanceId);
+        }
+        this.options.logger.debug({ instanceId, enabled }, "Broadcasting aggregate voice mode");
+        this.options.channel.send(instanceId, buildVoiceModeEvent(enabled));
+    }
+}
+function buildVoiceModeEvent(enabled) {
+    return {
+        type: "embeddedcowork.voiceMode",
+        properties: {
+            enabled,
+            formatVersion: "v1",
+        },
+    };
+}
+function getConnectionKey(connection) {
+    return `${connection.clientId}:${connection.connectionId}`;
+}

package/dist/releases/dev-release-monitor.js

@@ -0,0 +1,75 @@
+import { fetch } from "undici";
+import { compareVersionStrings, stripTagPrefix } from "./release-monitor";
+const DEFAULT_POLL_INTERVAL_MS = 15 * 60 * 1000;
+export function startDevReleaseMonitor(options) {
+    let stopped = false;
+    let timer = null;
+    const pollIntervalMs = Number.isFinite(options.pollIntervalMs) && (options.pollIntervalMs ?? 0) > 0
+        ? options.pollIntervalMs
+        : DEFAULT_POLL_INTERVAL_MS;
+    const refresh = async () => {
+        if (stopped)
+            return;
+        try {
+            const release = await fetchLatestPrerelease({
+                repo: options.repo,
+                currentVersion: options.currentVersion,
+            });
+            options.onUpdate(release);
+        }
+        catch (error) {
+            options.logger.debug({ err: error }, "Failed to refresh dev prerelease information");
+        }
+    };
+    void refresh();
+    timer = setInterval(() => void refresh(), pollIntervalMs);
+    return {
+        stop() {
+            stopped = true;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+    };
+}
+async function fetchLatestPrerelease(args) {
+    const normalizedRepo = args.repo.trim();
+    if (!/^[^/\s]+\/[^/\s]+$/.test(normalizedRepo)) {
+        throw new Error(`Invalid GitHub repo: ${args.repo}`);
+    }
+    const apiUrl = `https://api.github.com/repos/${normalizedRepo}/releases?per_page=20`;
+    const response = await fetch(apiUrl, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "EmbeddedCowork-CLI",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub releases API responded with ${response.status}`);
+    }
+    const list = (await response.json());
+    const latest = list.find((r) => r && r.prerelease === true && r.draft !== true);
+    if (!latest) {
+        return null;
+    }
+    const tag = latest.tag_name || latest.name;
+    if (!tag) {
+        return null;
+    }
+    const normalizedVersion = stripTagPrefix(tag);
+    if (!normalizedVersion) {
+        return null;
+    }
+    if (compareVersionStrings(normalizedVersion, args.currentVersion) <= 0) {
+        return null;
+    }
+    return {
+        version: normalizedVersion,
+        tag,
+        url: latest.html_url ?? `https://github.com/${normalizedRepo}/releases/tag/${encodeURIComponent(tag)}`,
+        channel: "dev",
+        publishedAt: latest.published_at ?? latest.created_at,
+        notes: latest.body,
+    };
+}

package/dist/releases/release-monitor.js

@@ -0,0 +1,107 @@
+import { fetch } from "undici";
+const RELEASES_API_URL = "https://api.github.com/repos/vividcode-ai/EmbeddedCowork/releases/latest";
+export function startReleaseMonitor(options) {
+    let stopped = false;
+    const refreshRelease = async () => {
+        if (stopped)
+            return;
+        try {
+            const release = await fetchLatestRelease(options);
+            options.onUpdate(release);
+        }
+        catch (error) {
+            options.logger.warn({ err: error }, "Failed to refresh release information");
+        }
+    };
+    void refreshRelease();
+    return {
+        stop() {
+            stopped = true;
+        },
+    };
+}
+export function compareVersionStrings(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    return compareVersions(left, right);
+}
+async function fetchLatestRelease(options) {
+    const response = await fetch(RELEASES_API_URL, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "EmbeddedCowork-CLI",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Release API responded with ${response.status}`);
+    }
+    const json = (await response.json());
+    const tagFromServer = json.tag_name || json.name;
+    if (!tagFromServer) {
+        return null;
+    }
+    const normalizedVersion = stripTagPrefix(tagFromServer);
+    if (!normalizedVersion) {
+        return null;
+    }
+    const current = parseVersion(options.currentVersion);
+    const remote = parseVersion(normalizedVersion);
+    if (compareVersions(remote, current) <= 0) {
+        return null;
+    }
+    return {
+        version: normalizedVersion,
+        tag: tagFromServer,
+        url: json.html_url ?? `https://github.com/vividcode-ai/EmbeddedCowork/releases/tag/${encodeURIComponent(tagFromServer)}`,
+        channel: json.prerelease || normalizedVersion.includes("-") ? "dev" : "stable",
+        publishedAt: json.published_at ?? json.created_at,
+        notes: json.body,
+    };
+}
+export function stripTagPrefix(tag) {
+    if (!tag)
+        return null;
+    const trimmed = tag.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.replace(/^v/i, "");
+}
+function parseVersion(value) {
+    const normalized = stripTagPrefix(value) ?? "0.0.0";
+    const dashIndex = normalized.indexOf("-");
+    const core = dashIndex >= 0 ? normalized.slice(0, dashIndex) : normalized;
+    const prerelease = dashIndex >= 0 ? normalized.slice(dashIndex + 1) : null;
+    const [major = 0, minor = 0, patch = 0] = core.split(".").map((segment) => {
+        const parsed = Number.parseInt(segment, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    return {
+        major,
+        minor,
+        patch,
+        prerelease,
+    };
+}
+function compareVersions(a, b) {
+    if (a.major !== b.major) {
+        return a.major > b.major ? 1 : -1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor > b.minor ? 1 : -1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch > b.patch ? 1 : -1;
+    }
+    const aPre = a.prerelease && a.prerelease.length > 0 ? a.prerelease : null;
+    const bPre = b.prerelease && b.prerelease.length > 0 ? b.prerelease : null;
+    if (aPre === bPre) {
+        return 0;
+    }
+    if (!aPre) {
+        return 1;
+    }
+    if (!bPre) {
+        return -1;
+    }
+    return aPre.localeCompare(bPre);
+}

package/dist/runtime-paths.js

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function safeModuleDir(importMetaUrl) {
+    try {
+        return path.dirname(fileURLToPath(importMetaUrl));
+    }
+    catch {
+        return null;
+    }
+}
+function firstExistingPath(candidates, predicate) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (predicate(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function getPackagedDistDir() {
+    return path.dirname(process.execPath);
+}
+export function resolveServerPackageRoot(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const configuredRoot = process.env.EMBEDDEDCOWORK_SERVER_ROOT?.trim();
+    const candidates = [
+        configuredRoot ? path.resolve(configuredRoot) : null,
+        moduleDir ? path.resolve(moduleDir, "..") : null,
+        path.resolve(getPackagedDistDir(), ".."),
+    ];
+    return (firstExistingPath(candidates, (value) => fs.existsSync(path.join(value, "package.json"))) ??
+        candidates.find((value) => Boolean(value)) ??
+        process.cwd());
+}
+export function resolveServerPublicDir(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const candidates = [moduleDir ? path.resolve(moduleDir, "../public") : null, path.join(resolveServerPackageRoot(importMetaUrl), "public")];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[candidates.length - 1];
+}
+export function resolveAuthTemplatePath(importMetaUrl, fileName) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const distDir = getPackagedDistDir();
+    const candidates = [
+        moduleDir ? path.join(moduleDir, "auth-pages", fileName) : null,
+        path.join(distDir, "auth-pages", fileName),
+        path.join(distDir, "server", "routes", "auth-pages", fileName),
+    ];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[0];
+}
+export function resolveOpencodeTemplateDir(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const resourcesPath = process.resourcesPath;
+    const candidates = [
+        moduleDir ? path.resolve(moduleDir, "../../opencode-config") : null,
+        resourcesPath ? path.resolve(resourcesPath, "opencode-config") : null,
+        moduleDir ? path.resolve(moduleDir, "opencode-config") : null,
+        path.join(getPackagedDistDir(), "opencode-config"),
+    ];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[candidates.length - 1];
+}
+export function readServerPackageVersion(importMetaUrl) {
+    const packageJsonPath = path.join(resolveServerPackageRoot(importMetaUrl), "package.json");
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version : "0.0.0";
+}

package/dist/server/__tests__/network-addresses.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import os from "node:os";
+import { describe, it } from "node:test";
+import { resolveNetworkAddresses, resolveRemoteAddresses } from "../network-addresses";
+describe("resolveNetworkAddresses", () => {
+    it("preserves interface order among external addresses", () => {
+        const addresses = [
+            { address: "172.24.0.1", family: "IPv4", internal: false },
+            { address: "192.168.1.128", family: "IPv4", internal: false },
+            { address: "10.0.0.8", family: 4, internal: false },
+            { address: "127.0.0.1", family: "IPv4", internal: true },
+            { address: "169.254.10.20", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveNetworkAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.map((entry) => entry.ip), ["172.24.0.1", "192.168.1.128", "10.0.0.8", "169.254.10.20", "127.0.0.1"]);
+        });
+    });
+});
+describe("resolveRemoteAddresses", () => {
+    it("keeps all external addresses user-visible while preferring non-link-local addresses for the primary URL", () => {
+        const addresses = [
+            { address: "169.254.10.20", family: "IPv4", internal: false },
+            { address: "192.168.1.128", family: "IPv4", internal: false },
+            { address: "172.24.0.1", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveRemoteAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.userVisible.map((entry) => entry.ip), ["192.168.1.128", "172.24.0.1", "169.254.10.20"]);
+            assert.equal(result.primaryRemoteUrl, "https://192.168.1.128:9898");
+        });
+    });
+    it("prefers private LAN addresses over public addresses", () => {
+        const addresses = [
+            { address: "203.0.113.40", family: "IPv4", internal: false },
+            { address: "192.168.1.128", family: "IPv4", internal: false },
+            { address: "8.8.8.8", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveRemoteAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.userVisible.map((entry) => entry.ip), ["192.168.1.128", "203.0.113.40", "8.8.8.8"]);
+            assert.equal(result.primaryRemoteUrl, "https://192.168.1.128:9898");
+        });
+    });
+    it("uses a public address when no private LAN address is available", () => {
+        const addresses = [
+            { address: "169.254.10.20", family: "IPv4", internal: false },
+            { address: "203.0.113.40", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveRemoteAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.userVisible.map((entry) => entry.ip), ["203.0.113.40", "169.254.10.20"]);
+            assert.equal(result.primaryRemoteUrl, "https://203.0.113.40:9898");
+        });
+    });
+});
+function usingMockedNetworkInterfaces(addresses, callback) {
+    const original = os.networkInterfaces;
+    os.networkInterfaces = (() => ({
+        ethernet0: addresses,
+    }));
+    try {
+        callback();
+    }
+    finally {
+        os.networkInterfaces = original;
+    }
+}