@dyyz1993/codenomad 0.15.0

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: "codenomad.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": "CodeNomad-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/NeuralNomadsAI/CodeNomad/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": "CodeNomad-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/NeuralNomadsAI/CodeNomad/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/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;
+    }
+}

package/dist/server/__tests__/remote-proxy.test.js

@@ -0,0 +1,204 @@
+import assert from "node:assert/strict";
+import { after, afterEach, describe, it } from "node:test";
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { Agent, fetch } from "undici";
+import { RemoteProxySessionManager } from "../remote-proxy";
+import { resolveHttpsOptions } from "../tls";
+const sharedTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-remote-proxy-test-"));
+const sharedTls = resolveHttpsOptions({
+    enabled: true,
+    configDir: sharedTempDir,
+    host: "127.0.0.1",
+    logger: createStubLogger(),
+});
+if (!sharedTls) {
+    throw new Error("Failed to generate HTTPS options for remote proxy tests");
+}
+const sharedHttpsOptions = sharedTls.httpsOptions;
+const httpsDispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+const managers = new Set();
+afterEach(async () => {
+    for (const manager of managers) {
+        await disposeManager(manager);
+    }
+    managers.clear();
+});
+after(() => {
+    fs.rmSync(sharedTempDir, { recursive: true, force: true });
+    httpsDispatcher.close().catch(() => { });
+});
+describe("RemoteProxySessionManager", () => {
+    it("blocks proxying before activation and keeps bootstrap tokens scoped per session", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const session1 = await createSession(manager, `${upstreamBaseUrl}/base`);
+            const session2 = await createSession(manager, `${upstreamBaseUrl}/base`);
+            const blocked = await proxyFetch(`${session1.proxyOrigin}/status`);
+            assert.equal(blocked.status, 403);
+            const wrongTokenResponse = await proxyFetch(`${session1.proxyOrigin}/__codenomad/api/auth/token`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ token: session2.token }),
+            });
+            assert.equal(wrongTokenResponse.status, 401);
+            assert.equal(await activateSession(session1), true);
+            assert.equal(await activateSession(session2), true);
+        }, (req, res) => {
+            res.writeHead(200, { "content-type": "text/plain" });
+            res.end(req.url ?? "");
+        });
+    });
+    it("preserves remote base paths and rewrites same-origin redirects to the local proxy origin", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const session = await createSession(manager, `${upstreamBaseUrl}/base`);
+            await activateSession(session);
+            const apiResponse = await proxyFetch(`${session.proxyOrigin}/api/auth/status?foo=bar`);
+            assert.equal(apiResponse.status, 200);
+            assert.equal(await apiResponse.text(), "/base/api/auth/status?foo=bar");
+            const redirectResponse = await proxyFetch(`${session.proxyOrigin}/redirect`, { redirect: "manual" });
+            assert.equal(redirectResponse.status, 302);
+            assert.equal(redirectResponse.headers.get("location"), `${session.proxyOrigin}/base/after?ok=1`);
+        }, (req, res) => {
+            const requestUrl = req.url ?? "";
+            if (requestUrl === "/base/redirect") {
+                res.writeHead(302, { location: "/base/after?ok=1" });
+                res.end();
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/plain" });
+            res.end(requestUrl);
+        });
+    });
+    it("rewrites set-cookie names for the proxy and restores cookie names on proxied requests", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const session = await createSession(manager, `${upstreamBaseUrl}/base`);
+            await activateSession(session);
+            const loginResponse = await proxyFetch(`${session.proxyOrigin}/login`);
+            assert.equal(loginResponse.status, 200);
+            const setCookie = getSetCookie(loginResponse)[0];
+            assert.match(setCookie, /^cnrp_[0-9a-f]+_session=abc123/i);
+            assert.doesNotMatch(setCookie, /domain=/i);
+            const cookieHeader = setCookie.split(";", 1)[0];
+            const whoamiResponse = await proxyFetch(`${session.proxyOrigin}/whoami`, {
+                headers: { cookie: cookieHeader },
+            });
+            assert.equal(await whoamiResponse.text(), "session=abc123");
+        }, (req, res) => {
+            const requestUrl = req.url ?? "";
+            if (requestUrl === "/base/login") {
+                res.writeHead(200, {
+                    "content-type": "text/plain",
+                    "set-cookie": "session=abc123; Path=/; Secure; HttpOnly; Domain=127.0.0.1",
+                });
+                res.end("ok");
+                return;
+            }
+            if (requestUrl === "/base/whoami") {
+                res.writeHead(200, { "content-type": "text/plain" });
+                res.end(req.headers.cookie ?? "");
+                return;
+            }
+            res.writeHead(404, { "content-type": "text/plain" });
+            res.end(requestUrl);
+        });
+    });
+    it("supports explicit deletion and idle cleanup of sessions", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const session = await createSession(manager, `${upstreamBaseUrl}/base`);
+            assert.equal(await manager.deleteSession(session.sessionId), true);
+            assert.equal(await manager.deleteSession(session.sessionId), false);
+            const session3 = await createSession(manager, `${upstreamBaseUrl}/base`);
+            const internalSessions = manager.sessions;
+            const internalCleanup = manager.cleanupExpiredSessions;
+            internalSessions.get(session3.sessionId).lastAccessAt = Date.now() - 31 * 60000;
+            await internalCleanup.call(manager);
+            assert.equal(internalSessions.has(session3.sessionId), false);
+            assert.equal(await manager.deleteSession(session3.sessionId), false);
+        }, (_req, res) => {
+            res.writeHead(200, { "content-type": "text/plain" });
+            res.end("ok");
+        });
+    });
+});
+function createSessionManager() {
+    const manager = new RemoteProxySessionManager({
+        authManager: {
+            isLoopbackRequest: () => true,
+        },
+        logger: createStubLogger(),
+        httpsOptions: sharedHttpsOptions,
+    });
+    managers.add(manager);
+    return manager;
+}
+async function createSession(manager, baseUrl) {
+    const created = await manager.createSession(baseUrl, false);
+    const windowUrl = new URL(created.windowUrl);
+    return {
+        sessionId: created.sessionId,
+        windowUrl,
+        proxyOrigin: windowUrl.origin,
+        token: decodeURIComponent(windowUrl.hash.replace(/^#/, "")),
+    };
+}
+async function activateSession(session) {
+    const response = await proxyFetch(`${session.proxyOrigin}/__codenomad/api/auth/token`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ token: session.token }),
+    });
+    if (!response.ok) {
+        return false;
+    }
+    const body = (await response.json());
+    return body.ok === true;
+}
+function getSetCookie(response) {
+    const values = response.headers.getSetCookie?.();
+    if (Array.isArray(values) && values.length > 0) {
+        return values;
+    }
+    const fallback = response.headers.get("set-cookie");
+    return fallback ? [fallback] : [];
+}
+async function proxyFetch(url, init) {
+    return fetch(url, { dispatcher: httpsDispatcher, ...init });
+}
+async function disposeManager(manager) {
+    const sessions = Array.from(manager.sessions.keys());
+    for (const sessionId of sessions) {
+        await manager.deleteSession(sessionId);
+    }
+    clearInterval(manager.cleanupTimer);
+}
+async function withUpstreamServer(callback, handler) {
+    const server = http.createServer(handler);
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    try {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            throw new Error("Failed to resolve upstream server address");
+        }
+        await callback(`http://127.0.0.1:${address.port}`);
+    }
+    finally {
+        await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    }
+}
+function createStubLogger() {
+    const logger = {
+        info() { },
+        warn() { },
+        error() { },
+        child() {
+            return logger;
+        },
+    };
+    return logger;
+}