windmill-cli 1.615.2 → 1.616.0

package/esm/gen/core/OpenAPI.js

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

package/esm/gen/services.gen.js

@@ -9042,6 +9042,324 @@ export const testSqsConnection = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * list available native trigger services
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns WorkspaceIntegrations native trigger services list
+ * @throws ApiError
+ */
+export const listNativeTriggerServices = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/native_triggers/integrations/list',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
+/**
+ * check if integrations for a particular service exists
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @returns boolean integration exists
+ * @throws ApiError
+ */
+export const checkIfNativeTriggersServiceExists = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/native_triggers/integrations/{service_name}/exists',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        }
+    });
+};
+/**
+ * create native trigger service
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.requestBody new native trigger service
+ * @returns string native trigger service created
+ * @throws ApiError
+ */
+export const createNativeTriggerService = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/native_triggers/integrations/{service_name}/create',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * generate connect url for native trigger service
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.requestBody redirect_uri
+ * @returns string native trigger service connect url
+ * @throws ApiError
+ */
+export const generateNativeTriggerServiceConnectUrl = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/native_triggers/integrations/{service_name}/generate_connect_url',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * delete native trigger service
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @returns string native trigger service deleted
+ * @throws ApiError
+ */
+export const deleteNativeTriggerService = (data) => {
+    return __request(OpenAPI, {
+        method: 'DELETE',
+        url: '/w/{workspace}/native_triggers/integrations/{service_name}/delete',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        }
+    });
+};
+/**
+ * native trigger service oauth callback
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.code
+ * @param data.state
+ * @param data.requestBody redirect_uri
+ * @returns string native trigger service oauth completed
+ * @throws ApiError
+ */
+export const nativeTriggerServiceCallback = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/native_triggers/integrations/{service_name}/callback/{code}/{state}',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName,
+            code: data.code,
+            state: data.state
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * create native trigger
+ * Creates a new native trigger for the specified service.
+ * Requires write access to the script or flow that the trigger will be associated with.
+ *
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.requestBody new native trigger configuration
+ * @returns CreateTriggerResponse native trigger created
+ * @throws ApiError
+ */
+export const createNativeTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/native_triggers/{service_name}/create',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * update native trigger
+ * Updates an existing native trigger.
+ * Requires write access to the script or flow that the trigger is associated with.
+ *
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.externalId The external ID of the trigger from the external service
+ * @param data.requestBody updated native trigger configuration
+ * @returns string native trigger updated
+ * @throws ApiError
+ */
+export const updateNativeTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/native_triggers/{service_name}/update/{external_id}',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName,
+            external_id: data.externalId
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * get native trigger
+ * Retrieves a native trigger by its external ID.
+ * Requires write access to the script or flow that the trigger is associated with.
+ *
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.externalId The external ID of the trigger from the external service
+ * @returns NativeTriggerWithExternal native trigger with external configuration
+ * @throws ApiError
+ */
+export const getNativeTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/native_triggers/{service_name}/get/{external_id}',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName,
+            external_id: data.externalId
+        }
+    });
+};
+/**
+ * delete native trigger
+ * Deletes a native trigger by its external ID.
+ * Requires write access to the script or flow that the trigger is associated with.
+ *
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.externalId The external ID of the trigger from the external service
+ * @returns string native trigger deleted
+ * @throws ApiError
+ */
+export const deleteNativeTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'DELETE',
+        url: '/w/{workspace}/native_triggers/{service_name}/delete/{external_id}',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName,
+            external_id: data.externalId
+        }
+    });
+};
+/**
+ * list native triggers
+ * Lists all native triggers for the specified service in the workspace.
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.page which page to return (start at 1, default 1)
+ * @param data.perPage number of items to return for a given page (default 30, max 100)
+ * @returns NativeTrigger native triggers list
+ * @throws ApiError
+ */
+export const listNativeTriggers = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/native_triggers/{service_name}/list',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        },
+        query: {
+            page: data.page,
+            per_page: data.perPage
+        }
+    });
+};
+/**
+ * check if native trigger exists
+ * Checks if a native trigger with the given external ID exists.
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @param data.externalId The external ID of the trigger from the external service
+ * @returns boolean whether the native trigger exists
+ * @throws ApiError
+ */
+export const existsNativeTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/native_triggers/{service_name}/exists/{external_id}',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName,
+            external_id: data.externalId
+        }
+    });
+};
+/**
+ * sync native triggers with external service
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.serviceName
+ * @returns unknown sync completed successfully
+ * @throws ApiError
+ */
+export const syncNativeTriggers = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/native_triggers/{service_name}/sync',
+        path: {
+            workspace: data.workspace,
+            service_name: data.serviceName
+        }
+    });
+};
+/**
+ * list available NextCloud events
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns NextCloudEventType list of available NextCloud events
+ * @throws ApiError
+ */
+export const listNextCloudEvents = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/native_triggers/nextcloud/events',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
+/**
+ * receive webhook from external native trigger service
+ * @param data The data for the request.
+ * @param data.serviceName
+ * @param data.workspaceId
+ * @param data.internalId The internal database ID of the trigger
+ * @param data.requestBody webhook payload from external service
+ * @returns string webhook received successfully
+ * @throws ApiError
+ */
+export const nativeTriggerWebhook = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/native_triggers/{service_name}/w/{workspace_id}/webhook/{internal_id}',
+        path: {
+            service_name: data.serviceName,
+            workspace_id: data.workspaceId,
+            internal_id: data.internalId
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * create mqtt trigger
  * @param data The data for the request.

package/esm/src/commands/sync/sync.js

@@ -3,7 +3,7 @@ import { requireLogin } from "../../core/auth.js";
 import { resolveWorkspace } from "../../core/context.js";
 import { colors, Command, Confirm, ensureDir, log, minimatch, path, SEP, yamlParseContent, yamlStringify, } from "../../../deps.js";
 import * as wmill from "../../../gen/services.gen.js";
-import { getTypeStrFromPath, parseFromPath, pushObj, showConflict, showDiff, } from "../../types.js";
+import { getTypeStrFromPath, parseFromPath, pushObj, showConflict, showDiff, extractNativeTriggerInfo, } from "../../types.js";
 import { downloadZip } from "./pull.js";
 import { exts, findContentFile, findResourceFile, handleScriptMetadata, removeExtensionToPath, } from "../script/script.js";
 import { handleFile } from "../script/script.js";
@@ -1107,7 +1107,8 @@ export async function elementsToMap(els, ignore, json, skips, specificItems, bra
                 path.endsWith(".mqtt_trigger" + ext) ||
                 path.endsWith(".sqs_trigger" + ext) ||
                 path.endsWith(".gcp_trigger" + ext) ||
-                path.endsWith(".email_trigger" + ext))) {
+                path.endsWith(".email_trigger" + ext) ||
+                path.endsWith("_native_trigger" + ext))) {
             continue;
         }
         if (!skips.includeUsers && path.endsWith(".user" + ext))
@@ -1424,7 +1425,8 @@ function getOrderFromPath(p) {
         typ == "mqtt_trigger" ||
         typ == "sqs_trigger" ||
         typ == "gcp_trigger" ||
-        typ == "email_trigger") {
+        typ == "email_trigger" ||
+        typ == "native_trigger") {
         return 14;
     }
     else {
@@ -2293,6 +2295,18 @@ export async function push(opts) {
                                         path: removeSuffix(target, ".email_trigger.json"),
                                     });
                                     break;
+                                case "native_trigger": {
+                                    const triggerInfo = extractNativeTriggerInfo(change.path);
+                                    if (!triggerInfo) {
+                                        throw new Error(`Invalid native trigger path: ${change.path}`);
+                                    }
+                                    await wmill.deleteNativeTrigger({
+                                        workspace: workspaceId,
+                                        serviceName: triggerInfo.serviceName,
+                                        externalId: triggerInfo.externalId,
+                                    });
+                                    break;
+                                }
                                 case "variable":
                                     await wmill.deleteVariable({
                                         workspace: workspaceId,

package/esm/src/commands/trigger/trigger.js

@@ -1,7 +1,7 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import * as wmill from "../../../gen/services.gen.js";
 import { colors, Command, log, SEP, Table } from "../../../deps.js";
-import { isSuperset, parseFromFile, removeType, TRIGGER_TYPES, } from "../../types.js";
+import { isSuperset, parseFromFile, removeType, TRIGGER_TYPES, extractNativeTriggerInfo, } from "../../types.js";
 import { fromBranchSpecificPath, isBranchSpecificFile, } from "../../core/specific_items.js";
 import { getCurrentGitBranch } from "../../utils/git.js";
 import { requireLogin } from "../../core/auth.js";
@@ -94,6 +94,85 @@ export async function pushTrigger(triggerType, workspace, path, trigger, localTr
         }
     }
 }
+export async function pushNativeTrigger(workspace, filePath, _remoteTrigger, localTrigger) {
+    const triggerInfo = extractNativeTriggerInfo(filePath);
+    if (!triggerInfo) {
+        throw new Error(`Invalid native trigger file path: ${filePath}. Expected format: {script_path}.{flow|script}.{external_id}.{service}_native_trigger.json`);
+    }
+    const { externalId, serviceName } = triggerInfo;
+    log.debug(`Processing local native trigger: service=${serviceName}, external_id=${externalId}`);
+    let remoteTrigger;
+    try {
+        const result = await wmill.getNativeTrigger({
+            workspace,
+            serviceName: serviceName,
+            externalId,
+        });
+        // getNativeTrigger returns NativeTriggerWithExternal, extract NativeTrigger fields
+        remoteTrigger = {
+            external_id: result.external_id,
+            workspace_id: result.workspace_id,
+            service_name: result.service_name,
+            script_path: result.script_path,
+            is_flow: result.is_flow,
+            service_config: result.service_config,
+            error: result.error,
+        };
+        log.debug(`Native trigger ${serviceName}/${externalId} exists on remote`);
+    }
+    catch {
+        log.debug(`Native trigger ${serviceName}/${externalId} does not exist on remote`);
+    }
+    const triggerData = {
+        script_path: localTrigger.script_path,
+        is_flow: localTrigger.is_flow,
+        service_config: localTrigger.service_config,
+    };
+    if (remoteTrigger) {
+        // Compare relevant fields
+        const localCompare = {
+            script_path: localTrigger.script_path,
+            is_flow: localTrigger.is_flow,
+            service_config: localTrigger.service_config,
+        };
+        const remoteCompare = {
+            script_path: remoteTrigger.script_path,
+            is_flow: remoteTrigger.is_flow,
+            service_config: remoteTrigger.service_config,
+        };
+        if (isSuperset(localCompare, remoteCompare)) {
+            log.debug(`Native trigger ${serviceName}/${externalId} is up to date`);
+            return;
+        }
+        log.debug(`Native trigger ${serviceName}/${externalId} is not up-to-date, updating...`);
+        try {
+            await wmill.updateNativeTrigger({
+                workspace,
+                serviceName: serviceName,
+                externalId,
+                requestBody: triggerData,
+            });
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+    }
+    else {
+        console.log(colors.bold.yellow(`Creating new native trigger: ${serviceName}/${externalId}`));
+        try {
+            await wmill.createNativeTrigger({
+                workspace,
+                serviceName: serviceName,
+                requestBody: triggerData,
+            });
+        }
+        catch (e) {
+            console.error(e.body);
+            throw e;
+        }
+    }
+}
 async function list(opts) {
     const workspace = await resolveWorkspace(opts);
     await requireLogin(opts);

package/esm/src/main.js

@@ -40,7 +40,7 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.615.2";
+export const VERSION = "1.616.0";
 // Re-exported from constants.ts to maintain backwards compatibility
 export { WM_FORK_PREFIX } from "./core/constants.js";
 const command = new Command()

package/esm/src/types.js

@@ -15,7 +15,7 @@ import { pushWorkspaceUser } from "./commands/user/user.js";
 import { pushGroup } from "./commands/user/user.js";
 import { pushWorkspaceDependencies } from "./commands/dependencies/dependencies.js";
 import { pushWorkspaceSettings, pushWorkspaceKey } from "./core/settings.js";
-import { pushTrigger } from "./commands/trigger/trigger.js";
+import { pushTrigger, pushNativeTrigger } from "./commands/trigger/trigger.js";
 import { pushRawApp } from "./commands/app/raw_apps.js";
 import { isFlowPath, isAppPath, isRawAppPath, extractResourceName, buildFolderPath, } from "./utils/resource_folders.js";
 export const TRIGGER_TYPES = [
@@ -29,6 +29,7 @@ export const TRIGGER_TYPES = [
     "gcp",
     "email",
 ];
+export const NATIVE_TRIGGER_SERVICES = ["nextcloud"];
 export function isSuperset(subset, superset) {
     return Object.keys(subset).every((key) => {
         const eq = deepEqual(subset[key], superset[key]);
@@ -150,6 +151,9 @@ export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alread
     else if (typeEnding === "email_trigger") {
         await pushTrigger("email", workspace, p, befObj, newObj);
     }
+    else if (typeEnding === "native_trigger") {
+        await pushNativeTrigger(workspace, p, befObj, newObj);
+    }
     else if (typeEnding === "user") {
         await pushWorkspaceUser(workspace, p, befObj, newObj);
     }
@@ -234,6 +238,10 @@ export function getTypeStrFromPath(p) {
         return "encryption_key";
     }
     const typeEnding = parsed.name.split(".").at(-1);
+    // Check for native trigger: {service}_native_trigger pattern
+    if (typeEnding?.endsWith("_native_trigger")) {
+        return "native_trigger";
+    }
     if (typeEnding === "script" ||
         typeEnding === "variable" ||
         typeEnding === "resource" ||
@@ -271,6 +279,27 @@ export function removeType(str, type) {
     }
     return normalizedStr.slice(0, normalizedStr.length - type.length - 6);
 }
+/**
+ * Extracts native trigger info from a path like:
+ * u/admin/script.flow.12345.nextcloud_native_trigger.json
+ * Returns { scriptPath: "u/admin/script", isFlow: true, externalId: "12345", serviceName: "nextcloud" }
+ */
+export function extractNativeTriggerInfo(p) {
+    // Remove extension (.json or .yaml)
+    const normalizedPath = path.normalize(p).replaceAll(SEP, "/");
+    const withoutExt = normalizedPath.replace(/\.(json|yaml)$/, "");
+    // Match pattern: {script_path}.{flow|script}.{external_id}.{service}_native_trigger
+    const match = withoutExt.match(/^(.+)\.(flow|script)\.([^.]+)\.(\w+)_native_trigger$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        scriptPath: match[1],
+        isFlow: match[2] === "flow",
+        externalId: match[3],
+        serviceName: match[4],
+    };
+}
 export function removePathPrefix(str, prefix) {
     // Normalize paths for cross-platform compatibility and convert to forward slashes for API consistency
     const normalizedStr = path.normalize(str).replaceAll(SEP, "/");

package/package.json

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