windmill-components 1.623.2 → 1.655.0

package/package/templates/claude_sandbox.ts.template

@@ -0,0 +1,85 @@
+// sandbox
+// volume: claude .claude
+
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import * as fs from "fs";
+import * as path from "path";
+
+// path -> content, fileset resource, that contains your CLAUDE.md, and skills
+type AgentInstructions = Record<string, string>
+
+export async function main(anthropic: RT.Anthropic, agent_instructions?: AgentInstructions) {
+
+  const sessionFile = path.join(".claude/session-id.txt");
+
+  let sessionId = fs.existsSync(sessionFile) ? fs.readFileSync(sessionFile, "utf-8").trim() : undefined
+
+  // Writing claude.md and skills to .claude/
+  for (const [filePath, content] of Object.entries(agent_instructions ?? {})) {const fullPath = path.join(filePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+  }
+
+
+  const isResume = !!sessionId;
+
+  // you can hardcode the prompt or pass it as input.
+  // AgentInstructions can contains a CLAUDE.md where to put the bulk of the instructions as well.
+  const prompt = !isResume ?
+    "What is the fastest OSS workflow engine?" :
+    "What did I ask you before?"
+
+  process.env.ANTHROPIC_API_KEY = anthropic.apiKey;
+
+  let response = "";
+  let newSessionId: string | undefined;
+  let tokenCount = 0
+  const seenIds = new Set<string>();
+
+  for await (const msg of query({
+    prompt,
+    options: {
+      model: "opus",
+      pathToClaudeCodeExecutable: "/usr/bin/claude",
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      ...(isResume ? { resume: sessionId } : {}),
+    },
+  })) {
+
+
+    if (msg.type === "system" && msg.subtype === "init") {
+      newSessionId = msg.session_id;
+    }
+    if (msg.type === "assistant") {
+      const msgId = msg.message.id;
+      if (!seenIds.has(msgId)) {
+        seenIds.add(msgId);
+        tokenCount += msg.message.usage.input_tokens + msg.message.usage.output_tokens;
+        console.log(`${tokenCount} tokens`)
+      }
+
+      response += msg.message.content
+        .filter((b: any) => b.type === "text")
+        .map((b: any) => b.text)
+        .join("");
+    }
+  }
+
+  if (newSessionId) {
+    fs.writeFileSync(sessionFile, newSessionId);
+  }
+
+  // Delete all files created from agent_instructions
+  for (const filePath of Object.keys(agent_instructions ?? {})) {
+      fs.unlinkSync(path.join(filePath));
+  }
+
+  return {
+    is_resume: isResume,
+    previous_session_id: sessionId ?? null,
+    new_session_id: newSessionId,
+    prompt,
+    response,
+  };
+}

package/package/toast.d.ts

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

package/package/toast.js

@@ -1,17 +1,20 @@
 import Toast from './components/Toast.svelte';
 import { toast } from '@zerodevx/svelte-toast';
-export function sendUserToast(message, error = false, actions = [], errorMessage = undefined, duration = 5000) {
+export function sendUserToast(message, _type = 'success', actions = [], errorMessage = undefined, duration = 5000) {
+    const type = typeof _type === 'boolean' ? (_type ? 'error' : 'success') : _type;
+    const error = type === 'error';
     if (globalThis.windmillToast) {
         globalThis.windmillToast({
             message,
             error,
+            type,
             actions,
             errorMessage,
             duration
         });
-        return;
+        return { destroy: () => { } };
     }
-    toast.push({
+    const id = toast.push({
         component: {
             // https://github.com/zerodevx/svelte-toast/issues/115
             // Svelte 5 changed its component type and svelte-toast is not up to date yet
@@ -19,7 +22,7 @@ export function sendUserToast(message, error = false, actions = [], errorMessage
             src: Toast,
             props: {
                 message,
-                error,
+                type,
                 actions,
                 errorMessage,
                 duration
@@ -32,7 +35,13 @@ export function sendUserToast(message, error = false, actions = [], errorMessage
             '--toastPadding': '0',
             '--toastMsgPadding': '0',
             '--toastBackground': '#00000000',
-            '--toastBorderRadius': '0.4rem'
+            '--toastBorderRadius': '0.4rem',
+            '--toastWidth': '34rem',
+            '--toastMinHeight': '1rem',
+            '--toastBoxShadow': 'none'
         }
     });
+    return {
+        destroy: () => toast.pop(id)
+    };
 }

package/package/utils/editInFork.d.ts

@@ -0,0 +1,3 @@
+type ItemType = 'script' | 'flow' | 'app' | 'raw_app';
+export declare function buildForkEditUrl(itemType: ItemType, itemPath: string): string;
+export {};

package/package/utils/editInFork.js

@@ -0,0 +1,19 @@
+import { base } from '../base';
+export function buildForkEditUrl(itemType, itemPath) {
+    let editPath;
+    switch (itemType) {
+        case 'script':
+            editPath = `${base}/scripts/edit/${itemPath}`;
+            break;
+        case 'flow':
+            editPath = `${base}/flows/edit/${itemPath}?nodraft=true`;
+            break;
+        case 'app':
+            editPath = `${base}/apps/edit/${itemPath}?nodraft=true`;
+            break;
+        case 'raw_app':
+            editPath = `${base}/apps_raw/edit/${itemPath}?nodraft=true`;
+            break;
+    }
+    return `${base}/user/fork_workspace?rd=${encodeURIComponent(editPath)}`;
+}

package/package/utils.js

@@ -11,7 +11,6 @@ import {} from './stores';
 import { sendUserToast } from './toast';
 export { sendUserToast };
 import { stateSnapshot } from './svelte5Utils.svelte';
-import { validate, dereference } from '@scalar/openapi-parser';
 export var OpenApi;
 (function (OpenApi) {
     let OpenApiVersion;
@@ -55,6 +54,7 @@ export var OpenApi;
      * @throws Will throw an error if the specification is invalid or cannot be parsed.
      */
     async function parse(api) {
+        const { validate, dereference } = await import('@scalar/openapi-parser');
         const { valid, errors } = await validate(api);
         if (!valid) {
             const errorMessage = errors
@@ -75,13 +75,6 @@ export function isJobReRunnable(j) {
     return (j.job_kind === 'script' || j.job_kind === 'flow') && j.parent_job === undefined;
 }
 export const WORKER_NAME_PREFIX = 'wk';
-export function isJobSelectable(selectionType) {
-    const f = {
-        cancel: isJobCancelable,
-        're-run': isJobReRunnable
-    }[selectionType];
-    return f;
-}
 export function escapeHtml(unsafe) {
     return unsafe
         .replace(/&/g, '&')
@@ -270,7 +263,7 @@ export function validatePassword(password) {
     const re = /^(?=.*[\d])(?=.*[!@#$%^&*])[\w!@#$%^&*]{8,30}$/;
     return re.test(password);
 }
-const portalDivs = ['#app-editor-select', '.select-dropdown-portal'];
+const portalDivs = ['#app-editor-select', '.dropdown-portal', '[data-context-menu]'];
 export function clickOutside(node, options) {
     const handleClick = async (event) => {
         const target = event.target;
@@ -1103,6 +1096,12 @@ export function cleanValueProperties(obj) {
         return newObj;
     }
 }
+export function hasUnsavedChanges(saved, modified) {
+    const normalizedSaved = cleanValueProperties({ ...saved, path: undefined });
+    const normalizedModified = cleanValueProperties({ ...modified, path: undefined });
+    return (orderedJsonStringify(replaceFalseWithUndefined(normalizedSaved)) !==
+        orderedJsonStringify(replaceFalseWithUndefined(normalizedModified)));
+}
 export function orderedJsonStringify(obj, space) {
     const allKeys = new Set();
     JSON.stringify(obj, (key, value) => (value != undefined && value != null && allKeys.add(key), value));
@@ -1330,6 +1329,37 @@ export function formatDateShort(dateString) {
         day: 'numeric'
     }).format(date);
 }
+export function formatDateRange(start, end) {
+    if (typeof start === 'string')
+        start = new Date(start);
+    if (typeof end === 'string')
+        end = new Date(end);
+    if (start && end) {
+        const differentDays = start.getFullYear() !== end.getFullYear() ||
+            start.getMonth() !== end.getMonth() ||
+            start.getDate() !== end.getDate();
+        const differentYears = start.getFullYear() !== end.getFullYear();
+        if (differentDays || differentYears) {
+            // Clone to avoid mutating originals
+            start = new Date(start);
+            end = new Date(end);
+            // Zero out time for display
+            start.setHours(0, 0, 0, 0);
+            end.setHours(0, 0, 0, 0);
+        }
+        if (differentYears) {
+            // Zero out month and day for display
+            start.setMonth(0, 1);
+            end.setMonth(0, 1);
+        }
+        return `${formatDatePretty(start)} to ${formatDatePretty(end)}`;
+    }
+    if (!end && start)
+        return `After ${formatDatePretty(start)}`;
+    if (!start && end)
+        return `Before ${formatDatePretty(end)}`;
+    return 'No input';
+}
 export function toJsonStr(result) {
     try {
         // console.log(result)
@@ -1675,3 +1705,180 @@ export function pick(obj, keys) {
     }
     return result;
 }
+export function parseDbInputFromAssetSyntax(path) {
+    const [p1, _p2] = path.split('://');
+    const [p2, _p3] = _p2.split('/');
+    const [p3, p4] = _p3.split('.');
+    return p1 === 'ducklake'
+        ? { type: 'ducklake', ducklake: p2 || 'main', specificTable: p4 ?? p3 }
+        : p1 === 'datatable'
+            ? {
+                type: 'database',
+                resourcePath: `datatable://${p2 || 'main'}`,
+                resourceType: 'postgresql',
+                specificTable: p4 ?? p3,
+                specificSchema: p4 ? p3 : undefined
+            }
+            : null;
+}
+export function formatMemory(sizeInKb, includeTooltip = false) {
+    const precise = `${sizeInKb.toLocaleString()}KB`;
+    let display;
+    if (sizeInKb >= 1024 * 1024) {
+        // Convert to GB for values >= 1GB
+        display = `${(sizeInKb / (1024 * 1024)).toFixed(0)}GB`;
+    }
+    else if (sizeInKb >= 1024) {
+        // Convert to MB for values >= 1MB
+        display = `${(sizeInKb / 1024).toFixed(0)}MB`;
+    }
+    else {
+        // Keep as KB for smaller values
+        display = `${sizeInKb.toFixed(0)}KB`;
+    }
+    if (includeTooltip) {
+        return {
+            display,
+            tooltip: `${precise} (${(sizeInKb / 1024).toFixed(2)}MB)`
+        };
+    }
+    return display;
+}
+export function assignObjInPlace(target, source, options = { onDelete: 'Delete' }) {
+    for (const key in target) {
+        if (!(key in source)) {
+            if (options?.onDelete === 'Delete')
+                delete target[key];
+            else if (options?.onDelete === 'SetNull')
+                target[key] = null;
+        }
+    }
+    for (const key in source)
+        target[key] = source[key];
+}
+export function isUSLocale() {
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        return locale.startsWith('en-US');
+    }
+    catch {
+        return false;
+    }
+}
+export function formatDatePretty(date) {
+    if (!date || isNaN(date.getTime()))
+        return '';
+    const now = new Date();
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const isCurrentYear = year === now.getFullYear();
+    const isToday = isCurrentYear && month === now.getMonth() + 1 && day === now.getDate();
+    const isOnlyYear = month === 1 && day === 1 && hours === 0 && minutes === 0;
+    const hasTime = hours !== 0 || minutes !== 0;
+    // If only year is defined (rest is 01/01 00:00)
+    if (isOnlyYear) {
+        return String(year);
+    }
+    // Format month/day depending on locale: MM/DD for US, DD/MM otherwise
+    const mm = String(month).padStart(2, '0');
+    const dd = String(day).padStart(2, '0');
+    const monthDay = isUSLocale() ? `${mm}/${dd}` : `${dd}/${mm}`;
+    // Format time if present (12-hour format with AM/PM)
+    let timeStr = '';
+    if (hasTime) {
+        const isPM = hours >= 12;
+        const displayHours = hours % 12 || 12;
+        const displayMinutes = String(minutes).padStart(2, '0');
+        timeStr = ` ${displayHours}:${displayMinutes} ${isPM ? 'PM' : 'AM'}`;
+    }
+    // If today and same year, only show time (if present)
+    if (isToday) {
+        return timeStr ? timeStr.trim() : monthDay;
+    }
+    // If same year, show month/day and time (if present)
+    if (isCurrentYear) {
+        return `${monthDay}${timeStr}`;
+    }
+    // Otherwise, show full date with year and time (if present)
+    return `${monthDay}/${year}${timeStr}`;
+}
+export function parsePrettyDate(text) {
+    if (!text)
+        return null;
+    const now = new Date();
+    const currentYear = now.getFullYear();
+    // Try parsing as year-only (e.g., "2025")
+    if (/^\d{4}$/.test(text)) {
+        const year = parseInt(text);
+        return new Date(year, 0, 1, 0, 0, 0);
+    }
+    // Try parsing time-only (e.g., "11:02 AM") - assumes today
+    const timeOnlyMatch = text.match(/^(\d{1,2}):(\d{2})\s+(AM|PM)$/i);
+    if (timeOnlyMatch) {
+        const [, hourStr, minuteStr, meridiem] = timeOnlyMatch;
+        let hours = parseInt(hourStr);
+        const minutes = parseInt(minuteStr);
+        if (meridiem.toUpperCase() === 'PM' && hours !== 12)
+            hours += 12;
+        if (meridiem.toUpperCase() === 'AM' && hours === 12)
+            hours = 0;
+        return new Date(currentYear, now.getMonth(), now.getDate(), hours, minutes, 0);
+    }
+    const usLocale = isUSLocale();
+    // Parse a "first/second" pair as month/day (US) or day/month (non-US)
+    function parseFirstSecond(firstStr, secondStr) {
+        const first = parseInt(firstStr);
+        const second = parseInt(secondStr);
+        return usLocale ? { month: first - 1, day: second } : { month: second - 1, day: first };
+    }
+    // Try parsing NN/NN (e.g., "01/04") - assumes current year, no time
+    // US: MM/DD, non-US: DD/MM
+    const monthDayMatch = text.match(/^(\d{2})\/(\d{2})$/);
+    if (monthDayMatch) {
+        const { month, day } = parseFirstSecond(monthDayMatch[1], monthDayMatch[2]);
+        return new Date(currentYear, month, day, 0, 0, 0);
+    }
+    // Try parsing NN/NN TIME (e.g., "01/04 11:02 AM") - assumes current year with time
+    // US: MM/DD TIME, non-US: DD/MM TIME
+    const monthDayTimeMatch = text.match(/^(\d{2})\/(\d{2})\s+(\d{1,2}):(\d{2})\s+(AM|PM)$/i);
+    if (monthDayTimeMatch) {
+        const { month, day } = parseFirstSecond(monthDayTimeMatch[1], monthDayTimeMatch[2]);
+        let hours = parseInt(monthDayTimeMatch[3]);
+        const minutes = parseInt(monthDayTimeMatch[4]);
+        const meridiem = monthDayTimeMatch[5];
+        if (meridiem.toUpperCase() === 'PM' && hours !== 12)
+            hours += 12;
+        if (meridiem.toUpperCase() === 'AM' && hours === 12)
+            hours = 0;
+        return new Date(currentYear, month, day, hours, minutes, 0);
+    }
+    // Try parsing NN/NN/YYYY (e.g., "01/04/2025") - no time
+    // US: MM/DD/YYYY, non-US: DD/MM/YYYY
+    const fullDateMatch = text.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (fullDateMatch) {
+        const { month, day } = parseFirstSecond(fullDateMatch[1], fullDateMatch[2]);
+        const year = parseInt(fullDateMatch[3]);
+        return new Date(year, month, day, 0, 0, 0);
+    }
+    // Try parsing NN/NN/YYYY TIME (e.g., "01/04/2025 3:00 PM")
+    // US: MM/DD/YYYY TIME, non-US: DD/MM/YYYY TIME
+    const fullDateTimeMatch = text.match(/^(\d{2})\/(\d{2})\/(\d{4})\s+(\d{1,2}):(\d{2})\s+(AM|PM)$/i);
+    if (fullDateTimeMatch) {
+        const { month, day } = parseFirstSecond(fullDateTimeMatch[1], fullDateTimeMatch[2]);
+        const year = parseInt(fullDateTimeMatch[3]);
+        let hours = parseInt(fullDateTimeMatch[4]);
+        const minutes = parseInt(fullDateTimeMatch[5]);
+        const meridiem = fullDateTimeMatch[6];
+        if (meridiem.toUpperCase() === 'PM' && hours !== 12)
+            hours += 12;
+        if (meridiem.toUpperCase() === 'AM' && hours === 12)
+            hours = 0;
+        return new Date(year, month, day, hours, minutes, 0);
+    }
+    // Fallback to standard Date parsing (e.g., ISO strings)
+    const date = new Date(text);
+    return isNaN(date.getTime()) ? null : date;
+}