@useconductor/conductor 1.0.0

package/src/cli/commands/lifecycle.ts

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Conductor } from '../../core/conductor.js';
+
+// ESM equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function registerLifecycleCommands(program: Command, conductor: Conductor): void {
+  program
+    .command('version')
+    .description('Show Conductor version')
+    .action(async () => {
+      try {
+        // Walk up from dist/cli/commands/ to find package.json
+        const packagePath = path.resolve(__dirname, '..', '..', '..', 'package.json');
+        const pkg = JSON.parse(await fs.readFile(packagePath, 'utf-8'));
+        console.log(`Conductor v${pkg.version}`);
+      } catch {
+        console.log('Conductor (version unknown)');
+      }
+    });
+
+  program
+    .command('status')
+    .description('Show Conductor status')
+    .action(async () => {
+      await conductor.initialize();
+
+      const config = conductor.getConfig();
+      const user = config.get<any>('user');
+      const ai = config.get<any>('ai');
+      const telegram = config.get<any>('telegram');
+      const plugins = config.get<string[]>('plugins.enabled') || [];
+
+      console.log('═══ Conductor Status ═══\n');
+      console.log(`User: ${user?.name || 'not configured'}`);
+      console.log(`AI Provider: ${ai?.provider || 'none'}`);
+      console.log(`AI Model: ${ai?.model || 'default'}`);
+      console.log(`Telegram: ${telegram?.enabled ? '✅ enabled' : '❌ disabled'}`);
+      console.log(`Plugins: ${plugins.length > 0 ? plugins.join(', ') : 'none'}`);
+    });
+
+  program
+    .command('reset')
+    .description('Reset Conductor configuration')
+    .option('--confirm', 'Skip confirmation prompt')
+    .action(async (opts) => {
+      if (!opts.confirm) {
+        const { default: inquirer } = await import('inquirer');
+        const { proceed } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'proceed',
+            message: 'This will reset all Conductor configuration. Are you sure?',
+            default: false,
+          },
+        ]);
+        if (!proceed) {
+          console.log('Cancelled.');
+          return;
+        }
+      }
+
+      const configDir = conductor.getConfig().getConfigDir();
+      await fs.rm(configDir, { recursive: true, force: true });
+      console.log('Conductor has been reset. Run the installer again to set up.');
+    });
+
+  program
+    .command('logs')
+    .description('Show recent activity logs')
+    .option('-n, --count <number>', 'Number of entries', '20')
+    .action(async (opts) => {
+      await conductor.initialize();
+
+      const count = parseInt(opts.count, 10);
+      const activities = await conductor.getRecentActivity(count);
+
+      if (activities.length === 0) {
+        console.log('No activity logged yet.');
+        return;
+      }
+
+      for (const entry of activities) {
+        const time = new Date(entry.timestamp).toLocaleString();
+        console.log(`[${time}] ${entry.user_id ?? 'system'}: ${entry.action}`);
+        if (entry.details) {
+          console.log(`  ${entry.details}`);
+        }
+      }
+    });
+}

package/src/cli/commands/marketplace.ts

@@ -0,0 +1,253 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { Conductor } from '../../core/conductor.js';
+
+const REGISTRY_URLS = [
+  'https://raw.githubusercontent.com/thegreatalxx/conductor-plugins/main/registry.json',
+  'https://conductor.thealxlabs.ca/registry.json',
+];
+const GITHUB_RAW = 'https://raw.githubusercontent.com';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+interface RegistryPlugin {
+  id: string;
+  name: string;
+  description: string;
+  longDescription: string;
+  category: string;
+  author: string;
+  version: string;
+  repo: string;
+  path: string;
+  asset: string;
+  credentials: { service: string; key: string; label: string; setup: string }[];
+  tools: string[];
+  tags: string[];
+  icon: string;
+}
+
+interface Registry {
+  version: string;
+  plugins: RegistryPlugin[];
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+async function fetchRegistry(): Promise<Registry> {
+  let lastError: Error | undefined;
+  for (const url of REGISTRY_URLS) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+      if (res.ok) return res.json() as Promise<Registry>;
+      lastError = new Error(`Registry at ${url} returned ${res.status}`);
+    } catch (e) {
+      lastError = e as Error;
+    }
+  }
+  throw new Error(`Cannot reach plugin registry. Check your internet connection.\n${lastError?.message ?? ''}`);
+}
+
+function pluginsDir(conductor: Conductor): string {
+  return path.join(conductor.getConfig().getConfigDir(), 'plugins');
+}
+
+function dim(s: string) {
+  return `\x1b[2m${s}\x1b[0m`;
+}
+function green(s: string) {
+  return `\x1b[32m${s}\x1b[0m`;
+}
+function red(s: string) {
+  return `\x1b[31m${s}\x1b[0m`;
+}
+function cyan(s: string) {
+  return `\x1b[36m${s}\x1b[0m`;
+}
+function bold(s: string) {
+  return `\x1b[1m${s}\x1b[0m`;
+}
+function yellow(s: string) {
+  return `\x1b[33m${s}\x1b[0m`;
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+/** conductor install <plugin> */
+export async function installPlugin(conductor: Conductor, pluginId: string): Promise<void> {
+  console.log('');
+  console.log(`  ${cyan('▶')} Fetching registry…`);
+
+  const registry = await fetchRegistry();
+  const plugin = registry.plugins.find((p) => p.id === pluginId);
+
+  if (!plugin) {
+    const ids = registry.plugins.map((p) => p.id).join(', ');
+    console.error(`  ${red('✗')} Plugin "${pluginId}" not found in registry.`);
+    console.error(`  ${dim('Available:')} ${ids}`);
+    console.error(`  ${dim('Browse:')} conductor marketplace`);
+    process.exit(1);
+  }
+
+  // Check if already installed
+  const dir = pluginsDir(conductor);
+  const dest = path.join(dir, `${plugin.id}.js`);
+  try {
+    await fs.access(dest);
+    console.log(`  ${yellow('⚠')}  ${bold(plugin.name)} is already installed. Reinstalling…`);
+  } catch {
+    /* not installed, continue */
+  }
+
+  // Download from GitHub
+  const url = `${GITHUB_RAW}/${plugin.repo}/main/${plugin.asset}`;
+  console.log(`  ${cyan('▶')} Downloading ${bold(plugin.name)} ${dim(`v${plugin.version}`)}…`);
+
+  let source: string;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`GitHub returned ${res.status} for ${url}`);
+    source = await res.text();
+  } catch (e: any) {
+    console.error(`  ${red('✗')} Download failed: ${e.message}`);
+    console.error(`  ${dim('Expected asset at:')} ${url}`);
+    process.exit(1);
+  }
+
+  // Save to plugins dir
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(dest, source, 'utf-8');
+
+  // Mark as installed in config
+  const installed = conductor.getConfig().get<string[]>('plugins.installed') ?? [];
+  if (!installed.includes(plugin.id)) {
+    await conductor.getConfig().set('plugins.installed', [...installed, plugin.id]);
+  }
+
+  console.log(`  ${green('✓')} ${bold(plugin.name)} installed`);
+  console.log('');
+
+  // Show credential setup instructions
+  if (plugin.credentials.length > 0) {
+    console.log(`  ${bold('Setup required:')} ${plugin.name} needs credentials to work.`);
+    for (const cred of plugin.credentials) {
+      console.log(`  ${dim('→')} ${cred.label}`);
+      console.log(`     ${cyan(cred.setup)}`);
+    }
+    console.log('');
+  }
+
+  console.log(`  ${dim('Enable it:')} ${cyan(`conductor plugins enable ${plugin.id}`)}`);
+  console.log(`  ${dim('Dashboard:')} ${cyan('conductor dashboard')}`);
+  console.log('');
+}
+
+/** conductor uninstall <plugin> */
+export async function uninstallPlugin(conductor: Conductor, pluginId: string): Promise<void> {
+  console.log('');
+  const dir = pluginsDir(conductor);
+  const dest = path.join(dir, `${pluginId}.js`);
+
+  try {
+    await fs.access(dest);
+  } catch {
+    console.error(`  ${red('✗')} Plugin "${pluginId}" is not installed.`);
+    process.exit(1);
+  }
+
+  await fs.unlink(dest);
+
+  // Remove from installed + enabled lists
+  const cfg = conductor.getConfig();
+  const installed = (cfg.get<string[]>('plugins.installed') ?? []).filter((p) => p !== pluginId);
+  const enabled = (cfg.get<string[]>('plugins.enabled') ?? []).filter((p) => p !== pluginId);
+  await cfg.set('plugins.installed', installed);
+  await cfg.set('plugins.enabled', enabled);
+
+  console.log(`  ${green('✓')} ${bold(pluginId)} uninstalled`);
+  console.log('');
+}
+
+/** conductor marketplace (list) */
+export async function listMarketplace(
+  _conductor: Conductor,
+  opts: { category?: string; search?: string },
+): Promise<void> {
+  console.log('');
+  console.log(`  ${bold(cyan('Conductor Marketplace'))}`);
+  console.log(`  ${dim('Browse at: https://conductor.thealxlabs.ca/marketplace')}`);
+  console.log('');
+
+  let registry: Registry;
+  try {
+    registry = await fetchRegistry();
+  } catch (e: any) {
+    console.error(`  ${red('✗')} ${e.message}`);
+    process.exit(1);
+  }
+
+  let plugins = registry.plugins;
+
+  if (opts.category) {
+    plugins = plugins.filter((p) => p.category === opts.category);
+  }
+  if (opts.search) {
+    const q = opts.search.toLowerCase();
+    plugins = plugins.filter(
+      (p) =>
+        p.id.includes(q) ||
+        p.name.toLowerCase().includes(q) ||
+        p.description.toLowerCase().includes(q) ||
+        p.tags.includes(q),
+    );
+  }
+
+  // Group by category
+  const categories = [...new Set(plugins.map((p) => p.category))];
+  for (const cat of categories) {
+    const group = plugins.filter((p) => p.category === cat);
+    console.log(`  ${bold(cat.toUpperCase())}`);
+    for (const p of group) {
+      console.log(`    ${p.icon}  ${bold(p.name.padEnd(20))} ${dim(p.id.padEnd(18))} ${p.description.slice(0, 55)}…`);
+    }
+    console.log('');
+  }
+
+  console.log(`  ${dim('Install:')}  ${cyan('conductor install <id>')}`);
+  console.log(`  ${dim('Details:')}  ${cyan('conductor marketplace info <id>')}`);
+  console.log(`  ${dim('Search:')}   ${cyan('conductor marketplace --search <query>')}`);
+  console.log('');
+}
+
+/** conductor marketplace info <plugin> */
+export async function pluginInfo(_conductor: Conductor, pluginId: string): Promise<void> {
+  console.log('');
+  const registry = await fetchRegistry();
+  const plugin = registry.plugins.find((p) => p.id === pluginId);
+
+  if (!plugin) {
+    console.error(`  ${red('✗')} Plugin "${pluginId}" not found.`);
+    process.exit(1);
+  }
+
+  console.log(`  ${plugin.icon}  ${bold(plugin.name)}  ${dim(`v${plugin.version} by ${plugin.author}`)}`);
+  console.log('');
+  console.log(`  ${plugin.longDescription}`);
+  console.log('');
+  console.log(`  ${bold('Tools:')} ${plugin.tools.join(', ')}`);
+  console.log(`  ${bold('Tags:')}  ${plugin.tags.join(', ')}`);
+  console.log('');
+
+  if (plugin.credentials.length > 0) {
+    console.log(`  ${bold('Credentials needed:')}`);
+    for (const c of plugin.credentials) {
+      console.log(`    ${dim('→')} ${c.label}`);
+    }
+    console.log('');
+  }
+
+  console.log(`  ${bold('Source:')} https://github.com/${plugin.repo}/tree/main/${plugin.path}`);
+  console.log('');
+  console.log(`  ${cyan(`conductor install ${plugin.id}`)}`);
+  console.log('');
+}

package/src/cli/commands/mcp.ts

@@ -0,0 +1,92 @@
+import { Conductor } from '../../core/conductor.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { homedir } from 'os';
+
+const CLAUDE_DESKTOP_CONFIG = path.join(
+  homedir(),
+  process.platform === 'darwin'
+    ? 'Library/Application Support/Claude/claude_desktop_config.json'
+    : process.platform === 'win32'
+      ? 'AppData/Roaming/Claude/claude_desktop_config.json'
+      : '.config/Claude/claude_desktop_config.json',
+);
+
+export async function mcpSetup(conductor: Conductor): Promise<void> {
+  await conductor.initialize();
+
+  // Build MCP server config entry
+  const conductorPath = process.argv[1]; // Path to the conductor CLI
+  const mcpConfig = {
+    command: 'node',
+    args: [conductorPath, 'mcp', 'start'],
+  };
+
+  try {
+    let config: any = {};
+    try {
+      const existing = await fs.readFile(CLAUDE_DESKTOP_CONFIG, 'utf-8');
+      config = JSON.parse(existing);
+    } catch {
+      // File doesn't exist yet
+    }
+
+    if (!config.mcpServers) config.mcpServers = {};
+    config.mcpServers.conductor = mcpConfig;
+
+    await fs.mkdir(path.dirname(CLAUDE_DESKTOP_CONFIG), { recursive: true });
+    await fs.writeFile(CLAUDE_DESKTOP_CONFIG, JSON.stringify(config, null, 2));
+
+    console.log('✅ MCP server configured for Claude Desktop.');
+    console.log(`   Config: ${CLAUDE_DESKTOP_CONFIG}`);
+    console.log('   Restart Claude Desktop to connect.');
+  } catch (error: any) {
+    console.error(`❌ Failed to configure MCP: ${error.message}`);
+  }
+}
+
+export async function mcpStatus(_conductor: Conductor): Promise<void> {
+  try {
+    const data = await fs.readFile(CLAUDE_DESKTOP_CONFIG, 'utf-8');
+    const config = JSON.parse(data);
+
+    if (config.mcpServers?.conductor) {
+      console.log('✅ Conductor MCP server is configured.');
+      console.log(`   Command: ${config.mcpServers.conductor.command}`);
+      console.log(`   Args: ${config.mcpServers.conductor.args.join(' ')}`);
+    } else {
+      console.log('❌ Conductor MCP server is not configured.');
+      console.log('   Run: conductor mcp setup');
+    }
+  } catch {
+    console.log('❌ Claude Desktop config not found.');
+    console.log('   Run: conductor mcp setup');
+  }
+}
+
+export async function mcpStart(_conductor: Conductor): Promise<void> {
+  // Start in MCP stdio mode — quiet to avoid polluting stdout
+  const quietConductor = new (await import('../../core/conductor.js')).Conductor(undefined, { quiet: true });
+  await quietConductor.initialize();
+
+  // Import and start MCP server (writes JSON-RPC to stdout)
+  const { startMCPServer } = await import('../../mcp/server.js');
+  await startMCPServer(quietConductor);
+}
+
+export async function mcpRemove(_conductor: Conductor): Promise<void> {
+  try {
+    const data = await fs.readFile(CLAUDE_DESKTOP_CONFIG, 'utf-8');
+    const config = JSON.parse(data);
+
+    if (config.mcpServers?.conductor) {
+      delete config.mcpServers.conductor;
+      await fs.writeFile(CLAUDE_DESKTOP_CONFIG, JSON.stringify(config, null, 2));
+      console.log('✅ Conductor MCP server removed from Claude Desktop config.');
+    } else {
+      console.log('Conductor was not configured in Claude Desktop.');
+    }
+  } catch {
+    console.log('Claude Desktop config not found. Nothing to remove.');
+  }
+}

package/src/cli/commands/onboard.ts

@@ -0,0 +1,248 @@
+/**
+ * conductor onboard — interactive TUI plugin picker
+ *
+ * Lets users browse all available plugins by category, select which ones
+ * to enable, and immediately configure credentials for any that need them.
+ * Works on first install or any time via `conductor plugins onboard`.
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { Conductor } from '../../core/conductor.js';
+import { PluginManager } from '../../plugins/manager.js';
+
+interface _PluginEntry {
+  name: string;
+  description: string;
+  enabled: boolean;
+  configured: boolean;
+  zeroConfig: boolean;
+  category: string;
+}
+
+// Category groupings for the TUI picker
+const CATEGORIES: Record<string, string[]> = {
+  'Developer Tools': [
+    'shell', 'docker', 'github', 'git', 'github-actions', 'vercel', 'n8n', 'linear', 'jira',
+  ],
+  'Communication': ['slack', 'telegram'],
+  'Google Workspace': ['gmail', 'google-calendar', 'google-drive'],
+  'Productivity': ['notes', 'memory', 'notion', 'todoist'],
+  'Finance & Commerce': ['stripe'],
+  'Utilities': [
+    'calculator', 'colors', 'crypto', 'hash', 'text-tools',
+    'timezone', 'network', 'url-tools', 'fun', 'system', 'cron', 'weather', 'translate',
+  ],
+  'Media & Social': ['spotify', 'x'],
+  'Smart Home': ['homekit'],
+};
+
+const ZERO_CONFIG_SET = new Set([
+  'calculator', 'colors', 'hash', 'text-tools', 'timezone',
+  'network', 'url-tools', 'fun', 'system', 'notes', 'memory',
+  'cron', 'shell', 'docker', 'github', 'translate',
+  'weather',
+  'crypto',
+]);
+
+function header(): void {
+  console.log('');
+  console.log(chalk.bold.white('  ╔══════════════════════════════════════╗'));
+  console.log(chalk.bold.white('  ║') + chalk.bold('  🎼 Conductor — Plugin Setup          ') + chalk.bold.white('║'));
+  console.log(chalk.bold.white('  ╚══════════════════════════════════════╝'));
+  console.log('');
+  console.log(chalk.dim('  Select the plugins you want to enable.'));
+  console.log(
+    chalk.dim('  Zero-config plugins ') + chalk.green('[free]') + chalk.dim(' work instantly — no credentials needed.'),
+  );
+  console.log('');
+}
+
+function categoryHeader(name: string): void {
+  console.log('  ' + chalk.bold.white('─── ' + name + ' '));
+}
+
+export async function onboard(conductor: Conductor): Promise<void> {
+  await conductor.initialize();
+  const pm = new PluginManager(conductor);
+  await pm.loadBuiltins();
+
+  header();
+
+  const available = pm.listPlugins();
+  const availableByName = new Map(available.map((p) => [p.name, p]));
+  const currentlyEnabled = new Set(available.filter((p) => p.enabled).map((p) => p.name));
+
+  // Build choices grouped by category
+  const choices: Array<{ type?: string; name?: string; value?: string; checked?: boolean; short?: string }> = [];
+
+  for (const [catName, pluginNames] of Object.entries(CATEGORIES)) {
+    categoryHeader(catName);
+
+    const catChoices = pluginNames
+      .filter((name) => availableByName.has(name))
+      .map((name) => {
+        const p = availableByName.get(name)!;
+        const zc = ZERO_CONFIG_SET.has(name);
+        const badge = zc ? ' ' + chalk.green('[zero-config]') : ' ' + chalk.yellow('[needs setup]');
+
+        return {
+          name: `${chalk.white(p.name.padEnd(22))} ${chalk.dim(p.description)}${badge}`,
+          value: name,
+          checked: currentlyEnabled.has(name) || zc,
+          short: name,
+        };
+      });
+
+    if (catChoices.length > 0) {
+      choices.push({ type: 'separator', name: '' });
+      choices.push(...catChoices);
+    }
+  }
+
+  // Also include plugins not in any category
+  const categorized = new Set(Object.values(CATEGORIES).flat());
+  const uncategorized = available.filter((p) => !categorized.has(p.name));
+  if (uncategorized.length > 0) {
+    categoryHeader('Other Plugins');
+    choices.push({ type: 'separator', name: '' });
+    for (const p of uncategorized) {
+      const zc = ZERO_CONFIG_SET.has(p.name);
+      choices.push({
+        name: `${chalk.white(p.name.padEnd(22))} ${chalk.dim(p.description)}${zc ? chalk.green(' [zero-config]') : chalk.yellow(' [needs setup]')}`,
+        value: p.name,
+        checked: currentlyEnabled.has(p.name) || zc,
+        short: p.name,
+      });
+    }
+  }
+
+  console.log('');
+  const { selected } = await inquirer.prompt<{ selected: string[] }>([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message: 'Select plugins to enable (Space to toggle, Enter to confirm):',
+      choices,
+      pageSize: 24,
+    },
+  ]);
+
+  if (selected.length === 0) {
+    console.log('');
+    console.log(chalk.yellow('  No plugins selected. Run conductor onboard again to pick plugins.'));
+    console.log('');
+    return;
+  }
+
+  // Determine which newly selected plugins need configuration
+  const toEnable = selected;
+  const needsSetup = toEnable.filter((name) => !ZERO_CONFIG_SET.has(name) && !currentlyEnabled.has(name));
+
+  // Update enabled list
+  const newEnabled = [...new Set([...Array.from(currentlyEnabled), ...toEnable])];
+  await conductor.getConfig().set('plugins.enabled', newEnabled);
+
+  console.log('');
+  console.log(chalk.bold.white('  ✓ Updated plugin list'));
+  console.log('');
+
+  // Offer to configure each credentialed plugin that was just selected
+  if (needsSetup.length > 0) {
+    console.log(chalk.dim(`  The following plugins need credentials to work:`));
+    for (const name of needsSetup) {
+      console.log(`    ${chalk.yellow('⚠')} ${chalk.white(name)}`);
+    }
+    console.log('');
+
+    const { configureNow } = await inquirer.prompt<{ configureNow: boolean }>([
+      {
+        type: 'confirm',
+        name: 'configureNow',
+        message: 'Configure credentials for these plugins now?',
+        default: true,
+      },
+    ]);
+
+    if (configureNow) {
+      for (const name of needsSetup) {
+        await setupPlugin(conductor, pm, name);
+      }
+    } else {
+      console.log('');
+      console.log(chalk.dim('  Configure later with:'));
+      for (const name of needsSetup) {
+        console.log(`    ${chalk.cyan(`conductor plugins setup ${name}`)}`);
+      }
+    }
+  }
+
+  // Final summary
+  console.log('');
+  console.log(chalk.bold.white('  ─────────────────────────────────────────'));
+  console.log(chalk.bold.white(`  🎼 ${toEnable.length} plugins enabled — ready to start`));
+  console.log('');
+  console.log(chalk.dim('  Start the MCP server:'));
+  console.log(`    ${chalk.cyan('conductor mcp start')}`);
+  console.log('');
+  console.log(chalk.dim('  Or connect your AI agent (auto-configures Claude Desktop):'));
+  console.log(`    ${chalk.cyan('conductor mcp setup')}`);
+  console.log('');
+}
+
+async function setupPlugin(conductor: Conductor, _pm: PluginManager, name: string): Promise<void> {
+  console.log('');
+  console.log(chalk.bold(`  ── Setting up ${chalk.white(name)} ──`));
+
+  const pm2 = new PluginManager(conductor);
+  await pm2.loadBuiltins();
+  const plugins = pm2.listPlugins();
+  const p = plugins.find((x) => x.name === name);
+
+  if (!p) {
+    console.log(chalk.yellow(`  Plugin "${name}" not found — skipping`));
+    return;
+  }
+
+  if (!p.configSchema || p.configSchema.fields.length === 0) {
+    console.log(chalk.green(`  ✓ ${name} requires no configuration`));
+    return;
+  }
+
+  if (p.configSchema.setupInstructions) {
+    console.log('');
+    console.log(chalk.dim('  ' + p.configSchema.setupInstructions.split('\n').join('\n  ')));
+    console.log('');
+  }
+
+  // Build inquirer prompts from the plugin's configSchema
+  const prompts = p.configSchema.fields.map((field) => ({
+    type: field.type === 'password' ? 'password' : field.type === 'boolean' ? 'confirm' : 'input',
+    name: field.key,
+    message: `${field.label}${field.required ? '' : ' (optional)'}:`,
+    mask: field.type === 'password' ? '*' : undefined,
+    validate: (input: string) => {
+      if (field.required && !input) return `${field.label} is required`;
+      return true;
+    },
+  }));
+
+  const answers = await inquirer.prompt<Record<string, string>>(prompts);
+
+  // Persist the values
+  const { Keychain } = await import('../../security/keychain.js');
+  const keychain = new Keychain(conductor.getConfig().getConfigDir());
+
+  for (const field of p.configSchema.fields) {
+    const value = answers[field.key];
+    if (!value) continue;
+
+    if (field.secret) {
+      await keychain.set(field.service ?? name, field.key, value);
+    } else {
+      await conductor.getConfig().set(`plugins.${name}.${field.key}`, value);
+    }
+  }
+
+  console.log(chalk.green(`  ✓ ${name} configured`));
+}