windmill-cli 1.641.0 → 1.643.0

package/esm/src/commands/app/raw_apps.js

@@ -1,385 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import * as dntShim from "../../../_dnt.shims.js";
-import { requireLogin } from "../../core/auth.js";
-import { resolveWorkspace, validatePath } from "../../core/context.js";
-import { colors, log, SEP, windmillUtils, yamlParseFile, yamlStringify, } from "../../../deps.js";
-import * as wmill from "../../../gen/services.gen.js";
-import path from "node:path";
-import { isSuperset } from "../../types.js";
-import { deepEqual } from "../../utils/utils.js";
-import { replaceInlineScripts, repopulateFields } from "./app.js";
-import { createBundle, detectFrameworks } from "./bundle.js";
-import { APP_BACKEND_FOLDER } from "./app_metadata.js";
-import { writeIfChanged } from "../../utils/utils.js";
-import { yamlOptions } from "../sync/sync.js";
-import { EXTENSION_TO_LANGUAGE, getLanguageFromExtension, } from "../../../windmill-utils-internal/src/path-utils/path-assigner.js";
-/**
- * Finds the content file for a runnable by looking for files matching the runnableId.
- * Returns the file extension and content, or undefined if not found.
- */
-async function findRunnableContentFile(backendPath, runnableId, allFiles) {
-    // Look for files matching pattern: {runnableId}.{ext}
-    // where ext is a known language extension
-    for (const fileName of allFiles) {
-        // Skip yaml and lock files
-        if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) {
-            continue;
-        }
-        // Check if file starts with runnableId followed by a dot
-        if (!fileName.startsWith(runnableId + ".")) {
-            continue;
-        }
-        // Extract extension (everything after the first dot following runnableId)
-        const ext = fileName.substring(runnableId.length + 1);
-        // Check if this is a recognized extension
-        if (EXTENSION_TO_LANGUAGE[ext]) {
-            try {
-                const content = await dntShim.Deno.readTextFile(path.join(backendPath, fileName));
-                return { ext, content };
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Extracts the runnable ID from a code file name.
- * Returns undefined if the file is not a recognized code file.
- *
- * Examples:
- * - "get_user.ts" -> "get_user"
- * - "fetch_data.bun.ts" -> "fetch_data"
- * - "query.pg.sql" -> "query"
- */
-function getRunnableIdFromCodeFile(fileName) {
-    // Skip yaml and lock files
-    if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) {
-        return undefined;
-    }
-    // Try to find a matching extension
-    for (const ext of Object.keys(EXTENSION_TO_LANGUAGE)) {
-        if (fileName.endsWith("." + ext)) {
-            return fileName.slice(0, -(ext.length + 1));
-        }
-    }
-    return undefined;
-}
-/**
- * Loads all runnables from the backend folder.
- *
- * Supports two modes:
- * 1. Explicit YAML config: `<id>.yaml` with type specification + optional `<id>.<ext>` code file
- * 2. Code-only (auto-detect): Just `<id>.<ext>` - assumes type: inline with empty fields
- *
- * Converts from file format to API format:
- * - For inline scripts (type: 'inline'): derives inlineScript from sibling files
- * - For path-based runnables (type: 'script'|'hubscript'|'flow'): converts to API format
- *   e.g., { type: "script" } -> { type: "path", runType: "script" }
- *
- * Returns an empty object if the backend folder doesn't exist.
- *
- * @param backendPath - Path to the backend folder
- * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
- */
-export async function loadRunnablesFromBackend(backendPath, defaultTs = "bun") {
-    const runnables = {};
-    try {
-        // First, collect all files in the backend folder
-        const allFiles = [];
-        for await (const entry of dntShim.Deno.readDir(backendPath)) {
-            if (entry.isFile) {
-                allFiles.push(entry.name);
-            }
-        }
-        // Track which runnable IDs have been processed (from YAML files)
-        const processedIds = new Set();
-        // Process YAML files first (explicit configuration)
-        for (const fileName of allFiles) {
-            if (!fileName.endsWith(".yaml")) {
-                continue;
-            }
-            const runnableId = fileName.replace(".yaml", "");
-            processedIds.add(runnableId);
-            const filePath = path.join(backendPath, fileName);
-            const runnable = (await yamlParseFile(filePath));
-            // If this is an inline script (type: 'inline'), derive inlineScript from files
-            if (runnable?.type === "inline") {
-                const contentFile = await findRunnableContentFile(backendPath, runnableId, allFiles);
-                if (contentFile) {
-                    const language = getLanguageFromExtension(contentFile.ext, defaultTs);
-                    // Try to load lock file
-                    let lock;
-                    try {
-                        lock = await dntShim.Deno.readTextFile(path.join(backendPath, `${runnableId}.lock`));
-                    }
-                    catch {
-                        // No lock file, that's fine
-                    }
-                    // Reconstruct inlineScript object
-                    runnable.inlineScript = {
-                        content: contentFile.content,
-                        language,
-                        ...(lock ? { lock } : {}),
-                    };
-                }
-            }
-            else if (runnable?.type === "script" ||
-                runnable?.type === "hubscript" ||
-                runnable?.type === "flow") {
-                // For path-based runnables, convert from file format to API format
-                // { type: "script" } -> { type: "path", runType: "script" }
-                // { type: "hubscript" } -> { type: "path", runType: "hubscript" }
-                // { type: "flow" } -> { type: "path", runType: "flow" }
-                const { type, schema: _schema, ...rest } = runnable;
-                runnable.type = "path";
-                runnable.runType = type;
-                // Remove schema if present
-                delete runnable.schema;
-                Object.assign(runnable, rest);
-            }
-            runnables[runnableId] = runnable;
-        }
-        // Auto-detect code files without YAML config (assume type: inline)
-        for (const fileName of allFiles) {
-            const runnableId = getRunnableIdFromCodeFile(fileName);
-            if (!runnableId) {
-                continue; // Not a recognized code file
-            }
-            if (processedIds.has(runnableId)) {
-                continue; // Already processed via YAML file
-            }
-            // Found a code file without corresponding YAML - treat as inline runnable
-            processedIds.add(runnableId);
-            const contentFile = await findRunnableContentFile(backendPath, runnableId, allFiles);
-            if (contentFile) {
-                const language = getLanguageFromExtension(contentFile.ext, defaultTs);
-                // Try to load lock file
-                let lock;
-                try {
-                    lock = await dntShim.Deno.readTextFile(path.join(backendPath, `${runnableId}.lock`));
-                }
-                catch {
-                    // No lock file, that's fine
-                }
-                // Create inline runnable with default empty fields
-                runnables[runnableId] = {
-                    type: "inline",
-                    inlineScript: {
-                        content: contentFile.content,
-                        language,
-                        ...(lock ? { lock } : {}),
-                    },
-                };
-            }
-        }
-    }
-    catch (error) {
-        if (error.name !== "NotFound") {
-            throw error;
-        }
-    }
-    return runnables;
-}
-/**
- * Writes a single runnable to its YAML file in the backend folder.
- * The file will be named `<runnableId>.yaml`.
- *
- * Converts from API format to file format:
- * - For inline scripts: keeps type: "inline"
- * - For path-based runnables: converts { type: "path", runType: "script" } to { type: "script" }
- *   and removes schema field
- */
-export function writeRunnableToBackend(backendPath, runnableId, runnable) {
-    let runnableToWrite = { ...runnable };
-    // Convert path-based runnables from API format to file format
-    if (runnable.type === "path" && runnable.runType) {
-        // { type: "path", runType: "script" } -> { type: "script" }
-        const { type: _type, runType, schema: _schema, ...rest } = runnable;
-        runnableToWrite = {
-            type: runType,
-            ...rest,
-        };
-    }
-    const filePath = path.join(backendPath, `${runnableId}.yaml`);
-    writeIfChanged(filePath, yamlStringify(runnableToWrite, yamlOptions));
-}
-const alreadySynced = [];
-async function collectAppFiles(localPath) {
-    const files = {};
-    async function readDirRecursive(dir, basePath = "/") {
-        for await (const entry of dntShim.Deno.readDir(dir)) {
-            const fullPath = dir + entry.name;
-            const relativePath = basePath + entry.name;
-            if (entry.isDirectory) {
-                // Skip the runnables, node_modules, and sql_to_apply subfolders
-                if (entry.name === APP_BACKEND_FOLDER ||
-                    entry.name === "node_modules" ||
-                    entry.name === "dist" ||
-                    entry.name === ".claude" ||
-                    entry.name === "sql_to_apply") {
-                    continue;
-                }
-                await readDirRecursive(fullPath + SEP, relativePath + "/");
-            }
-            else if (entry.isFile) {
-                // Skip generated/metadata files that shouldn't be part of the app
-                if (entry.name === "raw_app.yaml" ||
-                    entry.name === "package-lock.json" ||
-                    entry.name === "DATATABLES.md" ||
-                    entry.name === "AGENTS.md" ||
-                    entry.name === "wmill.d.ts") {
-                    continue;
-                }
-                const content = await dntShim.Deno.readTextFile(fullPath);
-                files[relativePath] = content;
-            }
-        }
-    }
-    await readDirRecursive(localPath);
-    return files;
-}
-export async function pushRawApp(workspace, remotePath, localPath, message) {
-    if (alreadySynced.includes(localPath)) {
-        return;
-    }
-    alreadySynced.push(localPath);
-    remotePath = remotePath.replaceAll(SEP, "/");
-    let app = undefined;
-    // deleting old app if it exists in raw mode
-    try {
-        app = await wmill.getAppByPath({
-            workspace,
-            path: remotePath,
-        });
-    }
-    catch {
-        //ignore
-    }
-    if (app?.["policy"]?.["execution_mode"] == "anonymous") {
-        app.public = true;
-    }
-    // console.log(app);
-    if (app) {
-        app.policy = undefined;
-    }
-    if (!localPath.endsWith(SEP)) {
-        localPath += SEP;
-    }
-    const appFilePath = localPath + "raw_app.yaml";
-    const localApp = (await yamlParseFile(appFilePath));
-    // Load runnables from separate YAML files in the backend folder
-    // Falls back to reading from raw_app.yaml if no separate files exist (backward compat)
-    const backendPath = path.join(localPath, APP_BACKEND_FOLDER);
-    const runnablesFromBackend = await loadRunnablesFromBackend(backendPath);
-    let runnables;
-    if (Object.keys(runnablesFromBackend).length > 0) {
-        // Use runnables from separate files (new format)
-        runnables = runnablesFromBackend;
-        log.info(colors.gray(`Loaded ${Object.keys(runnables).length} runnables from backend folder`));
-    }
-    else if (localApp.runnables) {
-        // Fall back to runnables from raw_app.yaml (old format)
-        runnables = localApp.runnables;
-        log.info(colors.gray(`Loaded ${Object.keys(runnables).length} runnables from raw_app.yaml (legacy format)`));
-    }
-    else {
-        runnables = {};
-    }
-    replaceInlineScripts(runnables, backendPath + SEP, true);
-    repopulateFields(runnables);
-    // Create a temporary app object for policy generation
-    const appForPolicy = { ...localApp, runnables };
-    await generatingPolicy(appForPolicy, remotePath, localApp?.["public"] ?? false);
-    const files = await collectAppFiles(localPath);
-    async function createBundleRaw() {
-        log.info(colors.yellow.bold(`Creating raw app ${remotePath} bundle...`));
-        // Detect frameworks to determine entry point
-        const frameworks = detectFrameworks(localPath);
-        const entryFile = frameworks.svelte || frameworks.vue
-            ? "index.ts"
-            : "index.tsx";
-        const entryPoint = localPath + entryFile;
-        return await createBundle({
-            entryPoint: entryPoint,
-            production: true,
-            minify: true,
-        });
-    }
-    // Build the value object, including data if present
-    const value = { runnables, files };
-    if (localApp.data) {
-        value.data = localApp.data;
-    }
-    if (app) {
-        // Check both metadata/runnables AND files for changes
-        // Files need separate comparison because isSuperset only checks if local keys exist in remote
-        const metadataUpToDate = isSuperset({ ...localApp, runnables }, app);
-        const filesUpToDate = deepEqual(files, app.value?.files);
-        if (metadataUpToDate && filesUpToDate) {
-            log.info(colors.green(`App ${remotePath} is up to date`));
-            return;
-        }
-        const { js, css } = await createBundleRaw();
-        log.info(colors.bold.yellow(`Updating app ${remotePath}...`));
-        await wmill.updateAppRaw({
-            workspace,
-            path: remotePath,
-            formData: {
-                app: {
-                    value,
-                    path: remotePath,
-                    summary: localApp.summary,
-                    policy: appForPolicy.policy,
-                    deployment_message: message,
-                    ...(localApp.custom_path
-                        ? { custom_path: localApp.custom_path }
-                        : {}),
-                },
-                js,
-                css,
-            },
-        });
-    }
-    else {
-        const { js, css } = await createBundleRaw();
-        await wmill.createAppRaw({
-            workspace,
-            formData: {
-                app: {
-                    value,
-                    path: remotePath,
-                    summary: localApp.summary,
-                    policy: appForPolicy.policy,
-                    deployment_message: message,
-                    ...(localApp.custom_path
-                        ? { custom_path: localApp.custom_path }
-                        : {}),
-                },
-                js,
-                css,
-            },
-        });
-    }
-}
-export async function generatingPolicy(app, path, publicApp) {
-    log.info(colors.gray(`Generating fresh policy for app ${path}...`));
-    try {
-        app.policy = await windmillUtils.updateRawAppPolicy(app.runnables, app.policy);
-        app.policy.execution_mode = publicApp ? "anonymous" : "publisher";
-    }
-    catch (e) {
-        log.error(colors.red(`Error generating policy for app ${path}: ${e}`));
-        throw e;
-    }
-}
-async function pushRawAppCommand(opts, filePath, remotePath) {
-    if (!validatePath(remotePath)) {
-        return;
-    }
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    await pushRawApp(workspace.workspaceId, remotePath, filePath);
-    log.info(colors.bold.underline.green("Raw app pushed"));
-}

package/esm/src/commands/app/wmillTsDev.js

@@ -1,128 +0,0 @@
-//comment this line and last to dev
-export function wmillTsDev(port) {
-    return `
-let reqs: Record<string, any> = {}
-let ws: WebSocket | null = null
-let wsReady: Promise<void>
-let wsReadyResolve: () => void
-
-function initWebSocket() {
-    wsReady = new Promise((resolve) => {
-        wsReadyResolve = resolve
-    })
-
-    ws = new WebSocket('ws://localhost:${port}')
-
-    ws.onopen = () => {
-        console.log('[wmill] WebSocket connected')
-        wsReadyResolve()
-    }
-
-    ws.onmessage = (event) => {
-        const data = JSON.parse(event.data)
-        if (data.type === 'streamJobUpdate') {
-            // Handle streaming update
-            const job = reqs[data.reqId]
-            if (job && job.onUpdate) {
-                job.onUpdate({
-                    new_result_stream: data.new_result_stream,
-                    stream_offset: data.stream_offset
-                })
-            }
-        } else if (data.type === 'streamJobRes') {
-            // Handle stream completion
-            const job = reqs[data.reqId]
-            if (job) {
-                if (data.error) {
-                    job.reject(new Error(data.result?.stack ?? data.result?.message ?? 'Stream error'))
-                } else {
-                    job.resolve(data.result)
-                }
-                delete reqs[data.reqId]
-            }
-        } else if (data.type === 'backendRes' || data.type === 'backendAsyncRes') {
-            console.log('Message from WebSocket backend', data)
-            const job = reqs[data.reqId]
-            if (job) {
-                const result = data.result
-                if (data.error) {
-                    job.reject(new Error(result.stack ?? result.message))
-                } else {
-                    job.resolve(result)
-                }
-                delete reqs[data.reqId]
-            } else {
-                console.error('No job found for', data.reqId)
-            }
-        }
-    }
-
-    ws.onerror = (error) => {
-        console.error('[wmill] WebSocket error:', error)
-    }
-
-    ws.onclose = () => {
-        console.log('[wmill] WebSocket closed, reconnecting...')
-        setTimeout(initWebSocket, 1000)
-    }
-}
-
-initWebSocket()
-
-async function doRequest(type: string, o: object) {
-    await wsReady
-    return new Promise((resolve, reject) => {
-        const reqId = Math.random().toString(36)
-        reqs[reqId] = { resolve, reject }
-        ws?.send(JSON.stringify({ ...o, type, reqId }))
-    })
-}
-
-export const backend = new Proxy(
-    {},
-    {
-        get(_, runnable_id: string) {
-            return (v: any) => {
-                return doRequest('backend', { runnable_id, v })
-            }
-        }
-    })
-
-export const backendAsync = new Proxy(
-    {},
-    {
-        get(_, runnable_id: string) {
-            return (v: any) => {
-                return doRequest('backendAsync', { runnable_id, v })
-            }
-        }
-    })
-
-export function waitJob(jobId: string) {
-    return doRequest('waitJob', { jobId })
-}
-
-export function getJob(jobId: string) {
-    return doRequest('getJob', { jobId })
-}
-
-/**
- * Stream job results using SSE. Calls onUpdate for each stream update,
- * and resolves with the final result when the job completes.
- * @param jobId - The job ID to stream
- * @param onUpdate - Callback for stream updates with new_result_stream data
- * @returns Promise that resolves with the final job result
- */
-export function streamJob(
-    jobId: string,
-    onUpdate?: (data: { new_result_stream?: string; stream_offset?: number }) => void
-): Promise<any> {
-    return new Promise(async (resolve, reject) => {
-        await wsReady
-        const reqId = Math.random().toString(36)
-        reqs[reqId] = { resolve, reject, onUpdate }
-        ws?.send(JSON.stringify({ jobId, type: 'streamJob', reqId }))
-    })
-}
-`;
-}

package/esm/src/commands/dependencies/dependencies.js

@@ -1,71 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import { requireLogin } from "../../core/auth.js";
-import { resolveWorkspace } from "../../core/context.js";
-import { colors, Command, log } from "../../../deps.js";
-import * as wmill from "../../../gen/services.gen.js";
-import fs from "node:fs";
-import { workspaceDependenciesPathToLanguageAndFilename } from "../../utils/metadata.js";
-async function push(opts, filePath) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    const content = fs.readFileSync(filePath, "utf8");
-    // Use the existing pushWorkspaceDependencies function
-    await pushWorkspaceDependencies(workspace.workspaceId, filePath, null, content);
-}
-const command = new Command()
-    .alias("deps")
-    .description("workspace dependencies related commands")
-    .command("push", "Push workspace dependencies from a local file")
-    .arguments("<file_path:string>")
-    .action(push);
-export async function pushWorkspaceDependencies(workspace, path, _befObj, newDependenciesContent) {
-    try {
-        const res = workspaceDependenciesPathToLanguageAndFilename(path);
-        if (!res) {
-            throw new Error(`Unknown workspace dependencies file format: ${path}`);
-        }
-        const { language, name } = res;
-        const displayName = name
-            ? `named dependencies "${name}"`
-            : `workspace default dependencies`;
-        // Fetch remote workspace dependencies and compare content directly
-        try {
-            const remoteDeps = await wmill.getLatestWorkspaceDependencies({
-                workspace,
-                language,
-                name,
-            });
-            if (remoteDeps && remoteDeps.content === newDependenciesContent) {
-                log.info(colors.green(`${displayName} for ${language} are up-to-date, skipping push`));
-                return;
-            }
-        }
-        catch (e) {
-            // If 404 or not found, the dependency doesn't exist remotely yet - proceed with push
-            if (e.status !== 404 && !e.message?.includes("not found")) {
-                throw e;
-            }
-        }
-        log.info(colors.yellow(`Pushing ${name ? "named" : "workspace default"} dependencies for ${language}...`));
-        await wmill.createWorkspaceDependencies({
-            workspace,
-            requestBody: {
-                name,
-                content: newDependenciesContent,
-                language,
-                workspace_id: workspace,
-                // Description is not supported in cli, it will use old description
-                description: undefined,
-            },
-        });
-        log.info(colors.green(`Successfully pushed ${displayName} for ${language}`));
-    }
-    catch (error) {
-        log.error(colors.red(`Failed to push workspace dependencies: ${error.message}`));
-        throw error;
-    }
-}
-export default command;