windmill-cli 1.686.0 → 1.688.0

package/esm/main.js

@@ -11812,7 +11812,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv2("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.686.0",
+    VERSION: "1.688.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -12335,6 +12335,7 @@ __export(exports_services_gen, {
   listGoogleDriveFiles: () => listGoogleDriveFiles,
   listGoogleCalendars: () => listGoogleCalendars,
   listGlobalSettings: () => listGlobalSettings,
+  listGithubRepos: () => listGithubRepos,
   listGitRepoFiles: () => listGitRepoFiles,
   listGcpTriggers: () => listGcpTriggers,
   listFolders: () => listFolders,
@@ -12379,6 +12380,7 @@ __export(exports_services_gen, {
   leaveInstance: () => leaveInstance,
   isValidPostgresConfiguration: () => isValidPostgresConfiguration,
   isSmtpConfigured: () => isSmtpConfigured,
+  isPasswordLoginDisabled: () => isPasswordLoginDisabled,
   isOwnerOfPath: () => isOwnerOfPath,
   isDomainAllowed: () => isDomainAllowed,
   isDefaultTagsPerWorkspace: () => isDefaultTagsPerWorkspace,
@@ -12867,6 +12869,11 @@ var backendVersion = () => {
     method: "GET",
     url: "/auth/is_smtp_configured"
   });
+}, isPasswordLoginDisabled = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/auth/is_password_login_disabled"
+  });
 }, requestPasswordReset = (data2) => {
   return request(OpenAPI, {
     method: "POST",
@@ -16738,7 +16745,8 @@ var backendVersion = () => {
       workspace: data2.workspace
     },
     query: {
-      force_cancel: data2.forceCancel
+      force_cancel: data2.forceCancel,
+      all_workspaces: data2.allWorkspaces
     },
     body: data2.requestBody,
     mediaType: "application/json"
@@ -18125,6 +18133,14 @@ var backendVersion = () => {
       workspace: data2.workspace
     }
   });
+}, listGithubRepos = (data2) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/w/{workspace}/native_triggers/github/repos",
+    path: {
+      workspace: data2.workspace
+    }
+  });
 }, nativeTriggerWebhook = (data2) => {
   return request(OpenAPI, {
     method: "POST",
@@ -67433,6 +67449,7 @@ var init_raw_apps = __esm(async () => {
 var exports_app_metadata = {};
 __export(exports_app_metadata, {
   inferRunnableSchemaFromFile: () => inferRunnableSchemaFromFile,
+  inferAllInlineSchemas: () => inferAllInlineSchemas,
   getAppFolders: () => getAppFolders,
   generateLocksCommand: () => generateLocksCommand,
   generateAppLocksInternal: () => generateAppLocksInternal,
@@ -67440,7 +67457,7 @@ __export(exports_app_metadata, {
   APP_BACKEND_FOLDER: () => APP_BACKEND_FOLDER
 });
 import path13 from "node:path";
-import { readFile as readFile11, mkdir as mkdir6 } from "node:fs/promises";
+import { readFile as readFile11, mkdir as mkdir6, readdir as readdir7 } from "node:fs/promises";
 import { sep as SEP11 } from "node:path";
 async function generateAppHash(rawReqs, folder, rawApp, defaultTs) {
   const runnablesFolder = rawApp ? path13.join(folder, APP_BACKEND_FOLDER) : folder;
@@ -67792,16 +67809,22 @@ ${text}`);
     throw new Error(`Failed to parse dependency response: ${rawResponse.statusText}, ${responseText}, ${e.message}`);
   }
 }
-async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
+async function inferRunnableSchemaFromFile(appFolder, runnableFilePath, defaultTs = "bun") {
   const fileName = path13.basename(runnableFilePath);
   if (fileName.endsWith(".lock") || fileName.endsWith(".yaml")) {
     return;
   }
-  const match2 = fileName.match(/^(.+)\.[^.]+$/);
-  if (!match2) {
+  let runnableId;
+  let ext2;
+  for (const knownExt of Object.keys(EXTENSION_TO_LANGUAGE)) {
+    if (fileName.endsWith("." + knownExt) && (!ext2 || knownExt.length > ext2.length)) {
+      ext2 = knownExt;
+      runnableId = fileName.slice(0, -(knownExt.length + 1));
+    }
+  }
+  if (!runnableId || !ext2) {
     return;
   }
-  const runnableId = match2[1];
   const runnableFilePath2 = path13.join(appFolder, APP_BACKEND_FOLDER, `${runnableId}.yaml`);
   let runnable;
   try {
@@ -67816,15 +67839,23 @@ async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
       }
       runnable = appFile.runnables[runnableId];
     } catch {
-      warn(colors.yellow(`Could not read runnable ${runnableId} from any source`));
-      return;
+      runnable = { type: "inline" };
     }
   }
-  if (!runnable?.inlineScript) {
+  let language;
+  let currentSchema;
+  if (runnable?.inlineScript) {
+    language = runnable.inlineScript.language;
+    currentSchema = runnable.inlineScript.schema;
+  } else if (runnable?.type === "inline" || runnable?.type === "runnableByName") {
+    language = getLanguageFromExtension(ext2, defaultTs);
+  } else {
+    return;
+  }
+  if (!language) {
+    warn(colors.yellow(`Could not determine language for ${runnableId} (ext: ${ext2})`));
     return;
   }
-  const inlineScript = runnable.inlineScript;
-  const language = inlineScript.language;
   const fullFilePath = path13.join(appFolder, APP_BACKEND_FOLDER, runnableFilePath);
   let content;
   try {
@@ -67833,7 +67864,6 @@ async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
     warn(colors.yellow(`Could not read file: ${fullFilePath}`));
     return;
   }
-  const currentSchema = inlineScript.schema;
   const remotePath = appFolder.replaceAll(SEP11, "/");
   try {
     const schemaResult = await inferSchema(language, content, currentSchema, `${remotePath}/${runnableId}`);
@@ -67847,6 +67877,28 @@ async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
     return;
   }
 }
+async function inferAllInlineSchemas(appFolder, defaultTs = "bun") {
+  const schemas = {};
+  const backendPath = path13.join(appFolder, APP_BACKEND_FOLDER);
+  let entries;
+  try {
+    entries = await readdir7(backendPath, { withFileTypes: true });
+  } catch {
+    return schemas;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile())
+      continue;
+    const fileName = entry.name;
+    if (fileName.endsWith(".yaml") || fileName.endsWith(".lock"))
+      continue;
+    const result = await inferRunnableSchemaFromFile(appFolder, fileName, defaultTs);
+    if (result) {
+      schemas[result.runnableId] = result.schema;
+    }
+  }
+  return schemas;
+}
 function getAppFolders(elems, extension) {
   return Object.keys(elems).filter((p) => p.endsWith(SEP11 + extension)).map((p) => p.substring(0, p.length - (SEP11 + extension).length));
 }
@@ -68181,7 +68233,19 @@ async function dev(opts, appFolder) {
   const appDir = path15.dirname(entryPoint) || process16.cwd();
   await ensureNodeModules(appDir);
   const inferredSchemas = {};
-  genRunnablesTs(inferredSchemas);
+  try {
+    Object.assign(inferredSchemas, await inferAllInlineSchemas(process16.cwd()));
+  } catch (err) {
+    warn(colors.yellow(`Could not seed inline schemas at startup: ${err.message}`));
+  }
+  const pathRunnableSchemas = {};
+  try {
+    const initialRunnables = await loadRunnablesFromBackend(path15.join(process16.cwd(), APP_BACKEND_FOLDER));
+    Object.assign(pathRunnableSchemas, await fetchPathRunnableSchemas(workspaceId, initialRunnables));
+  } catch (err) {
+    warn(colors.yellow(`Could not fetch schemas for path-based runnables: ${err.message}`));
+  }
+  await genRunnablesTs(inferredSchemas, pathRunnableSchemas);
   const distDir = path15.join(process16.cwd(), "dist");
   if (!fs10.existsSync(distDir)) {
     fs10.mkdirSync(distDir);
@@ -68275,7 +68339,7 @@ data: reload
           if (result) {
             inferredSchemas[result.runnableId] = result.schema;
             info(colors.green(`  Inferred Schemas: ${JSON.stringify(inferredSchemas, null, 2)}`));
-            await genRunnablesTs(inferredSchemas);
+            await genRunnablesTs(inferredSchemas, pathRunnableSchemas);
           }
         } catch (error2) {
           error(colors.red(`Error inferring schema: ${error2.message}`));
@@ -68709,7 +68773,7 @@ data: reload
     process16.exit(0);
   });
 }
-async function genRunnablesTs(schemaOverrides = {}) {
+async function genRunnablesTs(inlineSchemaOverrides = {}, pathSchemaOverrides = {}) {
   info(colors.blue("\uD83D\uDD04 Generating wmill.d.ts..."));
   const localPath = process16.cwd();
   const backendPath = path15.join(localPath, APP_BACKEND_FOLDER);
@@ -68722,21 +68786,65 @@ async function genRunnablesTs(schemaOverrides = {}) {
       runnables = {};
     }
   }
-  if (Object.keys(schemaOverrides).length > 0) {
-    for (const [runnableId, schema] of Object.entries(schemaOverrides)) {
-      if (runnables[runnableId]?.inlineScript) {
-        runnables[runnableId].inlineScript.schema = schema;
-        runnables[runnableId].type = "inline";
-      }
-    }
-  }
   try {
-    const newWmillTs = genWmillTs(runnables);
+    const newWmillTs = buildWmillTs(runnables, inlineSchemaOverrides, pathSchemaOverrides);
     writeFileSync5(path15.join(process16.cwd(), "wmill.d.ts"), newWmillTs);
   } catch (error2) {
     error(colors.red(`Failed to generate wmill.d.ts: ${error2.message}`));
   }
 }
+function buildWmillTs(runnables, inlineSchemaOverrides = {}, pathSchemaOverrides = {}) {
+  for (const [runnableId, schema] of Object.entries(inlineSchemaOverrides)) {
+    if (runnables[runnableId]?.inlineScript) {
+      runnables[runnableId].inlineScript.schema = schema;
+      runnables[runnableId].type = "inline";
+    }
+  }
+  for (const [runnableId, schema] of Object.entries(pathSchemaOverrides)) {
+    const runnable = runnables[runnableId];
+    if (runnable?.type === "path" && schema) {
+      runnable.schema = schema;
+    }
+  }
+  for (const runnable of Object.values(runnables)) {
+    if (runnable?.type === "path" && !runnable.schema) {
+      runnable.schema = {};
+    }
+  }
+  return genWmillTs(runnables);
+}
+async function fetchPathRunnableSchemas(workspaceId, runnables) {
+  const schemas = {};
+  for (const [runnableId, runnable] of Object.entries(runnables)) {
+    if (runnable?.type !== "path" || !runnable.path)
+      continue;
+    if (runnable.schema) {
+      schemas[runnableId] = runnable.schema;
+      continue;
+    }
+    try {
+      if (runnable.runType === "script") {
+        const script = await getScriptByPath({
+          workspace: workspaceId,
+          path: runnable.path
+        });
+        if (script.schema)
+          schemas[runnableId] = script.schema;
+      } else if (runnable.runType === "flow") {
+        const flow = await getFlowByPath({
+          workspace: workspaceId,
+          path: runnable.path
+        });
+        const flowSchema = flow?.value?.schema ?? flow?.schema;
+        if (flowSchema)
+          schemas[runnableId] = flowSchema;
+      }
+    } catch (err) {
+      warn(colors.yellow(`Failed to fetch schema for ${runnable.runType} ${runnable.path}: ${err.message}`));
+    }
+  }
+  return schemas;
+}
 function convertRunnablesToApiFormat(runnables) {
   for (const [runnableId, runnable] of Object.entries(runnables)) {
     if (runnable?.type === "script" || runnable?.type === "hubscript" || runnable?.type === "flow") {
@@ -70130,7 +70238,7 @@ var init_app = __esm(async () => {
 });
 
 // src/commands/folder/folder.ts
-import { stat as stat11, readdir as readdir7, writeFile as writeFile11, mkdir as mkdir8 } from "node:fs/promises";
+import { stat as stat11, readdir as readdir8, writeFile as writeFile11, mkdir as mkdir8 } from "node:fs/promises";
 import { sep as SEP14 } from "node:path";
 async function list7(opts) {
   if (opts.json)
@@ -70258,7 +70366,7 @@ async function addMissing(opts) {
     info("No 'f/' directory found. Nothing to do.");
     return;
   }
-  const entries = await readdir7(fDir, { withFileTypes: true });
+  const entries = await readdir8(fDir, { withFileTypes: true });
   const missing = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
@@ -71258,7 +71366,7 @@ var init_settings = __esm(async () => {
 });
 
 // src/commands/instance/instance.ts
-import { readFile as readFile13, writeFile as writeFile15, readdir as readdir8, mkdir as mkdir11, rm as rm3, stat as stat14 } from "node:fs/promises";
+import { readFile as readFile13, writeFile as writeFile15, readdir as readdir9, mkdir as mkdir11, rm as rm3, stat as stat14 } from "node:fs/promises";
 import { appendFile } from "node:fs/promises";
 import * as path18 from "node:path";
 async function allInstances() {
@@ -71673,7 +71781,7 @@ async function getLocalWorkspaces(rootDir, localPrefix, folderPerInstance) {
     await mkdir11(localPrefix);
   }
   if (folderPerInstance) {
-    const prefixEntries = await readdir8(rootDir + "/" + localPrefix, { withFileTypes: true });
+    const prefixEntries = await readdir9(rootDir + "/" + localPrefix, { withFileTypes: true });
     for (const dir of prefixEntries) {
       if (dir.isDirectory()) {
         const dirName = dir.name;
@@ -71684,7 +71792,7 @@ async function getLocalWorkspaces(rootDir, localPrefix, folderPerInstance) {
       }
     }
   } else {
-    const rootEntries = await readdir8(rootDir, { withFileTypes: true });
+    const rootEntries = await readdir9(rootDir, { withFileTypes: true });
     for (const dir of rootEntries) {
       const dirName = dir.name;
       if (dirName.startsWith(localPrefix + "_")) {
@@ -76682,7 +76790,7 @@ await __promiseAll([
 import { stat as stat18, writeFile as writeFile20, rm as rm4 } from "node:fs/promises";
 
 // src/guidance/writer.ts
-import { cp, mkdir as mkdir13, readdir as readdir9, readFile as readFile17, stat as stat17, writeFile as writeFile19 } from "node:fs/promises";
+import { cp, mkdir as mkdir13, readdir as readdir10, readFile as readFile17, stat as stat17, writeFile as writeFile19 } from "node:fs/promises";
 import { join as join17 } from "node:path";
 
 // src/guidance/core.ts
@@ -76725,6 +76833,19 @@ You MUST use the \`resources\` skill to manage resource types and credentials.
 
 You MUST use the \`cli-commands\` skill to use the CLI.
 
+## Debugging Jobs
+
+When the user reports a script or flow failure, is investigating unexpected output, or asks why something ran the way it did, use the CLI to fetch job details before speculating. See the \`cli-commands\` skill for all flags.
+
+- \`wmill job list --script-path <path>\` — recent runs of a specific script or flow
+- \`wmill job list --failed --limit 20\` — recent failures across the workspace
+- \`wmill job get <id>\` — status, timing, and (for flows) the step tree with sub-job IDs
+- \`wmill job logs <id>\` — stdout/stderr; for flows, aggregates every step's logs
+- \`wmill job result <id>\` — JSON result of a completed job
+- \`wmill job cancel <id>\` — stop a running or queued job
+
+For flow failures, start with \`wmill job get <id>\` to identify the failing step and its sub-job ID, then \`wmill job logs <sub-job-id>\` to drill in.
+
 ## Skills
 
 For specific guidance, ALWAYS use the skills listed below.
@@ -76760,7 +76881,7 @@ var SKILLS = [
   { name: "triggers", description: "MUST use when configuring triggers." },
   { name: "schedules", description: "MUST use when configuring schedules." },
   { name: "resources", description: "MUST use when managing resources." },
-  { name: "cli-commands", description: "MUST use when using the CLI." }
+  { name: "cli-commands", description: "MUST use when using the CLI, including debugging job failures and inspecting run history via `wmill job`." }
 ];
 var SKILL_CONTENT = {
   "write-script-bash": `---
@@ -81979,7 +82100,7 @@ wmill sync push
 `,
   "cli-commands": `---
 name: cli-commands
-description: MUST use when using the CLI.
+description: MUST use when using the CLI, including debugging job failures and inspecting run history via \`wmill job\`.
 ---
 
 # Windmill CLI Commands
@@ -83592,7 +83713,7 @@ async function ensureSkillsDirectory(targetDir) {
   return skillsDir;
 }
 async function copyDirectoryContents(sourceDir, targetDir) {
-  const entries = await readdir9(sourceDir, { withFileTypes: true });
+  const entries = await readdir10(sourceDir, { withFileTypes: true });
   await Promise.all(entries.map(async (entry) => {
     await cp(join17(sourceDir, entry.name), join17(targetDir, entry.name), {
       recursive: true,
@@ -83631,7 +83752,7 @@ ${schemaDocs.join(`
 `)}`;
 }
 async function readSkillMetadataFromDirectory(skillsDir) {
-  const entries = await readdir9(skillsDir, { withFileTypes: true });
+  const entries = await readdir10(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
     if (!entry.isDirectory()) {
@@ -85445,7 +85566,7 @@ var config_default = command35;
 
 // src/main.ts
 await init_context();
-var VERSION = "1.686.0";
+var VERSION = "1.688.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.686.0",
+  "version": "1.688.0",
   "description": "CLI for Windmill",
   "license": "Apache 2.0",
   "type": "module",