icopilot 2.2.0

package/dist/notifications/manager.js

@@ -0,0 +1,107 @@
+import { SlackNotificationHandler } from '../extensions/slack-provider.js';
+import { TeamsNotificationHandler } from '../extensions/teams-provider.js';
+import { registerNotificationHandler } from '../extensions/team.js';
+const logDebug = (msg) => {
+    if (process.env.ICOPILOT_LOG_LEVEL === 'debug') {
+        process.stderr.write(`[notifications] ${msg}\n`);
+    }
+};
+export class NotificationManager {
+    config;
+    handler = null;
+    constructor(config) {
+        this.config = config ?? null;
+        this.initializeHandler();
+    }
+    initializeHandler() {
+        if (!this.config || !this.config.token || !this.config.channel) {
+            logDebug('No notification config provided');
+            return;
+        }
+        try {
+            let handler;
+            if (this.config.provider === 'slack') {
+                handler = new SlackNotificationHandler(this.config.token, this.config.channel);
+                logDebug('Initialized Slack notification handler');
+            }
+            else if (this.config.provider === 'teams') {
+                handler = new TeamsNotificationHandler(this.config.token, this.config.channel, '');
+                logDebug('Initialized Teams notification handler');
+            }
+            else {
+                logDebug(`Unknown notification provider: ${this.config.provider}`);
+                return;
+            }
+            this.handler = handler;
+            registerNotificationHandler(handler);
+        }
+        catch (error) {
+            logDebug(`Failed to initialize notification handler: ${error}`);
+        }
+    }
+    async sendNotification(message, options) {
+        if (!this.handler || !this.config) {
+            logDebug('Notification handler not configured');
+            return;
+        }
+        const channel = options?.channel || this.config.channel;
+        try {
+            await this.handler.notify(channel, message, options?.metadata);
+            logDebug(`Sent notification to ${channel}`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[notifications] Failed to send notification: ${msg}\n`);
+        }
+    }
+    async requestUserApproval(action, details = {}) {
+        if (!this.handler || !this.config) {
+            logDebug('Notification handler not configured');
+            return { approved: false };
+        }
+        try {
+            const result = await this.handler.requestApproval(this.config.channel, action, details);
+            logDebug(`Approval request completed: ${action} - ${result.approved ? 'approved' : 'denied'}`);
+            return result;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[notifications] Failed to request approval: ${msg}\n`);
+            return { approved: false };
+        }
+    }
+    async getApprovalStatus(id) {
+        return null;
+    }
+    formatOutput(content, type = 'text') {
+        if (type === 'error') {
+            return `\`\`\`\n❌ Error:\n${content}\n\`\`\``;
+        }
+        if (type === 'code') {
+            return `\`\`\`\n${content}\n\`\`\``;
+        }
+        return content;
+    }
+    async getStatus() {
+        if (!this.handler) {
+            return { connected: false, error: 'No handler configured' };
+        }
+        return this.handler.getStatus();
+    }
+    isConfigured() {
+        return this.handler != null && this.config != null;
+    }
+    getConfig() {
+        return this.config;
+    }
+}
+let globalManager = null;
+export function initializeNotificationManager(config) {
+    globalManager = new NotificationManager(config);
+}
+export function getNotificationManager() {
+    if (!globalManager) {
+        globalManager = new NotificationManager(null);
+    }
+    return globalManager;
+}

package/dist/plugins/marketplace.js

@@ -0,0 +1,244 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+const DEFAULT_PLUGINS = [
+    {
+        name: 'azure-tools',
+        version: '1.2.0',
+        description: 'Azure deployment helpers, diagnostics, and workflow shortcuts.',
+        author: 'iCopilot',
+        installed: false,
+    },
+    {
+        name: 'jira-sync',
+        version: '0.8.1',
+        description: 'Create and update Jira issues from terminal workflows.',
+        author: 'iCopilot',
+        installed: false,
+    },
+    {
+        name: 'shell-utils',
+        version: '2.0.3',
+        description: 'Reusable shell helpers for scripts, prompts, and environment checks.',
+        author: 'iCopilot',
+        installed: false,
+    },
+];
+export class Marketplace {
+    registryFile;
+    pluginsDir;
+    seedPlugins;
+    constructor(options = {}) {
+        const homeDir = options.homeDir ?? os.homedir();
+        this.registryFile =
+            options.registryFile ?? path.join(homeDir, '.icopilot', 'plugin-registry.json');
+        this.pluginsDir = options.pluginsDir ?? path.join(homeDir, '.icopilot', 'plugins');
+        this.seedPlugins = dedupePlugins(options.seedPlugins ?? DEFAULT_PLUGINS);
+    }
+    async search(query) {
+        const normalizedQuery = query.trim().toLowerCase();
+        const plugins = await this.list();
+        if (!normalizedQuery)
+            return plugins;
+        return plugins.filter((plugin) => [plugin.name, plugin.version, plugin.description, plugin.author]
+            .join('\n')
+            .toLowerCase()
+            .includes(normalizedQuery));
+    }
+    async install(name) {
+        const registry = await this.readRegistry();
+        const plugin = findPlugin(registry.plugins, name);
+        if (!plugin) {
+            throw new Error(`plugin not found: ${name}`);
+        }
+        plugin.installed = true;
+        await this.writeRegistry(registry);
+        await this.writeInstalledPlugin(plugin);
+        return { ...plugin };
+    }
+    async uninstall(name) {
+        const registry = await this.readRegistry();
+        const plugin = findPlugin(registry.plugins, name);
+        if (!plugin) {
+            throw new Error(`plugin not found: ${name}`);
+        }
+        plugin.installed = false;
+        await this.writeRegistry(registry);
+        await fs.rm(this.pluginDir(plugin.name), { recursive: true, force: true });
+        return { ...plugin };
+    }
+    async update(name) {
+        const registry = await this.readRegistry();
+        const candidates = name
+            ? [findPlugin(registry.plugins, name)].filter((plugin) => Boolean(plugin))
+            : registry.plugins.filter((plugin) => plugin.installed);
+        if (name && candidates.length === 0) {
+            throw new Error(`plugin not found: ${name}`);
+        }
+        const notInstalled = candidates.find((plugin) => !plugin.installed);
+        if (notInstalled) {
+            throw new Error(`plugin is not installed: ${notInstalled.name}`);
+        }
+        for (const plugin of candidates) {
+            await this.writeInstalledPlugin(plugin);
+        }
+        if (candidates.length > 0) {
+            await this.writeRegistry(registry);
+        }
+        return candidates.map((plugin) => ({ ...plugin }));
+    }
+    async list() {
+        const registry = await this.readRegistry();
+        return registry.plugins.map((plugin) => ({ ...plugin }));
+    }
+    async getInfo(name) {
+        const registry = await this.readRegistry();
+        const plugin = findPlugin(registry.plugins, name);
+        return plugin ? { ...plugin } : null;
+    }
+    async readRegistry() {
+        await fs.mkdir(path.dirname(this.registryFile), { recursive: true });
+        try {
+            const raw = await fs.readFile(this.registryFile, 'utf8');
+            const parsed = JSON.parse(raw);
+            const plugins = mergeWithSeed(parseRegistryPlugins(parsed), this.seedPlugins);
+            const registry = { plugins };
+            await this.writeRegistry(registry);
+            return registry;
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT')
+                throw error;
+            const registry = { plugins: this.seedPlugins.map((plugin) => ({ ...plugin })) };
+            await this.writeRegistry(registry);
+            return registry;
+        }
+    }
+    async writeRegistry(registry) {
+        await fs.mkdir(path.dirname(this.registryFile), { recursive: true });
+        await fs.writeFile(this.registryFile, `${JSON.stringify({ plugins: dedupePlugins(registry.plugins) }, null, 2)}\n`, 'utf8');
+    }
+    async writeInstalledPlugin(plugin) {
+        const dir = this.pluginDir(plugin.name);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(path.join(dir, 'plugin.json'), `${JSON.stringify(plugin, null, 2)}\n`, 'utf8');
+    }
+    pluginDir(name) {
+        return path.join(this.pluginsDir, name);
+    }
+}
+export async function pluginCommand(args, marketplace = new Marketplace()) {
+    const [subcommandRaw, ...rest] = args;
+    const subcommand = (subcommandRaw || 'list').toLowerCase();
+    switch (subcommand) {
+        case 'search': {
+            const query = rest.join(' ').trim();
+            if (!query)
+                return theme.warn('usage: /plugin search <query>\n');
+            return formatPluginList(`Plugin search ${theme.dim(query)}`, await marketplace.search(query));
+        }
+        case 'install': {
+            const name = rest.join(' ').trim();
+            if (!name)
+                return theme.warn('usage: /plugin install <name>\n');
+            const plugin = await marketplace.install(name);
+            return theme.ok(`✔ installed ${plugin.name} ${theme.dim(`v${plugin.version}`)}\n`);
+        }
+        case 'uninstall': {
+            const name = rest.join(' ').trim();
+            if (!name)
+                return theme.warn('usage: /plugin uninstall <name>\n');
+            const plugin = await marketplace.uninstall(name);
+            return theme.ok(`✔ uninstalled ${plugin.name} ${theme.dim(`v${plugin.version}`)}\n`);
+        }
+        case 'update': {
+            const name = rest.join(' ').trim();
+            const updated = await marketplace.update(name || undefined);
+            if (updated.length === 0)
+                return theme.dim('No installed plugins to update.\n');
+            const scope = name ? `Updated ${updated[0].name}` : 'Updated plugins';
+            return formatPluginList(scope, updated);
+        }
+        case 'list':
+            return formatPluginList('Plugins', await marketplace.list());
+        case 'info': {
+            const name = rest.join(' ').trim();
+            if (!name)
+                return theme.warn('usage: /plugin info <name>\n');
+            const plugin = await marketplace.getInfo(name);
+            if (!plugin)
+                return theme.warn(`plugin not found: ${name}\n`);
+            return formatPluginDetails(plugin);
+        }
+        default:
+            return theme.warn('usage: /plugin list|search <query>|install <name>|uninstall <name>|update [name]|info <name>\n');
+    }
+}
+function formatPluginList(title, plugins) {
+    if (plugins.length === 0)
+        return `${theme.brand(title)}\n${theme.dim('  no plugins found')}\n`;
+    const lines = plugins.map((plugin) => `  ${theme.hl(plugin.name)} ${theme.dim(`v${plugin.version}`)} ${plugin.description} ${theme.dim(`(${plugin.author})`)}${plugin.installed ? ` ${theme.ok('[installed]')}` : ''}`);
+    return `${theme.brand(title)}\n${lines.join('\n')}\n`;
+}
+function formatPluginDetails(plugin) {
+    return [
+        `${theme.brand('Plugin')} ${theme.hl(plugin.name)} ${theme.dim(`v${plugin.version}`)}`,
+        `  ${plugin.description}`,
+        `  ${theme.dim('author:')} ${plugin.author}`,
+        `  ${theme.dim('installed:')} ${plugin.installed ? 'yes' : 'no'}`,
+        '',
+    ].join('\n');
+}
+function mergeWithSeed(plugins, seedPlugins) {
+    const merged = new Map();
+    for (const plugin of seedPlugins) {
+        merged.set(plugin.name.toLowerCase(), { ...plugin });
+    }
+    for (const plugin of plugins) {
+        const key = plugin.name.toLowerCase();
+        const base = merged.get(key);
+        merged.set(key, { ...(base ?? {}), ...plugin, installed: plugin.installed });
+    }
+    return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function parseRegistryPlugins(value) {
+    const rawPlugins = Array.isArray(value)
+        ? value
+        : value &&
+            typeof value === 'object' &&
+            Array.isArray(value.plugins)
+            ? value.plugins
+            : [];
+    return dedupePlugins(rawPlugins.filter(isPlugin));
+}
+function dedupePlugins(plugins) {
+    const deduped = new Map();
+    for (const plugin of plugins) {
+        deduped.set(plugin.name.toLowerCase(), normalizePlugin(plugin));
+    }
+    return [...deduped.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function normalizePlugin(plugin) {
+    return {
+        name: plugin.name.trim(),
+        version: plugin.version.trim(),
+        description: plugin.description.trim(),
+        author: plugin.author.trim(),
+        installed: Boolean(plugin.installed),
+    };
+}
+function findPlugin(plugins, name) {
+    const normalizedName = name.trim().toLowerCase();
+    return plugins.find((plugin) => plugin.name.toLowerCase() === normalizedName);
+}
+function isPlugin(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const plugin = value;
+    return (typeof plugin.name === 'string' &&
+        typeof plugin.version === 'string' &&
+        typeof plugin.description === 'string' &&
+        typeof plugin.author === 'string' &&
+        typeof plugin.installed === 'boolean');
+}

package/dist/providers/custom-provider.js

@@ -0,0 +1,298 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import OpenAI from 'openai';
+import { LOCAL_PROVIDER_DEFAULTS } from './local-model.js';
+const DEFAULT_PROVIDER_NAME = 'github';
+let cachedGithubCliToken;
+const BUILTIN_PROVIDERS = [
+    {
+        name: 'github',
+        baseUrl: 'https://models.inference.ai.azure.com',
+        models: [
+            'gpt-4o-mini',
+            'gpt-4.1-mini',
+            'gpt-4.1',
+            'o4-mini',
+            'claude-3.5-sonnet',
+            'Llama-3.3-70B-Instruct',
+        ],
+        defaultModel: 'gpt-4o-mini',
+    },
+    {
+        name: 'openai',
+        baseUrl: 'https://api.openai.com/v1',
+        models: ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'o4-mini'],
+        defaultModel: 'gpt-4o-mini',
+    },
+    {
+        name: 'anthropic',
+        baseUrl: 'https://api.anthropic.com/v1',
+        models: ['claude-3-5-haiku-latest', 'claude-3-5-sonnet-latest', 'claude-3-7-sonnet-latest'],
+        defaultModel: 'claude-3-5-haiku-latest',
+    },
+    {
+        name: 'ollama',
+        baseUrl: LOCAL_PROVIDER_DEFAULTS.ollama.baseUrl,
+        models: [LOCAL_PROVIDER_DEFAULTS.ollama.model],
+        defaultModel: LOCAL_PROVIDER_DEFAULTS.ollama.model,
+    },
+    {
+        name: 'vllm',
+        baseUrl: LOCAL_PROVIDER_DEFAULTS.vllm.baseUrl,
+        models: [LOCAL_PROVIDER_DEFAULTS.vllm.model],
+        defaultModel: LOCAL_PROVIDER_DEFAULTS.vllm.model,
+    },
+    {
+        name: 'lmstudio',
+        baseUrl: LOCAL_PROVIDER_DEFAULTS.lmstudio.baseUrl,
+        models: [LOCAL_PROVIDER_DEFAULTS.lmstudio.model],
+        defaultModel: LOCAL_PROVIDER_DEFAULTS.lmstudio.model,
+    },
+];
+function normalizeName(name) {
+    return name.trim().toLowerCase();
+}
+function trimTrailingSlash(url) {
+    return url.trim().replace(/\/+$/, '');
+}
+function normalizeHeaders(headers) {
+    if (!headers)
+        return undefined;
+    const normalized = Object.fromEntries(Object.entries(headers)
+        .filter((entry) => typeof entry[0] === 'string' && typeof entry[1] === 'string')
+        .map(([key, value]) => [key.trim(), value]));
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+function normalizeModels(models) {
+    return [...new Set(models.map((model) => model.trim()).filter(Boolean))];
+}
+function normalizeProviderConfig(config) {
+    const name = normalizeName(config.name);
+    const baseUrl = trimTrailingSlash(config.baseUrl);
+    const models = normalizeModels(config.models);
+    if (!name)
+        throw new Error('provider name is required');
+    if (!baseUrl)
+        throw new Error(`provider ${name} is missing a baseUrl`);
+    if (!models.length)
+        throw new Error(`provider ${name} must define at least one model`);
+    const defaultModel = config.defaultModel && models.includes(config.defaultModel) ? config.defaultModel : models[0];
+    const maxTokens = typeof config.maxTokens === 'number' &&
+        Number.isFinite(config.maxTokens) &&
+        config.maxTokens > 0
+        ? Math.floor(config.maxTokens)
+        : undefined;
+    return {
+        name,
+        baseUrl,
+        apiKey: typeof config.apiKey === 'string' && config.apiKey.trim() ? config.apiKey : undefined,
+        models,
+        defaultModel,
+        headers: normalizeHeaders(config.headers),
+        maxTokens,
+    };
+}
+export function providerConfigPath() {
+    return (process.env.ICOPILOT_PROVIDERS_PATH || path.join(os.homedir(), '.icopilot', 'providers.json'));
+}
+function resolveGitHubCliToken() {
+    if (cachedGithubCliToken !== undefined)
+        return cachedGithubCliToken || undefined;
+    try {
+        const token = execFileSync('gh', ['auth', 'token'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        cachedGithubCliToken = token || null;
+        return cachedGithubCliToken || undefined;
+    }
+    catch {
+        cachedGithubCliToken = null;
+        return undefined;
+    }
+}
+export function resolveProviderApiKey(provider) {
+    if (provider.apiKey)
+        return provider.apiKey;
+    switch (provider.name) {
+        case 'github':
+            return process.env.GITHUB_TOKEN || process.env.ICOPILOT_TOKEN || resolveGitHubCliToken();
+        case 'openai':
+            return process.env.OPENAI_API_KEY || process.env.ICOPILOT_TOKEN;
+        case 'anthropic':
+            return process.env.ANTHROPIC_API_KEY || process.env.ICOPILOT_TOKEN;
+        case 'ollama':
+        case 'vllm':
+        case 'lmstudio':
+            return process.env.ICOPILOT_LOCAL_API_KEY || process.env.ICOPILOT_TOKEN;
+        default:
+            return process.env.ICOPILOT_TOKEN;
+    }
+}
+export class ProviderRegistry {
+    configPath;
+    builtIns = new Map();
+    customProviders = new Map();
+    clientCache = new Map();
+    openAIClient;
+    activeName = DEFAULT_PROVIDER_NAME;
+    constructor(options = {}) {
+        this.configPath = options.configPath || providerConfigPath();
+        this.openAIClient = options.openAIClient || OpenAI;
+        for (const provider of options.builtIns || BUILTIN_PROVIDERS) {
+            const normalized = normalizeProviderConfig(provider);
+            this.builtIns.set(normalized.name, normalized);
+        }
+        this.load();
+    }
+    register(config) {
+        const normalized = normalizeProviderConfig(config);
+        if (this.builtIns.has(normalized.name)) {
+            throw new Error(`cannot override built-in provider: ${normalized.name}`);
+        }
+        this.customProviders.set(normalized.name, normalized);
+        this.clearClientCache(normalized.name);
+        this.save();
+        return normalized;
+    }
+    remove(name) {
+        const normalizedName = normalizeName(name);
+        if (this.builtIns.has(normalizedName))
+            return false;
+        const deleted = this.customProviders.delete(normalizedName);
+        if (!deleted)
+            return false;
+        if (this.activeName === normalizedName)
+            this.activeName = DEFAULT_PROVIDER_NAME;
+        this.clearClientCache(normalizedName);
+        this.save();
+        return true;
+    }
+    get(name) {
+        const normalizedName = normalizeName(name);
+        return this.customProviders.get(normalizedName) || this.builtIns.get(normalizedName);
+    }
+    list() {
+        return [...this.builtIns.values(), ...this.customProviders.values()].sort((left, right) => left.name.localeCompare(right.name));
+    }
+    getActive() {
+        return this.get(this.activeName) || this.get(DEFAULT_PROVIDER_NAME);
+    }
+    setActive(name) {
+        const provider = this.get(name);
+        if (!provider)
+            throw new Error(`unknown provider: ${name}`);
+        this.activeName = provider.name;
+        this.save();
+        return provider;
+    }
+    createClient(name) {
+        const provider = name ? this.get(name) : this.getActive();
+        if (!provider)
+            throw new Error(`unknown provider: ${name}`);
+        const apiKey = resolveProviderApiKey(provider) || 'not-needed';
+        const cacheKey = JSON.stringify({
+            name: provider.name,
+            baseUrl: provider.baseUrl,
+            apiKey,
+            headers: provider.headers || null,
+        });
+        const cached = this.clientCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const client = new this.openAIClient({
+            apiKey,
+            baseURL: provider.baseUrl,
+            defaultHeaders: provider.headers,
+        });
+        this.clientCache.set(cacheKey, client);
+        return client;
+    }
+    async testProvider(name) {
+        const provider = this.get(name);
+        if (!provider)
+            throw new Error(`unknown provider: ${name}`);
+        const client = this.createClient(provider.name);
+        try {
+            const models = await client.models.list();
+            const modelIds = models.data.map((model) => model.id).filter(Boolean);
+            return { ok: true, provider: provider.name, models: modelIds };
+        }
+        catch (modelError) {
+            const fallbackModel = provider.defaultModel || provider.models[0];
+            if (!fallbackModel) {
+                return {
+                    ok: false,
+                    provider: provider.name,
+                    models: [],
+                    error: stringifyError(modelError),
+                };
+            }
+            try {
+                await client.chat.completions.create({
+                    model: fallbackModel,
+                    messages: [{ role: 'user', content: 'ping' }],
+                    max_tokens: 1,
+                });
+                return { ok: true, provider: provider.name, models: [fallbackModel] };
+            }
+            catch (chatError) {
+                return {
+                    ok: false,
+                    provider: provider.name,
+                    models: [],
+                    error: stringifyError(chatError),
+                };
+            }
+        }
+    }
+    clearClientCache(name) {
+        for (const key of this.clientCache.keys()) {
+            if (key.includes(`"name":"${name}"`)) {
+                this.clientCache.delete(key);
+            }
+        }
+    }
+    load() {
+        if (!fs.existsSync(this.configPath))
+            return;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.configPath, 'utf8'));
+            const providers = Array.isArray(parsed.providers) ? parsed.providers : [];
+            this.customProviders.clear();
+            for (const provider of providers) {
+                try {
+                    const normalized = normalizeProviderConfig(provider);
+                    if (!this.builtIns.has(normalized.name)) {
+                        this.customProviders.set(normalized.name, normalized);
+                    }
+                }
+                catch {
+                    // Ignore invalid provider entries and keep loading the rest.
+                }
+            }
+            const active = typeof parsed.active === 'string' ? normalizeName(parsed.active) : DEFAULT_PROVIDER_NAME;
+            this.activeName = this.get(active)?.name || DEFAULT_PROVIDER_NAME;
+        }
+        catch {
+            this.customProviders.clear();
+            this.activeName = DEFAULT_PROVIDER_NAME;
+        }
+    }
+    save() {
+        const data = {
+            active: this.activeName,
+            providers: [...this.customProviders.values()],
+        };
+        fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+        fs.writeFileSync(this.configPath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    }
+}
+function stringifyError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export const providerRegistry = new ProviderRegistry();