windmill-cli 1.700.1 → 1.701.0

package/esm/main.js

@@ -16752,7 +16752,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv3("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.700.1",
+    VERSION: "1.701.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -44417,7 +44417,7 @@ var require_zipEntries = __commonJS((exports, module) => {
       if (this.centralDirRecords !== this.files.length) {
         if (this.centralDirRecords !== 0 && this.files.length === 0) {
           throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
-        } else {}
+        }
       }
     },
     readEndOfCentral: function() {
@@ -55347,7 +55347,7 @@ var require_loader = __commonJS((exports, module) => {
     var error2 = generateError(state, message);
     if (state.onWarning) {
       state.onWarning.call(null, error2);
-    } else {}
+    }
   }
   var directiveHandlers = {
     YAML: function handleYamlDirective(state, name, args) {
@@ -55885,7 +55885,7 @@ var require_loader = __commonJS((exports, module) => {
       } else if (detectedIndent) {
         sc.value += common3.repeat(`
 `, emptyLines + 1);
-      } else {}
+      }
       detectedIndent = true;
       emptyLines = 0;
       captureStart = state.position;
@@ -64370,12 +64370,16 @@ var init_path_assigner = __esm(() => {
 });
 
 // windmill-utils-internal/src/inline-scripts/extractor.ts
-function extractRawscriptInline(id, summary, rawscript, mapping, separator, assigner) {
+function extractRawscriptInline(id, summary, rawscript, mapping, separator, assigner, failOnInlineDirective) {
   const [basePath, ext2] = assigner.assignPath(summary ?? id, rawscript.language);
   const mappedPath = mapping[id];
   const path10 = mappedPath ?? basePath + ext2;
   const language = rawscript.language;
   const content = rawscript.content;
+  if (failOnInlineDirective && typeof content === "string" && content.startsWith("!inline ")) {
+    throw new Error(`Refusing to extract corrupted inline script for module '${id}': ` + `rawscript.content is the literal string \`${content.split(`
+`)[0]}\` ` + `instead of script source. The backend's flow_version.value is corrupt — ` + `re-push from a known-good local copy to repair it.`);
+  }
   const r = [{ path: path10, content, language, is_lock: false }];
   rawscript.content = "!inline " + path10.replaceAll(separator, "/");
   const lock = rawscript.lock;
@@ -64390,19 +64394,20 @@ function extractRawscriptInline(id, summary, rawscript, mapping, separator, assi
 }
 function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs, pathAssigner, options) {
   const assigner = pathAssigner ?? newPathAssigner(defaultTs ?? "bun", { skipInlineScriptSuffix: options?.skipInlineScriptSuffix });
+  const failOnInlineDirective = options?.failOnInlineDirective ?? false;
   return modules.flatMap((m) => {
     if (m.value.type == "rawscript") {
-      return extractRawscriptInline(m.id, m.summary, m.value, mapping, separator, assigner);
+      return extractRawscriptInline(m.id, m.summary, m.value, mapping, separator, assigner, failOnInlineDirective);
     } else if (m.value.type == "forloopflow") {
-      return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
+      return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner, options);
     } else if (m.value.type == "branchall") {
-      return m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner));
+      return m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner, options));
     } else if (m.value.type == "whileloopflow") {
-      return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
+      return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner, options);
     } else if (m.value.type == "branchone") {
       return [
-        ...m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner)),
-        ...extractInlineScripts(m.value.default, mapping, separator, defaultTs, assigner)
+        ...m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner, options)),
+        ...extractInlineScripts(m.value.default, mapping, separator, defaultTs, assigner, options)
       ];
     } else if (m.value.type == "aiagent") {
       return (m.value.tools ?? []).flatMap((tool) => {
@@ -64410,7 +64415,7 @@ function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs,
         if (!toolValue || toolValue.tool_type !== "flowmodule" || toolValue.type !== "rawscript") {
           return [];
         }
-        return extractRawscriptInline(tool.id, tool.summary, toolValue, mapping, separator, assigner);
+        return extractRawscriptInline(tool.id, tool.summary, toolValue, mapping, separator, assigner, failOnInlineDirective);
       });
     } else {
       return [];
@@ -64786,12 +64791,16 @@ async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpd
       const treePath = fileToTreePath.get(k) ?? folderNormalized + "/" + path10.basename(k, path10.extname(k));
       return tree.isStale(treePath);
     }) : changedScripts;
-    await replaceInlineScripts(flowValue.value.modules, fileReader, exports_log, folder + SEP7, SEP7, locksToRemove);
+    const missingFiles = [];
+    await replaceInlineScripts(flowValue.value.modules, fileReader, exports_log, folder + SEP7, SEP7, locksToRemove, missingFiles);
     if (flowValue.value.failure_module) {
-      await replaceInlineScripts([flowValue.value.failure_module], fileReader, exports_log, folder + SEP7, SEP7, locksToRemove);
+      await replaceInlineScripts([flowValue.value.failure_module], fileReader, exports_log, folder + SEP7, SEP7, locksToRemove, missingFiles);
     }
     if (flowValue.value.preprocessor_module) {
-      await replaceInlineScripts([flowValue.value.preprocessor_module], fileReader, exports_log, folder + SEP7, SEP7, locksToRemove);
+      await replaceInlineScripts([flowValue.value.preprocessor_module], fileReader, exports_log, folder + SEP7, SEP7, locksToRemove, missingFiles);
+    }
+    if (missingFiles.length > 0) {
+      throw new Error(`Cannot regenerate lock for flow ${remote_path}: missing inline script file(s): ${missingFiles.join(", ")}. ` + `Either restore the file(s) or remove the !inline reference(s) from flow.yaml before retrying.`);
     }
     const tempScriptRefs = tree?.getTempScriptRefs(folderNormalized);
     const savedNotes = flowValue.value.notes;
@@ -64804,12 +64813,13 @@ async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpd
     const lockAssigner = newPathAssigner(opts.defaultTs ?? "bun", {
       skipInlineScriptSuffix: getNonDottedPaths()
     });
-    const inlineScripts = extractInlineScripts(flowValue.value.modules, currentMapping, SEP7, opts.defaultTs, lockAssigner);
+    const extractOpts = { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true };
+    const inlineScripts = extractInlineScripts(flowValue.value.modules, currentMapping, SEP7, opts.defaultTs, lockAssigner, extractOpts);
     if (flowValue.value.failure_module) {
-      inlineScripts.push(...extractInlineScripts([flowValue.value.failure_module], currentMapping, SEP7, opts.defaultTs, lockAssigner));
+      inlineScripts.push(...extractInlineScripts([flowValue.value.failure_module], currentMapping, SEP7, opts.defaultTs, lockAssigner, extractOpts));
     }
     if (flowValue.value.preprocessor_module) {
-      inlineScripts.push(...extractInlineScripts([flowValue.value.preprocessor_module], currentMapping, SEP7, opts.defaultTs, lockAssigner));
+      inlineScripts.push(...extractInlineScripts([flowValue.value.preprocessor_module], currentMapping, SEP7, opts.defaultTs, lockAssigner, extractOpts));
     }
     inlineScripts.forEach((s) => {
       writeIfChanged(process.cwd() + SEP7 + folder + SEP7 + s.path, s.content);
@@ -65931,12 +65941,12 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             try {
               const assigner = newPathAssigner(defaultTs, { skipInlineScriptSuffix: getNonDottedPaths() });
               const inlineMapping = extractCurrentMapping(flow.value.modules, {}, flow.value.failure_module, flow.value.preprocessor_module);
-              inlineScripts = extractInlineScripts(flow.value.modules, inlineMapping, SEP9, defaultTs, assigner, { skipInlineScriptSuffix: getNonDottedPaths() });
+              inlineScripts = extractInlineScripts(flow.value.modules, inlineMapping, SEP9, defaultTs, assigner, { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true });
               if (flow.value.failure_module) {
-                inlineScripts.push(...extractInlineScripts([flow.value.failure_module], inlineMapping, SEP9, defaultTs, assigner, { skipInlineScriptSuffix: getNonDottedPaths() }));
+                inlineScripts.push(...extractInlineScripts([flow.value.failure_module], inlineMapping, SEP9, defaultTs, assigner, { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true }));
               }
               if (flow.value.preprocessor_module) {
-                inlineScripts.push(...extractInlineScripts([flow.value.preprocessor_module], inlineMapping, SEP9, defaultTs, assigner, { skipInlineScriptSuffix: getNonDottedPaths() }));
+                inlineScripts.push(...extractInlineScripts([flow.value.preprocessor_module], inlineMapping, SEP9, defaultTs, assigner, { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true }));
               }
             } catch (error2) {
               error(`Failed to extract inline scripts for flow at path: ${p}`);
@@ -75684,7 +75694,7 @@ async function pushFlow(workspace, remotePath, localPath, message, permissionedA
     await replaceInlineScripts([localFlow.value.preprocessor_module], fileReader, exports_log, localPath, SEP20, undefined, missingFiles);
   }
   if (missingFiles.length > 0) {
-    warn(colors.yellow(`Warning: missing inline script file(s): ${missingFiles.join(", ")}. ` + `The flow will be pushed with unresolved !inline references.`));
+    throw new Error(`Cannot push flow ${remotePath}: missing inline script file(s): ${missingFiles.join(", ")}. ` + `Either restore the file(s) or remove the !inline reference(s) from flow.yaml before pushing.`);
   }
   const hasOnBehalfOf = localFlow.has_on_behalf_of ?? !!localFlow.on_behalf_of_email;
   delete localFlow.has_on_behalf_of;
@@ -84945,9 +84955,9 @@ name: raw-app
 description: MUST use when creating raw apps.
 ---
 
-# Windmill Raw Apps
+# Windmill Raw Apps — CLI workflow
 
-Raw apps let you build custom frontends with React, Svelte, or Vue that connect to Windmill backend runnables and datatables.
+This guide covers raw apps from the terminal: scaffolding via \`wmill app new\`, the on-disk layout, and the file-based conventions the CLI uses to represent backend runnables and data table configuration. The platform shape (how a raw app behaves at runtime — frontend bundling, runnable types, datatable SDK calls) is covered in the companion authoring guide.
 
 ## Creating a Raw App
 
@@ -85016,7 +85026,7 @@ wmill app new
 
 This is the wizard. It only works when run by a human in a real terminal. Don't call it this way from an agent.
 
-## App Structure
+## On-disk app layout
 
 \`\`\`
 my_app{{RAW_APP_SUFFIX}}/
@@ -85036,11 +85046,7 @@ my_app{{RAW_APP_SUFFIX}}/
     └── *.sql              # SQL files to apply via dev server
 \`\`\`
 
-## Backend Runnables
-
-Backend runnables are server-side scripts that your frontend can call. They live in the \`backend/\` folder.
-
-### Creating a Backend Runnable
+## Backend runnables on disk
 
 Add a code file to the \`backend/\` folder:
 
@@ -85050,7 +85056,7 @@ backend/<id>.<ext>
 
 The runnable ID is the filename without extension. For example, \`get_user.ts\` creates a runnable with ID \`get_user\`.
 
-### Supported Languages
+### Supported languages (extension-driven)
 
 | Language         | Extension    | Example          |
 |------------------|--------------|------------------|
@@ -85072,27 +85078,14 @@ The runnable ID is the filename without extension. For example, \`get_user.ts\`
 | C#               | \`.cs\`        | \`myFunc.cs\`      |
 | Java             | \`.java\`      | \`myFunc.java\`    |
 
-### Example Backend Runnable
-
-**backend/get_user.ts:**
-\`\`\`typescript
-import * as wmill from 'windmill-client';
-
-export async function main(user_id: string) {
-  const sql = wmill.datatable();
-  const user = await sql\`SELECT * FROM users WHERE id = \${user_id}\`.fetchOne();
-  return user;
-}
-\`\`\`
-
-After creating, tell the user they can generate lock files by running:
+After creating a runnable, tell the user they can generate lock files by running:
 \`\`\`bash
 wmill generate-metadata
 \`\`\`
 
-### Optional YAML Configuration
+### Optional YAML configuration
 
-Add a \`<id>.yaml\` file to configure fields or static values:
+Add a \`<id>.yaml\` file alongside the code to configure fields or static values:
 
 **backend/get_user.yaml:**
 \`\`\`yaml
@@ -85103,7 +85096,7 @@ fields:
     value: "default_user"
 \`\`\`
 
-### Referencing Existing Scripts
+### Referencing existing scripts
 
 To use an existing Windmill script instead of inline code:
 
@@ -85119,32 +85112,9 @@ type: flow
 path: f/my_folder/my_flow
 \`\`\`
 
-### Calling Backend from Frontend
-
-Import from the auto-generated \`wmill.ts\`:
-
-\`\`\`typescript
-import { backend } from './wmill';
-
-// Call a backend runnable
-const user = await backend.get_user({ user_id: '123' });
-\`\`\`
-
-The \`wmill.ts\` file provides type-safe access to all backend runnables.
-
-## Data Tables
-
-Raw apps can query Windmill datatables (PostgreSQL databases managed by Windmill).
-
-### Critical Rules
+## Data tables — \`raw_app.yaml\` config
 
-1. **ONLY USE WHITELISTED TABLES**: You can ONLY query tables listed in \`raw_app.yaml\` → \`data.tables\`. Tables not in this list are NOT accessible.
-
-2. **ADD TABLES BEFORE USING**: To use a new table, first add it to \`data.tables\` in \`raw_app.yaml\`.
-
-3. **USE CONFIGURED DATATABLE/SCHEMA**: Check the app's \`raw_app.yaml\` for the default datatable and schema.
-
-### Configuration in raw_app.yaml
+The \`data\` block in \`raw_app.yaml\` controls which tables the app can query.
 
 \`\`\`yaml
 data:
@@ -85156,48 +85126,9 @@ data:
 \`\`\`
 
 **Table reference formats:**
-- \`<datatable>\` - All tables in the datatable
-- \`<datatable>/<table>\` - Specific table in public schema
-- \`<datatable>/<schema>:<table>\` - Table in specific schema
-
-### Querying in TypeScript (Bun/Deno)
-
-\`\`\`typescript
-import * as wmill from 'windmill-client';
-
-export async function main(user_id: string) {
-  const sql = wmill.datatable();  // Or: wmill.datatable('other_datatable')
-
-  // Parameterized queries (safe from SQL injection)
-  const user = await sql\`SELECT * FROM users WHERE id = \${user_id}\`.fetchOne();
-  const users = await sql\`SELECT * FROM users WHERE active = \${true}\`.fetch();
-
-  // Insert/Update
-  await sql\`INSERT INTO users (name, email) VALUES (\${name}, \${email})\`;
-  await sql\`UPDATE users SET name = \${newName} WHERE id = \${user_id}\`;
-
-  return user;
-}
-\`\`\`
-
-### Querying in Python
-
-\`\`\`python
-import wmill
-
-def main(user_id: str):
-    db = wmill.datatable()  # Or: wmill.datatable('other_datatable')
-
-    # Use $1, $2, etc. for parameters
-    user = db.query('SELECT * FROM users WHERE id = $1', user_id).fetch_one()
-    users = db.query('SELECT * FROM users WHERE active = $1', True).fetch()
-
-    # Insert/Update
-    db.query('INSERT INTO users (name, email) VALUES ($1, $2)', name, email)
-    db.query('UPDATE users SET name = $1 WHERE id = $2', new_name, user_id)
-
-    return user
-\`\`\`
+- \`<datatable>\` — All tables in the datatable
+- \`<datatable>/<table>\` — Specific table in public schema
+- \`<datatable>/<schema>:<table>\` — Table in specific schema
 
 ## SQL Migrations (sql_to_apply/)
 
@@ -85206,11 +85137,11 @@ The \`sql_to_apply/\` folder is for creating/modifying database tables during de
 ### Workflow
 
 1. Create \`.sql\` files in \`sql_to_apply/\`
-2. Run \`wmill app dev\` - the dev server watches this folder
+2. Run \`wmill app dev\` — the dev server watches this folder
 3. When SQL files change, a modal appears in the browser to confirm execution
 4. After creating tables, **add them to \`data.tables\`** in \`raw_app.yaml\`
 
-### Example Migration
+### Example migration
 
 **sql_to_apply/001_create_users.sql:**
 \`\`\`sql
@@ -85229,12 +85160,12 @@ data:
     - main/users
 \`\`\`
 
-### Migration Best Practices
+### Migration best practices
 
 - **Use idempotent SQL**: \`CREATE TABLE IF NOT EXISTS\`, etc.
 - **Number files**: \`001_\`, \`002_\` for ordering
 - **Always whitelist tables** after creation
-- This folder is NOT synced - it's for local development only
+- This folder is NOT synced — it's for local development only
 
 ## CLI Commands
 
@@ -85250,14 +85181,145 @@ For everything else, tell the user which command fits their intent and let them
 | \`wmill sync push\` | Deploy app to Windmill |
 | \`wmill sync pull\` | Pull latest from Windmill |
 
+
+
+# Windmill Raw Apps
+
+Raw apps let you build custom frontends with React, Svelte, or Vue that connect to Windmill backend runnables and datatables.
+
+## App shape
+
+A raw app has three logical parts:
+
+- **Frontend** — bundled with esbuild from \`index.tsx\` as the entrypoint. Files include the entrypoint, components (\`App.tsx\`), styles, etc.
+- **Backend runnables** — server-side scripts the frontend calls, each addressed by a unique key.
+- **Data** — optional whitelisted datatables (managed PostgreSQL) that the backend runnables can query. The frontend never queries the database directly; backend runnables are the only bridge.
+
+## Frontend
+
+### Entrypoint
+
+\`index.tsx\` is the bundling entrypoint. It typically renders a top-level \`App\` component. The bundler is esbuild.
+
+### Generated bindings (\`wmill.d.ts\` / \`wmill.ts\`)
+
+The frontend imports a generated module that mirrors the backend runnables. **Never write to it directly** — it gets regenerated whenever backend runnables change. Modifying it by hand will be overwritten.
+
+### Calling backend runnables
+
+Import the generated bindings and call the runnable like a function:
+
+\`\`\`typescript
+import { backend } from './wmill';
+
+// Call a backend runnable
+const user = await backend.get_user({ user_id: '123' });
+\`\`\`
+
+The frontend cannot reach datatables, workspace items, or external services on its own — it goes through \`backend.<key>(args)\` for everything server-side.
+
+## Backend runnables
+
+Each runnable has a unique key (used to call it from the frontend) and one of four types:
+
+| Type | What it is |
+|---|---|
+| \`inline\` | Custom code stored on the app itself. Most common for app-specific logic. |
+| \`script\` | Reference to an existing workspace script by path. |
+| \`flow\` | Reference to an existing workspace flow by path. |
+| \`hubscript\` | Reference to a hub script by path. |
+
+### Inline runnables
+
+Inline runnables carry their own source code. For file-based raw apps, the runnable language is determined by the backend file extension. The script must expose a \`main\` function as its entrypoint.
+
+**TypeScript example** (\`backend/get_user.ts\`):
+
+\`\`\`typescript
+import * as wmill from 'windmill-client';
+
+export async function main(user_id: string) {
+  const sql = wmill.datatable();
+  const user = await sql\`SELECT * FROM users WHERE id = \${user_id}\`.fetchOne();
+  return user;
+}
+\`\`\`
+
+**Python example** (\`backend/get_user.py\`):
+
+\`\`\`python
+import wmill
+
+def main(user_id: str):
+    db = wmill.datatable()
+    user = db.query('SELECT * FROM users WHERE id = $1', user_id).fetch_one()
+    return user
+\`\`\`
+
+### Path runnables (script / flow / hubscript)
+
+When \`type\` is \`script\`, \`flow\`, or \`hubscript\`, the runnable just stores a \`path\` to an existing workspace or hub item — no inline code. The referenced item's input/output schema becomes the runnable's surface.
+
+### Static inputs
+
+\`staticInputs\` is an optional \`Record<string, any>\` for arguments not overridable from the frontend. Useful with path runnables to pre-fill some args while leaving the rest to the frontend caller.
+
+## Data Tables
+
+Data tables are PostgreSQL databases managed by Windmill. Backend runnables query them via the \`wmill\` client; the frontend never queries them directly.
+
+### Critical rules
+
+1. **Whitelisted tables only**: a runnable can only query tables listed in the app's \`data.tables\` config. Tables not in this list are not accessible.
+2. **Add tables before using**: queries against unlisted tables fail at runtime. When you introduce a new table, register it in \`data.tables\` first.
+3. **Use the configured datatable/schema**: the app's \`data\` config sets the default datatable and schema; reference them consistently across runnables.
+
+### Querying in TypeScript (Bun/Deno)
+
+\`\`\`typescript
+import * as wmill from 'windmill-client';
+
+export async function main(user_id: string) {
+  const sql = wmill.datatable();  // Or: wmill.datatable('other_datatable')
+
+  // Parameterized queries (safe from SQL injection)
+  const user = await sql\`SELECT * FROM users WHERE id = \${user_id}\`.fetchOne();
+  const users = await sql\`SELECT * FROM users WHERE active = \${true}\`.fetch();
+
+  // Insert/Update
+  await sql\`INSERT INTO users (name, email) VALUES (\${name}, \${email})\`;
+  await sql\`UPDATE users SET name = \${newName} WHERE id = \${user_id}\`;
+
+  return user;
+}
+\`\`\`
+
+### Querying in Python
+
+\`\`\`python
+import wmill
+
+def main(user_id: str):
+    db = wmill.datatable()  # Or: wmill.datatable('other_datatable')
+
+    # Use $1, $2, etc. for parameters
+    user = db.query('SELECT * FROM users WHERE id = $1', user_id).fetch_one()
+    users = db.query('SELECT * FROM users WHERE active = $1', True).fetch()
+
+    # Insert/Update
+    db.query('INSERT INTO users (name, email) VALUES ($1, $2)', name, email)
+    db.query('UPDATE users SET name = $1 WHERE id = $2', new_name, user_id)
+
+    return user
+\`\`\`
+
 ## Best Practices
 
-1. **Check DATATABLES.md** for existing tables before creating new ones
-2. **Use parameterized queries** - never concatenate user input into SQL
-3. **Keep runnables focused** - one function per file
-4. **Use descriptive IDs** - \`get_user.ts\` not \`a.ts\`
-5. **Always whitelist tables** - add to \`data.tables\` before querying
-6. **Generate locks** - tell the user to run \`wmill generate-metadata\` after adding/modifying backend runnables
+1. **Check existing tables** before creating new ones — reuse beats schema growth.
+2. **Use parameterized queries** — never concatenate user input into SQL.
+3. **Keep runnables focused** — one function per runnable; small surface area.
+4. **Use descriptive keys** — \`get_user\`, not \`a\`.
+5. **Always whitelist tables** — adding a runnable that queries a new table requires the table to be in \`data.tables\` first.
 `,
   triggers: `---
 name: triggers
@@ -89624,7 +89686,7 @@ var config_default = command35;
 
 // src/main.ts
 await init_context();
-var VERSION = "1.700.1";
+var VERSION = "1.701.0";
 async function checkVersionSafe(cmd) {
   const mainCommand = cmd.getMainCommand();
   const upgradeCommand = mainCommand.getCommand("upgrade");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.700.1",
+  "version": "1.701.0",
   "description": "CLI for Windmill",
   "license": "Apache 2.0",
   "type": "module",