@clappstore/connect 0.6.1 → 0.7.1

package/clapps/settings/handlers/settings-handler.js

@@ -0,0 +1,760 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+const authProfilesPath = resolve(homedir(), ".openclaw", "agents", "main", "agent", "auth-profiles.json");
+// --- Helper functions (closures over ctx) ---
+function generateProfileId(provider, customName) {
+    const suffix = customName
+        ? customName.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-")
+        : "manual";
+    return `${provider}:${suffix}`;
+}
+function maskCredential(credential) {
+    if (credential.length <= 12)
+        return "***";
+    return credential.slice(0, 7) + "..." + credential.slice(-4);
+}
+function formatProviderName(provider) {
+    const names = {
+        anthropic: "Anthropic",
+        openai: "OpenAI",
+        "openai-codex": "OpenAI Codex",
+        gemini: "Google Gemini",
+        google: "Google",
+        "kimi-coding": "Kimi Coding",
+        nvidia: "NVIDIA",
+        ollama: "Ollama",
+    };
+    return names[provider] ?? provider.charAt(0).toUpperCase() + provider.slice(1);
+}
+function formatModelLabel(modelId, meta) {
+    const alias = typeof meta?.alias === "string" ? meta.alias : "";
+    const [, ...rest] = modelId.split("/");
+    const shortId = rest.join("/") || modelId;
+    return alias ? `${alias} (${shortId})` : shortId;
+}
+function formatModelLabelFromId(modelId) {
+    if (!modelId)
+        return "Unknown";
+    const aliases = {
+        "anthropic/claude-opus-4-5": "Claude Opus 4.5",
+        "anthropic/claude-opus-4-6": "Claude Opus 4.6",
+        "anthropic/claude-sonnet-4-5": "Claude Sonnet 4.5",
+        "openai-codex/gpt-5.3-codex": "Codex (GPT-5.3)",
+        "openai/gpt-5.2": "GPT-5.2",
+        "kimi-coding/k2p5": "Kimi K2.5",
+    };
+    return aliases[modelId] || modelId.split("/").pop() || modelId;
+}
+function formatSessionLabel(key, agentId, originLabel, displayName) {
+    if (originLabel) {
+        const namePart = originLabel.split(" (")[0].split(" @")[0].split(" id:")[0];
+        if (namePart && namePart.length > 0 && namePart.length < 30) {
+            return namePart;
+        }
+    }
+    if (displayName)
+        return displayName;
+    const parts = key.split(":");
+    if (parts[0] === "agent")
+        return agentId || parts[1] || key;
+    const channelNames = {
+        telegram: "Telegram",
+        discord: "Discord",
+        whatsapp: "WhatsApp",
+        signal: "Signal",
+        slack: "Slack",
+        irc: "IRC",
+    };
+    return channelNames[parts[0]] || parts[0];
+}
+function detectAuthType(profileId, profile) {
+    if (profile.access || profile.refresh)
+        return "subscription";
+    const lowerProfileId = profileId.toLowerCase();
+    if (lowerProfileId.includes("-sub") || lowerProfileId.includes("sub-"))
+        return "subscription";
+    if (profile.provider === "anthropic" && profile.token) {
+        if (profile.token.startsWith("sk-ant-api"))
+            return "api-key";
+        if (profile.token.startsWith("sk-ant-oat") || profile.token.startsWith("sk-ant-sid"))
+            return "subscription";
+    }
+    if (profile.provider === "openai-codex")
+        return "subscription";
+    return "api-key";
+}
+function getActiveModel() {
+    try {
+        const configPath = resolve(homedir(), ".openclaw", "openclaw.json");
+        if (!existsSync(configPath))
+            return null;
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        const primary = config?.agents?.defaults?.model?.primary;
+        if (typeof primary === "string" && primary.includes("/")) {
+            const [provider, ...rest] = primary.split("/");
+            return { provider, model: rest.join("/") };
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return null;
+}
+function getModelCatalogByProvider() {
+    const map = new Map();
+    try {
+        const configPath = resolve(homedir(), ".openclaw", "openclaw.json");
+        if (!existsSync(configPath))
+            return map;
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        const models = config?.agents?.defaults?.models ?? {};
+        for (const [modelId, meta] of Object.entries(models)) {
+            if (typeof modelId !== "string" || !modelId.includes("/"))
+                continue;
+            const [provider] = modelId.split("/");
+            if (!provider)
+                continue;
+            const label = formatModelLabel(modelId, meta);
+            const existing = map.get(provider) ?? [];
+            existing.push({ id: modelId, label });
+            map.set(provider, existing);
+        }
+        for (const [provider, entries] of map) {
+            entries.sort((a, b) => a.label.localeCompare(b.label));
+            map.set(provider, entries);
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return map;
+}
+function getFirstModelForProvider(provider) {
+    const modelsByProvider = getModelCatalogByProvider();
+    const normalizedProviderAliases = {
+        "openai codex": "openai-codex",
+        "google gemini": "gemini",
+        "kimi coding": "kimi-coding",
+        "kimi k2": "nvidia",
+        glm5: "nvidia",
+    };
+    const normalizedProvider = normalizedProviderAliases[provider] ?? provider;
+    const models = modelsByProvider.get(normalizedProvider) ?? [];
+    return models[0]?.id ?? null;
+}
+function getConfiguredProviders() {
+    const providers = [];
+    const activeModel = getActiveModel();
+    const modelsByProvider = getModelCatalogByProvider();
+    try {
+        if (!existsSync(authProfilesPath))
+            return providers;
+        const data = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+        for (const [profileId, profile] of Object.entries(data.profiles)) {
+            let maskedCred = "";
+            let mode = profile.type;
+            let authType = "api-key";
+            if (profile.token) {
+                maskedCred = maskCredential(profile.token);
+                mode = "token";
+                authType = detectAuthType(profileId, profile);
+            }
+            else if (profile.key) {
+                maskedCred = maskCredential(profile.key);
+                mode = "api_key";
+                authType = "api-key";
+            }
+            else if (profile.access) {
+                maskedCred = "OAuth connected";
+                mode = "oauth";
+                authType = "subscription";
+            }
+            if (maskedCred) {
+                const isActive = activeModel?.provider === profile.provider;
+                const profileIdentifier = profileId.includes(":") ? profileId.split(":")[1] : profileId;
+                const baseName = formatProviderName(profile.provider);
+                const displayName = profile.customName || `${baseName} · ${profileIdentifier}`;
+                providers.push({
+                    id: profileId,
+                    name: displayName,
+                    configured: true,
+                    mode,
+                    authType,
+                    maskedCredential: maskedCred,
+                    active: isActive,
+                    models: modelsByProvider.get(profile.provider) ?? [],
+                });
+            }
+        }
+        providers.sort((a, b) => {
+            if (a.active && !b.active)
+                return -1;
+            if (!a.active && b.active)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+    }
+    catch (err) {
+        console.warn(`[settings] Failed to read auth-profiles.json: ${err}`);
+    }
+    return providers;
+}
+function setEnvVar(key, value) {
+    try {
+        const configPath = resolve(homedir(), ".openclaw", "openclaw.json");
+        let config = {};
+        if (existsSync(configPath)) {
+            config = JSON.parse(readFileSync(configPath, "utf-8"));
+        }
+        if (!config.env || typeof config.env !== "object") {
+            config.env = {};
+        }
+        config.env[key] = value;
+        if (config.meta && typeof config.meta === "object") {
+            config.meta.lastTouchedAt = new Date().toISOString();
+        }
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log(`[settings] Set ${key} in openclaw.json`);
+    }
+    catch (err) {
+        console.warn(`[settings] Failed to set env var ${key}: ${err}`);
+    }
+}
+function getSessionsData() {
+    try {
+        const listResult = spawnSync("openclaw", ["gateway", "call", "sessions.list", "--params", '{"limit": 50}', "--json"], { encoding: "utf-8", timeout: 15_000 });
+        if (listResult.status !== 0)
+            return { sessions: [], globalModel: null };
+        let rawSessions = [];
+        try {
+            const parsed = JSON.parse(listResult.stdout);
+            rawSessions = parsed.sessions || [];
+        }
+        catch {
+            return { sessions: [], globalModel: null };
+        }
+        const globalDefault = getActiveModel();
+        const globalModelId = globalDefault
+            ? `${globalDefault.provider}/${globalDefault.model}`
+            : null;
+        const sessions = rawSessions
+            .filter((s) => s.kind === "direct")
+            .map((s) => {
+            const sessionModel = s.modelProvider && s.model
+                ? `${s.modelProvider}/${s.model}`
+                : s.model || globalModelId;
+            const isOverride = sessionModel !== globalModelId;
+            return {
+                key: s.key,
+                label: formatSessionLabel(s.key, s.agentId, s.origin?.label, s.displayName),
+                model: sessionModel,
+                modelLabel: formatModelLabelFromId(sessionModel),
+                isOverride,
+                lastUpdated: s.updatedAt ? new Date(s.updatedAt).toISOString() : undefined,
+            };
+        })
+            .sort((a, b) => {
+            if (a.isOverride && !b.isOverride)
+                return -1;
+            if (!a.isOverride && b.isOverride)
+                return 1;
+            return 0;
+        });
+        return { sessions, globalModel: globalModelId };
+    }
+    catch {
+        return { sessions: [], globalModel: null };
+    }
+}
+// === Factory ===
+export default function createSettingsHandler(ctx) {
+    function writeSettingsState() {
+        const providers = getConfiguredProviders();
+        const isConfigured = providers.length > 0;
+        const activeModel = getActiveModel();
+        const activeProvider = providers.find((p) => p.active);
+        const sessionsData = getSessionsData();
+        const state = {
+            version: Date.now(),
+            timestamp: new Date().toISOString(),
+            state: {
+                active: {
+                    isConfigured,
+                    provider: activeProvider?.name ?? null,
+                    model: activeModel ? `${activeModel.provider}/${activeModel.model}` : null,
+                },
+                configuredProviders: providers,
+                sessions: sessionsData,
+            },
+        };
+        const statePath = resolve(ctx.stateDir, "settings.json");
+        writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+    }
+    function pushSettingsState() {
+        const statePath = resolve(ctx.stateDir, "settings.json");
+        const content = readFileSync(statePath, "utf-8");
+        ctx.setState("settings", JSON.parse(content));
+    }
+    function pushStatusState() {
+        const statePath = resolve(ctx.stateDir, "_status.json");
+        if (existsSync(statePath)) {
+            const content = readFileSync(statePath, "utf-8");
+            ctx.setState("_status", JSON.parse(content));
+        }
+    }
+    function afterCredentialChange() {
+        writeSettingsState();
+        pushSettingsState();
+        ctx.checkAuthStatus();
+        pushStatusState();
+    }
+    function patchAllSessionModels(newModelId) {
+        try {
+            const listResult = spawnSync("openclaw", ["gateway", "call", "sessions.list", "--params", '{"limit": 100}', "--json"], { encoding: "utf-8", timeout: 15_000 });
+            if (listResult.status !== 0) {
+                console.warn(`[settings] Failed to list sessions: ${listResult.stderr}`);
+                return;
+            }
+            let sessions = [];
+            try {
+                const parsed = JSON.parse(listResult.stdout);
+                sessions = parsed.sessions || [];
+            }
+            catch {
+                console.warn(`[settings] Failed to parse sessions list`);
+                return;
+            }
+            const mainSessions = sessions.filter((s) => s.kind === "direct" || s.key.endsWith(":main"));
+            for (const session of mainSessions) {
+                const idempotencyKey = `clapps-model-${session.key}-${Date.now()}`;
+                const sendResult = spawnSync("openclaw", [
+                    "gateway",
+                    "call",
+                    "chat.send",
+                    "--params",
+                    JSON.stringify({
+                        sessionKey: session.key,
+                        message: `/model ${newModelId}`,
+                        idempotencyKey,
+                    }),
+                ], { encoding: "utf-8", timeout: 10_000 });
+                if (sendResult.status === 0) {
+                    console.log(`[settings] Sent /model to session "${session.key}"`);
+                }
+                else {
+                    console.warn(`[settings] Failed to send /model to "${session.key}": ${sendResult.stderr}`);
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[settings] Failed to update session models: ${err}`);
+        }
+    }
+    function clearAgentModelOverrides(newModelId) {
+        try {
+            const configPath = resolve(homedir(), ".openclaw", "openclaw.json");
+            if (!existsSync(configPath))
+                return;
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            if (Array.isArray(config.agents?.list)) {
+                let changed = false;
+                for (const agent of config.agents.list) {
+                    if (agent.model && agent.model !== newModelId) {
+                        agent.model = newModelId;
+                        changed = true;
+                        console.log(`[settings] Updated agent "${agent.id}" model to ${newModelId}`);
+                    }
+                }
+                if (changed) {
+                    if (config.meta)
+                        config.meta.lastTouchedAt = new Date().toISOString();
+                    writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+                    console.log(`[settings] Saved openclaw.json with updated agent models`);
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[settings] Failed to update agent model overrides: ${err}`);
+        }
+        patchAllSessionModels(newModelId);
+    }
+    function listSessions() {
+        try {
+            const listResult = spawnSync("openclaw", ["gateway", "call", "sessions.list", "--params", '{"limit": 50}', "--json"], { encoding: "utf-8", timeout: 15_000 });
+            if (listResult.status !== 0) {
+                console.warn(`[settings] Failed to list sessions: ${listResult.stderr}`);
+                return;
+            }
+            let rawSessions = [];
+            try {
+                const parsed = JSON.parse(listResult.stdout);
+                rawSessions = parsed.sessions || [];
+            }
+            catch {
+                console.warn(`[settings] Failed to parse sessions list`);
+                return;
+            }
+            const globalDefault = getActiveModel();
+            const globalModelId = globalDefault
+                ? `${globalDefault.provider}/${globalDefault.model}`
+                : null;
+            const sessions = rawSessions
+                .filter((s) => s.kind === "direct")
+                .map((s) => {
+                const sessionModel = s.modelProvider && s.model
+                    ? `${s.modelProvider}/${s.model}`
+                    : s.model || globalModelId;
+                const isOverride = sessionModel !== globalModelId;
+                return {
+                    key: s.key,
+                    label: formatSessionLabel(s.key, s.agentId, s.origin?.label, s.displayName),
+                    model: sessionModel,
+                    modelLabel: formatModelLabelFromId(sessionModel),
+                    isOverride,
+                    lastUpdated: s.updatedAt ? new Date(s.updatedAt).toISOString() : undefined,
+                };
+            })
+                .sort((a, b) => {
+                if (a.isOverride && !b.isOverride)
+                    return -1;
+                if (!a.isOverride && b.isOverride)
+                    return 1;
+                return 0;
+            });
+            const statePath = resolve(ctx.stateDir, "sessions.json");
+            const state = {
+                version: Date.now(),
+                timestamp: new Date().toISOString(),
+                state: { sessions, globalModel: globalModelId },
+            };
+            writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+            ctx.setState("sessions", state);
+        }
+        catch (err) {
+            console.warn(`[settings] Failed to list sessions: ${err}`);
+        }
+    }
+    // --- Credential setters ---
+    function setAnthropicKey(apiKey, customName, existingProfileId) {
+        let profiles = { version: 1, profiles: {} };
+        try {
+            if (existsSync(authProfilesPath)) {
+                profiles = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+            }
+        }
+        catch {
+            // Start fresh
+        }
+        const profileId = existingProfileId ?? generateProfileId("anthropic", customName);
+        profiles.profiles[profileId] = {
+            type: "token",
+            provider: "anthropic",
+            token: apiKey,
+            customName: customName || "Anthropic API",
+        };
+        mkdirSync(dirname(authProfilesPath), { recursive: true });
+        writeFileSync(authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+        console.log(`✅ Anthropic API key saved to ${authProfilesPath} (profile: ${profileId})`);
+        afterCredentialChange();
+    }
+    function setClaudeToken(token, customName) {
+        const result = spawnSync("openclaw", ["models", "auth", "paste-token", "--provider", "anthropic"], { input: token, encoding: "utf-8", timeout: 15_000 });
+        if (result.status !== 0) {
+            const msg = (result.stderr || result.error?.message || "unknown error").toString().trim();
+            console.error(`[settings] openclaw paste-token failed: ${msg}`);
+            return;
+        }
+        if (customName) {
+            try {
+                if (existsSync(authProfilesPath)) {
+                    const profiles = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+                    for (const [_key, profile] of Object.entries(profiles.profiles)) {
+                        if (profile.provider === "anthropic" && (profile.access || profile.refresh)) {
+                            profile.customName = customName;
+                            break;
+                        }
+                    }
+                    writeFileSync(authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        console.log("✅ Claude subscription token saved via openclaw");
+        afterCredentialChange();
+    }
+    function setOpenAIKey(apiKey, customName, existingProfileId) {
+        let profiles = { version: 1, profiles: {} };
+        try {
+            if (existsSync(authProfilesPath)) {
+                profiles = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+            }
+        }
+        catch {
+            // Start fresh
+        }
+        const profileId = existingProfileId ?? generateProfileId("openai", customName);
+        profiles.profiles[profileId] = {
+            type: "token",
+            provider: "openai",
+            token: apiKey,
+            customName: customName || "OpenAI API",
+        };
+        setEnvVar("OPENAI_API_KEY", apiKey);
+        mkdirSync(dirname(authProfilesPath), { recursive: true });
+        writeFileSync(authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+        console.log(`✅ OpenAI API key saved to ${authProfilesPath} (profile: ${profileId})`);
+        afterCredentialChange();
+    }
+    function setKimiCodingKey(apiKey, customName, existingProfileId) {
+        let profiles = { version: 1, profiles: {} };
+        try {
+            if (existsSync(authProfilesPath)) {
+                profiles = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+            }
+        }
+        catch {
+            // Start fresh
+        }
+        const profileId = existingProfileId ?? generateProfileId("kimi-coding", customName);
+        profiles.profiles[profileId] = {
+            type: "token",
+            provider: "kimi-coding",
+            token: apiKey,
+            customName: customName || "Kimi Coding",
+        };
+        setEnvVar("KIMI_API_KEY", apiKey);
+        mkdirSync(dirname(authProfilesPath), { recursive: true });
+        writeFileSync(authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+        console.log(`✅ Kimi Coding API key saved to ${authProfilesPath} (profile: ${profileId})`);
+        afterCredentialChange();
+    }
+    function startOAuth(provider, customName) {
+        const result = spawnSync("openclaw", ["models", "auth", "login", "--provider", provider], { encoding: "utf-8", timeout: 30_000, stdio: "inherit" });
+        if (result.status !== 0) {
+            console.error(`[settings] OAuth login failed for ${provider}`);
+            return;
+        }
+        if (customName) {
+            try {
+                if (existsSync(authProfilesPath)) {
+                    const profiles = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+                    for (const [_key, profile] of Object.entries(profiles.profiles)) {
+                        if (profile.provider === provider && (profile.access || profile.refresh)) {
+                            profile.customName = customName;
+                            break;
+                        }
+                    }
+                    writeFileSync(authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        console.log(`✅ OAuth login completed for ${provider}`);
+        afterCredentialChange();
+    }
+    function deleteProvider(profileId) {
+        try {
+            if (!existsSync(authProfilesPath)) {
+                console.warn(`[settings] No auth-profiles.json found`);
+                return;
+            }
+            const profiles = JSON.parse(readFileSync(authProfilesPath, "utf-8"));
+            if (!profiles.profiles[profileId]) {
+                console.warn(`[settings] Profile "${profileId}" not found`);
+                return;
+            }
+            delete profiles.profiles[profileId];
+            writeFileSync(authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+            console.log(`✅ Deleted provider profile: ${profileId}`);
+            afterCredentialChange();
+        }
+        catch (err) {
+            console.error(`[settings] Failed to delete provider: ${err}`);
+        }
+    }
+    function setActiveProvider(provider) {
+        const modelId = getFirstModelForProvider(provider);
+        if (!modelId) {
+            console.warn(`[settings] Unknown provider or no models available: ${provider}`);
+            return;
+        }
+        setActiveModel(modelId);
+    }
+    function setActiveModel(modelId) {
+        const result = spawnSync("openclaw", ["models", "set", modelId], {
+            encoding: "utf-8",
+            timeout: 20_000,
+        });
+        if (result.status !== 0) {
+            const msg = (result.stderr || result.error?.message || "unknown error").toString().trim();
+            console.error(`[settings] Failed to set default model: ${msg}`);
+            return;
+        }
+        clearAgentModelOverrides(modelId);
+        console.log(`✅ Active model set system-wide to ${modelId}`);
+        writeSettingsState();
+        pushSettingsState();
+    }
+    function resetSessionModel(sessionKey) {
+        const globalDefault = getActiveModel();
+        if (!globalDefault) {
+            console.warn(`[settings] No global default model configured`);
+            return;
+        }
+        const modelId = `${globalDefault.provider}/${globalDefault.model}`;
+        const result = spawnSync("openclaw", [
+            "gateway",
+            "call",
+            "chat.send",
+            "--params",
+            JSON.stringify({
+                sessionKey,
+                message: `/model ${modelId}`,
+                idempotencyKey: `clapps-reset-${sessionKey}-${Date.now()}`,
+            }),
+        ], { encoding: "utf-8", timeout: 10_000 });
+        if (result.status === 0) {
+            console.log(`[settings] Reset session "${sessionKey}" to default model`);
+        }
+        else {
+            console.warn(`[settings] Failed to reset session "${sessionKey}": ${result.stderr}`);
+        }
+        setTimeout(() => listSessions(), 1000);
+    }
+    function applyDefaultToAllSessions() {
+        const globalDefault = getActiveModel();
+        if (!globalDefault) {
+            console.warn(`[settings] No global default model configured`);
+            return;
+        }
+        const modelId = `${globalDefault.provider}/${globalDefault.model}`;
+        patchAllSessionModels(modelId);
+        setTimeout(() => listSessions(), 2000);
+    }
+    function refreshSettingsState() {
+        writeSettingsState();
+        pushSettingsState();
+        listSessions();
+    }
+    // --- Handler interface ---
+    return {
+        handleIntent(intent) {
+            if (!intent.intent.startsWith("settings."))
+                return false;
+            const customName = typeof intent.payload.customName === "string"
+                ? intent.payload.customName.trim()
+                : undefined;
+            const profileId = typeof intent.payload.profileId === "string"
+                ? intent.payload.profileId.trim()
+                : undefined;
+            switch (intent.intent) {
+                case "settings.setAnthropicKey": {
+                    const apiKey = intent.payload.apiKey;
+                    if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+                        console.warn("[settings] Invalid apiKey payload, ignoring");
+                        return true;
+                    }
+                    setAnthropicKey(apiKey.trim(), customName, profileId);
+                    return true;
+                }
+                case "settings.setClaudeToken": {
+                    const token = intent.payload.setupToken ?? intent.payload.token;
+                    if (typeof token !== "string" || token.trim().length === 0) {
+                        console.warn("[settings] Invalid token/setupToken payload, ignoring");
+                        return true;
+                    }
+                    setClaudeToken(token.trim(), customName);
+                    return true;
+                }
+                case "settings.setOpenAIKey": {
+                    const apiKey = intent.payload.apiKey;
+                    if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+                        console.warn("[settings] Invalid apiKey payload, ignoring");
+                        return true;
+                    }
+                    setOpenAIKey(apiKey.trim(), customName, profileId);
+                    return true;
+                }
+                case "settings.setKimiCodingKey": {
+                    const apiKey = intent.payload.apiKey;
+                    if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+                        console.warn("[settings] Invalid apiKey payload, ignoring");
+                        return true;
+                    }
+                    setKimiCodingKey(apiKey.trim(), customName, profileId);
+                    return true;
+                }
+                case "settings.startOAuth": {
+                    const provider = intent.payload.provider;
+                    if (typeof provider !== "string" || provider.trim().length === 0) {
+                        console.warn("[settings] Invalid provider payload for OAuth, ignoring");
+                        return true;
+                    }
+                    startOAuth(provider.trim(), customName);
+                    return true;
+                }
+                case "settings.deleteProvider": {
+                    if (!profileId) {
+                        console.warn("[settings] Missing profileId for deleteProvider, ignoring");
+                        return true;
+                    }
+                    deleteProvider(profileId);
+                    return true;
+                }
+                case "settings.setActiveProvider": {
+                    const provider = intent.payload.provider;
+                    if (typeof provider !== "string" || provider.trim().length === 0) {
+                        console.warn("[settings] Invalid provider payload, ignoring");
+                        return true;
+                    }
+                    setActiveProvider(provider.trim().toLowerCase());
+                    return true;
+                }
+                case "settings.setActiveModel": {
+                    const model = intent.payload.model;
+                    if (typeof model !== "string" || model.trim().length === 0) {
+                        console.warn("[settings] Invalid model payload, ignoring");
+                        return true;
+                    }
+                    setActiveModel(model.trim().toLowerCase());
+                    return true;
+                }
+                case "settings.listSessions": {
+                    listSessions();
+                    return true;
+                }
+                case "settings.resetSessionModel": {
+                    const sessionKey = intent.payload.sessionKey;
+                    if (typeof sessionKey !== "string" || sessionKey.trim().length === 0) {
+                        console.warn("[settings] Invalid sessionKey payload, ignoring");
+                        return true;
+                    }
+                    resetSessionModel(sessionKey.trim());
+                    return true;
+                }
+                case "settings.applyDefaultToAll": {
+                    applyDefaultToAllSessions();
+                    return true;
+                }
+                default:
+                    console.warn(`[settings] Unknown settings intent: ${intent.intent}`);
+                    return true;
+            }
+        },
+        onConnect() {
+            refreshSettingsState();
+        },
+        refresh() {
+            refreshSettingsState();
+        },
+        init() {
+            writeSettingsState();
+        },
+    };
+}