@useconductor/conductor 1.0.0

package/src/bot/telegram.ts

@@ -0,0 +1,185 @@
+import { Telegraf } from 'telegraf';
+import { Conductor } from '../core/conductor.js';
+import { Keychain } from '../security/keychain.js';
+import { AIManager } from '../ai/manager.js';
+import type { ConductorNotification } from '../core/interfaces.js';
+
+export class TelegramBot {
+  private conductor: Conductor;
+  private keychain: Keychain;
+  private bot: Telegraf | null = null;
+  private aiManager: AIManager;
+  private authorizedUserId: number | null = null;
+
+  constructor(conductor: Conductor) {
+    this.conductor = conductor;
+    this.keychain = new Keychain(conductor.getConfig().getConfigDir());
+    this.aiManager = new AIManager(conductor);
+  }
+
+  /** Start the Telegram bot. */
+  async start(): Promise<void> {
+    // Bug fix: install.sh saves token to keychain, NOT to config.
+    // Read from keychain first, fall back to config for backward compat.
+    let token = await this.keychain.get('telegram', 'bot_token');
+    if (!token) {
+      // Legacy fallback: some users may have set it in config
+      token = this.conductor.getConfig().get<string>('telegram.token') ?? null;
+    }
+
+    if (!token) {
+      throw new Error('Telegram bot token not found. Run the installer or set it with: conductor telegram setup');
+    }
+
+    // Load authorized user ID from config (set during install verification)
+    this.authorizedUserId = this.conductor.getConfig().get<number>('telegram.user_id') ?? null;
+
+    this.bot = new Telegraf(token);
+
+    this.registerHandlers();
+
+    // Graceful shutdown
+    process.once('SIGINT', () => this.bot?.stop('SIGINT'));
+    process.once('SIGTERM', () => this.bot?.stop('SIGTERM'));
+
+    process.stderr.write('Telegram bot starting...\n');
+    await this.bot.launch();
+
+    // Register this bot as the notification handler for Conductor
+    this.conductor.setNotificationHandler(this.sendMessage.bind(this));
+
+    // Start the proactive loop (every 30 mins default)
+    await this.conductor.startProactiveMode(30);
+  }
+
+  /** Register message handlers. */
+  private registerHandlers(): void {
+    if (!this.bot) return;
+
+    // Auth middleware — only respond to the verified owner
+    this.bot.use(async (ctx, next) => {
+      if (this.authorizedUserId && ctx.from?.id !== this.authorizedUserId) {
+        await ctx.reply('⛔ Unauthorized. This bot is private.');
+        return;
+      }
+      return next();
+    });
+
+    this.bot.command('start', async (ctx) => {
+      await ctx.reply("👋 Conductor is online.\n\nSend me a message and I'll route it through your AI provider.");
+    });
+
+    this.bot.command('status', async (ctx) => {
+      const config = this.conductor.getConfig();
+      const provider = config.get<string>('ai.provider') || 'none';
+      const plugins = config.get<string[]>('plugins.enabled') || [];
+
+      await ctx.reply(
+        `📊 Status:\n` +
+          `AI: ${provider}\n` +
+          `Plugins: ${plugins.length > 0 ? plugins.join(', ') : 'none'}\n` +
+          `User: ${config.get<string>('user.name') || 'not set'}`,
+      );
+    });
+
+    // Default: route text messages through AI
+    this.bot.on('text', async (ctx) => {
+      const message = ctx.message.text;
+
+      try {
+        const provider = await this.aiManager.getCurrentProvider();
+        if (!provider) {
+          await ctx.reply('No AI provider configured. Run: conductor ai');
+          return;
+        }
+
+        // Send typing indicator
+        await ctx.sendChatAction('typing');
+
+        const userId = String(ctx.from.id);
+        const agentResponse = await this.aiManager.handleConversation(userId, message);
+
+        await this.sendAgentResponse(ctx, agentResponse);
+      } catch (error: any) {
+        process.stderr.write(`Telegram AI error: ${error.message}\n`);
+        await ctx.reply(`❌ Error: ${error.message}`);
+      }
+    });
+
+    this.bot.action(/^approve:(.+)$/, async (ctx) => {
+      await ctx.answerCbQuery();
+      await ctx.editMessageReplyMarkup(undefined); // remove buttons
+
+      const toolCallId = ctx.match[1];
+      const userId = String(ctx.from?.id);
+
+      try {
+        await ctx.reply('⏳ Executing approved action...');
+        await ctx.sendChatAction('typing');
+        const agentResponse = await this.aiManager.executeApprovedTool(userId, toolCallId);
+        await this.sendAgentResponse(ctx, agentResponse);
+      } catch (error: any) {
+        process.stderr.write(`Telegram execute error: ${error.message}\n`);
+        await ctx.reply(`❌ Error: ${error.message}`);
+      }
+    });
+
+    this.bot.action(/^deny:(.+)$/, async (ctx) => {
+      await ctx.answerCbQuery();
+      await ctx.editMessageReplyMarkup(undefined); // remove buttons
+
+      const toolCallId = ctx.match[1];
+      const userId = String(ctx.from?.id);
+
+      try {
+        await ctx.reply('🛑 Action denied. Informing AI...');
+        await ctx.sendChatAction('typing');
+        const agentResponse = await this.aiManager.denyTool(userId, toolCallId);
+        await this.sendAgentResponse(ctx, agentResponse);
+      } catch (error: any) {
+        process.stderr.write(`Telegram deny error: ${error.message}\n`);
+        await ctx.reply(`❌ Error: ${error.message}`);
+      }
+    });
+  }
+
+  private async sendAgentResponse(ctx: any, res: any): Promise<void> {
+    if (res.approvalRequired) {
+      const { toolCallId, toolName, arguments: args } = res.approvalRequired;
+      const text = `*⚠️ Action Requires Approval*\n\nThe AI wants to use the \`${toolName}\` tool.\n\n*Arguments:*\n\`\`\`json\n${JSON.stringify(args, null, 2)}\n\`\`\`\n\n${res.text || 'Do you approve?'}`;
+
+      await ctx.reply(text, {
+        parse_mode: 'Markdown',
+        reply_markup: {
+          inline_keyboard: [
+            [
+              { text: '✅ Approve', callback_data: `approve:${toolCallId}` },
+              { text: '❌ Deny', callback_data: `deny:${toolCallId}` },
+            ],
+          ],
+        },
+      });
+    } else {
+      await ctx.reply(res.text);
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.bot?.stop();
+  }
+
+  /** Send a proactive notification to the authorized user. */
+  async sendMessage(notification: ConductorNotification): Promise<void> {
+    if (!this.bot) throw new Error('Bot not started');
+    if (!this.authorizedUserId) {
+      process.stderr.write('  [Telegram] Cannot send proactive message: No authorizedUserId set.\n');
+      return;
+    }
+    // Format as Telegram Markdown
+    let text = `*${notification.title}*\n\n${notification.body}`;
+    if (notification.codeBlock) {
+      text += `\n\n\`\`\`json\n${notification.codeBlock}\n\`\`\``;
+    }
+    await this.bot.telegram.sendMessage(this.authorizedUserId, text, { parse_mode: 'Markdown' });
+  }
+}

package/src/cli/README.md

@@ -0,0 +1,24 @@
+# src/cli
+
+Command-line interface for Conductor, built with Commander.
+
+## Contents
+
+- `index.ts` - CLI entry point, command registration
+- `commands/` - Individual CLI command implementations
+
+## Architecture
+
+The CLI is the primary user interface for managing Conductor. Entry point is `src/cli/index.ts`. Commands live in `commands/` and cover plugin management, MCP server setup, lifecycle control, diagnostics, and plugin scaffolding.
+
+Run locally without building:
+
+```bash
+npx tsx src/cli/index.ts <command>
+```
+
+After building:
+
+```bash
+node dist/cli/index.js <command>
+```

package/src/cli/commands/README.md

@@ -0,0 +1,20 @@
+# src/cli/commands
+
+Individual CLI command implementations for Conductor.
+
+## Contents
+
+- `plugins.ts` - Enable/disable/list/install plugins
+- `mcp.ts` - Start/setup MCP server
+- `lifecycle.ts` - Start/stop/status for Conductor services
+- `doctor.ts` - System health diagnostics
+- `marketplace.ts` - Plugin marketplace operations
+- `plugin-create.ts` - Scaffold new plugins
+- `ai.ts` - AI provider configuration
+- `init.ts` / `onboard.ts` - Initial setup and onboarding
+- `install.ts` - Installation utilities
+- `telegram.ts` - Telegram bot configuration
+
+## Architecture
+
+Each command is a Commander subcommand registered in `src/cli/index.ts`. Commands interact with the `Conductor` instance to manage plugins, configure AI providers, control service lifecycle, and perform diagnostics.

package/src/cli/commands/ai.ts

@@ -0,0 +1,170 @@
+import { Conductor } from '../../core/conductor.js';
+import { AIManager } from '../../ai/manager.js';
+
+export async function setupAI(conductor: Conductor): Promise<void> {
+  await conductor.initialize();
+
+  const { default: inquirer } = await import('inquirer');
+
+  const { provider } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Select an AI provider:',
+      choices: [
+        { name: 'Claude (Anthropic)', value: 'claude' },
+        { name: 'OpenAI (GPT-4o)', value: 'openai' },
+        { name: 'OpenRouter', value: 'openrouter' },
+        { name: 'Gemini (Google)', value: 'gemini' },
+        { name: 'Ollama (Local)', value: 'ollama' },
+      ],
+    },
+  ]);
+
+  const aiManager = new AIManager(conductor);
+
+  switch (provider) {
+    case 'claude': {
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: 'Enter your Anthropic API key:',
+          mask: '*',
+        },
+      ]);
+      await aiManager.setupClaude(apiKey);
+      console.log('✅ Claude configured successfully.');
+      break;
+    }
+    case 'openai': {
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: 'Enter your OpenAI API key:',
+          mask: '*',
+        },
+      ]);
+      await aiManager.setupOpenAI(apiKey);
+      console.log('✅ OpenAI configured successfully.');
+      break;
+    }
+    case 'openrouter': {
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: 'Enter your OpenRouter API key:',
+          mask: '*',
+        },
+      ]);
+
+      // Fetch available models from OpenRouter using the provided key
+      let modelChoices: { name: string; value: string }[] = [];
+      try {
+        process.stdout.write('Fetching available models from OpenRouter...');
+        const res = await fetch('https://openrouter.ai/api/v1/models', {
+          headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (res.ok) {
+          const json = (await res.json()) as { data: { id: string; name: string }[] };
+          modelChoices = json.data
+            .sort((a: { id: string; name: string }, b: { id: string; name: string }) => a.id.localeCompare(b.id))
+            .map((m: { id: string; name: string }) => ({ name: `${m.name} (${m.id})`, value: m.id }));
+          process.stdout.write(` ${modelChoices.length} models found.\n`);
+        }
+      } catch {
+        // silently fall through to manual entry
+      }
+
+      let model: string;
+      if (modelChoices.length > 0) {
+        const answer = await inquirer.prompt([
+          {
+            type: 'select',
+            name: 'model',
+            message: 'Select a model:',
+            choices: modelChoices,
+            pageSize: 15,
+          },
+        ]);
+        model = answer.model;
+      } else {
+        console.log('Could not fetch model list. Please enter a model ID manually.');
+        const answer = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'model',
+            message: 'Model ID (e.g. openai/gpt-4o, anthropic/claude-3.5-sonnet):',
+            default: 'openai/gpt-4o',
+          },
+        ]);
+        model = answer.model;
+      }
+
+      await aiManager.setupOpenRouter(apiKey, model);
+      console.log(`\u2705 OpenRouter configured successfully with ${model}.`);
+      break;
+    }
+    case 'gemini': {
+      const { method } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'method',
+          message: 'How would you like to authenticate?',
+          choices: [
+            { name: 'Google Sign-In (easiest)', value: 'oauth' },
+            { name: 'API Key', value: 'api_key' },
+          ],
+        },
+      ]);
+
+      if (method === 'oauth') {
+        console.log('Opening browser for Google Sign-In...');
+        await aiManager.setupGeminiOAuthEasy();
+        console.log('✅ Gemini configured with Google Sign-In.');
+      } else {
+        const { apiKey } = await inquirer.prompt([
+          {
+            type: 'password',
+            name: 'apiKey',
+            message: 'Enter your Gemini API key:',
+            mask: '*',
+          },
+        ]);
+        await aiManager.setupGemini(apiKey);
+        console.log('✅ Gemini configured successfully.');
+      }
+      break;
+    }
+    case 'ollama': {
+      const { model } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'model',
+          message: 'Which Ollama model?',
+          default: 'llama3.2',
+        },
+      ]);
+      await aiManager.setupOllama(model);
+      console.log(`✅ Ollama configured with ${model}.`);
+      break;
+    }
+  }
+}
+
+export async function testAI(conductor: Conductor): Promise<void> {
+  await conductor.initialize();
+  const aiManager = new AIManager(conductor);
+
+  const provider = await aiManager.getCurrentProvider();
+  if (!provider) {
+    console.log('No AI provider configured. Run: conductor ai setup');
+    return;
+  }
+
+  console.log(`Testing ${provider.getName()}...`);
+  const works = await provider.test();
+  console.log(works ? '✅ AI provider is working.' : '❌ AI provider test failed.');
+}

package/src/cli/commands/doctor.ts

@@ -0,0 +1,221 @@
+/**
+ * Conductor Doctor — diagnose every possible issue and tell you how to fix it.
+ *
+ * Checks:
+ *   - Node.js version
+ *   - Config file existence and validity
+ *   - Keychain accessibility
+ *   - AI provider configuration
+ *   - Plugin status
+ *   - MCP server connectivity
+ *   - Disk space
+ *   - Environment variables
+ *   - Dependency versions
+ *   - File permissions
+ */
+
+import { Conductor } from '../../core/conductor.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+interface CheckResult {
+  name: string;
+  status: 'ok' | 'warning' | 'error';
+  message: string;
+  fix?: string;
+}
+
+export async function doctor(conductor: Conductor): Promise<void> {
+  const checks: CheckResult[] = [];
+
+  // Node.js version
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1).split('.')[0]);
+  if (major >= 18) {
+    checks.push({ name: 'Node.js', status: 'ok', message: `${nodeVersion}` });
+  } else if (major >= 16) {
+    checks.push({
+      name: 'Node.js',
+      status: 'warning',
+      message: `${nodeVersion} (upgrade to 18+ recommended)`,
+      fix: 'nvm install 18',
+    });
+  } else {
+    checks.push({ name: 'Node.js', status: 'error', message: `${nodeVersion} (requires 18+)`, fix: 'nvm install 18' });
+  }
+
+  // Config directory
+  await conductor.initialize();
+  const configDir = conductor.getConfig().getConfigDir();
+  try {
+    await fs.access(configDir);
+    checks.push({ name: 'Config directory', status: 'ok', message: configDir });
+  } catch {
+    checks.push({
+      name: 'Config directory',
+      status: 'error',
+      message: `${configDir} does not exist`,
+      fix: `mkdir -p ${configDir}`,
+    });
+  }
+
+  // Config file
+  try {
+    const configFile = path.join(configDir, 'config.json');
+    const content = await fs.readFile(configFile, 'utf-8');
+    JSON.parse(content);
+    checks.push({ name: 'Config file', status: 'ok', message: configFile });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    checks.push({
+      name: 'Config file',
+      status: 'warning',
+      message: `Not found or invalid: ${msg}`,
+      fix: 'Run: conductor ai setup',
+    });
+  }
+
+  // Keychain
+  try {
+    const keychainDir = path.join(configDir, 'keychain');
+    await fs.access(keychainDir);
+    const files = await fs.readdir(keychainDir);
+    checks.push({ name: 'Keychain', status: 'ok', message: `${files.length} credentials stored` });
+  } catch {
+    checks.push({
+      name: 'Keychain',
+      status: 'warning',
+      message: 'Not initialized',
+      fix: 'Run: conductor ai setup or conductor auth google',
+    });
+  }
+
+  // AI Provider
+  const aiProvider = conductor.getConfig().get<string>('ai.provider');
+  if (aiProvider) {
+    checks.push({ name: 'AI Provider', status: 'ok', message: aiProvider });
+  } else {
+    checks.push({ name: 'AI Provider', status: 'warning', message: 'Not configured', fix: 'Run: conductor ai setup' });
+  }
+
+  // Enabled plugins
+  const enabledPlugins = conductor.getConfig().get<string[]>('plugins.enabled') || [];
+  if (enabledPlugins.length > 0) {
+    checks.push({
+      name: 'Plugins',
+      status: 'ok',
+      message: `${enabledPlugins.length} enabled: ${enabledPlugins.join(', ')}`,
+    });
+  } else {
+    checks.push({
+      name: 'Plugins',
+      status: 'warning',
+      message: 'No plugins enabled',
+      fix: 'Run: conductor plugins enable <name>',
+    });
+  }
+
+  // Disk space
+  const homeDir = os.homedir();
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const si = await import('systeminformation');
+    const fsInfo = await si.default.fsSize();
+    const homeFs = fsInfo.find((f: any) => homeDir.startsWith(f.mount));
+    if (homeFs) {
+      const usedPercent = homeFs.use;
+      if (usedPercent > 90) {
+        checks.push({
+          name: 'Disk space',
+          status: 'error',
+          message: `${usedPercent.toFixed(1)}% used on ${homeFs.mount}`,
+          fix: 'Free up disk space',
+        });
+      } else if (usedPercent > 80) {
+        checks.push({
+          name: 'Disk space',
+          status: 'warning',
+          message: `${usedPercent.toFixed(1)}% used on ${homeFs.mount}`,
+        });
+      } else {
+        checks.push({
+          name: 'Disk space',
+          status: 'ok',
+          message: `${usedPercent.toFixed(1)}% used on ${homeFs.mount}`,
+        });
+      }
+    }
+  } catch {
+    // systeminformation might not be available
+  }
+
+  // Environment variables
+  const envVars = ['CLAUDE_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY', 'GITHUB_TOKEN'];
+  const setVars = envVars.filter((v) => process.env[v]);
+  if (setVars.length > 0) {
+    checks.push({
+      name: 'Environment',
+      status: 'ok',
+      message: `${setVars.length} env vars set: ${setVars.join(', ')}`,
+    });
+  } else {
+    checks.push({
+      name: 'Environment',
+      status: 'warning',
+      message: 'No API keys in environment',
+      fix: 'Add keys to .env or run conductor ai setup',
+    });
+  }
+
+  // Audit log integrity
+  try {
+    const { AuditLogger } = await import('../../core/audit.js');
+    const audit = new AuditLogger(configDir);
+    const integrity = await audit.verifyIntegrity();
+    if (integrity.valid) {
+      checks.push({ name: 'Audit log', status: 'ok', message: 'Integrity verified' });
+    } else {
+      checks.push({
+        name: 'Audit log',
+        status: 'error',
+        message: `Integrity broken at ${integrity.brokenAt}`,
+        fix: 'Audit log may have been tampered with',
+      });
+    }
+    await audit.close();
+  } catch {
+    checks.push({ name: 'Audit log', status: 'warning', message: 'Not accessible' });
+  }
+
+  // Print results
+  console.log('');
+  console.log('  🔍 Conductor Doctor');
+  console.log('  ═══════════════════\n');
+
+  const errors = checks.filter((c) => c.status === 'error');
+  const warnings = checks.filter((c) => c.status === 'warning');
+  const oks = checks.filter((c) => c.status === 'ok');
+
+  for (const check of checks) {
+    const icon = check.status === 'ok' ? '✅' : check.status === 'warning' ? '⚠️' : '❌';
+    console.log(`  ${icon} ${check.name}`);
+    console.log(`     ${check.message}`);
+    if (check.fix) {
+      console.log(`     Fix: ${check.fix}`);
+    }
+    console.log('');
+  }
+
+  console.log('  ═══════════════════');
+  console.log(`  ${oks.length} ok, ${warnings.length} warnings, ${errors.length} errors\n`);
+
+  if (errors.length > 0) {
+    console.log('  ⚠️  Critical issues found. Fix them before using Conductor.\n');
+    process.exit(1);
+  } else if (warnings.length > 0) {
+    console.log('  ℹ️  Some warnings found. Conductor will work, but consider fixing them.\n');
+  } else {
+    console.log('  🎉 Everything looks good!\n');
+  }
+}