windmill-components 1.642.0 → 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/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
@@ -263,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;

package/package/utils_deployable.d.ts

@@ -13,20 +13,124 @@ export declare function existsTrigger(data: {
     workspace: string;
     path: string;
 }, triggerKind: TriggerKind): Promise<boolean>;
-export declare function getTriggersDeployData(kind: TriggerKind, path: string, workspace: string): Promise<{
-    data: import("./gen").SqsTrigger;
+/**
+ * Get trigger deployment data with optional email preservation.
+ * @param onBehalfOfEmail - If set, the trigger will be deployed with this email and preserve_email=true.
+ */
+export declare function getTriggersDeployData(kind: TriggerKind, path: string, workspace: string, onBehalfOfEmail?: string): Promise<{
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        queue_url: string;
+        aws_auth_resource_type: import("./gen").AwsAuthResourceType;
+        aws_resource_path: string;
+        message_attributes?: Array<(string)> | null;
+        server_id?: string;
+        last_server_ping?: string;
+        error?: string;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof SqsTriggerService.createSqsTrigger;
     updateFn: typeof SqsTriggerService.updateSqsTrigger;
 } | {
-    data: import("./gen").KafkaTrigger;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        kafka_resource_path: string;
+        group_id: string;
+        topics: Array<(string)>;
+        filters: Array<{
+            key: string;
+            value: unknown;
+        }>;
+        auto_offset_reset?: "latest" | "earliest";
+        auto_commit?: boolean;
+        server_id?: string;
+        last_server_ping?: string;
+        error?: string;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof KafkaTriggerService.createKafkaTrigger;
     updateFn: typeof KafkaTriggerService.updateKafkaTrigger;
 } | {
-    data: import("./gen").MqttTrigger;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        mqtt_resource_path: string;
+        subscribe_topics: Array<import("./gen").MqttSubscribeTopic>;
+        v3_config?: import("./gen").MqttV3Config | null;
+        v5_config?: import("./gen").MqttV5Config | null;
+        client_id?: string | null;
+        client_version?: import("./gen").MqttClientVersion | null;
+        server_id?: string;
+        last_server_ping?: string;
+        error?: string;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof MqttTriggerService.createMqttTrigger;
     updateFn: typeof MqttTriggerService.updateMqttTrigger;
 } | {
-    data: import("./gen").NatsTrigger;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        nats_resource_path: string;
+        use_jetstream: boolean;
+        stream_name?: string | null;
+        consumer_name?: string | null;
+        subjects: Array<(string)>;
+        server_id?: string;
+        last_server_ping?: string;
+        error?: string;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof NatsTriggerService.createNatsTrigger;
     updateFn: typeof NatsTriggerService.updateNatsTrigger;
 } | {
@@ -34,19 +138,135 @@ export declare function getTriggersDeployData(kind: TriggerKind, path: string, w
     createFn: typeof GcpTriggerService.createGcpTrigger;
     updateFn: typeof GcpTriggerService.updateGcpTrigger;
 } | {
-    data: import("./gen").PostgresTrigger;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        postgres_resource_path: string;
+        publication_name: string;
+        server_id?: string;
+        replication_slot_name: string;
+        error?: string;
+        last_server_ping?: string;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof PostgresTriggerService.createPostgresTrigger;
     updateFn: typeof PostgresTriggerService.updatePostgresTrigger;
 } | {
-    data: import("./gen").WebsocketTrigger;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        url: string;
+        server_id?: string;
+        last_server_ping?: string;
+        error?: string;
+        filters: Array<{
+            key: string;
+            value: unknown;
+        }>;
+        initial_messages?: Array<import("./gen").WebsocketTriggerInitialMessage> | null;
+        url_runnable_args?: import("./gen").ScriptArgs | null;
+        can_return_message: boolean;
+        can_return_error_result: boolean;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof WebsocketTriggerService.createWebsocketTrigger;
     updateFn: typeof WebsocketTriggerService.updateWebsocketTrigger;
 } | {
-    data: import("./gen").HttpTrigger;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        script_path: string;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        workspace_id: string;
+        edited_by: string;
+        edited_at: string;
+        is_flow: boolean;
+        mode: import("./gen").TriggerMode;
+        route_path: string;
+        static_asset_config?: {
+            s3: string;
+            storage?: string;
+            filename?: string;
+        } | null;
+        http_method: import("./gen").HttpMethod;
+        authentication_resource_path?: string | null;
+        summary?: string | null;
+        description?: string | null;
+        request_type: import("./gen").HttpRequestType;
+        authentication_method: import("./gen").AuthenticationMethod;
+        is_static_website: boolean;
+        workspaced_route: boolean;
+        wrap_body: boolean;
+        raw_string: boolean;
+        error_handler_path?: string;
+        error_handler_args?: import("./gen").ScriptArgs;
+        retry?: import("./gen").Retry;
+    };
     createFn: typeof HttpTriggerService.createHttpTrigger;
     updateFn: typeof HttpTriggerService.updateHttpTrigger;
 } | {
-    data: import("./gen").Schedule;
+    data: {
+        email: string | undefined;
+        preserve_email: boolean;
+        path: string;
+        edited_by: string;
+        edited_at: string;
+        schedule: string;
+        timezone: string;
+        enabled: boolean;
+        script_path: string;
+        is_flow: boolean;
+        args?: import("./gen").ScriptArgs | null;
+        extra_perms: {
+            [key: string]: (boolean);
+        };
+        error?: string | null;
+        on_failure?: string | null;
+        on_failure_times?: number | null;
+        on_failure_exact?: boolean | null;
+        on_failure_extra_args?: import("./gen").ScriptArgs | null;
+        on_recovery?: string | null;
+        on_recovery_times?: number | null;
+        on_recovery_extra_args?: import("./gen").ScriptArgs | null;
+        on_success?: string | null;
+        on_success_extra_args?: import("./gen").ScriptArgs | null;
+        ws_error_handler_muted?: boolean;
+        retry?: import("./gen").Retry | null;
+        summary?: string | null;
+        description?: string | null;
+        no_flow_overlap?: boolean;
+        tag?: string | null;
+        paused_until?: string | null;
+        cron_version?: string | null;
+        dynamic_skip?: string | null;
+    };
     createFn: typeof ScheduleService.createSchedule;
     updateFn: typeof ScheduleService.updateSchedule;
 }>;
@@ -553,6 +773,10 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
     is_static_website?: undefined;
     authentication_resource_path?: undefined;
 }>;
+/**
+ * Get the email for a trigger (used for on_behalf_of during deployment).
+ */
+export declare function getTriggerEmail(kind: TriggerKind, path: string, workspace: string): Promise<string | undefined>;
 export declare function getTriggerDependency(kind: TriggerKind, path: string, workspace: string): Promise<{
     kind: Kind;
     path: string;

package/package/utils_deployable.js

@@ -49,14 +49,19 @@ export async function existsTrigger(data, triggerKind) {
     }
     throw new Error(`Unexpected trigger kind ${triggerKind}. Allowed kinds are: routes, kafka, mqtt, postgres, sqs, gcp, websockets, nats, schedules.`);
 }
-export async function getTriggersDeployData(kind, path, workspace) {
+/**
+ * Get trigger deployment data with optional email preservation.
+ * @param onBehalfOfEmail - If set, the trigger will be deployed with this email and preserve_email=true.
+ */
+export async function getTriggersDeployData(kind, path, workspace, onBehalfOfEmail) {
+    const preserveEmail = onBehalfOfEmail !== undefined;
     if (kind === 'sqs') {
         const sqsTrigger = await SqsTriggerService.getSqsTrigger({
             workspace: workspace,
             path: path
         });
         return {
-            data: sqsTrigger,
+            data: { ...sqsTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: SqsTriggerService.createSqsTrigger,
             updateFn: SqsTriggerService.updateSqsTrigger
         };
@@ -67,7 +72,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: kafkaTrigger,
+            data: { ...kafkaTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: KafkaTriggerService.createKafkaTrigger,
             updateFn: KafkaTriggerService.updateKafkaTrigger
         };
@@ -78,7 +83,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: mqttTrigger,
+            data: { ...mqttTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: MqttTriggerService.createMqttTrigger,
             updateFn: MqttTriggerService.updateMqttTrigger
         };
@@ -89,7 +94,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: natsTrigger,
+            data: { ...natsTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: NatsTriggerService.createNatsTrigger,
             updateFn: NatsTriggerService.updateNatsTrigger
         };
@@ -107,7 +112,9 @@ export async function getTriggersDeployData(kind, path, workspace) {
         const data = {
             ...gcpTrigger,
             delivery_config: gcpTrigger.delivery_config ?? undefined,
-            base_endpoint: gcpTrigger.delivery_type === 'push' ? `${window.location.origin}${base}` : undefined
+            base_endpoint: gcpTrigger.delivery_type === 'push' ? `${window.location.origin}${base}` : undefined,
+            email: onBehalfOfEmail,
+            preserve_email: preserveEmail
         };
         return {
             data,
@@ -121,7 +128,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: postgresTrigger,
+            data: { ...postgresTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: PostgresTriggerService.createPostgresTrigger,
             updateFn: PostgresTriggerService.updatePostgresTrigger
         };
@@ -132,7 +139,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: websocketTrigger,
+            data: { ...websocketTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: WebsocketTriggerService.createWebsocketTrigger,
             updateFn: WebsocketTriggerService.updateWebsocketTrigger
         };
@@ -143,7 +150,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: httpTrigger,
+            data: { ...httpTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: HttpTriggerService.createHttpTrigger,
             updateFn: HttpTriggerService.updateHttpTrigger
         };
@@ -154,7 +161,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
             path: path
         });
         return {
-            data: schedulesTrigger,
+            data: { ...schedulesTrigger, email: onBehalfOfEmail, preserve_email: preserveEmail },
             createFn: ScheduleService.createSchedule,
             updateFn: ScheduleService.updateSchedule
         };
@@ -312,6 +319,53 @@ export async function getTriggerValue(kind, path, workspace) {
     }
     throw new Error(`Unexpected trigger kind got: ${kind}`);
 }
+/**
+ * Get the email for a trigger (used for on_behalf_of during deployment).
+ */
+export async function getTriggerEmail(kind, path, workspace) {
+    try {
+        if (kind === 'sqs') {
+            const trigger = await SqsTriggerService.getSqsTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'kafka') {
+            const trigger = await KafkaTriggerService.getKafkaTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'mqtt') {
+            const trigger = await MqttTriggerService.getMqttTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'nats') {
+            const trigger = await NatsTriggerService.getNatsTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'gcp') {
+            const trigger = await GcpTriggerService.getGcpTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'postgres') {
+            const trigger = await PostgresTriggerService.getPostgresTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'websockets') {
+            const trigger = await WebsocketTriggerService.getWebsocketTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'routes') {
+            const trigger = await HttpTriggerService.getHttpTrigger({ workspace, path });
+            return trigger.edited_by;
+        }
+        else if (kind === 'schedules') {
+            const trigger = await ScheduleService.getSchedule({ workspace, path });
+            return trigger.edited_by;
+        }
+    }
+    catch {
+        // Trigger may not exist in the workspace
+    }
+    return undefined;
+}
 function retrieveScriptOrFlowKind(path, is_flow) {
     return {
         kind: is_flow ? 'flow' : 'script',

package/package/utils_workspace_deploy.d.ts

@@ -0,0 +1,31 @@
+import { type AdditionalInformation, type Kind } from './utils_deployable';
+export interface DeployItemParams {
+    kind: Kind;
+    path: string;
+    workspaceFrom: string;
+    workspaceTo: string;
+    additionalInformation?: AdditionalInformation;
+    /** The email to use for on_behalf_of. If set, preserve_on_behalf_of will be true. If undefined, deploying user's email is used. */
+    onBehalfOfEmail?: string;
+}
+export interface DeployResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Deploy an item from one workspace to another.
+ * Handles all item kinds: flow, script, app, variable, resource, resource_type, folder, trigger.
+ */
+export declare function deployItem(params: DeployItemParams): Promise<DeployResult>;
+/**
+ * Check if an item already exists in the target workspace.
+ */
+export declare function checkItemExists(kind: Kind, path: string, workspace: string, additionalInformation?: AdditionalInformation): Promise<boolean>;
+/**
+ * Get the value of an item for diff comparison.
+ */
+export declare function getItemValue(kind: Kind, path: string, workspace: string, additionalInformation?: AdditionalInformation): Promise<unknown>;
+/**
+ * Get the on_behalf_of_email for a flow, script, app, or trigger (including schedule).
+ */
+export declare function getOnBehalfOfEmail(kind: Kind, path: string, workspace: string, additionalInformation?: AdditionalInformation): Promise<string | undefined>;