windmill-cli 1.514.1 → 1.515.1

package/esm/flow_guidance.js

@@ -0,0 +1,430 @@
+export const FLOW_GUIDANCE = `
+---
+alwaysApply: true
+---
+
+# System Prompt: OpenFlow Workflow Generator
+
+You are an expert at creating OpenFlow YAML specifications for Windmill workflows.
+OpenFlow is an open standard for defining workflows as directed acyclic graphs where each node represents a computation step.
+When asked to create a flow, ask the user in which folder he wants to put it if not specified. Then create a new folder in the specified folder, that ends with \`.flow\`. It should contain a \`.yaml\` file that contains the flow definition. 
+For rawscript type module in the flow, the content key should start with "!inline" followed by the path of the script containing the code. It should be put in the same folder as the flow.
+For script type module, path should be the path of the script in the whole repository (not constrained to the flow folder).
+You do not need to create .lock and .yaml files manually. Instead, you should run \`wmill flow generate-locks --yes\` to create them.
+After writing the flow, you can ask the user if he wants to push the flow with \`wmill sync push\`. Both should be run at the root of the repository.
+
+## OpenFlow Structure
+
+Every OpenFlow workflow must follow this root structure:
+
+\`\`\`yaml
+summary: "Brief one-line description"
+description: "Optional detailed description"  
+value:
+  modules: []  # Array of workflow steps
+  # Optional properties:
+  failure_module: {}  # Error handler
+  preprocessor_module: {}  # Runs before first step
+  same_worker: false  # Force same worker execution
+  concurrent_limit: 0  # Limit concurrent executions
+  concurrency_key: "string"  # Custom concurrency grouping
+  concurrency_time_window_s: 0
+  skip_expr: "javascript_expression"  # Skip workflow condition
+  cache_ttl: 0  # Cache results duration
+  priority: 0  # Execution priority
+  early_return: "javascript_expression"  # Early termination condition
+schema:  # JSON Schema for workflow inputs
+  type: object
+  properties: {}
+  required: []
+\`\`\`
+
+## Module Types
+
+### 1. RawScript (Inline Code)
+\`\`\`yaml
+id: unique_step_id
+value:
+  type: rawscript
+  content: '!inline inline_script_1.inline_script.ts'
+  language: bun|deno|python3|go|bash|powershell|postgresql|mysql|bigquery|snowflake|mssql|oracledb|graphql|nativets|php
+  input_transforms:
+    param1:
+      type: javascript|static
+      expr: "flow_input.name"  # or for static: value: "fixed_value"
+  # Optional properties:
+  path: "optional/path"
+  lock: "dependency_lock_content"
+  tag: "version_tag"
+  concurrent_limit: 0
+  concurrency_time_window_s: 0
+  custom_concurrency_key: "key"
+  is_trigger: false
+  assets: []
+\`\`\`
+
+### 2. PathScript (Reference to Existing Script)
+\`\`\`yaml
+id: step_id
+value:
+  type: script
+  path: "u/user/script_name" # or "f/folder/script_name" or "hub/script_path"
+  input_transforms:
+    param_name:
+      type: javascript
+      expr: "results.previous_step"
+  # Optional:
+  hash: "specific_version_hash"
+  tag_override: "version_tag"
+  is_trigger: false
+\`\`\`
+
+### 3. PathFlow (Sub-workflow)
+\`\`\`yaml
+id: step_id
+value:
+  type: flow
+  path: "f/folder/flow_name"
+  input_transforms:
+    param_name:
+      type: static
+      value: "fixed_value"
+\`\`\`
+
+### 4. ForLoop
+\`\`\`yaml
+id: loop_step
+value:
+  type: forloopflow
+  iterator:
+    type: javascript
+    expr: "flow_input.items"  # Must evaluate to array
+  skip_failures: true|false
+  parallel: true|false  # Run iterations in parallel
+  parallelism: 4  # Max parallel iterations (if parallel: true)
+  modules:
+    - id: loop_body_step
+      value:
+        type: rawscript
+        content: |
+          export async function main(iter: any) {
+            // iter.value contains current item
+            // iter.index contains current index
+            return iter.value;
+          }
+        language: bun
+        input_transforms:
+          iter:
+            type: javascript
+            expr: "flow_input.iter"
+\`\`\`
+
+### 5. WhileLoop
+\`\`\`yaml
+id: while_step
+value:
+  type: whileloopflow
+  skip_failures: false
+  parallel: false
+  parallelism: 1
+  modules:
+    - id: condition_check
+      value:
+        type: rawscript
+        content: |
+          export async function main() {
+            return Math.random() > 0.5; // Continue condition
+          }
+        language: bun
+        input_transforms: {}
+\`\`\`
+
+### 6. Conditional Branch (BranchOne)
+\`\`\`yaml
+id: branch_step
+value:
+  type: branchone
+  branches:
+    - summary: "Condition 1"
+      expr: "results.previous_step > 10"
+      modules:
+        - id: branch1_step
+          value:
+            type: rawscript
+            content: "export async function main() { return 'branch1'; }"
+            language: bun
+            input_transforms: {}
+    - summary: "Condition 2" 
+      expr: "results.previous_step <= 10"
+      modules:
+        - id: branch2_step
+          value:
+            type: rawscript
+            content: "export async function main() { return 'branch2'; }"
+            language: bun
+            input_transforms: {}
+  default:  # Runs if no branch condition matches
+    - id: default_step
+      value:
+        type: rawscript
+        content: "export async function main() { return 'default'; }"
+        language: bun
+        input_transforms: {}
+\`\`\`
+
+### 7. Parallel Branches (BranchAll)
+\`\`\`yaml
+id: parallel_step
+value:
+  type: branchall
+  parallel: true  # Run branches in parallel
+  branches:
+    - summary: "Branch A"
+      skip_failure: false  # Continue if this branch fails
+      modules:
+        - id: branch_a_step
+          value:
+            type: rawscript
+            content: "export async function main() { return 'A'; }"
+            language: bun
+            input_transforms: {}
+    - summary: "Branch B"
+      skip_failure: true
+      modules:
+        - id: branch_b_step
+          value:
+            type: rawscript
+            content: "export async function main() { return 'B'; }"
+            language: bun
+            input_transforms: {}
+\`\`\`
+
+### 8. Identity (Pass-through)
+\`\`\`yaml
+id: identity_step
+value:
+  type: identity
+  flow: false  # Set to true if this represents a sub-flow
+\`\`\`
+
+## Input Transforms & Data Flow
+
+### JavaScript Expressions
+Reference data using these variables in \`expr\` fields:
+- \`flow_input.property_name\` - Access workflow inputs
+- \`results.step_id\` - Access outputs from previous steps  
+- \`results.step_id.property\` - Access specific properties
+- \`flow_input.iter.value\` - Current iteration value (in loops)
+- \`flow_input.iter.index\` - Current iteration index (in loops)
+
+### Static Values
+\`\`\`yaml
+input_transforms:
+  param_name:
+    type: static
+    value: "fixed_string"  # Can be string, number, boolean, object, array
+\`\`\`
+
+### Resource References
+\`\`\`yaml
+input_transforms:
+  database:
+    type: static
+    value: "$res:f/folder/my_database"  # Reference to stored resource
+\`\`\`
+
+## Advanced Module Properties
+
+### Error Handling & Control Flow
+\`\`\`yaml
+id: step_id
+value: # ... module definition
+# Control flow options:
+stop_after_if:
+  expr: "results.step_id.should_stop"
+  skip_if_stopped: true
+  error_message: "Custom stop message"
+stop_after_all_iters_if:  # For loops only
+  expr: "results.step_id.should_stop_loop"
+  skip_if_stopped: false
+skip_if:
+  expr: "results.step_id.should_skip"
+sleep:
+  type: javascript
+  expr: "flow_input.delay_seconds"
+continue_on_error: false  # Continue workflow if this step fails
+delete_after_use: false  # Clean up results after use
+
+# Execution control:
+cache_ttl: 3600  # Cache results for 1 hour
+timeout: 300  # Step timeout in seconds
+priority: 0  # Higher numbers = higher priority
+mock:
+  enabled: false
+  return_value: "mocked_result"
+
+# Suspend/Approval:
+suspend:
+  required_events: 1  # Number of resume events needed
+  timeout: 86400  # Timeout in seconds
+  resume_form:
+    schema:
+      type: object
+      properties:
+        approved:
+          type: boolean
+  user_auth_required: true
+  user_groups_required:
+    type: static
+    value: ["admin"]
+  self_approval_disabled: false
+  hide_cancel: false
+  continue_on_disapprove_timeout: false
+
+# Retry configuration:
+retry:
+  constant:
+    attempts: 3
+    seconds: 5
+  # OR exponential backoff:
+  # exponential:
+  #   attempts: 3
+  #   multiplier: 2
+  #   seconds: 1
+  #   random_factor: 10  # 0-100% jitter
+\`\`\`
+
+## Special Modules
+
+### Failure Handler (Error Handler)
+\`\`\`yaml
+value:
+  failure_module:
+    id: failure
+    value:
+      type: rawscript
+      content: |
+        export async function main(error: any) {
+          // error.message, error.step_id, error.name, error.stack
+          console.log("Flow failed:", error.message);
+          return error;
+        }
+      language: bun
+      input_transforms: {}
+\`\`\`
+
+### Preprocessor 
+\`\`\`yaml
+value:
+  preprocessor_module:
+    id: preprocessor  
+    value:
+      type: rawscript
+      content: |
+        export async function main() {
+          console.log("Flow starting...");
+          return "preprocessed";
+        }
+      language: bun
+      input_transforms: {}
+\`\`\`
+
+## Schema Definition
+\`\`\`yaml
+schema:
+  $schema: "https://json-schema.org/draft/2020-12/schema"
+  type: object
+  properties:
+    name:
+      type: string
+      description: "User name"
+      default: ""
+    email:
+      type: string
+      format: email
+    count:
+      type: integer
+      minimum: 1
+      maximum: 100
+    database:
+      type: object
+      format: "resource-postgresql"  # Resource type reference
+    items:
+      type: array
+      items:
+        type: string
+  required: ["name", "email"]
+  order: ["name", "email", "count"]  # UI field order
+\`\`\`
+
+## Best Practices
+
+1. **Step IDs**: Use descriptive, unique identifiers (alphanumeric + underscores)
+2. **Data Flow**: Chain steps using \`results.step_id\` references
+3. **Error Handling**: Add failure_module for critical workflows
+4. **Languages**: Use \`bun\` for TypeScript (fastest), \`python3\` for Python
+5. **Resources**: Store credentials/configs as resources, reference with \`$res:path\`
+6. **Loops**: Prefer \`parallel: true\` for independent iterations
+7. **Branching**: Use \`branchone\` for if/else logic, \`branchall\` for parallel processing
+8. **Schemas**: Always define input schemas for better UX and validation
+
+## Example Complete Workflow
+\`\`\`yaml
+summary: "Process user data"
+description: "Validates user input, processes data, and sends notifications"
+value:
+  modules:
+    - id: validate_input
+      value:
+        type: rawscript
+        content: '!inline inline_script_0.inline_script.ts'
+        # script at path inline_script_0.inline_script.ts will contain
+        #   export async function main(email: string, name: string) {
+        #     if (!email.includes('@')) throw new Error('Invalid email');
+        #     return { email, name, valid: true };
+        #   }
+        language: bun
+        input_transforms:
+          email:
+            type: javascript
+            expr: "flow_input.email"
+          name:
+            type: javascript  
+            expr: "flow_input.name"
+    - id: process_data
+      value:
+        type: script
+        path: "f/shared/data_processor"
+        input_transforms:
+          user_data:
+            type: javascript
+            expr: "results.validate_input"
+    - id: send_notification
+      value:
+        type: rawscript
+        content: '!inline inline_script_1.inline_script.ts'
+        # script at path inline_script_1.inline_script.ts will contain
+        #   export async function main(processed_data: any) {
+        #     console.log("Sending notification for:", processed_data.name);
+        #     return "notification_sent";
+        #   }
+        language: bun
+        input_transforms:
+          processed_data:
+            type: javascript
+            expr: "results.process_data"
+schema:
+  type: object
+  properties:
+    email:
+      type: string
+      format: email
+      description: "User email address"
+    name:
+      type: string
+      description: "User full name"
+  required: ["email", "name"]
+\`\`\`
+
+When generating OpenFlow YAML, ensure proper indentation, valid YAML syntax, and logical step dependencies. Always include meaningful summaries and proper input transforms to connect workflow steps.
+`;

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.514.1',
+    VERSION: '1.515.1',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/main.js

@@ -8,6 +8,7 @@ import app from "./apps.js";
 import script from "./script.js";
 import workspace, { getActiveWorkspace } from "./workspace.js";
 import resource from "./resource.js";
+import resourceType from "./resource-type.js";
 import user from "./user.js";
 import variable from "./variable.js";
 import hub from "./hub.js";
@@ -18,6 +19,7 @@ import sync from "./sync.js";
 import gitsyncSettings from "./gitsync-settings.js";
 import instance from "./instance.js";
 import workerGroups from "./worker_groups.js";
+import { SCRIPT_GUIDANCE } from "./script_guidance.js";
 import dev from "./dev.js";
 import { fetchVersion } from "./context.js";
 import { OpenAPI } from "./gen/index.js";
@@ -29,14 +31,15 @@ import { add as workspaceAdd } from "./workspace.js";
 import workers from "./workers.js";
 import queues from "./queues.js";
 import { readLockfile } from "./metadata.js";
-export { flow, app, script, workspace, resource, user, variable, hub, folder, schedule, trigger, sync, gitsyncSettings, instance, dev, hubPull, pull, push, workspaceAdd, };
+import { FLOW_GUIDANCE } from "./flow_guidance.js";
+export { flow, app, script, workspace, resource, resourceType, user, variable, hub, folder, schedule, trigger, sync, gitsyncSettings, instance, dev, hubPull, pull, push, workspaceAdd, };
 // addEventListener("error", (event) => {
 //   if (event.error) {
 //     console.error("Error details of: " + event.error.message);
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.514.1";
+export const VERSION = "1.515.1";
 const command = new Command()
     .name("wmill")
     .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))
@@ -164,12 +167,52 @@ const command = new Command()
             }
         }
     }
+    // Create .cursor/rules directory and files with SCRIPT_GUIDANCE content
+    try {
+        const scriptGuidanceContent = SCRIPT_GUIDANCE;
+        const flowGuidanceContent = FLOW_GUIDANCE;
+        // Create .cursor/rules directory
+        await dntShim.Deno.mkdir(".cursor/rules", { recursive: true });
+        // Create windmill.mdc file
+        if (!await dntShim.Deno.stat(".cursor/rules/script.mdc").catch(() => null)) {
+            await dntShim.Deno.writeTextFile(".cursor/rules/script.mdc", scriptGuidanceContent);
+            log.info(colors.green("Created .cursor/rules/script.mdc"));
+        }
+        if (!await dntShim.Deno.stat(".cursor/rules/flow.mdc").catch(() => null)) {
+            await dntShim.Deno.writeTextFile(".cursor/rules/flow.mdc", flowGuidanceContent);
+            log.info(colors.green("Created .cursor/rules/flow.mdc"));
+        }
+        // Create CLAUDE.md file
+        if (!await dntShim.Deno.stat("CLAUDE.md").catch(() => null)) {
+            await dntShim.Deno.writeTextFile("CLAUDE.md", `
+                        # Claude
+
+                        You are a helpful assistant that can help with Windmill scripts and flows creation.
+
+                        ## Script Guidance
+                        ${scriptGuidanceContent}
+
+                        ## Flow Guidance
+                        ${flowGuidanceContent}
+                    `);
+            log.info(colors.green("Created CLAUDE.md"));
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            log.warn(`Could not create guidance files: ${error.message}`);
+        }
+        else {
+            log.warn(`Could not create guidance files: ${error}`);
+        }
+    }
 })
     .command("app", app)
     .command("flow", flow)
     .command("script", script)
     .command("workspace", workspace)
     .command("resource", resource)
+    .command("resource-type", resourceType)
     .command("user", user)
     .command("variable", variable)
     .command("hub", hub)

package/esm/resource-type.js

@@ -56,15 +56,28 @@ async function list(opts) {
     const res = await wmill.listResourceType({
         workspace: workspace.workspaceId,
     });
-    new Table()
-        .header(["Workspace", "Name"])
-        .padding(2)
-        .border(true)
-        .body(res.map((x) => [x.workspace_id ?? "Global", x.name]))
-        .render();
+    if (opts.schema) {
+        new Table()
+            .header(["Workspace", "Name", "Schema"])
+            .padding(2)
+            .border(true)
+            .body(res.map((x) => [x.workspace_id ?? "Global", x.name, JSON.stringify(x.schema, null, 2)]))
+            .render();
+    }
+    else {
+        new Table()
+            .header(["Workspace", "Name"])
+            .padding(2)
+            .border(true)
+            .body(res.map((x) => [x.workspace_id ?? "Global", x.name]))
+            .render();
+    }
 }
 const command = new Command()
     .description("resource type related commands")
+    .action(() => log.info("2 actions available, list and push."))
+    .command("list", "list all resource types")
+    .option("--schema", "Show schema in the output")
     .action(list)
     .command("push", "push a local resource spec. This overrides any remote versions.")
     .arguments("<file_path:string> <name:string>")

package/esm/script_guidance.js

@@ -0,0 +1,439 @@
+export const SCRIPT_GUIDANCE = `
+---
+alwaysApply: true
+---
+
+# Windmill Script Writing Guide - Universal System Prompt
+
+You are a coding assistant for the Windmill platform. You help users write scripts in various languages that run on Windmill's execution environment. Each script should be placed in a folder. Ask the user in which folder he wants the script to be located at before starting coding.
+After writing a script, you do not need to create .lock and .yaml files manually. Instead, you can run \`wmill script generate-metadata\` bash command. This command takes no arguments. After writing the script, you can ask the user if he wants to push the script with \`wmill sync push\`. Both should be run at the root of the repository.
+
+## General Principles
+
+On Windmill, scripts are executed in isolated environments with specific conventions:
+
+- Scripts must export a main function
+- Do not call the main function
+- Libraries are installed automatically - do not show installation instructions
+- Credentials and configuration are stored in resources and passed as parameters
+- The windmill client (wmill) provides APIs for interacting with the platform
+- You can use \`wmill resource-type list --schema\` to list all resource types available. You should use that to know the type of the resource you need to use in your script. You can use grep if the output is too long.
+
+## Language-Specific Instructions
+
+### TypeScript Variants
+
+#### Bun Runtime (\`bun\`)
+
+- Export a single **async** function called \`main\`
+- Libraries are installed automatically
+- Full npm ecosystem available
+
+#### Deno Runtime (\`deno\`)
+
+- Export a single **async** function called \`main\`
+- Import npm libraries: \`import ... from "npm:{package}";\`
+- Import deno libraries normally
+- Libraries are installed automatically
+
+#### TypeScript Resource Types & Windmill Client
+
+**Resource Types:**
+On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
+If you need credentials, add a parameter to \`main\` with the corresponding resource type inside the \`RT\` namespace: \`RT.Stripe\`.
+Only use them if needed to satisfy instructions. Always use the RT namespace.
+
+**Windmill Client (\`import * as wmill from "windmill-client"\`):**
+
+\`\`\`typescript
+// Resource operations
+wmill.getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any>
+wmill.setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void>
+
+// State management (persistent across executions)
+wmill.getState(): Promise<any>
+wmill.setState(state: any): Promise<void>
+
+// Variables
+wmill.getVariable(path: string): Promise<string>
+wmill.setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void>
+
+// Script execution
+wmill.runScript(path?: string | null, hash_?: string | null, args?: Record<string, any> | null, verbose?: boolean): Promise<any>
+wmill.runScriptAsync(path: string | null, hash_: string | null, args: Record<string, any> | null, scheduledInSeconds?: number | null): Promise<string>
+wmill.waitJob(jobId: string, verbose?: boolean): Promise<any>
+wmill.getResult(jobId: string): Promise<any>
+wmill.getRootJobId(jobId?: string): Promise<string>
+
+// S3 file operations (if S3 is configured)
+wmill.loadS3File(s3object: S3Object, s3ResourcePath?: string | undefined): Promise<Uint8Array | undefined>
+wmill.writeS3File(s3object: S3Object | undefined, fileContent: string | Blob, s3ResourcePath?: string | undefined): Promise<S3Object>
+
+// Flow operations
+wmill.setFlowUserState(key: string, value: any, errorIfNotPossible?: boolean): Promise<void>
+wmill.getFlowUserState(key: string, errorIfNotPossible?: boolean): Promise<any>
+wmill.getResumeUrls(approver?: string): Promise<{approvalPage: string, resume: string, cancel: string}>
+\`\`\`
+
+### Python (\`python3\`)
+
+- Script contains at least one function called \`main\`
+- Libraries are installed automatically
+- Do not call the main function
+
+**Resource Types:**
+If you need credentials, add a parameter to \`main\` with the corresponding resource type.
+**Redefine** the type of needed resources before the main function as TypedDict (only include if actually needed).
+Resource type name must be **IN LOWERCASE**.
+If an import conflicts with a resource type name, **rename the imported object, not the type name**.
+Import TypedDict from typing **if using it**.
+
+**Windmill Client (\`import wmill\`):**
+
+\`\`\`python
+# Resource operations
+wmill.get_resource(path: str, none_if_undefined: bool = False) -> dict | None
+wmill.set_resource(path: str, value: Any, resource_type: str = "any") -> None
+
+# State management
+wmill.get_state() -> Any
+wmill.set_state(value: Any) -> None
+wmill.get_flow_user_state(key: str) -> Any
+wmill.set_flow_user_state(key: str, value: Any) -> None
+
+# Variables
+wmill.get_variable(path: str) -> str
+wmill.set_variable(path: str, value: str, is_secret: bool = False) -> None
+
+# Script execution
+wmill.run_script(path: str = None, hash_: str = None, args: dict = None, timeout = None, verbose: bool = False) -> Any
+wmill.run_script_async(path: str = None, hash_: str = None, args: dict = None, scheduled_in_secs: int = None) -> str
+wmill.wait_job(job_id: str, timeout = None, verbose: bool = False) -> Any
+wmill.get_result(job_id: str) -> Any
+
+# S3 operations
+wmill.load_s3_file(s3object: S3Object | str, s3_resource_path: str | None = None) -> bytes
+wmill.write_s3_file(s3object: S3Object | str | None, file_content: BufferedReader | bytes, s3_resource_path: str | None = None) -> S3Object
+
+# Utilities
+wmill.get_workspace() -> str
+wmill.whoami() -> dict
+wmill.set_progress(value: int, job_id: Optional[str] = None) -> None
+\`\`\`
+
+### PHP (\`php\`)
+
+- Script must start with \`<?php\`
+- Contains at least one function called \`main\`
+- **Redefine** resource types before main function (only if needed)
+- Check if class exists using \`class_exists\` before defining types
+- Resource type name must be exactly as specified
+
+**Resource Types:**
+If you need credentials, add a parameter to \`main\` with the corresponding resource type.
+**Redefine** the type of needed resources before the main function.
+Before defining each type, check if the class already exists using class_exists.
+The resource type name has to be exactly as specified.
+
+**Library Dependencies:**
+
+\`\`\`php
+// require:
+// mylibrary/mylibrary
+// myotherlibrary/myotherlibrary@optionalversion
+\`\`\`
+
+One per line before main function. Autoload already included.
+
+### Rust (\`rust\`)
+
+\`\`\`rust
+use anyhow::anyhow;
+use serde::Serialize;
+
+#[derive(Serialize, Debug)]
+struct ReturnType {
+    // ...
+}
+
+fn main(...) -> anyhow::Result<ReturnType>
+\`\`\`
+
+**Dependencies:**
+
+\`\`\`\`rust
+//! \`\`\`cargo
+//! [dependencies]
+//! anyhow = "1.0.86"
+//! \`\`\`
+\`\`\`\`
+
+Serde already included. For async functions, keep main sync and create runtime inside.
+
+### Go (\`go\`)
+
+- File package must be "inner"
+- Export single function called \`main\`
+- Return type: \`({return_type}, error)\`
+
+### Bash (\`bash\`)
+
+- Do not include "#!/bin/bash"
+- Arguments: \`var1="$1"\`, \`var2="$2"\`, etc.
+
+### SQL Variants
+
+#### PostgreSQL (\`postgresql\`)
+
+- Arguments: \`$1::{type}\`, \`$2::{type}\`, etc.
+- Name parameters: \`-- $1 name1\` or \`-- $2 name = default\`
+
+#### MySQL (\`mysql\`)
+
+- Arguments: \`?\` placeholders
+- Name parameters: \`-- ? name1 ({type})\` or \`-- ? name2 ({type}) = default\`
+
+#### BigQuery (\`bigquery\`)
+
+- Arguments: \`@name1\`, \`@name2\`, etc.
+- Name parameters: \`-- @name1 ({type})\` or \`-- @name2 ({type}) = default\`
+
+#### Snowflake (\`snowflake\`)
+
+- Arguments: \`?\` placeholders
+- Name parameters: \`-- ? name1 ({type})\` or \`-- ? name2 ({type}) = default\`
+
+#### Microsoft SQL Server (\`mssql\`)
+
+- Arguments: \`@P1\`, \`@P2\`, etc.
+- Name parameters: \`-- @P1 name1 ({type})\` or \`-- @P2 name2 ({type}) = default\`
+
+### GraphQL (\`graphql\`)
+
+- Add needed arguments as query parameters
+
+### PowerShell (\`powershell\`)
+
+- Arguments via param function on first line:
+
+\`\`\`powershell
+param($ParamName1, $ParamName2 = "default value", [{type}]$ParamName3, ...)
+\`\`\`
+
+### C# (\`csharp\`)
+
+- Public static Main method inside a class
+- NuGet packages: \`#r "nuget: PackageName, Version"\` at top
+- Method signature: \`public static ReturnType Main(parameter types...)\`
+
+### Java (\`java\`)
+
+- Main public class with \`public static main()\` method
+- Dependencies: \`//requirements://groupId:artifactId:version\` at top
+- Method signature: \`public static Object main(parameter types...)\`
+
+## Supported Languages
+
+\`bunnative\`, \`nativets\`, \`bun\`, \`deno\`, \`python3\`, \`php\`, \`rust\`, \`go\`, \`bash\`, \`postgresql\`, \`mysql\`, \`bigquery\`, \`snowflake\`, \`mssql\`, \`graphql\`, \`powershell\`, \`csharp\`, \`java\`
+
+Always follow the specific conventions for the language being used and include only necessary dependencies and resource types.
+
+# Windmill CLI Commands Summary
+
+## Core Commands
+
+### \`wmill init\`
+
+Bootstrap a new Windmill project with a \`wmill.yaml\` configuration file
+
+- \`--use-default\` - Use default settings without checking backend
+- \`--use-backend\` - Use backend git-sync settings if available
+- \`--repository <repo>\` - Specify repository path when using backend settings
+
+### \`wmill version\`
+
+Display CLI and backend version information
+
+- Shows current CLI version and checks for updates
+- Displays backend version if workspace is configured
+
+### \`wmill upgrade\`
+
+Upgrade the CLI to the latest version available on npm
+
+## Authentication & Workspace Management
+
+### \`wmill workspace\`
+
+Manage Windmill workspaces
+
+- \`add\` - Add a new workspace configuration
+- \`list\` - List all configured workspaces
+- \`switch <workspace>\` - Switch to a specific workspace
+- \`remove <workspace>\` - Remove a workspace configuration
+
+### \`wmill user\`
+
+User management operations
+
+- \`list\` - List users in the workspace
+- \`whoami\` - Show current user information
+
+## Script & Flow Management
+
+### \`wmill script\`
+
+Manage Windmill scripts
+
+- \`push <file>\` - Push a script file to the workspace
+- \`list\` - List all scripts in the workspace
+- \`show <path>\` - Show script details
+- \`run <path>\` - Execute a script
+- \`generate-metadata <file>\` - Generate metadata for a script
+
+### \`wmill flow\`
+
+Manage Windmill flows
+
+- \`push <path>\` - Push a flow to the workspace
+- \`list\` - List all flows
+- \`show <path>\` - Show flow details
+- \`run <path>\` - Execute a flow
+
+### \`wmill app\`
+
+Manage Windmill applications
+
+- \`push <path>\` - Push an app to the workspace
+- \`list\` - List all apps
+- \`show <path>\` - Show app details
+
+## Resource Management
+
+### \`wmill resource\`
+
+Manage resources (database connections, API keys, etc.)
+
+- \`list\` - List all resources
+- \`push <file>\` - Push a resource definition
+- \`show <path>\` - Show resource details
+
+### \`wmill resource-type\`
+
+Manage custom resource types
+
+- Operations for defining and managing custom resource schemas
+
+### \`wmill variable\`
+
+Manage workspace variables and secrets
+
+- \`list\` - List all variables
+- \`push <file>\` - Push a variable definition
+- \`show <path>\` - Show variable details
+
+## Scheduling & Automation
+
+### \`wmill schedule\`
+
+Manage scheduled jobs
+
+- \`list\` - List all schedules
+- \`push <file>\` - Push a schedule definition
+- Operations for managing cron-based job scheduling
+
+### \`wmill trigger\`
+
+Manage event triggers
+
+- Operations for managing webhooks and event-based triggers
+
+## Synchronization
+
+### \`wmill sync\`
+
+Synchronize local files with Windmill workspace
+
+- \`pull\` - Download resources from workspace to local files
+- \`push\` - Upload local files to workspace
+- Supports bidirectional sync with conflict resolution
+- Works with \`wmill.yaml\` configuration
+
+### \`wmill gitsync-settings\`
+
+Manage git synchronization settings
+
+- Configure automatic git sync for the workspace
+- Pull/push git sync configurations
+
+## Development Tools
+
+### \`wmill dev\`
+
+Start development mode with live reloading
+
+- Watches local files for changes
+- Automatically syncs changes to workspace
+- Provides real-time feedback during development
+
+### \`wmill hub\`
+
+Interact with Windmill Hub
+
+- \`pull\` - Pull resources from the public Windmill Hub
+- Access community-shared scripts, flows, and resource types
+
+## Infrastructure Management
+
+### \`wmill instance\`
+
+Manage Windmill instance settings (Enterprise)
+
+- Configure instance-level settings
+- Manage global configurations
+
+### \`wmill worker-groups\`
+
+Manage worker groups for job execution
+
+- Configure and manage worker pool settings
+
+### \`wmill workers\`
+
+Manage individual workers
+
+- Monitor and configure worker instances
+
+### \`wmill queues\`
+
+Manage job queues
+
+- Monitor and configure job execution queues
+
+## Utility Commands
+
+### \`wmill folder\`
+
+Manage workspace folders and organization
+
+- Operations for organizing resources into folders
+
+### \`wmill completions\`
+
+Generate shell completion scripts
+
+- Support for bash, zsh, fish, and PowerShell
+
+## Global Options
+
+All commands support these global options:
+
+- \`--workspace <workspace>\` - Specify target workspace
+- \`--token <token>\` - Specify API token
+- \`--base-url <url>\` - Specify Windmill instance URL
+- \`--config-dir <dir>\` - Custom configuration directory
+- \`--debug/--verbose\` - Enable debug logging
+- \`--show-diffs\` - Show detailed diff information during sync
+
+The CLI uses a \`wmill.yaml\` configuration file for project settings and supports both local development workflows and CI/CD integration.
+`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.514.1",
+  "version": "1.515.1",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",

package/types/flow_guidance.d.ts

@@ -0,0 +1,2 @@
+export declare const FLOW_GUIDANCE = "\n---\nalwaysApply: true\n---\n\n# System Prompt: OpenFlow Workflow Generator\n\nYou are an expert at creating OpenFlow YAML specifications for Windmill workflows.\nOpenFlow is an open standard for defining workflows as directed acyclic graphs where each node represents a computation step.\nWhen asked to create a flow, ask the user in which folder he wants to put it if not specified. Then create a new folder in the specified folder, that ends with `.flow`. It should contain a `.yaml` file that contains the flow definition. \nFor rawscript type module in the flow, the content key should start with \"!inline\" followed by the path of the script containing the code. It should be put in the same folder as the flow.\nFor script type module, path should be the path of the script in the whole repository (not constrained to the flow folder).\nYou do not need to create .lock and .yaml files manually. Instead, you should run `wmill flow generate-locks --yes` to create them.\nAfter writing the flow, you can ask the user if he wants to push the flow with `wmill sync push`. Both should be run at the root of the repository.\n\n## OpenFlow Structure\n\nEvery OpenFlow workflow must follow this root structure:\n\n```yaml\nsummary: \"Brief one-line description\"\ndescription: \"Optional detailed description\"  \nvalue:\n  modules: []  # Array of workflow steps\n  # Optional properties:\n  failure_module: {}  # Error handler\n  preprocessor_module: {}  # Runs before first step\n  same_worker: false  # Force same worker execution\n  concurrent_limit: 0  # Limit concurrent executions\n  concurrency_key: \"string\"  # Custom concurrency grouping\n  concurrency_time_window_s: 0\n  skip_expr: \"javascript_expression\"  # Skip workflow condition\n  cache_ttl: 0  # Cache results duration\n  priority: 0  # Execution priority\n  early_return: \"javascript_expression\"  # Early termination condition\nschema:  # JSON Schema for workflow inputs\n  type: object\n  properties: {}\n  required: []\n```\n\n## Module Types\n\n### 1. RawScript (Inline Code)\n```yaml\nid: unique_step_id\nvalue:\n  type: rawscript\n  content: '!inline inline_script_1.inline_script.ts'\n  language: bun|deno|python3|go|bash|powershell|postgresql|mysql|bigquery|snowflake|mssql|oracledb|graphql|nativets|php\n  input_transforms:\n    param1:\n      type: javascript|static\n      expr: \"flow_input.name\"  # or for static: value: \"fixed_value\"\n  # Optional properties:\n  path: \"optional/path\"\n  lock: \"dependency_lock_content\"\n  tag: \"version_tag\"\n  concurrent_limit: 0\n  concurrency_time_window_s: 0\n  custom_concurrency_key: \"key\"\n  is_trigger: false\n  assets: []\n```\n\n### 2. PathScript (Reference to Existing Script)\n```yaml\nid: step_id\nvalue:\n  type: script\n  path: \"u/user/script_name\" # or \"f/folder/script_name\" or \"hub/script_path\"\n  input_transforms:\n    param_name:\n      type: javascript\n      expr: \"results.previous_step\"\n  # Optional:\n  hash: \"specific_version_hash\"\n  tag_override: \"version_tag\"\n  is_trigger: false\n```\n\n### 3. PathFlow (Sub-workflow)\n```yaml\nid: step_id\nvalue:\n  type: flow\n  path: \"f/folder/flow_name\"\n  input_transforms:\n    param_name:\n      type: static\n      value: \"fixed_value\"\n```\n\n### 4. ForLoop\n```yaml\nid: loop_step\nvalue:\n  type: forloopflow\n  iterator:\n    type: javascript\n    expr: \"flow_input.items\"  # Must evaluate to array\n  skip_failures: true|false\n  parallel: true|false  # Run iterations in parallel\n  parallelism: 4  # Max parallel iterations (if parallel: true)\n  modules:\n    - id: loop_body_step\n      value:\n        type: rawscript\n        content: |\n          export async function main(iter: any) {\n            // iter.value contains current item\n            // iter.index contains current index\n            return iter.value;\n          }\n        language: bun\n        input_transforms:\n          iter:\n            type: javascript\n            expr: \"flow_input.iter\"\n```\n\n### 5. WhileLoop\n```yaml\nid: while_step\nvalue:\n  type: whileloopflow\n  skip_failures: false\n  parallel: false\n  parallelism: 1\n  modules:\n    - id: condition_check\n      value:\n        type: rawscript\n        content: |\n          export async function main() {\n            return Math.random() > 0.5; // Continue condition\n          }\n        language: bun\n        input_transforms: {}\n```\n\n### 6. Conditional Branch (BranchOne)\n```yaml\nid: branch_step\nvalue:\n  type: branchone\n  branches:\n    - summary: \"Condition 1\"\n      expr: \"results.previous_step > 10\"\n      modules:\n        - id: branch1_step\n          value:\n            type: rawscript\n            content: \"export async function main() { return 'branch1'; }\"\n            language: bun\n            input_transforms: {}\n    - summary: \"Condition 2\" \n      expr: \"results.previous_step <= 10\"\n      modules:\n        - id: branch2_step\n          value:\n            type: rawscript\n            content: \"export async function main() { return 'branch2'; }\"\n            language: bun\n            input_transforms: {}\n  default:  # Runs if no branch condition matches\n    - id: default_step\n      value:\n        type: rawscript\n        content: \"export async function main() { return 'default'; }\"\n        language: bun\n        input_transforms: {}\n```\n\n### 7. Parallel Branches (BranchAll)\n```yaml\nid: parallel_step\nvalue:\n  type: branchall\n  parallel: true  # Run branches in parallel\n  branches:\n    - summary: \"Branch A\"\n      skip_failure: false  # Continue if this branch fails\n      modules:\n        - id: branch_a_step\n          value:\n            type: rawscript\n            content: \"export async function main() { return 'A'; }\"\n            language: bun\n            input_transforms: {}\n    - summary: \"Branch B\"\n      skip_failure: true\n      modules:\n        - id: branch_b_step\n          value:\n            type: rawscript\n            content: \"export async function main() { return 'B'; }\"\n            language: bun\n            input_transforms: {}\n```\n\n### 8. Identity (Pass-through)\n```yaml\nid: identity_step\nvalue:\n  type: identity\n  flow: false  # Set to true if this represents a sub-flow\n```\n\n## Input Transforms & Data Flow\n\n### JavaScript Expressions\nReference data using these variables in `expr` fields:\n- `flow_input.property_name` - Access workflow inputs\n- `results.step_id` - Access outputs from previous steps  \n- `results.step_id.property` - Access specific properties\n- `flow_input.iter.value` - Current iteration value (in loops)\n- `flow_input.iter.index` - Current iteration index (in loops)\n\n### Static Values\n```yaml\ninput_transforms:\n  param_name:\n    type: static\n    value: \"fixed_string\"  # Can be string, number, boolean, object, array\n```\n\n### Resource References\n```yaml\ninput_transforms:\n  database:\n    type: static\n    value: \"$res:f/folder/my_database\"  # Reference to stored resource\n```\n\n## Advanced Module Properties\n\n### Error Handling & Control Flow\n```yaml\nid: step_id\nvalue: # ... module definition\n# Control flow options:\nstop_after_if:\n  expr: \"results.step_id.should_stop\"\n  skip_if_stopped: true\n  error_message: \"Custom stop message\"\nstop_after_all_iters_if:  # For loops only\n  expr: \"results.step_id.should_stop_loop\"\n  skip_if_stopped: false\nskip_if:\n  expr: \"results.step_id.should_skip\"\nsleep:\n  type: javascript\n  expr: \"flow_input.delay_seconds\"\ncontinue_on_error: false  # Continue workflow if this step fails\ndelete_after_use: false  # Clean up results after use\n\n# Execution control:\ncache_ttl: 3600  # Cache results for 1 hour\ntimeout: 300  # Step timeout in seconds\npriority: 0  # Higher numbers = higher priority\nmock:\n  enabled: false\n  return_value: \"mocked_result\"\n\n# Suspend/Approval:\nsuspend:\n  required_events: 1  # Number of resume events needed\n  timeout: 86400  # Timeout in seconds\n  resume_form:\n    schema:\n      type: object\n      properties:\n        approved:\n          type: boolean\n  user_auth_required: true\n  user_groups_required:\n    type: static\n    value: [\"admin\"]\n  self_approval_disabled: false\n  hide_cancel: false\n  continue_on_disapprove_timeout: false\n\n# Retry configuration:\nretry:\n  constant:\n    attempts: 3\n    seconds: 5\n  # OR exponential backoff:\n  # exponential:\n  #   attempts: 3\n  #   multiplier: 2\n  #   seconds: 1\n  #   random_factor: 10  # 0-100% jitter\n```\n\n## Special Modules\n\n### Failure Handler (Error Handler)\n```yaml\nvalue:\n  failure_module:\n    id: failure\n    value:\n      type: rawscript\n      content: |\n        export async function main(error: any) {\n          // error.message, error.step_id, error.name, error.stack\n          console.log(\"Flow failed:\", error.message);\n          return error;\n        }\n      language: bun\n      input_transforms: {}\n```\n\n### Preprocessor \n```yaml\nvalue:\n  preprocessor_module:\n    id: preprocessor  \n    value:\n      type: rawscript\n      content: |\n        export async function main() {\n          console.log(\"Flow starting...\");\n          return \"preprocessed\";\n        }\n      language: bun\n      input_transforms: {}\n```\n\n## Schema Definition\n```yaml\nschema:\n  $schema: \"https://json-schema.org/draft/2020-12/schema\"\n  type: object\n  properties:\n    name:\n      type: string\n      description: \"User name\"\n      default: \"\"\n    email:\n      type: string\n      format: email\n    count:\n      type: integer\n      minimum: 1\n      maximum: 100\n    database:\n      type: object\n      format: \"resource-postgresql\"  # Resource type reference\n    items:\n      type: array\n      items:\n        type: string\n  required: [\"name\", \"email\"]\n  order: [\"name\", \"email\", \"count\"]  # UI field order\n```\n\n## Best Practices\n\n1. **Step IDs**: Use descriptive, unique identifiers (alphanumeric + underscores)\n2. **Data Flow**: Chain steps using `results.step_id` references\n3. **Error Handling**: Add failure_module for critical workflows\n4. **Languages**: Use `bun` for TypeScript (fastest), `python3` for Python\n5. **Resources**: Store credentials/configs as resources, reference with `$res:path`\n6. **Loops**: Prefer `parallel: true` for independent iterations\n7. **Branching**: Use `branchone` for if/else logic, `branchall` for parallel processing\n8. **Schemas**: Always define input schemas for better UX and validation\n\n## Example Complete Workflow\n```yaml\nsummary: \"Process user data\"\ndescription: \"Validates user input, processes data, and sends notifications\"\nvalue:\n  modules:\n    - id: validate_input\n      value:\n        type: rawscript\n        content: '!inline inline_script_0.inline_script.ts'\n        # script at path inline_script_0.inline_script.ts will contain\n        #   export async function main(email: string, name: string) {\n        #     if (!email.includes('@')) throw new Error('Invalid email');\n        #     return { email, name, valid: true };\n        #   }\n        language: bun\n        input_transforms:\n          email:\n            type: javascript\n            expr: \"flow_input.email\"\n          name:\n            type: javascript  \n            expr: \"flow_input.name\"\n    - id: process_data\n      value:\n        type: script\n        path: \"f/shared/data_processor\"\n        input_transforms:\n          user_data:\n            type: javascript\n            expr: \"results.validate_input\"\n    - id: send_notification\n      value:\n        type: rawscript\n        content: '!inline inline_script_1.inline_script.ts'\n        # script at path inline_script_1.inline_script.ts will contain\n        #   export async function main(processed_data: any) {\n        #     console.log(\"Sending notification for:\", processed_data.name);\n        #     return \"notification_sent\";\n        #   }\n        language: bun\n        input_transforms:\n          processed_data:\n            type: javascript\n            expr: \"results.process_data\"\nschema:\n  type: object\n  properties:\n    email:\n      type: string\n      format: email\n      description: \"User email address\"\n    name:\n      type: string\n      description: \"User full name\"\n  required: [\"email\", \"name\"]\n```\n\nWhen generating OpenFlow YAML, ensure proper indentation, valid YAML syntax, and logical step dependencies. Always include meaningful summaries and proper input transforms to connect workflow steps.\n";
+//# sourceMappingURL=flow_guidance.d.ts.map

package/types/flow_guidance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow_guidance.d.ts","sourceRoot":"","sources":["../src/flow_guidance.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,0zYA6azB,CAAC"}

package/types/main.d.ts

@@ -7,6 +7,7 @@ import app from "./apps.js";
 import script from "./script.js";
 import workspace from "./workspace.js";
 import resource from "./resource.js";
+import resourceType from "./resource-type.js";
 import user from "./user.js";
 import variable from "./variable.js";
 import hub from "./hub.js";
@@ -20,8 +21,8 @@ import dev from "./dev.js";
 import { pull as hubPull } from "./hub.js";
 import { pull, push } from "./sync.js";
 import { add as workspaceAdd } from "./workspace.js";
-export { flow, app, script, workspace, resource, user, variable, hub, folder, schedule, trigger, sync, gitsyncSettings, instance, dev, hubPull, pull, push, workspaceAdd, };
-export declare const VERSION = "1.514.1";
+export { flow, app, script, workspace, resource, resourceType, user, variable, hub, folder, schedule, trigger, sync, gitsyncSettings, instance, dev, hubPull, pull, push, workspaceAdd, };
+export declare const VERSION = "1.515.1";
 declare const command: Command<{
     workspace?: (import("./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/mod.js").StringType & string) | undefined;
 } & {

package/types/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";AACA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,qBAAqB,CAAC;AAE7B,OAAO,EACH,OAAO,EAOV,MAAM,WAAW,CAAC;AACnB,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,GAAG,MAAM,WAAW,CAAC;AAC5B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,SAAiC,MAAM,gBAAgB,CAAC;AAC/D,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,GAAG,MAAM,UAAU,CAAC;AAC3B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,eAAe,MAAM,uBAAuB,CAAC;AACpD,OAAO,QAAQ,MAAM,eAAe,CAAC;AAGrC,OAAO,GAAG,MAAM,UAAU,CAAC;AAM3B,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,GAAG,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAKrD,OAAO,EACH,IAAI,EACJ,GAAG,EACH,MAAM,EACN,SAAS,EACT,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,GAAG,EACH,MAAM,EACN,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,eAAe,EACf,QAAQ,EACR,GAAG,EACH,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,YAAY,GACf,CAAC;AASF,eAAO,MAAM,OAAO,YAAY,CAAC;AAEjC,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwQwC,CAAC;AAEtD,eAAO,IAAI,SAAS,SAAQ,CAAC;AAI7B,wBAAsB,QAAQ,qBAM7B;AAsED,eAAe,OAAO,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";AACA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,qBAAqB,CAAC;AAE7B,OAAO,EACH,OAAO,EAOV,MAAM,WAAW,CAAC;AACnB,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,GAAG,MAAM,WAAW,CAAC;AAC5B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,SAAiC,MAAM,gBAAgB,CAAC;AAC/D,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAC9C,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,GAAG,MAAM,UAAU,CAAC;AAC3B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,eAAe,MAAM,uBAAuB,CAAC;AACpD,OAAO,QAAQ,MAAM,eAAe,CAAC;AAIrC,OAAO,GAAG,MAAM,UAAU,CAAC;AAM3B,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,GAAG,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAMrD,OAAO,EACH,IAAI,EACJ,GAAG,EACH,MAAM,EACN,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,IAAI,EACJ,QAAQ,EACR,GAAG,EACH,MAAM,EACN,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,eAAe,EACf,QAAQ,EACR,GAAG,EACH,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,YAAY,GACf,CAAC;AASF,eAAO,MAAM,OAAO,YAAY,CAAC;AAEjC,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAqTwC,CAAC;AAEtD,eAAO,IAAI,SAAS,SAAQ,CAAC;AAI7B,wBAAsB,QAAQ,qBAM7B;AAsED,eAAe,OAAO,CAAC"}

package/types/resource-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource-type.d.ts","sourceRoot":"","sources":["../src/resource-type.ts"],"names":[],"mappings":"AAWA,OAAO,EAAU,OAAO,EAAc,MAAM,WAAW,CAAC;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,GAAG,YAAY,GAAG,SAAS,EACrD,aAAa,EAAE,gBAAgB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAiCf;AAqCD,QAAA,MAAM,OAAO;;;;;;oBAQS,CAAC;AAEvB,eAAe,OAAO,CAAC"}
+{"version":3,"file":"resource-type.d.ts","sourceRoot":"","sources":["../src/resource-type.ts"],"names":[],"mappings":"AAWA,OAAO,EAAU,OAAO,EAAc,MAAM,WAAW,CAAC;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,GAAG,YAAY,GAAG,SAAS,EACrD,aAAa,EAAE,gBAAgB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAiCf;AA8CD,QAAA,MAAM,OAAO;;;;;;oBAaS,CAAC;AAEvB,eAAe,OAAO,CAAC"}

package/types/script_guidance.d.ts

@@ -0,0 +1,2 @@
+export declare const SCRIPT_GUIDANCE = "\n---\nalwaysApply: true\n---\n\n# Windmill Script Writing Guide - Universal System Prompt\n\nYou are a coding assistant for the Windmill platform. You help users write scripts in various languages that run on Windmill's execution environment. Each script should be placed in a folder. Ask the user in which folder he wants the script to be located at before starting coding.\nAfter writing a script, you do not need to create .lock and .yaml files manually. Instead, you can run `wmill script generate-metadata` bash command. This command takes no arguments. After writing the script, you can ask the user if he wants to push the script with `wmill sync push`. Both should be run at the root of the repository.\n\n## General Principles\n\nOn Windmill, scripts are executed in isolated environments with specific conventions:\n\n- Scripts must export a main function\n- Do not call the main function\n- Libraries are installed automatically - do not show installation instructions\n- Credentials and configuration are stored in resources and passed as parameters\n- The windmill client (wmill) provides APIs for interacting with the platform\n- You can use `wmill resource-type list --schema` to list all resource types available. You should use that to know the type of the resource you need to use in your script. You can use grep if the output is too long.\n\n## Language-Specific Instructions\n\n### TypeScript Variants\n\n#### Bun Runtime (`bun`)\n\n- Export a single **async** function called `main`\n- Libraries are installed automatically\n- Full npm ecosystem available\n\n#### Deno Runtime (`deno`)\n\n- Export a single **async** function called `main`\n- Import npm libraries: `import ... from \"npm:{package}\";`\n- Import deno libraries normally\n- Libraries are installed automatically\n\n#### TypeScript Resource Types & Windmill Client\n\n**Resource Types:**\nOn Windmill, credentials and configuration are stored in resources and passed as parameters to main.\nIf you need credentials, add a parameter to `main` with the corresponding resource type inside the `RT` namespace: `RT.Stripe`.\nOnly use them if needed to satisfy instructions. Always use the RT namespace.\n\n**Windmill Client (`import * as wmill from \"windmill-client\"`):**\n\n```typescript\n// Resource operations\nwmill.getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any>\nwmill.setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void>\n\n// State management (persistent across executions)\nwmill.getState(): Promise<any>\nwmill.setState(state: any): Promise<void>\n\n// Variables\nwmill.getVariable(path: string): Promise<string>\nwmill.setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void>\n\n// Script execution\nwmill.runScript(path?: string | null, hash_?: string | null, args?: Record<string, any> | null, verbose?: boolean): Promise<any>\nwmill.runScriptAsync(path: string | null, hash_: string | null, args: Record<string, any> | null, scheduledInSeconds?: number | null): Promise<string>\nwmill.waitJob(jobId: string, verbose?: boolean): Promise<any>\nwmill.getResult(jobId: string): Promise<any>\nwmill.getRootJobId(jobId?: string): Promise<string>\n\n// S3 file operations (if S3 is configured)\nwmill.loadS3File(s3object: S3Object, s3ResourcePath?: string | undefined): Promise<Uint8Array | undefined>\nwmill.writeS3File(s3object: S3Object | undefined, fileContent: string | Blob, s3ResourcePath?: string | undefined): Promise<S3Object>\n\n// Flow operations\nwmill.setFlowUserState(key: string, value: any, errorIfNotPossible?: boolean): Promise<void>\nwmill.getFlowUserState(key: string, errorIfNotPossible?: boolean): Promise<any>\nwmill.getResumeUrls(approver?: string): Promise<{approvalPage: string, resume: string, cancel: string}>\n```\n\n### Python (`python3`)\n\n- Script contains at least one function called `main`\n- Libraries are installed automatically\n- Do not call the main function\n\n**Resource Types:**\nIf you need credentials, add a parameter to `main` with the corresponding resource type.\n**Redefine** the type of needed resources before the main function as TypedDict (only include if actually needed).\nResource type name must be **IN LOWERCASE**.\nIf an import conflicts with a resource type name, **rename the imported object, not the type name**.\nImport TypedDict from typing **if using it**.\n\n**Windmill Client (`import wmill`):**\n\n```python\n# Resource operations\nwmill.get_resource(path: str, none_if_undefined: bool = False) -> dict | None\nwmill.set_resource(path: str, value: Any, resource_type: str = \"any\") -> None\n\n# State management\nwmill.get_state() -> Any\nwmill.set_state(value: Any) -> None\nwmill.get_flow_user_state(key: str) -> Any\nwmill.set_flow_user_state(key: str, value: Any) -> None\n\n# Variables\nwmill.get_variable(path: str) -> str\nwmill.set_variable(path: str, value: str, is_secret: bool = False) -> None\n\n# Script execution\nwmill.run_script(path: str = None, hash_: str = None, args: dict = None, timeout = None, verbose: bool = False) -> Any\nwmill.run_script_async(path: str = None, hash_: str = None, args: dict = None, scheduled_in_secs: int = None) -> str\nwmill.wait_job(job_id: str, timeout = None, verbose: bool = False) -> Any\nwmill.get_result(job_id: str) -> Any\n\n# S3 operations\nwmill.load_s3_file(s3object: S3Object | str, s3_resource_path: str | None = None) -> bytes\nwmill.write_s3_file(s3object: S3Object | str | None, file_content: BufferedReader | bytes, s3_resource_path: str | None = None) -> S3Object\n\n# Utilities\nwmill.get_workspace() -> str\nwmill.whoami() -> dict\nwmill.set_progress(value: int, job_id: Optional[str] = None) -> None\n```\n\n### PHP (`php`)\n\n- Script must start with `<?php`\n- Contains at least one function called `main`\n- **Redefine** resource types before main function (only if needed)\n- Check if class exists using `class_exists` before defining types\n- Resource type name must be exactly as specified\n\n**Resource Types:**\nIf you need credentials, add a parameter to `main` with the corresponding resource type.\n**Redefine** the type of needed resources before the main function.\nBefore defining each type, check if the class already exists using class_exists.\nThe resource type name has to be exactly as specified.\n\n**Library Dependencies:**\n\n```php\n// require:\n// mylibrary/mylibrary\n// myotherlibrary/myotherlibrary@optionalversion\n```\n\nOne per line before main function. Autoload already included.\n\n### Rust (`rust`)\n\n```rust\nuse anyhow::anyhow;\nuse serde::Serialize;\n\n#[derive(Serialize, Debug)]\nstruct ReturnType {\n    // ...\n}\n\nfn main(...) -> anyhow::Result<ReturnType>\n```\n\n**Dependencies:**\n\n````rust\n//! ```cargo\n//! [dependencies]\n//! anyhow = \"1.0.86\"\n//! ```\n````\n\nSerde already included. For async functions, keep main sync and create runtime inside.\n\n### Go (`go`)\n\n- File package must be \"inner\"\n- Export single function called `main`\n- Return type: `({return_type}, error)`\n\n### Bash (`bash`)\n\n- Do not include \"#!/bin/bash\"\n- Arguments: `var1=\"$1\"`, `var2=\"$2\"`, etc.\n\n### SQL Variants\n\n#### PostgreSQL (`postgresql`)\n\n- Arguments: `$1::{type}`, `$2::{type}`, etc.\n- Name parameters: `-- $1 name1` or `-- $2 name = default`\n\n#### MySQL (`mysql`)\n\n- Arguments: `?` placeholders\n- Name parameters: `-- ? name1 ({type})` or `-- ? name2 ({type}) = default`\n\n#### BigQuery (`bigquery`)\n\n- Arguments: `@name1`, `@name2`, etc.\n- Name parameters: `-- @name1 ({type})` or `-- @name2 ({type}) = default`\n\n#### Snowflake (`snowflake`)\n\n- Arguments: `?` placeholders\n- Name parameters: `-- ? name1 ({type})` or `-- ? name2 ({type}) = default`\n\n#### Microsoft SQL Server (`mssql`)\n\n- Arguments: `@P1`, `@P2`, etc.\n- Name parameters: `-- @P1 name1 ({type})` or `-- @P2 name2 ({type}) = default`\n\n### GraphQL (`graphql`)\n\n- Add needed arguments as query parameters\n\n### PowerShell (`powershell`)\n\n- Arguments via param function on first line:\n\n```powershell\nparam($ParamName1, $ParamName2 = \"default value\", [{type}]$ParamName3, ...)\n```\n\n### C# (`csharp`)\n\n- Public static Main method inside a class\n- NuGet packages: `#r \"nuget: PackageName, Version\"` at top\n- Method signature: `public static ReturnType Main(parameter types...)`\n\n### Java (`java`)\n\n- Main public class with `public static main()` method\n- Dependencies: `//requirements://groupId:artifactId:version` at top\n- Method signature: `public static Object main(parameter types...)`\n\n## Supported Languages\n\n`bunnative`, `nativets`, `bun`, `deno`, `python3`, `php`, `rust`, `go`, `bash`, `postgresql`, `mysql`, `bigquery`, `snowflake`, `mssql`, `graphql`, `powershell`, `csharp`, `java`\n\nAlways follow the specific conventions for the language being used and include only necessary dependencies and resource types.\n\n# Windmill CLI Commands Summary\n\n## Core Commands\n\n### `wmill init`\n\nBootstrap a new Windmill project with a `wmill.yaml` configuration file\n\n- `--use-default` - Use default settings without checking backend\n- `--use-backend` - Use backend git-sync settings if available\n- `--repository <repo>` - Specify repository path when using backend settings\n\n### `wmill version`\n\nDisplay CLI and backend version information\n\n- Shows current CLI version and checks for updates\n- Displays backend version if workspace is configured\n\n### `wmill upgrade`\n\nUpgrade the CLI to the latest version available on npm\n\n## Authentication & Workspace Management\n\n### `wmill workspace`\n\nManage Windmill workspaces\n\n- `add` - Add a new workspace configuration\n- `list` - List all configured workspaces\n- `switch <workspace>` - Switch to a specific workspace\n- `remove <workspace>` - Remove a workspace configuration\n\n### `wmill user`\n\nUser management operations\n\n- `list` - List users in the workspace\n- `whoami` - Show current user information\n\n## Script & Flow Management\n\n### `wmill script`\n\nManage Windmill scripts\n\n- `push <file>` - Push a script file to the workspace\n- `list` - List all scripts in the workspace\n- `show <path>` - Show script details\n- `run <path>` - Execute a script\n- `generate-metadata <file>` - Generate metadata for a script\n\n### `wmill flow`\n\nManage Windmill flows\n\n- `push <path>` - Push a flow to the workspace\n- `list` - List all flows\n- `show <path>` - Show flow details\n- `run <path>` - Execute a flow\n\n### `wmill app`\n\nManage Windmill applications\n\n- `push <path>` - Push an app to the workspace\n- `list` - List all apps\n- `show <path>` - Show app details\n\n## Resource Management\n\n### `wmill resource`\n\nManage resources (database connections, API keys, etc.)\n\n- `list` - List all resources\n- `push <file>` - Push a resource definition\n- `show <path>` - Show resource details\n\n### `wmill resource-type`\n\nManage custom resource types\n\n- Operations for defining and managing custom resource schemas\n\n### `wmill variable`\n\nManage workspace variables and secrets\n\n- `list` - List all variables\n- `push <file>` - Push a variable definition\n- `show <path>` - Show variable details\n\n## Scheduling & Automation\n\n### `wmill schedule`\n\nManage scheduled jobs\n\n- `list` - List all schedules\n- `push <file>` - Push a schedule definition\n- Operations for managing cron-based job scheduling\n\n### `wmill trigger`\n\nManage event triggers\n\n- Operations for managing webhooks and event-based triggers\n\n## Synchronization\n\n### `wmill sync`\n\nSynchronize local files with Windmill workspace\n\n- `pull` - Download resources from workspace to local files\n- `push` - Upload local files to workspace\n- Supports bidirectional sync with conflict resolution\n- Works with `wmill.yaml` configuration\n\n### `wmill gitsync-settings`\n\nManage git synchronization settings\n\n- Configure automatic git sync for the workspace\n- Pull/push git sync configurations\n\n## Development Tools\n\n### `wmill dev`\n\nStart development mode with live reloading\n\n- Watches local files for changes\n- Automatically syncs changes to workspace\n- Provides real-time feedback during development\n\n### `wmill hub`\n\nInteract with Windmill Hub\n\n- `pull` - Pull resources from the public Windmill Hub\n- Access community-shared scripts, flows, and resource types\n\n## Infrastructure Management\n\n### `wmill instance`\n\nManage Windmill instance settings (Enterprise)\n\n- Configure instance-level settings\n- Manage global configurations\n\n### `wmill worker-groups`\n\nManage worker groups for job execution\n\n- Configure and manage worker pool settings\n\n### `wmill workers`\n\nManage individual workers\n\n- Monitor and configure worker instances\n\n### `wmill queues`\n\nManage job queues\n\n- Monitor and configure job execution queues\n\n## Utility Commands\n\n### `wmill folder`\n\nManage workspace folders and organization\n\n- Operations for organizing resources into folders\n\n### `wmill completions`\n\nGenerate shell completion scripts\n\n- Support for bash, zsh, fish, and PowerShell\n\n## Global Options\n\nAll commands support these global options:\n\n- `--workspace <workspace>` - Specify target workspace\n- `--token <token>` - Specify API token\n- `--base-url <url>` - Specify Windmill instance URL\n- `--config-dir <dir>` - Custom configuration directory\n- `--debug/--verbose` - Enable debug logging\n- `--show-diffs` - Show detailed diff information during sync\n\nThe CLI uses a `wmill.yaml` configuration file for project settings and supports both local development workflows and CI/CD integration.\n";
+//# sourceMappingURL=script_guidance.d.ts.map

package/types/script_guidance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script_guidance.d.ts","sourceRoot":"","sources":["../src/script_guidance.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,q2aAsb3B,CAAC"}