windmill-components 1.511.1 → 1.531.0

package/package/components/PullGitRepoPopover.svelte

@@ -1,355 +0,0 @@
-<script lang="ts">import { Button } from './common';
-import Popover from './meltComponents/Popover.svelte';
-import { Loader2, Eye, Save, CheckCircle2, XCircle, DownloadCloud, AlertTriangle, Terminal, ChevronDown, ChevronUp } from 'lucide-svelte';
-import { workspaceStore } from '../stores';
-import hubPaths from '../hubPaths.json';
-import { JobService } from '../gen';
-import { tryEvery } from '../utils';
-import { sendUserToast } from '../toast';
-import GitDiffPreview from './GitDiffPreview.svelte';
-import { page } from '$app/stores';
-let { gitRepoResourcePath, uiState, onFilterUpdate } = $props();
-let previewResult = $state(undefined);
-let isPreviewLoading = $state(false);
-let isPulling = $state(false);
-let pullGitRepoPopover = $state(null);
-let jobStatus = $state({
-    id: null,
-    status: undefined,
-    type: 'preview'
-});
-let isCliInfoExpanded = $state(false);
-async function handleJobCompletion(jobId, workspace) {
-    let success = false;
-    await tryEvery({
-        tryCode: async () => {
-            const result = await JobService.getCompletedJob({
-                workspace,
-                id: jobId
-            });
-            success = !!result.success;
-        },
-        timeoutCode: async () => {
-            try {
-                await JobService.cancelQueuedJob({
-                    workspace,
-                    id: jobId,
-                    requestBody: {
-                        reason: 'Job timed out after 5s'
-                    }
-                });
-            }
-            catch (err) {
-                console.error(err);
-            }
-        },
-        interval: 500,
-        timeout: 10000
-    });
-    return success;
-}
-async function previewChanges() {
-    const workspace = $workspaceStore;
-    if (!workspace)
-        return;
-    console.log('Previewing changes for repo:', gitRepoResourcePath);
-    isPreviewLoading = true;
-    jobStatus = { id: null, status: undefined, type: 'preview' };
-    try {
-        // Always use the simplified JSON approach
-        const jobId = await JobService.runScriptByPath({
-            workspace,
-            path: hubPaths.gitInitRepo,
-            requestBody: {
-                workspace_id: workspace,
-                repo_url_resource_path: gitRepoResourcePath,
-                dry_run: true,
-                pull: true,
-                only_wmill_yaml: false,
-                settings_json: JSON.stringify(uiState)
-            },
-            skipPreprocessor: true
-        });
-        jobStatus = { id: jobId, status: 'running', type: 'preview' };
-        const success = await handleJobCompletion(jobId, workspace);
-        if (success) {
-            const rawResult = await JobService.getCompletedJobResult({ workspace, id: jobId });
-            console.log('Preview result:', rawResult);
-            // Convert new CLI format to expected format
-            const added = [];
-            const deleted = [];
-            const modified = [];
-            if (rawResult &&
-                rawResult.changes &&
-                Array.isArray(rawResult.changes)) {
-                for (const change of rawResult.changes) {
-                    if (change.type === 'added') {
-                        added.push(change.path);
-                    }
-                    else if (change.type === 'deleted') {
-                        deleted.push(change.path);
-                    }
-                    else if (change.type === 'modified') {
-                        modified.push(change.path);
-                    }
-                }
-            }
-            // For full sync mode, just use the CLI results directly
-            // The CLI already handles wmill.yaml changes with --include-wmill-yaml flag
-            previewResult = { added, deleted, modified };
-            jobStatus.status = 'success';
-        }
-        else {
-            previewResult = undefined;
-            jobStatus.status = 'failure';
-        }
-    }
-    catch (error) {
-        console.error('Failed to preview changes:', error);
-        previewResult = undefined;
-        jobStatus = {
-            ...jobStatus,
-            status: 'failure',
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    finally {
-        isPreviewLoading = false;
-    }
-}
-async function pullFromRepo() {
-    const workspace = $workspaceStore;
-    if (!workspace)
-        return;
-    console.log('Pulling from repo:', gitRepoResourcePath);
-    isPulling = true;
-    jobStatus = { id: null, status: undefined, type: 'pull' };
-    try {
-        // Use init git repo script with dry_run: false (actual pull operation)
-        // The script will read wmill.yaml directly from the cloned repo, no need to pass settings
-        const jobId = await JobService.runScriptByPath({
-            workspace,
-            path: hubPaths.gitInitRepo,
-            requestBody: {
-                workspace_id: workspace,
-                repo_url_resource_path: gitRepoResourcePath,
-                dry_run: false,
-                branch_to_push: '',
-                only_wmill_yaml: false,
-                pull: true,
-                settings_json: undefined // Let script use wmill.yaml from repo
-            },
-            skipPreprocessor: true
-        });
-        jobStatus = { id: jobId, status: 'running', type: 'pull' };
-        const success = await handleJobCompletion(jobId, workspace);
-        jobStatus.status = success ? 'success' : 'failure';
-        if (success) {
-            // Get the result which should contain the local git repo settings as JSON
-            const result = (await JobService.getCompletedJobResult({ workspace, id: jobId }));
-            console.log('Pull result:', result);
-            // Apply the settings from the sync operation result to the UI
-            if (result?.settings_json) {
-                // Directly update the UI state with the JSON result - no YAML conversion needed!
-                const settingsJson = result.settings_json;
-                onFilterUpdate({
-                    include_path: settingsJson.include_path || ['f/**'],
-                    exclude_path: settingsJson.exclude_path || [],
-                    extra_include_path: settingsJson.extra_include_path || [],
-                    include_type: settingsJson.include_type || ['script', 'flow', 'app', 'folder']
-                });
-                sendUserToast('Successfully pulled workspace content from repository');
-                // Reset popover state after successful pull
-                previewResult = undefined;
-                jobStatus = { id: null, status: undefined, type: 'preview' };
-                pullGitRepoPopover?.close();
-            }
-            else {
-                console.warn('No settings_json returned from pull operation');
-                sendUserToast('Pull completed but could not update filter settings', true);
-            }
-        }
-    }
-    catch (error) {
-        console.error('Failed to pull from repo:', error);
-        jobStatus = {
-            ...jobStatus,
-            status: 'failure',
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    finally {
-        isPulling = false;
-    }
-}
-</script>
-
-<Popover
-	bind:this={pullGitRepoPopover}
-	floatingConfig={{
-		placement: 'top-start',
-		strategy: 'fixed',
-		flip: false,
-		shift: true
-	}}
-	contentClasses="p-4 w-1/3"
->
-	<svelte:fragment slot="trigger">
-		<Button
-			color="dark"
-			size="sm"
-			nonCaptureEvent
-			onclick={pullGitRepoPopover?.open}
-			startIcon={{ icon: DownloadCloud }}
-		>
-			Pull workspace from Git repo
-		</Button>
-	</svelte:fragment>
-
-	<svelte:fragment slot="content" let:close>
-		<div class="flex flex-col gap-4">
-			<div class="flex flex-col gap-2">
-				<h3 class="text-lg font-semibold">Pull workspace from Git repository</h3>
-				<div class="prose max-w-none text-2xs text-tertiary">
-					This action will pull all workspace objects from your Git repository according to the
-					filters set in the Git repository wmill.yaml file and apply those filter settings to the
-					workspace.
-					<span class="text-orange-600 flex items-center gap-1">
-						<AlertTriangle size={14} /> This will overwrite your current workspace content and Git sync
-						filter settings with the content from the Git repository.
-					</span>
-
-					<!-- Collapsible CLI Info Section -->
-					<div class="mt-2 border rounded-md">
-						<button
-							class="w-full flex items-center justify-between p-1.5 bg-surface-secondary hover:bg-surface-hover"
-							onclick={() => (isCliInfoExpanded = !isCliInfoExpanded)}
-						>
-							<span class="font-medium flex items-center gap-2">
-								<Terminal size={14} />
-								Windmill CLI to push local files to Windmill
-							</span>
-							{#if isCliInfoExpanded}
-								<ChevronUp size={16} />
-							{:else}
-								<ChevronDown size={16} />
-							{/if}
-						</button>
-
-						{#if isCliInfoExpanded}
-							<div class="p-1 bg-surface-tertiary">
-								<div class="text-2xs mb-2">
-									Not familiar with Windmill CLI? <a
-										href="https://www.windmill.dev/docs/advanced/cli/sync"
-										class="text-blue-500 hover:text-blue-600 underline"
-										target="_blank"
-										rel="noopener noreferrer">Check out the docs</a
-									>
-								</div>
-								<div class="font-mono text-2xs">
-									<pre class="overflow-auto max-h-60"
-										><code
-											>npm install -g windmill-cli
-# Clone your git repository
-git clone $REPO_URL
-cd $REPO_NAME
-# Configure Windmill CLI
-wmill workspace add {$workspaceStore} {$workspaceStore} {`${$page.url.protocol}//${$page.url.hostname}/`}
-# Push the content to Windmill
-wmill sync push --yes
-# Optional: add --skip-secrets --skip-variables --skip-resources flags as needed</code
-										></pre
-									>
-								</div>
-							</div>
-						{/if}
-					</div>
-				</div>
-			</div>
-
-			{#if previewResult}
-				<GitDiffPreview {previewResult} />
-			{/if}
-
-			{#if jobStatus.id}
-				<div class="flex items-center gap-2 text-xs text-tertiary">
-					{#if jobStatus.status === 'running'}
-						<Loader2 class="animate-spin" size={14} />
-					{:else if jobStatus.status === 'success'}
-						<CheckCircle2 size={14} class="text-green-600" />
-					{:else if jobStatus.status === 'failure'}
-						<XCircle size={14} class="text-red-700" />
-					{/if}
-					{jobStatus.type === 'preview' ? 'Preview' : 'Pull'} job:
-					<a
-						target="_blank"
-						class="underline"
-						href={`/run/${jobStatus.id}?workspace=${$workspaceStore}`}
-					>
-						{jobStatus.id}
-					</a>
-				</div>
-				{#if jobStatus.error}
-					<div class="text-xs text-red-600">{jobStatus.error}</div>
-				{/if}
-			{/if}
-
-			<div class="flex justify-between items-center mt-4">
-				<Button
-					color="light"
-					size="xs"
-					on:click={() => {
-						previewResult = undefined
-						jobStatus = { id: null, status: undefined, type: 'preview' }
-						close()
-					}}
-					disabled={isPreviewLoading || isPulling}
-				>
-					Cancel
-				</Button>
-				<div class="flex gap-2">
-					{#if !previewResult}
-						<Button
-							size="xs"
-							on:click={previewChanges}
-							disabled={isPreviewLoading || isPulling}
-							startIcon={{
-								icon: isPreviewLoading ? Loader2 : Eye,
-								classes: isPreviewLoading ? 'animate-spin' : ''
-							}}
-						>
-							Preview
-						</Button>
-					{:else}
-						<Button
-							size="xs"
-							on:click={previewChanges}
-							disabled={isPreviewLoading || isPulling}
-							startIcon={{
-								icon: isPreviewLoading ? Loader2 : Eye,
-								classes: isPreviewLoading ? 'animate-spin' : ''
-							}}
-							title="Preview changes again"
-						>
-							Preview
-						</Button>
-						{#if previewResult.added?.length || previewResult.deleted?.length || previewResult.modified?.length}
-							<Button
-								color="red"
-								size="xs"
-								on:click={pullFromRepo}
-								disabled={isPreviewLoading || isPulling}
-								startIcon={{
-									icon: isPulling ? Loader2 : Save,
-									classes: isPulling ? 'animate-spin' : ''
-								}}
-							>
-								{isPulling ? 'Pulling...' : 'Pull'}
-							</Button>
-						{/if}
-					{/if}
-				</div>
-			</div>
-		</div>
-	</svelte:fragment>
-</Popover>

package/package/components/PullGitRepoPopover.svelte.d.ts

@@ -1,18 +0,0 @@
-type $$ComponentProps = {
-    gitRepoResourcePath: string;
-    uiState: {
-        include_path: string[];
-        exclude_path: string[];
-        extra_include_path: string[];
-        include_type: string[];
-    };
-    onFilterUpdate: (filters: {
-        include_path: string[];
-        exclude_path: string[];
-        extra_include_path: string[];
-        include_type: string[];
-    }) => void;
-};
-declare const PullGitRepoPopover: import("svelte").Component<$$ComponentProps, {}, "">;
-type PullGitRepoPopover = ReturnType<typeof PullGitRepoPopover>;
-export default PullGitRepoPopover;

package/package/components/copilot/chat/navigator/apiTools.d.ts

@@ -1,68 +0,0 @@
-import type { ChatCompletionTool } from 'openai/resources/index.mjs';
-import type { Tool } from '../shared';
-interface OpenAPIParameter {
-    name: string;
-    in: string;
-    description?: string;
-    required?: boolean;
-    schema?: {
-        type?: string;
-        format?: string;
-    };
-}
-interface OpenAPIRequestBody {
-    description?: string;
-    required?: boolean;
-    content: {
-        [contentType: string]: {
-            schema: {
-                type?: string;
-                properties?: Record<string, any>;
-            };
-        };
-    };
-}
-interface OpenAPIOperation {
-    operationId?: string;
-    summary?: string;
-    description?: string;
-    parameters?: OpenAPIParameter[];
-    requestBody?: OpenAPIRequestBody;
-    responses?: Record<string, any>;
-    tags?: string[];
-}
-interface OpenAPIPathItem {
-    get?: OpenAPIOperation;
-    post?: OpenAPIOperation;
-    put?: OpenAPIOperation;
-    delete?: OpenAPIOperation;
-    patch?: OpenAPIOperation;
-    options?: OpenAPIOperation;
-    parameters?: OpenAPIParameter[];
-    summary?: string;
-    description?: string;
-}
-interface OpenAPISpec {
-    paths: {
-        [path: string]: OpenAPIPathItem;
-    };
-    components?: {
-        parameters?: {
-            [name: string]: OpenAPIParameter;
-        };
-        schemas?: {
-            [name: string]: any;
-        };
-    };
-}
-export declare function buildToolsFromOpenApi(openApiSpec: OpenAPISpec, options?: {
-    pathFilter?: (path: string) => boolean;
-    operationFilter?: (operation: OpenAPIOperation) => boolean;
-    methodFilter?: string[];
-}): {
-    tools: ChatCompletionTool[];
-    endpointMap: Record<string, string>;
-};
-export declare function createApiTools(chatTools: ChatCompletionTool[], endpointMap?: Record<string, string>): Tool<{}>[];
-export declare function loadApiTools(): Promise<Tool<{}>[]>;
-export {};

package/package/components/copilot/chat/navigator/apiTools.js

@@ -1,258 +0,0 @@
-import { get } from 'svelte/store';
-import { workspaceStore, enterpriseLicense } from '../../../../stores';
-/**
- * Dereferences parameter $ref references in an OpenAPI spec
- * Only resolves parameter references, not schemas or other components
- */
-function dereferenceParameters(spec) {
-    if (!spec.components?.parameters) {
-        return spec;
-    }
-    const resolveParameterRef = (paramRef) => {
-        if (paramRef.$ref) {
-            // Extract parameter name from $ref (e.g., "#/components/parameters/WorkspaceId" -> "WorkspaceId")
-            const refPath = paramRef.$ref.split('/');
-            if (refPath.length >= 4 && refPath[1] === 'components' && refPath[2] === 'parameters') {
-                const paramName = refPath[3];
-                const resolvedParam = spec.components?.parameters?.[paramName];
-                if (resolvedParam) {
-                    return resolvedParam;
-                }
-            }
-            console.warn(`Could not resolve parameter reference: ${paramRef.$ref}`);
-            return paramRef;
-        }
-        return paramRef;
-    };
-    const processParameters = (parameters) => {
-        return parameters.map(resolveParameterRef);
-    };
-    const dereferencedSpec = {
-        ...spec,
-        paths: {}
-    };
-    // Process each path
-    for (const [pathKey, pathItem] of Object.entries(spec.paths)) {
-        const newPathItem = { ...pathItem };
-        // Dereference path-level parameters
-        if (pathItem.parameters) {
-            newPathItem.parameters = processParameters(pathItem.parameters);
-        }
-        // Dereference operation-level parameters
-        const methods = ['get', 'post', 'put', 'delete', 'patch', 'options'];
-        for (const method of methods) {
-            const operation = pathItem[method];
-            if (operation?.parameters) {
-                newPathItem[method] = {
-                    ...operation,
-                    parameters: processParameters(operation.parameters)
-                };
-            }
-        }
-        dereferencedSpec.paths[pathKey] = newPathItem;
-    }
-    return dereferencedSpec;
-}
-const buildApiCallTools = (name, description, parameters) => {
-    return {
-        type: 'function',
-        function: {
-            name,
-            description,
-            parameters
-        }
-    };
-};
-export function buildToolsFromOpenApi(openApiSpec, options = {}) {
-    const tools = [];
-    const endpointMap = {};
-    const { pathFilter, methodFilter = ['get', 'post', 'put', 'delete', 'patch'] } = options;
-    // Iterate through all paths in the OpenAPI spec
-    for (const [path, pathItem] of Object.entries(openApiSpec.paths)) {
-        if (pathFilter && !pathFilter(path))
-            continue;
-        for (const [method, operation] of Object.entries(pathItem)) {
-            // Skip non-operation properties
-            if (method === 'parameters' ||
-                method === 'servers' ||
-                method === 'summary' ||
-                method === 'description')
-                continue;
-            // Skip methods not in methodFilter
-            if (!methodFilter.includes(method.toLowerCase()))
-                continue;
-            // Type cast to OpenAPIOperation
-            const op = operation;
-            if (!op.operationId || !op.summary) {
-                console.error(`Operation ${method} ${path} has no operationId or summary`);
-                continue;
-            }
-            // Build the parameters schema
-            const parameters = {
-                type: 'object',
-                properties: {},
-                required: []
-            };
-            // Process path parameters
-            const pathParams = [...(pathItem.parameters || []), ...(op.parameters || [])].filter((p) => p.in === 'path');
-            // Process query parameters
-            const queryParams = (op.parameters || []).filter((p) => p.in === 'query');
-            // Add path parameters
-            for (const param of pathParams) {
-                if (param.name === 'workspace') {
-                    continue;
-                }
-                parameters.properties[param.name] = {
-                    type: param.schema?.type || 'string',
-                    description: param.description || `Path parameter: ${param.name}`
-                };
-                if (param.required) {
-                    parameters.required.push(param.name);
-                }
-            }
-            // Add query parameters
-            for (const param of queryParams) {
-                parameters.properties[param.name] = {
-                    type: param.schema?.type || 'string',
-                    description: param.description || `Query parameter: ${param.name}`
-                };
-                if (param.required) {
-                    parameters.required.push(param.name);
-                }
-            }
-            // Handle request body if present
-            if (op.requestBody) {
-                const contentType = Object.keys(op.requestBody.content || {})[0];
-                if (contentType) {
-                    const schema = op.requestBody.content[contentType].schema;
-                    if (schema) {
-                        parameters.properties.body = {
-                            type: 'object',
-                            description: op.requestBody.description || 'Request body',
-                            properties: schema.properties || {}
-                        };
-                        if (op.requestBody.required) {
-                            parameters.required.push('body');
-                        }
-                    }
-                }
-            }
-            const tool = buildApiCallTools('api_' + op.operationId.replace(/\s+/g, ''), op.summary || op.description || `${method.toUpperCase()} ${path}`, parameters);
-            // Store the endpoint path in the map
-            endpointMap['api_' + op.operationId.replace(/\s+/g, '')] = `${method.toUpperCase()} ${path}`;
-            tools.push(tool);
-        }
-    }
-    return { tools, endpointMap };
-}
-export function createApiTools(chatTools, endpointMap = {}) {
-    return chatTools.map((chatTool) => {
-        return {
-            def: chatTool,
-            fn: async ({ args, toolId, toolCallbacks }) => {
-                const toolName = chatTool.function.name;
-                let endpoint = endpointMap[toolName] || '';
-                endpoint = endpoint.replace('{workspace}', get(workspaceStore));
-                try {
-                    // Extract method and path from endpoint
-                    const [method, path] = endpoint.split(' ', 2);
-                    if (!endpoint || !method || !path) {
-                        throw new Error(`Invalid endpoint for tool ${toolName}: ${endpoint}`);
-                    }
-                    // Build URL with path parameters
-                    let url = `/api${path}`;
-                    const queryParams = {};
-                    // Process arguments
-                    for (const [key, value] of Object.entries(args)) {
-                        if (key === 'body')
-                            continue; // Body is handled separately
-                        // Check if this is a path parameter
-                        if (url.includes(`{${key}}`)) {
-                            url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
-                        }
-                        else {
-                            // Assume it's a query parameter
-                            queryParams[key] = String(value);
-                        }
-                    }
-                    // Add query parameters to URL if needed
-                    if (Object.keys(queryParams).length > 0) {
-                        const searchParams = new URLSearchParams();
-                        for (const [key, value] of Object.entries(queryParams)) {
-                            searchParams.append(key, value);
-                        }
-                        url += `?${searchParams.toString()}`;
-                    }
-                    // Log the constructed URL
-                    console.log(`Calling API: ${method} ${url} with args: ${JSON.stringify(args)}`);
-                    toolCallbacks.setToolStatus(toolId, `Calling API endpoint (${url})...`);
-                    const response = await fetch(url, {
-                        method: method
-                    });
-                    if (response.ok) {
-                        let result = '';
-                        if (response.headers.get('content-type')?.includes('application/json')) {
-                            result = await response.json();
-                        }
-                        else {
-                            result = await response.text();
-                        }
-                        toolCallbacks.setToolStatus(toolId, `API call to ${url} completed`);
-                        return JSON.stringify({
-                            success: true,
-                            data: result
-                        });
-                    }
-                    else {
-                        const text = await response.text();
-                        toolCallbacks.setToolStatus(toolId, `API call to ${url} failed`);
-                        return JSON.stringify({
-                            success: false,
-                            data: text
-                        });
-                    }
-                }
-                catch (error) {
-                    toolCallbacks.setToolStatus(toolId, `API call to ${endpoint} failed`);
-                    console.error(`Error calling API to ${endpoint}:`, error);
-                    return `Error calling API: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            }
-        };
-    });
-}
-export async function loadApiTools() {
-    try {
-        const response = await fetch('/api/openapi.json');
-        const rawOpenApiSpec = (await response.json());
-        // Dereference parameter references
-        const openApiSpec = dereferenceParameters(rawOpenApiSpec);
-        const pathsToInclude = [
-            'jobs',
-            'jobs_u',
-            'scripts',
-            'flows',
-            'resources',
-            'variables',
-            'schedules',
-            'workers'
-        ];
-        // call srch endpoint to check if it's available
-        if (get(enterpriseLicense)) {
-            const srchResponse = await fetch(`/api/srch/index/search/enabled`);
-            if (srchResponse.ok) {
-                pathsToInclude.push('srch/w'); // job search
-            }
-        }
-        const { tools: apiTools, endpointMap } = buildToolsFromOpenApi(openApiSpec, {
-            pathFilter: (path) => pathsToInclude.some((p) => path.includes(`/${p}/`)),
-            methodFilter: ['get']
-        });
-        const executableApiTools = createApiTools(apiTools, endpointMap);
-        return executableApiTools;
-    }
-    catch (error) {
-        console.error('Failed to load API tools:', error);
-        return [];
-    }
-}