sessioncast-cli 2.2.2 → 2.3.1

package/dist/agent/cdp-client.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const events_1 = require("events");
+const debug_1 = require("./debug");
+/**
+ * Lightweight Chrome DevTools Protocol client.
+ * Uses the existing `ws` package — no additional dependencies.
+ */
+class CdpClient extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.ws = null;
+        this.nextId = 1;
+        this.callbacks = new Map();
+        this.connected = false;
+    }
+    /**
+     * Connect to a Chrome DevTools WebSocket URL.
+     * URL is obtained from Chrome's --remote-debugging-port output.
+     */
+    async connect(browserDebugUrl) {
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(browserDebugUrl);
+            this.ws.on('open', () => {
+                this.connected = true;
+                (0, debug_1.debugLog)('CDP', 'Connected to', browserDebugUrl);
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.id !== undefined) {
+                        // Response to a command
+                        const cb = this.callbacks.get(msg.id);
+                        if (cb) {
+                            this.callbacks.delete(msg.id);
+                            if (msg.error) {
+                                cb.reject(new Error(`CDP error: ${msg.error.message}`));
+                            }
+                            else {
+                                cb.resolve(msg.result);
+                            }
+                        }
+                    }
+                    else if (msg.method) {
+                        // Event notification
+                        this.emit(msg.method, msg.params);
+                    }
+                }
+                catch (e) {
+                    (0, debug_1.debugLog)('CDP', 'Failed to parse message:', e.message);
+                }
+            });
+            this.ws.on('close', () => {
+                this.connected = false;
+                this.emit('close');
+                // Reject all pending callbacks
+                for (const [id, cb] of this.callbacks) {
+                    cb.reject(new Error('CDP connection closed'));
+                    this.callbacks.delete(id);
+                }
+            });
+            this.ws.on('error', (err) => {
+                if (!this.connected) {
+                    reject(err);
+                }
+                this.emit('error', err);
+            });
+        });
+    }
+    /**
+     * Send a CDP command and wait for the response.
+     */
+    async send(method, params) {
+        if (!this.ws || !this.connected) {
+            throw new Error('CDP not connected');
+        }
+        const id = this.nextId++;
+        const message = { id, method };
+        if (params) {
+            message.params = params;
+        }
+        return new Promise((resolve, reject) => {
+            this.callbacks.set(id, { resolve, reject });
+            this.ws.send(JSON.stringify(message), (err) => {
+                if (err) {
+                    this.callbacks.delete(id);
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Check if connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Close the CDP connection.
+     */
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+    }
+}
+exports.CdpClient = CdpClient;

package/dist/agent/chrome-finder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find system Chrome/Chromium binary path.
+ * Returns null if no Chrome installation is found.
+ */
+export declare function findChromePath(): string | null;

package/dist/agent/chrome-finder.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findChromePath = findChromePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+/**
+ * Find system Chrome/Chromium binary path.
+ * Returns null if no Chrome installation is found.
+ */
+function findChromePath() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        const macPaths = [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            path.join(os.homedir(), 'Applications/Google Chrome.app/Contents/MacOS/Google Chrome'),
+        ];
+        for (const p of macPaths) {
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    else if (platform === 'linux') {
+        const linuxNames = [
+            'google-chrome-stable',
+            'google-chrome',
+            'chromium-browser',
+            'chromium',
+        ];
+        for (const name of linuxNames) {
+            try {
+                const result = (0, child_process_1.execSync)(`which ${name}`, { stdio: 'pipe' }).toString().trim();
+                if (result)
+                    return result;
+            }
+            catch { /* not found */ }
+        }
+        // Common Linux paths
+        const linuxPaths = [
+            '/usr/bin/google-chrome-stable',
+            '/usr/bin/google-chrome',
+            '/usr/bin/chromium-browser',
+            '/usr/bin/chromium',
+            '/snap/bin/chromium',
+        ];
+        for (const p of linuxPaths) {
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    else if (platform === 'win32') {
+        const winPaths = [
+            path.join(process.env['PROGRAMFILES'] || '', 'Google/Chrome/Application/chrome.exe'),
+            path.join(process.env['PROGRAMFILES(X86)'] || '', 'Google/Chrome/Application/chrome.exe'),
+            path.join(process.env['LOCALAPPDATA'] || '', 'Google/Chrome/Application/chrome.exe'),
+            path.join(process.env['PROGRAMFILES'] || '', 'Chromium/Application/chrome.exe'),
+        ];
+        for (const p of winPaths) {
+            if (p && fs.existsSync(p))
+                return p;
+        }
+    }
+    return null;
+}

package/dist/agent/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(data: Buffer, key: Buffer): Buffer;
+export declare function decrypt(data: Buffer, key: Buffer): Buffer;

package/dist/agent/crypto.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const crypto_1 = require("crypto");
+const ALGO = 'aes-256-gcm';
+const IV_LEN = 12;
+const TAG_LEN = 16;
+function encrypt(data, key) {
+    const iv = (0, crypto_1.randomBytes)(IV_LEN);
+    const cipher = (0, crypto_1.createCipheriv)(ALGO, key, iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    // Format: [iv(12) | tag(16) | ciphertext]
+    return Buffer.concat([iv, tag, encrypted]);
+}
+function decrypt(data, key) {
+    const iv = data.subarray(0, IV_LEN);
+    const tag = data.subarray(IV_LEN, IV_LEN + TAG_LEN);
+    const ciphertext = data.subarray(IV_LEN + TAG_LEN);
+    const decipher = (0, crypto_1.createDecipheriv)(ALGO, key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}

package/dist/agent/llm-service.d.ts

@@ -1,12 +1,25 @@
 import { LlmConfig, LlmMessage, LlmResponse } from './types';
+export type StreamChunk = {
+    content: string;
+    done: boolean;
+};
 export declare class LlmService {
     private config;
     constructor(config?: LlmConfig);
     chat(model?: string, messages?: LlmMessage[], temperature?: number, maxTokens?: number, stream?: boolean): Promise<LlmResponse>;
+    chatStream(model?: string, messages?: LlmMessage[], temperature?: number, maxTokens?: number, onChunk?: (chunk: StreamChunk) => void): Promise<LlmResponse>;
     private callOllama;
     private convertOllamaToOpenAiFormat;
     private callOpenAi;
     private callAnthropic;
     private callClaudeCode;
+    private callCodex;
+    private callGemini;
+    private convertGeminiToOpenAiFormat;
+    private callCursor;
+    private callClaudeCodeStream;
+    private callOllamaStream;
+    private callOpenAiStream;
+    private callAnthropicStream;
     private convertAnthropicToOpenAiFormat;
 }