windmill-components 1.623.2 → 1.655.0

package/dist/sharedUtils/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@windmill-labs/shared-utils",
+  "version": "1.0.7",
+  "type": "module",
+  "private": false,
+  "main": "./lib.es.js",
+  "module": "./lib.es.js",
+  "exports": {
+    ".": "./lib.es.js"
+  },
+  "types": "./lib.d.ts"
+}

package/dist/sharedUtils/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Schema, SchemaProperty } from './common';
+export declare function schemaToTsType(schema: Schema | SchemaProperty): string;
+export declare function schemaToObject(schema: Schema, args: Record<string, any>): Object;

package/dist/sharedUtils/stores.d.ts

@@ -0,0 +1,96 @@
+import { type Readable } from 'svelte/store';
+import type { IntrospectionQuery } from 'graphql';
+import { type OperatorSettings, type TokenResponse, type UserWorkspaceList, type WorkspaceDefaultScripts } from './gen';
+import { type StateStore } from './utils';
+export interface UserExt {
+    email: string;
+    name?: string;
+    username: string;
+    is_admin: boolean;
+    is_super_admin: boolean;
+    operator: boolean;
+    created_at: string;
+    groups: string[];
+    pgroups: string[];
+    folders: string[];
+    folders_owners: string[];
+}
+export interface UserWorkspace {
+    id: string;
+    name: string;
+    username: string;
+    color?: string;
+    operator_settings?: OperatorSettings;
+    parent_workspace_id?: string | null;
+    disabled: boolean;
+}
+export declare function getWorkspaceFromStorage(): string | undefined;
+export declare function clearWorkspaceFromStorage(): void;
+export declare const tutorialsToDo: import("svelte/store").Writable<number[]>;
+export declare const globalEmailInvite: import("svelte/store").Writable<string>;
+export declare const awarenessStore: import("svelte/store").Writable<Record<string, string>>;
+export declare const enterpriseLicense: import("svelte/store").Writable<string | undefined>;
+export declare const whitelabelNameStore: Readable<string | undefined>;
+export declare const workerTags: import("svelte/store").Writable<string[] | undefined>;
+export declare const usageStore: import("svelte/store").Writable<number>;
+export declare const workspaceUsageStore: import("svelte/store").Writable<number>;
+export declare const initialArgsStore: import("svelte/store").Writable<any>;
+export declare const oauthStore: import("svelte/store").Writable<TokenResponse | undefined>;
+export declare const userStore: import("svelte/store").Writable<UserExt | undefined>;
+export declare const workspaceStore: import("svelte/store").Writable<string | undefined>;
+export declare const defaultScripts: import("svelte/store").Writable<WorkspaceDefaultScripts | undefined>;
+export declare const dbClockDrift: import("svelte/store").Writable<number | undefined>;
+export declare const isPremiumStore: import("svelte/store").Writable<boolean>;
+export declare const starStore: import("svelte/store").Writable<number>;
+export declare const usersWorkspaceStore: import("svelte/store").Writable<UserWorkspaceList | undefined>;
+export declare const superadmin: import("svelte/store").Writable<string | false | undefined>;
+export declare const devopsRole: import("svelte/store").Writable<string | false | undefined>;
+export declare const lspTokenStore: import("svelte/store").Writable<string | undefined>;
+export declare const hubBaseUrlStore: import("svelte/store").Writable<string>;
+export declare const userWorkspaces: Readable<Array<UserWorkspace>>;
+export declare const codeCompletionLoading: import("svelte/store").Writable<boolean>;
+export declare const metadataCompletionEnabled: import("svelte/store").Writable<boolean>;
+export declare const stepInputCompletionEnabled: import("svelte/store").Writable<boolean>;
+export declare const FORMAT_ON_SAVE_SETTING_NAME = "formatOnSave";
+export declare const VIM_MODE_SETTING_NAME = "vimMode";
+export declare const RELATIVE_LINE_NUMBERS_SETTING_NAME = "relativeLineNumbers";
+export declare const CODE_COMPLETION_SETTING_NAME = "codeCompletionSessionEnabled";
+export declare const COPILOT_SESSION_MODEL_SETTING_NAME = "copilotSessionModel";
+export declare const COPILOT_SESSION_PROVIDER_SETTING_NAME = "copilotSessionProvider";
+export declare const formatOnSave: import("svelte/store").Writable<boolean>;
+export declare const vimMode: import("svelte/store").Writable<boolean>;
+export declare const relativeLineNumbers: import("svelte/store").Writable<boolean>;
+export declare const codeCompletionSessionEnabled: import("svelte/store").Writable<boolean>;
+export declare const usedTriggerKinds: import("svelte/store").Writable<string[]>;
+type SQLBaseSchema = {
+    [schemaKey: string]: {
+        [tableKey: string]: {
+            [columnKey: string]: {
+                type: string;
+                default: string;
+                required: boolean;
+            };
+        };
+    };
+};
+export declare const SQLSchemaLanguages: readonly ["mysql", "bigquery", "postgresql", "snowflake", "mssql", "oracledb"];
+export interface SQLSchema {
+    lang: (typeof SQLSchemaLanguages)[number] | 'ducklake';
+    schema: SQLBaseSchema;
+    publicOnly: boolean | undefined;
+    stringified: string;
+}
+export interface GraphqlSchema {
+    lang: 'graphql';
+    schema: IntrospectionQuery;
+    stringified: string;
+}
+export type DBSchema = SQLSchema | GraphqlSchema;
+export type DBSchemas = Partial<Record<string, DBSchema>>;
+export declare const dbSchemas: import("svelte/store").Writable<Partial<Record<string, DBSchema>>>;
+export declare const instanceSettingsSelectedTab: import("svelte/store").Writable<string>;
+export declare const isCriticalAlertsUIOpen: import("svelte/store").Writable<boolean>;
+export declare const workspaceColor: Readable<string | null | undefined>;
+export declare const isCurrentlyInTutorial: StateStore<boolean>;
+export declare function getFlatTableNamesFromSchema(dbSchema: DBSchema | undefined): string[];
+export {};

package/dist/sharedUtils/svelte5Utils.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { StateStore } from './utils';
+export declare function withProps<Component, Props>(component: Component, props: Props): {
+    component: Component;
+    props: Props;
+};
+export declare function createState<T>(initialValue: T): T;
+export declare function stateSnapshot<T>(state: T): $state.Snapshot<T>;
+export declare function refreshStateStore<T>(store: StateStore<T>): void;
+export type UsePromiseResult<T> = ({
+    status: 'loading';
+    value?: undefined;
+    error?: undefined;
+} | {
+    status: 'error';
+    error: any;
+    value?: undefined;
+} | {
+    status: 'ok';
+    value: T;
+    error?: undefined;
+} | {
+    status: 'idle';
+    value?: undefined;
+    error?: undefined;
+}) & {
+    refresh: () => void;
+    clear: () => void;
+};
+export type UsePromiseOptions = {
+    loadInit?: boolean;
+    clearValueOnRefresh?: boolean;
+};
+export declare function usePromise<T>(createPromise: () => Promise<T>, { loadInit, clearValueOnRefresh }?: UsePromiseOptions): UsePromiseResult<T>;
+/**
+ * Generic change tracker class that monitors changes in state using deep equality comparison
+ * and provides a counter to trigger Svelte 5 reactivity. Similar to the pattern used in
+ * FlowGraphV2.svelte's onModulesChange2 function.
+ */
+export declare class ChangeTracker<T> {
+    #private;
+    counter: number;
+    constructor(initialValue?: T);
+    /**
+     * Check if the value has changed and update the counter to trigger reactivity
+     * @param value - The current value to check for changes
+     * @returns true if the value changed, false otherwise
+     */
+    track(value: T): boolean;
+}

package/dist/sharedUtils/toast.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from 'svelte';
+import type { Button } from './components/common';
+export type ToastAction = {
+    label: string;
+    callback: () => void;
+    buttonType?: ComponentProps<typeof Button>['variant'];
+};
+export declare function sendUserToast(message: string, error?: boolean, actions?: ToastAction[], errorMessage?: string | undefined, duration?: number): void;

package/dist/sharedUtils/utils.d.ts

@@ -0,0 +1,250 @@
+import { type UserExt } from './stores';
+import { sendUserToast } from './toast';
+import type { Job, RunnableKind, Script, ScriptLang, Retry } from './gen';
+import type { EnumType, SchemaProperty } from './common';
+import type { Schema } from './common';
+export { sendUserToast };
+import type { AnyMeltElement } from '@melt-ui/svelte';
+import type { TriggerKind } from './components/triggers';
+export type RunsSelectionMode = 'cancel' | 're-run';
+export declare namespace OpenApi {
+    enum OpenApiVersion {
+        V2 = 0,
+        V3 = 1,
+        V3_1 = 2
+    }
+    function isV2(doc: OpenAPI.Document): doc is OpenAPIV2.Document;
+    function isV3(doc: OpenAPI.Document): doc is OpenAPIV3.Document;
+    function isV3_1(doc: OpenAPI.Document): doc is OpenAPIV3_1.Document;
+    function getOpenApiVersion(version: string): OpenApiVersion;
+    /**
+     * Parses and validates an OpenAPI specification provided as a string in either JSON or YAML format.
+     *
+     * @param api - A string containing a valid OpenAPI specification in JSON or YAML format.
+     * @returns A promise that resolves to a tuple:
+     *   - The first element is the validated OpenAPI document.
+     *   - The second element is the detected OpenAPI version (2, 3.0, or 3.1).
+     *
+     * @throws Will throw an error if the specification is invalid or cannot be parsed.
+     */
+    function parse(api: string): Promise<[OpenAPI.Document, OpenApiVersion]>;
+}
+export declare function isJobCancelable(j: Job): boolean;
+export declare function isJobReRunnable(j: Job): boolean;
+export declare const WORKER_NAME_PREFIX = "wk";
+export declare function isJobSelectable(selectionType: RunsSelectionMode): (j: Job) => boolean;
+export declare function escapeHtml(unsafe: string): string;
+export declare function validateUsername(username: string): string;
+export declare function parseQueryParams(url: string | undefined): Record<string, string>;
+export declare function displayDateOnly(dateString: string | Date | undefined): string;
+export declare function retrieveCommonWorkerPrefix(workerName: string): string;
+export declare function subtractDaysFromDateString(dateString: string | undefined, days: number): string | undefined;
+export declare function displayDate(dateString: string | Date | undefined, displaySecond?: boolean, displayDate?: boolean): string;
+export declare function displayTime(dateString: string | Date | undefined): string;
+export declare function displaySize(sizeInBytes: number | undefined): string | undefined;
+export declare function msToSec(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function removeTriggerKindIfUnused(length: number, triggerKind: TriggerKind, usedTriggerKinds: string[]): string[];
+export declare function msToReadableTime(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function msToReadableTimeShort(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function getToday(): Date;
+export declare function truncateHash(hash: string): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function addIfNotExists<T>(e: T, arr: Array<T> | undefined): Array<T>;
+export declare function validatePassword(password: string): boolean;
+interface ClickOutsideOptions {
+    capture?: boolean;
+    exclude?: (() => Promise<HTMLElement[]>) | HTMLElement[] | undefined;
+    stopPropagation?: boolean;
+    customEventName?: string;
+    eventToListenName?: 'click' | 'pointerdown';
+    onClickOutside?: (event: MouseEvent) => void;
+}
+export declare function clickOutside(node: Node, options?: ClickOutsideOptions | boolean): {
+    destroy(): void;
+    update(newOptions: ClickOutsideOptions | boolean): void;
+};
+export declare function pointerDownOutside(node: Node, options?: ClickOutsideOptions): {
+    destroy(): void;
+    update(newOptions: ClickOutsideOptions): void;
+};
+export interface DropdownItem {
+    displayName: string;
+    eventName?: string;
+    action?: ((event?: MouseEvent) => Promise<void>) | ((event?: MouseEvent) => void);
+    href?: string;
+    separatorTop?: boolean;
+    separatorBottom?: boolean;
+    type?: 'action' | 'delete';
+    disabled?: boolean;
+    icon?: any | undefined;
+}
+export declare const DELETE: "delete";
+export declare function emptySchema(): Schema;
+export declare function simpleSchema(): Schema;
+export declare function removeItemAll<T>(arr: T[], value: T): T[];
+export declare function emptyString(str: string | undefined | null): boolean;
+export declare function emptyStringTrimmed(str: string | undefined | null): boolean;
+export declare function defaultIfEmptyString(str: string | undefined, dflt: string): string;
+export declare function removeKeysWithEmptyValues(obj: any): any;
+export declare function allTrue(dict: {
+    [id: string]: boolean;
+}): boolean;
+export declare function elapsedSinceSecs(date: string): number;
+export declare function pathIsEmpty(path: string): boolean;
+export declare function encodeState(state: any): string;
+export declare function decodeState(query: string): any;
+export declare function itemsExists<T>(arr: T[] | undefined, item: T): boolean;
+export declare function groupBy<K, V>(items: V[], toGroup: (t: V) => K, toSort: (t: V) => string, dflts?: K[]): [K, V[]][];
+export declare function removeMarkdown(text: string): string;
+export declare function truncate(s: string, n: number, suffix?: string): string;
+export declare function truncateRev(s: string, n: number, prefix?: string): string;
+export declare function isString(value: any): value is string | String;
+export type InputCat = 'string' | 'email' | 'number' | 'boolean' | 'list' | 'resource-object' | 'enum' | 'date' | 'base64' | 'resource-string' | 'object' | 'sql' | 'yaml' | 'currency' | 'oneOf' | 'dynamic' | 'json-schema' | 'ai-provider';
+export declare namespace DynamicInput {
+    type HelperScript = {
+        source: 'deployed';
+        path: string;
+        runnable_kind: RunnableKind;
+    } | {
+        source: 'inline';
+        code: string;
+        lang: ScriptLang;
+    };
+    const generatePythonFnTemplate: (functionName: string) => string;
+    const generateJsFnTemplate: (functionName: string) => string;
+    const generateDefaultTemplateFn: (functionName: string, lang: ScriptLang) => string;
+    const getGenerateTemplateFn: (lang: ScriptLang) => (functionName: string) => string;
+    const isDynInputFormat: (format?: string) => boolean;
+}
+export declare function setInputCat(type: string | undefined, format: string | undefined, itemsType: string | undefined, enum_: any, contentEncoding: string | undefined): InputCat;
+export declare function formatCron(inp: string): string;
+export declare function scriptLangArrayToCommaList(languages: ScriptLang[]): string;
+export declare function cronV1toV2(inp: string): string;
+export declare function classNames(...classes: Array<string | undefined>): string;
+export declare function download(filename: string, fileContent: string, mimeType?: string): void;
+export declare function copyToClipboard(value?: string, sendToast?: boolean): Promise<boolean>;
+export declare function pluralize(quantity: number, word: string, customPlural?: string): string;
+export declare function addDeterminant(word: string): string;
+export { capitalize } from './sharedUtils';
+export declare function addWhitespaceBeforeCapitals(word?: string): string;
+export declare function isObject(obj: any): obj is Record<string, any>;
+export declare function debounce(func: (...args: any[]) => any, wait: number): {
+    debounced: (...args: any[]) => void;
+    clearDebounce: () => void;
+};
+export declare function throttle<T>(func: (...args: any[]) => T, wait: number): (...args: any[]) => void;
+export declare function isMac(): boolean;
+export declare function getModifierKey(): string;
+export declare function isValidHexColor(color: string): boolean;
+export declare function sortObject<T>(o: T & object): T;
+export declare function sortArray<T>(array: T[], compareFn?: (a: T, b: T) => number): T[];
+export declare function generateRandomString(len?: number): string;
+export declare function deepMergeWithPriority<T>(target: T, source: T): T;
+export declare function canWrite(path: string, extra_perms: Record<string, boolean>, user?: UserExt): boolean;
+export declare function isOwner(path: string, user: UserExt | undefined, workspace: string | undefined): boolean;
+export declare function isObviousOwner(path: string, user?: UserExt): boolean;
+export declare function extractCustomProperties(styleStr: string): string;
+export declare function computeSharableHash(args: any): string;
+export declare function toCamel(s: string): string;
+export declare function cleanExpr(expr: string | undefined): string;
+export declare function isCodeInjection(expr: string | undefined): boolean;
+export declare function urlParamsToObject(params: URLSearchParams): Record<string, string>;
+export declare function tryEvery({ tryCode, timeoutCode, interval, timeout }: {
+    tryCode: () => Promise<any>;
+    timeoutCode: () => void;
+    interval: number;
+    timeout: number;
+}): Promise<void>;
+export declare function roughSizeOfObject(object: object | string | any): number;
+export type Value = {
+    language?: Script['language'];
+    content?: string;
+    path?: string;
+    draft_only?: boolean;
+    value?: any;
+    draft?: Value;
+    [key: string]: any;
+};
+export declare function replaceFalseWithUndefined(obj: any): any;
+export declare function cleanValueProperties(obj: Value): any;
+export declare function orderedJsonStringify(obj: any, space?: string | number): string;
+export declare function orderedYamlStringify(obj: any): string;
+export declare function computeShow(argName: string, expr: string | undefined, args: any): any;
+export declare function urlize(input: string, formatter: 'html' | 'md'): string;
+export declare function storeLocalSetting(name: string, value: string | undefined): void;
+export declare function getLocalSetting(name: string): string | null | undefined;
+export declare function computeKind(enum_: EnumType, contentEncoding: 'base64' | 'binary' | undefined, pattern: string | undefined, format: string | undefined): 'base64' | 'none' | 'pattern' | 'enum' | 'resource' | 'format' | 'date-time';
+export declare function shouldDisplayPlaceholder(type: string | undefined, format: string | undefined, enum_: EnumType, contentEncoding: 'base64' | 'binary' | undefined, pattern: string | undefined, extra: Record<string, any> | undefined): boolean;
+export declare function getSchemaFromProperties(properties: {
+    [name: string]: SchemaProperty;
+}): Schema;
+export declare function validateFileExtension(ext: string): boolean;
+export declare function isFlowPreview(job_kind: Job['job_kind'] | undefined): job_kind is "flowpreview" | "flownode";
+export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): job_kind is "script" | "aiagent" | "identity" | "preview" | "dependencies" | "flowdependencies" | "appdependencies" | "script_hub" | "deploymentcallback" | "flowscript" | "appscript" | undefined;
+export declare function isScriptPreview(job_kind: Job['job_kind'] | undefined): job_kind is "preview" | "flowscript" | "appscript";
+export declare function conditionalMelt(node: HTMLElement, meltItem: AnyMeltElement | undefined): void | import("svelte/action").ActionReturn<undefined, Record<never, any>>;
+export type Item = {
+    displayName: string;
+    action?: (e: MouseEvent) => void;
+    icon?: any;
+    iconColor?: string;
+    href?: string;
+    hrefTarget?: '_blank' | '_self' | '_parent' | '_top';
+    disabled?: boolean;
+    type?: 'action' | 'delete';
+    hide?: boolean | undefined;
+    extra?: Snippet;
+    id?: string;
+};
+export declare function isObjectTooBig(obj: any): boolean;
+export declare function localeConcatAnd(items: string[]): string;
+export declare function formatDate(dateString: string | undefined): string;
+export declare function formatDateShort(dateString: string | undefined): string;
+export declare function toJsonStr(result: any): string;
+export declare function getOS(): "Windows" | "macOS" | "iOS" | "Android" | "Linux" | "Unknown OS";
+import { type ClassValue } from 'clsx';
+import type { Component, Snippet } from 'svelte';
+import { OpenAPIV2, type OpenAPI, type OpenAPIV3, type OpenAPIV3_1 } from 'openapi-types';
+import type { IPosition } from 'monaco-editor';
+export declare function cn(...inputs: ClassValue[]): string;
+export type StateStore<T> = {
+    val: T;
+};
+export type ReadFieldsRecursivelyOptions = {
+    excludeField?: string[];
+};
+export declare function readFieldsRecursively(obj: any, options?: ReadFieldsRecursivelyOptions): void;
+export declare function reorder<T>(items: T[], oldIndex: number, newIndex: number): T[];
+export declare function scroll_into_view_if_needed_polyfill(elem: Element, centerIfNeeded?: boolean): IntersectionObserver;
+export declare function clone<T>(t: T): T;
+export declare const editorPositionMap: Record<string, IPosition>;
+export type S3Uri = `s3://${string}/${string}`;
+export type S3Object = S3Uri | {
+    s3: string;
+    storage?: string;
+};
+export declare function parseS3Object(s3Object: S3Object): {
+    s3: string;
+    storage?: string;
+};
+export declare function formatS3Object(s3Object: S3Object): S3Uri;
+export declare function isS3Uri(uri: string): uri is S3Uri;
+export declare function uniqueBy<T>(array: T[], key: (t: T) => any): T[];
+export declare function pruneNullishArray<T>(array: (T | null | undefined)[]): T[];
+export declare function assert(msg: string, condition: boolean, value?: any): void;
+export declare function createCache<Keys extends Record<string, any>, T, InitialKeys extends Keys = Keys>(compute: (keys: Keys) => T, params?: {
+    maxSize?: number;
+    initial?: InitialKeys;
+    invalidateMs?: number;
+}): (keys: Keys) => T;
+export declare function wait(ms: number): Promise<unknown>;
+export declare function validateRetryConfig(retry: Retry | undefined): string | null;
+export type CssColor = keyof (typeof tokensFile)['tokens']['light'];
+import tokensFile from './assets/tokens/tokens.json';
+export declare function getCssColor(color: CssColor, { alpha, format }: {
+    alpha?: number;
+    format?: 'css-var' | 'hex-dark' | 'hex-light';
+}): string;
+export type IconType = Component<{
+    size?: number;
+}> | typeof import('lucide-svelte').Dot;

package/package/aiStore.d.ts

@@ -11,5 +11,6 @@ export declare const copilotInfo: import("svelte/store").Writable<{
 export declare function loadCopilot(workspace: string): Promise<void>;
 export declare function setCopilotInfo(aiConfig: AIConfig): void;
 export declare function getCurrentModel(): AIProviderModel;
+export declare function tryGetCurrentModel(): AIProviderModel | undefined;
 export declare function getUserCustomPrompts(): Record<string, string>;
 export declare function getCombinedCustomPrompt(mode: string): string | undefined;

package/package/aiStore.js

@@ -69,6 +69,9 @@ export function getCurrentModel() {
     }
     return model;
 }
+export function tryGetCurrentModel() {
+    return get(copilotSessionModel) ?? get(copilotInfo).defaultModel ?? get(copilotInfo).aiModels[0];
+}
 export function getUserCustomPrompts() {
     const stored = getLocalSetting(USER_CUSTOM_PROMPTS_KEY);
     if (stored) {

package/package/assets/app.css

@@ -4,25 +4,34 @@
 @tailwind utilities;
 
 @media (min-width: 1760px) {
-  :root {
-    font-size: 18px;
-  }
+	:root {
+		font-size: 18px;
+	}
 }
 
 @layer base {
-
 	/* Light mode: default border color */
-	.border, .border-t, .border-r, .border-b, .border-l, 
-	.border-x, .border-y, 
-	.divide-x > :not([hidden]) ~ :not([hidden]), 
+	.border,
+	.border-t,
+	.border-r,
+	.border-b,
+	.border-l,
+	.border-x,
+	.border-y,
+	.divide-x > :not([hidden]) ~ :not([hidden]),
 	.divide-y > :not([hidden]) ~ :not([hidden]) {
 		border-color: rgb(var(--color-border-light));
 	}
 
 	/* Dark mode: change border color */
-	.dark .border, .dark .border-t, .dark .border-r, .dark .border-b, .dark .border-l, 
-	.dark .border-x, .dark .border-y, 
-	.dark .divide-x > :not([hidden]) ~ :not([hidden]), 
+	.dark .border,
+	.dark .border-t,
+	.dark .border-r,
+	.dark .border-b,
+	.dark .border-l,
+	.dark .border-x,
+	.dark .border-y,
+	.dark .divide-x > :not([hidden]) ~ :not([hidden]),
 	.dark .divide-y > :not([hidden]) ~ :not([hidden]) {
 		border-color: rgb(var(--color-border-light));
 	}
@@ -205,11 +214,21 @@ svelte-virtual-list-contents > * + * {
 /* Prevent clock icon in input[type="time"] making the input taller */
 
 /* Chrome, Safari, Edge, Opera */
-input[type="time"]::-webkit-calendar-picker-indicator {
+input[type='time']::-webkit-calendar-picker-indicator {
 	margin: 0;
-  padding: 0;
+	padding: 0;
+}
+
+/* Settings search highlight (used by both the drawer and the setup page) */
+[data-setting-key] {
+	transition: outline 0.8s ease;
+	outline: 2px solid transparent;
+	outline-offset: -2px;
+}
+[data-setting-key].setting-highlight {
+	outline: 2px solid rgb(var(--color-border-accent, 59 130 246));
 }
 
 .svelte-flow__edges {
 	z-index: -10;
-}
+}

package/package/components/AIAgentLogViewer.svelte

@@ -32,7 +32,7 @@ const resultSchema = z.object({
             .optional()
     }))
 });
-let { tools, agentJob, workspaceId, onToolJobLoaded, storedToolCallJobs } = $props();
+let { tools, agentJob, workspaceId, onToolJobLoaded, storedToolCallJobs, noPadding = false } = $props();
 const fakeModuleStates = $state({});
 async function loadMissingJobs(agentActions) {
     const promises = agentActions.map(async (toolCall, idx) => {
@@ -168,7 +168,7 @@ onMount(() => {
 </script>
 
 {#if job}
-	<div class="p-2">
+	<div class={noPadding ? '' : 'p-2'}>
 		<FlowLogViewerWrapper
 			{job}
 			localModuleStates={fakeModuleStates}

package/package/components/AIAgentLogViewer.svelte.d.ts

@@ -8,6 +8,7 @@ interface Props {
     workspaceId?: string | undefined;
     storedToolCallJobs?: Record<number, Job>;
     onToolJobLoaded?: (job: Job, idx: number) => void;
+    noPadding?: boolean;
 }
 declare const AIAgentLogViewer: import("svelte").Component<Props, {}, "">;
 type AIAgentLogViewer = ReturnType<typeof AIAgentLogViewer>;