@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/installation-id.js

@@ -0,0 +1,692 @@
+import { createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync, randomUUID, sign, verify, } from "node:crypto";
+import { chmodSync, closeSync, constants, fchmodSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, fsyncSync, } from "node:fs";
+import { chmod, link, lstat, mkdir, open, readFile, rm, } from "node:fs/promises";
+import { join } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import { encodeServerAcceptedProofPayload, encodeServerHelloProofPayload, } from "@rynx-ai/protocol/direct-runtime";
+const INSTALLATION_ID_FILE = "installation-id";
+const INSTALLATION_KEY_FILE = "installation-key.json";
+const DIRECT_RUNTIME_ENCRYPTION_KEY_FILE = "direct-runtime-encryption-key.json";
+const INSTALLATION_KEY_VERSION = 1;
+const DIRECT_RUNTIME_ENCRYPTION_KEY_VERSION = 1;
+const INSTALLATION_PROOF_DOMAIN = "rynx-plugin-installation-proof-v1";
+const INSTALLATION_HOME_MODE = 0o700;
+const INSTALLATION_FILE_MODE = 0o600;
+// Windows keeps the legacy compatibility path until an ACL/keychain-backed
+// implementation can make equivalent ownership and no-follow guarantees.
+const CHECK_POSIX_SECURITY = process.platform === "darwin" || process.platform === "linux";
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function daemonInstallationIdFile(env = process.env) {
+    return join(rynxHome(env), INSTALLATION_ID_FILE);
+}
+export function daemonInstallationKeyFile(env = process.env) {
+    return join(rynxHome(env), INSTALLATION_KEY_FILE);
+}
+export function daemonDirectRuntimeEncryptionKeyFile(env = process.env) {
+    return join(rynxHome(env), DIRECT_RUNTIME_ENCRYPTION_KEY_FILE);
+}
+/** Direct hosting requires ownership/mode/no-follow checks for its persistent server key. */
+export function isDaemonDirectRuntimeHostingSupported(platform = process.platform) {
+    return platform === "darwin" || platform === "linux";
+}
+/** Load or atomically create the daemon's persistent Direct Runtime E2EE key. */
+export async function loadOrCreateDaemonDirectRuntimeEncryptionIdentity(env = process.env) {
+    if (!isDaemonDirectRuntimeHostingSupported()) {
+        throw new Error("Direct Runtime hosting is supported only on macOS and Linux until protected server-key storage is available on other operating systems");
+    }
+    return await withSecureInstallationHome(rynxHome(env), async () => {
+        const key = await loadOrCreateDirectRuntimeEncryptionKey(env);
+        return directRuntimeEncryptionIdentity(key);
+    });
+}
+/** Load the stable installation id and proof key without exposing private key material. */
+export async function loadOrCreateDaemonInstallationIdentity(env = process.env) {
+    return await withSecureInstallationHome(rynxHome(env), async () => {
+        const key = await loadOrCreateInstallationKey(env);
+        const installationId = await loadOrCreateDaemonInstallationIdAfterKey(env);
+        return installationIdentity(installationId, key);
+    });
+}
+/** Synchronous composition-root variant used before spawning an explicit plugin CLI. */
+export function loadOrCreateDaemonInstallationIdentitySync(env = process.env) {
+    return withSecureInstallationHomeSync(rynxHome(env), () => {
+        const key = loadOrCreateInstallationKeySync(env);
+        const installationId = loadOrCreateDaemonInstallationIdAfterKeySync(env);
+        return installationIdentity(installationId, key);
+    });
+}
+/** Load the public ID, creating the proof key first on a new installation. */
+export async function loadOrCreateDaemonInstallationId(env = process.env) {
+    return await withSecureInstallationHome(rynxHome(env), async () => {
+        await loadOrCreateInstallationKey(env);
+        return await loadOrCreateDaemonInstallationIdAfterKey(env);
+    });
+}
+async function loadOrCreateDaemonInstallationIdAfterKey(env) {
+    const file = daemonInstallationIdFile(env);
+    try {
+        return await readInstallationId(file);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    const candidate = randomUUID();
+    const handle = await open(temporary, "wx", INSTALLATION_FILE_MODE);
+    try {
+        await handle.writeFile(`${candidate}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        // A hard link publishes the fully written inode without replacing an ID
+        // concurrently created by another daemon startup.
+        try {
+            await link(temporary, file);
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return await readInstallationId(file);
+}
+/** Synchronous variant for CLI dispatch, which must pin the plugin before yielding. */
+export function loadOrCreateDaemonInstallationIdSync(env = process.env) {
+    return withSecureInstallationHomeSync(rynxHome(env), () => {
+        loadOrCreateInstallationKeySync(env);
+        return loadOrCreateDaemonInstallationIdAfterKeySync(env);
+    });
+}
+function loadOrCreateDaemonInstallationIdAfterKeySync(env) {
+    const file = daemonInstallationIdFile(env);
+    try {
+        return readInstallationIdSync(file);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    const candidate = randomUUID();
+    const fd = openSync(temporary, "wx", INSTALLATION_FILE_MODE);
+    try {
+        writeFileSync(fd, `${candidate}\n`, "utf8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    try {
+        try {
+            linkSync(temporary, file);
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+    return readInstallationIdSync(file);
+}
+async function readInstallationId(file) {
+    const raw = CHECK_POSIX_SECURITY
+        ? await readSecureInstallationFile(file)
+        : await readFile(file, "utf8");
+    const value = raw.trim();
+    if (!UUID_V4_PATTERN.test(value)) {
+        throw new Error(`invalid daemon installation ID in ${file}`);
+    }
+    if (!CHECK_POSIX_SECURITY)
+        await chmod(file, INSTALLATION_FILE_MODE);
+    return value;
+}
+function readInstallationIdSync(file) {
+    const raw = CHECK_POSIX_SECURITY
+        ? readSecureInstallationFileSync(file)
+        : readFileSync(file, "utf8");
+    const value = raw.trim();
+    if (!UUID_V4_PATTERN.test(value)) {
+        throw new Error(`invalid daemon installation ID in ${file}`);
+    }
+    if (!CHECK_POSIX_SECURITY)
+        chmodSync(file, INSTALLATION_FILE_MODE);
+    return value;
+}
+async function loadOrCreateInstallationKey(env) {
+    const file = daemonInstallationKeyFile(env);
+    try {
+        return await readInstallationKey(file);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    await assertNoInstallationIdWithoutKey(env);
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    const candidate = generateInstallationKey();
+    const handle = await open(temporary, "wx", INSTALLATION_FILE_MODE);
+    try {
+        await handle.writeFile(`${JSON.stringify(candidate, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        try {
+            await link(temporary, file);
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return await readInstallationKey(file);
+}
+async function loadOrCreateDirectRuntimeEncryptionKey(env) {
+    const file = daemonDirectRuntimeEncryptionKeyFile(env);
+    try {
+        return await readDirectRuntimeEncryptionKey(file);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    const candidate = generateDirectRuntimeEncryptionKey();
+    const handle = await open(temporary, "wx", INSTALLATION_FILE_MODE);
+    try {
+        await handle.writeFile(`${JSON.stringify(candidate, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        // Publish without replacing a key concurrently created by another caller.
+        try {
+            await link(temporary, file);
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return await readDirectRuntimeEncryptionKey(file);
+}
+function loadOrCreateInstallationKeySync(env) {
+    const file = daemonInstallationKeyFile(env);
+    try {
+        return readInstallationKeySync(file);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    assertNoInstallationIdWithoutKeySync(env);
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    const candidate = generateInstallationKey();
+    const fd = openSync(temporary, "wx", INSTALLATION_FILE_MODE);
+    try {
+        writeFileSync(fd, `${JSON.stringify(candidate, null, 2)}\n`, "utf8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    try {
+        try {
+            linkSync(temporary, file);
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+    return readInstallationKeySync(file);
+}
+async function assertNoInstallationIdWithoutKey(env) {
+    const file = daemonInstallationIdFile(env);
+    try {
+        await readInstallationId(file);
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return;
+        throw error;
+    }
+    throw new Error(`daemon installation key is missing for existing installation ID in ${file}`);
+}
+function assertNoInstallationIdWithoutKeySync(env) {
+    const file = daemonInstallationIdFile(env);
+    try {
+        readInstallationIdSync(file);
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return;
+        throw error;
+    }
+    throw new Error(`daemon installation key is missing for existing installation ID in ${file}`);
+}
+async function readInstallationKey(file) {
+    const raw = CHECK_POSIX_SECURITY
+        ? await readSecureInstallationFile(file)
+        : await readFile(file, "utf8");
+    const key = parseInstallationKey(raw, file);
+    if (!CHECK_POSIX_SECURITY)
+        await chmod(file, INSTALLATION_FILE_MODE);
+    return key;
+}
+async function readDirectRuntimeEncryptionKey(file) {
+    const raw = CHECK_POSIX_SECURITY
+        ? await readSecureInstallationFile(file)
+        : await readFile(file, "utf8");
+    const key = parseDirectRuntimeEncryptionKey(raw, file);
+    if (!CHECK_POSIX_SECURITY)
+        await chmod(file, INSTALLATION_FILE_MODE);
+    return key;
+}
+function readInstallationKeySync(file) {
+    const raw = CHECK_POSIX_SECURITY
+        ? readSecureInstallationFileSync(file)
+        : readFileSync(file, "utf8");
+    const key = parseInstallationKey(raw, file);
+    if (!CHECK_POSIX_SECURITY)
+        chmodSync(file, INSTALLATION_FILE_MODE);
+    return key;
+}
+async function withSecureInstallationHome(home, operation) {
+    await mkdir(home, { recursive: true, mode: INSTALLATION_HOME_MODE });
+    if (!CHECK_POSIX_SECURITY)
+        return await operation();
+    let handle;
+    try {
+        handle = await open(home, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        throw new Error(`daemon installation home must be a non-symlink directory: ${messageOf(error)}`, { cause: error });
+    }
+    try {
+        const identity = fileIdentity(await secureInstallationHandle(handle, home, "directory", INSTALLATION_HOME_MODE));
+        try {
+            return await operation();
+        }
+        finally {
+            await secureInstallationHandle(handle, home, "directory", INSTALLATION_HOME_MODE, identity);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+function withSecureInstallationHomeSync(home, operation) {
+    mkdirSync(home, { recursive: true, mode: INSTALLATION_HOME_MODE });
+    if (!CHECK_POSIX_SECURITY)
+        return operation();
+    let fd;
+    try {
+        fd = openSync(home, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        throw new Error(`daemon installation home must be a non-symlink directory: ${messageOf(error)}`, { cause: error });
+    }
+    try {
+        const identity = fileIdentity(secureInstallationHandleSync(fd, home, "directory", INSTALLATION_HOME_MODE));
+        try {
+            return operation();
+        }
+        finally {
+            secureInstallationHandleSync(fd, home, "directory", INSTALLATION_HOME_MODE, identity);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+async function readSecureInstallationFile(file) {
+    let handle;
+    try {
+        handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            throw error;
+        throw new Error(`daemon installation file must be a non-symlink regular file: ${messageOf(error)}`, { cause: error });
+    }
+    let bytes;
+    let before;
+    try {
+        before = await secureInstallationHandle(handle, file, "file", INSTALLATION_FILE_MODE);
+        const expected = fileIdentity(before);
+        bytes = await handle.readFile();
+        const after = await secureInstallationHandle(handle, file, "file", INSTALLATION_FILE_MODE, expected);
+        assertInstallationReadStable(before, after, bytes.byteLength);
+    }
+    finally {
+        await handle.close();
+    }
+    await assertSecureInstallationPath(file, before, "file", INSTALLATION_FILE_MODE);
+    return bytes.toString("utf8");
+}
+function readSecureInstallationFileSync(file) {
+    let fd;
+    try {
+        fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            throw error;
+        throw new Error(`daemon installation file must be a non-symlink regular file: ${messageOf(error)}`, { cause: error });
+    }
+    let bytes;
+    let before;
+    try {
+        before = secureInstallationHandleSync(fd, file, "file", INSTALLATION_FILE_MODE);
+        const expected = fileIdentity(before);
+        bytes = readFileSync(fd);
+        const after = secureInstallationHandleSync(fd, file, "file", INSTALLATION_FILE_MODE, expected);
+        assertInstallationReadStable(before, after, bytes.byteLength);
+    }
+    finally {
+        closeSync(fd);
+    }
+    assertSecureInstallationPathSync(file, before, "file", INSTALLATION_FILE_MODE);
+    return bytes.toString("utf8");
+}
+async function secureInstallationHandle(handle, path, kind, expectedMode, expected) {
+    let stats = await handle.stat({ bigint: true });
+    assertInstallationMetadata(stats, kind);
+    if (expected) {
+        assertSameFile(expected, stats, `daemon installation ${kind} changed during access`);
+    }
+    if (permissionMode(stats) !== expectedMode) {
+        try {
+            await handle.chmod(expectedMode);
+        }
+        catch (error) {
+            throw new Error(`failed to secure daemon installation ${kind} permissions: ${messageOf(error)}`);
+        }
+        stats = await handle.stat({ bigint: true });
+    }
+    assertInstallationMetadata(stats, kind);
+    assertMode(stats, expectedMode, `daemon installation ${kind}`);
+    if (expected) {
+        assertSameFile(expected, stats, `daemon installation ${kind} changed during access`);
+    }
+    await assertSecureInstallationPath(path, stats, kind, expectedMode);
+    return stats;
+}
+function secureInstallationHandleSync(fd, path, kind, expectedMode, expected) {
+    let stats = fstatSync(fd, { bigint: true });
+    assertInstallationMetadata(stats, kind);
+    if (expected) {
+        assertSameFile(expected, stats, `daemon installation ${kind} changed during access`);
+    }
+    if (permissionMode(stats) !== expectedMode) {
+        try {
+            fchmodSync(fd, expectedMode);
+        }
+        catch (error) {
+            throw new Error(`failed to secure daemon installation ${kind} permissions: ${messageOf(error)}`);
+        }
+        stats = fstatSync(fd, { bigint: true });
+    }
+    assertInstallationMetadata(stats, kind);
+    assertMode(stats, expectedMode, `daemon installation ${kind}`);
+    if (expected) {
+        assertSameFile(expected, stats, `daemon installation ${kind} changed during access`);
+    }
+    assertSecureInstallationPathSync(path, stats, kind, expectedMode);
+    return stats;
+}
+async function assertSecureInstallationPath(path, opened, kind, expectedMode) {
+    const current = await lstat(path, { bigint: true });
+    assertInstallationMetadata(current, kind);
+    assertMode(current, expectedMode, `daemon installation ${kind}`);
+    assertSameFile(fileIdentity(opened), current, `daemon installation ${kind} changed during access`);
+}
+function assertSecureInstallationPathSync(path, opened, kind, expectedMode) {
+    const current = lstatSync(path, { bigint: true });
+    assertInstallationMetadata(current, kind);
+    assertMode(current, expectedMode, `daemon installation ${kind}`);
+    assertSameFile(fileIdentity(opened), current, `daemon installation ${kind} changed during access`);
+}
+function assertInstallationMetadata(stats, kind) {
+    const valid = kind === "directory" ? stats.isDirectory() : stats.isFile();
+    if (stats.isSymbolicLink() || !valid) {
+        throw new Error(kind === "directory"
+            ? "daemon installation home must be a non-symlink directory"
+            : "daemon installation file must be a non-symlink regular file");
+    }
+    assertCurrentUserOwner(stats, kind === "directory" ? "daemon installation home" : "daemon installation file");
+}
+function assertCurrentUserOwner(stats, label) {
+    if (typeof process.getuid !== "function") {
+        throw new Error(`${label} ownership cannot be verified`);
+    }
+    if (stats.uid !== BigInt(process.getuid())) {
+        throw new Error(`${label} is not owned by the current user`);
+    }
+}
+function assertMode(stats, expectedMode, label) {
+    if (permissionMode(stats) !== expectedMode) {
+        throw new Error(`${label} permissions are unsafe`);
+    }
+}
+function permissionMode(stats) {
+    return Number(stats.mode & 511n);
+}
+function fileIdentity(stats) {
+    return { dev: stats.dev, ino: stats.ino };
+}
+function assertSameFile(expected, actual, message) {
+    if (actual.dev !== expected.dev || actual.ino !== expected.ino)
+        throw new Error(message);
+}
+function assertInstallationReadStable(before, after, bytesRead) {
+    // Atomic publication temporarily gives the inode two hard links; removing
+    // the private temporary name changes ctime/nlink without changing content.
+    const publicationCleanup = before.nlink === 2n && after.nlink === 1n;
+    if (before.size !== after.size ||
+        before.mtimeNs !== after.mtimeNs ||
+        (before.ctimeNs !== after.ctimeNs && !publicationCleanup) ||
+        after.size !== BigInt(bytesRead)) {
+        throw new Error("daemon installation file changed while reading");
+    }
+}
+function generateInstallationKey() {
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+    return {
+        version: INSTALLATION_KEY_VERSION,
+        algorithm: "Ed25519",
+        publicKey: publicKey.export({ type: "spki", format: "der" }).toString("base64url"),
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+    };
+}
+function generateDirectRuntimeEncryptionKey() {
+    const { publicKey, privateKey } = generateKeyPairSync("x25519");
+    return {
+        version: DIRECT_RUNTIME_ENCRYPTION_KEY_VERSION,
+        algorithm: "X25519",
+        publicKey: publicKey.export({ type: "spki", format: "der" }).toString("base64url"),
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+    };
+}
+function parseInstallationKey(raw, file) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`invalid daemon installation key in ${file}: ${messageOf(error)}`);
+    }
+    if (!isRecord(value) || value.version !== INSTALLATION_KEY_VERSION || value.algorithm !== "Ed25519") {
+        throw new Error(`invalid daemon installation key in ${file}`);
+    }
+    if (typeof value.publicKey !== "string" || typeof value.privateKeyPem !== "string") {
+        throw new Error(`invalid daemon installation key in ${file}`);
+    }
+    try {
+        const privateKey = createPrivateKey(value.privateKeyPem);
+        const publicKey = createPublicKey({
+            key: Buffer.from(value.publicKey, "base64url"),
+            type: "spki",
+            format: "der",
+        });
+        if (privateKey.asymmetricKeyType !== "ed25519" || publicKey.asymmetricKeyType !== "ed25519") {
+            throw new Error("installation proof key must use Ed25519");
+        }
+        const probe = Buffer.from("rynx-installation-key-validation", "utf8");
+        const signature = sign(null, probe, privateKey);
+        if (!verify(null, probe, publicKey, signature))
+            throw new Error("public and private keys do not match");
+    }
+    catch (error) {
+        throw new Error(`invalid daemon installation key in ${file}: ${messageOf(error)}`);
+    }
+    return {
+        version: INSTALLATION_KEY_VERSION,
+        algorithm: "Ed25519",
+        publicKey: value.publicKey,
+        privateKeyPem: value.privateKeyPem,
+    };
+}
+function parseDirectRuntimeEncryptionKey(raw, file) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`invalid daemon Direct Runtime encryption key in ${file}: ${messageOf(error)}`);
+    }
+    if (!isRecord(value) ||
+        value.version !== DIRECT_RUNTIME_ENCRYPTION_KEY_VERSION ||
+        value.algorithm !== "X25519" ||
+        typeof value.publicKey !== "string" ||
+        typeof value.privateKeyPem !== "string") {
+        throw new Error(`invalid daemon Direct Runtime encryption key in ${file}`);
+    }
+    try {
+        const privateKey = createPrivateKey(value.privateKeyPem);
+        if (privateKey.asymmetricKeyType !== "x25519") {
+            throw new Error("Direct Runtime encryption key must use X25519");
+        }
+        const publicKey = parseX25519PublicKey(value.publicKey);
+        const derivedPublicKey = createPublicKey(privateKey)
+            .export({ type: "spki", format: "der" })
+            .toString("base64url");
+        if (derivedPublicKey !== value.publicKey) {
+            throw new Error("Direct Runtime encryption public and private keys do not match");
+        }
+        // Keep the parsed public key live through validation so OpenSSL also
+        // rejects malformed algorithm parameters, not only a matching byte shape.
+        if (publicKey.asymmetricKeyType !== "x25519") {
+            throw new Error("Direct Runtime encryption key must use X25519");
+        }
+    }
+    catch (error) {
+        throw new Error(`invalid daemon Direct Runtime encryption key in ${file}: ${messageOf(error)}`);
+    }
+    return {
+        version: DIRECT_RUNTIME_ENCRYPTION_KEY_VERSION,
+        algorithm: "X25519",
+        publicKey: value.publicKey,
+        privateKeyPem: value.privateKeyPem,
+    };
+}
+function installationIdentity(installationId, key) {
+    const privateKey = createPrivateKey(key.privateKeyPem);
+    return {
+        installationId,
+        algorithm: "Ed25519",
+        publicKey: key.publicKey,
+        sign(pluginId, challenge) {
+            return sign(null, installationProofPayload(installationId, pluginId, challenge), privateKey).toString("base64url");
+        },
+        signDirectRuntimeServerHello(channelBinding, hello) {
+            return sign(null, encodeServerHelloProofPayload(channelBinding, hello), privateKey).toString("base64url");
+        },
+        signDirectRuntimeServerAccepted(channelBinding, helloHash, authenticateHash, accepted) {
+            return sign(null, encodeServerAcceptedProofPayload(channelBinding, helloHash, authenticateHash, accepted), privateKey).toString("base64url");
+        },
+    };
+}
+function directRuntimeEncryptionIdentity(key) {
+    const privateKey = createPrivateKey(key.privateKeyPem);
+    return {
+        algorithm: "X25519",
+        publicKey: key.publicKey,
+        deriveSharedSecret(peerPublicKey) {
+            let secret;
+            try {
+                secret = diffieHellman({
+                    privateKey,
+                    publicKey: parseX25519PublicKey(peerPublicKey),
+                });
+            }
+            catch (error) {
+                throw new Error(`invalid Direct Runtime peer encryption key: ${messageOf(error)}`);
+            }
+            if (secret.byteLength !== 32 || secret.every((byte) => byte === 0)) {
+                throw new Error("invalid Direct Runtime peer encryption key: shared secret is unsafe");
+            }
+            return Uint8Array.from(secret);
+        },
+    };
+}
+function parseX25519PublicKey(value) {
+    if (typeof value !== "string" || !/^[A-Za-z0-9_-]{59}$/.test(value)) {
+        throw new Error("X25519 public key must be canonical SPKI DER base64url");
+    }
+    const bytes = Buffer.from(value, "base64url");
+    if (bytes.byteLength !== 44 || bytes.toString("base64url") !== value) {
+        throw new Error("X25519 public key must be canonical SPKI DER base64url");
+    }
+    const publicKey = createPublicKey({ key: bytes, type: "spki", format: "der" });
+    if (publicKey.asymmetricKeyType !== "x25519" ||
+        publicKey.export({ type: "spki", format: "der" }).toString("base64url") !== value) {
+        throw new Error("public key must use X25519");
+    }
+    return publicKey;
+}
+export function installationProofPayload(installationId, pluginId, challenge) {
+    if (!UUID_V4_PATTERN.test(installationId)) {
+        throw new Error("installation proof installationId is invalid");
+    }
+    const normalizedPluginId = pluginId.trim();
+    if (!/^[a-z][a-z0-9-]{0,62}$/.test(normalizedPluginId)) {
+        throw new Error("installation proof pluginId is invalid");
+    }
+    if (!challenge || challenge.length > 16_384) {
+        throw new Error("installation proof challenge is invalid");
+    }
+    return Buffer.from(`${INSTALLATION_PROOF_DOMAIN}\0${installationId}\0plugin:${normalizedPluginId}\0${challenge}`, "utf8");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function hasCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/dist/migrations/cleanup-legacy-sessions.d.ts

@@ -1,9 +1,6 @@
 export interface CleanupOptions {
     /** CodexSessionStore JSON path; defaults to `<cwd>/.codex-proxy/sessions.json`. */
     codexStorePath?: string;
-    /** Dir holding the channel routing maps (`lark-sessions*.json`); defaults to
-     *  `<cwd>/.codex-proxy`. */
-    channelStoreDir?: string;
     /** Report what would be removed without deleting anything. */
     dryRun?: boolean;
     log?: (entry: Record<string, unknown>) => void;