@velum-labs/cursorkit 0.1.0 → 0.1.2

package/dist/src/cli.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-export {};
+import { Command } from "commander";
+export declare function buildCursorkitProgram(): Command;

package/dist/src/cli.js

@@ -1,265 +1,37 @@
 #!/usr/bin/env node
-import fs from "node:fs";
-import path from "node:path";
-import { loadConfig } from "./config.js";
-import { loadTlsMaterial } from "./certs.js";
-import { desktopCertificateStatus, desktopDnsStatus, desktopEnv, desktopTrustCommand, localModelBackendStatus, upstreamReachabilityStatus, writeDesktopCertificate, } from "./desktop.js";
-import { createLogger } from "./logger.js";
-import { assertCursorRunRequestV1, assertCursorRunResultV1, assertHarnessRunRequestV1, assertHarnessRunResultV1, } from "./fixtures/modelFusion.js";
-import { listProtoFiles, loadCursorProto, resolveProtoDirectory, } from "./proto.js";
-import { createBridgeRuntime, startServer } from "./server.js";
-const HELP = `cursorkit
-
-Usage:
-  cursorkit serve            Start the local bridge
-  cursorkit doctor           Check local configuration and proto availability
-  cursorkit desktop-cert     Generate local TLS material for Cursor desktop proxying
-  cursorkit desktop-proxy    Start the bridge with Cursor desktop proxy defaults
-  cursorkit desktop-doctor   Check Cursor desktop proxy prerequisites
-  cursorkit capture          Print capture-mode guidance
-  cursorkit fixtures         Validate committed fixture metadata
-  cursorkit --help           Show this help
-
+import { Command } from "commander";
+import { registerCk } from "./ckLauncher.js";
+import { registerDoctor } from "./commands/doctor.js";
+import { registerMaintenance } from "./commands/maintenance.js";
+import { registerServe } from "./commands/serve.js";
+const ENV_HELP = `
 Environment:
   BRIDGE_HOST=127.0.0.1
   BRIDGE_PORT=9443
   CURSOR_UPSTREAM_BASE_URL=https://example.cursor-backend.local
   MODEL_BASE_URL=http://localhost:8080/v1
-  MODEL_NAME=local-model
-`;
-async function main(argv) {
-    const command = parseCommand(argv);
-    if (command === "help") {
-        console.log(HELP);
+  MODEL_NAME=local-model`;
+export function buildCursorkitProgram() {
+    const program = new Command();
+    program
+        .name("cursorkit")
+        .description("local model bridge for Cursor")
+        .addHelpText("after", ENV_HELP);
+    registerServe(program);
+    registerDoctor(program);
+    registerMaintenance(program);
+    registerCk(program);
+    return program;
+}
+async function main() {
+    const program = buildCursorkitProgram();
+    if (process.argv.slice(2).length === 0) {
+        program.outputHelp();
         return;
     }
-    const config = loadConfig(command === "desktop-proxy" || command === "desktop-doctor"
-        ? desktopEnv(process.env)
-        : process.env);
-    const logger = createLogger(config.logLevel);
-    switch (command) {
-        case "serve": {
-            const runtime = await createBridgeRuntime(config, logger);
-            installGracefulShutdown(await startServer(runtime), logger);
-            break;
-        }
-        case "doctor": {
-            await doctor(config);
-            break;
-        }
-        case "capture": {
-            capture(config);
-            break;
-        }
-        case "fixtures": {
-            validateFixtures(config.captureDir);
-            break;
-        }
-        case "desktop-cert": {
-            await desktopCert();
-            break;
-        }
-        case "desktop-proxy": {
-            const runtime = await createBridgeRuntime(config, logger);
-            installGracefulShutdown(await startServer(runtime), logger);
-            break;
-        }
-        case "desktop-doctor": {
-            await doctor(config);
-            await desktopDoctor(config);
-            break;
-        }
-        default: {
-            const exhaustive = command;
-            throw new Error(`Unhandled command: ${exhaustive}`);
-        }
-    }
-}
-function parseCommand(argv) {
-    const first = argv[2];
-    if (first === undefined ||
-        first === "--help" ||
-        first === "-h" ||
-        first === "help") {
-        return "help";
-    }
-    if (first === "serve" ||
-        first === "doctor" ||
-        first === "capture" ||
-        first === "fixtures" ||
-        first === "desktop-cert" ||
-        first === "desktop-proxy" ||
-        first === "desktop-doctor") {
-        return first;
-    }
-    throw new Error(`Unknown command: ${first}\n\n${HELP}`);
-}
-async function doctor(config) {
-    const checks = [];
-    const protoDir = resolveProtoDirectory();
-    checks.push(["proto directory", protoDir]);
-    checks.push(["proto files", String(listProtoFiles(protoDir).length)]);
-    const proto = await loadCursorProto();
-    checks.push([
-        "available models type",
-        proto.AvailableModelsResponse.fullName,
-    ]);
-    checks.push(["chat type", proto.StreamUnifiedChatRequestWithTools.fullName]);
-    checks.push(["bind", `${config.host}:${config.port}`]);
-    checks.push(["tls", config.useTls ? "enabled" : "disabled"]);
-    checks.push(["upstream", config.upstreamBaseUrl ?? "not configured"]);
-    checks.push([
-        "local models",
-        config.models.map((model) => model.id).join(", "),
-    ]);
-    checks.push([
-        "capture",
-        config.captureEnabled ? `enabled -> ${config.captureDir}` : "disabled",
-    ]);
-    checks.push(["fail-open", String(config.failOpen)]);
-    checks.push([
-        "auth",
-        config.authToken === undefined ? "disabled" : "enabled",
-    ]);
-    checks.push([
-        "non-localhost unsafe mode",
-        String(config.unsafeAllowNonLocalhost),
-    ]);
-    if (config.useTls) {
-        const tls = await loadTlsMaterial(config);
-        checks.push([
-            "tls material",
-            tls.generated
-                ? "generated self-signed dev certificate"
-                : "custom certificate",
-        ]);
-    }
-    for (const [name, value] of checks) {
-        console.log(`${name}: ${value}`);
-    }
-    if (config.upstreamBaseUrl === undefined) {
-        console.warn("warning: pass-through traffic needs CURSOR_UPSTREAM_BASE_URL");
-    }
-    if (config.captureEnabled) {
-        console.warn("warning: capture mode treats traffic as sensitive; sanitize before committing fixtures");
-    }
-    if (config.modelPayloadLogging === "full") {
-        console.warn("warning: BRIDGE_LOG_MODEL_PAYLOADS=full may log prompt and tool payloads; use only for local debugging");
-    }
-    if (config.unsafeAllowNonLocalhost) {
-        console.warn("warning: non-localhost unsafe mode exposes the bridge without built-in auth");
-    }
-}
-function installGracefulShutdown(server, logger) {
-    let shuttingDown = false;
-    const shutdown = (signal) => {
-        if (shuttingDown) {
-            logger.warn("forcing bridge shutdown", { signal });
-            process.exit(1);
-        }
-        shuttingDown = true;
-        logger.info("shutting down bridge", { signal });
-        const forceTimer = setTimeout(() => {
-            logger.error("bridge shutdown timed out", { signal });
-            process.exit(1);
-        }, 5_000);
-        server.close((error) => {
-            clearTimeout(forceTimer);
-            if (error !== undefined) {
-                logger.error("bridge shutdown failed", { error: error.message });
-                process.exitCode = 1;
-            }
-            process.exit();
-        });
-    };
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-}
-async function desktopCert() {
-    const cert = await writeDesktopCertificate();
-    console.log(`cert: ${cert.certPath}`);
-    console.log(`key: ${cert.keyPath}`);
-    console.log("");
-    console.log("Manual macOS trust command:");
-    console.log(desktopTrustCommand(cert.certPath).join(" "));
-    console.log("");
-    console.log("Then start with:");
-    console.log(`BRIDGE_CERT_PATH=${cert.certPath} BRIDGE_KEY_PATH=${cert.keyPath} cursorkit desktop-proxy`);
-}
-async function desktopDoctor(config) {
-    const checks = [];
-    checks.push(["desktop mode", String(config.desktopMode)]);
-    checks.push(["public origin", config.publicOrigin ?? "not configured"]);
-    checks.push(["tls hostnames", config.tlsHostnames.join(", ")]);
-    checks.push(["route inventory", String(config.routeInventoryEnabled)]);
-    checks.push(["desktop upstream", config.upstreamBaseUrl ?? "not configured"]);
-    checks.push([
-        "desktop upstream connect",
-        config.upstreamConnectHost === undefined
-            ? "system DNS"
-            : `${config.upstreamConnectHost}${config.upstreamConnectPort === undefined ? "" : `:${config.upstreamConnectPort}`}`,
-    ]);
-    checks.push(["desktop cert", desktopCertificateStatus(config)]);
-    checks.push(["desktop dns", await desktopDnsStatus(config)]);
-    checks.push([
-        "upstream reachability",
-        await upstreamReachabilityStatus(config),
-    ]);
-    checks.push(["local model backend", await localModelBackendStatus(config)]);
-    for (const [name, value] of checks) {
-        console.log(`${name}: ${value}`);
-    }
-}
-function capture(config) {
-    console.log(`captureEnabled: ${config.captureEnabled}`);
-    console.log(`captureDir: ${config.captureDir}`);
-    console.log("Capture mode is explicit and sanitized fixture writing is required before committing data.");
-}
-function validateFixtures(captureDir) {
-    const modelFusionCount = validateModelFusionFixtures();
-    if (!fs.existsSync(captureDir)) {
-        console.log(`No fixture capture directory found at ${captureDir}`);
-        console.log(`Validated ${modelFusionCount} model-fusion fixture file(s)`);
-        return;
-    }
-    const files = fs
-        .readdirSync(captureDir)
-        .filter((file) => file.endsWith(".json"));
-    for (const file of files) {
-        const fullPath = path.join(captureDir, file);
-        const parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
-        if (parsed.redaction?.status !== "sanitized") {
-            throw new Error(`${fullPath} is missing redaction.status=sanitized`);
-        }
-    }
-    console.log(`Validated ${files.length} capture fixture file(s) and ${modelFusionCount} model-fusion fixture file(s)`);
-}
-function validateModelFusionFixtures() {
-    const root = path.resolve("fixtures", "model-fusion-contract");
-    if (!fs.existsSync(root))
-        return 0;
-    let count = 0;
-    const validators = {
-        "harness-run-request.v1": assertHarnessRunRequestV1,
-        "harness-run-result.v1": assertHarnessRunResultV1,
-        "cursor-run-request.v1": assertCursorRunRequestV1,
-        "cursor-run-result.v1": assertCursorRunResultV1,
-    };
-    for (const [schema, validate] of Object.entries(validators)) {
-        const schemaDir = path.join(root, schema);
-        if (!fs.existsSync(schemaDir))
-            continue;
-        for (const file of fs
-            .readdirSync(schemaDir)
-            .filter((item) => item.endsWith(".json"))) {
-            const fixturePath = path.join(schemaDir, file);
-            validate(JSON.parse(fs.readFileSync(fixturePath, "utf8")));
-            count++;
-        }
-    }
-    return count;
+    await program.parseAsync(process.argv);
 }
-main(process.argv).catch((error) => {
+main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;
 });

package/dist/src/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerDoctor(program: Command): void;

package/dist/src/commands/doctor.js

@@ -0,0 +1,129 @@
+import { loadConfig } from "../config.js";
+import { loadTlsMaterial } from "../certs.js";
+import { desktopCertificateStatus, desktopDnsStatus, desktopEnv, localModelBackendStatus, upstreamReachabilityStatus, } from "../desktop.js";
+import { listProtoFiles, loadCursorProto, resolveProtoDirectory, } from "../proto.js";
+import { bold, brandHeader, green, uiStream, withSpinner, } from "../ui/index.js";
+import { renderCheck, warningLine } from "./render.js";
+function write(line) {
+    uiStream().write(`${line}\n`);
+}
+async function runDoctor(config) {
+    write(`\n${brandHeader("environment check")}\n`);
+    const proto = await withSpinner("loading Cursor proto", () => loadCursorProto());
+    const protoDir = resolveProtoDirectory();
+    const checks = [
+        { label: "proto directory", detail: protoDir },
+        { label: "proto files", detail: String(listProtoFiles(protoDir).length) },
+        {
+            label: "available models type",
+            detail: proto.AvailableModelsResponse.fullName,
+        },
+        {
+            label: "chat type",
+            detail: proto.StreamUnifiedChatRequestWithTools.fullName,
+        },
+        { label: "bind", detail: `${config.host}:${config.port}` },
+        { label: "tls", detail: config.useTls ? "enabled" : "disabled" },
+        {
+            label: "upstream",
+            ok: config.upstreamBaseUrl !== undefined,
+            detail: config.upstreamBaseUrl ?? "not configured",
+            hint: "pass-through traffic needs CURSOR_UPSTREAM_BASE_URL",
+        },
+        {
+            label: "local models",
+            detail: config.models.map((model) => model.id).join(", "),
+        },
+        {
+            label: "capture",
+            detail: config.captureEnabled
+                ? `enabled -> ${config.captureDir}`
+                : "disabled",
+        },
+        { label: "fail-open", detail: String(config.failOpen) },
+        {
+            label: "auth",
+            detail: config.authToken === undefined ? "disabled" : "enabled",
+        },
+        {
+            label: "non-localhost unsafe mode",
+            detail: String(config.unsafeAllowNonLocalhost),
+        },
+    ];
+    if (config.useTls) {
+        const tls = await loadTlsMaterial(config);
+        checks.push({
+            label: "tls material",
+            detail: tls.generated
+                ? "generated self-signed dev certificate"
+                : "custom certificate",
+        });
+    }
+    write(bold("configuration"));
+    for (const check of checks)
+        write(`  ${renderCheck(check)}`);
+    const warnings = [];
+    if (config.captureEnabled) {
+        warnings.push("capture mode treats traffic as sensitive; sanitize before committing fixtures");
+    }
+    if (config.modelPayloadLogging === "full") {
+        warnings.push("BRIDGE_LOG_MODEL_PAYLOADS=full may log prompt and tool payloads; use only for local debugging");
+    }
+    if (config.unsafeAllowNonLocalhost) {
+        warnings.push("non-localhost unsafe mode exposes the bridge without built-in auth");
+    }
+    if (warnings.length > 0) {
+        write("");
+        for (const warning of warnings)
+            write(`  ${warningLine(warning)}`);
+    }
+}
+async function runDesktopDoctor(config) {
+    write(`\n${bold("desktop proxy")}\n`);
+    const checks = [
+        { label: "desktop mode", detail: String(config.desktopMode) },
+        { label: "public origin", detail: config.publicOrigin ?? "not configured" },
+        { label: "tls hostnames", detail: config.tlsHostnames.join(", ") },
+        { label: "route inventory", detail: String(config.routeInventoryEnabled) },
+        {
+            label: "desktop upstream",
+            detail: config.upstreamBaseUrl ?? "not configured",
+        },
+        {
+            label: "desktop upstream connect",
+            detail: config.upstreamConnectHost === undefined
+                ? "system DNS"
+                : `${config.upstreamConnectHost}${config.upstreamConnectPort === undefined ? "" : `:${config.upstreamConnectPort}`}`,
+        },
+        { label: "desktop cert", detail: desktopCertificateStatus(config) },
+        { label: "desktop dns", detail: await desktopDnsStatus(config) },
+        {
+            label: "upstream reachability",
+            detail: await upstreamReachabilityStatus(config),
+        },
+        {
+            label: "local model backend",
+            detail: await localModelBackendStatus(config),
+        },
+    ];
+    for (const check of checks)
+        write(`  ${renderCheck(check)}`);
+    write("");
+    write(green("desktop checks complete."));
+}
+export function registerDoctor(program) {
+    program
+        .command("doctor")
+        .description("check local configuration and proto availability")
+        .action(async () => {
+        await runDoctor(loadConfig(process.env));
+    });
+    program
+        .command("desktop-doctor")
+        .description("check Cursor desktop proxy prerequisites")
+        .action(async () => {
+        const config = loadConfig(desktopEnv(process.env));
+        await runDoctor(config);
+        await runDesktopDoctor(config);
+    });
+}

package/dist/src/commands/maintenance.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerMaintenance(program: Command): void;

package/dist/src/commands/maintenance.js

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config.js";
+import { desktopTrustCommand, writeDesktopCertificate } from "../desktop.js";
+import { assertCursorRunRequestV1, assertCursorRunResultV1, assertHarnessRunRequestV1, assertHarnessRunResultV1, } from "../fixtures/modelFusion.js";
+import { bold, brandHeader, dim, done, note, uiStream, withSpinner, } from "../ui/index.js";
+function write(line) {
+    uiStream().write(`${line}\n`);
+}
+function capture(captureDir, captureEnabled) {
+    write(`\n${brandHeader("capture")}\n`);
+    write(`${dim("captureEnabled:")} ${captureEnabled}`);
+    write(`${dim("captureDir:")} ${captureDir}`);
+    note("Capture mode is explicit; sanitized fixture writing is required before committing data.");
+}
+function validateModelFusionFixtures() {
+    const root = path.resolve("fixtures", "model-fusion-contract");
+    if (!fs.existsSync(root))
+        return 0;
+    let count = 0;
+    const validators = {
+        "harness-run-request.v1": assertHarnessRunRequestV1,
+        "harness-run-result.v1": assertHarnessRunResultV1,
+        "cursor-run-request.v1": assertCursorRunRequestV1,
+        "cursor-run-result.v1": assertCursorRunResultV1,
+    };
+    for (const [schema, validate] of Object.entries(validators)) {
+        const schemaDir = path.join(root, schema);
+        if (!fs.existsSync(schemaDir))
+            continue;
+        for (const file of fs
+            .readdirSync(schemaDir)
+            .filter((item) => item.endsWith(".json"))) {
+            const fixturePath = path.join(schemaDir, file);
+            validate(JSON.parse(fs.readFileSync(fixturePath, "utf8")));
+            count++;
+        }
+    }
+    return count;
+}
+function validateFixtures(captureDir) {
+    write(`\n${brandHeader("fixtures")}\n`);
+    const modelFusionCount = validateModelFusionFixtures();
+    if (!fs.existsSync(captureDir)) {
+        note(`No fixture capture directory found at ${captureDir}`);
+        done(`Validated ${modelFusionCount} model-fusion fixture file(s)`);
+        return;
+    }
+    const files = fs
+        .readdirSync(captureDir)
+        .filter((file) => file.endsWith(".json"));
+    for (const file of files) {
+        const fullPath = path.join(captureDir, file);
+        const parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
+        if (parsed.redaction?.status !== "sanitized") {
+            throw new Error(`${fullPath} is missing redaction.status=sanitized`);
+        }
+    }
+    done(`Validated ${files.length} capture fixture file(s) and ${modelFusionCount} model-fusion fixture file(s)`);
+}
+async function desktopCert() {
+    write(`\n${brandHeader("desktop certificate")}\n`);
+    const cert = await withSpinner("generating self-signed certificate", () => writeDesktopCertificate());
+    write(`${dim("cert:")} ${cert.certPath}`);
+    write(`${dim("key:")}  ${cert.keyPath}`);
+    write("");
+    write(bold("Manual macOS trust command:"));
+    write(desktopTrustCommand(cert.certPath).join(" "));
+    write("");
+    write(bold("Then start with:"));
+    write(`BRIDGE_CERT_PATH=${cert.certPath} BRIDGE_KEY_PATH=${cert.keyPath} cursorkit desktop-proxy`);
+}
+export function registerMaintenance(program) {
+    program
+        .command("capture")
+        .description("print capture-mode guidance")
+        .action(() => {
+        const config = loadConfig(process.env);
+        capture(config.captureDir, config.captureEnabled);
+    });
+    program
+        .command("fixtures")
+        .description("validate committed fixture metadata")
+        .action(() => {
+        const config = loadConfig(process.env);
+        validateFixtures(config.captureDir);
+    });
+    program
+        .command("desktop-cert")
+        .description("generate local TLS material for Cursor desktop proxying")
+        .action(async () => {
+        await desktopCert();
+    });
+}

package/dist/src/commands/render.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A single diagnostic line. `ok === undefined` renders as a neutral bullet
+ * (informational), while `true`/`false` render as a tick/cross. A `hint` is
+ * shown on the next line only for failed checks.
+ */
+export type Check = {
+    label: string;
+    ok?: boolean;
+    detail?: string;
+    hint?: string;
+};
+export declare function renderCheck(check: Check): string;
+/** A yellow advisory line (non-fatal warnings). */
+export declare function warningLine(message: string): string;

package/dist/src/commands/render.js

@@ -0,0 +1,17 @@
+import { dim, glyph, gray, green, red, yellow } from "../ui/index.js";
+export function renderCheck(check) {
+    const mark = check.ok === undefined
+        ? gray(glyph.bullet())
+        : check.ok
+            ? green(glyph.tick())
+            : red(glyph.cross());
+    const detail = check.detail !== undefined ? ` ${dim(check.detail)}` : "";
+    const hint = check.ok === false && check.hint !== undefined
+        ? `\n    ${yellow(glyph.arrow())} ${check.hint}`
+        : "";
+    return `${mark} ${check.label}${detail}${hint}`;
+}
+/** A yellow advisory line (non-fatal warnings). */
+export function warningLine(message) {
+    return `${yellow(glyph.warn())} ${message}`;
+}

package/dist/src/commands/serve.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerServe(program: Command): void;

package/dist/src/commands/serve.js

@@ -0,0 +1,52 @@
+import { loadConfig } from "../config.js";
+import { desktopEnv } from "../desktop.js";
+import { createLogger } from "../logger.js";
+import { createBridgeRuntime, startServer } from "../server.js";
+import { brandHeader, bold, dim, glyph, green, uiStream } from "../ui/index.js";
+function installGracefulShutdown(server, logger) {
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+        if (shuttingDown) {
+            logger.warn("forcing bridge shutdown", { signal });
+            process.exit(1);
+        }
+        shuttingDown = true;
+        logger.info("shutting down bridge", { signal });
+        const forceTimer = setTimeout(() => {
+            logger.error("bridge shutdown timed out", { signal });
+            process.exit(1);
+        }, 5_000);
+        server.close((error) => {
+            clearTimeout(forceTimer);
+            if (error !== undefined) {
+                logger.error("bridge shutdown failed", { error: error.message });
+                process.exitCode = 1;
+            }
+            process.exit();
+        });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
+async function startBridge(env, mode) {
+    const config = loadConfig(env);
+    const logger = createLogger(config.logLevel);
+    uiStream().write(`\n${brandHeader(mode === "desktop" ? "desktop proxy" : "bridge")}\n` +
+        `${dim("bind:")} ${bold(`${config.host}:${config.port}`)}   ${dim("tls:")} ${config.useTls ? green(glyph.tick()) : "off"}\n\n`);
+    const runtime = await createBridgeRuntime(config, logger);
+    installGracefulShutdown(await startServer(runtime), logger);
+}
+export function registerServe(program) {
+    program
+        .command("serve")
+        .description("start the local bridge")
+        .action(async () => {
+        await startBridge(process.env, "default");
+    });
+    program
+        .command("desktop-proxy")
+        .description("start the bridge with Cursor desktop proxy defaults")
+        .action(async () => {
+        await startBridge(desktopEnv(process.env), "desktop");
+    });
+}

package/dist/src/cursorDesktopState.d.ts

@@ -0,0 +1,10 @@
+import type { LocalModelConfig } from "./config.js";
+/**
+ * Builders that shape the Cursor desktop `applicationUser` state and local
+ * model catalog entries. Extracted from `ckLauncher` so the (large) launcher
+ * module is not also responsible for the desktop state-seed schema. These are
+ * pure data transforms over plain JSON-shaped records.
+ */
+export declare function mergeLocalAgentBackendUrlsIntoApplicationUser(applicationUser: Record<string, unknown>, agentOrigin: string): void;
+export declare function mergeLocalDesktopModelsIntoApplicationUser(applicationUser: Record<string, unknown>, models: LocalModelConfig[]): void;
+export declare function buildLocalDesktopModelEntry(model: LocalModelConfig): Record<string, unknown>;