@qodercn-ai/qoderclicn 0.1.0

package/bundle/node_modules/@google/gemini-cli-devtools/dist/src/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { EventEmitter } from 'node:events';
+import { type WebSocket } from 'ws';
+import type { NetworkLog, ConsoleLogPayload } from './types.js';
+export type { NetworkLog, ConsoleLogPayload, InspectorConsoleLog, } from './types.js';
+interface IncomingNetworkPayload extends Partial<NetworkLog> {
+    chunk?: {
+        index: number;
+        data: string;
+        timestamp: number;
+    };
+}
+export interface SessionInfo {
+    sessionId: string;
+    ws: WebSocket;
+    lastPing: number;
+}
+/**
+ * DevTools Viewer
+ *
+ * Receives logs via WebSocket from CLI sessions.
+ */
+export declare class DevTools extends EventEmitter {
+    private static instance;
+    private logs;
+    private consoleLogs;
+    private server;
+    private wss;
+    private sessions;
+    private heartbeatTimer;
+    private port;
+    private static readonly DEFAULT_PORT;
+    private static readonly MAX_PORT_RETRIES;
+    private constructor();
+    static getInstance(): DevTools;
+    addInternalConsoleLog(payload: ConsoleLogPayload, sessionId?: string, timestamp?: number): void;
+    addInternalNetworkLog(payload: IncomingNetworkPayload, sessionId?: string, timestamp?: number): void;
+    getUrl(): string;
+    getPort(): number;
+    stop(): Promise<void>;
+    start(): Promise<string>;
+    private setupWebSocketServer;
+    private handleWebSocketMessage;
+}

package/bundle/node_modules/@google/gemini-cli-devtools/dist/src/index.js

@@ -0,0 +1,323 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { WebSocketServer } from 'ws';
+import { INDEX_HTML, CLIENT_JS } from './_client-assets.js';
+/**
+ * DevTools Viewer
+ *
+ * Receives logs via WebSocket from CLI sessions.
+ */
+export class DevTools extends EventEmitter {
+    static instance;
+    logs = [];
+    consoleLogs = [];
+    server = null;
+    wss = null;
+    sessions = new Map();
+    heartbeatTimer = null;
+    port = 25417;
+    static DEFAULT_PORT = 25417;
+    static MAX_PORT_RETRIES = 10;
+    constructor() {
+        super();
+        // Each SSE client adds 3 listeners; raise the limit to avoid warnings
+        this.setMaxListeners(50);
+    }
+    static getInstance() {
+        if (!DevTools.instance) {
+            DevTools.instance = new DevTools();
+        }
+        return DevTools.instance;
+    }
+    addInternalConsoleLog(payload, sessionId, timestamp) {
+        const entry = {
+            ...payload,
+            id: randomUUID(),
+            sessionId,
+            timestamp: timestamp || Date.now(),
+        };
+        this.consoleLogs.push(entry);
+        if (this.consoleLogs.length > 5000)
+            this.consoleLogs.shift();
+        this.emit('console-update', entry);
+    }
+    addInternalNetworkLog(payload, sessionId, timestamp) {
+        if (!payload.id)
+            return;
+        const existingIndex = this.logs.findIndex((l) => l.id === payload.id);
+        if (existingIndex > -1) {
+            const existing = this.logs[existingIndex];
+            // Handle chunk accumulation
+            if (payload.chunk) {
+                const chunks = existing.chunks || [];
+                chunks.push(payload.chunk);
+                this.logs[existingIndex] = {
+                    ...existing,
+                    chunks,
+                    sessionId: sessionId || existing.sessionId,
+                };
+            }
+            else {
+                this.logs[existingIndex] = {
+                    ...existing,
+                    ...payload,
+                    sessionId: sessionId || existing.sessionId,
+                    // Drop chunks once we have the full response body — the data
+                    // is redundant and keeping both can blow past V8's string limit
+                    // when serializing the snapshot.
+                    chunks: payload.response?.body ? undefined : existing.chunks,
+                    response: payload.response
+                        ? { ...existing.response, ...payload.response }
+                        : existing.response,
+                };
+            }
+            this.emit('update', this.logs[existingIndex]);
+        }
+        else if (payload.url) {
+            const entry = {
+                ...payload,
+                sessionId,
+                timestamp: timestamp || Date.now(),
+                chunks: payload.chunk ? [payload.chunk] : undefined,
+            };
+            this.logs.push(entry);
+            if (this.logs.length > 2000)
+                this.logs.shift();
+            this.emit('update', entry);
+        }
+    }
+    getUrl() {
+        return `http://127.0.0.1:${this.port}`;
+    }
+    getPort() {
+        return this.port;
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            if (this.wss) {
+                this.wss.close();
+                this.wss = null;
+            }
+            if (this.server) {
+                this.server.close(() => resolve());
+                this.server = null;
+            }
+            else {
+                resolve();
+            }
+            // Reset singleton so a fresh start() is possible
+            DevTools.instance = undefined;
+        });
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            if (this.server) {
+                resolve(this.getUrl());
+                return;
+            }
+            this.server = http.createServer((req, res) => {
+                // Only allow same-origin requests — the client is served from this
+                // server so cross-origin access is unnecessary and would let arbitrary
+                // websites exfiltrate logs (which may contain API keys/headers).
+                const origin = req.headers.origin;
+                if (origin) {
+                    const allowed = `http://127.0.0.1:${this.port}`;
+                    if (origin === allowed) {
+                        res.setHeader('Access-Control-Allow-Origin', allowed);
+                    }
+                }
+                // API routes
+                if (req.url === '/api/trigger-debugger' && req.method === 'POST') {
+                    let body = '';
+                    req.on('data', (chunk) => {
+                        body += chunk;
+                    });
+                    req.on('end', () => {
+                        try {
+                            const parsed = JSON.parse(body);
+                            if (typeof parsed !== 'object' ||
+                                parsed === null ||
+                                !('sessionId' in parsed) ||
+                                typeof parsed.sessionId !== 'string') {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: 'Invalid request' }));
+                                return;
+                            }
+                            const sessionId = parsed.sessionId;
+                            const session = this.sessions.get(sessionId);
+                            if (session) {
+                                session.ws.send(JSON.stringify({ type: 'trigger-debugger' }));
+                                res.writeHead(200, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ success: true }));
+                            }
+                            else {
+                                res.writeHead(404, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: 'Session not found' }));
+                            }
+                        }
+                        catch {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'Invalid request' }));
+                        }
+                    });
+                }
+                else if (req.url === '/events') {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        Connection: 'keep-alive',
+                    });
+                    // Send full snapshot on connect
+                    const snapshot = JSON.stringify({
+                        networkLogs: this.logs,
+                        consoleLogs: this.consoleLogs,
+                        sessions: Array.from(this.sessions.keys()),
+                    });
+                    res.write(`event: snapshot\ndata: ${snapshot}\n\n`);
+                    // Incremental updates
+                    const onNetwork = (log) => {
+                        res.write(`event: network\ndata: ${JSON.stringify(log)}\n\n`);
+                    };
+                    const onConsole = (log) => {
+                        res.write(`event: console\ndata: ${JSON.stringify(log)}\n\n`);
+                    };
+                    const onSession = () => {
+                        const sessions = Array.from(this.sessions.keys());
+                        res.write(`event: session\ndata: ${JSON.stringify(sessions)}\n\n`);
+                    };
+                    this.on('update', onNetwork);
+                    this.on('console-update', onConsole);
+                    this.on('session-update', onSession);
+                    req.on('close', () => {
+                        this.off('update', onNetwork);
+                        this.off('console-update', onConsole);
+                        this.off('session-update', onSession);
+                    });
+                }
+                else if (req.url === '/' || req.url === '/index.html') {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(INDEX_HTML);
+                }
+                else if (req.url === '/assets/main.js') {
+                    res.writeHead(200, { 'Content-Type': 'application/javascript' });
+                    res.end(CLIENT_JS);
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Not Found');
+                }
+            });
+            this.server.on('error', (e) => {
+                if (typeof e === 'object' &&
+                    e !== null &&
+                    'code' in e &&
+                    e.code === 'EADDRINUSE') {
+                    if (this.port - DevTools.DEFAULT_PORT >= DevTools.MAX_PORT_RETRIES) {
+                        reject(new Error(`DevTools: all ports ${DevTools.DEFAULT_PORT}–${this.port} in use`));
+                        return;
+                    }
+                    this.port++;
+                    this.server?.listen(this.port, '127.0.0.1');
+                }
+                else {
+                    reject(e instanceof Error ? e : new Error(String(e)));
+                }
+            });
+            this.server.listen(this.port, '127.0.0.1', () => {
+                this.setupWebSocketServer();
+                resolve(this.getUrl());
+            });
+        });
+    }
+    setupWebSocketServer() {
+        if (!this.server)
+            return;
+        this.wss = new WebSocketServer({ server: this.server, path: '/ws' });
+        this.wss.on('connection', (ws) => {
+            let sessionId = null;
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    // Handle registration first
+                    if (message.type === 'register') {
+                        sessionId = String(message.sessionId);
+                        if (!sessionId)
+                            return;
+                        this.sessions.set(sessionId, {
+                            sessionId,
+                            ws,
+                            lastPing: Date.now(),
+                        });
+                        // Notify session update
+                        this.emit('session-update');
+                        // Send registration acknowledgement
+                        ws.send(JSON.stringify({
+                            type: 'registered',
+                            sessionId,
+                            timestamp: Date.now(),
+                        }));
+                    }
+                    else if (sessionId) {
+                        this.handleWebSocketMessage(sessionId, message);
+                    }
+                }
+                catch {
+                    // Invalid WebSocket message
+                }
+            });
+            ws.on('close', () => {
+                if (sessionId) {
+                    this.sessions.delete(sessionId);
+                    this.emit('session-update');
+                }
+            });
+            ws.on('error', () => {
+                // WebSocket error — no action needed
+            });
+        });
+        // Heartbeat mechanism
+        this.heartbeatTimer = setInterval(() => {
+            const now = Date.now();
+            this.sessions.forEach((session, sessionId) => {
+                if (now - session.lastPing > 30000) {
+                    session.ws.close();
+                    this.sessions.delete(sessionId);
+                }
+                else {
+                    // Send ping
+                    session.ws.send(JSON.stringify({ type: 'ping', timestamp: now }));
+                }
+            });
+        }, 10000);
+        this.heartbeatTimer.unref();
+    }
+    handleWebSocketMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        switch (message['type']) {
+            case 'pong':
+                session.lastPing = Date.now();
+                break;
+            case 'console':
+                this.addInternalConsoleLog(message['payload'], sessionId, message['timestamp']);
+                break;
+            case 'network':
+                this.addInternalNetworkLog(message['payload'], sessionId, message['timestamp']);
+                break;
+            default:
+                break;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/bundle/node_modules/@google/gemini-cli-devtools/dist/src/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface NetworkLog {
+    id: string;
+    sessionId?: string;
+    timestamp: number;
+    method: string;
+    url: string;
+    headers: Record<string, string | string[] | undefined>;
+    body?: string;
+    pending?: boolean;
+    chunks?: Array<{
+        index: number;
+        data: string;
+        timestamp: number;
+    }>;
+    response?: {
+        status: number;
+        headers: Record<string, string | string[] | undefined>;
+        body?: string;
+        durationMs: number;
+    };
+    error?: string;
+}
+export interface ConsoleLogPayload {
+    type: 'log' | 'warn' | 'error' | 'debug' | 'info';
+    content: string;
+}
+export interface InspectorConsoleLog extends ConsoleLogPayload {
+    id: string;
+    sessionId?: string;
+    timestamp: number;
+}

package/bundle/node_modules/@google/gemini-cli-devtools/dist/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/bundle/node_modules/@google/gemini-cli-devtools/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@google/gemini-cli-devtools",
+  "version": "0.2.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run build:client && tsc -p tsconfig.build.json",
+    "build:client": "node esbuild.client.js"
+  },
+  "files": [
+    "dist",
+    "client/index.html"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  }
+}

package/bundle/policies/sandbox-default.toml

@@ -0,0 +1,19 @@
+[modes.plan]
+network = false
+readonly = true
+approvedTools = []
+allowOverrides = true
+
+[modes.default]
+network = false
+readonly = false
+approvedTools = ['cat', 'ls', 'grep', 'head', 'tail', 'less', 'Get-Content', 'dir', 'type', 'findstr', 'Get-ChildItem', 'echo']
+allowOverrides = true
+
+[modes.accepting_edits]
+network = false
+readonly = false
+approvedTools = ['sed', 'grep', 'awk', 'perl', 'cat', 'echo', 'Add-Content', 'Set-Content']
+allowOverrides = true
+
+[commands]