windmill-components 1.555.0 → 1.558.1

package/package/components/flows/conversations/FlowChatManager.svelte.js

@@ -0,0 +1,422 @@
+import { FlowConversationService } from '../../../gen';
+import { sendUserToast } from '../../../toast';
+import { waitJob } from '../../waitJob';
+import { tick } from 'svelte';
+class FlowChatManager {
+    // State
+    messages = $state([]);
+    inputMessage = $state('');
+    isLoading = $state(false);
+    isLoadingMessages = $state(false);
+    isWaitingForResponse = $state(false);
+    messagesContainer = $state(undefined);
+    inputElement = $state(undefined);
+    page = $state(1);
+    hasMoreMessages = $state(false);
+    loadingMoreMessages = $state(false);
+    currentEventSource = $state(undefined);
+    pollingInterval = $state(undefined);
+    // Private state
+    #conversationsCache = $state({});
+    #scrollTimeout = undefined;
+    #perPage = 50;
+    #workspace = $state(undefined);
+    // Options
+    #onRunFlow;
+    #createConversation;
+    #refreshConversations;
+    #conversationId = $state(undefined);
+    #useStreaming = $state(false);
+    #path = $state(undefined);
+    initialize(options, workspace) {
+        this.#onRunFlow = options.onRunFlow;
+        this.#createConversation = options.createConversation;
+        this.#refreshConversations = options.refreshConversations;
+        this.#conversationId = options.conversationId;
+        this.#useStreaming = options.useStreaming ?? false;
+        this.#path = options.path;
+        this.#workspace = workspace;
+    }
+    updateConversationId(conversationId) {
+        this.#conversationId = conversationId;
+    }
+    cleanup() {
+        if (this.currentEventSource) {
+            this.currentEventSource.close();
+            this.currentEventSource = undefined;
+        }
+        this.stopPolling();
+        this.isLoading = false;
+        this.isWaitingForResponse = false;
+    }
+    // Public methods for component to call
+    fillInputMessage(message) {
+        this.inputMessage = message;
+    }
+    focusInput() {
+        this.inputElement?.focus();
+    }
+    clearMessages() {
+        this.messages = [];
+        this.inputMessage = '';
+        this.page = 1;
+    }
+    async loadConversationMessages(conversationId) {
+        this.page = 1;
+        await this.loadMessages(true, conversationId);
+    }
+    // Message loading
+    async loadMessages(reset, conversationId) {
+        let conversationIdToUse = conversationId ?? this.#conversationId;
+        if (!this.#workspace || !conversationIdToUse)
+            return;
+        if (reset) {
+            if (this.#conversationsCache[conversationIdToUse]) {
+                this.messages = this.#conversationsCache[conversationIdToUse];
+                return;
+            }
+            this.isLoadingMessages = true;
+        }
+        else {
+            this.loadingMoreMessages = true;
+        }
+        const pageToFetch = reset ? 1 : this.page + 1;
+        try {
+            const previousScrollHeight = this.messagesContainer?.scrollHeight || 0;
+            const response = await FlowConversationService.listConversationMessages({
+                workspace: this.#workspace,
+                conversationId: conversationIdToUse,
+                page: pageToFetch,
+                perPage: this.#perPage
+            });
+            if (reset) {
+                this.#conversationsCache[conversationIdToUse] = response;
+                this.messages = response;
+                this.isLoadingMessages = false;
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                this.scrollToBottom();
+            }
+            else {
+                this.messages = [...response, ...this.messages];
+                this.page = pageToFetch;
+                // Restore scroll position
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                if (this.messagesContainer) {
+                    this.messagesContainer.scrollTop =
+                        this.messagesContainer.scrollHeight - previousScrollHeight;
+                }
+            }
+            this.hasMoreMessages = response.length === this.#perPage;
+        }
+        catch (error) {
+            console.error('Failed to load messages:', error);
+            sendUserToast('Failed to load messages: ' + error);
+        }
+        finally {
+            this.isLoadingMessages = false;
+            this.loadingMoreMessages = false;
+        }
+    }
+    handleScroll = () => {
+        if (this.#scrollTimeout)
+            clearTimeout(this.#scrollTimeout);
+        this.#scrollTimeout = setTimeout(() => {
+            if (!this.messagesContainer || !this.hasMoreMessages || this.loadingMoreMessages)
+                return;
+            if (this.messagesContainer.scrollTop <= 10) {
+                this.loadMessages(false);
+            }
+        }, 200);
+    };
+    scrollToBottom() {
+        if (this.messagesContainer) {
+            this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight;
+        }
+    }
+    scrollToUserMessage(messageId) {
+        if (!this.messagesContainer)
+            return;
+        const messageElement = this.messagesContainer.querySelector(`[data-message-id="${messageId}"]`);
+        if (messageElement) {
+            messageElement.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        }
+    }
+    // Polling
+    async pollJobResult(jobId) {
+        try {
+            await waitJob(jobId);
+        }
+        catch (error) {
+            console.error('Error polling job result:', error);
+        }
+        finally {
+            // Do a final poll to get all messages from database
+            try {
+                if (this.#conversationId) {
+                    await this.pollConversationMessages(this.#conversationId);
+                }
+            }
+            catch { }
+            this.cleanup();
+        }
+    }
+    parseStreamDeltas(streamData) {
+        let type = 'message';
+        const lines = streamData.trim().split('\n');
+        let content = '';
+        let success = true;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type === 'tool_result') {
+                    type = 'tool_result';
+                    const toolName = parsed.function_name;
+                    success = parsed.success;
+                    content = success ? `Used ${toolName} tool` : `Failed to use ${toolName} tool`;
+                }
+                if (parsed.type === 'token_delta' && parsed.content) {
+                    type = 'message';
+                    content += parsed.content;
+                }
+            }
+            catch (e) {
+                console.error('Failed to parse stream line:', line, e);
+            }
+        }
+        return { type, content, success };
+    }
+    async pollConversationMessages(conversationId, isNewConversation) {
+        if (!this.#workspace)
+            return;
+        try {
+            const lastId = this.messages[this.messages.length - 1].id;
+            const response = await FlowConversationService.listConversationMessages({
+                workspace: this.#workspace,
+                conversationId: conversationId,
+                page: 1,
+                perPage: 50,
+                afterId: lastId
+            });
+            if (isNewConversation) {
+                await this.#refreshConversations?.();
+            }
+            const filteredResponse = response.filter((msg) => msg.message_type !== 'user');
+            // Add any new intermediate messages not already present
+            for (const msg of filteredResponse) {
+                if (!this.messages.find((m) => m.id === msg.id)) {
+                    this.messages = [...this.messages, msg];
+                }
+            }
+            // Remove temporary messages
+            this.messages = this.messages.filter((msg) => !msg.id.startsWith('temp-'));
+        }
+        catch (error) {
+            console.error('Polling error:', error);
+        }
+    }
+    startPolling(conversationId, isNewConversation) {
+        if (this.pollingInterval)
+            return;
+        this.pollingInterval = setInterval(() => {
+            this.pollConversationMessages(conversationId, isNewConversation);
+        }, 500); // Poll every 0.5 seconds
+        setTimeout(() => {
+            this.stopPolling();
+        }, 2 * 60 * 1000); // Stop polling after 2 minutes
+    }
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    // Message sending
+    async sendMessage() {
+        if (!this.inputMessage.trim() || this.isLoading)
+            return;
+        const isNewConversation = this.messages.length === 0;
+        // Reset state for new message
+        this.stopPolling();
+        // Generate a new conversation ID if we don't have one
+        let currentConversationId = this.#conversationId;
+        if (!this.#conversationId && this.#createConversation) {
+            const newConversationId = await this.#createConversation({ clearMessages: false });
+            currentConversationId = newConversationId;
+        }
+        if (!currentConversationId) {
+            console.error('No conversation ID found');
+            return;
+        }
+        // Invalidate the conversation cache
+        delete this.#conversationsCache[currentConversationId];
+        const userMessage = {
+            id: crypto.randomUUID(),
+            content: this.inputMessage.trim(),
+            created_at: new Date().toISOString(),
+            message_type: 'user',
+            conversation_id: currentConversationId
+        };
+        this.messages = [...this.messages, userMessage];
+        const messageContent = this.inputMessage.trim();
+        this.inputMessage = '';
+        this.isLoading = true;
+        this.isWaitingForResponse = true;
+        try {
+            await tick();
+            this.scrollToUserMessage(userMessage.id);
+            if (this.#useStreaming && this.#path) {
+                await this.handleStreamingMessage(messageContent, currentConversationId, isNewConversation);
+            }
+            else {
+                await this.handlePollingMessage(messageContent, currentConversationId, isNewConversation);
+            }
+        }
+        catch (error) {
+            console.error('Error running flow:', error);
+            sendUserToast('Failed to run flow: ' + error, true);
+        }
+        finally {
+            if (!this.#useStreaming) {
+                this.isLoading = false;
+            }
+        }
+        await tick();
+        this.focusInput();
+    }
+    async handleStreamingMessage(messageContent, currentConversationId, isNewConversation) {
+        // Close any existing EventSource
+        if (this.currentEventSource) {
+            this.currentEventSource.close();
+        }
+        // Track stream state for this message
+        let accumulatedContent = '';
+        let assistantMessageId = '';
+        let isCompleted = false;
+        try {
+            // Encode the payload as base64
+            const payload = { user_message: messageContent };
+            const payloadBase64 = btoa(JSON.stringify(payload));
+            // Build the EventSource URL
+            const streamUrl = `/api/w/${this.#workspace}/jobs/run_and_stream/f/${this.#path}`;
+            const url = new URL(streamUrl, window.location.origin);
+            url.searchParams.set('payload', payloadBase64);
+            url.searchParams.set('memory_id', currentConversationId);
+            url.searchParams.set('poll_delay_ms', '50');
+            // Create EventSource connection
+            const eventSource = new EventSource(url.toString());
+            this.currentEventSource = eventSource;
+            // start polling
+            this.startPolling(currentConversationId, isNewConversation);
+            eventSource.onmessage = async (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    if (data.type === 'update') {
+                        // Process new stream content
+                        if (data.new_result_stream) {
+                            // Stop polling since we are receiving last step streaming
+                            this.stopPolling();
+                            const { type, content: newContent, success } = this.parseStreamDeltas(data.new_result_stream);
+                            accumulatedContent += newContent;
+                            if (accumulatedContent.length > 0 || type === 'tool_result') {
+                                this.isWaitingForResponse = false;
+                            }
+                            // Create tool message if type is tool_result
+                            if (type === 'tool_result') {
+                                // set last message streaming to false
+                                this.messages = this.messages.map((msg) => msg.id === this.messages[this.messages.length - 1].id
+                                    ? { ...msg, streaming: false }
+                                    : msg);
+                                this.messages = [
+                                    ...this.messages,
+                                    {
+                                        id: 'temp-' + crypto.randomUUID(),
+                                        content: newContent,
+                                        created_at: new Date().toISOString(),
+                                        message_type: 'tool',
+                                        conversation_id: currentConversationId,
+                                        job_id: '',
+                                        loading: false,
+                                        streaming: false,
+                                        success
+                                    }
+                                ];
+                                // Reset assistant message ID since we are creating a tool message
+                                assistantMessageId = '';
+                                accumulatedContent = '';
+                            }
+                            // Create message on first content
+                            else if (type === 'message' &&
+                                assistantMessageId.length === 0 &&
+                                accumulatedContent.length > 0) {
+                                assistantMessageId = 'temp-' + crypto.randomUUID();
+                                this.messages = [
+                                    ...this.messages,
+                                    {
+                                        id: assistantMessageId,
+                                        content: accumulatedContent,
+                                        created_at: new Date().toISOString(),
+                                        message_type: 'assistant',
+                                        conversation_id: currentConversationId,
+                                        job_id: '',
+                                        loading: false,
+                                        streaming: true
+                                    }
+                                ];
+                            }
+                            else {
+                                // Update existing message
+                                this.messages = this.messages.map((msg) => msg.id === assistantMessageId ? { ...msg, content: accumulatedContent } : msg);
+                            }
+                        }
+                        // Handle completion
+                        if (data.completed) {
+                            isCompleted = true;
+                            // Do a final poll to get all messages from database
+                            if (this.#conversationId) {
+                                await this.pollConversationMessages(this.#conversationId);
+                            }
+                            this.cleanup();
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('Error processing stream event:', error);
+                }
+            };
+            eventSource.onerror = (error) => {
+                if (isCompleted)
+                    return;
+                console.error('EventSource error:', error);
+                sendUserToast('Stream error occurred', true);
+                this.cleanup();
+            };
+        }
+        catch (error) {
+            console.error('Stream connection error:', error);
+            sendUserToast('Failed to connect to stream', true);
+            this.cleanup();
+        }
+    }
+    async handlePollingMessage(messageContent, currentConversationId, isNewConversation) {
+        const jobId = await this.#onRunFlow?.(messageContent, currentConversationId);
+        if (!jobId) {
+            console.error('No jobId returned from onRunFlow');
+            return;
+        }
+        if (isNewConversation) {
+            await this.#refreshConversations?.();
+        }
+        // Start polling for intermediate messages in non-streaming mode too
+        this.startPolling(currentConversationId);
+        this.pollJobResult(jobId);
+    }
+    handleKeyDown = (event) => {
+        if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            this.sendMessage();
+        }
+    };
+}
+export const createFlowChatManager = () => new FlowChatManager();

package/package/components/flows/conversations/FlowChatMessage.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">import { Markdown } from 'svelte-exmarkdown';
+import { gfmPlugin } from 'svelte-exmarkdown/gfm';
+import { Loader2, CheckCircle2, AlertTriangle } from 'lucide-svelte';
+import CodeDisplay from '../../copilot/chat/script/CodeDisplay.svelte';
+import LinkRenderer from '../../copilot/chat/LinkRenderer.svelte';
+import {} from './FlowChatManager.svelte';
+let { message } = $props();
+</script>
+
+<div
+	class={`flex ${message.message_type === 'user' ? 'justify-end' : 'justify-start'} ${message.loading || message.streaming ? 'min-h-[200px] items-start' : ''}`}
+	data-message-id={message.id}
+>
+	<div
+		class="max-w-[90%] min-w-0 rounded-lg
+			{message.message_type === 'user'
+			? 'bg-surface-secondary p-3'
+			: `bg-surface border ${message.success !== false ? 'border-gray-200 dark:border-gray-600' : '!border-red-500'}`}"
+	>
+		{#if message.step_name}
+			<div
+				class="bg-surface-secondary text-2xs text-tertiary mb-2 font-medium py-1 px-2 rounded-t-lg"
+				>{message.step_name}</div
+			>
+		{/if}
+
+		{#if message.message_type === 'user'}
+			<p class="whitespace-pre-wrap text-sm break-words">{message.content}</p>
+		{:else if message.loading}
+			<div class="flex items-center gap-2 text-tertiary">
+				<Loader2 size={16} class="animate-spin" />
+				<span>Processing...</span>
+			</div>
+		{:else if message.content}
+			<div
+				class="flex flex-row items-center gap-2 px-3 pb-3 text-sm {!message.step_name
+					? 'pt-3'
+					: ''}"
+			>
+				{#if message.message_type === 'tool'}
+					{#if message.success !== false}
+						<CheckCircle2 class="w-3.5 h-3.5 text-green-500" />
+					{:else}
+						<AlertTriangle class="w-3.5 h-3.5 text-red-500" />
+					{/if}
+				{/if}
+				<div
+					class="prose prose-sm dark:prose-invert break-words whitespace-pre-wrap prose-headings:!text-base"
+				>
+					<Markdown
+						md={message.content}
+						plugins={[
+							gfmPlugin(),
+							{
+								renderer: {
+									pre: CodeDisplay,
+									a: LinkRenderer
+								}
+							}
+						]}
+					/>
+				</div>
+			</div>
+		{:else}
+			<p class="text-tertiary text-sm">No result</p>
+		{/if}
+	</div>
+</div>

package/package/components/flows/{FlowChatMessage.svelte.d.ts → conversations/FlowChatMessage.svelte.d.ts}

@@ -1,8 +1,6 @@
-import type { FlowConversationMessage } from '../../gen';
+import { type ChatMessage } from './FlowChatManager.svelte';
 interface Props {
-    message: FlowConversationMessage & {
-        loading?: boolean;
-    };
+    message: ChatMessage;
 }
 declare const FlowChatMessage: import("svelte").Component<Props, {}, "">;
 type FlowChatMessage = ReturnType<typeof FlowChatMessage>;

package/package/components/flows/{FlowConversationsSidebar.svelte → conversations/FlowConversationsSidebar.svelte}

@@ -1,10 +1,10 @@
-<script lang="ts">import { Button } from '../common';
+<script lang="ts">import { Button } from '../../common';
 import { MessageCircle, Plus, Trash2, PanelLeftClose, PanelLeftOpen, Loader2 } from 'lucide-svelte';
-import { workspaceStore } from '../../stores';
-import { FlowConversationService } from '../../gen';
-import { sendUserToast } from '../../toast';
-import CountBadge from '../common/badge/CountBadge.svelte';
-import InfiniteList from '../InfiniteList.svelte';
+import { workspaceStore } from '../../../stores';
+import { FlowConversationService } from '../../../gen';
+import { sendUserToast } from '../../../toast';
+import CountBadge from '../../common/badge/CountBadge.svelte';
+import InfiniteList from '../../InfiniteList.svelte';
 import { untrack } from 'svelte';
 import { twMerge } from 'tailwind-merge';
 let { flowPath, selectedConversationId, onNewConversation, onSelectConversation, onDeleteConversation } = $props();

package/package/components/flows/flowInfers.js

@@ -25,7 +25,7 @@ export const AI_AGENT_SCHEMA = {
         streaming: {
             type: 'boolean',
             description: 'Whether to stream the output of the AI agent.',
-            default: false,
+            default: true,
             showExpr: "fields.output_type === 'text'"
         },
         messages_context_length: {

package/package/components/flows/scheduleUtils.js

@@ -141,7 +141,8 @@ export async function saveScheduleFromCfg(scheduleCfg, edit, workspace) {
         no_flow_overlap: scheduleCfg.no_flow_overlap,
         tag: scheduleCfg.tag,
         paused_until: scheduleCfg.paused_until,
-        cron_version: scheduleCfg.cron_version
+        cron_version: scheduleCfg.cron_version,
+        dynamic_skip: scheduleCfg.dynamic_skip
     };
     try {
         if (edit) {

package/package/components/graph/renderers/nodes/AIToolNode.svelte.d.ts

@@ -19,6 +19,6 @@ import type { GraphModuleState } from '../../model';
 interface Props {
     data: AiToolN['data'];
 }
-declare const AiToolNode: import("svelte").Component<Props, {}, "">;
-type AiToolNode = ReturnType<typeof AiToolNode>;
-export default AiToolNode;
+declare const AIToolNode: import("svelte").Component<Props, {}, "">;
+type AIToolNode = ReturnType<typeof AIToolNode>;
+export default AIToolNode;

package/package/components/graph/renderers/nodes/NewAIToolNode.svelte.d.ts

@@ -2,6 +2,6 @@ import { type NewAiToolN } from '../../graphBuilder.svelte';
 interface Props {
     data: NewAiToolN['data'];
 }
-declare const NewAiToolNode: import("svelte").Component<Props, {}, "">;
-type NewAiToolNode = ReturnType<typeof NewAiToolNode>;
-export default NewAiToolNode;
+declare const NewAIToolNode: import("svelte").Component<Props, {}, "">;
+type NewAIToolNode = ReturnType<typeof NewAIToolNode>;
+export default NewAIToolNode;

package/package/components/icons/CACertificate.svelte.d.ts

@@ -2,6 +2,6 @@ interface Props {
     height?: string;
     width?: string;
 }
-declare const CaCertificate: import("svelte").Component<Props, {}, "">;
-type CaCertificate = ReturnType<typeof CaCertificate>;
-export default CaCertificate;
+declare const CACertificate: import("svelte").Component<Props, {}, "">;
+type CACertificate = ReturnType<typeof CACertificate>;
+export default CACertificate;

package/package/components/icons/MSSqlServerIcon.svelte.d.ts

@@ -2,6 +2,6 @@ interface Props {
     height?: string;
     width?: string;
 }
-declare const MsSqlServerIcon: import("svelte").Component<Props, {}, "">;
-type MsSqlServerIcon = ReturnType<typeof MsSqlServerIcon>;
-export default MsSqlServerIcon;
+declare const MSSqlServerIcon: import("svelte").Component<Props, {}, "">;
+type MSSqlServerIcon = ReturnType<typeof MSSqlServerIcon>;
+export default MSSqlServerIcon;

package/package/components/icons/MSTeamsIcon.svelte.d.ts

@@ -2,6 +2,6 @@ interface Props {
     height?: string;
     width?: string;
 }
-declare const MsTeamsIcon: import("svelte").Component<Props, {}, "">;
-type MsTeamsIcon = ReturnType<typeof MsTeamsIcon>;
-export default MsTeamsIcon;
+declare const MSTeamsIcon: import("svelte").Component<Props, {}, "">;
+type MSTeamsIcon = ReturnType<typeof MSTeamsIcon>;
+export default MSTeamsIcon;

package/package/components/icons/OracleDBIcon.svelte.d.ts

@@ -2,6 +2,6 @@ interface Props {
     height?: string;
     width?: string;
 }
-declare const OracleDbIcon: import("svelte").Component<Props, {}, "">;
-type OracleDbIcon = ReturnType<typeof OracleDbIcon>;
-export default OracleDbIcon;
+declare const OracleDBIcon: import("svelte").Component<Props, {}, "">;
+type OracleDBIcon = ReturnType<typeof OracleDBIcon>;
+export default OracleDBIcon;

package/package/components/icons/PHPIcon.svelte.d.ts

@@ -2,6 +2,6 @@ interface Props {
     height?: string;
     width?: string;
 }
-declare const PhpIcon: import("svelte").Component<Props, {}, "">;
-type PhpIcon = ReturnType<typeof PhpIcon>;
-export default PhpIcon;
+declare const PHPIcon: import("svelte").Component<Props, {}, "">;
+type PHPIcon = ReturnType<typeof PHPIcon>;
+export default PHPIcon;

package/package/components/icons/QRCodeIcon.svelte.d.ts

@@ -1,6 +1,6 @@
 interface Props {
     height?: number;
 }
-declare const QrCodeIcon: import("svelte").Component<Props, {}, "">;
-type QrCodeIcon = ReturnType<typeof QrCodeIcon>;
-export default QrCodeIcon;
+declare const QRCodeIcon: import("svelte").Component<Props, {}, "">;
+type QRCodeIcon = ReturnType<typeof QRCodeIcon>;
+export default QRCodeIcon;

package/package/components/instanceSettings.js

@@ -128,7 +128,7 @@ export const settings = {
         },
         {
             label: 'Private Hub base url',
-            description: 'Base URL of your private Hub instance, without trailing slash. <a href="https://www.windmill.dev/docs/core_concepts/private_hub">Learn more</a>',
+            description: 'Base URL of your Private Hub instance, without trailing slash. <a href="https://www.windmill.dev/docs/core_concepts/private_hub">Learn more</a>',
             placeholder: 'https://hub.company.com',
             key: 'hub_base_url',
             fieldType: 'text',
@@ -159,6 +159,15 @@ export const settings = {
             ee_only: '',
             requiresReloadOnChange: true
         },
+        {
+            label: 'Private Hub API secret',
+            description: 'If access to your Private Hub is restricted, you can set the hub API secret here. <a href="https://www.windmill.dev/docs/core_concepts/private_hub">Learn more</a>',
+            key: 'hub_api_secret',
+            fieldType: 'password',
+            storage: 'setting',
+            ee_only: '',
+            requiresReloadOnChange: true
+        },
         {
             label: 'App workspace prefix',
             description: 'When enabled apps will be accessible at /a/{workspace_id}/{custom_path} instead of /a/{custom_path} allowing you to define same custom path for apps in different workspace without conflict',
@@ -285,7 +294,7 @@ export const settings = {
             label: 'PowerShell Repository PAT',
             description: 'Add private PowerShell repository Personal Access Token',
             key: 'powershell_repo_pat',
-            fieldType: 'text',
+            fieldType: 'password',
             storage: 'setting',
             ee_only: ''
         }