icopilot 2.2.0

package/dist/bridge/ide-bridge.js

@@ -0,0 +1,479 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { createServer } from 'node:http';
+import net from 'node:net';
+const WEBSOCKET_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+const DEFAULT_HOST = '127.0.0.1';
+export const DEFAULT_BRIDGE_PORT = 7891;
+export class IDEBridge {
+    handlers = new Set();
+    createTransport;
+    transport = null;
+    cleanupTransport = [];
+    port = null;
+    constructor(options = {}) {
+        this.createTransport = options.createTransport ?? createClientTransport;
+    }
+    async connect(port = DEFAULT_BRIDGE_PORT) {
+        if (this.transport && this.transport.isOpen() && this.port === port)
+            return;
+        await this.disconnect();
+        const transport = await this.createTransport(port);
+        this.transport = transport;
+        this.port = port;
+        this.cleanupTransport = [
+            transport.onMessage((raw) => {
+                const message = parseBridgeMessage(raw);
+                if (!message)
+                    return;
+                for (const handler of this.handlers)
+                    handler(message);
+            }),
+            transport.onClose(() => {
+                this.transport = null;
+            }),
+        ];
+    }
+    async disconnect() {
+        const transport = this.transport;
+        this.transport = null;
+        this.port = null;
+        for (const cleanup of this.cleanupTransport.splice(0))
+            cleanup();
+        if (!transport)
+            return;
+        transport.close();
+    }
+    send(message) {
+        if (!this.transport || !this.transport.isOpen()) {
+            throw new Error('IDE bridge is not connected.');
+        }
+        this.transport.send(JSON.stringify(message));
+    }
+    onMessage(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    isConnected() {
+        return Boolean(this.transport?.isOpen());
+    }
+    getPort() {
+        return this.port;
+    }
+}
+export class BridgeServer {
+    handlers = new Set();
+    heartbeatMs;
+    server = null;
+    heartbeatTimer = null;
+    connections = new Set();
+    port = null;
+    constructor(options = {}) {
+        this.heartbeatMs = options.heartbeatMs ?? 30_000;
+    }
+    async start(port = DEFAULT_BRIDGE_PORT) {
+        if (this.server && this.port === port)
+            return this.port;
+        if (this.server)
+            await this.stop();
+        const server = createServer((_request, response) => {
+            response.statusCode = 426;
+            response.setHeader('Connection', 'close');
+            response.end('Upgrade Required');
+        });
+        server.on('upgrade', (request, socket, head) => {
+            if (!isWebSocketUpgrade(request)) {
+                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            const key = request.headers['sec-websocket-key'];
+            if (typeof key !== 'string' || !key.trim()) {
+                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            const accept = createHash('sha1').update(`${key}${WEBSOCKET_GUID}`).digest('base64');
+            socket.write([
+                'HTTP/1.1 101 Switching Protocols',
+                'Upgrade: websocket',
+                'Connection: Upgrade',
+                `Sec-WebSocket-Accept: ${accept}`,
+                '\r\n',
+            ].join('\r\n'));
+            const connection = new RawWebSocketConnection(socket, false, head);
+            this.connections.add(connection);
+            connection.onMessage((raw) => {
+                const message = parseBridgeMessage(raw);
+                if (!message)
+                    return;
+                for (const handler of this.handlers)
+                    handler(message);
+            });
+            connection.onClose(() => {
+                this.connections.delete(connection);
+            });
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                server.off('error', onError);
+                reject(error);
+            };
+            server.once('error', onError);
+            server.listen(port, DEFAULT_HOST, () => {
+                server.off('error', onError);
+                resolve();
+            });
+        });
+        this.server = server;
+        this.port = server.address()?.port ?? port;
+        this.startHeartbeat();
+        return this.port;
+    }
+    async stop() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        for (const connection of this.connections) {
+            connection.close();
+            connection.terminate();
+        }
+        this.connections.clear();
+        const server = this.server;
+        this.server = null;
+        this.port = null;
+        if (!server)
+            return;
+        await new Promise((resolve, reject) => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    broadcast(message) {
+        const payload = JSON.stringify(message);
+        for (const connection of this.connections) {
+            connection.sendText(payload);
+        }
+    }
+    onMessage(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    isRunning() {
+        return this.server !== null;
+    }
+    getPort() {
+        return this.port;
+    }
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    startHeartbeat() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => {
+            for (const connection of this.connections) {
+                if (!connection.beginHeartbeat()) {
+                    connection.terminate();
+                    this.connections.delete(connection);
+                    continue;
+                }
+                connection.sendPing();
+            }
+        }, this.heartbeatMs);
+        this.heartbeatTimer.unref();
+    }
+}
+class RawWebSocketConnection extends EventEmitter {
+    socket;
+    maskOutgoing;
+    buffer = Buffer.alloc(0);
+    open = true;
+    alive = true;
+    closeSent = false;
+    constructor(socket, maskOutgoing, initialData) {
+        super();
+        this.socket = socket;
+        this.maskOutgoing = maskOutgoing;
+        socket.on('data', (chunk) => {
+            this.alive = true;
+            this.buffer = Buffer.concat([this.buffer, Buffer.from(chunk)]);
+            this.drainBuffer();
+        });
+        socket.on('close', () => {
+            this.handleClose();
+        });
+        socket.on('end', () => {
+            this.handleClose();
+        });
+        socket.on('error', () => {
+            this.handleClose();
+        });
+        if (initialData && initialData.length > 0) {
+            this.buffer = Buffer.concat([this.buffer, Buffer.from(initialData)]);
+            this.drainBuffer();
+        }
+    }
+    onMessage(handler) {
+        this.on('message', handler);
+    }
+    onClose(handler) {
+        this.on('close-connection', handler);
+    }
+    sendText(data) {
+        this.writeFrame(0x1, Buffer.from(data, 'utf8'));
+    }
+    sendPing(payload = Buffer.alloc(0)) {
+        this.writeFrame(0x9, payload);
+    }
+    sendPong(payload = Buffer.alloc(0)) {
+        this.writeFrame(0xa, payload);
+    }
+    beginHeartbeat() {
+        const wasAlive = this.alive;
+        this.alive = false;
+        return wasAlive;
+    }
+    close(code = 1000, reason = '') {
+        if (this.closeSent)
+            return;
+        const reasonBuffer = Buffer.from(reason, 'utf8');
+        const payload = Buffer.allocUnsafe(2 + reasonBuffer.length);
+        payload.writeUInt16BE(code, 0);
+        reasonBuffer.copy(payload, 2);
+        this.closeSent = true;
+        this.writeFrame(0x8, payload);
+    }
+    terminate() {
+        if (!this.open)
+            return;
+        this.open = false;
+        this.socket.destroy();
+    }
+    handleClose() {
+        if (!this.open)
+            return;
+        this.open = false;
+        this.emit('close-connection');
+    }
+    drainBuffer() {
+        while (this.buffer.length >= 2) {
+            const firstByte = this.buffer[0];
+            const secondByte = this.buffer[1];
+            const opcode = firstByte & 0x0f;
+            const masked = (secondByte & 0x80) !== 0;
+            let payloadLength = secondByte & 0x7f;
+            let offset = 2;
+            if (payloadLength === 126) {
+                if (this.buffer.length < offset + 2)
+                    return;
+                payloadLength = this.buffer.readUInt16BE(offset);
+                offset += 2;
+            }
+            else if (payloadLength === 127) {
+                if (this.buffer.length < offset + 8)
+                    return;
+                const rawLength = this.buffer.readBigUInt64BE(offset);
+                if (rawLength > BigInt(Number.MAX_SAFE_INTEGER)) {
+                    this.terminate();
+                    return;
+                }
+                payloadLength = Number(rawLength);
+                offset += 8;
+            }
+            const maskLength = masked ? 4 : 0;
+            const frameLength = offset + maskLength + payloadLength;
+            if (this.buffer.length < frameLength)
+                return;
+            let mask;
+            if (masked) {
+                mask = this.buffer.subarray(offset, offset + 4);
+                offset += 4;
+            }
+            const payload = Buffer.from(this.buffer.subarray(offset, offset + payloadLength));
+            this.buffer = this.buffer.subarray(frameLength);
+            if (mask) {
+                for (let index = 0; index < payload.length; index += 1) {
+                    payload[index] ^= mask[index % 4];
+                }
+            }
+            if (opcode === 0x1) {
+                this.emit('message', payload.toString('utf8'));
+                continue;
+            }
+            if (opcode === 0x8) {
+                if (!this.closeSent) {
+                    this.closeSent = true;
+                    this.writeFrame(0x8, payload);
+                }
+                this.socket.end();
+                continue;
+            }
+            if (opcode === 0x9) {
+                this.sendPong(payload);
+                continue;
+            }
+            if (opcode === 0xa) {
+                this.alive = true;
+            }
+        }
+    }
+    writeFrame(opcode, payload) {
+        if (!this.open || this.socket.destroyed)
+            return;
+        const headerLength = 2 +
+            (payload.length < 126 ? 0 : payload.length < 65_536 ? 2 : 8) +
+            (this.maskOutgoing ? 4 : 0);
+        const frame = Buffer.allocUnsafe(headerLength + payload.length);
+        let offset = 0;
+        frame[offset] = 0x80 | (opcode & 0x0f);
+        offset += 1;
+        const lengthByteOffset = offset;
+        if (payload.length < 126) {
+            frame[offset] = payload.length;
+            offset += 1;
+        }
+        else if (payload.length < 65_536) {
+            frame[offset] = 126;
+            offset += 1;
+            frame.writeUInt16BE(payload.length, offset);
+            offset += 2;
+        }
+        else {
+            frame[offset] = 127;
+            offset += 1;
+            frame.writeBigUInt64BE(BigInt(payload.length), offset);
+            offset += 8;
+        }
+        if (this.maskOutgoing) {
+            const mask = randomBytes(4);
+            frame[lengthByteOffset] |= 0x80;
+            mask.copy(frame, offset);
+            offset += 4;
+            for (let index = 0; index < payload.length; index += 1) {
+                frame[offset + index] = payload[index] ^ mask[index % 4];
+            }
+            this.socket.write(frame);
+            return;
+        }
+        payload.copy(frame, offset);
+        this.socket.write(frame);
+    }
+}
+async function createClientTransport(port) {
+    const socket = net.createConnection({ host: DEFAULT_HOST, port });
+    const key = randomBytes(16).toString('base64');
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let handshakeBuffer = Buffer.alloc(0);
+        let connection = null;
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            reject(error);
+        };
+        socket.once('error', fail);
+        socket.once('connect', () => {
+            socket.write([
+                'GET / HTTP/1.1',
+                `Host: ${DEFAULT_HOST}:${port}`,
+                'Upgrade: websocket',
+                'Connection: Upgrade',
+                `Sec-WebSocket-Key: ${key}`,
+                'Sec-WebSocket-Version: 13',
+                '\r\n',
+            ].join('\r\n'));
+        });
+        socket.on('data', (chunk) => {
+            if (settled)
+                return;
+            handshakeBuffer = Buffer.concat([handshakeBuffer, Buffer.from(chunk)]);
+            const headerEnd = handshakeBuffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                return;
+            const headerText = handshakeBuffer.subarray(0, headerEnd).toString('utf8');
+            const expectedAccept = createHash('sha1').update(`${key}${WEBSOCKET_GUID}`).digest('base64');
+            if (!headerText.startsWith('HTTP/1.1 101') ||
+                !headerText.toLowerCase().includes(`sec-websocket-accept: ${expectedAccept.toLowerCase()}`)) {
+                fail(new Error(`WebSocket handshake failed on port ${port}.`));
+                return;
+            }
+            settled = true;
+            socket.removeListener('error', fail);
+            socket.removeAllListeners('data');
+            connection = new RawWebSocketConnection(socket, true, handshakeBuffer.subarray(headerEnd + 4));
+            resolve({
+                send(data) {
+                    connection?.sendText(data);
+                },
+                close(code, reason) {
+                    connection?.close(code, reason);
+                    connection?.terminate();
+                },
+                onMessage(handler) {
+                    const listener = (data) => handler(data);
+                    connection?.on('message', listener);
+                    return () => {
+                        connection?.off('message', listener);
+                    };
+                },
+                onClose(handler) {
+                    const listener = () => handler();
+                    connection?.on('close-connection', listener);
+                    return () => {
+                        connection?.off('close-connection', listener);
+                    };
+                },
+                isOpen() {
+                    return socket.readyState === 'open';
+                },
+            });
+        });
+        socket.once('close', () => {
+            if (!settled)
+                fail(new Error(`Unable to connect to IDE bridge on port ${port}.`));
+        });
+    });
+}
+function isWebSocketUpgrade(request) {
+    const upgrade = request.headers.upgrade;
+    const connection = request.headers.connection;
+    return (typeof upgrade === 'string' &&
+        upgrade.toLowerCase() === 'websocket' &&
+        typeof connection === 'string' &&
+        connection
+            .toLowerCase()
+            .split(',')
+            .some((value) => value.trim() === 'upgrade'));
+}
+function parseBridgeMessage(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        if (parsed.type !== 'openFile' &&
+            parsed.type !== 'editFile' &&
+            parsed.type !== 'showDiff' &&
+            parsed.type !== 'navigate' &&
+            parsed.type !== 'diagnostic' &&
+            parsed.type !== 'status') {
+            return null;
+        }
+        return { type: parsed.type, payload: parsed.payload };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cloud/routine-executor.js

@@ -0,0 +1,34 @@
+import { streamChat } from '../api/github-models.js';
+import { Session } from '../session/session.js';
+export class CloudRoutineExecutor {
+    async execute(routine) {
+        const session = new Session({ mode: 'ask' });
+        await session.initializeGitContext();
+        const messages = [
+            {
+                role: 'user',
+                content: routine.prompt,
+            },
+        ];
+        let output = '';
+        const result = await streamChat({
+            model: session.state.model,
+            messages,
+            onToken: (token) => {
+                output += token;
+            },
+        });
+        session.push({
+            role: 'user',
+            content: routine.prompt,
+        });
+        session.push({
+            role: 'assistant',
+            content: result.content || output,
+        });
+    }
+}
+export function createCloudRoutineExecutor() {
+    const executor = new CloudRoutineExecutor();
+    return (routine) => executor.execute(routine);
+}

package/dist/cloud/routine-scheduler.js

@@ -0,0 +1,67 @@
+import { CloudRoutineStore } from './routine-storage.js';
+export class CloudRoutineScheduler {
+    store;
+    executor = null;
+    pollingInterval;
+    intervalHandle = null;
+    isRunning = false;
+    constructor(pollingInterval = 60000) {
+        this.store = new CloudRoutineStore();
+        this.pollingInterval = pollingInterval;
+    }
+    setExecutor(executor) {
+        this.executor = executor;
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.scheduleNextCheck();
+    }
+    stop() {
+        this.isRunning = false;
+        if (this.intervalHandle) {
+            clearTimeout(this.intervalHandle);
+            this.intervalHandle = null;
+        }
+    }
+    scheduleNextCheck() {
+        if (!this.isRunning)
+            return;
+        this.intervalHandle = setTimeout(() => {
+            void this.executeDue();
+            this.scheduleNextCheck();
+        }, this.pollingInterval);
+    }
+    async executeDue() {
+        if (!this.executor)
+            return;
+        const dueRoutines = this.store.findDueRoutines();
+        for (const routine of dueRoutines) {
+            try {
+                const startTime = Date.now();
+                await this.executor(routine);
+                const duration = Date.now() - startTime;
+                this.store.logExecution(routine.id, 'success', undefined, undefined, duration);
+                this.store.updateLastRun(routine.id, new Date().toISOString());
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                this.store.logExecution(routine.id, 'error', undefined, error, 0);
+            }
+        }
+    }
+    getStore() {
+        return this.store;
+    }
+    isSchedulerRunning() {
+        return this.isRunning;
+    }
+}
+let schedulerInstance = null;
+export function getCloudRoutineScheduler() {
+    if (!schedulerInstance) {
+        schedulerInstance = new CloudRoutineScheduler();
+    }
+    return schedulerInstance;
+}