windmill-components 1.613.5 → 1.623.1

package/package/components/debug/dapClient.d.ts

@@ -1,192 +0,0 @@
-/**
- * DAP (Debug Adapter Protocol) WebSocket Client for Monaco integration.
- *
- * This client implements the DAP protocol over WebSocket to communicate
- * with a Python debugpy-based debug server.
- */
-export interface DAPMessage {
-    seq: number;
-    type: 'request' | 'response' | 'event';
-    command?: string;
-    event?: string;
-    request_seq?: number;
-    success?: boolean;
-    message?: string;
-    body?: Record<string, unknown>;
-    arguments?: Record<string, unknown>;
-}
-export interface Breakpoint {
-    id: number;
-    verified: boolean;
-    line: number;
-    source?: {
-        path: string;
-        name?: string;
-    };
-}
-export interface StackFrame {
-    id: number;
-    name: string;
-    source?: {
-        path: string;
-        name?: string;
-    };
-    line: number;
-    column: number;
-}
-export interface Variable {
-    name: string;
-    value: string;
-    type?: string;
-    variablesReference: number;
-}
-export interface Scope {
-    name: string;
-    variablesReference: number;
-    expensive: boolean;
-}
-export interface DebugState {
-    connected: boolean;
-    initialized: boolean;
-    running: boolean;
-    stopped: boolean;
-    stoppedReason?: string;
-    currentLine?: number;
-    currentFile?: string;
-    stackFrames: StackFrame[];
-    scopes: Scope[];
-    variables: Map<number, Variable[]>;
-    breakpoints: Map<string, Breakpoint[]>;
-    output: string[];
-    logs: string;
-    result?: unknown;
-    error?: string;
-}
-export declare const debugState: import("svelte/store").Writable<DebugState>;
-export declare class DAPClient {
-    private ws;
-    private seq;
-    private pendingRequests;
-    private url;
-    constructor(url?: string);
-    /**
-     * Connect to the DAP server.
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from the DAP server.
-     */
-    disconnect(): void;
-    /**
-     * Send a request to the DAP server and wait for a response.
-     */
-    private sendRequest;
-    /**
-     * Handle incoming messages from the DAP server.
-     */
-    private handleMessage;
-    /**
-     * Handle DAP events.
-     */
-    private handleEvent;
-    /**
-     * Initialize the debug session.
-     */
-    initialize(): Promise<DAPMessage>;
-    /**
-     * Set breakpoints in a source file.
-     */
-    setBreakpoints(path: string, lines: number[]): Promise<Breakpoint[]>;
-    /**
-     * Notify the server that configuration is done.
-     */
-    configurationDone(): Promise<void>;
-    /**
-     * Launch a script for debugging.
-     */
-    launch(options: {
-        program?: string;
-        code?: string;
-        args?: string[] | Record<string, unknown>;
-        cwd?: string;
-        callMain?: boolean;
-        env?: Record<string, string>;
-        token?: string;
-    }): Promise<void>;
-    /**
-     * Continue execution.
-     */
-    continue_(): Promise<void>;
-    /**
-     * Step over (next).
-     */
-    stepOver(): Promise<void>;
-    /**
-     * Step into.
-     */
-    stepIn(): Promise<void>;
-    /**
-     * Step out.
-     */
-    stepOut(): Promise<void>;
-    /**
-     * Pause execution.
-     */
-    pause(): Promise<void>;
-    /**
-     * Terminate the debug session.
-     */
-    terminate(): Promise<void>;
-    /**
-     * Get threads.
-     */
-    getThreads(): Promise<{
-        id: number;
-        name: string;
-    }[]>;
-    /**
-     * Get stack trace.
-     */
-    getStackTrace(threadId?: number): Promise<StackFrame[]>;
-    /**
-     * Get scopes for a stack frame.
-     */
-    getScopes(frameId: number): Promise<Scope[]>;
-    /**
-     * Get variables for a scope.
-     */
-    getVariables(variablesReference: number): Promise<Variable[]>;
-    /**
-     * Evaluate an expression.
-     * @param expression The expression to evaluate
-     * @param frameId Optional frame ID to evaluate in
-     * @param context The evaluation context
-     * @param token Optional JWT token for signed expression (audit logging)
-     */
-    evaluate(expression: string, frameId?: number, context?: 'watch' | 'repl' | 'hover', token?: string): Promise<{
-        result: string;
-        variablesReference: number;
-    }>;
-    /**
-     * Fetch stack trace (called automatically when stopped).
-     */
-    private fetchStackTrace;
-    /**
-     * Clear output.
-     */
-    clearOutput(): void;
-    /**
-     * Check if connected.
-     */
-    isConnected(): boolean;
-    /**
-     * Check if running.
-     */
-    isRunning(): boolean;
-    /**
-     * Check if stopped at a breakpoint.
-     */
-    isStopped(): boolean;
-}
-export declare function getDAPClient(url?: string): DAPClient;
-export declare function resetDAPClient(): void;

package/package/components/debug/dapClient.js

@@ -1,426 +0,0 @@
-/**
- * DAP (Debug Adapter Protocol) WebSocket Client for Monaco integration.
- *
- * This client implements the DAP protocol over WebSocket to communicate
- * with a Python debugpy-based debug server.
- */
-import { writable, get } from 'svelte/store';
-const initialState = {
-    connected: false,
-    initialized: false,
-    running: false,
-    stopped: false,
-    stackFrames: [],
-    scopes: [],
-    variables: new Map(),
-    breakpoints: new Map(),
-    output: [],
-    logs: '',
-    result: undefined,
-    error: undefined
-};
-export const debugState = writable({ ...initialState });
-export class DAPClient {
-    ws = null;
-    seq = 1;
-    pendingRequests = new Map();
-    url;
-    constructor(url = 'ws://localhost:3003') {
-        this.url = url;
-    }
-    /**
-     * Connect to the DAP server.
-     */
-    async connect() {
-        return new Promise((resolve, reject) => {
-            try {
-                console.log('[DAP] Connecting to:', this.url);
-                this.ws = new WebSocket(this.url);
-                this.ws.onopen = () => {
-                    console.log('[DAP] Connected successfully');
-                    debugState.update((s) => ({ ...s, connected: true }));
-                    resolve();
-                };
-                this.ws.onclose = () => {
-                    console.log('[DAP] WebSocket closed');
-                    debugState.update((s) => ({
-                        ...initialState,
-                        breakpoints: s.breakpoints,
-                        // Preserve result and logs after disconnect
-                        result: s.result,
-                        logs: s.logs,
-                        output: s.output
-                    }));
-                    this.pendingRequests.clear();
-                };
-                this.ws.onerror = (error) => {
-                    console.error('DAP WebSocket error:', error);
-                    reject(new Error('WebSocket connection failed'));
-                };
-                this.ws.onmessage = (event) => {
-                    this.handleMessage(event.data);
-                };
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Disconnect from the DAP server.
-     */
-    disconnect() {
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
-        debugState.set({ ...initialState });
-    }
-    /**
-     * Send a request to the DAP server and wait for a response.
-     */
-    async sendRequest(command, args) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            throw new Error('Not connected to DAP server');
-        }
-        const seq = this.seq++;
-        const message = {
-            seq,
-            type: 'request',
-            command,
-            arguments: args
-        };
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.pendingRequests.delete(seq);
-                reject(new Error(`Request timeout: ${command}`));
-            }, 10000);
-            this.pendingRequests.set(seq, {
-                resolve: (value) => {
-                    clearTimeout(timeout);
-                    resolve(value);
-                },
-                reject: (error) => {
-                    clearTimeout(timeout);
-                    reject(error);
-                }
-            });
-            this.ws.send(JSON.stringify(message));
-        });
-    }
-    /**
-     * Handle incoming messages from the DAP server.
-     */
-    handleMessage(data) {
-        try {
-            const message = JSON.parse(data);
-            if (message.type === 'response') {
-                const pending = this.pendingRequests.get(message.request_seq);
-                if (pending) {
-                    this.pendingRequests.delete(message.request_seq);
-                    if (message.success) {
-                        pending.resolve(message);
-                    }
-                    else {
-                        pending.reject(new Error(message.message || 'Request failed'));
-                    }
-                }
-            }
-            else if (message.type === 'event') {
-                console.log('[DAP] Event received:', message.event, message.body);
-                this.handleEvent(message);
-            }
-        }
-        catch (error) {
-            console.error('Failed to parse DAP message:', error);
-        }
-    }
-    /**
-     * Handle DAP events.
-     */
-    handleEvent(event) {
-        console.log('[DAP] Handling event:', event.event);
-        const body = event.body;
-        switch (event.event) {
-            case 'initialized':
-                // Clear logs and result when starting a new session
-                debugState.update((s) => ({
-                    ...s,
-                    initialized: true,
-                    logs: '',
-                    output: [],
-                    result: undefined,
-                    error: undefined
-                }));
-                break;
-            case 'stopped':
-                debugState.update((s) => ({
-                    ...s,
-                    stopped: true,
-                    running: false,
-                    stoppedReason: body?.reason,
-                    currentLine: body?.line
-                }));
-                // Automatically fetch stack trace when stopped
-                this.fetchStackTrace();
-                break;
-            case 'continued':
-                debugState.update((s) => ({
-                    ...s,
-                    stopped: false,
-                    running: true,
-                    stoppedReason: undefined
-                }));
-                break;
-            case 'terminated':
-                debugState.update((s) => ({
-                    ...s,
-                    running: false,
-                    stopped: false,
-                    initialized: false,
-                    result: body?.result,
-                    error: body?.error
-                }));
-                break;
-            case 'output':
-                if (body?.output) {
-                    debugState.update((s) => ({
-                        ...s,
-                        output: [...s.output, body.output],
-                        logs: s.logs + body.output
-                    }));
-                }
-                break;
-            case 'breakpoint':
-                // Breakpoint was verified/modified by the server
-                break;
-            default:
-                console.log('Unhandled DAP event:', event.event);
-        }
-    }
-    /**
-     * Initialize the debug session.
-     */
-    async initialize() {
-        const response = await this.sendRequest('initialize', {
-            clientID: 'windmill',
-            clientName: 'Windmill Script Editor',
-            adapterID: 'python',
-            pathFormat: 'path',
-            linesStartAt1: true,
-            columnsStartAt1: true,
-            supportsVariableType: true,
-            supportsVariablePaging: false,
-            supportsRunInTerminalRequest: false,
-            locale: 'en-US'
-        });
-        return response;
-    }
-    /**
-     * Set breakpoints in a source file.
-     */
-    async setBreakpoints(path, lines) {
-        console.log('[DAP] Setting breakpoints at path:', path, 'lines:', lines);
-        const response = await this.sendRequest('setBreakpoints', {
-            source: { path },
-            breakpoints: lines.map((line) => ({ line }))
-        });
-        console.log('[DAP] Breakpoints response:', response.body);
-        const breakpoints = response.body?.breakpoints || [];
-        debugState.update((s) => {
-            const newBreakpoints = new Map(s.breakpoints);
-            newBreakpoints.set(path, breakpoints);
-            return { ...s, breakpoints: newBreakpoints };
-        });
-        return breakpoints;
-    }
-    /**
-     * Notify the server that configuration is done.
-     */
-    async configurationDone() {
-        await this.sendRequest('configurationDone');
-    }
-    /**
-     * Launch a script for debugging.
-     */
-    async launch(options) {
-        await this.sendRequest('launch', {
-            program: options.program,
-            code: options.code,
-            args: options.args || {},
-            cwd: options.cwd || '.',
-            callMain: options.callMain || false,
-            env: options.env || {},
-            // Pass JWT token to debugger for verification
-            token: options.token
-        });
-        debugState.update((s) => ({ ...s, running: true }));
-    }
-    /**
-     * Continue execution.
-     */
-    async continue_() {
-        await this.sendRequest('continue', { threadId: 1 });
-        debugState.update((s) => ({ ...s, stopped: false, running: true }));
-    }
-    /**
-     * Step over (next).
-     */
-    async stepOver() {
-        await this.sendRequest('next', { threadId: 1 });
-    }
-    /**
-     * Step into.
-     */
-    async stepIn() {
-        await this.sendRequest('stepIn', { threadId: 1 });
-    }
-    /**
-     * Step out.
-     */
-    async stepOut() {
-        await this.sendRequest('stepOut', { threadId: 1 });
-    }
-    /**
-     * Pause execution.
-     */
-    async pause() {
-        await this.sendRequest('pause', { threadId: 1 });
-    }
-    /**
-     * Terminate the debug session.
-     */
-    async terminate() {
-        await this.sendRequest('terminate');
-    }
-    /**
-     * Get threads.
-     */
-    async getThreads() {
-        const response = await this.sendRequest('threads');
-        return response.body?.threads || [];
-    }
-    /**
-     * Get stack trace.
-     */
-    async getStackTrace(threadId = 1) {
-        const response = await this.sendRequest('stackTrace', {
-            threadId,
-            startFrame: 0,
-            levels: 20
-        });
-        const frames = response.body?.stackFrames || [];
-        debugState.update((s) => ({
-            ...s,
-            stackFrames: frames,
-            currentLine: frames[0]?.line,
-            currentFile: frames[0]?.source?.path
-        }));
-        return frames;
-    }
-    /**
-     * Get scopes for a stack frame.
-     */
-    async getScopes(frameId) {
-        console.log('[DAP] getScopes called with frameId:', frameId);
-        const response = await this.sendRequest('scopes', { frameId });
-        console.log('[DAP] getScopes response:', response);
-        const scopes = response.body?.scopes || [];
-        console.log('[DAP] getScopes parsed scopes:', scopes);
-        debugState.update((s) => ({ ...s, scopes }));
-        return scopes;
-    }
-    /**
-     * Get variables for a scope.
-     */
-    async getVariables(variablesReference) {
-        console.log('[DAP] getVariables called with variablesReference:', variablesReference);
-        const response = await this.sendRequest('variables', { variablesReference });
-        console.log('[DAP] getVariables response:', response);
-        const variables = response.body?.variables || [];
-        console.log('[DAP] getVariables parsed variables:', variables);
-        debugState.update((s) => {
-            const newVariables = new Map(s.variables);
-            newVariables.set(variablesReference, variables);
-            return { ...s, variables: newVariables };
-        });
-        return variables;
-    }
-    /**
-     * Evaluate an expression.
-     * @param expression The expression to evaluate
-     * @param frameId Optional frame ID to evaluate in
-     * @param context The evaluation context
-     * @param token Optional JWT token for signed expression (audit logging)
-     */
-    async evaluate(expression, frameId, context = 'repl', token) {
-        const response = await this.sendRequest('evaluate', {
-            expression,
-            frameId,
-            context,
-            token
-        });
-        return {
-            result: response.body?.result,
-            variablesReference: response.body?.variablesReference
-        };
-    }
-    /**
-     * Fetch stack trace (called automatically when stopped).
-     */
-    async fetchStackTrace() {
-        console.log('[DAP] fetchStackTrace called');
-        try {
-            const frames = await this.getStackTrace();
-            console.log('[DAP] fetchStackTrace got frames:', frames);
-            if (frames.length > 0) {
-                console.log('[DAP] fetchStackTrace calling getScopes with frameId:', frames[0].id);
-                await this.getScopes(frames[0].id);
-            }
-            else {
-                console.log('[DAP] fetchStackTrace: no frames, skipping getScopes');
-            }
-        }
-        catch (error) {
-            console.error('Failed to fetch stack trace:', error);
-        }
-    }
-    /**
-     * Clear output.
-     */
-    clearOutput() {
-        debugState.update((s) => ({ ...s, output: [] }));
-    }
-    /**
-     * Check if connected.
-     */
-    isConnected() {
-        return get(debugState).connected;
-    }
-    /**
-     * Check if running.
-     */
-    isRunning() {
-        return get(debugState).running;
-    }
-    /**
-     * Check if stopped at a breakpoint.
-     */
-    isStopped() {
-        return get(debugState).stopped;
-    }
-}
-// Singleton instance
-let dapClientInstance = null;
-export function getDAPClient(url) {
-    if (!dapClientInstance) {
-        dapClientInstance = new DAPClient(url);
-    }
-    return dapClientInstance;
-}
-export function resetDAPClient() {
-    if (dapClientInstance) {
-        dapClientInstance.disconnect();
-        dapClientInstance = null;
-    }
-}

package/package/components/debug/debugUtils.d.ts

@@ -1,30 +0,0 @@
-/**
- * Shared debug utility functions used across ScriptEditor, FlowModuleComponent,
- * and RawAppInlineScriptEditor.
- */
-/**
- * Fetch contextual variables (WM_WORKSPACE, WM_TOKEN, etc.) for the debugger.
- * Creates a fresh short-lived token for the debug session.
- */
-export declare function fetchContextualVariables(workspace: string): Promise<Record<string, string>>;
-/**
- * Sign a debug request with the backend. This creates an audit log entry
- * and returns a signed token that authorizes the debug session.
- */
-export declare function signDebugRequest(workspace: string, code: string, language: string): Promise<{
-    token: string;
-    code: string;
-    job_id: string;
-}>;
-/**
- * Get a user-friendly error message for debug errors
- */
-export declare function getDebugErrorMessage(error: unknown): string;
-/**
- * Check if a language supports debugging
- */
-export declare function isDebuggableLanguage(language: string | undefined): boolean;
-/**
- * Get the file extension for a language (used for debug file path)
- */
-export declare function getDebugFileExtension(language: string | undefined): string;