@desktalk/miniapp-preference 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeskTalk contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/backend.d.ts

@@ -0,0 +1,12 @@
+import type { MiniAppManifest, MiniAppContext, MiniAppBackendActivation } from '@desktalk/sdk';
+export declare const manifest: MiniAppManifest;
+/**
+ * The Preference MiniApp uses ctx.storage as the persistence layer for settings.
+ * In production, the core would provide a privileged ctx.config hook that writes
+ * to <config>/config.toml. For now, ctx.storage serves as the backing store.
+ *
+ * All settings are stored under the key "config" as a flat Config object.
+ */
+export declare function activate(ctx: MiniAppContext): MiniAppBackendActivation;
+export declare function deactivate(): void;
+//# sourceMappingURL=backend.d.ts.map

package/dist/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../src/backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAmB/F,eAAO,MAAM,QAAQ,EAAE,eAMtB,CAAC;AAIF;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,wBAAwB,CAiTtE;AAID,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}

package/dist/backend.js

@@ -0,0 +1,622 @@
+// src/schema.ts
+var DEFAULT_AI_PROVIDER_ID = "openai";
+var AI_PROVIDER_DEFINITIONS = [
+  { id: "anthropic", label: "Anthropic", supportsApiKey: true, supportsBaseUrl: false },
+  {
+    id: "azure-openai-responses",
+    label: "Azure OpenAI",
+    supportsApiKey: true,
+    supportsBaseUrl: true
+  },
+  { id: DEFAULT_AI_PROVIDER_ID, label: "OpenAI", supportsApiKey: true, supportsBaseUrl: true },
+  { id: "google", label: "Google Gemini", supportsApiKey: true, supportsBaseUrl: false },
+  {
+    id: "mistral",
+    label: "Mistral",
+    supportsApiKey: true,
+    supportsBaseUrl: true
+  },
+  { id: "groq", label: "Groq", supportsApiKey: true, supportsBaseUrl: true },
+  {
+    id: "cerebras",
+    label: "Cerebras",
+    supportsApiKey: true,
+    supportsBaseUrl: true
+  },
+  { id: "xai", label: "xAI", supportsApiKey: true, supportsBaseUrl: true },
+  {
+    id: "openrouter",
+    label: "OpenRouter",
+    supportsApiKey: true,
+    supportsBaseUrl: true
+  },
+  {
+    id: "vercel-ai-gateway",
+    label: "Vercel AI Gateway",
+    supportsApiKey: true,
+    supportsBaseUrl: true
+  },
+  { id: "zai", label: "ZAI", supportsApiKey: true, supportsBaseUrl: false },
+  { id: "opencode", label: "OpenCode Zen", supportsApiKey: true, supportsBaseUrl: false },
+  { id: "opencode-go", label: "OpenCode Go", supportsApiKey: true, supportsBaseUrl: false },
+  {
+    id: "huggingface",
+    label: "Hugging Face",
+    supportsApiKey: true,
+    supportsBaseUrl: true
+  },
+  {
+    id: "kimi-coding",
+    label: "Kimi For Coding",
+    supportsApiKey: true,
+    supportsBaseUrl: false
+  },
+  { id: "minimax", label: "MiniMax", supportsApiKey: true, supportsBaseUrl: false },
+  {
+    id: "minimax-cn",
+    label: "MiniMax China",
+    supportsApiKey: true,
+    supportsBaseUrl: false
+  },
+  { id: "ollama", label: "Ollama", supportsApiKey: false, supportsBaseUrl: true }
+];
+var DEFAULT_VOICE_PROVIDER_ID = "openai-whisper";
+var VOICE_PROVIDER_DEFINITIONS = [
+  {
+    id: DEFAULT_VOICE_PROVIDER_ID,
+    label: "OpenAI Whisper",
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    supportsModel: true,
+    supportsAzureDeployment: false,
+    supportsAzureApiVersion: false
+  },
+  {
+    id: "azure-openai-whisper",
+    label: "Azure OpenAI Whisper",
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    supportsModel: false,
+    supportsAzureDeployment: true,
+    supportsAzureApiVersion: true
+  }
+];
+var AI_PROVIDER_IDS = new Set(AI_PROVIDER_DEFINITIONS.map((provider) => provider.id));
+var VOICE_PROVIDER_IDS = new Set(VOICE_PROVIDER_DEFINITIONS.map((provider) => provider.id));
+function getAiProviderDefinition(providerId) {
+  return AI_PROVIDER_DEFINITIONS.find((provider) => provider.id === providerId);
+}
+function getAiProviderConfigKeys(providerId) {
+  const definition = getAiProviderDefinition(providerId);
+  if (!definition) {
+    return [];
+  }
+  const keys = [`ai.providers.${providerId}.model`];
+  if (definition.supportsApiKey) {
+    keys.push(`ai.providers.${providerId}.apiKey`);
+  }
+  if (definition.supportsBaseUrl) {
+    keys.push(`ai.providers.${providerId}.baseUrl`);
+  }
+  return keys;
+}
+function parseAiEnabledProviders(value) {
+  if (typeof value !== "string") {
+    return [DEFAULT_AI_PROVIDER_ID];
+  }
+  const providers = value.split(",").map((item) => item.trim()).filter(
+    (item, index, items) => item && items.indexOf(item) === index && AI_PROVIDER_IDS.has(item)
+  );
+  return providers.length > 0 ? providers : [DEFAULT_AI_PROVIDER_ID];
+}
+function serializeAiEnabledProviders(providerIds) {
+  return parseAiEnabledProviders(providerIds.join(",")).join(",");
+}
+function hasAiProviderConfig(config, providerId) {
+  return getAiProviderConfigKeys(providerId).some((key) => {
+    const value = config[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+function getVoiceProviderDefinition(providerId) {
+  return VOICE_PROVIDER_DEFINITIONS.find((provider) => provider.id === providerId);
+}
+function getVoiceProviderConfigKeys(providerId) {
+  const definition = getVoiceProviderDefinition(providerId);
+  if (!definition) {
+    return [];
+  }
+  const keys = [];
+  if (definition.supportsApiKey) {
+    keys.push(`voice.providers.${providerId}.apiKey`);
+  }
+  if (definition.supportsModel) {
+    keys.push(`voice.providers.${providerId}.model`);
+  }
+  if (definition.supportsBaseUrl) {
+    keys.push(`voice.providers.${providerId}.baseUrl`);
+  }
+  if (definition.supportsAzureDeployment) {
+    keys.push(`voice.providers.${providerId}.azureDeployment`);
+  }
+  if (definition.supportsAzureApiVersion) {
+    keys.push(`voice.providers.${providerId}.azureApiVersion`);
+  }
+  return keys;
+}
+function parseVoiceEnabledProviders(value) {
+  if (typeof value !== "string") {
+    return [DEFAULT_VOICE_PROVIDER_ID];
+  }
+  const providers = value.split(",").map((item) => item.trim()).filter(
+    (item, index, items) => item && items.indexOf(item) === index && VOICE_PROVIDER_IDS.has(item)
+  );
+  return providers.length > 0 ? providers : [DEFAULT_VOICE_PROVIDER_ID];
+}
+function serializeVoiceEnabledProviders(providerIds) {
+  return parseVoiceEnabledProviders(providerIds.join(",")).join(",");
+}
+function hasVoiceProviderConfig(config, providerId) {
+  return getVoiceProviderConfigKeys(providerId).some((key) => {
+    const value = config[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+function getAiProviderPreferenceSchemas() {
+  const schemas = [
+    {
+      key: "ai.enabledProviders",
+      label: "Enabled Providers",
+      description: "Ordered list of configured AI providers.",
+      type: "string",
+      default: DEFAULT_AI_PROVIDER_ID,
+      category: "AI"
+    },
+    {
+      key: "ai.defaultProvider",
+      label: "Default Provider",
+      description: "Provider selected by default for chat and tool execution.",
+      type: "string",
+      default: DEFAULT_AI_PROVIDER_ID,
+      options: AI_PROVIDER_DEFINITIONS.map((provider) => provider.id),
+      category: "AI"
+    }
+  ];
+  for (const provider of AI_PROVIDER_DEFINITIONS) {
+    schemas.push({
+      key: `ai.providers.${provider.id}.model`,
+      label: `${provider.label} Model`,
+      description: `Model identifier to use when ${provider.label} is selected.`,
+      type: "string",
+      default: "",
+      category: "AI"
+    });
+    if (provider.supportsApiKey) {
+      schemas.push({
+        key: `ai.providers.${provider.id}.apiKey`,
+        label: `${provider.label} API Key`,
+        description: `API key for ${provider.label}.`,
+        type: "string",
+        default: "",
+        category: "AI",
+        sensitive: true
+      });
+    }
+    if (provider.supportsBaseUrl) {
+      schemas.push({
+        key: `ai.providers.${provider.id}.baseUrl`,
+        label: `${provider.label} Base URL`,
+        description: `Optional custom API base URL for ${provider.label}.`,
+        type: "string",
+        default: "",
+        category: "AI"
+      });
+    }
+  }
+  schemas.push({
+    key: "ai.maxTokens",
+    label: "Max Tokens",
+    description: "Maximum tokens per AI response.",
+    type: "number",
+    default: 4096,
+    min: 256,
+    max: 128e3,
+    category: "AI"
+  });
+  return schemas;
+}
+var AI_PREFERENCE_SCHEMAS = getAiProviderPreferenceSchemas();
+function getVoiceProviderPreferenceSchemas() {
+  const schemas = [
+    {
+      key: "voice.enabledProviders",
+      label: "Enabled Providers",
+      description: "Ordered list of configured STT providers.",
+      type: "string",
+      default: DEFAULT_VOICE_PROVIDER_ID,
+      category: "Voice"
+    },
+    {
+      key: "voice.defaultProvider",
+      label: "Default Provider",
+      description: "Provider selected by default for voice transcription.",
+      type: "string",
+      default: DEFAULT_VOICE_PROVIDER_ID,
+      options: VOICE_PROVIDER_DEFINITIONS.map((provider) => provider.id),
+      category: "Voice"
+    }
+  ];
+  for (const provider of VOICE_PROVIDER_DEFINITIONS) {
+    if (provider.supportsApiKey) {
+      schemas.push({
+        key: `voice.providers.${provider.id}.apiKey`,
+        label: `${provider.label} API Key`,
+        description: `API key for ${provider.label}.`,
+        type: "string",
+        default: "",
+        category: "Voice",
+        sensitive: true
+      });
+    }
+    if (provider.supportsModel) {
+      schemas.push({
+        key: `voice.providers.${provider.id}.model`,
+        label: `${provider.label} Model`,
+        description: `Model identifier to use when ${provider.label} is selected.`,
+        type: "string",
+        default: "whisper-1",
+        category: "Voice"
+      });
+    }
+    if (provider.supportsBaseUrl) {
+      schemas.push({
+        key: `voice.providers.${provider.id}.baseUrl`,
+        label: `${provider.label} Base URL`,
+        description: provider.id === "azure-openai-whisper" ? "Base URL for Azure OpenAI Whisper requests." : `Optional custom API base URL for ${provider.label}.`,
+        type: "string",
+        default: provider.id === DEFAULT_VOICE_PROVIDER_ID ? "https://api.openai.com/v1" : "",
+        category: "Voice"
+      });
+    }
+    if (provider.supportsAzureDeployment) {
+      schemas.push({
+        key: `voice.providers.${provider.id}.azureDeployment`,
+        label: `${provider.label} Deployment`,
+        description: "Azure OpenAI deployment name for Whisper transcription.",
+        type: "string",
+        default: "",
+        category: "Voice"
+      });
+    }
+    if (provider.supportsAzureApiVersion) {
+      schemas.push({
+        key: `voice.providers.${provider.id}.azureApiVersion`,
+        label: `${provider.label} API Version`,
+        description: "Azure OpenAI API version used for transcription requests.",
+        type: "string",
+        default: "2024-06-01",
+        category: "Voice"
+      });
+    }
+  }
+  return schemas;
+}
+var VOICE_PREFERENCE_SCHEMAS = getVoiceProviderPreferenceSchemas();
+var PREFERENCE_SCHEMAS = [
+  // ─── General ─────────────────────────────────────────────────────────────
+  {
+    key: "general.theme",
+    label: "Theme",
+    description: "UI theme: light or dark.",
+    type: "string",
+    default: "light",
+    options: ["light", "dark"],
+    category: "General"
+  },
+  {
+    key: "general.accentColor",
+    label: "Accent Color",
+    description: "Primary theme color. Accepts hex values or any CSS color string.",
+    type: "string",
+    default: "#7c6ff7",
+    category: "General"
+  },
+  {
+    key: "general.language",
+    label: "Language",
+    description: "UI language/locale.",
+    type: "string",
+    default: "en",
+    options: ["en", "zh", "ja", "ko", "es", "fr", "de"],
+    category: "General"
+  },
+  {
+    key: "general.dataDirectory",
+    label: "Data Directory",
+    description: "Override the base data directory. Leave empty for platform default (resolved via env-paths).",
+    type: "string",
+    default: "",
+    category: "General",
+    requiresRestart: true
+  },
+  // ─── Server ──────────────────────────────────────────────────────────────
+  {
+    key: "server.host",
+    label: "Host",
+    description: "Server bind address.",
+    type: "string",
+    default: "localhost",
+    category: "Server",
+    requiresRestart: true
+  },
+  {
+    key: "server.port",
+    label: "Port",
+    description: "Server listen port.",
+    type: "number",
+    default: 3e3,
+    min: 1,
+    max: 65535,
+    category: "Server",
+    requiresRestart: true
+  },
+  // ─── AI ──────────────────────────────────────────────────────────────────
+  ...AI_PREFERENCE_SCHEMAS,
+  // ─── Voice ────────────────────────────────────────────────────────────
+  ...VOICE_PREFERENCE_SCHEMAS,
+  {
+    key: "voice.silenceTimeoutMs",
+    label: "Silence Timeout",
+    description: "Silence duration (ms) before finalizing an utterance.",
+    type: "number",
+    default: 800,
+    min: 200,
+    max: 5e3,
+    category: "Voice"
+  },
+  {
+    key: "voice.energyThreshold",
+    label: "Energy Threshold",
+    description: "RMS energy threshold for voice activity detection (0\u201332767).",
+    type: "number",
+    default: 500,
+    min: 50,
+    max: 1e4,
+    category: "Voice"
+  }
+];
+function getDefaultConfig() {
+  const config = {};
+  for (const schema of PREFERENCE_SCHEMAS) {
+    config[schema.key] = schema.default;
+  }
+  return config;
+}
+function getSchema(key) {
+  return PREFERENCE_SCHEMAS.find((s) => s.key === key);
+}
+function maskSensitive(value) {
+  if (value.length <= 4) return "****";
+  return "*".repeat(value.length - 4) + value.slice(-4);
+}
+
+// src/backend.ts
+var manifest = {
+  id: "preference",
+  name: "Preferences",
+  icon: "\u2699\uFE0F",
+  version: "0.1.0",
+  description: "Application settings and configuration"
+};
+function activate(ctx) {
+  ctx.logger.info("Preference MiniApp activated");
+  const defaults = getDefaultConfig();
+  async function loadConfig() {
+    const stored = await ctx.storage.get("config");
+    const config = { ...defaults, ...stored ?? {} };
+    const legacyProvider = typeof stored?.["ai.provider"] === "string" ? stored["ai.provider"] : void 0;
+    if (legacyProvider && typeof stored?.["ai.defaultProvider"] !== "string") {
+      config["ai.defaultProvider"] = legacyProvider;
+    }
+    if (legacyProvider) {
+      const legacyModel = typeof stored?.["ai.model"] === "string" ? stored["ai.model"] : void 0;
+      const legacyApiKey = typeof stored?.["ai.apiKey"] === "string" ? stored["ai.apiKey"] : void 0;
+      const legacyBaseUrl = typeof stored?.["ai.baseUrl"] === "string" ? stored["ai.baseUrl"] : void 0;
+      const providerModelKey = `ai.providers.${legacyProvider}.model`;
+      const providerApiKeyKey = `ai.providers.${legacyProvider}.apiKey`;
+      const providerBaseUrlKey = `ai.providers.${legacyProvider}.baseUrl`;
+      if (legacyModel && !config[providerModelKey]) {
+        config[providerModelKey] = legacyModel;
+      }
+      if (legacyApiKey && !config[providerApiKeyKey]) {
+        config[providerApiKeyKey] = legacyApiKey;
+      }
+      if (legacyBaseUrl && !config[providerBaseUrlKey]) {
+        config[providerBaseUrlKey] = legacyBaseUrl;
+      }
+    }
+    const enabledProviders = parseAiEnabledProviders(stored?.["ai.enabledProviders"]);
+    const derivedProviders = enabledProviders.filter(
+      (providerId) => hasAiProviderConfig(config, providerId)
+    );
+    for (const schema of PREFERENCE_SCHEMAS) {
+      if (!schema.key.startsWith("ai.providers.")) {
+        continue;
+      }
+      const match = /^ai\.providers\.([^.]+)\./.exec(schema.key);
+      const providerId = match?.[1];
+      if (providerId && hasAiProviderConfig(config, providerId) && !derivedProviders.includes(providerId)) {
+        derivedProviders.push(providerId);
+      }
+    }
+    const defaultProvider = typeof config["ai.defaultProvider"] === "string" && config["ai.defaultProvider"] ? String(config["ai.defaultProvider"]) : DEFAULT_AI_PROVIDER_ID;
+    if (!derivedProviders.includes(defaultProvider)) {
+      derivedProviders.unshift(defaultProvider);
+    }
+    for (const providerId of enabledProviders) {
+      if (!derivedProviders.includes(providerId)) {
+        derivedProviders.push(providerId);
+      }
+    }
+    config["ai.enabledProviders"] = serializeAiEnabledProviders(derivedProviders);
+    config["ai.defaultProvider"] = derivedProviders[0] ?? DEFAULT_AI_PROVIDER_ID;
+    const legacyVoiceProvider = typeof stored?.["voice.provider"] === "string" ? stored["voice.provider"] : void 0;
+    if (legacyVoiceProvider && typeof stored?.["voice.defaultProvider"] !== "string") {
+      config["voice.defaultProvider"] = legacyVoiceProvider;
+    }
+    if (legacyVoiceProvider) {
+      const legacyVoiceApiKey = typeof stored?.["voice.apiKey"] === "string" ? stored["voice.apiKey"] : void 0;
+      const legacyVoiceModel = typeof stored?.["voice.model"] === "string" ? stored["voice.model"] : void 0;
+      const legacyVoiceBaseUrl = typeof stored?.["voice.baseUrl"] === "string" ? stored["voice.baseUrl"] : void 0;
+      const legacyVoiceDeployment = typeof stored?.["voice.azureDeployment"] === "string" ? stored["voice.azureDeployment"] : void 0;
+      const legacyVoiceApiVersion = typeof stored?.["voice.azureApiVersion"] === "string" ? stored["voice.azureApiVersion"] : void 0;
+      if (legacyVoiceApiKey && !config[`voice.providers.${legacyVoiceProvider}.apiKey`]) {
+        config[`voice.providers.${legacyVoiceProvider}.apiKey`] = legacyVoiceApiKey;
+      }
+      if (legacyVoiceModel && !config[`voice.providers.${legacyVoiceProvider}.model`]) {
+        config[`voice.providers.${legacyVoiceProvider}.model`] = legacyVoiceModel;
+      }
+      if (legacyVoiceBaseUrl && !config[`voice.providers.${legacyVoiceProvider}.baseUrl`]) {
+        config[`voice.providers.${legacyVoiceProvider}.baseUrl`] = legacyVoiceBaseUrl;
+      }
+      if (legacyVoiceDeployment && !config[`voice.providers.${legacyVoiceProvider}.azureDeployment`]) {
+        config[`voice.providers.${legacyVoiceProvider}.azureDeployment`] = legacyVoiceDeployment;
+      }
+      if (legacyVoiceApiVersion && !config[`voice.providers.${legacyVoiceProvider}.azureApiVersion`]) {
+        config[`voice.providers.${legacyVoiceProvider}.azureApiVersion`] = legacyVoiceApiVersion;
+      }
+    }
+    const enabledVoiceProviders = parseVoiceEnabledProviders(stored?.["voice.enabledProviders"]);
+    const derivedVoiceProviders = enabledVoiceProviders.filter(
+      (providerId) => hasVoiceProviderConfig(config, providerId)
+    );
+    for (const schema of PREFERENCE_SCHEMAS) {
+      if (!schema.key.startsWith("voice.providers.")) {
+        continue;
+      }
+      const match = /^voice\.providers\.([^.]+)\./.exec(schema.key);
+      const providerId = match?.[1];
+      if (providerId && hasVoiceProviderConfig(config, providerId) && !derivedVoiceProviders.includes(providerId)) {
+        derivedVoiceProviders.push(providerId);
+      }
+    }
+    const defaultVoiceProvider = typeof config["voice.defaultProvider"] === "string" && config["voice.defaultProvider"] ? String(config["voice.defaultProvider"]) : DEFAULT_VOICE_PROVIDER_ID;
+    if (!derivedVoiceProviders.includes(defaultVoiceProvider)) {
+      derivedVoiceProviders.unshift(defaultVoiceProvider);
+    }
+    for (const providerId of enabledVoiceProviders) {
+      if (!derivedVoiceProviders.includes(providerId)) {
+        derivedVoiceProviders.push(providerId);
+      }
+    }
+    config["voice.enabledProviders"] = serializeVoiceEnabledProviders(derivedVoiceProviders);
+    config["voice.defaultProvider"] = derivedVoiceProviders[0] ?? DEFAULT_VOICE_PROVIDER_ID;
+    return config;
+  }
+  async function saveConfig(config) {
+    await ctx.storage.set("config", config);
+  }
+  function maskConfig(config) {
+    const masked = { ...config };
+    for (const schema of PREFERENCE_SCHEMAS) {
+      if (schema.sensitive && typeof masked[schema.key] === "string") {
+        const raw = masked[schema.key];
+        masked[schema.key] = raw ? maskSensitive(raw) : "";
+      }
+    }
+    return masked;
+  }
+  ctx.messaging.onCommand("preferences.getAll", async () => {
+    const config = await loadConfig();
+    return maskConfig(config);
+  });
+  ctx.messaging.onCommand(
+    "preferences.get",
+    async (req) => {
+      const config = await loadConfig();
+      const schema = getSchema(req.key);
+      let value = config[req.key] ?? defaults[req.key];
+      if (value === void 0) {
+        throw new Error(`Unknown preference key: ${req.key}`);
+      }
+      if (schema?.sensitive && typeof value === "string" && value) {
+        value = maskSensitive(value);
+      }
+      return { value };
+    }
+  );
+  ctx.messaging.onCommand(
+    "preferences.getRaw",
+    async (req) => {
+      const config = await loadConfig();
+      const value = config[req.key] ?? defaults[req.key];
+      if (value === void 0) {
+        throw new Error(`Unknown preference key: ${req.key}`);
+      }
+      return { value };
+    }
+  );
+  ctx.messaging.onCommand(
+    "preferences.set",
+    async (req) => {
+      const schema = getSchema(req.key);
+      if (!schema) {
+        throw new Error(`Unknown preference key: ${req.key}`);
+      }
+      if (typeof req.value !== schema.type) {
+        throw new Error(`Expected ${schema.type} for ${req.key}, got ${typeof req.value}`);
+      }
+      if (schema.type === "number" && typeof req.value === "number") {
+        if (schema.min !== void 0 && req.value < schema.min) {
+          throw new Error(`${req.key} must be >= ${schema.min}`);
+        }
+        if (schema.max !== void 0 && req.value > schema.max) {
+          throw new Error(`${req.key} must be <= ${schema.max}`);
+        }
+      }
+      if (schema.options && typeof req.value === "string") {
+        if (!schema.options.includes(req.value)) {
+          throw new Error(`${req.key} must be one of: ${schema.options.join(", ")}`);
+        }
+      }
+      const config = await loadConfig();
+      config[req.key] = req.value;
+      await saveConfig(config);
+      ctx.logger.info(`Setting updated: ${req.key}`);
+      ctx.messaging.emit("preferences:changed", {
+        key: req.key,
+        value: schema.sensitive ? maskSensitive(String(req.value)) : req.value,
+        requiresRestart: schema.requiresRestart ?? false
+      });
+    }
+  );
+  ctx.messaging.onCommand("preferences.reset", async (req) => {
+    const schema = getSchema(req.key);
+    if (!schema) {
+      throw new Error(`Unknown preference key: ${req.key}`);
+    }
+    const config = await loadConfig();
+    config[req.key] = schema.default;
+    await saveConfig(config);
+    ctx.logger.info(`Setting reset: ${req.key}`);
+    ctx.messaging.emit("preferences:changed", {
+      key: req.key,
+      value: schema.default,
+      requiresRestart: schema.requiresRestart ?? false
+    });
+  });
+  ctx.messaging.onCommand("preferences.resetAll", async () => {
+    await saveConfig({ ...defaults });
+    ctx.logger.info("All settings reset to defaults");
+    ctx.messaging.emit("preferences:resetAll", {});
+  });
+  return {};
+}
+function deactivate() {
+}
+export {
+  activate,
+  deactivate,
+  manifest
+};
+//# sourceMappingURL=backend.js.map