icopilot 2.2.0

package/dist/extensions/slack-provider.js

@@ -0,0 +1,181 @@
+import { randomUUID } from 'node:crypto';
+export class SlackNotificationFormatter {
+    formatText(message) {
+        return {
+            type: 'section',
+            text: {
+                type: 'mrkdwn',
+                text: message,
+            },
+        };
+    }
+    formatApprovalRequest(action, details) {
+        const blocks = [
+            {
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: `🔐 *Approval Request* (ID: ${details.id || 'unknown'})`,
+                },
+            },
+            {
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: `*Action:* ${action}\n*Description:* ${details.description || 'N/A'}`,
+                },
+            },
+            {
+                type: 'actions',
+                elements: [
+                    {
+                        type: 'button',
+                        text: { type: 'plain_text', text: 'Approve' },
+                        value: `approve-${details.id}`,
+                        action_id: `approve-${details.id}`,
+                        style: 'primary',
+                    },
+                    {
+                        type: 'button',
+                        text: { type: 'plain_text', text: 'Deny' },
+                        value: `deny-${details.id}`,
+                        action_id: `deny-${details.id}`,
+                        style: 'danger',
+                    },
+                ],
+            },
+        ];
+        if (details.timeout && typeof details.timeout === 'number') {
+            const seconds = Math.ceil(details.timeout / 1000);
+            blocks.push({
+                type: 'context',
+                elements: [
+                    {
+                        type: 'mrkdwn',
+                        text: `⏱️ Response required within ${seconds}s`,
+                    },
+                ],
+            });
+        }
+        return { blocks };
+    }
+    formatError(error) {
+        return {
+            type: 'section',
+            text: {
+                type: 'mrkdwn',
+                text: `⚠️ *Error:* ${error}`,
+            },
+        };
+    }
+}
+export class SlackNotificationHandler {
+    token;
+    channel;
+    apiUrl = 'https://slack.com/api';
+    formatter = new SlackNotificationFormatter();
+    pendingApprovals = new Map();
+    webhookHandlers = new Map();
+    _connected = false;
+    constructor(token, channel) {
+        this.token = token;
+        this.channel = channel;
+    }
+    async notify(channel, message, metadata) {
+        const block = this.formatter.formatText(message);
+        const payload = {
+            channel,
+            blocks: [block],
+        };
+        if (metadata?.threadTs && typeof metadata.threadTs === 'string') {
+            payload.thread_ts = metadata.threadTs;
+        }
+        await this.callSlackApi('chat.postMessage', payload);
+    }
+    async requestApproval(channel, action, details) {
+        const id = randomUUID();
+        const timeout = details.timeout ?? 5 * 60 * 1000;
+        const formattedDetails = {
+            id,
+            description: details.description || 'Manual approval required',
+        };
+        if (timeout) {
+            formattedDetails.timeout = timeout;
+        }
+        const formatted = this.formatter.formatApprovalRequest(action, formattedDetails);
+        const payload = {
+            channel,
+            ...formatted,
+        };
+        await this.callSlackApi('chat.postMessage', payload);
+        return new Promise((resolve) => {
+            const timeoutHandle = setTimeout(() => {
+                this.pendingApprovals.delete(id);
+                resolve({ approved: false });
+            }, timeout);
+            const approval = {
+                id,
+                action,
+                timeout: timeoutHandle,
+                resolve,
+            };
+            this.pendingApprovals.set(id, approval);
+        });
+    }
+    async getStatus() {
+        try {
+            const result = await this.callSlackApi('auth.test', {});
+            this._connected = result.ok === true;
+            return { connected: this._connected };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { connected: false, error: msg };
+        }
+    }
+    registerWebhook(url) {
+        process.env.ICOPILOT_SLACK_WEBHOOK_URL = url;
+    }
+    handleWebhookEvent(payload) {
+        const action = payload.actions;
+        if (!Array.isArray(action) || !action[0])
+            return;
+        const firstAction = action[0];
+        const actionId = firstAction.action_id;
+        if (!actionId || (!actionId.startsWith('approve-') && !actionId.startsWith('deny-')))
+            return;
+        const approved = actionId.startsWith('approve-');
+        const id = actionId.split('-')[1];
+        const pending = this.pendingApprovals.get(id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingApprovals.delete(id);
+        const user = payload.user?.id;
+        pending.resolve({
+            approved,
+            approver: user,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    async callSlackApi(method, payload) {
+        const url = `${this.apiUrl}/${method}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Slack API error: ${response.status} ${response.statusText}`);
+        }
+        const result = (await response.json());
+        if (result.ok !== true) {
+            const error = result.error;
+            throw new Error(`Slack API error: ${error || 'unknown'}`);
+        }
+        return result;
+    }
+}

package/dist/extensions/team.js

@@ -0,0 +1,56 @@
+export const noopTeamTransport = {
+    async connect() {
+        throw new Error('Team mode transport not configured. See docs/future.md.');
+    },
+    async send() {
+        /* no-op */
+    },
+    on() {
+        /* no-op */
+    },
+    async disconnect() {
+        /* no-op */
+    },
+};
+const noopNotificationHandler = {
+    async notify() {
+        /* no-op */
+    },
+    async requestApproval() {
+        return { approved: false };
+    },
+    async getStatus() {
+        return { connected: false, error: 'Notifications not configured' };
+    },
+};
+let _transport = noopTeamTransport;
+let _notificationHandler = noopNotificationHandler;
+export function registerTeamTransport(t) {
+    _transport = t;
+}
+export function getTeamTransport() {
+    return _transport;
+}
+export function registerNotificationHandler(handler) {
+    _notificationHandler = handler;
+}
+export function getNotificationHandler() {
+    return _notificationHandler;
+}
+export function isTeamConfigured(config) {
+    return config != null && Boolean(config.token && config.channel);
+}
+export function getTeamConfig(env) {
+    const e = env || process.env;
+    const provider = e.ICOPILOT_NOTIFICATIONS_PROVIDER;
+    const token = e.ICOPILOT_NOTIFICATIONS_TOKEN;
+    const channel = e.ICOPILOT_NOTIFICATIONS_CHANNEL;
+    if (!provider || !token || !channel)
+        return null;
+    return {
+        provider,
+        token,
+        channel,
+        autoApprove: e.ICOPILOT_NOTIFICATIONS_AUTO_APPROVE?.split(',').filter(Boolean),
+    };
+}

package/dist/extensions/teams-provider.js

@@ -0,0 +1,222 @@
+import { randomUUID } from 'node:crypto';
+export class TeamsNotificationFormatter {
+    formatText(message) {
+        return {
+            type: 'AdaptiveCard',
+            body: [
+                {
+                    type: 'TextBlock',
+                    text: message,
+                    wrap: true,
+                    spacing: 'Large',
+                },
+            ],
+        };
+    }
+    formatApprovalRequest(action, details) {
+        const card = {
+            type: 'AdaptiveCard',
+            body: [
+                {
+                    type: 'TextBlock',
+                    text: '🔐 Approval Request',
+                    weight: 'bolder',
+                    size: 'large',
+                },
+                {
+                    type: 'FactSet',
+                    facts: [
+                        {
+                            name: 'Action',
+                            value: action,
+                        },
+                        {
+                            name: 'Description',
+                            value: details.description || 'N/A',
+                        },
+                        {
+                            name: 'ID',
+                            value: details.id || 'unknown',
+                        },
+                    ],
+                },
+            ],
+            actions: [
+                {
+                    type: 'Action.OpenUrl',
+                    title: 'Approve',
+                    url: `${details.approveUrl || ''}`,
+                    style: 'positive',
+                },
+                {
+                    type: 'Action.OpenUrl',
+                    title: 'Deny',
+                    url: `${details.denyUrl || ''}`,
+                    style: 'destructive',
+                },
+            ],
+        };
+        if (details.timeout && typeof details.timeout === 'number') {
+            const seconds = Math.ceil(details.timeout / 1000);
+            card.body.push({
+                type: 'TextBlock',
+                text: `⏱️ Response required within ${seconds}s`,
+                spacing: 'Large',
+                color: 'warning',
+            });
+        }
+        return card;
+    }
+    formatError(error) {
+        return {
+            type: 'AdaptiveCard',
+            body: [
+                {
+                    type: 'TextBlock',
+                    text: `⚠️ Error: ${error}`,
+                    wrap: true,
+                    color: 'attention',
+                    weight: 'bolder',
+                },
+            ],
+        };
+    }
+}
+export class TeamsNotificationHandler {
+    appId;
+    appPassword;
+    channelId;
+    formatter = new TeamsNotificationFormatter();
+    pendingApprovals = new Map();
+    _connected = false;
+    constructor(appId, appPassword, channelId) {
+        this.appId = appId;
+        this.appPassword = appPassword;
+        this.channelId = channelId;
+    }
+    async notify(channel, message, metadata) {
+        const card = this.formatter.formatText(message);
+        const payload = {
+            type: 'message',
+            from: { id: this.appId },
+            conversation: { id: channel },
+            attachments: [
+                {
+                    contentType: 'application/vnd.microsoft.card.adaptive',
+                    content: card,
+                },
+            ],
+        };
+        if (metadata?.replyToId && typeof metadata.replyToId === 'string') {
+            payload.replyToId = metadata.replyToId;
+        }
+        await this.callTeamsApi(channel, payload);
+    }
+    async requestApproval(channel, action, details) {
+        const id = randomUUID();
+        const timeout = details.timeout ?? 5 * 60 * 1000;
+        const webhookUrl = process.env.ICOPILOT_TEAMS_WEBHOOK_URL || '';
+        const baseUrl = webhookUrl.split('/connectors/')[0];
+        const formattedDetails = {
+            id,
+            description: details.description || 'Manual approval required',
+            approveUrl: `${baseUrl}/approve?id=${id}`,
+            denyUrl: `${baseUrl}/deny?id=${id}`,
+        };
+        if (timeout) {
+            formattedDetails.timeout = timeout;
+        }
+        const card = this.formatter.formatApprovalRequest(action, formattedDetails);
+        const payload = {
+            type: 'message',
+            from: { id: this.appId },
+            conversation: { id: channel },
+            attachments: [
+                {
+                    contentType: 'application/vnd.microsoft.card.adaptive',
+                    content: card,
+                },
+            ],
+        };
+        await this.callTeamsApi(channel, payload);
+        return new Promise((resolve) => {
+            const timeoutHandle = setTimeout(() => {
+                this.pendingApprovals.delete(id);
+                resolve({ approved: false });
+            }, timeout);
+            const approval = {
+                id,
+                action,
+                timeout: timeoutHandle,
+                resolve,
+            };
+            this.pendingApprovals.set(id, approval);
+        });
+    }
+    async getStatus() {
+        try {
+            const token = await this.getAccessToken();
+            if (!token) {
+                return { connected: false, error: 'Failed to obtain access token' };
+            }
+            this._connected = true;
+            return { connected: true };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { connected: false, error: msg };
+        }
+    }
+    registerWebhook(url) {
+        process.env.ICOPILOT_TEAMS_WEBHOOK_URL = url;
+    }
+    handleApprovalResponse(id, approved, userId) {
+        const pending = this.pendingApprovals.get(id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingApprovals.delete(id);
+        pending.resolve({
+            approved,
+            approver: userId,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    async getAccessToken() {
+        const url = 'https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token';
+        const params = new URLSearchParams({
+            client_id: this.appId,
+            client_secret: this.appPassword,
+            grant_type: 'client_credentials',
+            scope: 'https://api.botframework.com/.default',
+        });
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            throw new Error(`Teams auth error: ${response.status}`);
+        }
+        const data = (await response.json());
+        const token = data.access_token;
+        if (!token)
+            throw new Error('No access token in response');
+        return token;
+    }
+    async callTeamsApi(channel, payload) {
+        const token = await this.getAccessToken();
+        const response = await fetch(`https://smba.trafficmanager.net/apis/v3/conversations/${channel}/activities`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Teams API error: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+}

package/dist/extensions/voice.js

@@ -0,0 +1,18 @@
+export const noopSpeechProvider = {
+    async transcribe() {
+        throw new Error('Voice input not configured. Install a speech provider plugin (e.g., openai-whisper) with `/plugin install openai-whisper`.');
+    },
+    isConfigured() {
+        return false;
+    },
+};
+let _provider = noopSpeechProvider;
+export function registerSpeechProvider(p) {
+    _provider = p;
+}
+export function getSpeechProvider() {
+    return _provider;
+}
+export function isVoiceInputConfigured() {
+    return _provider.isConfigured();
+}

package/dist/hooks/lifecycle.js

@@ -0,0 +1,215 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+/**
+ * Loads lifecycle hook definitions and executes matching hooks for emitted events.
+ */
+export class HookManager {
+    hooks = [];
+    projectDir = process.cwd();
+    homeDir;
+    spawnFn;
+    constructor(options = {}) {
+        const defaultSpawn = (command, args, spawnOptions) => (spawnOptions
+            ? spawn(command, args ?? [], spawnOptions)
+            : spawn(command, args ?? []));
+        this.homeDir = options.homeDir ?? os.homedir();
+        this.spawnFn = options.spawnFn ?? defaultSpawn;
+    }
+    /**
+     * Load hooks from the global ~/.icopilot/hooks.json file and the project-local
+     * .icopilot/hooks.json file. Project hooks are applied after global hooks.
+     */
+    async loadHooks(projectDir) {
+        this.projectDir = projectDir;
+        const files = [
+            path.join(this.homeDir, '.icopilot', 'hooks.json'),
+            path.join(projectDir, '.icopilot', 'hooks.json'),
+        ];
+        this.hooks = files.flatMap((filePath) => this.readHookFile(filePath));
+    }
+    /**
+     * Replace the active hook set. Intended for tests and in-memory scenarios.
+     */
+    replaceHooks(hooks, projectDir = this.projectDir) {
+        this.projectDir = projectDir;
+        this.hooks = hooks.map((hook) => normalizeHookConfig(hook)).filter(isHookConfig);
+    }
+    /**
+     * Return the currently loaded hook definitions.
+     */
+    getHooks() {
+        return this.hooks.map((hook) => ({ ...hook }));
+    }
+    /**
+     * Emit a lifecycle event. The payload is written to each hook's stdin as JSON.
+     * Hooks may deny the event, or modify the payload passed to later hooks.
+     */
+    async emit(event, payload) {
+        const candidates = this.hooks.filter((hook) => hook.event === event);
+        if (!candidates.length)
+            return { action: 'continue' };
+        let activePayload = toRecord(payload);
+        let finalModifications;
+        let finalReason;
+        for (const hook of candidates) {
+            const result = await this.runHook(hook, activePayload);
+            if (result.reason)
+                finalReason = result.reason;
+            if (result.action === 'deny') {
+                return {
+                    action: 'deny',
+                    reason: result.reason ?? `hook denied ${event}`,
+                    modifications: result.modifications,
+                };
+            }
+            if (result.action === 'modify' && result.modifications) {
+                const normalized = toRecord(result.modifications);
+                activePayload = { ...activePayload, ...normalized };
+                finalModifications = { ...(finalModifications ?? {}), ...normalized };
+            }
+        }
+        if (finalModifications && Object.keys(finalModifications).length > 0) {
+            return { action: 'modify', reason: finalReason, modifications: finalModifications };
+        }
+        return { action: 'continue', reason: finalReason };
+    }
+    readHookFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath))
+                return [];
+            const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.hooks))
+                return [];
+            return parsed.hooks.map((hook) => normalizeHookConfig(hook)).filter(isHookConfig);
+        }
+        catch {
+            return [];
+        }
+    }
+    runHook(hook, payload) {
+        return new Promise((resolve) => {
+            const child = this.spawnFn(hook.command, [], {
+                cwd: this.projectDir,
+                shell: true,
+                windowsHide: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            let settled = false;
+            const timeoutMs = hook.timeout ?? 5_000;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                try {
+                    child.kill();
+                }
+                catch {
+                    /* ignore */
+                }
+                resolve({
+                    action: 'continue',
+                    reason: `hook timed out after ${timeoutMs}ms: ${hook.command}`,
+                });
+            }, timeoutMs);
+            child.stdout?.on('data', (chunk) => {
+                stdout += String(chunk);
+            });
+            child.stderr?.on('data', (chunk) => {
+                stderr += String(chunk);
+            });
+            child.on('error', (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve({
+                    action: 'continue',
+                    reason: `hook failed: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            });
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(parseHookOutput(stdout, stderr, code, hook.command));
+            });
+            child.stdin?.write(JSON.stringify(payload));
+            child.stdin?.end();
+        });
+    }
+}
+/**
+ * Shared lifecycle hook manager for the active CLI process.
+ */
+export const hookManager = new HookManager();
+/**
+ * Load lifecycle hooks for the active project directory.
+ */
+export async function initializeLifecycleHooks(projectDir) {
+    await hookManager.loadHooks(projectDir);
+}
+function normalizeHookConfig(input) {
+    const candidate = input && typeof input === 'object' ? input : {};
+    return {
+        event: candidate.event,
+        command: typeof candidate.command === 'string' ? candidate.command : '',
+        timeout: typeof candidate.timeout === 'number' ? candidate.timeout : undefined,
+    };
+}
+function isHookConfig(hook) {
+    return (isHookEvent(hook.event) &&
+        typeof hook.command === 'string' &&
+        hook.command.trim().length > 0 &&
+        (hook.timeout === undefined || (Number.isFinite(hook.timeout) && hook.timeout > 0)));
+}
+function isHookEvent(value) {
+    return (value === 'sessionStart' ||
+        value === 'sessionEnd' ||
+        value === 'userPromptSubmit' ||
+        value === 'preToolUse' ||
+        value === 'postToolUse' ||
+        value === 'fileChanged' ||
+        value === 'cwdChanged' ||
+        value === 'preCompact' ||
+        value === 'postCompact' ||
+        value === 'errorOccurred');
+}
+function parseHookOutput(stdout, stderr, code, command) {
+    const trimmed = stdout.trim();
+    if (trimmed) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.action === 'continue' || parsed.action === 'deny' || parsed.action === 'modify') {
+                return {
+                    action: parsed.action,
+                    reason: typeof parsed.reason === 'string' ? parsed.reason : undefined,
+                    modifications: parsed.modifications && typeof parsed.modifications === 'object'
+                        ? parsed.modifications
+                        : undefined,
+                };
+            }
+        }
+        catch {
+            return { action: 'continue', reason: trimmed };
+        }
+    }
+    const stderrText = stderr.trim();
+    if (stderrText || code) {
+        return {
+            action: 'continue',
+            reason: stderrText || `hook exited with code ${String(code)}: ${command}`,
+        };
+    }
+    return { action: 'continue' };
+}
+function toRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return { ...value };
+    }
+    return {};
+}