@clappstore/connect 0.7.7 → 0.7.8

package/dist/settings-handler.js

@@ -0,0 +1,848 @@
+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";
+import { checkAuthStatus } from "./defaults.js";
+export class SettingsHandler {
+    stateDir;
+    store;
+    authProfilesPath;
+    constructor(options) {
+        this.stateDir = options.stateDir;
+        this.store = options.store;
+        this.authProfilesPath =
+            options.authProfilesPath ??
+                resolve(homedir(), ".openclaw", "agents", "main", "agent", "auth-profiles.json");
+    }
+    /** Returns true if the intent was handled locally (should not be forwarded to ACP) */
+    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;
+                }
+                this.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;
+                }
+                this.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;
+                }
+                this.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;
+                }
+                this.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;
+                }
+                this.startOAuth(provider.trim(), customName);
+                return true;
+            }
+            case "settings.deleteProvider": {
+                if (!profileId) {
+                    console.warn("[settings] Missing profileId for deleteProvider, ignoring");
+                    return true;
+                }
+                this.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;
+                }
+                this.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;
+                }
+                this.setActiveModel(model.trim().toLowerCase());
+                return true;
+            }
+            case "settings.listSessions": {
+                this.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;
+                }
+                this.resetSessionModel(sessionKey.trim());
+                return true;
+            }
+            case "settings.applyDefaultToAll": {
+                this.applyDefaultToAllSessions();
+                return true;
+            }
+            default:
+                console.warn(`[settings] Unknown settings intent: ${intent.intent}`);
+                return true;
+        }
+    };
+    /** Generate a unique profile ID */
+    generateProfileId(provider, customName) {
+        const suffix = customName
+            ? customName.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-")
+            : "manual";
+        return `${provider}:${suffix}`;
+    }
+    /** Write auth-profiles.json with the Anthropic API key */
+    setAnthropicKey(apiKey, customName, existingProfileId) {
+        let profiles = { version: 1, profiles: {} };
+        try {
+            if (existsSync(this.authProfilesPath)) {
+                profiles = JSON.parse(readFileSync(this.authProfilesPath, "utf-8"));
+            }
+        }
+        catch {
+            // Start fresh if unreadable
+        }
+        const profileId = existingProfileId ?? this.generateProfileId("anthropic", customName);
+        profiles.profiles[profileId] = {
+            type: "token",
+            provider: "anthropic",
+            token: apiKey,
+            customName: customName || "Anthropic API",
+        };
+        mkdirSync(dirname(this.authProfilesPath), { recursive: true });
+        writeFileSync(this.authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+        console.log(`✅ Anthropic API key saved to ${this.authProfilesPath} (profile: ${profileId})`);
+        this.writeSettingsState();
+        this.pushSettingsState();
+        checkAuthStatus(this.stateDir, this.authProfilesPath);
+        this.pushStatusState();
+    }
+    /** Set Claude subscription token via openclaw CLI */
+    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;
+        }
+        // Update the profile with custom name if provided
+        if (customName) {
+            try {
+                if (existsSync(this.authProfilesPath)) {
+                    const profiles = JSON.parse(readFileSync(this.authProfilesPath, "utf-8"));
+                    // Find the anthropic profile that was just updated
+                    for (const [key, profile] of Object.entries(profiles.profiles)) {
+                        if (profile.provider === "anthropic" && (profile.access || profile.refresh)) {
+                            profile.customName = customName;
+                            break;
+                        }
+                    }
+                    writeFileSync(this.authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+                }
+            }
+            catch {
+                // Ignore errors updating custom name
+            }
+        }
+        console.log("✅ Claude subscription token saved via openclaw");
+        this.writeSettingsState();
+        this.pushSettingsState();
+        checkAuthStatus(this.stateDir, this.authProfilesPath);
+        this.pushStatusState();
+    }
+    /** Write auth-profiles.json with the OpenAI API key */
+    setOpenAIKey(apiKey, customName, existingProfileId) {
+        let profiles = { version: 1, profiles: {} };
+        try {
+            if (existsSync(this.authProfilesPath)) {
+                profiles = JSON.parse(readFileSync(this.authProfilesPath, "utf-8"));
+            }
+        }
+        catch {
+            // Start fresh if unreadable
+        }
+        const profileId = existingProfileId ?? this.generateProfileId("openai", customName);
+        profiles.profiles[profileId] = {
+            type: "token",
+            provider: "openai",
+            token: apiKey,
+            customName: customName || "OpenAI API",
+        };
+        // Also set the env var in openclaw.json for compatibility
+        this.setEnvVar("OPENAI_API_KEY", apiKey);
+        mkdirSync(dirname(this.authProfilesPath), { recursive: true });
+        writeFileSync(this.authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+        console.log(`✅ OpenAI API key saved to ${this.authProfilesPath} (profile: ${profileId})`);
+        this.writeSettingsState();
+        this.pushSettingsState();
+        checkAuthStatus(this.stateDir, this.authProfilesPath);
+        this.pushStatusState();
+    }
+    /** Write auth-profiles.json with the Kimi Coding API key */
+    setKimiCodingKey(apiKey, customName, existingProfileId) {
+        let profiles = { version: 1, profiles: {} };
+        try {
+            if (existsSync(this.authProfilesPath)) {
+                profiles = JSON.parse(readFileSync(this.authProfilesPath, "utf-8"));
+            }
+        }
+        catch {
+            // Start fresh if unreadable
+        }
+        const profileId = existingProfileId ?? this.generateProfileId("kimi-coding", customName);
+        profiles.profiles[profileId] = {
+            type: "token",
+            provider: "kimi-coding",
+            token: apiKey,
+            customName: customName || "Kimi Coding",
+        };
+        // Also set the env var in openclaw.json for compatibility
+        this.setEnvVar("KIMI_API_KEY", apiKey);
+        mkdirSync(dirname(this.authProfilesPath), { recursive: true });
+        writeFileSync(this.authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+        console.log(`✅ Kimi Coding API key saved to ${this.authProfilesPath} (profile: ${profileId})`);
+        this.writeSettingsState();
+        this.pushSettingsState();
+        checkAuthStatus(this.stateDir, this.authProfilesPath);
+        this.pushStatusState();
+    }
+    /** Start OAuth flow for a provider */
+    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;
+        }
+        // Update with custom name if provided
+        if (customName) {
+            try {
+                if (existsSync(this.authProfilesPath)) {
+                    const profiles = JSON.parse(readFileSync(this.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(this.authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        console.log(`✅ OAuth login completed for ${provider}`);
+        this.writeSettingsState();
+        this.pushSettingsState();
+        checkAuthStatus(this.stateDir, this.authProfilesPath);
+        this.pushStatusState();
+    }
+    /** Delete a provider profile */
+    deleteProvider(profileId) {
+        try {
+            if (!existsSync(this.authProfilesPath)) {
+                console.warn(`[settings] No auth-profiles.json found`);
+                return;
+            }
+            const profiles = JSON.parse(readFileSync(this.authProfilesPath, "utf-8"));
+            if (!profiles.profiles[profileId]) {
+                console.warn(`[settings] Profile "${profileId}" not found`);
+                return;
+            }
+            delete profiles.profiles[profileId];
+            writeFileSync(this.authProfilesPath, JSON.stringify(profiles, null, 2), "utf-8");
+            console.log(`✅ Deleted provider profile: ${profileId}`);
+            this.writeSettingsState();
+            this.pushSettingsState();
+            checkAuthStatus(this.stateDir, this.authProfilesPath);
+            this.pushStatusState();
+        }
+        catch (err) {
+            console.error(`[settings] Failed to delete provider: ${err}`);
+        }
+    }
+    /** Set an environment variable in openclaw.json */
+    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}`);
+        }
+    }
+    /** Set the active AI provider by choosing its first configured model */
+    setActiveProvider(provider) {
+        // Provider may be a full profile ID (e.g. "anthropic:anthropic-theforever")
+        // or a base provider name. Extract base provider for model lookup.
+        const baseProvider = provider.includes(":") ? provider.split(":")[0] : provider;
+        const modelId = this.getFirstModelForProvider(baseProvider);
+        if (!modelId) {
+            console.warn(`[settings] Unknown provider or no models available: ${baseProvider}`);
+            return;
+        }
+        this.setActiveModel(modelId);
+    }
+    /** Set the active model system-wide */
+    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;
+        }
+        this.clearAgentModelOverrides(modelId);
+        console.log(`✅ Active model set system-wide to ${modelId}`);
+        this.writeSettingsState();
+        this.pushSettingsState();
+    }
+    /** Clear per-agent model overrides so all agents use the system default */
+    clearAgentModelOverrides(newModelId) {
+        try {
+            const configPath = resolve(homedir(), ".openclaw", "openclaw.json");
+            if (!existsSync(configPath))
+                return;
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            // Update agents.list to use the new model (or remove overrides)
+            if (Array.isArray(config.agents?.list)) {
+                let changed = false;
+                for (const agent of config.agents.list) {
+                    if (agent.model && agent.model !== newModelId) {
+                        // Set all agents to use the same model for system-wide consistency
+                        agent.model = newModelId;
+                        changed = true;
+                        console.log(`[settings] Updated agent "${agent.id}" model to ${newModelId}`);
+                    }
+                }
+                if (changed) {
+                    // Update lastTouchedAt timestamp
+                    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}`);
+        }
+        // Patch all active sessions to use the new model
+        this.patchAllSessionModels(newModelId);
+    }
+    /** Set model override for all active sessions via /model command */
+    patchAllSessionModels(newModelId) {
+        try {
+            // First, list all sessions
+            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;
+            }
+            // Only send /model to main/direct sessions (not cron, hooks, subagents)
+            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}`);
+        }
+    }
+    /** Get the active model from OpenClaw config */
+    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 errors
+        }
+        return null;
+    }
+    /** Read available models grouped by provider from OpenClaw config */
+    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 = this.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 parse errors and return empty catalog
+        }
+        return map;
+    }
+    /** Return first available model id for a provider */
+    getFirstModelForProvider(provider) {
+        const modelsByProvider = this.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;
+    }
+    /** Build a human-readable model label */
+    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;
+    }
+    /** Read OpenClaw auth-profiles.json and extract configured providers */
+    getConfiguredProviders() {
+        const providers = [];
+        const activeModel = this.getActiveModel();
+        const modelsByProvider = this.getModelCatalogByProvider();
+        try {
+            if (!existsSync(this.authProfilesPath)) {
+                return providers;
+            }
+            const data = JSON.parse(readFileSync(this.authProfilesPath, "utf-8"));
+            // Build provider info for each profile
+            for (const [profileId, profile] of Object.entries(data.profiles)) {
+                let maskedCredential = "";
+                let mode = profile.type;
+                let authType = "api-key";
+                if (profile.token) {
+                    maskedCredential = this.maskCredential(profile.token);
+                    mode = "token";
+                    // Detect if it's a subscription token vs API key
+                    authType = this.detectAuthType(profileId, profile);
+                }
+                else if (profile.key) {
+                    maskedCredential = this.maskCredential(profile.key);
+                    mode = "api_key";
+                    authType = "api-key";
+                }
+                else if (profile.access) {
+                    maskedCredential = "OAuth connected";
+                    mode = "oauth";
+                    authType = "subscription";
+                }
+                if (maskedCredential) {
+                    // Derive base provider from profile ID prefix (e.g. "anthropic" from "anthropic:anthropic-theforever")
+                    // profile.provider may contain account-specific names that don't match the model catalog
+                    const baseProvider = profileId.includes(":") ? profileId.split(":")[0] : profile.provider;
+                    // Check if this provider is the active one
+                    const isActive = activeModel?.provider === baseProvider;
+                    // Use custom name if available; otherwise include profile identifier to avoid duplicate labels
+                    const profileIdentifier = profileId.includes(":") ? profileId.split(":")[1] : profileId;
+                    const baseName = this.formatProviderName(baseProvider);
+                    const displayName = profile.customName || `${baseName} · ${profileIdentifier}`;
+                    providers.push({
+                        id: profileId, // Use the full profile ID for editing
+                        name: displayName,
+                        configured: true,
+                        mode,
+                        authType,
+                        maskedCredential,
+                        active: isActive,
+                        models: modelsByProvider.get(baseProvider) ?? [],
+                    });
+                }
+            }
+            // Sort so active provider comes first, then by name
+            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;
+    }
+    /** Detect whether a profile uses API key or subscription auth */
+    detectAuthType(profileId, profile) {
+        // If has OAuth tokens, it's subscription/oauth
+        if (profile.access || profile.refresh) {
+            return "subscription";
+        }
+        // Check profile ID for hints
+        const lowerProfileId = profileId.toLowerCase();
+        if (lowerProfileId.includes("-sub") || lowerProfileId.includes("sub-")) {
+            return "subscription";
+        }
+        // Check token format for Anthropic
+        if (profile.provider === "anthropic" && profile.token) {
+            // API keys: sk-ant-api03-...
+            // OAuth tokens: sk-ant-oat-...
+            // Setup tokens have different patterns
+            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";
+            }
+        }
+        // Check for OpenAI Codex (always subscription-based)
+        if (profile.provider === "openai-codex") {
+            return "subscription";
+        }
+        // Default to api-key
+        return "api-key";
+    }
+    /** Mask a credential for display */
+    maskCredential(credential) {
+        if (credential.length <= 12)
+            return "***";
+        return credential.slice(0, 7) + "..." + credential.slice(-4);
+    }
+    /** Format provider name for display */
+    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);
+    }
+    /** Refresh settings state from disk (call periodically to detect external changes) */
+    refreshSettingsState() {
+        this.writeSettingsState();
+        this.pushSettingsState();
+        // Also refresh sessions
+        this.listSessions();
+    }
+    /** List all active sessions with their current model */
+    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 = this.getActiveModel();
+            const globalModelId = globalDefault
+                ? `${globalDefault.provider}/${globalDefault.model}`
+                : null;
+            // Transform sessions for the UI
+            const sessions = rawSessions
+                .filter(s => s.kind === "direct") // Only show direct chat sessions
+                .map(s => {
+                // Combine modelProvider and model into full model ID
+                const sessionModel = s.modelProvider && s.model
+                    ? `${s.modelProvider}/${s.model}`
+                    : s.model || globalModelId;
+                const isOverride = sessionModel !== globalModelId;
+                return {
+                    key: s.key,
+                    label: this.formatSessionLabel(s.key, s.agentId, s.origin?.label, s.displayName),
+                    model: sessionModel,
+                    modelLabel: this.formatModelLabelFromId(sessionModel),
+                    isOverride,
+                    lastUpdated: s.updatedAt ? new Date(s.updatedAt).toISOString() : undefined,
+                };
+            })
+                .sort((a, b) => {
+                // Sort overrides first, then by last updated
+                if (a.isOverride && !b.isOverride)
+                    return -1;
+                if (!a.isOverride && b.isOverride)
+                    return 1;
+                return 0;
+            });
+            // Write to state
+            const statePath = resolve(this.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");
+            this.store.setState("sessions", state);
+        }
+        catch (err) {
+            console.warn(`[settings] Failed to list sessions: ${err}`);
+        }
+    }
+    /** Format a session key into a human-readable label */
+    formatSessionLabel(key, agentId, originLabel, displayName) {
+        // Use origin label if available (e.g., "Robin Spottiswoode (@robin_blocks)")
+        if (originLabel) {
+            // Extract just the name part before any ID/handle info
+            const namePart = originLabel.split(" (")[0].split(" @")[0].split(" id:")[0];
+            if (namePart && namePart.length > 0 && namePart.length < 30) {
+                return namePart;
+            }
+        }
+        // Use display name if available
+        if (displayName) {
+            return displayName;
+        }
+        // Fall back to parsing the key
+        const parts = key.split(":");
+        if (parts[0] === "agent") {
+            return agentId || parts[1] || key;
+        }
+        // Channel-based session
+        const channelNames = {
+            telegram: "Telegram",
+            discord: "Discord",
+            whatsapp: "WhatsApp",
+            signal: "Signal",
+            slack: "Slack",
+            irc: "IRC",
+        };
+        return channelNames[parts[0]] || parts[0];
+    }
+    /** Format a model ID into a human-readable label */
+    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;
+    }
+    /** Reset a session's model override to use the global default */
+    resetSessionModel(sessionKey) {
+        const globalDefault = this.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}`);
+        }
+        // Refresh session list
+        setTimeout(() => this.listSessions(), 1000);
+    }
+    /** Apply the global default model to all active sessions */
+    applyDefaultToAllSessions() {
+        const globalDefault = this.getActiveModel();
+        if (!globalDefault) {
+            console.warn(`[settings] No global default model configured`);
+            return;
+        }
+        const modelId = `${globalDefault.provider}/${globalDefault.model}`;
+        this.patchAllSessionModels(modelId);
+        // Refresh session list after a delay
+        setTimeout(() => this.listSessions(), 2000);
+    }
+    /** Write settings.json state with provider status */
+    writeSettingsState() {
+        const providers = this.getConfiguredProviders();
+        const isConfigured = providers.length > 0;
+        const activeModel = this.getActiveModel();
+        // Find the active provider
+        const activeProvider = providers.find((p) => p.active);
+        // Get sessions data to include in settings state
+        const sessionsData = this.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,
+                // Include sessions directly in settings state for component access
+                sessions: sessionsData,
+            },
+        };
+        const statePath = resolve(this.stateDir, "settings.json");
+        writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+    }
+    /** Get sessions data without writing to separate file */
+    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 = this.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: this.formatSessionLabel(s.key, s.agentId, s.origin?.label, s.displayName),
+                    model: sessionModel,
+                    modelLabel: this.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 };
+        }
+    }
+    /** Push settings state to in-memory store */
+    pushSettingsState() {
+        const statePath = resolve(this.stateDir, "settings.json");
+        const content = readFileSync(statePath, "utf-8");
+        this.store.setState("settings", JSON.parse(content));
+    }
+    /** Push _status state to in-memory store */
+    pushStatusState() {
+        const statePath = resolve(this.stateDir, "_status.json");
+        if (existsSync(statePath)) {
+            const content = readFileSync(statePath, "utf-8");
+            this.store.setState("_status", JSON.parse(content));
+        }
+    }
+}
+//# sourceMappingURL=settings-handler.js.map