comisai 1.0.18 → 1.0.22

package/node_modules/@comis/agent/dist/safety/tool-image-sanitizer.js

@@ -1,96 +0,0 @@
-/**
- * Tool image sanitizer -- validates, resizes, and re-encodes images
- * from tool results before they enter LLM context.
- *
- * Prevents memory spikes from oversized images and rejects corrupt
- * or unsupported image data. Uses sharp for processing with
- * decompression bomb protection via limitInputPixels.
- */
-import sharp from "sharp";
-import { ok, err } from "@comis/shared";
-// Disable sharp cache to prevent memory accumulation across calls
-sharp.cache(false);
-/** Default limit for decompression bomb protection (268 million pixels). */
-const DEFAULT_LIMIT_INPUT_PIXELS = 268_402_689;
-/**
- * Create a tool image sanitizer instance.
- *
- * @param opts - Optional configuration overriding defaults.
- * @returns A ToolImageSanitizer instance.
- */
-export function createToolImageSanitizer(opts) {
-    const maxWidth = opts?.maxWidth ?? 1024;
-    const maxHeight = opts?.maxHeight ?? 1024;
-    const maxInputBytes = opts?.maxInputBytes ?? 10_485_760;
-    const outputFormat = opts?.outputFormat ?? "png";
-    const quality = opts?.quality ?? 85;
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        async sanitize(base64Data, _mimeType) {
-            // Reject empty input
-            if (!base64Data || base64Data.length === 0) {
-                return err("Empty image data provided");
-            }
-            // Decode base64 to buffer
-            let inputBuffer;
-            try {
-                inputBuffer = Buffer.from(base64Data, "base64");
-            }
-            catch {
-                return err("Failed to decode base64 image data");
-            }
-            // Reject if decoded buffer is empty (empty base64 decodes to empty buffer)
-            if (inputBuffer.length === 0) {
-                return err("Empty image data after base64 decode");
-            }
-            // Check size against maxInputBytes
-            if (inputBuffer.length > maxInputBytes) {
-                return err(`Image size ${inputBuffer.length} bytes exceeds maximum allowed ${maxInputBytes} bytes`);
-            }
-            try {
-                // Create sharp instance with decompression bomb protection
-                const image = sharp(inputBuffer, {
-                    limitInputPixels: DEFAULT_LIMIT_INPUT_PIXELS,
-                });
-                // Read metadata to determine if resize is needed
-                const metadata = await image.metadata();
-                if (!metadata.width || !metadata.height) {
-                    return err("Unable to read image dimensions -- possibly corrupt or unsupported format");
-                }
-                // Resize if exceeds limits (fit: inside preserves aspect ratio)
-                const needsResize = metadata.width > maxWidth || metadata.height > maxHeight;
-                if (needsResize) {
-                    image.resize(maxWidth, maxHeight, { fit: "inside" });
-                }
-                // Convert to output format
-                let outputBuffer;
-                switch (outputFormat) {
-                    case "jpeg":
-                        outputBuffer = await image.jpeg({ quality }).toBuffer();
-                        break;
-                    case "webp":
-                        outputBuffer = await image.webp({ quality }).toBuffer();
-                        break;
-                    case "png":
-                    default:
-                        outputBuffer = await image.png().toBuffer();
-                        break;
-                }
-                // Read final metadata from the output
-                const outputMeta = await sharp(outputBuffer).metadata();
-                return ok({
-                    buffer: outputBuffer,
-                    format: outputFormat,
-                    width: outputMeta.width ?? (needsResize ? maxWidth : metadata.width),
-                    height: outputMeta.height ?? (needsResize ? maxHeight : metadata.height),
-                    originalBytes: inputBuffer.length,
-                    sanitizedBytes: outputBuffer.length,
-                });
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                return err(`Image processing failed: ${message}`);
-            }
-        },
-    };
-}

package/node_modules/@comis/agent/dist/safety/tool-sanitizer.d.ts

@@ -1,44 +0,0 @@
-/**
- * Tool output sanitizer -- strips indirect prompt injection patterns.
- *
- * Detects instruction-like text in tool outputs that could be used
- * to hijack the agent's behavior via indirect prompt injection.
- * Replaces detected patterns with "[REDACTED]" and truncates
- * oversized output at newline boundaries.
- */
-/**
- * Normalize text for secure pattern matching.
- * 1. Apply Unicode NFKC normalization (compatibility decomposition + canonical composition)
- * 2. Strip zero-width and invisible formatting characters (including tag block bypass)
- *
- * IMPORTANT: Always normalize FIRST, then do pattern matching on the normalized string.
- * NFKC can change string length (e.g., fullwidth A -> A, ligatures decompose).
- */
-export declare function normalizeForMatching(text: string): string;
-/**
- * Regex patterns that indicate potential prompt injection attempts.
- *
- * Imported from @comis/core injection-patterns.ts (single source of truth).
- * Each pattern uses the `gi` flag for case-insensitive global matching.
- *
- * Note: The `system\s*:\s+` pattern requires whitespace after colon
- * to avoid matching URLs like `https://system.example.com:8080`
- * or code like `process.env.system`.
- */
-export declare const INSTRUCTION_PATTERNS: readonly RegExp[];
-/**
- * Sanitize tool output against indirect prompt injection.
- *
- * 1. Checks for Unicode tag block bypass characters (for caller-side INFO logging)
- * 2. Replaces instruction-like injection patterns with "[REDACTED]"
- * 3. Truncates output exceeding `maxChars` at the last newline before
- *    the 95% mark, appending a truncation notice
- *
- * @param text - Raw tool output text
- * @param maxChars - Maximum allowed characters (default: 50,000)
- * @param options - Optional callbacks for tag block detection logging
- * @returns Sanitized text with injections redacted and size enforced
- */
-export declare function sanitizeToolOutput(text: string, maxChars?: number, options?: {
-    onTagBlockDetected?: () => void;
-}): string;

package/node_modules/@comis/agent/dist/safety/tool-sanitizer.js

@@ -1,94 +0,0 @@
-/**
- * Tool output sanitizer -- strips indirect prompt injection patterns.
- *
- * Detects instruction-like text in tool outputs that could be used
- * to hijack the agent's behavior via indirect prompt injection.
- * Replaces detected patterns with "[REDACTED]" and truncates
- * oversized output at newline boundaries.
- */
-import { stripInvisible, containsTagBlockChars, IGNORE_PREV_INSTRUCTIONS, YOU_ARE_NOW, FORGET_EVERYTHING, NEW_INSTRUCTIONS, SYSTEM_COLON, SYSTEM_BRACKET, INST_BRACKET, SYSTEM_TAG, IMPORTANT_OVERRIDE, DISREGARD_INSTRUCTIONS, ACT_AS_ROLE, ASSISTANT_ROLE_MARKER, SPECIAL_TOKEN_DELIMITERS, CONTEXT_RESET, RULE_REPLACEMENT, OVERRIDE_SAFETY, } from "@comis/core";
-/**
- * Normalize text for secure pattern matching.
- * 1. Apply Unicode NFKC normalization (compatibility decomposition + canonical composition)
- * 2. Strip zero-width and invisible formatting characters (including tag block bypass)
- *
- * IMPORTANT: Always normalize FIRST, then do pattern matching on the normalized string.
- * NFKC can change string length (e.g., fullwidth A -> A, ligatures decompose).
- */
-export function normalizeForMatching(text) {
-    return stripInvisible(text.normalize("NFKC")).text;
-}
-/** Default maximum characters for tool output */
-const DEFAULT_MAX_CHARS = 50_000;
-/** Truncation message appended when output is cut */
-const TRUNCATION_MSG = "\n[Content truncated -- exceeded size limit]";
-/**
- * Regex patterns that indicate potential prompt injection attempts.
- *
- * Imported from @comis/core injection-patterns.ts (single source of truth).
- * Each pattern uses the `gi` flag for case-insensitive global matching.
- *
- * Note: The `system\s*:\s+` pattern requires whitespace after colon
- * to avoid matching URLs like `https://system.example.com:8080`
- * or code like `process.env.system`.
- */
-export const INSTRUCTION_PATTERNS = [
-    IGNORE_PREV_INSTRUCTIONS, // /ignore\s+(all\s+)?previous\s+instructions/gi
-    YOU_ARE_NOW, // /you\s+are\s+now\s+/gi
-    FORGET_EVERYTHING, // /forget\s+(everything|all|your)\s/gi
-    NEW_INSTRUCTIONS, // /new\s+instructions?\s*:/gi
-    SYSTEM_COLON, // /system\s*:\s+/gi
-    SYSTEM_BRACKET, // /\[SYSTEM\]/gi
-    INST_BRACKET, // /\[INST\]/gi
-    SYSTEM_TAG, // /<\/?system>/gi
-    IMPORTANT_OVERRIDE, // /IMPORTANT\s*:\s*override/gi
-    DISREGARD_INSTRUCTIONS, // /disregard ... instructions/
-    ACT_AS_ROLE, // /act as root|admin|.../
-    ASSISTANT_ROLE_MARKER, // /assistant:|user:/
-    SPECIAL_TOKEN_DELIMITERS, // /<|...|>/
-    CONTEXT_RESET, // /context reset|cleared|.../
-    RULE_REPLACEMENT, // /new rules:|updated guidelines:/
-    OVERRIDE_SAFETY, // /override safety|bypass security/
-];
-/**
- * Sanitize tool output against indirect prompt injection.
- *
- * 1. Checks for Unicode tag block bypass characters (for caller-side INFO logging)
- * 2. Replaces instruction-like injection patterns with "[REDACTED]"
- * 3. Truncates output exceeding `maxChars` at the last newline before
- *    the 95% mark, appending a truncation notice
- *
- * @param text - Raw tool output text
- * @param maxChars - Maximum allowed characters (default: 50,000)
- * @param options - Optional callbacks for tag block detection logging
- * @returns Sanitized text with injections redacted and size enforced
- */
-export function sanitizeToolOutput(text, maxChars = DEFAULT_MAX_CHARS, options) {
-    if (text.length === 0)
-        return text;
-    // Check for tag block bypass BEFORE normalization strips them
-    if (containsTagBlockChars(text)) {
-        options?.onTagBlockDetected?.();
-    }
-    // Phase 1: Normalize for pattern matching (NFKC + strip zero-width + tag block)
-    let sanitized = normalizeForMatching(text);
-    // Phase 2: Redact injection patterns (on normalized text)
-    for (const pattern of INSTRUCTION_PATTERNS) {
-        // Reset lastIndex for sticky/global regexes across multiple calls
-        pattern.lastIndex = 0;
-        sanitized = sanitized.replace(pattern, "[REDACTED]");
-    }
-    // Phase 3: Truncate oversized output
-    if (sanitized.length > maxChars) {
-        const cutPoint = Math.floor(maxChars * 0.95);
-        const lastNewline = sanitized.lastIndexOf("\n", cutPoint);
-        if (lastNewline > 0) {
-            sanitized = sanitized.slice(0, lastNewline + 1) + TRUNCATION_MSG;
-        }
-        else {
-            // No newline found -- hard cut at 95%
-            sanitized = sanitized.slice(0, cutPoint) + TRUNCATION_MSG;
-        }
-    }
-    return sanitized;
-}

package/node_modules/@comis/channels/dist/shared/thinking-tag-filter.d.ts

@@ -1,28 +0,0 @@
-/**
- * Thinking tag filter -- strips <think>, <thinking>, and <final> blocks
- * from streaming deltas using a character-level state machine.
- *
- * Handles tags split across chunk boundaries by buffering partial
- * tag sequences and resolving them when more data arrives.
- *
- * @module
- */
-/** Streaming thinking tag filter interface. */
-export interface ThinkingTagFilter {
-    /** Process a streaming delta, returning only visible text. */
-    feed(delta: string): string;
-    /** Flush any buffered partial tag text (call at stream end). */
-    flush(): string;
-    /** Reset state for a new message. */
-    reset(): void;
-}
-/**
- * Create a thinking tag filter that strips thinking blocks from streaming deltas.
- *
- * The filter processes characters one at a time through a state machine:
- * - `passthrough`: Normal text flows through. On `<`, transition to `buffering`.
- * - `buffering`: Accumulating chars after `<` to identify an opening or closing tag.
- * - `inside_block`: All text is suppressed. On `<`, transition to `close_buffering`.
- * - `close_buffering`: Inside a block, checking for the matching closing tag.
- */
-export declare function createThinkingTagFilter(): ThinkingTagFilter;

package/node_modules/@comis/channels/dist/shared/thinking-tag-filter.js

@@ -1,206 +0,0 @@
-/**
- * Thinking tag filter -- strips <think>, <thinking>, and <final> blocks
- * from streaming deltas using a character-level state machine.
- *
- * Handles tags split across chunk boundaries by buffering partial
- * tag sequences and resolving them when more data arrives.
- *
- * @module
- */
-/** Recognized thinking tag names (lowercased).
- * Note: "final" is NOT included — <final> wraps the actual answer content
- * and should be unwrapped (tags stripped, content kept), not suppressed.
- * See sanitizeAssistantResponse() in @comis/agent sanitize-pipeline.ts. */
-const THINKING_TAGS = new Set(["think", "thinking"]);
-/** Maximum buffer length before we give up matching a tag. */
-const MAX_BUFFER = 24;
-/**
- * Create a thinking tag filter that strips thinking blocks from streaming deltas.
- *
- * The filter processes characters one at a time through a state machine:
- * - `passthrough`: Normal text flows through. On `<`, transition to `buffering`.
- * - `buffering`: Accumulating chars after `<` to identify an opening or closing tag.
- * - `inside_block`: All text is suppressed. On `<`, transition to `close_buffering`.
- * - `close_buffering`: Inside a block, checking for the matching closing tag.
- */
-export function createThinkingTagFilter() {
-    let state = "passthrough";
-    let buffer = "";
-    let activeTag = ""; // The tag name that opened the current block (lowercased)
-    /**
-     * Try to resolve the buffer as a tag.
-     *
-     * Returns:
-     * - `{ type: "open", tagName }` if buffer is a complete opening tag like `<think>`
-     * - `{ type: "close", tagName }` if buffer is a complete closing tag like `</think>`
-     * - `{ type: "not_tag" }` if buffer cannot be a thinking tag (flush as text)
-     * - `{ type: "partial" }` if buffer could still become a thinking tag (keep buffering)
-     */
-    function classifyBuffer(buf) {
-        // Buffer must start with <
-        if (!buf.startsWith("<"))
-            return { type: "not_tag" };
-        const lower = buf.toLowerCase();
-        // Check for closing tag pattern: </tagname>
-        if (lower.length >= 2 && lower[1] === "/") {
-            const rest = lower.slice(2);
-            // Check if it ends with >
-            if (rest.endsWith(">")) {
-                const tagName = rest.slice(0, -1);
-                if (THINKING_TAGS.has(tagName)) {
-                    return { type: "close", tagName };
-                }
-                return { type: "not_tag" };
-            }
-            // Still could be partial: check if any thinking tag starts with what we have
-            for (const tag of THINKING_TAGS) {
-                if (tag.startsWith(rest) || rest.startsWith(tag)) {
-                    return { type: "partial" };
-                }
-            }
-            return { type: "not_tag" };
-        }
-        // Check for opening tag pattern: <tagname> or <tagname/>
-        const rest = lower.slice(1);
-        // If it ends with ">", check the tag name
-        if (rest.endsWith(">")) {
-            // Could be <tagname> or <tagname/>
-            let tagName = rest.slice(0, -1);
-            if (tagName.endsWith("/")) {
-                tagName = tagName.slice(0, -1);
-            }
-            if (THINKING_TAGS.has(tagName)) {
-                return { type: "open", tagName };
-            }
-            return { type: "not_tag" };
-        }
-        // Still accumulating -- check if any thinking tag could match
-        for (const tag of THINKING_TAGS) {
-            // rest could be a prefix of the tag name (e.g., "thi" prefix of "think")
-            if (tag.startsWith(rest)) {
-                return { type: "partial" };
-            }
-            // rest could be the tag name followed by "/" (self-closing start)
-            if (rest.startsWith(tag) && (rest.length === tag.length || rest[tag.length] === "/")) {
-                return { type: "partial" };
-            }
-        }
-        return { type: "not_tag" };
-    }
-    function processChar(ch, output) {
-        switch (state) {
-            case "passthrough":
-                if (ch === "<") {
-                    buffer = "<";
-                    state = "buffering";
-                }
-                else {
-                    output.push(ch);
-                }
-                break;
-            case "buffering":
-                buffer += ch;
-                // Safety limit
-                if (buffer.length > MAX_BUFFER) {
-                    output.push(buffer);
-                    buffer = "";
-                    state = "passthrough";
-                    break;
-                }
-                {
-                    const result = classifyBuffer(buffer);
-                    if (result.type === "open") {
-                        // Enter inside_block, suppress everything
-                        activeTag = result.tagName;
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    else if (result.type === "close") {
-                        // Closing tag outside a block -- just flush it as text
-                        output.push(buffer);
-                        buffer = "";
-                        state = "passthrough";
-                    }
-                    else if (result.type === "not_tag") {
-                        // Not a thinking tag -- flush buffer as normal text
-                        output.push(buffer);
-                        buffer = "";
-                        state = "passthrough";
-                    }
-                    // "partial" -- keep buffering
-                }
-                break;
-            case "inside_block":
-                if (ch === "<") {
-                    buffer = "<";
-                    state = "close_buffering";
-                }
-                // else: suppress character
-                break;
-            case "close_buffering":
-                buffer += ch;
-                // Safety limit
-                if (buffer.length > MAX_BUFFER) {
-                    // Not a closing tag -- stay inside block
-                    buffer = "";
-                    state = "inside_block";
-                    break;
-                }
-                {
-                    const result = classifyBuffer(buffer);
-                    if (result.type === "close" && result.tagName === activeTag) {
-                        // Matching closing tag found -- exit block
-                        buffer = "";
-                        activeTag = "";
-                        state = "passthrough";
-                    }
-                    else if (result.type === "close") {
-                        // Non-matching closing tag -- stay inside block
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    else if (result.type === "open") {
-                        // Nested opening tag inside block -- just suppress, stay in block
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    else if (result.type === "not_tag") {
-                        // Not a tag at all -- suppress it, stay in block
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    // "partial" -- keep buffering
-                }
-                break;
-        }
-    }
-    return {
-        feed(delta) {
-            const output = [];
-            for (let i = 0; i < delta.length; i++) {
-                processChar(delta[i], output);
-            }
-            return output.join("");
-        },
-        flush() {
-            // Return any buffered text that never resolved to a thinking tag
-            if (buffer && (state === "buffering")) {
-                const result = buffer;
-                buffer = "";
-                state = "passthrough";
-                return result;
-            }
-            // If inside a block or close_buffering, the block was never closed.
-            // Discard -- thinking content should not leak to output.
-            buffer = "";
-            state = "passthrough";
-            activeTag = "";
-            return "";
-        },
-        reset() {
-            state = "passthrough";
-            buffer = "";
-            activeTag = "";
-        },
-    };
-}

package/node_modules/@comis/cli/dist/wizard/config-writer.d.ts

@@ -1,25 +0,0 @@
-/**
- * Config writer for wizard results.
- *
- * Converts WizardResult into a valid config.yaml and .env file
- * using the yaml library's stringify (not hand-rolled YAML).
- * Uses safePath from @comis/core for all file write paths.
- *
- * @module
- */
-import { type Result } from "@comis/shared";
-import type { WizardResult } from "./flow-types.js";
-/**
- * Write a config.yaml file from wizard results.
- *
- * Builds a config object matching AppConfigSchema shape and serializes
- * it to YAML via the yaml library. Returns the written file path.
- */
-export declare function writeWizardConfig(result: WizardResult, configDir: string): Result<string, Error>;
-/**
- * Write a .env file from wizard results.
- *
- * Sets the appropriate provider API key environment variable.
- * File is written with mode 0o600 (owner read/write only).
- */
-export declare function writeWizardEnv(result: WizardResult, configDir: string): Result<string, Error>;

package/node_modules/@comis/cli/dist/wizard/config-writer.js

@@ -1,144 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Config writer for wizard results.
- *
- * Converts WizardResult into a valid config.yaml and .env file
- * using the yaml library's stringify (not hand-rolled YAML).
- * Uses safePath from @comis/core for all file write paths.
- *
- * @module
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import { stringify } from "yaml";
-import { safePath } from "@comis/core";
-import { ok, err } from "@comis/shared";
-import { PROVIDER_ENV_KEYS, CHANNEL_ENV_KEYS } from "./flow-types.js";
-/**
- * Write a config.yaml file from wizard results.
- *
- * Builds a config object matching AppConfigSchema shape and serializes
- * it to YAML via the yaml library. Returns the written file path.
- */
-export function writeWizardConfig(result, configDir) {
-    try {
-        const defaultDir = os.homedir() + "/.comis";
-        const config = {
-            logLevel: "info",
-            dataDir: result.dataDir ?? defaultDir,
-            agents: {
-                default: {
-                    name: result.agentName,
-                    provider: result.provider,
-                    model: result.model ?? getDefaultModel(result.provider),
-                },
-            },
-        };
-        // Gateway section
-        const gatewayConfig = {
-            enabled: result.gatewayEnabled ?? false,
-        };
-        if (result.gatewayEnabled) {
-            gatewayConfig.host = result.gatewayHost ?? "127.0.0.1";
-            gatewayConfig.port = result.gatewayPort ?? 3000;
-            if (result.gatewayToken) {
-                gatewayConfig.tokens = [
-                    { id: "default", secret: "${COMIS_GATEWAY_TOKEN}", scopes: ["*"] },
-                ];
-            }
-        }
-        config.gateway = gatewayConfig;
-        // Channels section
-        if (result.channels && result.channels.length > 0) {
-            const channels = {};
-            for (const ch of result.channels) {
-                const entry = { enabled: true };
-                // Use ${VAR} substitution — credentials go in .env, not config.yaml
-                if (ch.type === "telegram" && ch.botToken)
-                    entry.botToken = "${TELEGRAM_BOT_TOKEN}";
-                if (ch.type === "discord" && ch.botToken)
-                    entry.botToken = "${DISCORD_BOT_TOKEN}";
-                if (ch.type === "slack" && ch.botToken)
-                    entry.botToken = "${SLACK_BOT_TOKEN}";
-                if (ch.type === "slack" && ch.apiKey)
-                    entry.signingSecret = "${SLACK_SIGNING_SECRET}";
-                if (ch.type === "whatsapp" && ch.botToken)
-                    entry.accessToken = "${WHATSAPP_ACCESS_TOKEN}";
-                if (ch.type === "line" && ch.botToken)
-                    entry.channelAccessToken = "${LINE_CHANNEL_ACCESS_TOKEN}";
-                if (ch.type === "line" && ch.apiKey)
-                    entry.channelSecret = "${LINE_CHANNEL_SECRET}";
-                // Generic fallback for other channel types
-                if (ch.botToken && !entry.botToken && !entry.accessToken && !entry.channelAccessToken) {
-                    entry.botToken = `\${${ch.type.toUpperCase()}_BOT_TOKEN}`;
-                }
-                if (ch.apiKey && !entry.signingSecret && !entry.channelSecret) {
-                    entry.apiKey = `\${${ch.type.toUpperCase()}_API_KEY}`;
-                }
-                if (ch.appToken)
-                    entry.appToken = `\${${ch.type.toUpperCase()}_APP_TOKEN}`;
-                channels[ch.type] = entry;
-            }
-            config.channels = channels;
-        }
-        const yaml = stringify(config, { lineWidth: 0 });
-        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-        const configPath = safePath(configDir, "config.yaml");
-        fs.writeFileSync(configPath, yaml, "utf-8");
-        return ok(configPath);
-    }
-    catch (e) {
-        return err(e instanceof Error ? e : new Error(String(e)));
-    }
-}
-/**
- * Write a .env file from wizard results.
- *
- * Sets the appropriate provider API key environment variable.
- * File is written with mode 0o600 (owner read/write only).
- */
-export function writeWizardEnv(result, configDir) {
-    try {
-        const lines = ["# Comis secrets -- generated by init wizard"];
-        if (result.provider && result.apiKey) {
-            const envKey = PROVIDER_ENV_KEYS[result.provider];
-            if (envKey) {
-                lines.push(`${envKey}=${result.apiKey}`);
-            }
-        }
-        // Write channel credentials to .env
-        if (result.channels) {
-            for (const ch of result.channels) {
-                const envKeys = CHANNEL_ENV_KEYS[ch.type];
-                if (ch.botToken && envKeys?.[0])
-                    lines.push(`${envKeys[0]}=${ch.botToken}`);
-                if (ch.apiKey && envKeys?.[1])
-                    lines.push(`${envKeys[1]}=${ch.apiKey}`);
-                if (ch.appToken)
-                    lines.push(`${ch.type.toUpperCase()}_APP_TOKEN=${ch.appToken}`);
-            }
-        }
-        // Write gateway token to .env
-        if (result.gatewayToken) {
-            lines.push(`COMIS_GATEWAY_TOKEN=${result.gatewayToken}`);
-        }
-        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-        const envPath = safePath(configDir, ".env");
-        fs.writeFileSync(envPath, lines.join("\n") + "\n", { mode: 0o600 });
-        return ok(envPath);
-    }
-    catch (e) {
-        return err(e instanceof Error ? e : new Error(String(e)));
-    }
-}
-/** Get a sensible default model for a provider. */
-function getDefaultModel(provider) {
-    const defaults = {
-        anthropic: "claude-sonnet-4-5-20250929",
-        openai: "gpt-4o",
-        google: "gemini-2.0-flash",
-        groq: "llama-3.3-70b-versatile",
-        ollama: "llama3",
-    };
-    return defaults[provider] ?? "default";
-}