mixdog 0.7.2 → 0.7.4

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Claude Code all-in-one agent plugin — autonomous agents, continuous memory, cost-aware sub-agents, and syntax-aware code editing.",
   "hooks": "./hooks/hooks.json",
   "mcpServers": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Claude Code all-in-one bridge plugin: role-based bridge workers, continuous memory, and syntax-aware code editing.",
   "author": "mixdog contributors <dev@tribgames.com>",
   "license": "MIT",

package/setup/install.mjs

@@ -24,9 +24,10 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
 import { spawn } from 'node:child_process';
+import { DEFAULT_MARKETPLACE, DEFAULT_PLUGIN } from '../src/shared/plugin-paths.mjs';
 
-const MARKETPLACE = 'trib-plugin';        // must match .claude-plugin/marketplace.json "name"
-const PLUGIN_REF = 'mixdog@trib-plugin';  // <plugin name>@<marketplace name>
+const MARKETPLACE = DEFAULT_MARKETPLACE;
+const PLUGIN_REF = `${DEFAULT_PLUGIN}@${DEFAULT_MARKETPLACE}`;
 const REPO = 'trib-plugin/mixdog';        // github owner/repo
 const REPO_URL = 'https://github.com/trib-plugin/mixdog';
 
@@ -47,7 +48,7 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function main() {
+function registerPluginInSettings() {
   const dir = settingsDir();
   const file = join(dir, 'settings.json');
 
@@ -88,6 +89,22 @@ function main() {
   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.`);
+}
+
+async function main() {
+  registerPluginInSettings();
+
+  // npx / node setup/install.mjs runs outside Claude Code — config.mjs needs a data dir.
+  process.env.CLAUDE_PLUGIN_DATA = join(
+    homedir(),
+    '.claude',
+    'plugins',
+    'data',
+    'mixdog-trib-plugin',
+  );
+
+  const { runSetupWizard } = await import('./wizard.mjs');
+  await runSetupWizard();
 
   maybeStarNudge();
 }
@@ -97,9 +114,9 @@ function main() {
 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) => {
+  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();
+    if (a === 'y' || a === 'yes') openRepo();
     else console.log(`No problem — you can star it anytime at ${REPO_URL}`);
     rl.close();
   });
@@ -117,4 +134,7 @@ function openRepo() {
   }
 }
 
-main();
+main().catch((err) => {
+  console.error(err?.stack || err?.message || String(err));
+  process.exit(1);
+});

package/setup/wizard.mjs

@@ -0,0 +1,418 @@
+/**
+ * Interactive terminal setup wizard for `npx mixdog` / mixdog-install.
+ * Runs after plugin registration when stdin is a TTY and CI is unset.
+ *
+ * Callers must set process.env.CLAUDE_PLUGIN_DATA before importing this
+ * module (install.mjs does that) so src/shared/config.mjs can resolve paths.
+ */
+import { createInterface } from 'node:readline';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  mergeAgentConfig,
+  mergeMemoryConfig,
+  mergeConfig,
+} from './config-merge.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '..');
+const DEFAULT_USER_WORKFLOW = JSON.parse(
+  readFileSync(join(REPO_ROOT, 'defaults', 'user-workflow.json'), 'utf8'),
+);
+
+const AG_API_PROVIDERS = [
+  { id: 'openai', name: 'OpenAI', env: 'OPENAI_API_KEY' },
+  { id: 'anthropic', name: 'Anthropic', env: 'ANTHROPIC_API_KEY' },
+  { id: 'gemini', name: 'Gemini', env: 'GEMINI_API_KEY' },
+  { id: 'deepseek', name: 'DeepSeek', env: 'DEEPSEEK_API_KEY' },
+  { id: 'xai', name: 'xAI', env: 'XAI_API_KEY' },
+  { id: 'nvidia', name: 'NVIDIA', env: 'NVIDIA_API_KEY' },
+];
+
+const WORKFLOW_ROLES = ['worker', 'reviewer', 'debugger', 'tester'];
+
+function pluginDataDir() {
+  const dir = process.env.CLAUDE_PLUGIN_DATA;
+  if (!dir || typeof dir !== 'string' || !String(dir).trim()) {
+    throw new Error(
+      'CLAUDE_PLUGIN_DATA must be set before running the setup wizard (install.mjs sets it unconditionally)',
+    );
+  }
+  return String(dir).trim();
+}
+
+function sanitizeName(n) {
+  if (!n || typeof n !== 'string') return null;
+  if (n !== basename(n)) return null;
+  if (n.includes('..') || n.startsWith('.')) return null;
+  return n;
+}
+
+function isSkippableAnswer(raw) {
+  return raw === undefined || raw === null || String(raw).trim() === '';
+}
+
+function defaultIo() {
+  const interactive = !!(process.stdin.isTTY && !process.env.CI);
+  if (!interactive) {
+    return {
+      interactive: false,
+      ask: async () => '',
+      askSecret: async () => '',
+      say: (line) => { if (line) console.log(line); },
+    };
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (prompt) => new Promise((resolve) => {
+    rl.question(prompt, (answer) => resolve(answer));
+  });
+  const askSecret = (prompt) => readHiddenLine(prompt).finally(() => {
+    rl.resume();
+  });
+  return {
+    interactive: true,
+    ask,
+    askSecret,
+    say: (line) => { if (line) console.log(line); },
+    close: () => rl.close(),
+  };
+}
+
+function readHiddenLine(prompt) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      resolve('');
+      return;
+    }
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    process.stdout.write(prompt);
+    let value = '';
+    const onData = (chunk) => {
+      const s = chunk.toString('utf8');
+      for (const ch of s) {
+        if (ch === '\n' || ch === '\r' || ch === '\u0004') {
+          stdin.removeListener('data', onData);
+          stdin.setRawMode(wasRaw);
+          process.stdout.write('\n');
+          resolve(value);
+          return;
+        }
+        if (ch === '\u0003') {
+          stdin.removeListener('data', onData);
+          stdin.setRawMode(wasRaw);
+          reject(new Error('cancelled'));
+          return;
+        }
+        if (ch === '\u007f' || ch === '\b') {
+          value = value.slice(0, -1);
+          continue;
+        }
+        value += ch;
+      }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+async function loadConfigModules() {
+  const { ensureDataSeeds } = await import('../src/shared/seed.mjs');
+  const { readSection, updateSection } = await import('../src/shared/config.mjs');
+  const { DEFAULT_PRESETS } = await import('../src/agent/orchestrator/config.mjs');
+  const dataDir = pluginDataDir();
+  mkdirSync(dataDir, { recursive: true });
+  ensureDataSeeds(dataDir);
+  return { readSection, updateSection, DEFAULT_PRESETS, dataDir };
+}
+
+function readUserWorkflow(dataDir) {
+  const path = join(dataDir, 'user-workflow.json');
+  if (!existsSync(path)) return structuredClone(DEFAULT_USER_WORKFLOW);
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new SyntaxError('user-workflow root must be a JSON object');
+    }
+    return parsed;
+  } catch (parseErr) {
+    const corrupt = `${path}.corrupt-${Date.now()}`;
+    try {
+      if (existsSync(path)) renameSync(path, corrupt);
+    } catch {}
+    process.stderr.write(
+      `[wizard] user-workflow.json is malformed (${parseErr.message}). Renamed to ${corrupt}. Fix or delete before re-running setup.\n`,
+    );
+    throw new Error(
+      `[wizard] user-workflow.json is malformed (${parseErr.message}); refusing role mapping that would overwrite user data`,
+    );
+  }
+}
+
+function writeUserWorkflow(dataDir, data) {
+  const path = join(dataDir, 'user-workflow.json');
+  const roles = Array.isArray(data?.roles) ? data.roles.slice() : [];
+  if (!roles.some((r) => r?.name === 'worker')) {
+    const seedWorker = DEFAULT_USER_WORKFLOW.roles.find((r) => r?.name === 'worker');
+    if (seedWorker) roles.unshift({ ...seedWorker });
+  }
+  const sanitizedRoles = roles.map((r) => {
+    if (!r || typeof r !== 'object') return r;
+    const name = sanitizeName(r.name);
+    if (name == null) throw new Error(`invalid role name: ${r.name}`);
+    return { ...r, name };
+  });
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ ...data, roles: sanitizedRoles }, null, 2) + '\n', 'utf8');
+  renameSync(tmp, path);
+}
+
+function presetIdsFromAgent(agentSection) {
+  const presets = Array.isArray(agentSection?.presets) ? agentSection.presets : [];
+  return presets.map((p) => p.id || p.name).filter(Boolean);
+}
+
+async function stepDiscordToken(io, { updateSection }) {
+  io.say('\n── Step 2/7: Discord bot token ──');
+  io.say('Paste your Discord bot token (hidden). Enter to skip.');
+  const token = (await io.askSecret('Discord bot token: ')).trim();
+  if (isSkippableAnswer(token)) {
+    io.say('• Skipped Discord token.');
+    return false;
+  }
+  const secrets = {};
+  updateSection('channels', (current) => mergeConfig(current, { discord: { token } }, secrets));
+  io.say('• Discord token saved to keychain.');
+  return true;
+}
+
+function formatVoiceProgress(p) {
+  const phase = p?.phase || 'download';
+  const downloaded = Number(p?.downloaded) || 0;
+  const total = Number(p?.total) || 0;
+  if (total > 0) {
+    const pct = Math.floor((downloaded / total) * 100);
+    const mb = (n) => `${(n / (1024 * 1024)).toFixed(1)} MB`;
+    return `${phase} · ${mb(downloaded)} / ${mb(total)} (${pct}%)`;
+  }
+  const mb = (downloaded / (1024 * 1024)).toFixed(1);
+  return `${phase} · received ${mb} MB`;
+}
+
+async function installVoiceRuntime(dataDir, io) {
+  const {
+    ensureWhisperRuntime,
+    ensureWhisperModel,
+    ensureFfmpegRuntime,
+  } = await import('../src/channels/lib/voice-runtime-fetcher.mjs');
+  const onProgress = (p) => {
+    const line = formatVoiceProgress(p);
+    if (line) io.say(`  ${line}`);
+  };
+  await ensureWhisperRuntime(dataDir, onProgress);
+  const model = await ensureWhisperModel(dataDir, onProgress);
+  await ensureFfmpegRuntime(dataDir, onProgress);
+  return model?.modelId || 'large-v3-turbo';
+}
+
+/** Mirrors setup.html channels save: `voice` via POST /config → mergeConfig. */
+async function stepVoiceTranscription(io, ctx, discordTokenSaved) {
+  if (!discordTokenSaved) return;
+  io.say('\n── Step 2a/7: Voice transcription (음성 전사) ──');
+  io.say('Install local Speech-to-text (whisper.cpp) for Discord voice messages.');
+  const raw = await io.ask('Enable voice transcription? [y/N] (Enter=skip): ');
+  if (isSkippableAnswer(raw)) {
+    io.say('• Skipped voice transcription.');
+    return;
+  }
+  const a = String(raw).trim().toLowerCase();
+  if (a !== 'y' && a !== 'yes') {
+    io.say('• Skipped voice transcription.');
+    return;
+  }
+  const { updateSection, dataDir } = ctx;
+  try {
+    io.say('• Downloading voice runtime (this may take a while)…');
+    const modelId = await installVoiceRuntime(dataDir, io);
+    const voice = { language: 'auto', model: modelId };
+    updateSection('channels', (current) => mergeConfig(current, { voice }, {}));
+    io.say('• Voice transcription runtime installed and channels voice config saved.');
+  } catch (err) {
+    io.say(`• Voice install failed: ${err?.message || err}`);
+    throw err;
+  }
+}
+
+async function stepAddressForm(io, { updateSection, readSection }) {
+  io.say('\n── Step 1/7: Address form (호칭) ──');
+  const memory = readSection('memory');
+  const curTitle = memory?.user?.title || '';
+  const curName = memory?.user?.name || '';
+  const titleRaw = await io.ask(`How should Mixdog address you? user.title [${curTitle}]: `);
+  const nameRaw = await io.ask(`Your display name? user.name [${curName}]: `);
+  const title = isSkippableAnswer(titleRaw) ? '' : String(titleRaw).trim();
+  const name = isSkippableAnswer(nameRaw) ? '' : String(nameRaw).trim();
+  if (!title && !name) {
+    io.say('• Skipped address form.');
+    return;
+  }
+  const user = {};
+  if (title) user.title = title;
+  if (name) user.name = name;
+  const secrets = {};
+  updateSection('memory', (current) => mergeMemoryConfig(current, { user }, secrets));
+  io.say('• Saved memory.user (title/name).');
+}
+
+export async function stepWebhookReceiver(io, { updateSection, readSection }) {
+  io.say('\n── Step 3/7: Inbound webhooks (ngrok receiver) ──');
+  io.say('Global webhook tunnel for inbound HTTP (channels.webhook). Per-endpoint registration is configured later in the UI.');
+  const enableRaw = await io.ask('Enable inbound webhooks? [y/N]: ');
+  if (isSkippableAnswer(enableRaw)) {
+    io.say('• Skipped webhook setup.');
+    return;
+  }
+  const enable = String(enableRaw).trim().toLowerCase();
+  if (enable !== 'y' && enable !== 'yes') {
+    io.say('• Skipped webhook setup.');
+    return;
+  }
+  const { hasStoredSecret, SECRET_ACCOUNTS } = await import('../src/shared/config.mjs');
+  const channels = readSection('channels') || {};
+  const curWebhook = channels.webhook && typeof channels.webhook === 'object' ? channels.webhook : {};
+  const curDomain = String(curWebhook.domain || curWebhook.ngrokDomain || '').trim();
+  const domainBase =
+    'Domain (ngrok, e.g. your-name.ngrok-free.dev — get it at dashboard.ngrok.com/domains)';
+  const domainPrompt = curDomain
+    ? `${domainBase} (current: ${curDomain}, Enter=keep): `
+    : `${domainBase}: `;
+  const domainRaw = await io.ask(domainPrompt);
+  const webhook = { enabled: true };
+  if (!isSkippableAnswer(domainRaw)) {
+    webhook.domain = String(domainRaw).trim();
+  }
+  const authPrompt = hasStoredSecret(SECRET_ACCOUNTS.webhookAuth)
+    ? 'Auth Token (stored, Enter=keep): '
+    : 'ngrok Auth Token [hidden]: ';
+  webhook.authtoken = (await io.askSecret(authPrompt)).trim();
+  const secrets = {};
+  updateSection('channels', (current) => mergeConfig(current, { webhook }, secrets));
+  io.say('• Inbound webhook receiver saved (channels.webhook enabled/domain; authtoken in keychain).');
+}
+
+async function stepProviderKeys(io, { updateSection }) {
+  io.say('\n── Step 4/7: Provider API keys ──');
+  io.say('Optional API keys (hidden). Enter to skip a provider.');
+  const providers = {};
+  for (const p of AG_API_PROVIDERS) {
+    const key = (await io.askSecret(`${p.name} API key (${p.env}, Enter=skip): `)).trim();
+    if (!isSkippableAnswer(key)) {
+      providers[p.id] = { apiKey: key, enabled: true };
+    }
+  }
+  if (Object.keys(providers).length === 0) {
+    io.say('• Skipped provider keys.');
+    return;
+  }
+  const secrets = {};
+  updateSection('agent', (current) => mergeAgentConfig(current, { providers }, secrets));
+  io.say(`• Saved ${Object.keys(providers).length} provider key(s) to keychain.`);
+}
+
+async function stepPresets(io, { readSection, updateSection, DEFAULT_PRESETS }) {
+  io.say('\n── Step 5/7: Agent presets ──');
+  const agent = readSection('agent');
+  const existing = presetIdsFromAgent(agent);
+  if (existing.length > 0) {
+    io.say(`Current presets: ${existing.join(', ')}`);
+  }
+  const raw = await io.ask('Install default Mixdog presets? [y/N] (Enter=skip): ');
+  if (isSkippableAnswer(raw)) {
+    io.say('• Kept existing presets.');
+    return;
+  }
+  const a = String(raw).trim().toLowerCase();
+  if (a !== 'y' && a !== 'yes') {
+    io.say('• Kept existing presets.');
+    return;
+  }
+  const list = DEFAULT_PRESETS.map((p) => ({ ...p }));
+  updateSection('agent', (current) => {
+    const next = { ...current, presets: list };
+    const validKeys = list.map((p) => p.id).filter(Boolean);
+    if (!next.default || !validKeys.includes(next.default)) next.default = validKeys[0] || null;
+    return next;
+  });
+  io.say(`• Installed ${list.length} default presets.`);
+}
+
+async function stepRolePresetMapping(io, { readSection, dataDir }) {
+  io.say('\n── Step 6/7: Role → preset mapping ──');
+  const agent = readSection('agent');
+  const presetIds = presetIdsFromAgent(agent);
+  if (presetIds.length === 0) {
+    io.say('No presets on disk — run step 4 first or configure presets in the Mixdog UI later.');
+    return;
+  }
+  io.say(`Available presets: ${presetIds.join(', ')}`);
+  const wf = readUserWorkflow(dataDir);
+  const roles = Array.isArray(wf.roles) ? wf.roles : [];
+  const byName = new Map(roles.map((r) => [r.name, r]));
+  for (const roleName of WORKFLOW_ROLES) {
+    const cur = byName.get(roleName)?.preset || DEFAULT_USER_WORKFLOW.roles.find((r) => r.name === roleName)?.preset || '';
+    const raw = await io.ask(`Preset for role "${roleName}" [${cur}]: `);
+    if (isSkippableAnswer(raw)) continue;
+    const preset = String(raw).trim();
+    if (!presetIds.includes(preset)) {
+      io.say(`  ! Unknown preset "${preset}" — left "${roleName}" unchanged.`);
+      continue;
+    }
+    const entry = byName.get(roleName) || { name: roleName, permission: 'full' };
+    entry.preset = preset;
+    byName.set(roleName, entry);
+  }
+  const mergedRoles = WORKFLOW_ROLES.map((name) => byName.get(name)).filter(Boolean);
+  for (const r of roles) {
+    if (!WORKFLOW_ROLES.includes(r.name) && !mergedRoles.some((x) => x.name === r.name)) {
+      mergedRoles.push(r);
+    }
+  }
+  writeUserWorkflow(dataDir, { ...wf, roles: mergedRoles });
+  io.say('• Role → preset mapping saved to user-workflow.json.');
+}
+
+/**
+ * @param {object} [ioOverride]
+ * @param {boolean} [ioOverride.interactive]
+ * @param {(prompt:string)=>Promise<string>} [ioOverride.ask]
+ * @param {(prompt:string)=>Promise<string>} [ioOverride.askSecret]
+ * @param {(line:string)=>void} [ioOverride.say]
+ */
+export async function runSetupWizard(ioOverride = null) {
+  const io = ioOverride ? { ...defaultIo(), ...ioOverride } : defaultIo();
+  if (!io.interactive) return { skipped: true };
+
+  io.say('\nMixdog setup wizard — configure before opening Claude Code.');
+  io.say('Press Enter on any step to skip it.\n');
+
+  const ctx = await loadConfigModules();
+  try {
+    await stepAddressForm(io, ctx);
+    const discordSaved = await stepDiscordToken(io, ctx);
+    await stepVoiceTranscription(io, ctx, discordSaved);
+    await stepWebhookReceiver(io, ctx);
+    await stepProviderKeys(io, ctx);
+    await stepPresets(io, ctx);
+    await stepRolePresetMapping(io, ctx);
+    io.say('\n✓ Wizard complete. Restart Claude Code (or /reload-plugins) to load mixdog.');
+  } catch (err) {
+    io.say(`\n✗ Wizard error: ${err?.message || err}`);
+    throw err;
+  } finally {
+    if (typeof io.close === 'function') io.close();
+  }
+  return { skipped: false };
+}