omnikey-cli 1.0.12 → 1.0.14

package/backend-dist/ai-client.js

@@ -0,0 +1,469 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiClient = exports.AIClient = void 0;
+exports.getDefaultModel = getDefaultModel;
+const openai_1 = __importDefault(require("openai"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const genai_1 = require("@google/genai");
+const cuid_1 = __importDefault(require("cuid"));
+const config_1 = require("./config");
+// ---------------------------------------------------------------------------
+// Default model mapping
+// ---------------------------------------------------------------------------
+const DEFAULT_MODELS = {
+    openai: { fast: 'gpt-4o-mini', smart: 'gpt-5.1' },
+    gemini: { fast: 'gemini-2.5-flash', smart: 'gemini-2.5-pro' },
+    anthropic: { fast: 'claude-haiku-4-5-20251001', smart: 'claude-sonnet-4-6' },
+};
+function getDefaultModel(provider, tier) {
+    return DEFAULT_MODELS[provider][tier];
+}
+// ---------------------------------------------------------------------------
+// OpenAI adapter
+// ---------------------------------------------------------------------------
+class OpenAIAdapter {
+    constructor(apiKey) {
+        this.client = new openai_1.default({ apiKey });
+    }
+    async complete(model, messages, options) {
+        const oaiMessages = toOpenAIMessages(messages);
+        const tools = options.tools?.length ? toOpenAITools(options.tools) : undefined;
+        const completion = await this.client.chat.completions.create({
+            model,
+            messages: oaiMessages,
+            tools: tools?.length ? tools : undefined,
+            temperature: options.temperature ?? 0.2,
+            max_tokens: options.maxTokens,
+        });
+        const choice = completion.choices[0];
+        const msg = choice.message;
+        const content = (msg.content ?? '').toString().trim();
+        const tool_calls = msg.tool_calls
+            ?.filter((tc) => tc.type === 'function' && 'function' in tc)
+            .map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: JSON.parse(tc.function.arguments || '{}'),
+        }));
+        const finishReason = choice.finish_reason === 'tool_calls'
+            ? 'tool_calls'
+            : choice.finish_reason === 'length'
+                ? 'length'
+                : 'stop';
+        const usage = completion.usage
+            ? {
+                prompt_tokens: completion.usage.prompt_tokens,
+                completion_tokens: completion.usage.completion_tokens,
+                total_tokens: completion.usage.total_tokens,
+            }
+            : undefined;
+        const assistantMessage = {
+            role: 'assistant',
+            content,
+            ...(tool_calls?.length ? { tool_calls } : {}),
+        };
+        return { content, finish_reason: finishReason, tool_calls, usage, model, assistantMessage };
+    }
+    async streamComplete(model, messages, options, onDelta) {
+        const oaiMessages = toOpenAIMessages(messages);
+        const stream = await this.client.chat.completions.create({
+            model,
+            messages: oaiMessages,
+            temperature: options.temperature ?? 0.3,
+            stream: true,
+            stream_options: { include_usage: true },
+        });
+        let usage;
+        for await (const part of stream) {
+            const delta = part.choices?.[0]?.delta?.content ?? '';
+            if (delta) {
+                onDelta(delta);
+            }
+            if (part.usage) {
+                usage = {
+                    prompt_tokens: part.usage.prompt_tokens ?? 0,
+                    completion_tokens: part.usage.completion_tokens ?? 0,
+                    total_tokens: part.usage.total_tokens ?? 0,
+                };
+            }
+        }
+        return { usage, model };
+    }
+}
+// ---------------------------------------------------------------------------
+// Anthropic adapter
+// ---------------------------------------------------------------------------
+class AnthropicAdapter {
+    constructor(apiKey) {
+        this.client = new sdk_1.default({ apiKey });
+    }
+    async complete(model, messages, options) {
+        const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+        const tools = options.tools?.length ? toAnthropicTools(options.tools) : undefined;
+        const response = await this.client.messages.create({
+            model,
+            max_tokens: options.maxTokens ?? 8192,
+            ...(system ? { system } : {}),
+            messages: anthropicMessages,
+            ...(tools?.length ? { tools } : {}),
+            temperature: options.temperature ?? 0.2,
+        });
+        const textContent = response.content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('');
+        const tool_calls = response.content
+            .filter((b) => b.type === 'tool_use')
+            .map((b) => {
+            const tu = b;
+            return {
+                id: tu.id,
+                name: tu.name,
+                arguments: tu.input,
+            };
+        });
+        const finishReason = response.stop_reason === 'tool_use'
+            ? 'tool_calls'
+            : response.stop_reason === 'max_tokens'
+                ? 'length'
+                : 'stop';
+        const usage = {
+            prompt_tokens: response.usage.input_tokens,
+            completion_tokens: response.usage.output_tokens,
+            total_tokens: response.usage.input_tokens + response.usage.output_tokens,
+        };
+        const assistantMessage = {
+            role: 'assistant',
+            content: textContent,
+            ...(tool_calls?.length ? { tool_calls } : {}),
+        };
+        return {
+            content: textContent,
+            finish_reason: finishReason,
+            tool_calls: tool_calls?.length ? tool_calls : undefined,
+            usage,
+            model,
+            assistantMessage,
+        };
+    }
+    async streamComplete(model, messages, options, onDelta) {
+        const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+        const stream = this.client.messages.stream({
+            model,
+            max_tokens: options.maxTokens ?? 8192,
+            ...(system ? { system } : {}),
+            messages: anthropicMessages,
+            temperature: options.temperature ?? 0.3,
+        });
+        for await (const event of stream) {
+            if (event.type === 'content_block_delta' &&
+                event.delta.type === 'text_delta' &&
+                event.delta.text) {
+                onDelta(event.delta.text);
+            }
+        }
+        const finalMsg = await stream.finalMessage();
+        const usage = {
+            prompt_tokens: finalMsg.usage.input_tokens,
+            completion_tokens: finalMsg.usage.output_tokens,
+            total_tokens: finalMsg.usage.input_tokens + finalMsg.usage.output_tokens,
+        };
+        return { usage, model };
+    }
+}
+// ---------------------------------------------------------------------------
+// Gemini adapter
+// ---------------------------------------------------------------------------
+class GeminiAdapter {
+    constructor(apiKey) {
+        this.client = new genai_1.GoogleGenAI({ apiKey });
+    }
+    async complete(model, messages, options) {
+        const { systemInstruction, contents } = toGeminiContents(messages);
+        const tools = options.tools?.length ? toGeminiTools(options.tools) : undefined;
+        const response = await this.client.models.generateContent({
+            model,
+            contents,
+            config: {
+                ...(systemInstruction ? { systemInstruction } : {}),
+                ...(tools?.length ? { tools } : {}),
+                temperature: options.temperature ?? 0.2,
+            },
+        });
+        const candidate = response.candidates?.[0];
+        const parts = candidate?.content?.parts ?? [];
+        const textContent = parts
+            .filter((p) => p.text != null)
+            .map((p) => p.text ?? '')
+            .join('');
+        const functionCalls = parts.filter((p) => p.functionCall != null);
+        const tool_calls = functionCalls.length
+            ? functionCalls.map((p) => ({
+                id: (0, cuid_1.default)(),
+                name: p.functionCall.name ?? '',
+                arguments: (p.functionCall.args ?? {}),
+            }))
+            : undefined;
+        const finishReason = candidate?.finishReason === 'MAX_TOKENS'
+            ? 'length'
+            : tool_calls?.length
+                ? 'tool_calls'
+                : 'stop';
+        const usageMeta = response.usageMetadata;
+        const usage = usageMeta
+            ? {
+                prompt_tokens: usageMeta.promptTokenCount ?? 0,
+                completion_tokens: usageMeta.candidatesTokenCount ?? 0,
+                total_tokens: usageMeta.totalTokenCount ?? 0,
+            }
+            : undefined;
+        const assistantMessage = {
+            role: 'assistant',
+            content: textContent,
+            ...(tool_calls?.length ? { tool_calls } : {}),
+        };
+        return {
+            content: textContent,
+            finish_reason: finishReason,
+            tool_calls,
+            usage,
+            model,
+            assistantMessage,
+        };
+    }
+    async streamComplete(model, messages, options, onDelta) {
+        const { systemInstruction, contents } = toGeminiContents(messages);
+        const stream = await this.client.models.generateContentStream({
+            model,
+            contents,
+            config: {
+                ...(systemInstruction ? { systemInstruction } : {}),
+                temperature: options.temperature ?? 0.3,
+            },
+        });
+        let usage;
+        for await (const chunk of stream) {
+            const text = chunk.text ?? '';
+            if (text) {
+                onDelta(text);
+            }
+            if (chunk.usageMetadata) {
+                usage = {
+                    prompt_tokens: chunk.usageMetadata.promptTokenCount ?? 0,
+                    completion_tokens: chunk.usageMetadata.candidatesTokenCount ?? 0,
+                    total_tokens: chunk.usageMetadata.totalTokenCount ?? 0,
+                };
+            }
+        }
+        return { usage, model };
+    }
+}
+// ---------------------------------------------------------------------------
+// Main AIClient
+// ---------------------------------------------------------------------------
+class AIClient {
+    constructor(provider, apiKey) {
+        this.provider = provider;
+        if (provider === 'openai') {
+            this.openai = new OpenAIAdapter(apiKey);
+        }
+        else if (provider === 'anthropic') {
+            this.anthropic = new AnthropicAdapter(apiKey);
+        }
+        else if (provider === 'gemini') {
+            this.gemini = new GeminiAdapter(apiKey);
+        }
+    }
+    getProvider() {
+        return this.provider;
+    }
+    async complete(model, messages, options = {}) {
+        if (this.provider === 'openai' && this.openai) {
+            return this.openai.complete(model, messages, options);
+        }
+        if (this.provider === 'anthropic' && this.anthropic) {
+            return this.anthropic.complete(model, messages, options);
+        }
+        if (this.provider === 'gemini' && this.gemini) {
+            return this.gemini.complete(model, messages, options);
+        }
+        throw new Error(`AI provider "${this.provider}" is not configured.`);
+    }
+    async streamComplete(model, messages, options = {}, onDelta) {
+        if (this.provider === 'openai' && this.openai) {
+            return this.openai.streamComplete(model, messages, options, onDelta);
+        }
+        if (this.provider === 'anthropic' && this.anthropic) {
+            return this.anthropic.streamComplete(model, messages, options, onDelta);
+        }
+        if (this.provider === 'gemini' && this.gemini) {
+            return this.gemini.streamComplete(model, messages, options, onDelta);
+        }
+        throw new Error(`AI provider "${this.provider}" is not configured.`);
+    }
+}
+exports.AIClient = AIClient;
+// ---------------------------------------------------------------------------
+// Message format converters — OpenAI
+// ---------------------------------------------------------------------------
+function toOpenAIMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            result.push({ role: 'system', content: msg.content });
+        }
+        else if (msg.role === 'user') {
+            result.push({ role: 'user', content: msg.content });
+        }
+        else if (msg.role === 'assistant') {
+            if (msg.tool_calls?.length) {
+                result.push({
+                    role: 'assistant',
+                    content: msg.content || null,
+                    tool_calls: msg.tool_calls.map((tc) => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+                    })),
+                });
+            }
+            else {
+                result.push({ role: 'assistant', content: msg.content });
+            }
+        }
+        else if (msg.role === 'tool' && msg.tool_call_id) {
+            result.push({
+                role: 'tool',
+                tool_call_id: msg.tool_call_id,
+                content: msg.content,
+            });
+        }
+    }
+    return result;
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+function toAnthropicMessages(messages) {
+    let system;
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            // Anthropic takes system as a top-level param; concatenate if multiple
+            system = system ? `${system}\n${msg.content}` : msg.content;
+            continue;
+        }
+        if (msg.role === 'tool' && msg.tool_call_id) {
+            // Tool results must go into the user role
+            const prev = result[result.length - 1];
+            const toolResult = {
+                type: 'tool_result',
+                tool_use_id: msg.tool_call_id,
+                content: msg.content,
+            };
+            if (prev && prev.role === 'user' && Array.isArray(prev.content)) {
+                prev.content.push(toolResult);
+            }
+            else {
+                result.push({ role: 'user', content: [toolResult] });
+            }
+            continue;
+        }
+        if (msg.role === 'assistant' && msg.tool_calls?.length) {
+            const blocks = [];
+            if (msg.content) {
+                blocks.push({ type: 'text', text: msg.content });
+            }
+            for (const tc of msg.tool_calls) {
+                blocks.push({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.name,
+                    input: tc.arguments,
+                });
+            }
+            result.push({ role: 'assistant', content: blocks });
+            continue;
+        }
+        result.push({
+            role: msg.role === 'assistant' ? 'assistant' : 'user',
+            content: msg.content,
+        });
+    }
+    return { system, messages: result };
+}
+function toAnthropicTools(tools) {
+    return tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+    }));
+}
+// ---------------------------------------------------------------------------
+// Message format converters — Gemini
+// ---------------------------------------------------------------------------
+function toGeminiContents(messages) {
+    let systemInstruction;
+    const contents = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            systemInstruction = systemInstruction ? `${systemInstruction}\n${msg.content}` : msg.content;
+            continue;
+        }
+        if (msg.role === 'tool' && msg.tool_call_id) {
+            // Tool responses go as user messages with functionResponse parts
+            const prev = contents[contents.length - 1];
+            const responsePart = {
+                functionResponse: {
+                    name: msg.tool_name ?? 'tool',
+                    response: { result: msg.content },
+                },
+            };
+            if (prev && prev.role === 'user') {
+                prev.parts = [...(prev.parts ?? []), responsePart];
+            }
+            else {
+                contents.push({ role: 'user', parts: [responsePart] });
+            }
+            continue;
+        }
+        if (msg.role === 'assistant' && msg.tool_calls?.length) {
+            const parts = msg.tool_calls.map((tc) => ({
+                functionCall: { name: tc.name, args: tc.arguments },
+            }));
+            if (msg.content) {
+                parts.unshift({ functionCall: undefined, text: msg.content });
+            }
+            contents.push({ role: 'model', parts });
+            continue;
+        }
+        const role = msg.role === 'assistant' ? 'model' : 'user';
+        contents.push({ role, parts: [{ text: msg.content }] });
+    }
+    return { systemInstruction, contents };
+}
+function toGeminiTools(tools) {
+    return [
+        {
+            functionDeclarations: tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            })),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Shared singleton — import this instead of constructing a new AIClient
+// ---------------------------------------------------------------------------
+exports.aiClient = new AIClient(config_1.config.aiProvider, config_1.config.aiApiKey);

package/backend-dist/config.js

@@ -43,12 +43,36 @@ function getSqlitePath() {
         return defaultPath;
     return path_1.default.isAbsolute(envPath) ? envPath : path_1.default.join(homeDir, '.omnikey', envPath);
 }
+function getAIProvider() {
+    const value = getEnv('AI_PROVIDER', false);
+    if (value === 'gemini' || value === 'anthropic' || value === 'openai')
+        return value;
+    // Auto-detect from available keys
+    if (getEnv('ANTHROPIC_API_KEY', false))
+        return 'anthropic';
+    if (getEnv('GEMINI_API_KEY', false))
+        return 'gemini';
+    return 'openai';
+}
+function getActiveApiKey(provider) {
+    if (provider === 'openai')
+        return getEnv('OPENAI_API_KEY', true);
+    if (provider === 'anthropic')
+        return getEnv('ANTHROPIC_API_KEY', true);
+    if (provider === 'gemini')
+        return getEnv('GEMINI_API_KEY', true);
+    throw new Error(`Unknown AI provider: ${provider}`);
+}
+const _provider = getAIProvider();
 exports.config = {
     // Server
     logLevel: getEnv('LOG_LEVEL', false) || 'info',
     isLocal: getBooleanEnv('LOCAL', false),
-    // OpenAI
-    openaiApiKey: getEnv('OPENAI_API_KEY', true),
+    // AI provider
+    aiProvider: _provider,
+    aiApiKey: getActiveApiKey(_provider),
+    // Legacy — kept for backwards compatibility; may be undefined when using another provider
+    openaiApiKey: getEnv('OPENAI_API_KEY', false),
     // Database
     databaseUrl: getEnv('DATABASE_URL', getBooleanEnv('IS_SELF_HOSTED', false) ? false : true),
     dbLogging: getBooleanEnv('DB_LOGGING', false),
@@ -62,4 +86,9 @@ exports.config = {
     internalApiKey: getEnv('INTERNAL_API_KEY', false),
     port: getNumberEnv('OMNIKEY_PORT', 8080),
     isSelfHosted: getBooleanEnv('IS_SELF_HOSTED', false),
+    // Web search providers (all optional — DuckDuckGo is used as free fallback)
+    serperApiKey: getEnv('SERPER_API_KEY', false),
+    braveSearchApiKey: getEnv('BRAVE_SEARCH_API_KEY', false),
+    tavilyApiKey: getEnv('TAVILY_API_KEY', false),
+    searxngUrl: getEnv('SEARXNG_URL', false),
 };

package/backend-dist/featureRoutes.js

@@ -7,7 +7,6 @@ exports.getPromptForCommand = getPromptForCommand;
 exports.runEnhancementModel = runEnhancementModel;
 exports.createFeatureRouter = createFeatureRouter;
 const express_1 = __importDefault(require("express"));
-const openai_1 = __importDefault(require("openai"));
 const zod_1 = __importDefault(require("zod"));
 const types_1 = require("./types");
 const prompts_1 = require("./prompts");
@@ -17,6 +16,7 @@ const subscription_1 = require("./models/subscription");
 const subscriptionUsage_1 = require("./models/subscriptionUsage");
 const compression_1 = require("./compression");
 const subscriptionTaskTemplate_1 = require("./models/subscriptionTaskTemplate");
+const ai_client_1 = require("./ai-client");
 function parseImprovedTextResponse(logger, response) {
     const match = response.match(/<improved_text>([\s\S]*?)<\/improved_text>/);
     if (match && match[1]) {
@@ -25,9 +25,6 @@ function parseImprovedTextResponse(logger, response) {
     logger.warn('LLM response did not contain expected <improved_text> tags; returning raw response.');
     return response.trim();
 }
-const openai = new openai_1.default({
-    apiKey: config_1.config.openaiApiKey,
-});
 const enhanceRequestSchema = zod_1.default.object({
     text: zod_1.default.string(),
 });
@@ -59,7 +56,13 @@ async function getPromptForCommand(logger, cmd, subscription) {
     return '';
 }
 function getModelForCommand(cmd) {
-    return cmd === 'task' ? 'gpt-5.1' : 'gpt-4o-mini';
+    const tier = cmd === 'task' ? 'smart' : 'fast';
+    const models = {
+        openai: { fast: 'gpt-4o-mini', smart: 'gpt-5.1' },
+        gemini: { fast: 'gemini-2.5-flash', smart: 'gemini-2.5-pro' },
+        anthropic: { fast: 'claude-haiku-4-5-20251001', smart: 'claude-sonnet-4-6' },
+    };
+    return models[config_1.config.aiProvider]?.[tier] ?? 'gpt-4o-mini';
 }
 function createMessagesParams(cmd, input, prompt) {
     if (cmd === 'task') {
@@ -82,49 +85,27 @@ ${input}
         ];
     }
     return [
-        {
-            role: 'system',
-            content: [prompt, prompts_1.OUTPUT_FORMAT_INSTRUCTION].join('\n'),
-        },
-        {
-            role: 'user',
-            content: input,
-        },
+        { role: 'system', content: [prompt, prompts_1.OUTPUT_FORMAT_INSTRUCTION].join('\n') },
+        { role: 'user', content: input },
     ];
 }
 async function runEnhancementModel(logger, text, cmd, subscription, onDelta) {
     const trimmed = text.trim();
-    if (!config_1.config.openaiApiKey) {
-        logger.warn('OPENAI_API_KEY is not set; returning null from runEnhancementModel.');
-        return new types_1.OmniKeyError('OpenAI API key is not configured.', 500);
-    }
     const prompt = await getPromptForCommand(logger, cmd, subscription);
     if (!prompt) {
         logger.error(`No system prompt found for command: ${cmd}`);
         return new types_1.OmniKeyError(`No system prompt found for command: ${cmd}`, 404);
     }
     const model = getModelForCommand(cmd);
-    const stream = await openai.chat.completions.create({
-        model,
-        messages: createMessagesParams(cmd, trimmed, prompt),
-        temperature: 0.3,
-        stream: true,
-        stream_options: { include_usage: true },
-    });
+    const messages = createMessagesParams(cmd, trimmed, prompt);
     let rawResponse = '';
     let usage;
-    for await (const part of stream) {
-        const delta = part.choices?.[0]?.delta?.content ?? '';
-        if (delta) {
-            rawResponse += delta;
-            if (onDelta) {
-                onDelta(delta);
-            }
-        }
-        if (part.usage) {
-            usage = part.usage;
-        }
-    }
+    const result = await ai_client_1.aiClient.streamComplete(model, messages, { temperature: 0.3 }, (delta) => {
+        rawResponse += delta;
+        if (onDelta)
+            onDelta(delta);
+    });
+    usage = result.usage;
     return { rawResponse, usage, model };
 }
 async function enhanceText(logger, text, cmd, subscription) {

package/backend-dist/index.js

@@ -7,13 +7,14 @@ const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const zlib_1 = __importDefault(require("zlib"));
 const subscriptionRoutes_1 = require("./subscriptionRoutes");
 const featureRoutes_1 = require("./featureRoutes");
 const db_1 = require("./db");
 const logger_1 = require("./logger");
 const taskInstructionRoutes_1 = require("./taskInstructionRoutes");
 const config_1 = require("./config");
-const agentServer_1 = require("./agentServer");
+const agentServer_1 = require("./agent/agentServer");
 const app = (0, express_1.default)();
 const PORT = Number(config_1.config.port);
 app.use((0, cors_1.default)());
@@ -80,19 +81,30 @@ app.get('/macos/appcast', (req, res) => {
 // ── Windows distribution endpoints ───────────────────────────────────────────
 // These should match the values in windows/OmniKey.Windows.csproj
 // <Version> and windows/build_release_zip.ps1 $APP_VERSION.
-const WIN_VERSION = '1.0';
-const WIN_ZIP_FILENAME = 'OmniKeyAI-windows-x64.zip';
+const WIN_VERSION = '1.1';
+const WIN_ZIP_FILENAME = 'OmniKeyAI-windows-win-x64.zip';
 const WIN_ZIP_PATH = path_1.default.join(process.cwd(), 'windows', WIN_ZIP_FILENAME);
 // Serves the pre-built ZIP produced by windows/build_release_zip.ps1.
+// Streams through gzip to reduce response size on Cloud Run.
 app.get('/windows/download', (_req, res) => {
-    res.download(WIN_ZIP_PATH, WIN_ZIP_FILENAME, (err) => {
-        if (err) {
-            logger_1.logger.error('Failed to send Windows ZIP for download.', { error: err });
-            if (!res.headersSent) {
-                res.status(500).send('Unable to download file.');
-            }
+    if (!fs_1.default.existsSync(WIN_ZIP_PATH)) {
+        res.status(404).send('File not found.');
+        return;
+    }
+    res.set({
+        'Content-Type': 'application/zip',
+        'Content-Disposition': `attachment; filename="${WIN_ZIP_FILENAME}"`,
+        'Content-Encoding': 'gzip',
+    });
+    const fileStream = fs_1.default.createReadStream(WIN_ZIP_PATH);
+    const gzip = zlib_1.default.createGzip();
+    fileStream.on('error', (err) => {
+        logger_1.logger.error('Failed to send Windows ZIP for download.', { error: err });
+        if (!res.headersSent) {
+            res.status(500).send('Unable to download file.');
         }
     });
+    fileStream.pipe(gzip).pipe(res);
 });
 // JSON update-check endpoint consumed by UpdateChecker.cs on the Windows client.
 // Returns the latest version + download URL so the client can decide whether