mixdog 0.7.1

package/setup/config-merge.mjs

@@ -0,0 +1,254 @@
+/**
+ * Setup UI config merge helpers (importable without starting setup-server).
+ */
+import { applyDefaults as applyChannelsDefaults } from '../src/channels/lib/config.mjs';
+import {
+  SECRET_ACCOUNTS,
+  saveSecret,
+  deleteSecret,
+  hasStoredSecret,
+  getDiscordToken,
+  getWebhookAuthtoken,
+  getSearchApiKey,
+  getAgentApiKey,
+  diagnoseDiscordTokenValue,
+} from '../src/shared/config.mjs';
+
+const SUPPORTED_PROVIDERS = [
+  'anthropic-oauth', 'openai-oauth', 'openai-api', 'gemini-api', 'xai-api', 'grok-oauth',
+  'tavily', 'firecrawl', 'exa',
+];
+
+const AGENT_PROVIDER_ENV = Object.freeze({
+  openai: 'OPENAI_API_KEY',
+  anthropic: 'ANTHROPIC_API_KEY',
+  gemini: 'GEMINI_API_KEY',
+  deepseek: 'DEEPSEEK_API_KEY',
+  xai: 'XAI_API_KEY',
+  nvidia: 'NVIDIA_API_KEY',
+});
+
+function envSecretPresent(account) {
+  const key = 'MIXDOG_' + String(account || '').replace(/[.\s]+/g, '_').toUpperCase();
+  if (process.env[key]) return true;
+  const agentMatch = String(account || '').match(/^agent\.([^.]+)\.apiKey$/);
+  if (agentMatch) {
+    const std = AGENT_PROVIDER_ENV[agentMatch[1]];
+    if (std && process.env[std]) return true;
+  }
+  return false;
+}
+
+function getSecretByAccount(account) {
+  if (account === SECRET_ACCOUNTS.discordToken) return getDiscordToken();
+  if (account === SECRET_ACCOUNTS.webhookAuth) return getWebhookAuthtoken();
+  const searchMatch = String(account || '').match(/^search\.([^.]+)\.apiKey$/);
+  if (searchMatch) return getSearchApiKey(searchMatch[1]);
+  const agentMatch = String(account || '').match(/^agent\.([^.]+)\.apiKey$/);
+  if (agentMatch) return getAgentApiKey(agentMatch[1]);
+  return null;
+}
+
+function keychainSecretPresent(account) {
+  if (hasStoredSecret(account)) return true;
+  if (envSecretPresent(account)) return false;
+  return !!getSecretByAccount(account);
+}
+
+function saveSecretChecked(account, rawValue, label) {
+  const value = typeof rawValue === 'string' ? rawValue.trim() : '';
+  if (!value) {
+    return { attempted: false, stored: keychainSecretPresent(account), env: envSecretPresent(account), inputLength: 0 };
+  }
+  saveSecret(account, value);
+  const stored = keychainSecretPresent(account);
+  if (!stored && !envSecretPresent(account)) {
+    throw new Error(`${label}: keychain write completed but secret is not readable`);
+  }
+  return { attempted: true, stored, env: envSecretPresent(account), inputLength: value.length };
+}
+
+function deleteSecretIfCurrentValue(account, value) {
+  if (!value) return false;
+  try {
+    if (getSecretByAccount(account) !== value) return false;
+    deleteSecret(account);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function saveDiscordTokenChecked(rawValue, config) {
+  const value = typeof rawValue === 'string' ? rawValue.trim() : '';
+  if (!value) {
+    return { attempted: false, stored: keychainSecretPresent(SECRET_ACCOUNTS.discordToken), env: envSecretPresent(SECRET_ACCOUNTS.discordToken), inputLength: 0 };
+  }
+  const problem = diagnoseDiscordTokenValue(value, config || {});
+  if (problem) {
+    const removed = deleteSecretIfCurrentValue(SECRET_ACCOUNTS.discordToken, value);
+    throw new Error(`channels.discord.token: ${problem}${removed ? ' Removed the invalid saved value.' : ''}`);
+  }
+  return saveSecretChecked(SECRET_ACCOUNTS.discordToken, value, 'channels.discord.token');
+}
+
+// Shallow merge that preserves keys the incoming payload omits. BOTH sides are
+// normalized to plain objects first so a stray array/string (on either side)
+// can never spread into numeric keys (e.g. ['x'] -> {0:'x'}).
+const plainObject = (o) => (o && typeof o === 'object' && !Array.isArray(o)) ? o : {};
+export const mergeKept = (existing, incoming) => ({ ...plainObject(existing), ...plainObject(incoming) });
+
+/** schedules/<name>/config.json — partial UI/skill saves must keep unmanaged keys (cron, timezone, secret, …). */
+export function mergeEndpointConfig(existing, incoming) {
+  return mergeKept(existing, incoming);
+}
+
+/** webhooks/<name>/config.json — merge then pin dispatch role invariant. */
+export function mergeWebhookEndpointConfig(existing, incoming) {
+  const merged = mergeEndpointConfig(existing, incoming);
+  merged.role = 'webhook-handler';
+  return merged;
+}
+
+export function mergeAgentConfig(existing, data, secretReport = {}) {
+  // Shallow copy of existing preserves unmanaged top-level keys; providers
+  // deep-merge per-key (partial save must not wipe other providers).
+  const config = { ...existing };
+  config.providers = { ...(config.providers || {}) };
+  if (data.providers) {
+    for (const [name, val] of Object.entries(data.providers)) {
+      if (!val || typeof val !== 'object') continue;
+      config.providers[name] = { ...(config.providers[name] || {}) };
+      for (const [k, v] of Object.entries(val)) {
+        if (v === undefined) continue;
+        if (k === 'apiKey') {
+          secretReport[`agent.${name}.apiKey`] = saveSecretChecked(SECRET_ACCOUNTS.agentApiKey(name), v, `agent.${name}.apiKey`);
+          continue;
+        }
+        config.providers[name][k] = v;
+      }
+    }
+  }
+  if (data.bridge && typeof data.bridge === 'object') {
+    config.bridge = { ...(config.bridge || {}), ...data.bridge };
+  }
+  return config;
+}
+
+export function mergeMemoryConfig(existing, incoming, secretReport = {}) {
+  // Field-wise partial updates + deep-merge providers (same preserve rules as agent).
+  const config = { ...existing };
+  if (incoming.enabled !== undefined) config.enabled = incoming.enabled;
+  if (incoming.cycle1) {
+    if (!config.cycle1) config.cycle1 = {};
+    if (incoming.cycle1.interval !== undefined) config.cycle1.interval = incoming.cycle1.interval;
+    if (incoming.cycle1.timeout !== undefined) config.cycle1.timeout = incoming.cycle1.timeout;
+    if (incoming.cycle1.batchSize !== undefined) config.cycle1.batchSize = incoming.cycle1.batchSize;
+  }
+  if (incoming.cycle2) {
+    if (!config.cycle2) config.cycle2 = {};
+    if (incoming.cycle2.interval !== undefined) config.cycle2.interval = incoming.cycle2.interval;
+  }
+  if (incoming.user) {
+    if (!config.user) config.user = { name: '', title: '' };
+    if (incoming.user.name !== undefined) config.user.name = incoming.user.name;
+    if (incoming.user.title !== undefined) config.user.title = incoming.user.title;
+  }
+  if (incoming.providers) {
+    config.providers = { ...(config.providers || {}) };
+    for (const [name, val] of Object.entries(incoming.providers)) {
+      if (!val || typeof val !== 'object') continue;
+      config.providers[name] = { ...(config.providers[name] || {}) };
+      for (const [k, v] of Object.entries(val)) {
+        if (v === undefined) continue;
+        if (k === 'apiKey') {
+          secretReport[`memory.${name}.apiKey`] = saveSecretChecked(SECRET_ACCOUNTS.agentApiKey(name), v, `memory.${name}.apiKey`);
+          continue;
+        }
+        config.providers[name][k] = v;
+      }
+    }
+  }
+  return config;
+}
+
+export function mergeSearchConfig(existing, data, secretReport = {}) {
+  // Partial field updates; models shallow-merge; modelOptions replaces per-family
+  // entries intentionally so the UI can clear a family's overrides.
+  const config = { ...existing };
+  if (!config.rawSearch) config.rawSearch = {};
+  if (!config.rawSearch.credentials) config.rawSearch.credentials = {};
+  if (data.provider !== undefined && SUPPORTED_PROVIDERS.includes(data.provider)) {
+    config.provider = data.provider;
+  }
+  if (data.maxResults !== undefined) config.rawSearch.maxResults = data.maxResults;
+  if (data.requestTimeoutMs !== undefined) config.requestTimeoutMs = data.requestTimeoutMs;
+  if (data.crawl !== undefined) config.crawl = data.crawl;
+  if (data.models !== undefined && typeof data.models === 'object') {
+    config.models = { ...(config.models || {}), ...data.models };
+  }
+  if (data.modelOptions !== undefined && typeof data.modelOptions === 'object') {
+    config.modelOptions = { ...(config.modelOptions || {}) };
+    for (const [fam, opts] of Object.entries(data.modelOptions)) {
+      if (opts && typeof opts === 'object' && Object.keys(opts).length > 0) {
+        config.modelOptions[fam] = { ...opts };
+      } else {
+        delete config.modelOptions[fam];
+      }
+    }
+  }
+  for (const [id, key] of Object.entries(data.searchProviders || {})) {
+    if (!config.rawSearch.credentials[id]) config.rawSearch.credentials[id] = {};
+    secretReport[`search.${id}.apiKey`] = saveSecretChecked(SECRET_ACCOUNTS.searchApiKey(id), key, `search.${id}.apiKey`);
+    delete config.rawSearch.credentials[id].apiKey;
+  }
+  return config;
+}
+
+export function mergeConfig(existing, data, secretReport = {}) {
+  const config = { ...existing };
+
+  config.backend = 'discord';
+
+  if (data.discord) {
+    config.discord = { ...config.discord };
+    if (Object.prototype.hasOwnProperty.call(data.discord, 'token')) {
+      const tokenConfig = {
+        ...config,
+        discord: { ...(config.discord || {}), ...data.discord },
+        channelsConfig: data.channelsConfig || config.channelsConfig,
+        mainChannel: data.mainChannel || config.mainChannel,
+      };
+      secretReport['channels.discord.token'] = saveDiscordTokenChecked(data.discord.token, tokenConfig);
+      delete config.discord.token;
+    }
+    if (data.discord.applicationId) config.discord.applicationId = data.discord.applicationId;
+  }
+
+  if (data.channelsConfig && Object.keys(data.channelsConfig).length > 0) {
+    // Intentional full replace: deleting a channel in the UI must remove its row;
+    // shallow merge would leave stale channel entries on disk.
+    config.channelsConfig = data.channelsConfig;
+  }
+  if (data.mainChannel) config.mainChannel = data.mainChannel;
+  if (data.access) config.access = mergeKept(config.access, data.access);
+  if (data.voice) config.voice = mergeKept(config.voice, data.voice);
+  if (data.schedules) config.schedules = mergeKept(config.schedules, data.schedules);
+  if (data.webhook) {
+    const { authtoken, ...webhookRest } = data.webhook;
+    if (Object.prototype.hasOwnProperty.call(data.webhook, 'authtoken')) {
+      secretReport['channels.webhook.authtoken'] = saveSecretChecked(SECRET_ACCOUNTS.webhookAuth, authtoken, 'channels.webhook.authtoken');
+    }
+    // Strip any plaintext authtoken from the on-disk webhook BEFORE merging so
+    // the secret is never re-persisted to config JSON (keychain-only invariant
+    // that the prior full-replace path enforced implicitly).
+    const { authtoken: _existingAuth, ...existingWebhook } = config.webhook || {};
+    config.webhook = mergeKept(existingWebhook, webhookRest);
+  }
+  if (data.quiet) {
+    config.quiet = applyChannelsDefaults({ ...config, quiet: mergeKept(config.quiet, data.quiet) }).quiet;
+  }
+
+  return config;
+}
+

package/setup/install.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// install.mjs — one-shot bootstrapper that registers the mixdog plugin in the
+// user's Claude Code settings so it auto-loads on the next session start.
+//
+// Run via:  npx -p mixdog mixdog-install   (after the package is published)
+//       or:  node setup/install.mjs          (from a checkout)
+//
+// It merges two keys into the user-scope settings file (preserving everything
+// else that is already there):
+//   extraKnownMarketplaces["trib-plugin"] -> the GitHub marketplace source
+//   enabledPlugins["mixdog@trib-plugin"]  -> true
+//
+// After it runs, the user restarts Claude Code (or runs /reload-plugins) and
+// mixdog is already present — there is no separate /plugin install step.
+
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
+
+const MARKETPLACE = 'trib-plugin';        // must match .claude-plugin/marketplace.json "name"
+const PLUGIN_REF = 'mixdog@trib-plugin';  // <plugin name>@<marketplace name>
+const REPO = 'trib-plugin/mixdog';        // github owner/repo
+const REPO_URL = 'https://github.com/trib-plugin/mixdog';
+
+// Claude Code honours CLAUDE_CONFIG_DIR; otherwise the user scope is ~/.claude.
+function settingsDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+}
+
+function loadSettings(file) {
+  if (!existsSync(file)) return {};
+  const raw = readFileSync(file, 'utf8');
+  if (raw.trim() === '') return {};
+  // Invariant: never clobber a file we cannot parse — let the caller abort.
+  return JSON.parse(raw);
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function main() {
+  const dir = settingsDir();
+  const file = join(dir, 'settings.json');
+
+  let settings;
+  try {
+    settings = loadSettings(file);
+  } catch (err) {
+    console.error(`\n✗ ${file} is not valid JSON — refusing to overwrite it.`);
+    console.error(`  Fix or remove the file, then re-run. (${err.message})`);
+    process.exit(1);
+  }
+  if (!isPlainObject(settings)) {
+    console.error(`\n✗ ${file} does not contain a JSON object — refusing to overwrite it.`);
+    process.exit(1);
+  }
+
+  // Merge marketplace + enable flag without touching any other keys.
+  if (!isPlainObject(settings.extraKnownMarketplaces)) settings.extraKnownMarketplaces = {};
+  settings.extraKnownMarketplaces[MARKETPLACE] = {
+    source: { source: 'github', repo: REPO },
+  };
+  if (!isPlainObject(settings.enabledPlugins)) settings.enabledPlugins = {};
+  const already = settings.enabledPlugins[PLUGIN_REF] === true;
+  settings.enabledPlugins[PLUGIN_REF] = true;
+
+  // Back up an existing file before the first write; create the dir otherwise.
+  if (existsSync(file)) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const bak = `${file}.bak-${stamp}`;
+    copyFileSync(file, bak);
+    console.log(`• Backed up existing settings → ${bak}`);
+  } else {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
+  console.log(`✓ Registered mixdog in ${file}`);
+  console.log(`  - marketplace "${MARKETPLACE}" → github:${REPO}`);
+  console.log(`  - enabled plugin "${PLUGIN_REF}"${already ? ' (was already enabled)' : ''}`);
+  console.log(`\nNext: restart Claude Code (or run /reload-plugins). mixdog loads automatically.`);
+
+  maybeStarNudge();
+}
+
+// Non-blocking, opt-in star nudge. Only on a real interactive terminal — never
+// in CI or piped/non-TTY installs, so it can never break an automated setup.
+function maybeStarNudge() {
+  if (!process.stdin.isTTY || process.env.CI) return;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  rl.question('\n⭐ Found this useful? Star the repo on GitHub? (Y/n) ', (answer) => {
+    const a = answer.trim().toLowerCase();
+    if (a === '' || a === 'y' || a === 'yes') openRepo();
+    else console.log(`No problem — you can star it anytime at ${REPO_URL}`);
+    rl.close();
+  });
+}
+
+function openRepo() {
+  const platform = process.platform;
+  const cmd = platform === 'win32' ? 'cmd' : platform === 'darwin' ? 'open' : 'xdg-open';
+  const args = platform === 'win32' ? ['/c', 'start', '', REPO_URL] : [REPO_URL];
+  try {
+    spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+    console.log('Opening the repo in your browser — thank you! 🙏');
+  } catch {
+    console.log(`Please visit ${REPO_URL} to star. Thank you! 🙏`);
+  }
+}
+
+main();