mirror of
https://github.com/windmill-labs/windmill.git
synced 2026-11-20 16:09:26 +00:00
* feat: move the open in AI session button to the page header Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix: address local review findings on the header session button Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix: update header fold comments and test the page header session source Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix: show the header session button to users who cannot edit the item Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * feat: place the header session button right before the page's main action Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix: drop an always-true guard and stale comments around the header session button Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix: keep the compact autosave label for screen readers and correct two comments Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2924 lines
95 KiB
Svelte
2924 lines
95 KiB
Svelte
<script lang="ts">
|
||
import { buildWsUrl } from '$lib/wsUrl'
|
||
import { paneMinPercent } from '$lib/utils/splitpaneSizing'
|
||
import { processSecretArgs } from './secretArgUtils'
|
||
import type { Schema, SupportedLanguage } from '$lib/common'
|
||
import {
|
||
type CompletedJob,
|
||
type Job,
|
||
JobService,
|
||
type Preview,
|
||
type ScriptLang,
|
||
type ScriptModule
|
||
} from '$lib/gen'
|
||
import { enterpriseLicense, userStore } from '$lib/stores'
|
||
import { copyToClipboard, emptySchema, sendUserToast } from '$lib/utils'
|
||
import Editor from './Editor.svelte'
|
||
import { inferArgs, inferAssets, inferAnsibleExecutionMode } from '$lib/infer'
|
||
import { injectPartitionArg } from '$lib/scriptEditorSchema'
|
||
import { isWorkflowAsCode } from '$lib/components/graph/wacToFlow'
|
||
import WacDiagram from '$lib/components/graph/WacDiagram.svelte'
|
||
import { Pane, Splitpanes } from 'svelte-splitpanes'
|
||
import { canonicalModulePath, findModulePathClash } from './scriptModulePath'
|
||
import SchemaForm from './SchemaForm.svelte'
|
||
import PowerShellCommonParams from './PowerShellCommonParams.svelte'
|
||
import LogPanel from './scriptEditor/LogPanel.svelte'
|
||
import EditorBar, {
|
||
EDITOR_BAR_WIDTH_THRESHOLD,
|
||
EDITOR_BAR_HELPERS_COMPACT_THRESHOLD
|
||
} from './EditorBar.svelte'
|
||
import JobLoader from './JobLoader.svelte'
|
||
import JobProgressBar from '$lib/components/jobs/JobProgressBar.svelte'
|
||
import { createEventDispatcher, getContext, onDestroy, onMount, untrack } from 'svelte'
|
||
import { Button } from './common'
|
||
import SplitPanesWrapper from './splitPanes/SplitPanesWrapper.svelte'
|
||
import WindmillIcon from './icons/WindmillIcon.svelte'
|
||
import * as Y from 'yjs'
|
||
import { scriptLangToEditorLang } from '$lib/scripts'
|
||
import { langToExt } from '$lib/editorLangUtils'
|
||
import { WebsocketProvider } from 'y-websocket'
|
||
import Modal from './common/modal/Modal.svelte'
|
||
import Popover from './meltComponents/Popover.svelte'
|
||
import DiffEditor from './DiffEditor.svelte'
|
||
import {
|
||
Bug,
|
||
ChevronDown,
|
||
Copy,
|
||
CornerDownLeft,
|
||
Disc,
|
||
Download,
|
||
ExternalLink,
|
||
Github,
|
||
GitBranch,
|
||
Play,
|
||
PlayIcon,
|
||
Plus,
|
||
Target,
|
||
Terminal,
|
||
Pencil,
|
||
WandSparkles,
|
||
X,
|
||
Zap
|
||
} from 'lucide-svelte'
|
||
import {
|
||
DebugToolbar,
|
||
DebugPanel,
|
||
DebugConsole,
|
||
getDAPClient,
|
||
debugState,
|
||
resetDAPClient,
|
||
getDebugServerUrl,
|
||
type DebugLanguage,
|
||
isDebuggable,
|
||
getDebugFileExtension,
|
||
fetchContextualVariables,
|
||
signDebugRequest,
|
||
signMultiplayerRequest,
|
||
getDebugErrorMessage
|
||
} from '$lib/components/debug'
|
||
import { SvelteSet } from 'svelte/reactivity'
|
||
import { setLicense } from '$lib/enterpriseUtils'
|
||
import type { ScriptEditorWhitelabelCustomUi } from './custom_ui'
|
||
import Tabs from './common/tabs/Tabs.svelte'
|
||
import Tab from './common/tabs/Tab.svelte'
|
||
import DraggableTabs, { type TabItem } from './common/tabs/DraggableTabs.svelte'
|
||
import { slide } from 'svelte/transition'
|
||
import CaptureTable from '$lib/components/triggers/CaptureTable.svelte'
|
||
import CaptureButton from './triggers/CaptureButton.svelte'
|
||
import { setContext } from 'svelte'
|
||
import HideButton from './apps/editor/settingsPanel/HideButton.svelte'
|
||
import DispatchEventsButton from '$lib/components/runs/DispatchEventsButton.svelte'
|
||
import { SUPPORTED_CHAT_SCRIPT_LANGUAGES } from './copilot/chat/script/core'
|
||
import { getStringError } from './copilot/chat/utils'
|
||
import type { ScriptOptions } from './copilot/chat/ContextManager.svelte'
|
||
import { aiChatManager, AIMode } from './copilot/chat/AIChatManager.svelte'
|
||
import OpenInSessionButton, {
|
||
type OpenInSessionSource
|
||
} from './sessions/OpenInSessionButton.svelte'
|
||
import { setOpenInSessionHandoff } from './sessions/openInSessionContext'
|
||
|
||
// Forward-looking hook for the upcoming session-pane feature: that PR will
|
||
// `setContext('aiChatManager', ...)` from the session wrapper so this editor
|
||
// can detect it and hide its own AI/VS Code controls. On main today nothing
|
||
// sets the context, so `inSessionPane` is always false and these buttons
|
||
// render normally — keep the check anyway to avoid re-touching this file
|
||
// when the session-pane PR lands. Untyped getContext to avoid coupling to
|
||
// the AIChatManager class export (which lives on the chat-visuals PR).
|
||
const inSessionPane = !!getContext('aiChatManager')
|
||
import { triggerableByAI } from '$lib/actions/triggerableByAI.svelte'
|
||
import AssetsDropdownButton from './assets/AssetsDropdownButton.svelte'
|
||
import { canHavePreprocessor } from '$lib/script_helpers'
|
||
import { assetEq, type AssetWithAltAccessType } from './assets/lib'
|
||
import type { ColumnLineage } from './assets/AssetGraph/parsePipelineAnnotations'
|
||
import {
|
||
computeContractMarkers,
|
||
type ContractMarker,
|
||
type SchemaContractGraphContext
|
||
} from './assets/AssetGraph/schemaContracts'
|
||
import { editor as meditor } from 'monaco-editor'
|
||
import type { ReviewChangesOpts } from './copilot/chat/monaco-adapter'
|
||
import GitRepoViewer from './GitRepoViewer.svelte'
|
||
import GitRepoResourcePicker from './GitRepoResourcePicker.svelte'
|
||
import { updateDelegateToGitRepoConfig, insertAdditionalInventories } from '$lib/ansibleUtils'
|
||
import { copilotInfo } from '$lib/aiStore'
|
||
import JsonInputs from '$lib/components/JsonInputs.svelte'
|
||
import { argsToJsonPayload } from '$lib/schema'
|
||
import Toggle from './Toggle.svelte'
|
||
import { deepEqual } from 'fast-equals'
|
||
import { usePreparedAssetSqlQueries } from '$lib/infer.svelte'
|
||
import { resource, watch } from 'runed'
|
||
import { buildScriptRecording, downloadRecordingJson } from './recording/runRecording'
|
||
import DropdownV2 from './DropdownV2.svelte'
|
||
import { useOperatingWorkspace } from '$lib/components/operatingWorkspace.svelte'
|
||
|
||
const operatingWorkspace = useOperatingWorkspace()
|
||
|
||
interface Props {
|
||
// Exported
|
||
schema?: Schema | any
|
||
code: string
|
||
path: string | undefined
|
||
lang: Preview['language']
|
||
/** Identity the test runs as instead of the user (see `previewOnBehalfOf`). */
|
||
previewOnBehalfOf?: string
|
||
kind?: string | undefined
|
||
autoKind?: string | undefined
|
||
template?:
|
||
| 'pgsql'
|
||
| 'mysql'
|
||
| 'script'
|
||
| 'docker'
|
||
| 'powershell'
|
||
| 'bunnative'
|
||
| 'claudesandbox'
|
||
| 'pisandbox'
|
||
| 'wac_python'
|
||
| 'wac_typescript'
|
||
| 'ci_test_bun'
|
||
| 'ci_test_python'
|
||
tag: string | undefined
|
||
initialArgs?: Record<string, any>
|
||
fixedOverflowWidgets?: boolean
|
||
noSyncFromGithub?: boolean
|
||
editor?: Editor | undefined
|
||
diffEditor?: DiffEditor | undefined
|
||
collabMode?: boolean
|
||
edit?: boolean
|
||
noHistory?: boolean
|
||
saveToWorkspace?: boolean
|
||
watchChanges?: boolean
|
||
customUi?: ScriptEditorWhitelabelCustomUi | undefined
|
||
// Pipeline editor: an asset-parse failure should also turn the
|
||
// "parsable" badge red — asset lineage is load-bearing there, so a
|
||
// green badge must mean both the main function AND the asset parse
|
||
// succeeded.
|
||
requireValidAssets?: boolean
|
||
args: Record<string, any>
|
||
// Emitted with the test-form's full-schema validity whenever it changes, so
|
||
// a host (the pipeline editor) can gate a data-upload entry's readiness on
|
||
// whether every required field is filled, not just the S3 file. A callback
|
||
// rather than a bindable so we don't hit the `$bindable(default)` ban.
|
||
onIsValidChange?: (isValid: boolean) => void
|
||
// Custom timeout (in seconds) from the script settings. Forwarded to the
|
||
// preview run so "Test" honors the same timeout a deployed run would,
|
||
// instead of silently falling back to the instance default.
|
||
timeout?: number
|
||
selectedTab?: 'main' | 'preprocessor' | 'diagram'
|
||
hasPreprocessor?: boolean
|
||
captureTable?: CaptureTable | undefined
|
||
showCaptures?: boolean
|
||
stablePathForCaptures?: string
|
||
lastSavedCode?: string | undefined
|
||
lastDeployedCode?: string | undefined
|
||
disableAi?: boolean
|
||
assets?: AssetWithAltAccessType[]
|
||
// Body-inferred column lineage (DuckDB SQL AST), surfaced alongside
|
||
// `assets` so the pipeline editor can render inferred column lineage on
|
||
// the live graph. Empty/undefined for non-DuckDB or when the parser
|
||
// build predates the inference.
|
||
inferredColumnLineage?: ColumnLineage[]
|
||
modules?: { [key: string]: ScriptModule } | null
|
||
editorBarRight?: import('svelte').Snippet
|
||
enablePreprocessorSnippet?: boolean
|
||
/**
|
||
* Layout for the test/preview panel relative to the code editor.
|
||
* `right` (default) splits horizontally with the test panel on the
|
||
* right; `bottom` splits vertically with the test panel below — same
|
||
* orientation the flow editor uses for module step editing.
|
||
*/
|
||
previewLayout?: 'right' | 'bottom'
|
||
/**
|
||
* Fires whenever the test/preview run state changes — used by the
|
||
* pipeline editor to mirror the running script onto the canvas
|
||
* (animate its incoming/outgoing edges) so Test feels equivalent
|
||
* to clicking a run button on the graph.
|
||
*/
|
||
onTestStateChange?: (running: boolean) => void
|
||
// Fired whenever a test run is started from this editor, with the
|
||
// preview job id. Used by whitelabel embedders to track test jobs.
|
||
onTestJob?: (e: { jobId: string }) => void
|
||
// Drives the right-hand test/run pane collapsed state. Seeds the pane
|
||
// collapsed at mount when true, and is edge-triggered afterwards: a later
|
||
// change collapses/expands the pane (but the user's own toggles in between
|
||
// are preserved — the effect only acts on a transition). Defaults to false
|
||
// so the regular /scripts/edit route keeps its open-by-default UX; the
|
||
// session preview collapses it to save space and reopens it in full screen.
|
||
testPanelCollapsed?: boolean
|
||
// Lets the AI toolbar button open the script in a fresh AI session
|
||
// instead of the inline chat panel (see OpenInSessionButton for gating).
|
||
sessionOpen?: OpenInSessionSource
|
||
// Producer-side facts for the live schema-contract diagnostics
|
||
// (`on_schema_change=ignore` suppression + scd2 `_current` fallback),
|
||
// built by the pipeline page from the resolved graph. Absent outside the
|
||
// pipeline editor — the check still runs, just without suppression.
|
||
schemaContractContext?: SchemaContractGraphContext
|
||
// Workspace to scope this editor's calls to (tests, captures, toolbar lookups).
|
||
// Defaults to the operating workspace (see `useOperatingWorkspace`).
|
||
workspaceOverride?: string
|
||
}
|
||
|
||
let {
|
||
schema = $bindable(),
|
||
code = $bindable(),
|
||
path,
|
||
lang,
|
||
previewOnBehalfOf,
|
||
kind = undefined,
|
||
autoKind = undefined,
|
||
template = 'script',
|
||
tag,
|
||
fixedOverflowWidgets = true,
|
||
noSyncFromGithub = false,
|
||
editor = $bindable(undefined),
|
||
diffEditor = $bindable(undefined),
|
||
collabMode = false,
|
||
edit = true,
|
||
noHistory = false,
|
||
saveToWorkspace = false,
|
||
watchChanges = false,
|
||
customUi = undefined,
|
||
requireValidAssets = false,
|
||
args = $bindable(),
|
||
onIsValidChange,
|
||
timeout = undefined,
|
||
selectedTab = $bindable('main'),
|
||
hasPreprocessor = $bindable(false),
|
||
captureTable = $bindable(undefined),
|
||
showCaptures = true,
|
||
stablePathForCaptures = '',
|
||
lastSavedCode = undefined,
|
||
lastDeployedCode = undefined,
|
||
disableAi = false,
|
||
assets = $bindable(),
|
||
inferredColumnLineage = $bindable(),
|
||
modules = $bindable(undefined),
|
||
editorBarRight,
|
||
enablePreprocessorSnippet = false,
|
||
previewLayout = 'right',
|
||
onTestStateChange,
|
||
onTestJob,
|
||
testPanelCollapsed = false,
|
||
sessionOpen = undefined,
|
||
schemaContractContext = undefined,
|
||
workspaceOverride = undefined
|
||
}: Props = $props()
|
||
|
||
let opWs = $derived(workspaceOverride ?? $operatingWorkspace)
|
||
|
||
// Publish this editor's hand-off for AI entry points below it (the preview
|
||
// panel's "AI Fix"), withheld under `disableAi` so an embed that turned AI off
|
||
// gets no entry point that navigates its host to /sessions. Shadows an
|
||
// ancestor's hand-off deliberately: ScriptEditorDrawer mounts this without a
|
||
// `sessionOpen`, and falling through to FlowBuilder's would answer "fix this
|
||
// script" by opening the flow and abandoning the drawer's unsaved content.
|
||
setOpenInSessionHandoff({ source: () => (disableAi ? undefined : sessionOpen) })
|
||
|
||
$effect(() => {
|
||
onTestStateChange?.(testIsLoading)
|
||
})
|
||
|
||
let initialArgs = structuredClone($state.snapshot(args))
|
||
let jsonView = $state(false)
|
||
let schemaHeight = $state(0)
|
||
// Asset-trigger cascade choice for the Test button. Only meaningful when
|
||
// `customUi.previewPanel.downstreamSubscribers > 0`. Defaults to off so
|
||
// iteration on a pipeline script doesn't accidentally fan out runs to
|
||
// downstream subscribers. The user can flip it via the split-button
|
||
// caret next to Test, and the choice sticks for the rest of the session.
|
||
let cascadeDownstream = $state(false)
|
||
let cascadeMenuOpen = $state(false)
|
||
let psCommonParams: Record<string, any> = $state({})
|
||
let showPsCommonParams = $derived(lang === 'powershell' && /^\s*\[CmdletBinding/im.test(code))
|
||
|
||
// Module tab state
|
||
let activeModuleTab: string | null = $state(null)
|
||
// Per-module test panel state (args + schema), persisted across tab switches
|
||
let moduleTestState: Record<string, { args: Record<string, any>; schema: Schema }> = $state({})
|
||
let testPanelArgs: Record<string, any> = $state({})
|
||
let testPanelSchema: Schema = $state(emptySchema())
|
||
// Bumped whenever the args under test are replaced from outside the arg panel. Both arg
|
||
// views key off it: without a bump the JSON editor keeps showing, and on the next
|
||
// keystroke commits, the payload it was seeded with for the previous args.
|
||
let argsRender = $state(0)
|
||
// editorCode is what the editor shows; code always holds the main script content
|
||
let editorCode: string = $state(code)
|
||
// Sync editorCode when code changes externally (template reset, copilot,
|
||
// new-script template init, etc.). We also re-run schema inference in that
|
||
// case — otherwise if the code prop is set after ScriptEditor's onMount (as
|
||
// happens on /scripts/add when initContent sets script.content after the
|
||
// editor has already mounted with an empty string), the schema would stay
|
||
// empty until the user typed into the editor.
|
||
let lastSyncedCode = code
|
||
$effect.pre(() => {
|
||
if (activeModuleTab === null && code !== lastSyncedCode) {
|
||
editorCode = code
|
||
lastSyncedCode = code
|
||
editor?.setCode(editorCode) // immediate sync, don't wait for the 800ms debounce
|
||
untrack(() => inferSchema(code))
|
||
}
|
||
})
|
||
|
||
function switchToModule(modulePath: string) {
|
||
// Re-clicking the tab you are already on is a no-op. Re-running the body would reset this
|
||
// module's test state whenever its inference is still pending or has failed (the catch
|
||
// leaves `moduleTestState` unwritten), losing both the filled-in args and the arg views.
|
||
if (activeModuleTab === modulePath) {
|
||
return
|
||
}
|
||
if (activeModuleTab !== null && modules) {
|
||
// Switching from another module: save its content and test state
|
||
modules[activeModuleTab] = { ...modules[activeModuleTab], content: editorCode }
|
||
moduleTestState[activeModuleTab] = { args: testPanelArgs, schema: testPanelSchema }
|
||
}
|
||
if (modules && modules[modulePath]) {
|
||
activeModuleTab = modulePath
|
||
editorCode = modules[modulePath].content
|
||
editor?.setCode(editorCode)
|
||
// Restore or initialize test state for the new module
|
||
if (moduleTestState[modulePath]) {
|
||
testPanelArgs = moduleTestState[modulePath].args
|
||
testPanelSchema = moduleTestState[modulePath].schema
|
||
} else {
|
||
testPanelArgs = {}
|
||
testPanelSchema = emptySchema()
|
||
// Inference lands after the bump below, so the editor opens on `{}` and the arg
|
||
// views follow the schema in once it arrives. Remounting them again on arrival
|
||
// instead would discard anything typed while it was in flight.
|
||
inferModuleSchema()
|
||
}
|
||
argsRender++
|
||
}
|
||
}
|
||
|
||
function switchToMain() {
|
||
if (activeModuleTab === null) {
|
||
return
|
||
}
|
||
if (modules) {
|
||
// Save current module content and test state
|
||
modules[activeModuleTab] = { ...modules[activeModuleTab], content: editorCode }
|
||
moduleTestState[activeModuleTab] = { args: testPanelArgs, schema: testPanelSchema }
|
||
}
|
||
activeModuleTab = null
|
||
editorCode = code
|
||
lastSyncedCode = code
|
||
editor?.setCode(editorCode)
|
||
argsRender++
|
||
}
|
||
|
||
// Whether the open file is tested as a runnable of its own. A `__mod` helper
|
||
// is.
|
||
let onModuleArgs = $derived(activeModuleTab !== null)
|
||
|
||
let effectiveLang = $derived(
|
||
activeModuleTab && modules?.[activeModuleTab]
|
||
? (modules[activeModuleTab].language as Preview['language'])
|
||
: lang
|
||
)
|
||
|
||
let isWacV2 = $derived.by(() => {
|
||
const mainCode = code
|
||
const isTsWac =
|
||
mainCode.includes('windmill-client') &&
|
||
mainCode.includes('workflow') &&
|
||
mainCode.includes('task')
|
||
const isPyWac =
|
||
(mainCode.includes('import wmill') || mainCode.includes('from wmill')) &&
|
||
mainCode.includes('workflow') &&
|
||
mainCode.includes('task')
|
||
return isTsWac || isPyWac
|
||
})
|
||
let supportsModules = $derived((lang === 'bun' || lang === 'python3') && isWacV2)
|
||
let mainFileName = $derived('script.' + langToExt(scriptLangToEditorLang(lang)))
|
||
|
||
// A module path always ends in a file extension, so this id can't collide with one.
|
||
const MAIN_FILE_TAB_ID = '__main__'
|
||
// Tab order is view state only: `modules` is stored as JSONB, which re-sorts its keys on
|
||
// deploy, so an order written into it would not survive.
|
||
let moduleTabOrder: string[] = $state([])
|
||
let fileTabs = $derived.by<TabItem[]>(() => {
|
||
const paths = Object.keys(modules ?? {})
|
||
const rank = new Map(paths.map((p, i) => [p, i + moduleTabOrder.length]))
|
||
moduleTabOrder.forEach((p, i) => rank.has(p) && rank.set(p, i))
|
||
return [
|
||
{ id: MAIN_FILE_TAB_ID, label: mainFileName, closable: false, pinned: 'left' },
|
||
// Not closable through the strip: closing deletes the module's code, so it stays on
|
||
// the explicit × rather than Delete/Backspace and middle-click.
|
||
...paths
|
||
.sort((a, b) => rank.get(a)! - rank.get(b)!)
|
||
.map((modulePath) => ({
|
||
id: modulePath,
|
||
label: modulePath,
|
||
title: modulePath,
|
||
closable: false
|
||
}))
|
||
]
|
||
})
|
||
|
||
let modulePathInput = $state('')
|
||
let showAddModulePopover = $state(false)
|
||
let modulePathInputEl: HTMLInputElement | undefined = $state(undefined)
|
||
let modulePathError = $state('')
|
||
|
||
let renameModuleInput = $state('')
|
||
let renameModuleError = $state('')
|
||
let renameModuleInputEl: HTMLInputElement | undefined = $state(undefined)
|
||
|
||
const ALL_MODULE_EXTENSIONS: Record<string, ScriptModule['language']> = {
|
||
'.ts': 'bun',
|
||
'.py': 'python3',
|
||
'.go': 'go',
|
||
'.sh': 'bash',
|
||
'.ps1': 'powershell',
|
||
'.sql': 'postgresql',
|
||
'.gql': 'graphql',
|
||
'.php': 'php',
|
||
'.rs': 'rust',
|
||
'.yml': 'ansible',
|
||
'.cs': 'csharp',
|
||
'.nu': 'nu',
|
||
'.java': 'java',
|
||
'.rb': 'ruby'
|
||
}
|
||
|
||
/** Map main script language to allowed module file extensions. */
|
||
const LANG_MODULE_EXTENSIONS: Partial<Record<Preview['language'] & string, string[]>> = {
|
||
python3: ['.py'],
|
||
bun: ['.ts'],
|
||
deno: ['.ts'],
|
||
nativets: ['.ts'],
|
||
go: ['.go'],
|
||
bash: ['.sh'],
|
||
powershell: ['.ps1'],
|
||
postgresql: ['.sql'],
|
||
mysql: ['.sql'],
|
||
bigquery: ['.sql'],
|
||
snowflake: ['.sql'],
|
||
mssql: ['.sql'],
|
||
oracledb: ['.sql'],
|
||
duckdb: ['.sql'],
|
||
graphql: ['.gql'],
|
||
php: ['.php'],
|
||
rust: ['.rs'],
|
||
ansible: ['.yml'],
|
||
csharp: ['.cs'],
|
||
nu: ['.nu'],
|
||
java: ['.java'],
|
||
ruby: ['.rb'],
|
||
bunnative: ['.ts']
|
||
}
|
||
|
||
let allowedModuleExtensions = $derived(
|
||
lang
|
||
? (LANG_MODULE_EXTENSIONS[lang] ?? Object.keys(ALL_MODULE_EXTENSIONS))
|
||
: Object.keys(ALL_MODULE_EXTENSIONS)
|
||
)
|
||
|
||
function inferModuleLang(filePath: string): ScriptModule['language'] | undefined {
|
||
for (const [ext, moduleLang] of Object.entries(ALL_MODULE_EXTENSIONS)) {
|
||
if (filePath.endsWith(ext)) return moduleLang
|
||
}
|
||
return undefined
|
||
}
|
||
|
||
function getModuleDefaultContent(filePath: string): string {
|
||
if (filePath.endsWith('.py')) {
|
||
return `def hello() -> str:\n return "world"\n`
|
||
} else if (filePath.endsWith('.ts')) {
|
||
return `export function hello(): string {\n return "world"\n}\n`
|
||
} else if (filePath.endsWith('.go')) {
|
||
return `package inner\n\nfunc Hello() string {\n\treturn "world"\n}\n`
|
||
} else if (filePath.endsWith('.sh')) {
|
||
return `#!/bin/bash\necho "world"\n`
|
||
} else if (filePath.endsWith('.ps1')) {
|
||
return `function Hello {\n return "world"\n}\n`
|
||
} else if (filePath.endsWith('.sql')) {
|
||
return `SELECT 'world' as result;\n`
|
||
} else if (filePath.endsWith('.gql')) {
|
||
return `query Hello {\n hello\n}\n`
|
||
} else if (filePath.endsWith('.php')) {
|
||
return `<?php\nfunction hello(): string {\n return "world";\n}\n`
|
||
} else if (filePath.endsWith('.rs')) {
|
||
return `pub fn hello() -> String {\n "world".to_string()\n}\n`
|
||
} else if (filePath.endsWith('.yml')) {
|
||
return `---\n- name: Hello\n debug:\n msg: "world"\n`
|
||
} else if (filePath.endsWith('.cs')) {
|
||
return `public static string Hello() {\n return "world";\n}\n`
|
||
} else if (filePath.endsWith('.nu')) {
|
||
return `def hello [] {\n "world"\n}\n`
|
||
} else if (filePath.endsWith('.java')) {
|
||
return `public class Helper {\n public static String hello() {\n return "world";\n }\n}\n`
|
||
} else if (filePath.endsWith('.rb')) {
|
||
return `def hello\n "world"\nend\n`
|
||
}
|
||
return ''
|
||
}
|
||
|
||
function validateModulePath(path: string): string {
|
||
if (!path.trim()) return ''
|
||
const canonical = canonicalModulePath(path)
|
||
if ('error' in canonical) return canonical.error
|
||
const moduleLang = inferModuleLang(canonical.path)
|
||
if (!moduleLang) {
|
||
const exts = allowedModuleExtensions.join(', ')
|
||
return `File must end with a supported extension: ${exts}`
|
||
}
|
||
const matchedExt = allowedModuleExtensions.find((ext) => canonical.path.endsWith(ext))
|
||
if (!matchedExt) {
|
||
const exts = allowedModuleExtensions.join(', ')
|
||
return `File must end with a supported extension for this language: ${exts}`
|
||
}
|
||
const clash = findModulePathClash(modules, canonical.path)
|
||
if (clash) {
|
||
return `Module ${clash} already exists`
|
||
}
|
||
return ''
|
||
}
|
||
|
||
function addModule() {
|
||
if (!modulePathInput.trim()) return
|
||
const canonical = canonicalModulePath(modulePathInput)
|
||
if ('error' in canonical) {
|
||
modulePathError = canonical.error
|
||
return
|
||
}
|
||
const modulePath = canonical.path
|
||
const error = validateModulePath(modulePath)
|
||
if (error) {
|
||
modulePathError = error
|
||
return
|
||
}
|
||
if (!modules) {
|
||
modules = {}
|
||
}
|
||
modules[modulePath] = {
|
||
content: getModuleDefaultContent(modulePath),
|
||
language: inferModuleLang(modulePath)!
|
||
}
|
||
modulePathInput = ''
|
||
modulePathError = ''
|
||
showAddModulePopover = false
|
||
switchToModule(modulePath)
|
||
}
|
||
|
||
function removeModule(modulePath: string) {
|
||
if (!modules) return
|
||
if (activeModuleTab === modulePath) {
|
||
switchToMain()
|
||
}
|
||
delete modules[modulePath]
|
||
delete moduleTestState[modulePath]
|
||
modules = { ...modules }
|
||
moduleTabOrder = moduleTabOrder.filter((p) => p !== modulePath)
|
||
}
|
||
|
||
function validateRenameModulePath(newPath: string, oldPath: string): string {
|
||
if (!newPath.trim()) return ''
|
||
const canonical = canonicalModulePath(newPath)
|
||
if ('error' in canonical) return canonical.error
|
||
const moduleLang = inferModuleLang(canonical.path)
|
||
if (!moduleLang) {
|
||
const exts = allowedModuleExtensions.join(', ')
|
||
return `File must end with a supported extension: ${exts}`
|
||
}
|
||
const matchedExt = allowedModuleExtensions.find((ext) => canonical.path.endsWith(ext))
|
||
if (!matchedExt) {
|
||
const exts = allowedModuleExtensions.join(', ')
|
||
return `File must end with a supported extension for this language: ${exts}`
|
||
}
|
||
const clash = findModulePathClash(modules, canonical.path, oldPath)
|
||
if (clash) {
|
||
return `Module ${clash} already exists`
|
||
}
|
||
return ''
|
||
}
|
||
|
||
/// A spelling of the name the module already has. Nothing to do, so the button
|
||
/// that would submit it stays disabled rather than being a dead click.
|
||
function renameIsNoop(input: string, oldPath: string): boolean {
|
||
const canonical = canonicalModulePath(input)
|
||
return 'path' in canonical && canonical.path === oldPath
|
||
}
|
||
|
||
function prefillRename(modulePath: string) {
|
||
renameModuleInput = modulePath
|
||
renameModuleError = ''
|
||
}
|
||
|
||
function renameModule(oldPath: string) {
|
||
if (!renameModuleInput.trim()) return
|
||
const canonical = canonicalModulePath(renameModuleInput)
|
||
if ('error' in canonical) {
|
||
renameModuleError = canonical.error
|
||
return
|
||
}
|
||
const newPath = canonical.path
|
||
if (newPath === oldPath) return
|
||
const error = validateRenameModulePath(newPath, oldPath)
|
||
if (error) {
|
||
renameModuleError = error
|
||
return
|
||
}
|
||
if (!modules) return
|
||
const mod = modules[oldPath]
|
||
const newLang = inferModuleLang(newPath)
|
||
delete modules[oldPath]
|
||
modules[newPath] = { ...mod, language: newLang ?? mod.language }
|
||
modules = { ...modules }
|
||
moduleTabOrder = moduleTabOrder.map((p) => (p === oldPath ? newPath : p))
|
||
if (moduleTestState[oldPath]) {
|
||
moduleTestState[newPath] = moduleTestState[oldPath]
|
||
delete moduleTestState[oldPath]
|
||
}
|
||
if (activeModuleTab === oldPath) {
|
||
activeModuleTab = newPath
|
||
}
|
||
renameModuleInput = ''
|
||
renameModuleError = ''
|
||
}
|
||
|
||
/** Save the active module tab's editor content back into the modules map (no UI side-effects). */
|
||
function flushModuleContent() {
|
||
if (activeModuleTab !== null && modules) {
|
||
modules[activeModuleTab] = { ...modules[activeModuleTab], content: editorCode }
|
||
}
|
||
}
|
||
|
||
/** Flush module content and reset the editor back to the main script tab. */
|
||
export function flushModuleState() {
|
||
if (activeModuleTab !== null && modules) {
|
||
flushModuleContent()
|
||
moduleTestState[activeModuleTab] = { args: testPanelArgs, schema: testPanelSchema }
|
||
activeModuleTab = null
|
||
editorCode = code
|
||
}
|
||
}
|
||
|
||
$effect.pre(() => {
|
||
if (schema == undefined) {
|
||
schema = emptySchema()
|
||
}
|
||
})
|
||
let showHistoryDrawer = $state(false)
|
||
|
||
let jobProgressBar: JobProgressBar | undefined = $state(undefined)
|
||
let diffMode = $state(false)
|
||
|
||
let websocketAlive = $state({
|
||
pyright: false,
|
||
deno: false,
|
||
go: false,
|
||
ruff: false,
|
||
shellcheck: false
|
||
})
|
||
|
||
let inferAssetsRes = resource([() => lang, () => code, () => code], () => inferAssets(lang, code))
|
||
let preparedSqlQueries = usePreparedAssetSqlQueries(
|
||
() => inferAssetsRes.current?.sql_queries,
|
||
() => opWs
|
||
)
|
||
// Asset-parse validity for the editor badge. `undefined` while loading (so
|
||
// the badge doesn't flicker red); only an explicit parser error counts as
|
||
// invalid. Surfaced only when `requireValidAssets` (pipeline editor).
|
||
let validAssets = $derived(
|
||
requireValidAssets ? inferAssetsRes.current?.status !== 'error' : undefined
|
||
)
|
||
|
||
const dispatch = createEventDispatcher()
|
||
|
||
$effect(() => {
|
||
watchChanges &&
|
||
(code != undefined || schema != undefined) &&
|
||
dispatch('change', { code, schema })
|
||
})
|
||
|
||
watch(
|
||
() => inferAssetsRes.current,
|
||
() => {
|
||
if (!inferAssetsRes.current || inferAssetsRes.current?.status === 'error') {
|
||
// Clear stale lineage on parse error / unset, so a script switch
|
||
// whose new body fails to parse can't leave the previous script's
|
||
// inferred column lineage bound to the new path.
|
||
if (inferredColumnLineage !== undefined) inferredColumnLineage = undefined
|
||
return
|
||
}
|
||
let newAssets = inferAssetsRes.current.assets as AssetWithAltAccessType[]
|
||
for (const asset of newAssets) {
|
||
const old = assets?.find((a) => assetEq(a, asset))
|
||
if (old?.alt_access_type) asset.alt_access_type = old.alt_access_type
|
||
}
|
||
const normalizedAssets = newAssets.length > 0 ? newAssets : undefined
|
||
if (!deepEqual(assets, normalizedAssets)) assets = normalizedAssets
|
||
|
||
const newLineage = inferAssetsRes.current.column_lineage
|
||
const normalizedLineage = newLineage && newLineage.length > 0 ? newLineage : undefined
|
||
if (!deepEqual(inferredColumnLineage, normalizedLineage))
|
||
inferredColumnLineage = normalizedLineage
|
||
}
|
||
)
|
||
|
||
// Live schema-contract diagnostics (pipelines gap #2b): diff the buffer's
|
||
// asset refs against the captured producer schemas and surface mismatches
|
||
// as Monaco warning squiggles — the as-you-type mirror of the authoritative
|
||
// save-time check. The result is a prop on Editor (not an imperative call)
|
||
// because this can resolve before Monaco initializes on mount. Sequenced so
|
||
// a slow schema fetch can't overwrite the markers of a newer keystroke.
|
||
let contractMarkers: ContractMarker[] = $state([])
|
||
let contractCheckSeq = 0
|
||
watch([() => inferAssetsRes.current, () => schemaContractContext], () => {
|
||
const res = inferAssetsRes.current
|
||
const workspace = opWs
|
||
const seq = ++contractCheckSeq
|
||
if (!workspace || !res || res.status === 'error') {
|
||
contractMarkers = []
|
||
return
|
||
}
|
||
const bufferCode = code
|
||
computeContractMarkers(
|
||
workspace,
|
||
bufferCode,
|
||
(res.assets ?? []) as AssetWithAltAccessType[],
|
||
schemaContractContext
|
||
)
|
||
.then((markers) => {
|
||
if (seq === contractCheckSeq) contractMarkers = markers
|
||
})
|
||
.catch((e) => console.error('schema-contract diagnostics failed', e))
|
||
})
|
||
|
||
watch([() => code, () => lang], () => {
|
||
if (lang !== 'ansible') return
|
||
inferAnsibleExecutionMode(code).then((v) => {
|
||
if (
|
||
v !== undefined &&
|
||
(v.delegate_to_git_repo_details === null ||
|
||
v.delegate_to_git_repo_details.resource !== ansibleAlternativeExecutionMode?.resource ||
|
||
v.delegate_to_git_repo_details.playbook !== ansibleAlternativeExecutionMode?.playbook ||
|
||
v.delegate_to_git_repo_details.inventories_location !==
|
||
ansibleAlternativeExecutionMode?.inventories_location ||
|
||
v.delegate_to_git_repo_details.commit !== ansibleAlternativeExecutionMode?.commit ||
|
||
v.git_ssh_identity !== ansibleGitSshIdentity)
|
||
) {
|
||
ansibleAlternativeExecutionMode = v.delegate_to_git_repo_details
|
||
ansibleGitSshIdentity = v.git_ssh_identity
|
||
}
|
||
})
|
||
})
|
||
|
||
let width = $state(1200)
|
||
|
||
let jobLoader: JobLoader | undefined = $state(undefined)
|
||
|
||
let isValid: boolean = $state(true)
|
||
// Mirror the test-form validity out to an optional host callback.
|
||
$effect(() => {
|
||
onIsValidChange?.(isValid)
|
||
})
|
||
let scriptProgress = $state(undefined)
|
||
|
||
let logPanel: LogPanel | undefined = $state(undefined)
|
||
// Test
|
||
let testIsLoading = $state(false)
|
||
let testJob: Job | undefined = $state()
|
||
let pastPreviews: CompletedJob[] = $state([])
|
||
let historyTabActive = false
|
||
let pastPreviewsRequest: ReturnType<typeof JobService.listCompletedJobs> | undefined
|
||
let validCode = $state(true)
|
||
|
||
// Recording: nothing is captured live — a "record" run just remembers the
|
||
// completed job id plus the code/args/schema as they were at run time, and
|
||
// the recording is built from the completed job on download.
|
||
let recordingArmed = false
|
||
let lastRecordingJobId: string | undefined = $state(undefined)
|
||
let recordingMeta:
|
||
| {
|
||
scriptPath: string
|
||
code: string
|
||
language: string
|
||
args: Record<string, any>
|
||
schema?: Record<string, any>
|
||
}
|
||
| undefined = undefined
|
||
let downloadingRecording = $state(false)
|
||
|
||
let wsProvider: WebsocketProvider | undefined = $state(undefined)
|
||
let yContent: Y.Text | undefined = $state(undefined)
|
||
let peers: { name: string }[] = $state([])
|
||
let showCollabPopup = $state(false)
|
||
|
||
let ansibleAlternativeExecutionMode = $state<
|
||
| { resource?: string; commit?: string; inventories_location?: string; playbook?: string }
|
||
| null
|
||
| undefined
|
||
>()
|
||
let ansibleGitSshIdentity = $state<string[]>([])
|
||
|
||
// Debug mode state
|
||
let debugMode = $state(false)
|
||
let debugBreakpoints = new SvelteSet<number>()
|
||
let breakpointDecorations: string[] = $state([])
|
||
let currentLineDecoration: string[] = $state([])
|
||
let hoverBreakpointDecoration: string[] = $state([])
|
||
// Line currently showing the ghost breakpoint, used to short-circuit redundant
|
||
// deltaDecorations calls on every mousemove event.
|
||
let hoverBreakpointLine: number | null = null
|
||
// Get the DAP server URL based on language
|
||
const dapServerUrl = $derived(getDebugServerUrl((lang || 'python3') as DebugLanguage))
|
||
const debugFilePath = $derived(`/tmp/script${getDebugFileExtension(lang || '')}`)
|
||
let dapClient = $state<ReturnType<typeof getDAPClient> | null>(null)
|
||
const isDebuggableScript = $derived(isDebuggable(lang || ''))
|
||
// Derived: show debug panel when connected and (running or stopped, but not terminated)
|
||
const showDebugPanel = $derived(
|
||
debugMode && $debugState.connected && ($debugState.running || $debugState.stopped)
|
||
)
|
||
// Derived: debug has a result (script completed)
|
||
const hasDebugResult = $derived(debugMode && $debugState.result !== undefined)
|
||
// Show debug console at bottom of editor when debugging is active
|
||
let showDebugConsole = $state(true)
|
||
const debugConsoleVisible = $derived(showDebugPanel && showDebugConsole)
|
||
// Selected stack frame ID - shared between DebugPanel and DebugConsole
|
||
let selectedDebugFrameId: number | null = $state(null)
|
||
// Use selected frame or first frame for console context
|
||
const currentDebugFrameId = $derived(selectedDebugFrameId ?? $debugState.stackFrames[0]?.id)
|
||
// Job ID of the current debug session (for expression signing/audit logging)
|
||
let debugSessionJobId: string | null = $state(null)
|
||
// Pane sizes for editor/console split (percentage)
|
||
let editorPaneSize = $state(75)
|
||
let consolePaneSize = $state(25)
|
||
|
||
// Breakpoint decoration options
|
||
// stickiness: 1 = NeverGrowsWhenTypingAtEdges - decorations track their position when code changes
|
||
const breakpointDecorationType: meditor.IModelDecorationOptions = {
|
||
glyphMarginClassName: 'debug-breakpoint-glyph',
|
||
glyphMarginHoverMessage: { value: 'Breakpoint (click to remove)' },
|
||
stickiness: 1
|
||
}
|
||
|
||
// Ghost breakpoint shown while hovering the gutter on a line without a breakpoint
|
||
const hoverBreakpointDecorationType: meditor.IModelDecorationOptions = {
|
||
glyphMarginClassName: 'debug-breakpoint-glyph-hover',
|
||
glyphMarginHoverMessage: { value: 'Click to add a breakpoint' },
|
||
stickiness: 1
|
||
}
|
||
|
||
const currentLineDecorationType = {
|
||
isWholeLine: true,
|
||
className: 'debug-current-line',
|
||
glyphMarginClassName: 'debug-current-line-glyph'
|
||
}
|
||
|
||
const url = new URL(window.location.toString())
|
||
let initialCollab = /true|1/i.test(url.searchParams.get('collab') ?? '0')
|
||
|
||
if (initialCollab) {
|
||
setCollaborationMode()
|
||
url.searchParams.delete('collab')
|
||
url.searchParams.delete('path')
|
||
history.replaceState(null, '', url)
|
||
}
|
||
|
||
function onKeyDown(event: KeyboardEvent) {
|
||
if ((event.ctrlKey || event.metaKey) && event.key == 'Enter') {
|
||
event.preventDefault()
|
||
runTest()
|
||
} else if ((event.ctrlKey || event.metaKey) && event.key == 'u') {
|
||
event.preventDefault()
|
||
toggleTestPanel()
|
||
}
|
||
}
|
||
|
||
export function setArgs(nargs: Record<string, any>) {
|
||
args = nargs
|
||
argsRender++
|
||
}
|
||
|
||
export async function runTest(opts?: { cascade?: boolean; skipDdlGuard?: boolean }) {
|
||
// Intercept DDL statements (offer to turn them into data table migrations)
|
||
// on every run path, not just the editor's Cmd+Enter. `skipDdlGuard` is set
|
||
// by the Cmd+Enter action, which already guarded before calling us.
|
||
if (!opts?.skipDdlGuard) {
|
||
if ((await editor?.guardDdlBeforeRun()) === false) return
|
||
// The guard may have rewritten the code (migrated statements stripped);
|
||
// `editorCode` is kept in sync by the editor binding, so mirror the
|
||
// on:change handler and pull it into `code` before we run.
|
||
if (activeModuleTab === null) code = editorCode
|
||
}
|
||
// When the caller forces a cascade choice (e.g. the canvas runnable
|
||
// menu's "Run + trigger N downstream"), also flip the persistent
|
||
// `cascadeDownstream` state so the split button's label/icon reflect
|
||
// the active mode after the run kicks off — keeps "what mode am I in"
|
||
// visible instead of having a one-off run silently disagree with the
|
||
// UI. The caller is welcome to bump the signal repeatedly; we just
|
||
// keep the latest choice as the active mode.
|
||
if (opts?.cascade !== undefined) cascadeDownstream = opts.cascade
|
||
// Discard any previous recording when running a normal test
|
||
if (!recordingArmed) {
|
||
lastRecordingJobId = undefined
|
||
}
|
||
// Not defined if JobProgressBar not loaded
|
||
jobProgressBar?.reset()
|
||
// Flush module edits back to modules map before running preview
|
||
flushModuleContent()
|
||
|
||
const onModule = onModuleArgs
|
||
const testCode = onModule ? editorCode : code
|
||
const testLang = onModule ? effectiveLang : lang
|
||
const rawTestArgs = onModule
|
||
? testPanelArgs
|
||
: selectedTab === 'preprocessor' || kind === 'preprocessor'
|
||
? { _ENTRYPOINT_OVERRIDE: 'preprocessor', ...(args ?? {}) }
|
||
: (args ?? {})
|
||
const testSchema = onModule ? testPanelSchema : schema
|
||
const testArgs = await processSecretArgs(rawTestArgs, testSchema, opWs)
|
||
if (showPsCommonParams) {
|
||
for (const [k, v] of Object.entries(psCommonParams)) {
|
||
if (v !== undefined && v !== false && v !== '') {
|
||
testArgs[k] = v
|
||
}
|
||
}
|
||
}
|
||
// In pipeline-editor contexts (downstreamSubscribers prop set), default
|
||
// the test run to *just this step* by passing the backend opt-out arg.
|
||
// The user can run with cascade via the split button's caret option,
|
||
// which flips `cascadeDownstream` and lets dispatch fire normally.
|
||
if ((customUi?.previewPanel?.downstreamSubscribers ?? 0) > 0 && !cascadeDownstream) {
|
||
testArgs['_wmill_skip_asset_dispatch'] = true
|
||
}
|
||
|
||
//@ts-ignore
|
||
let job = await jobLoader.runPreview(
|
||
path,
|
||
testCode,
|
||
testLang,
|
||
testArgs,
|
||
tag,
|
||
undefined,
|
||
undefined,
|
||
{
|
||
done(x) {
|
||
if (recordingArmed) {
|
||
recordingArmed = false
|
||
lastRecordingJobId = x?.id
|
||
}
|
||
if (historyTabActive) {
|
||
loadPastTests()
|
||
}
|
||
},
|
||
doneError({ id, error }) {
|
||
// A failed run is still a completed job and records fine.
|
||
if (recordingArmed) {
|
||
recordingArmed = false
|
||
lastRecordingJobId = id
|
||
}
|
||
console.error(error)
|
||
}
|
||
},
|
||
undefined,
|
||
// A `__mod` helper is tested alone, so its siblings are left out.
|
||
onModule ? undefined : modules,
|
||
undefined,
|
||
timeout,
|
||
{ onBehalfOf: previewOnBehalfOf }
|
||
)
|
||
if (job) {
|
||
onTestJob?.({ jobId: job })
|
||
}
|
||
logPanel?.setFocusToLogs()
|
||
return job
|
||
}
|
||
|
||
async function recordAndTest() {
|
||
lastRecordingJobId = undefined
|
||
recordingMeta = {
|
||
scriptPath: path ?? '',
|
||
code,
|
||
language: lang ?? '',
|
||
args: JSON.parse(JSON.stringify(args ?? {})),
|
||
schema: schema ? JSON.parse(JSON.stringify(schema)) : undefined
|
||
}
|
||
recordingArmed = true
|
||
await runTest()
|
||
}
|
||
|
||
async function downloadRecording() {
|
||
if (!lastRecordingJobId || !recordingMeta || downloadingRecording) return
|
||
downloadingRecording = true
|
||
try {
|
||
const recording = await buildScriptRecording(opWs!, lastRecordingJobId, recordingMeta)
|
||
downloadRecordingJson(
|
||
recording,
|
||
`script-recording-${(recording.script_path || 'untitled').replace(/\//g, '-')}`
|
||
)
|
||
} catch (e: any) {
|
||
sendUserToast('Could not build the recording', true, undefined, e?.toString())
|
||
} finally {
|
||
downloadingRecording = false
|
||
}
|
||
}
|
||
|
||
async function loadPastTests(): Promise<void> {
|
||
pastPreviewsRequest?.cancel()
|
||
const req = JobService.listCompletedJobs({
|
||
workspace: opWs!,
|
||
jobKinds: 'preview',
|
||
createdBy: $userStore?.username,
|
||
scriptPathExact: path,
|
||
hasNullParent: true
|
||
})
|
||
pastPreviewsRequest = req
|
||
try {
|
||
const result = await req
|
||
if (pastPreviewsRequest === req) {
|
||
pastPreviews = result
|
||
}
|
||
} catch (err) {
|
||
if (!(err instanceof Error) || err.name !== 'CancelError') {
|
||
throw err
|
||
}
|
||
} finally {
|
||
if (pastPreviewsRequest === req) {
|
||
pastPreviewsRequest = undefined
|
||
}
|
||
}
|
||
}
|
||
|
||
export async function inferSchema(
|
||
code: string,
|
||
{
|
||
nlang,
|
||
resetArgs = false,
|
||
applyInitialArgs = false
|
||
}: {
|
||
nlang?: SupportedLanguage
|
||
resetArgs?: boolean
|
||
applyInitialArgs?: boolean
|
||
} = {}
|
||
) {
|
||
let nschema = schema ?? emptySchema()
|
||
|
||
try {
|
||
const result = await inferArgs(
|
||
nlang ?? lang,
|
||
code,
|
||
nschema,
|
||
selectedTab === 'preprocessor' || kind === 'preprocessor' ? 'preprocessor' : undefined
|
||
)
|
||
|
||
if (kind === 'preprocessor') {
|
||
hasPreprocessor = false
|
||
selectedTab = 'main'
|
||
} else {
|
||
hasPreprocessor =
|
||
(selectedTab === 'preprocessor' ? !result?.auto_kind : result?.has_preprocessor) ?? false
|
||
|
||
if (!hasPreprocessor && selectedTab === 'preprocessor') {
|
||
selectedTab = 'main'
|
||
}
|
||
}
|
||
|
||
validCode = true
|
||
if (resetArgs) {
|
||
args = {}
|
||
}
|
||
if (applyInitialArgs) {
|
||
// we reapply initial args as the schema form might have cleared them between mount and the schema inference
|
||
args = initialArgs
|
||
}
|
||
injectPartitionArg(nschema, args, nlang ?? lang, code)
|
||
schema = nschema
|
||
} catch (e) {
|
||
validCode = false
|
||
}
|
||
}
|
||
|
||
async function inferModuleSchema() {
|
||
if (activeModuleTab === null) return
|
||
try {
|
||
await inferArgs(effectiveLang, editorCode, testPanelSchema)
|
||
injectPartitionArg(testPanelSchema, testPanelArgs, effectiveLang, editorCode)
|
||
moduleTestState[activeModuleTab] = { args: testPanelArgs, schema: testPanelSchema }
|
||
} catch (e) {
|
||
// Module code may be in-progress; silently ignore
|
||
}
|
||
}
|
||
|
||
let gitRepoResourcePickerOpen = $state(false)
|
||
let commitHashForGitRepo = $derived(ansibleAlternativeExecutionMode?.commit)
|
||
|
||
// Check if delegate_to_git_repo exists in the code
|
||
let hasDelegateToGitRepo = $derived(code && code.includes('delegate_to_git_repo:'))
|
||
|
||
function handleDelegateConfigUpdate(event: {
|
||
detail: { resourcePath: string; playbook?: string; inventoriesLocation?: string }
|
||
}) {
|
||
if (!editor) return
|
||
|
||
const currentCode = editor.getCode()
|
||
const newCode = updateDelegateToGitRepoConfig(currentCode, {
|
||
resource: event.detail.resourcePath,
|
||
playbook: event.detail.playbook,
|
||
inventories_location: event.detail.inventoriesLocation
|
||
})
|
||
editor.setCode(newCode)
|
||
|
||
// Trigger schema inference to update assets
|
||
inferSchema(newCode)
|
||
}
|
||
|
||
function handleAddInventories(event: { detail: { inventoryPaths: string[] } }) {
|
||
if (!editor) return
|
||
|
||
const currentCode = editor.getCode()
|
||
const newCode = insertAdditionalInventories(currentCode, event.detail.inventoryPaths)
|
||
editor.setCode(newCode)
|
||
|
||
// Trigger schema inference to update assets
|
||
inferSchema(newCode)
|
||
}
|
||
|
||
// Debug functions
|
||
function toggleBreakpoint(line: number): void {
|
||
if (debugBreakpoints.has(line)) {
|
||
debugBreakpoints.delete(line)
|
||
} else {
|
||
debugBreakpoints.add(line)
|
||
}
|
||
updateBreakpointDecorations()
|
||
clearHoverBreakpointDecoration()
|
||
}
|
||
|
||
function updateHoverBreakpointDecoration(line: number): void {
|
||
if (hoverBreakpointLine === line) return
|
||
const monacoEditor = editor?.getEditor?.()
|
||
if (!monacoEditor) return
|
||
|
||
const decorations = [
|
||
{
|
||
range: { startLineNumber: line, startColumn: 1, endLineNumber: line, endColumn: 1 },
|
||
options: hoverBreakpointDecorationType
|
||
}
|
||
]
|
||
|
||
const oldDecorations = untrack(() => hoverBreakpointDecoration)
|
||
hoverBreakpointDecoration = monacoEditor.deltaDecorations(oldDecorations, decorations)
|
||
hoverBreakpointLine = line
|
||
}
|
||
|
||
function clearHoverBreakpointDecoration(): void {
|
||
if (hoverBreakpointLine === null) return
|
||
const monacoEditor = editor?.getEditor?.()
|
||
if (!monacoEditor) return
|
||
const oldDecorations = untrack(() => hoverBreakpointDecoration)
|
||
if (oldDecorations.length > 0) {
|
||
hoverBreakpointDecoration = monacoEditor.deltaDecorations(oldDecorations, [])
|
||
}
|
||
hoverBreakpointLine = null
|
||
}
|
||
|
||
function updateBreakpointDecorations(): void {
|
||
const monacoEditor = editor?.getEditor?.()
|
||
if (!monacoEditor) return
|
||
|
||
const decorations = Array.from(debugBreakpoints).map((line) => ({
|
||
range: { startLineNumber: line, startColumn: 1, endLineNumber: line, endColumn: 1 },
|
||
options: breakpointDecorationType
|
||
}))
|
||
|
||
// Use untrack to prevent reactive loop when reading the old decorations
|
||
const oldDecorations = untrack(() => breakpointDecorations)
|
||
breakpointDecorations = monacoEditor.deltaDecorations(oldDecorations, decorations)
|
||
}
|
||
|
||
// Refresh breakpoint line numbers from decoration positions after code edits
|
||
function refreshBreakpointPositions(): void {
|
||
const monacoEditor = editor?.getEditor?.()
|
||
if (!monacoEditor || breakpointDecorations.length === 0) return
|
||
|
||
const model = monacoEditor.getModel()
|
||
if (!model) return
|
||
|
||
// Get current line numbers from decorations (Monaco tracks positions when code changes)
|
||
const newLines = new Set<number>()
|
||
for (const decorationId of breakpointDecorations) {
|
||
const range = model.getDecorationRange(decorationId)
|
||
if (range) {
|
||
newLines.add(range.startLineNumber)
|
||
}
|
||
}
|
||
|
||
// Check if positions changed
|
||
const oldLines = Array.from(debugBreakpoints).sort((a, b) => a - b)
|
||
const updatedLines = Array.from(newLines).sort((a, b) => a - b)
|
||
|
||
const positionsChanged =
|
||
oldLines.length !== updatedLines.length ||
|
||
oldLines.some((line, i) => line !== updatedLines[i])
|
||
|
||
if (positionsChanged) {
|
||
// Update breakpoints set with new positions
|
||
debugBreakpoints.clear()
|
||
for (const line of newLines) {
|
||
debugBreakpoints.add(line)
|
||
}
|
||
// Sync updated positions with server if connected
|
||
syncBreakpointsWithServer()
|
||
}
|
||
}
|
||
|
||
// Sync breakpoints with DAP server when connected
|
||
async function syncBreakpointsWithServer(): Promise<void> {
|
||
if (!dapClient || !dapClient.isConnected()) return
|
||
|
||
try {
|
||
await dapClient.setBreakpoints(debugFilePath, Array.from(debugBreakpoints))
|
||
} catch (error) {
|
||
console.error('Failed to sync breakpoints:', error)
|
||
}
|
||
}
|
||
|
||
function updateCurrentLineDecoration(line: number | undefined): void {
|
||
const monacoEditor = editor?.getEditor?.()
|
||
if (!monacoEditor) return
|
||
|
||
// Use untrack to prevent reactive loop when reading the old decorations
|
||
const oldDecorations = untrack(() => currentLineDecoration)
|
||
|
||
if (!line) {
|
||
currentLineDecoration = monacoEditor.deltaDecorations(oldDecorations, [])
|
||
return
|
||
}
|
||
|
||
const decorations = [
|
||
{
|
||
range: { startLineNumber: line, startColumn: 1, endLineNumber: line, endColumn: 1 },
|
||
options: currentLineDecorationType
|
||
}
|
||
]
|
||
|
||
currentLineDecoration = monacoEditor.deltaDecorations(oldDecorations, decorations)
|
||
monacoEditor.revealLineInCenter(line)
|
||
}
|
||
|
||
async function startDebugging(): Promise<void> {
|
||
try {
|
||
// Show console when starting a debug session
|
||
showDebugConsole = true
|
||
// Reset selected frame when starting new session
|
||
selectedDebugFrameId = null
|
||
|
||
// Always reset and create a fresh DAP client with the correct URL for the current language
|
||
// This ensures we connect to the correct endpoint even if language changed
|
||
resetDAPClient()
|
||
dapClient = getDAPClient(dapServerUrl)
|
||
|
||
// Fetch contextual variables (WM_WORKSPACE, WM_TOKEN, etc.) from backend
|
||
const env = await fetchContextualVariables(opWs ?? '')
|
||
|
||
// Sign the debug request (creates audit log entry)
|
||
let signedPayload
|
||
try {
|
||
signedPayload = await signDebugRequest(opWs ?? '', code ?? '', lang ?? 'python3')
|
||
debugSessionJobId = signedPayload.job_id
|
||
} catch (signError) {
|
||
sendUserToast(getDebugErrorMessage(signError), true)
|
||
return
|
||
}
|
||
|
||
await dapClient.connect()
|
||
await dapClient.initialize()
|
||
await dapClient.setBreakpoints(debugFilePath, Array.from(debugBreakpoints))
|
||
await dapClient.configurationDone()
|
||
// Pass the signed token along with other launch parameters
|
||
await dapClient.launch({
|
||
code,
|
||
cwd: '/tmp',
|
||
args: args ?? {},
|
||
callMain: true,
|
||
env,
|
||
// JWT token for verification by the debugger
|
||
token: signedPayload.token
|
||
})
|
||
} catch (error) {
|
||
console.error('Failed to start debugging:', error)
|
||
sendUserToast(getDebugErrorMessage(error), true)
|
||
}
|
||
}
|
||
|
||
async function stopDebugging(): Promise<void> {
|
||
if (!dapClient) return
|
||
try {
|
||
await dapClient.terminate()
|
||
dapClient.disconnect()
|
||
} catch (error) {
|
||
console.error('Failed to stop debugging:', error)
|
||
} finally {
|
||
// Clear the job ID when debug session ends
|
||
debugSessionJobId = null
|
||
}
|
||
}
|
||
|
||
async function continueExecution(): Promise<void> {
|
||
if (!dapClient) return
|
||
await dapClient.continue_()
|
||
}
|
||
|
||
async function stepOver(): Promise<void> {
|
||
if (!dapClient) return
|
||
await dapClient.stepOver()
|
||
}
|
||
|
||
async function stepIn(): Promise<void> {
|
||
if (!dapClient) return
|
||
await dapClient.stepIn()
|
||
}
|
||
|
||
async function stepOut(): Promise<void> {
|
||
if (!dapClient) return
|
||
await dapClient.stepOut()
|
||
}
|
||
|
||
function clearAllBreakpoints(): void {
|
||
debugBreakpoints.clear()
|
||
updateBreakpointDecorations()
|
||
}
|
||
|
||
function toggleDebugMode(): void {
|
||
if (debugMode) {
|
||
// Exiting debug mode - clean up
|
||
debugMode = false
|
||
stopDebugging()
|
||
clearAllBreakpoints()
|
||
updateCurrentLineDecoration(undefined)
|
||
} else {
|
||
debugMode = true
|
||
// The debug UI mounts inside the test pane, which is collapsed to 0 in
|
||
// AI sessions. Must stay a one-shot expand at the toggle, not a reactive
|
||
// effect: an effect would reopen the pane whenever the user collapsed it
|
||
// while debugging.
|
||
if (testPanelSize === 0) {
|
||
expandTestPanel()
|
||
}
|
||
}
|
||
}
|
||
|
||
// Subscribe to debug state changes for current line highlighting
|
||
$effect(() => {
|
||
const currentLine = $debugState.currentLine
|
||
if (debugMode) {
|
||
untrack(() => updateCurrentLineDecoration(currentLine))
|
||
}
|
||
})
|
||
|
||
// Watch for language changes - exit debug mode and reset client when language changes
|
||
let lastDebugLang: typeof lang | undefined = undefined
|
||
$effect(() => {
|
||
const currentLang = lang
|
||
if (lastDebugLang !== undefined && lastDebugLang !== currentLang && debugMode) {
|
||
// Language changed while in debug mode - exit debug mode
|
||
untrack(() => {
|
||
// Stop any running debug session
|
||
if (dapClient) {
|
||
dapClient
|
||
.terminate()
|
||
.catch(() => {})
|
||
.finally(() => {
|
||
dapClient?.disconnect()
|
||
})
|
||
}
|
||
// Reset the singleton
|
||
resetDAPClient()
|
||
dapClient = null
|
||
// Exit debug mode
|
||
debugMode = false
|
||
// Clear decorations
|
||
clearAllBreakpoints()
|
||
updateCurrentLineDecoration(undefined)
|
||
})
|
||
}
|
||
lastDebugLang = currentLang
|
||
})
|
||
|
||
// Set up glyph margin click handler for breakpoints when debug mode is enabled
|
||
$effect(() => {
|
||
const monacoEditor = editor?.getEditor?.()
|
||
if (!monacoEditor) return
|
||
|
||
if (debugMode && isDebuggableScript) {
|
||
// Enable glyph margin for breakpoints
|
||
monacoEditor.updateOptions({ glyphMargin: true })
|
||
|
||
// Add click handler for glyph margin (breakpoint toggle)
|
||
const mouseDownDisposable = monacoEditor.onMouseDown((e) => {
|
||
if (e.target.type === meditor.MouseTargetType.GUTTER_GLYPH_MARGIN) {
|
||
const line = e.target.position?.lineNumber
|
||
if (line) {
|
||
toggleBreakpoint(line)
|
||
}
|
||
}
|
||
})
|
||
|
||
// Show a ghost breakpoint while hovering anywhere in the gutter on an empty line.
|
||
// Hover area is intentionally wider than the click target — clicks still only
|
||
// toggle when landing on the glyph margin itself, but the ghost helps users find it.
|
||
const mouseMoveDisposable = monacoEditor.onMouseMove((e) => {
|
||
const t = e.target.type
|
||
const isGutter =
|
||
t === meditor.MouseTargetType.GUTTER_GLYPH_MARGIN ||
|
||
t === meditor.MouseTargetType.GUTTER_LINE_NUMBERS ||
|
||
t === meditor.MouseTargetType.GUTTER_LINE_DECORATIONS
|
||
const line = e.target.position?.lineNumber
|
||
if (isGutter && line && !debugBreakpoints.has(line)) {
|
||
updateHoverBreakpointDecoration(line)
|
||
} else {
|
||
clearHoverBreakpointDecoration()
|
||
}
|
||
})
|
||
|
||
const mouseLeaveDisposable = monacoEditor.onMouseLeave(() => {
|
||
clearHoverBreakpointDecoration()
|
||
})
|
||
|
||
// Add F9 keyboard shortcut for toggling breakpoint at cursor
|
||
monacoEditor.addCommand(120, () => {
|
||
// KeyCode.F9 = 120
|
||
const position = monacoEditor.getPosition()
|
||
if (position) {
|
||
toggleBreakpoint(position.lineNumber)
|
||
}
|
||
})
|
||
|
||
// Debug stepping keyboard shortcuts (only active when stopped)
|
||
// F8 = Continue (KeyCode.F8 = 119)
|
||
monacoEditor.addCommand(119, () => {
|
||
if ($debugState.stopped) continueExecution()
|
||
})
|
||
|
||
// F6 = Step Over (KeyCode.F6 = 117)
|
||
monacoEditor.addCommand(117, () => {
|
||
if ($debugState.stopped) stepOver()
|
||
})
|
||
|
||
// F7 = Step Into (KeyCode.F7 = 118)
|
||
monacoEditor.addCommand(118, () => {
|
||
if ($debugState.stopped) stepIn()
|
||
})
|
||
|
||
// Shift+F8 = Step Out (KeyMod.Shift | KeyCode.F8 = 1024 | 119 = 1143)
|
||
monacoEditor.addCommand(1143, () => {
|
||
if ($debugState.stopped) stepOut()
|
||
})
|
||
|
||
return () => {
|
||
mouseDownDisposable.dispose()
|
||
mouseMoveDisposable.dispose()
|
||
mouseLeaveDisposable.dispose()
|
||
clearHoverBreakpointDecoration()
|
||
// Disable glyph margin when exiting debug mode
|
||
monacoEditor.updateOptions({ glyphMargin: false })
|
||
}
|
||
} else {
|
||
// Ensure glyph margin is disabled when not in debug mode
|
||
monacoEditor.updateOptions({ glyphMargin: false })
|
||
}
|
||
})
|
||
|
||
onMount(async () => {
|
||
await inferSchema(code, { applyInitialArgs: true })
|
||
// Retry once if the initial inference failed silently (e.g. transient WASM
|
||
// init race). Without this, users had to modify the code to trigger a
|
||
// second on:change-driven inference.
|
||
if (!validCode && code && lang) {
|
||
await inferSchema(code, { applyInitialArgs: true })
|
||
}
|
||
aiChatManager.saveAndClear()
|
||
aiChatManager.changeMode(AIMode.SCRIPT)
|
||
if (customUi?.previewPanel?.loadLastRunOnMount) {
|
||
void loadLastRunIntoTestPanel()
|
||
}
|
||
})
|
||
|
||
// Pull the most recent top-level completed job for this script path and
|
||
// feed it through the JobLoader so the preview pane renders its logs +
|
||
// result. Best-effort: any error (no job yet, network blip) leaves the
|
||
// panel empty rather than surfacing a toast — this is a passive "show
|
||
// what's there" affordance, not a user action. Skipped when a test is
|
||
// already running so a live job's stream is never clobbered.
|
||
async function loadLastRunIntoTestPanel(): Promise<void> {
|
||
if (!path || !opWs) return
|
||
if (testIsLoading || testJob !== undefined) return
|
||
try {
|
||
const jobs = await JobService.listCompletedJobs({
|
||
workspace: opWs,
|
||
scriptPathExact: path,
|
||
hasNullParent: true,
|
||
perPage: 1,
|
||
orderDesc: true
|
||
})
|
||
const lastId = jobs[0]?.id
|
||
if (lastId && !testIsLoading && testJob === undefined) {
|
||
await jobLoader?.watchJob(lastId)
|
||
}
|
||
} catch (e) {
|
||
// Silent: empty preview pane is the natural fallback.
|
||
}
|
||
}
|
||
|
||
setLicense()
|
||
export async function setCollaborationMode() {
|
||
await setLicense()
|
||
if (!$enterpriseLicense) {
|
||
sendUserToast(`Multiplayer is an enterprise feature`, true, [
|
||
{
|
||
label: 'Upgrade',
|
||
callback: () => {
|
||
window.open('https://www.windmill.dev/pricing', '_blank')
|
||
}
|
||
}
|
||
])
|
||
return
|
||
}
|
||
|
||
let token: string | undefined
|
||
try {
|
||
token = await signMultiplayerRequest(opWs ?? '')
|
||
} catch (e) {
|
||
console.error('Failed to sign multiplayer request:', e)
|
||
sendUserToast('Failed to authorize multiplayer session', true)
|
||
return
|
||
}
|
||
|
||
const ydoc = new Y.Doc()
|
||
if (wsProvider) {
|
||
wsProvider.destroy()
|
||
}
|
||
let yContentInit = ydoc.getText('content')
|
||
|
||
wsProvider = new WebsocketProvider(
|
||
buildWsUrl('/ws_mp/'),
|
||
opWs + '/' + (path ?? 'no-room-name'),
|
||
ydoc,
|
||
{ connect: false, params: { token } }
|
||
)
|
||
|
||
wsProvider.on('sync', (isSynced: boolean) => {
|
||
if (isSynced && yContentInit?.toJSON() == '') {
|
||
showCollabPopup = true
|
||
yContentInit?.insert(0, code)
|
||
}
|
||
yContent = yContentInit
|
||
})
|
||
|
||
wsProvider.on('connection-error', (WSErrorEvent) => {
|
||
console.error(WSErrorEvent)
|
||
sendUserToast('Multiplayer server connection had an error', true)
|
||
})
|
||
wsProvider.connect()
|
||
const awareness = wsProvider.awareness
|
||
|
||
awareness.setLocalStateField('user', {
|
||
name: $userStore?.username
|
||
})
|
||
|
||
function setPeers() {
|
||
peers = Array.from(awareness.getStates().values()).map((x) => x?.['user'])
|
||
}
|
||
|
||
setPeers()
|
||
// You can observe when a user updates their awareness information
|
||
awareness.on('change', (changes) => {
|
||
setPeers()
|
||
})
|
||
}
|
||
|
||
export function disableCollaboration() {
|
||
if (!wsProvider?.shouldConnect) return
|
||
peers = []
|
||
wsProvider?.disconnect()
|
||
wsProvider.destroy()
|
||
wsProvider = undefined
|
||
}
|
||
|
||
onDestroy(() => {
|
||
pastPreviewsRequest?.cancel()
|
||
pastPreviewsRequest = undefined
|
||
disableCollaboration()
|
||
aiChatManager.scriptEditorApplyCode = undefined
|
||
aiChatManager.scriptEditorShowDiffMode = undefined
|
||
aiChatManager.scriptEditorGetLintErrors = undefined
|
||
aiChatManager.scriptEditorOptions = undefined
|
||
aiChatManager.saveAndClear()
|
||
aiChatManager.changeMode(AIMode.NAVIGATOR)
|
||
// Clean up debug mode
|
||
if (debugMode) {
|
||
stopDebugging()
|
||
resetDAPClient()
|
||
}
|
||
})
|
||
|
||
function asKind(str: string | undefined) {
|
||
return str as 'script' | 'approval' | 'trigger' | undefined
|
||
}
|
||
|
||
function collabUrl() {
|
||
let url = new URL(window.location.toString().split('#')[0])
|
||
url.search = ''
|
||
return (
|
||
`${url}?collab=1&workspace=${encodeURIComponent(opWs ?? '')}&lang=${encodeURIComponent(lang ?? '')}` +
|
||
(edit ? '' : `&path=${path}`)
|
||
)
|
||
}
|
||
|
||
const WAC_CONTEXT_LANGUAGES = ['python3', 'bun']
|
||
let isWac = $derived(
|
||
template === 'wac_python' ||
|
||
template === 'wac_typescript' ||
|
||
autoKind === 'wac' ||
|
||
(code && lang ? isWorkflowAsCode(code, lang) : false)
|
||
)
|
||
let workflowAsCodeAiContext = $derived(
|
||
activeModuleTab === null && isWac && WAC_CONTEXT_LANGUAGES.includes(lang ?? '')
|
||
)
|
||
let showTabs = $derived(hasPreprocessor || isWac)
|
||
$effect(() => {
|
||
!hasPreprocessor && (selectedTab = 'main')
|
||
})
|
||
// `main` and `preprocessor` describe the same args under different schemas; every other tab
|
||
// (`diagram`) runs against main's schema, so it collapses into `main` here.
|
||
let lastSchemaTab = untrack(() => (selectedTab === 'preprocessor' ? 'preprocessor' : 'main'))
|
||
$effect(() => {
|
||
// Only depend on selectedTab (preprocessor ↔ main toggle).
|
||
// Code changes are handled by the editor on:change handler and
|
||
// explicit inferSchema calls (initContent, onMount), so we read
|
||
// `code` inside untrack to avoid a redundant double-inference race.
|
||
selectedTab &&
|
||
untrack(() => {
|
||
const schemaTab = selectedTab === 'preprocessor' ? 'preprocessor' : 'main'
|
||
const switched = schemaTab !== lastSchemaTab
|
||
lastSchemaTab = schemaTab
|
||
if (!code) return
|
||
// Bump on the switch itself, not on the inference it starts: the other tab's schema
|
||
// only lands once that resolves, and remounting the arg views then would discard
|
||
// anything typed while it was in flight. An untouched editor follows the schema in.
|
||
if (switched) {
|
||
argsRender++
|
||
}
|
||
inferSchema(code)
|
||
})
|
||
})
|
||
|
||
export async function updateArgs(newArgs: Record<string, any>) {
|
||
if (Object.keys(newArgs).length > 0) {
|
||
args = { ...newArgs }
|
||
argsRender++
|
||
}
|
||
}
|
||
|
||
setContext('disableTooltips', untrack(() => customUi)?.disableTooltips === true)
|
||
|
||
// Pixel minimum size for the test pane while open. The pane's `minSize`
|
||
// is a percentage of the *split axis* (width for `right` layout, height
|
||
// for `bottom`), so we derive it from whichever container dimension the
|
||
// splitter actually distributes. Without this layout switch, the bottom
|
||
// layout would translate a 400px width-fraction into a height-fraction,
|
||
// which on wide screens is far too tall and on tall narrow screens far
|
||
// too short.
|
||
let splitContainerWidth = $state(0)
|
||
let splitContainerHeight = $state(0)
|
||
const testPaneMinPx = $derived(previewLayout === 'bottom' ? 220 : 400)
|
||
const splitAxisExtent = $derived(
|
||
previewLayout === 'bottom' ? splitContainerHeight : splitContainerWidth
|
||
)
|
||
const testPaneMinPercent = $derived(paneMinPercent(splitAxisExtent, testPaneMinPx))
|
||
|
||
// Raw user-controlled test size (what the splitter wrote, or what the
|
||
// toggle set). The size we actually pass to <Pane> is clamped to the
|
||
// dynamic minimum below — so when the editor shrinks, the displayed test
|
||
// pane grows to honor the new minimum without needing an effect. The code
|
||
// pane's size is purely derived from it (100 - test).
|
||
// `testPanelCollapsed` seeds the raw value at 0 (collapsed) while
|
||
// keeping the "remembered" size at 30, so the user's first toggle expands
|
||
// the pane to a sensible width rather than 0.
|
||
let rawTestPanelSize = $state(untrack(() => (testPanelCollapsed ? 0 : 30)))
|
||
let storedTestPanelSize = 30
|
||
const testPanelSize = $derived(
|
||
rawTestPanelSize === 0 ? 0 : Math.max(rawTestPanelSize, testPaneMinPercent)
|
||
)
|
||
const codePanelSize = $derived(100 - testPanelSize)
|
||
|
||
function expandTestPanel() {
|
||
// Restore the remembered *intent* only. `testPanelSize` clamps up to the
|
||
// dynamic pixel-min reactively, so we must NOT bake `testPaneMinPercent`
|
||
// into the raw size here: when the container is still narrow (e.g. the
|
||
// frame the session preview enters full screen, before the pane widens),
|
||
// that min is a huge fraction and would stick as an oversized pane.
|
||
rawTestPanelSize = storedTestPanelSize
|
||
}
|
||
|
||
function collapseTestPanel() {
|
||
// Store the raw (unclamped) preference so reopening on a wider screen
|
||
// restores the user's intent, not the pixel-min that inflated the pane.
|
||
storedTestPanelSize = rawTestPanelSize
|
||
rawTestPanelSize = 0
|
||
}
|
||
|
||
function toggleTestPanel() {
|
||
if (testPanelSize > 0) {
|
||
collapseTestPanel()
|
||
} else {
|
||
expandTestPanel()
|
||
}
|
||
}
|
||
|
||
// React to an external `testPanelCollapsed` change (e.g. the session preview
|
||
// entering/leaving full screen) without clobbering the user's own toggles:
|
||
// only act on a genuine transition, reading the live size untracked so a drag
|
||
// never re-runs this. The mount seed already matches `testPanelCollapsed`, so
|
||
// the initial run is a no-op.
|
||
$effect(() => {
|
||
const collapsed = testPanelCollapsed
|
||
untrack(() => {
|
||
if (collapsed && testPanelSize > 0) {
|
||
collapseTestPanel()
|
||
} else if (!collapsed && testPanelSize === 0) {
|
||
expandTestPanel()
|
||
}
|
||
})
|
||
})
|
||
|
||
// When the compact preview shows a SchemaForm above the logs
|
||
// (`argsAboveLogs`), give the preview pane extra height so the args
|
||
// form doesn't shrink the logs/result area. This is a deliberate
|
||
// $effect (not $derived): the schema loads async and the same
|
||
// code/test sizes are two-way bound to the splitpane drag handle, so
|
||
// the offset is folded into the user-resizable state once on the
|
||
// has-args transition — manual resizing still works afterwards.
|
||
let hasArgsAboveLogs = $derived(
|
||
customUi?.previewPanel?.argsAboveLogs === true &&
|
||
!!schema?.properties &&
|
||
Object.keys(schema.properties).length > 0
|
||
)
|
||
let argsHeightBonus = $state(0)
|
||
$effect(() => {
|
||
const want = hasArgsAboveLogs ? 18 : 0
|
||
untrack(() => {
|
||
const delta = want - argsHeightBonus
|
||
if (delta === 0) return
|
||
if (testPanelSize > 0) {
|
||
rawTestPanelSize += delta
|
||
} else {
|
||
// preview collapsed — bake the bonus into the size it
|
||
// restores to so it lands correctly on expand.
|
||
storedTestPanelSize += delta
|
||
}
|
||
argsHeightBonus = want
|
||
})
|
||
})
|
||
|
||
function getError(job: Job | undefined) {
|
||
if (job != undefined && job.type === 'CompletedJob' && !job.success) {
|
||
return getStringError(job.result)
|
||
}
|
||
return undefined
|
||
}
|
||
|
||
function showDiffMode() {
|
||
const model = editor?.getModel()
|
||
if (model == undefined) return
|
||
diffMode = true
|
||
diffEditor?.showWithModelAndOriginal(lastDeployedCode ?? '', model)
|
||
editor?.hide()
|
||
}
|
||
|
||
function hideDiffMode() {
|
||
diffMode = false
|
||
diffEditor?.hide()
|
||
editor?.show()
|
||
}
|
||
|
||
let error = $derived(getError(testJob))
|
||
|
||
$effect(() => {
|
||
;[
|
||
editor,
|
||
lastSavedCode,
|
||
lastDeployedCode,
|
||
diffMode,
|
||
workflowAsCodeAiContext,
|
||
args,
|
||
error,
|
||
lang,
|
||
path
|
||
]
|
||
untrack(() => {
|
||
const options: ScriptOptions = {
|
||
getCode: () => code,
|
||
lang: lang as ScriptLang,
|
||
error,
|
||
args: args ?? {},
|
||
path,
|
||
lastSavedCode,
|
||
lastDeployedCode,
|
||
diffMode,
|
||
workflowAsCode: workflowAsCodeAiContext
|
||
}
|
||
aiChatManager.scriptEditorOptions = options
|
||
aiChatManager.scriptEditorApplyCode = async (code: string, opts?: ReviewChangesOpts) => {
|
||
hideDiffMode()
|
||
await editor?.reviewAndApplyCode(code, opts)
|
||
}
|
||
aiChatManager.scriptEditorShowDiffMode = showDiffMode
|
||
aiChatManager.scriptEditorGetLintErrors = () => {
|
||
return (
|
||
editor?.getLintErrors() ?? { errorCount: 0, warningCount: 0, errors: [], warnings: [] }
|
||
)
|
||
}
|
||
})
|
||
})
|
||
</script>
|
||
|
||
<JobLoader
|
||
noCode={true}
|
||
workspaceOverride={opWs}
|
||
bind:scriptProgress
|
||
bind:this={jobLoader}
|
||
bind:isLoading={testIsLoading}
|
||
bind:job={testJob}
|
||
/>
|
||
|
||
<svelte:window onkeydown={onKeyDown} />
|
||
|
||
<!-- Standalone triggerable registration for the script editor -->
|
||
<div
|
||
style="display: none"
|
||
use:triggerableByAI={{
|
||
id: 'script-editor',
|
||
description: 'Component to edit a script'
|
||
}}
|
||
></div>
|
||
|
||
<Modal title="Invite others" bind:open={showCollabPopup}>
|
||
<div>Have others join by sharing the following url:</div>
|
||
<div class="flex gap-2 pr-4">
|
||
<input type="text" disabled value={collabUrl()} />
|
||
|
||
<Button
|
||
color="light"
|
||
startIcon={{ icon: Copy }}
|
||
iconOnly
|
||
on:click={() => copyToClipboard(collabUrl())}
|
||
/>
|
||
</div>
|
||
</Modal>
|
||
|
||
<div class="border-b shadow-sm px-1 pr-4" bind:clientWidth={width}>
|
||
<div class="flex justify-between space-x-2">
|
||
{#if args}
|
||
<EditorBar
|
||
workspace={opWs}
|
||
scriptPath={edit ? path : undefined}
|
||
on:toggleCollabMode={() => {
|
||
if (wsProvider?.shouldConnect) {
|
||
disableCollaboration()
|
||
} else {
|
||
setCollaborationMode()
|
||
}
|
||
}}
|
||
on:showDiffMode={showDiffMode}
|
||
on:hideDiffMode={hideDiffMode}
|
||
customUi={customUi?.editorBar}
|
||
collabLive={wsProvider?.shouldConnect}
|
||
{collabMode}
|
||
{validCode}
|
||
{validAssets}
|
||
iconOnly={width < EDITOR_BAR_WIDTH_THRESHOLD}
|
||
compactHelpers={width < EDITOR_BAR_HELPERS_COMPACT_THRESHOLD}
|
||
on:collabPopup={() => (showCollabPopup = true)}
|
||
{editor}
|
||
{lang}
|
||
on:createScriptFromInlineScript
|
||
{websocketAlive}
|
||
collabUsers={peers}
|
||
kind={asKind(kind)}
|
||
{template}
|
||
{args}
|
||
{noHistory}
|
||
{saveToWorkspace}
|
||
lastDeployedCode={lastDeployedCode && lastDeployedCode !== code
|
||
? lastDeployedCode
|
||
: undefined}
|
||
{diffMode}
|
||
bind:showHistoryDrawer
|
||
>
|
||
{#snippet right()}
|
||
{@render editorBarRight?.()}
|
||
{/snippet}
|
||
</EditorBar>
|
||
{/if}
|
||
{#if !noSyncFromGithub && customUi?.editorBar?.useVsCode != false && !inSessionPane}
|
||
<div class="py-1">
|
||
<Button
|
||
target="_blank"
|
||
href="https://www.windmill.dev/docs/cli_local_dev/vscode-extension"
|
||
variant="subtle"
|
||
unifiedSize="md"
|
||
iconOnly={width < EDITOR_BAR_WIDTH_THRESHOLD}
|
||
title="Use VS Code"
|
||
startIcon={{
|
||
icon: Github
|
||
}}
|
||
>
|
||
VScode
|
||
</Button>
|
||
</div>
|
||
{/if}
|
||
</div>
|
||
</div>
|
||
<SplitPanesWrapper>
|
||
<div
|
||
bind:clientWidth={splitContainerWidth}
|
||
bind:clientHeight={splitContainerHeight}
|
||
class="h-full"
|
||
>
|
||
<Splitpanes class="!overflow-visible" horizontal={previewLayout === 'bottom'}>
|
||
<Pane size={codePanelSize} minSize={0} class="!overflow-visible">
|
||
{#if lang === 'ansible' && ansibleAlternativeExecutionMode != null}
|
||
<!-- Vertical split for ansible with assets -->
|
||
<Splitpanes horizontal class="!overflow-visible h-full">
|
||
<Pane size={60} minSize={30} class="!overflow-visible">
|
||
{@render editorContent()}
|
||
</Pane>
|
||
<Pane size={40} minSize={20} class="!overflow-visible">
|
||
<div
|
||
class="h-full flex flex-col bg-surface border-l border-gray-200 dark:border-gray-700"
|
||
>
|
||
<div class="p-3 border-b border-gray-200 dark:border-gray-700">
|
||
<h4 class="text-sm font-semibold text-primary">File Browser</h4>
|
||
</div>
|
||
<GitRepoViewer
|
||
workspace={opWs}
|
||
gitRepoResourcePath={ansibleAlternativeExecutionMode?.resource || ''}
|
||
gitSshIdentity={ansibleGitSshIdentity}
|
||
bind:commitHashInput={commitHashForGitRepo}
|
||
/>
|
||
</div>
|
||
</Pane>
|
||
</Splitpanes>
|
||
{:else}
|
||
<!-- Original single editor layout -->
|
||
{@render editorContent()}
|
||
{/if}
|
||
</Pane>
|
||
<Pane
|
||
bind:size={() => testPanelSize, (v) => (rawTestPanelSize = v)}
|
||
minSize={testPaneMinPercent}
|
||
class={customUi?.previewPanel?.hideArgs ? '!overflow-visible' : ''}
|
||
>
|
||
<div
|
||
data-test-panel
|
||
class={customUi?.previewPanel?.hideArgs
|
||
? 'flex flex-col h-full !overflow-visible'
|
||
: 'flex flex-col h-full'}
|
||
>
|
||
{#if showTabs}
|
||
<div transition:slide={{ duration: 200 }}>
|
||
<Tabs bind:selected={selectedTab}>
|
||
<Tab value="main" label="Main" />
|
||
{#if hasPreprocessor}
|
||
<div transition:slide={{ duration: 200, axis: 'x' }}>
|
||
<Tab value="preprocessor" label="Preprocessor" />
|
||
</div>
|
||
{/if}
|
||
{#if isWac}
|
||
<div transition:slide={{ duration: 200, axis: 'x' }}>
|
||
<Tab value="diagram" label="Diagram" />
|
||
</div>
|
||
{/if}
|
||
</Tabs>
|
||
</div>
|
||
{/if}
|
||
|
||
{#if debugMode && isDebuggableScript}
|
||
<div transition:slide={{ duration: 200 }}>
|
||
<DebugToolbar
|
||
connected={$debugState.connected}
|
||
running={$debugState.running}
|
||
stopped={$debugState.stopped}
|
||
breakpointCount={debugBreakpoints.size}
|
||
onStart={startDebugging}
|
||
onStop={stopDebugging}
|
||
onContinue={continueExecution}
|
||
onStepOver={stepOver}
|
||
onStepIn={stepIn}
|
||
onStepOut={stepOut}
|
||
onClearBreakpoints={clearAllBreakpoints}
|
||
/>
|
||
</div>
|
||
{/if}
|
||
|
||
{#if selectedTab === 'diagram'}
|
||
<div class="flex-1 min-h-0">
|
||
<WacDiagram {code} language={lang ?? ''} />
|
||
</div>
|
||
{:else}
|
||
{#if previewLayout !== 'bottom'}
|
||
<!-- min-h keeps room for the absolute controls when debug mode hides the run buttons -->
|
||
<div class="flex justify-center pt-1 relative min-h-9">
|
||
<div class="absolute top-2 left-2">
|
||
<HideButton
|
||
hidden={false}
|
||
direction="right"
|
||
panelName="Test"
|
||
shortcut="U"
|
||
size="md"
|
||
on:click={() => {
|
||
toggleTestPanel()
|
||
}}
|
||
/>
|
||
</div>
|
||
{#if !(debugMode && isDebuggableScript)}
|
||
<div class="flex flex-row gap-2">
|
||
<div
|
||
class="flex flex-row divide-x divide-gray-800 dark:divide-gray-300 items-stretch"
|
||
>
|
||
{#if testIsLoading}
|
||
{@render cancelTestButton('md', 'w-full')}
|
||
{:else}
|
||
{@const disableTriggerButton =
|
||
customUi?.previewPanel?.disableTriggerButton === true}
|
||
{@render runTestButton(
|
||
'md',
|
||
`w-full ${!disableTriggerButton ? 'rounded-r-none' : ''}`
|
||
)}
|
||
{#if !disableTriggerButton}
|
||
<CaptureButton on:openTriggers />
|
||
{/if}
|
||
{/if}
|
||
</div>
|
||
{#if lastRecordingJobId}
|
||
<Button
|
||
on:click={downloadRecording}
|
||
unifiedSize="md"
|
||
startIcon={{ icon: Download }}
|
||
iconOnly
|
||
loading={downloadingRecording}
|
||
title="Download recording"
|
||
/>
|
||
{/if}
|
||
</div>
|
||
{/if}
|
||
<div class="absolute top-2 right-2 flex items-center gap-2">
|
||
{#if customUi?.previewPanel?.disableJsonView !== true}
|
||
<Toggle size="2xs" bind:checked={jsonView} options={{ right: 'JSON' }} />
|
||
{/if}
|
||
<DropdownV2
|
||
size="xs"
|
||
items={[
|
||
{
|
||
displayName: 'Test & record',
|
||
icon: Disc,
|
||
action: () => recordAndTest()
|
||
}
|
||
]}
|
||
/>
|
||
</div>
|
||
</div>
|
||
{/if}
|
||
{#if customUi?.previewPanel?.hideArgs}
|
||
<!-- Compact preview layout used by the pipeline editor: no args
|
||
column (most pipeline scripts take no inputs) and a full-width
|
||
LogPanel. The controls sit in normal flow rather than floating
|
||
onto the editor band, which Firefox clipped (transform +
|
||
overflow: visible on the parent splitpane Pane). -->
|
||
<div class="h-full flex flex-col">
|
||
<!-- Test sits at the top right, the last run's link under it. -->
|
||
<div class="shrink-0 flex flex-col items-end gap-1 px-2 pt-2 pb-1">
|
||
<div>
|
||
{#if testIsLoading}
|
||
{@render cancelTestButton('sm', 'shadow-md')}
|
||
{:else if (customUi?.previewPanel?.downstreamSubscribers ?? 0) > 0 || customUi?.previewPanel?.onBoundedRun}
|
||
<!-- Split button: primary "Test" runs just this step
|
||
(skips the asset-trigger cascade); the caret
|
||
opens a popover with the cascade option labelled
|
||
by the downstream count. The active mode is
|
||
reflected in both the button label and the
|
||
check-mark on the menu item so the user always
|
||
knows whether the next run will fan out. A
|
||
pure-reader-only root has no subscriber downstream
|
||
but still gets `onBoundedRun`, so the split button
|
||
also opens for it (with the cascade item hidden). -->
|
||
{@const downstream = customUi?.previewPanel?.downstreamSubscribers ?? 0}
|
||
<div class="flex items-stretch shadow-md rounded-md overflow-hidden">
|
||
<Button
|
||
on:click={() => runTest()}
|
||
unifiedSize="sm"
|
||
btnClasses="rounded-r-none"
|
||
variant="accent-secondary"
|
||
startIcon={{
|
||
icon: cascadeDownstream ? Zap : Play,
|
||
classes: 'animate-none'
|
||
}}
|
||
shortCut={{ Icon: CornerDownLeft }}
|
||
>
|
||
{cascadeDownstream ? `Test + trigger ${downstream}` : 'Test'}
|
||
</Button>
|
||
<Popover
|
||
placement="bottom-end"
|
||
bind:isOpen={cascadeMenuOpen}
|
||
usePointerDownOutside
|
||
contentClasses="p-0"
|
||
>
|
||
{#snippet trigger()}
|
||
<!-- min-h-7 matches Button's unifiedSize="sm" (28px);
|
||
the bg/text/hover classes mirror Button's
|
||
`variant="accent-secondary"` so the split reads as
|
||
one connected control instead of two mismatched
|
||
buttons. The left seam uses a translucent
|
||
foreground-tinted border so it stays visible
|
||
against both the base and hover bg without
|
||
fighting the variant's color. -->
|
||
<button
|
||
type="button"
|
||
class="self-stretch min-h-7 px-1.5 flex items-center justify-center bg-surface-accent-secondary hover:bg-surface-accent-secondary-hover focus-visible:bg-surface-accent-secondary-clicked text-white dark:text-deep-blue-900 border-l border-white/30 dark:border-deep-blue-900/30 transition-colors"
|
||
title="Run options"
|
||
aria-label="Run options"
|
||
>
|
||
<ChevronDown size={14} />
|
||
</button>
|
||
{/snippet}
|
||
{#snippet content({ close })}
|
||
<div class="w-72 py-1 text-xs">
|
||
<button
|
||
type="button"
|
||
class="w-full text-left px-3 py-2 hover:bg-surface-hover flex items-start gap-2"
|
||
onclick={() => {
|
||
cascadeDownstream = false
|
||
close()
|
||
void runTest()
|
||
}}
|
||
>
|
||
<Play
|
||
size={14}
|
||
class="mt-0.5 shrink-0 text-emerald-700 dark:text-emerald-400"
|
||
/>
|
||
<div class="flex flex-col min-w-0">
|
||
<span class="font-medium">
|
||
Test {!cascadeDownstream ? '(current)' : ''}
|
||
</span>
|
||
<span class="text-2xs text-secondary"
|
||
>Run just this step. Downstream subscribers are not triggered.</span
|
||
>
|
||
</div>
|
||
</button>
|
||
{#if downstream > 0}
|
||
<button
|
||
type="button"
|
||
class="w-full text-left px-3 py-2 hover:bg-surface-hover flex items-start gap-2"
|
||
onclick={() => {
|
||
cascadeDownstream = true
|
||
close()
|
||
void runTest()
|
||
}}
|
||
>
|
||
<Zap
|
||
size={14}
|
||
class="mt-0.5 shrink-0 text-amber-600 dark:text-amber-400"
|
||
/>
|
||
<div class="flex flex-col min-w-0">
|
||
<span class="font-medium">
|
||
Test + trigger {downstream} downstream {cascadeDownstream
|
||
? '(current)'
|
||
: ''}
|
||
</span>
|
||
<span class="text-2xs text-secondary">
|
||
Let the asset-trigger cascade fan out to the {downstream}
|
||
subscribed script{downstream === 1 ? '' : 's'} after this run succeeds.
|
||
</span>
|
||
</div>
|
||
</button>
|
||
{/if}
|
||
{#if customUi?.previewPanel?.onBoundedRun}
|
||
<button
|
||
type="button"
|
||
class="w-full text-left px-3 py-2 hover:bg-surface-hover flex items-start gap-2 border-t"
|
||
onclick={() => {
|
||
close()
|
||
customUi!.previewPanel!.onBoundedRun!()
|
||
}}
|
||
>
|
||
<Target
|
||
size={14}
|
||
class="mt-0.5 shrink-0 text-blue-600 dark:text-blue-400"
|
||
/>
|
||
<div class="flex flex-col min-w-0">
|
||
<span class="font-medium">Run downstream up to…</span>
|
||
<span class="text-2xs text-secondary">
|
||
Pick end node(s) on the graph, then run only the cascade between
|
||
this script and them.
|
||
</span>
|
||
</div>
|
||
</button>
|
||
{/if}
|
||
</div>
|
||
{/snippet}
|
||
</Popover>
|
||
</div>
|
||
{:else}
|
||
{@render runTestButton('sm', 'shadow-md')}
|
||
{/if}
|
||
</div>
|
||
{#if testJob?.id && testJob.type === 'CompletedJob' && opWs}
|
||
<!-- Right-side affordances when we're displaying a *completed*
|
||
job (either the user just ran a test, or the on-mount
|
||
last-run loader populated the panel). The job-id link
|
||
opens the full run page in a new tab; the dispatch
|
||
button mounts a popover that shows what downstream
|
||
jobs this run triggered (rendered only when the run
|
||
actually dispatched anything). -->
|
||
<div class="flex items-center gap-2">
|
||
<a
|
||
class="text-3xs text-blue-600 hover:underline font-mono"
|
||
href={`/run/${testJob.id}?workspace=${opWs}`}
|
||
target="_blank"
|
||
rel="noopener noreferrer"
|
||
title="Open this run"
|
||
>
|
||
{testJob.id.slice(0, 8)}… ↗
|
||
</a>
|
||
<DispatchEventsButton
|
||
workspace={testJob.workspace_id ?? opWs}
|
||
jobId={testJob.id}
|
||
/>
|
||
</div>
|
||
{/if}
|
||
</div>
|
||
{#if customUi?.previewPanel?.argsAboveLogs && schema?.properties && Object.keys(schema.properties).length > 0}
|
||
<div
|
||
class="shrink-0 overflow-auto max-h-[45%] border-b border-gray-200 dark:border-gray-700 px-4 py-3"
|
||
>
|
||
{#key argsRender}
|
||
<SchemaForm
|
||
workspace={opWs}
|
||
helperScript={{
|
||
source: 'inline',
|
||
code,
|
||
//@ts-ignore
|
||
lang
|
||
}}
|
||
compact
|
||
{schema}
|
||
bind:args
|
||
bind:isValid
|
||
noVariablePicker={customUi?.previewPanel?.disableVariablePicker === true}
|
||
showSchemaExplorer
|
||
/>
|
||
{/key}
|
||
</div>
|
||
{/if}
|
||
<div class="grow min-h-0">
|
||
{@render testLogPanel()}
|
||
</div>
|
||
</div>
|
||
{:else}
|
||
{#key previewLayout}
|
||
<!-- min-h-0 lets this shrink to the space the header row leaves it. Without it the
|
||
100% height wins, the panes settle one header too tall, and any reflow during a
|
||
run snaps them up and back. -->
|
||
<Splitpanes horizontal={previewLayout !== 'bottom'} class="min-h-0">
|
||
<Pane size={previewLayout === 'bottom' ? 40 : 33}>
|
||
{#if previewLayout === 'bottom' && !(debugMode && isDebuggableScript)}
|
||
<div class="px-3 pt-2 pb-1 flex items-center gap-2">
|
||
{#if testIsLoading}
|
||
{@render cancelTestButton('sm', 'w-full')}
|
||
{:else}
|
||
{@render runTestButton('sm', 'w-full')}
|
||
{/if}
|
||
</div>
|
||
{/if}
|
||
{#if jsonView}
|
||
<div
|
||
class="py-2"
|
||
style="height: {!schemaHeight || schemaHeight < 600 ? 600 : schemaHeight}px"
|
||
data-schema-picker
|
||
>
|
||
{#key argsRender}
|
||
<JsonInputs
|
||
on:select={(e) => {
|
||
if (e.detail) {
|
||
if (onModuleArgs) {
|
||
testPanelArgs = e.detail
|
||
} else {
|
||
args = e.detail
|
||
}
|
||
}
|
||
}}
|
||
initialCode={onModuleArgs
|
||
? argsToJsonPayload(testPanelSchema, testPanelArgs)
|
||
: argsToJsonPayload(schema, args)}
|
||
updateOnBlur={false}
|
||
placeholder={`Write args as JSON.<br/><br/>Example:<br/><br/>{<br/> "foo": "12"<br/>}`}
|
||
/>
|
||
{/key}
|
||
</div>
|
||
{:else}
|
||
<div class="px-4">
|
||
<div
|
||
class="break-words relative font-sans"
|
||
bind:clientHeight={schemaHeight}
|
||
>
|
||
{#key argsRender}
|
||
{#if onModuleArgs}
|
||
<SchemaForm
|
||
workspace={opWs}
|
||
helperScript={{
|
||
source: 'inline',
|
||
code: editorCode,
|
||
//@ts-ignore
|
||
lang: effectiveLang
|
||
}}
|
||
compact
|
||
schema={testPanelSchema}
|
||
bind:args={testPanelArgs}
|
||
bind:isValid
|
||
noVariablePicker={customUi?.previewPanel?.disableVariablePicker ===
|
||
true}
|
||
showSchemaExplorer
|
||
/>
|
||
{:else}
|
||
<SchemaForm
|
||
workspace={opWs}
|
||
helperScript={{
|
||
source: 'inline',
|
||
code,
|
||
//@ts-ignore
|
||
lang
|
||
}}
|
||
compact
|
||
{schema}
|
||
bind:args
|
||
bind:isValid
|
||
noVariablePicker={customUi?.previewPanel?.disableVariablePicker ===
|
||
true}
|
||
showSchemaExplorer
|
||
/>
|
||
{/if}
|
||
{/key}
|
||
{#if showPsCommonParams}
|
||
<div class="mt-2">
|
||
<PowerShellCommonParams bind:args={psCommonParams} />
|
||
</div>
|
||
{/if}
|
||
</div>
|
||
</div>
|
||
{/if}
|
||
</Pane>
|
||
<Pane size={previewLayout === 'bottom' ? 60 : 67} class="relative">
|
||
{@render testLogPanel()}
|
||
</Pane>
|
||
</Splitpanes>
|
||
{/key}
|
||
{/if}
|
||
{/if}
|
||
</div>
|
||
</Pane>
|
||
</Splitpanes>
|
||
</div>
|
||
</SplitPanesWrapper>
|
||
|
||
{#snippet cancelTestButton(size: 'sm' | 'md', btnClasses: string)}
|
||
<Button on:click={() => jobLoader?.cancelJob()} unifiedSize={size} {btnClasses}>
|
||
<WindmillIcon
|
||
white={true}
|
||
class="mr-2 text-white"
|
||
height={size === 'md' ? '16px' : '14px'}
|
||
width={size === 'md' ? '20px' : '16px'}
|
||
spin="fast"
|
||
/>
|
||
Cancel
|
||
</Button>
|
||
{/snippet}
|
||
|
||
{#snippet runTestButton(size: 'sm' | 'md', btnClasses: string)}
|
||
<Button
|
||
on:click={() => runTest()}
|
||
unifiedSize={size}
|
||
{btnClasses}
|
||
variant="accent-secondary"
|
||
startIcon={{ icon: Play, classes: 'animate-none' }}
|
||
shortCut={{ Icon: CornerDownLeft }}
|
||
>
|
||
<!-- Named, because a run that silently narrowed to whichever file happens to
|
||
be open is the kind of surprise a warehouse bill discovers. -->
|
||
Test
|
||
</Button>
|
||
{/snippet}
|
||
|
||
<!-- Single source of truth for the preview LogPanel — rendered by both the
|
||
compact (hideArgs) layout and the splitpane layouts. One invocation
|
||
prevents prop drift between copies (the history tab's lazy-load via
|
||
onTabChange was lost in one copy when they diverged). -->
|
||
{#snippet testLogPanel()}
|
||
<LogPanel
|
||
bind:this={logPanel}
|
||
workspace={opWs}
|
||
{lang}
|
||
previewJob={debugMode
|
||
? ({
|
||
id: 'debug',
|
||
logs: $debugState.logs,
|
||
result: $debugState.result,
|
||
success: !$debugState.error,
|
||
type: hasDebugResult ? 'CompletedJob' : 'QueuedJob'
|
||
} as any)
|
||
: testJob}
|
||
{pastPreviews}
|
||
onTabChange={(tab) => {
|
||
historyTabActive = tab === 'history'
|
||
if (historyTabActive) {
|
||
loadPastTests()
|
||
}
|
||
}}
|
||
previewIsLoading={debugMode ? $debugState.running && !$debugState.stopped : testIsLoading}
|
||
{editor}
|
||
{diffEditor}
|
||
args={onModuleArgs ? testPanelArgs : args}
|
||
{showCaptures}
|
||
customUi={customUi?.previewPanel}
|
||
showCustomResultPanel={showDebugPanel}
|
||
>
|
||
{#if scriptProgress && !debugMode}
|
||
<!-- Put to the slot in logpanel -->
|
||
<JobProgressBar job={testJob} {scriptProgress} bind:this={jobProgressBar} compact={true} />
|
||
{/if}
|
||
{#snippet capturesTab()}
|
||
<div class="h-full p-2">
|
||
<CaptureTable
|
||
bind:this={captureTable}
|
||
workspace={opWs}
|
||
{hasPreprocessor}
|
||
canHavePreprocessor={canHavePreprocessor(lang)}
|
||
isFlow={false}
|
||
path={stablePathForCaptures}
|
||
canEdit={true}
|
||
on:applyArgs
|
||
on:updateSchema
|
||
on:addPreprocessor
|
||
/>
|
||
</div>
|
||
{/snippet}
|
||
{#snippet customResultPanel()}
|
||
<DebugPanel
|
||
stackFrames={$debugState.stackFrames}
|
||
scopes={$debugState.scopes}
|
||
variables={$debugState.variables}
|
||
client={dapClient}
|
||
bind:selectedFrameId={selectedDebugFrameId}
|
||
/>
|
||
{/snippet}
|
||
</LogPanel>
|
||
{/snippet}
|
||
|
||
{#snippet addModuleForm(close: () => void)}
|
||
<div class="flex flex-col gap-2">
|
||
<label for="module-name-input" class="text-xs font-semibold text-emphasis">File name</label>
|
||
<input
|
||
id="module-name-input"
|
||
type="text"
|
||
class="border rounded px-2 py-1.5 text-sm bg-surface"
|
||
bind:this={modulePathInputEl}
|
||
bind:value={modulePathInput}
|
||
placeholder={'helper' + (allowedModuleExtensions[0] ?? '.ts')}
|
||
oninput={() => {
|
||
modulePathError = validateModulePath(modulePathInput)
|
||
}}
|
||
onkeydown={(e) => {
|
||
if (e.key === 'Enter') addModule()
|
||
if (e.key === 'Escape') close()
|
||
}}
|
||
/>
|
||
{#if modulePathError}
|
||
<p class="text-red-500 text-2xs">{modulePathError}</p>
|
||
{/if}
|
||
<p class="text-tertiary text-2xs"
|
||
>Supports subfolders, e.g. <code class="text-2xs"
|
||
>utils/math{allowedModuleExtensions[0] ?? '.ts'}</code
|
||
></p
|
||
>
|
||
<div class="flex justify-end gap-2">
|
||
<Button
|
||
variant="default"
|
||
size="xs"
|
||
onclick={() => {
|
||
modulePathInput = ''
|
||
modulePathError = ''
|
||
close()
|
||
}}>Cancel</Button
|
||
>
|
||
<Button
|
||
variant="accent"
|
||
size="xs"
|
||
onclick={addModule}
|
||
disabled={!modulePathInput.trim() || !!modulePathError}>Add</Button
|
||
>
|
||
</div>
|
||
</div>
|
||
{/snippet}
|
||
|
||
{#snippet renameModuleForm(oldPath: string, close: () => void)}
|
||
<div class="flex flex-col gap-2">
|
||
<label for="rename-module-input" class="text-xs font-semibold text-emphasis"
|
||
>Rename module</label
|
||
>
|
||
<input
|
||
id="rename-module-input"
|
||
type="text"
|
||
class="border rounded px-2 py-1.5 text-sm bg-surface"
|
||
bind:this={renameModuleInputEl}
|
||
bind:value={renameModuleInput}
|
||
oninput={() => {
|
||
renameModuleError = validateRenameModulePath(renameModuleInput, oldPath)
|
||
}}
|
||
onkeydown={(e) => {
|
||
if (e.key === 'Enter') {
|
||
renameModule(oldPath)
|
||
close()
|
||
}
|
||
if (e.key === 'Escape') close()
|
||
}}
|
||
/>
|
||
{#if renameModuleError}
|
||
<p class="text-red-500 text-2xs">{renameModuleError}</p>
|
||
{/if}
|
||
<div class="flex justify-end gap-2">
|
||
<Button
|
||
variant="default"
|
||
size="xs"
|
||
onclick={() => {
|
||
renameModuleInput = ''
|
||
renameModuleError = ''
|
||
close()
|
||
}}>Cancel</Button
|
||
>
|
||
<Button
|
||
variant="accent"
|
||
size="xs"
|
||
onclick={() => {
|
||
renameModule(oldPath)
|
||
close()
|
||
}}
|
||
disabled={!renameModuleInput.trim() ||
|
||
renameIsNoop(renameModuleInput, oldPath) ||
|
||
!!renameModuleError}>Rename</Button
|
||
>
|
||
</div>
|
||
</div>
|
||
{/snippet}
|
||
|
||
{#snippet editorContent()}
|
||
<div class="h-full !overflow-visible bg-surface dark:bg-surface-secondary relative flex flex-col">
|
||
{#if supportsModules}
|
||
<DraggableTabs
|
||
tabs={fileTabs}
|
||
activeId={activeModuleTab ?? MAIN_FILE_TAB_ID}
|
||
onSelect={(id) => (id === MAIN_FILE_TAB_ID ? switchToMain() : switchToModule(id))}
|
||
onReorder={(next) => (moduleTabOrder = next.map((t) => t.id))}
|
||
class="shrink-0 border-b border-light bg-surface-secondary/50"
|
||
>
|
||
{#snippet tabAccessory(tab)}
|
||
{#if tab.id !== MAIN_FILE_TAB_ID}
|
||
<!-- Stops the trigger's click, mouse or Enter/Space alike, from also selecting the tab. -->
|
||
<span role="presentation" class="inline-flex" onclick={(e) => e.stopPropagation()}>
|
||
<Popover
|
||
placement="bottom-start"
|
||
openFocus={renameModuleInputEl}
|
||
contentClasses="p-3 w-72"
|
||
class="inline-flex"
|
||
triggerAttrs={{
|
||
'aria-label': `Rename ${tab.id}`,
|
||
onpointerdown: () => prefillRename(tab.id),
|
||
onkeydown: (e: KeyboardEvent) =>
|
||
(e.key === 'Enter' || e.key === ' ') && prefillRename(tab.id)
|
||
}}
|
||
>
|
||
{#snippet trigger()}
|
||
<span
|
||
class="opacity-0 group-hover:opacity-100 group-focus-within:opacity-100 rounded hover:bg-surface-hover w-4 h-4 inline-flex items-center justify-center"
|
||
>
|
||
<Pencil size={10} />
|
||
</span>
|
||
{/snippet}
|
||
{#snippet content({ close })}
|
||
{@render renameModuleForm(tab.id, close)}
|
||
{/snippet}
|
||
</Popover>
|
||
</span>
|
||
<Button
|
||
variant="subtle"
|
||
unifiedSize="2xs"
|
||
iconOnly
|
||
startIcon={{ icon: X }}
|
||
wrapperClasses="opacity-0 group-hover:opacity-100 focus-within:opacity-100"
|
||
aria-label={`Delete ${tab.id}`}
|
||
title={`Delete ${tab.id}`}
|
||
onClick={() => removeModule(tab.id)}
|
||
/>
|
||
{/if}
|
||
{/snippet}
|
||
{#snippet afterTabs()}
|
||
<Popover
|
||
placement="bottom-start"
|
||
bind:isOpen={showAddModulePopover}
|
||
openFocus={modulePathInputEl}
|
||
contentClasses="p-3 w-72"
|
||
class="ml-0.5 h-6 w-6 rounded-md inline-flex items-center justify-center text-hint hover:text-secondary hover:bg-surface-hover focus:outline-none focus-visible:ring-1 focus-visible:ring-border-selected"
|
||
triggerAttrs={{ 'aria-label': 'Add module' }}
|
||
>
|
||
{#snippet trigger()}
|
||
<Plus size={12} />
|
||
{/snippet}
|
||
{#snippet content({ close })}
|
||
{@render addModuleForm(close)}
|
||
{/snippet}
|
||
</Popover>
|
||
{/snippet}
|
||
</DraggableTabs>
|
||
{/if}
|
||
<div class="relative flex-1 min-h-0 min-w-0 !overflow-visible">
|
||
<div class="absolute bg-surface top-2 right-4 z-10 flex flex-row gap-2">
|
||
{#if assets?.length}
|
||
<AssetsDropdownButton {assets} />
|
||
{/if}
|
||
|
||
{#if isDebuggableScript && customUi?.editorBar?.debug != false}
|
||
<Button
|
||
variant={debugMode ? 'accent' : 'default'}
|
||
unifiedSize="sm"
|
||
onclick={toggleDebugMode}
|
||
startIcon={{ icon: Bug }}
|
||
iconOnly
|
||
btnClasses={debugMode
|
||
? ''
|
||
: 'bg-surface hover:bg-surface-hover border border-tertiary/30'}
|
||
title={debugMode ? 'Exit Debug Mode' : 'Toggle Debug Mode'}
|
||
/>
|
||
{/if}
|
||
{#if showDebugPanel && !showDebugConsole}
|
||
<Button
|
||
variant="default"
|
||
unifiedSize="sm"
|
||
onclick={() => (showDebugConsole = true)}
|
||
startIcon={{ icon: Terminal }}
|
||
title="Show Debug Console"
|
||
>
|
||
Console
|
||
</Button>
|
||
{/if}
|
||
{#if lang === 'ansible' && hasDelegateToGitRepo}
|
||
<Button
|
||
variant="default"
|
||
unifiedSize="sm"
|
||
onclick={() => (gitRepoResourcePickerOpen = true)}
|
||
startIcon={{ icon: GitBranch }}
|
||
>
|
||
Delegating to git repo
|
||
</Button>
|
||
{/if}
|
||
{#if testPanelSize === 0}
|
||
<HideButton
|
||
hidden={true}
|
||
direction="right"
|
||
unifiedSize="sm"
|
||
variant="accent-secondary"
|
||
panelName="test"
|
||
shortcut="U"
|
||
customHiddenIcon={{
|
||
icon: PlayIcon
|
||
}}
|
||
on:click={() => {
|
||
toggleTestPanel()
|
||
}}
|
||
/>
|
||
{/if}
|
||
{#if !aiChatManager.open && !disableAi && !inSessionPane}
|
||
{#if customUi?.editorBar?.aiGen != false && SUPPORTED_CHAT_SCRIPT_LANGUAGES.includes(lang ?? '')}
|
||
<OpenInSessionButton source={sessionOpen} deferToHeader>
|
||
{#snippet fallback()}
|
||
<HideButton
|
||
hidden={true}
|
||
direction="right"
|
||
panelName="AI"
|
||
shortcut="L"
|
||
unifiedSize="sm"
|
||
usePopoverOverride={!$copilotInfo.enabled}
|
||
customHiddenIcon={{
|
||
icon: WandSparkles
|
||
}}
|
||
btnClasses="!text-ai"
|
||
variant="default"
|
||
on:click={() => {
|
||
if (!aiChatManager.open) {
|
||
aiChatManager.changeMode(AIMode.SCRIPT)
|
||
}
|
||
aiChatManager.toggleOpen()
|
||
}}
|
||
>
|
||
{#snippet popoverOverride()}
|
||
<div class="text-sm">
|
||
Enable Windmill AI in the <a
|
||
href="/workspace_settings?tab=ai"
|
||
target="_blank"
|
||
class="inline-flex flex-row items-center gap-1"
|
||
>
|
||
workspace settings <ExternalLink size={16} />
|
||
</a>
|
||
</div>
|
||
{/snippet}
|
||
</HideButton>
|
||
{/snippet}
|
||
</OpenInSessionButton>
|
||
{/if}
|
||
{/if}
|
||
</div>
|
||
|
||
{#if debugConsoleVisible}
|
||
<!-- Use Splitpanes when debug console is visible for resizing -->
|
||
<Splitpanes horizontal class="h-full !overflow-visible">
|
||
<Pane bind:size={editorPaneSize} minSize={20} class="!overflow-visible">
|
||
{@render editorPane()}
|
||
</Pane>
|
||
<Pane bind:size={consolePaneSize} minSize={10}>
|
||
<DebugConsole
|
||
client={dapClient}
|
||
currentFrameId={currentDebugFrameId}
|
||
onClose={() => (showDebugConsole = false)}
|
||
workspace={opWs}
|
||
jobId={debugSessionJobId ?? undefined}
|
||
/>
|
||
</Pane>
|
||
</Splitpanes>
|
||
{:else}
|
||
<!-- Normal editor without console -->
|
||
<div class="h-full !overflow-visible">
|
||
{@render editorPane()}
|
||
</div>
|
||
{/if}
|
||
</div>
|
||
</div>
|
||
{/snippet}
|
||
|
||
{#snippet editorPane()}
|
||
{#key effectiveLang}
|
||
<Editor
|
||
lineNumbersMinChars={4}
|
||
folding
|
||
{path}
|
||
bind:code={editorCode}
|
||
bind:websocketAlive
|
||
bind:this={editor}
|
||
schemaContractMarkers={contractMarkers}
|
||
{yContent}
|
||
awareness={wsProvider?.awareness}
|
||
on:change={(e) => {
|
||
if (activeModuleTab === null) {
|
||
// `editorCode`, not the payload: `setCode` dispatches the string it was
|
||
// handed, but Monaco may have normalized it (EOL) while applying it, and
|
||
// the re-entrant `updateCode` that runs inside `setCode` has already put
|
||
// that normalized text here. Taking the payload would leave `code`
|
||
// disagreeing with the buffer.
|
||
code = editorCode
|
||
lastSyncedCode = code
|
||
inferSchema(e.detail)
|
||
} else {
|
||
flushModuleContent()
|
||
inferModuleSchema()
|
||
}
|
||
// Refresh breakpoint positions when code changes (decorations track their lines)
|
||
if (debugMode && breakpointDecorations.length > 0) {
|
||
refreshBreakpointPositions()
|
||
}
|
||
}}
|
||
on:saveDraft
|
||
on:toggleTestPanel={toggleTestPanel}
|
||
cmdEnterAction={async () => {
|
||
if (activeModuleTab === null) {
|
||
await inferSchema(editorCode)
|
||
} else {
|
||
await inferModuleSchema()
|
||
}
|
||
// The Editor already ran the DDL guard before invoking this action.
|
||
runTest({ skipDdlGuard: true })
|
||
}}
|
||
formatAction={async () => {
|
||
if (activeModuleTab === null) {
|
||
await inferSchema(editorCode)
|
||
}
|
||
dispatch('format')
|
||
}}
|
||
class="flex flex-1 h-full !overflow-visible"
|
||
scriptLang={effectiveLang}
|
||
automaticLayout={true}
|
||
{fixedOverflowWidgets}
|
||
{args}
|
||
workflowAsCode={workflowAsCodeAiContext}
|
||
{enablePreprocessorSnippet}
|
||
preparedAssetsSqlQueries={preparedSqlQueries.current}
|
||
customTag={tag}
|
||
/>
|
||
<DiffEditor
|
||
className="h-full"
|
||
bind:this={diffEditor}
|
||
modifiedModel={editor?.getModel() as meditor.ITextModel}
|
||
automaticLayout
|
||
defaultLang={scriptLangToEditorLang(lang)}
|
||
{fixedOverflowWidgets}
|
||
buttons={diffMode
|
||
? [
|
||
{
|
||
text: 'See changes history',
|
||
onClick: () => {
|
||
showHistoryDrawer = true
|
||
}
|
||
},
|
||
{
|
||
text: 'Quit diff mode',
|
||
onClick: () => {
|
||
hideDiffMode()
|
||
},
|
||
color: 'red'
|
||
}
|
||
]
|
||
: []}
|
||
/>
|
||
{/key}
|
||
{/snippet}
|
||
|
||
<GitRepoResourcePicker
|
||
workspace={opWs}
|
||
bind:open={gitRepoResourcePickerOpen}
|
||
currentResource={ansibleAlternativeExecutionMode?.resource}
|
||
currentCommit={commitHashForGitRepo || ansibleAlternativeExecutionMode?.commit}
|
||
currentInventories={ansibleAlternativeExecutionMode?.inventories_location}
|
||
currentPlaybook={ansibleAlternativeExecutionMode?.playbook}
|
||
gitSshIdentity={ansibleGitSshIdentity}
|
||
on:selected={handleDelegateConfigUpdate}
|
||
on:addInventories={handleAddInventories}
|
||
/>
|
||
|
||
<style global>
|
||
/* Debug breakpoint glyph - red circle in the glyph margin */
|
||
.debug-breakpoint-glyph {
|
||
background-color: #e51400;
|
||
border-radius: 50%;
|
||
width: 10px !important;
|
||
height: 10px !important;
|
||
margin-left: 5px;
|
||
margin-top: 4px;
|
||
}
|
||
|
||
/* Ghost breakpoint shown on gutter hover before the user clicks */
|
||
.debug-breakpoint-glyph-hover {
|
||
background-color: #e51400;
|
||
opacity: 0.35;
|
||
border-radius: 50%;
|
||
width: 10px !important;
|
||
height: 10px !important;
|
||
margin-left: 5px;
|
||
margin-top: 4px;
|
||
cursor: pointer;
|
||
}
|
||
|
||
/* Current execution line - yellow background */
|
||
.debug-current-line {
|
||
background-color: rgba(255, 238, 0, 0.2);
|
||
}
|
||
|
||
/* Current execution line glyph - yellow arrow in the glyph margin */
|
||
.debug-current-line-glyph {
|
||
background-color: #ffcc00;
|
||
clip-path: polygon(0 0, 100% 50%, 0 100%);
|
||
width: 10px !important;
|
||
height: 14px !important;
|
||
margin-left: 5px;
|
||
margin-top: 2px;
|
||
}
|
||
</style>
|