@geminilight/mindos 0.6.61 → 0.6.65

package/app/lib/settings.ts

@@ -3,9 +3,13 @@ import path from 'path';
 import os from 'os';
 import { parseAcpAgentOverrides } from './acp/agent-descriptors';
 import { type ProviderId, PROVIDER_PRESETS, isProviderId, getApiKeyFromEnv } from './agent/providers';
+import { type Provider, parseProviders, findProvider, migrateProviders } from './custom-endpoints';
+// Backward compat re-exports for files still importing from settings
+export type { Provider };
 
 const SETTINGS_PATH = path.join(os.homedir(), '.mindos', 'config.json');
 
+/** @deprecated Use Provider from custom-endpoints.ts */
 export interface ProviderConfig {
   apiKey: string;
   model: string;
@@ -13,8 +17,8 @@ export interface ProviderConfig {
 }
 
 export interface AiConfig {
-  provider: ProviderId;
-  providers: Partial<Record<ProviderId, ProviderConfig>>;
+  activeProvider: string;    // provider entry ID (p_*)
+  providers: Provider[];     // unified provider list
 }
 
 export interface AgentConfig {
@@ -60,15 +64,13 @@ export interface ServerSettings {
   };
   /** User-defined agents not built into MindOS. */
   customAgents?: import('./custom-agents').CustomAgentDef[];
+  // customProviders is now merged into ai.providers — kept for migration only
 }
 
 const DEFAULTS: ServerSettings = {
   ai: {
-    provider: 'anthropic' as ProviderId,
-    providers: {
-      anthropic: { apiKey: '', model: 'claude-sonnet-4-6' },
-      openai:    { apiKey: '', model: 'gpt-5.4', baseUrl: '' },
-    },
+    activeProvider: '',
+    providers: [],
   },
   mindRoot: '',
 };
@@ -82,56 +84,27 @@ function str(obj: unknown, key: string, fallback: string): string {
   return fallback;
 }
 
-/** Parse a provider config from unknown input, filling missing/invalid fields with defaults */
-function parseProvider(raw: unknown, defaults: ProviderConfig): ProviderConfig {
-  return {
-    apiKey:   str(raw, 'apiKey',  defaults.apiKey),
-    model:    str(raw, 'model',   defaults.model),
-    ...(defaults.baseUrl !== undefined
-      ? { baseUrl: str(raw, 'baseUrl', defaults.baseUrl) }
-      : {}),
-  };
-}
-
 /** Migrate old flat ai structure to new providers dict, if needed */
 function migrateAi(parsed: Record<string, unknown>): AiConfig {
   const ai = parsed.ai as Record<string, unknown> | undefined;
   if (!ai) return { ...DEFAULTS.ai };
 
-  const providerField = typeof ai.provider === 'string' ? ai.provider : 'anthropic';
-  const provider: ProviderId = isProviderId(providerField) ? providerField : 'anthropic';
-
-  // Already new format — parse all known providers from disk
-  if (ai.providers && typeof ai.providers === 'object') {
-    const p = ai.providers as Record<string, unknown>;
-    const providers: Partial<Record<ProviderId, ProviderConfig>> = {};
-    for (const id of Object.keys(p)) {
-      if (!isProviderId(id)) continue;
-      const preset = PROVIDER_PRESETS[id];
-      const defaultCfg = DEFAULTS.ai.providers[id] ?? { apiKey: '', model: preset.defaultModel };
-      providers[id] = parseProvider(p[id], defaultCfg);
-    }
-    // Ensure at least anthropic and openai exist (backward compat)
-    if (!providers.anthropic) providers.anthropic = DEFAULTS.ai.providers.anthropic;
-    if (!providers.openai) providers.openai = DEFAULTS.ai.providers.openai;
-    return { provider, providers };
+  // ── New format: ai.providers is an array ──
+  if (Array.isArray(ai.providers)) {
+    const providers = parseProviders(ai.providers);
+    const activeProvider = typeof ai.activeProvider === 'string' ? ai.activeProvider : '';
+    return { activeProvider, providers };
   }
 
-  // Old flat format — migrate
-  return {
-    provider,
-    providers: {
-      anthropic: {
-        apiKey: str(ai, 'anthropicApiKey', ''),
-        model:  str(ai, 'anthropicModel',  'claude-sonnet-4-6'),
-      },
-      openai: {
-        apiKey:   str(ai, 'openaiApiKey',  ''),
-        model:    str(ai, 'openaiModel',   'gpt-5.4'),
-        baseUrl:  str(ai, 'openaiBaseUrl', ''),
-      },
-    },
-  };
+  // ── Old format: ai.providers is a dict (or missing) → auto-migrate ──
+  const migrated = migrateProviders(parsed);
+  if (migrated) {
+    return { activeProvider: migrated.activeProvider, providers: migrated.providers };
+  }
+
+  // Very old flat format (anthropicApiKey etc.) — also handled by migrateProviders
+  // but if it returns null, fall through to defaults
+  return { ...DEFAULTS.ai };
 }
 
 /** Parse agent config from unknown input */
@@ -195,7 +168,12 @@ export function readSettings(): ServerSettings {
   try {
     const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
     const parsed = JSON.parse(raw) as Record<string, unknown>;
-    return {
+
+    // Detect old format and check if migration is needed
+    const ai = parsed.ai as Record<string, unknown> | undefined;
+    const needsMigration = ai && !Array.isArray(ai.providers);
+
+    const settings: ServerSettings = {
       ai: migrateAi(parsed),
       agent: parseAgent(parsed.agent),
       acpAgents: parseAcpAgentsField(parsed.acpAgents),
@@ -220,11 +198,18 @@ export function readSettings(): ServerSettings {
       connectionMode: inferConnectionMode(parsed),
       customAgents: Array.isArray(parsed.customAgents) ? parsed.customAgents as import('./custom-agents').CustomAgentDef[] : undefined,
     };
+
+    // Auto-persist migrated config so migration only runs once
+    if (needsMigration) {
+      try { writeSettings(settings); } catch { /* best-effort */ }
+    }
+
+    return settings;
   } catch {
     // Config file missing or corrupt → force setup wizard
     return {
       ...DEFAULTS,
-      ai: { ...DEFAULTS.ai, providers: { ...DEFAULTS.ai.providers } },
+      ai: { ...DEFAULTS.ai, providers: [] },
       setupPending: true,
       connectionMode: { cli: true, mcp: false },
     };
@@ -250,6 +235,8 @@ export function writeSettings(settings: ServerSettings): void {
   if (settings.baseUrlCompat !== undefined) merged.baseUrlCompat = settings.baseUrlCompat;
   if (settings.connectionMode !== undefined) merged.connectionMode = settings.connectionMode;
   if (settings.customAgents !== undefined) merged.customAgents = settings.customAgents;
+  // Remove legacy customProviders (now merged into ai.providers array)
+  delete merged.customProviders;
   // setupPending: false/undefined → remove the field (cleanup); true → set it
   if ('setupPending' in settings) {
     if (settings.setupPending) merged.setupPending = true;
@@ -297,33 +284,42 @@ export function recordSkillInstall(agentKey: string, skillName: string, installP
 
 /** Effective AI config — unified interface for all providers.
  *  Resolves: saved config → env var → preset default, in that priority order.
- *  When `providerOverride` is given, resolves that provider's config instead. */
-export function effectiveAiConfig(providerOverride?: ProviderId): {
+ *  When `providerOverride` is given (a provider entry ID), resolves that provider's config. */
+export function effectiveAiConfig(providerOverride?: string): {
   provider: ProviderId;
   apiKey: string;
   model: string;
   baseUrl: string;
 } {
   const s = readSettings();
+
+  // Find the provider entry
+  const targetId = providerOverride || s.ai.activeProvider;
+  const entry = targetId ? findProvider(s.ai.providers, targetId) : undefined;
+
+  if (entry) {
+    // Resolve from the unified provider entry
+    const preset = PROVIDER_PRESETS[entry.protocol];
+    const apiKey = entry.apiKey
+      || getApiKeyFromEnv(entry.protocol)
+      || preset?.apiKeyFallback
+      || '';
+    const model = entry.model || preset?.defaultModel || '';
+    const baseUrl = entry.baseUrl || preset?.fixedBaseUrl || '';
+    return { provider: entry.protocol, apiKey, model, baseUrl };
+  }
+
+  // Fallback: no matching entry — try env var or default
   const envProvider = process.env.AI_PROVIDER;
-  const provider: ProviderId = providerOverride
-    ?? (isProviderId(s.ai.provider) ? s.ai.provider
-      : (envProvider && isProviderId(envProvider) ? envProvider : 'anthropic'));
-
-  const preset = PROVIDER_PRESETS[provider] ?? PROVIDER_PRESETS.anthropic;
-  const provCfg = s.ai.providers[provider] ?? { apiKey: '', model: '' };
-
-  const apiKey = provCfg.apiKey
-    || getApiKeyFromEnv(provider)
-    || preset.apiKeyFallback
-    || '';
-  const model = provCfg.model
-    || preset.defaultModel;
-  const baseUrl = provCfg.baseUrl
-    || preset.fixedBaseUrl
-    || '';
-
-  return { provider, apiKey, model, baseUrl };
+  const protocol: ProviderId = (envProvider && isProviderId(envProvider)) ? envProvider : 'anthropic';
+  const preset = PROVIDER_PRESETS[protocol] ?? PROVIDER_PRESETS.anthropic;
+
+  return {
+    provider: protocol,
+    apiKey: getApiKeyFromEnv(protocol) || preset.apiKeyFallback || '',
+    model: preset.defaultModel,
+    baseUrl: preset.fixedBaseUrl || '',
+  };
 }
 
 /** Effective MIND_ROOT — settings file can override, env var is fallback */

package/app/lib/types.ts

@@ -69,6 +69,10 @@ export interface Message {
   images?: ImagePart[];
   /** Skill name used for this user message (rendered as a capsule in the UI) */
   skillName?: string;
+  /** KB file paths (@mentions) sent with this message */
+  attachedFiles?: string[];
+  /** Names of uploaded files (PDFs etc.) sent with this message */
+  uploadedFileNames?: string[];
 }
 
 export interface LocalAttachment {

package/bin/lib/mcp-agents.js

@@ -256,6 +256,16 @@ export const MCP_AGENTS = {
     preferredTransport: 'stdio',
     presenceDirs: ['~/.lingma/'],
   },
+  'copaw': {
+    name: 'CoPaw',
+    project: null,
+    global: '~/.copaw/config.json',
+    key: 'mcp',
+    globalNestedKey: 'mcp.clients',
+    preferredTransport: 'stdio',
+    presenceCli: 'copaw',
+    presenceDirs: ['~/.copaw/'],
+  },
 };
 
 /**
@@ -286,6 +296,7 @@ export const SKILL_AGENT_REGISTRY = {
   'qclaw': { mode: 'unsupported' },
   'workbuddy': { mode: 'unsupported' },
   'lingma': { mode: 'unsupported' },
+  'copaw': { mode: 'unsupported' },
 };
 
 export function detectAgentPresence(agentKey) {

package/bin/lib/mcp-install.js

@@ -7,6 +7,37 @@ import { parseJsonc } from './jsonc.js';
 import { MCP_AGENTS, SKILL_AGENT_REGISTRY, detectAgentPresence } from './mcp-agents.js';
 import { mergeTomlEntry } from './toml.js';
 
+/**
+ * Walk a dot-separated path inside an object, creating intermediate {} as needed.
+ * Returns the leaf object so the caller can set keys on it.
+ * e.g. ensureNestedPath({}, 'mcp.clients') → creates obj.mcp.clients = {} and returns it.
+ */
+function ensureNestedPath(obj, dotPath) {
+  const parts = dotPath.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (!current[part] || typeof current[part] !== 'object') {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+/**
+ * Read-only walk of a dot-separated path. Returns null if any segment is missing.
+ */
+function readNestedPath(obj, dotPath) {
+  const parts = dotPath.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (!current || typeof current !== 'object') return null;
+    current = current[part];
+  }
+  if (!current || typeof current !== 'object') return null;
+  return current;
+}
+
 /**
  * Recursively copy a directory using pure Node.js (cross-platform).
  * Uses cpSync on Node >=16.7, falls back to manual walk otherwise.
@@ -24,9 +55,28 @@ function copyDirSync(src, dst) {
   }
 }
 
+/**
+ * Determine active skill variant based on user's locale setting.
+ * Respects disabledSkills to detect if user prefers Chinese (mindos-zh).
+ */
+function getActiveSkillName() {
+  try {
+    const content = readFileSync(CONFIG_PATH, 'utf-8');
+    const config = parseJsonc(content);
+    // If 'mindos' is disabled, user prefers Chinese (mindos-zh)
+    if (config.disabledSkills?.includes('mindos')) {
+      return 'mindos-zh';
+    }
+  } catch {
+    // Fall back to English if settings can't be read
+  }
+  return 'mindos';
+}
+
 /**
  * Auto-copy skill folder for agents with mode 'unsupported'.
  * Called after MCP config is written. Best-effort, never throws.
+ * Respects user's locale setting (English mindos / Chinese mindos-zh).
  */
 function autoInstallSkillForAgent(agentKey, skillName) {
   const reg = SKILL_AGENT_REGISTRY[agentKey];
@@ -253,7 +303,14 @@ export async function mcpInstall() {
               installed = content.includes(`[${agent.key}.mindos]`);
             } else {
               const config = parseJsonc(content);
-              if (config[agent.key]?.mindos) installed = true;
+              // For agents with globalNestedKey (e.g. CoPaw: mcp.clients),
+              // check the nested path for mindos entry
+              if (agent.globalNestedKey) {
+                const nested = readNestedPath(config, agent.globalNestedKey);
+                if (nested?.mindos) installed = true;
+              } else {
+                if (config[agent.key]?.mindos) installed = true;
+              }
             }
             if (installed) break;
           } catch {}
@@ -391,18 +448,25 @@ export async function mcpInstall() {
           continue;
         }
       }
-      if (!config[agent.key]) config[agent.key] = {};
-      existed = !!config[agent.key].mindos;
-      config[agent.key].mindos = entry;
+
+      // For global scope with nested key (e.g. CoPaw: mcp.clients),
+      // write to the nested path instead of the flat key
+      const useNestedKey = isGlobal && agent.globalNestedKey;
+      const container = useNestedKey
+        ? ensureNestedPath(config, agent.globalNestedKey)
+        : (() => { if (!config[agent.key]) config[agent.key] = {}; return config[agent.key]; })();
+      existed = !!container.mindos;
+      container.mindos = entry;
       writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
     }
 
     console.log(`${green('✔')} ${existed ? 'Updated' : 'Installed'} MindOS MCP for ${bold(agent.name)} ${dim(`→ ${absPath}`)}`);
 
-    // Auto-copy skill for unsupported agents
-    const skillResult = autoInstallSkillForAgent(agentKey, 'mindos');
+    // Auto-copy skill for unsupported agents, respecting user's locale setting
+    const activeSkill = getActiveSkillName();
+    const skillResult = autoInstallSkillForAgent(agentKey, activeSkill);
     if (skillResult === 'copied') {
-      console.log(`${green('✔')} Copied MindOS Skill for ${bold(agent.name)}`);
+      console.log(`${green('✔')} Copied MindOS Skill (${activeSkill}) for ${bold(agent.name)}`);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.6.61",
+  "version": "0.6.65",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",