windmill-cli 1.518.1 → 1.518.3

package/esm/script.js

@@ -1,753 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import * as dntShim from "./_dnt.shims.js";
-import { requireLogin } from "./auth.js";
-import { resolveWorkspace, validatePath } from "./context.js";
-import { colors, Command, Confirm, log, readAll, SEP, Table, writeAllSync, yamlStringify, } from "./deps.js";
-import { deepEqual } from "./utils.js";
-import * as wmill from "./gen/services.gen.js";
-import { defaultScriptMetadata, scriptBootstrapCode, } from "./bootstrap/script_bootstrap.js";
-import { generateScriptMetadataInternal, parseMetadataFile, } from "./metadata.js";
-import { inferContentTypeFromFilePath, languagesWithRawReqsSupport, } from "./script_common.js";
-import { elementsToMap, findCodebase, readDirRecursiveWithIgnore, yamlOptions, } from "./sync.js";
-import { ignoreF } from "./sync.js";
-import { FSFSElement } from "./sync.js";
-import { mergeConfigWithConfigFile, readConfigFile, } from "./conf.js";
-import { listSyncCodebases } from "./codebase.js";
-import fs from "node:fs";
-import { execSync } from "node:child_process";
-async function push(opts, filePath) {
-    opts = await mergeConfigWithConfigFile(opts);
-    const workspace = await resolveWorkspace(opts);
-    if (!validatePath(filePath)) {
-        return;
-    }
-    const fstat = await dntShim.Deno.stat(filePath);
-    if (!fstat.isFile) {
-        throw new Error("file path must refer to a file.");
-    }
-    if (filePath.endsWith(".script.json") || filePath.endsWith(".script.yaml")) {
-        throw Error("Cannot push a script metadata file, point to the script content file instead (.py, .ts, .go|.sh)");
-    }
-    await requireLogin(opts);
-    const codebases = await listSyncCodebases(opts);
-    const globalDeps = await findGlobalDeps();
-    await handleFile(filePath, workspace, [], undefined, opts, globalDeps, codebases);
-    log.info(colors.bold.underline.green(`Script ${filePath} pushed`));
-}
-export async function findResourceFile(path) {
-    const splitPath = path.split(".");
-    const contentBasePathJSON = splitPath[0] + "." + splitPath[1] + ".json";
-    const contentBasePathYAML = splitPath[0] + "." + splitPath[1] + ".yaml";
-    const validCandidates = (await Promise.all([contentBasePathJSON, contentBasePathYAML].map((x) => {
-        return dntShim.Deno.stat(x)
-            .catch(() => undefined)
-            .then((x) => x?.isFile)
-            .then((e) => {
-            return { path: x, file: e };
-        });
-    })))
-        .filter((x) => x.file)
-        .map((x) => x.path);
-    if (validCandidates.length > 1) {
-        throw new Error("Found two resource files for the same resource" +
-            validCandidates.join(", "));
-    }
-    if (validCandidates.length < 1) {
-        throw new Error(`No resource matching file resource: ${path}.`);
-    }
-    return validCandidates[0];
-}
-export async function handleScriptMetadata(path, workspace, alreadySynced, message, globalDeps, codebases, opts) {
-    if (path.endsWith(".script.json") ||
-        path.endsWith(".script.yaml") ||
-        path.endsWith(".script.lock")) {
-        const contentPath = await findContentFile(path);
-        return handleFile(contentPath, workspace, alreadySynced, message, opts, globalDeps, codebases);
-    }
-    else {
-        return false;
-    }
-}
-export async function handleFile(path, workspace, alreadySynced, message, opts, globalDeps, codebases) {
-    if (!path.includes(".inline_script.") &&
-        exts.some((exts) => path.endsWith(exts))) {
-        if (alreadySynced.includes(path)) {
-            return true;
-        }
-        log.debug(`Processing local script ${path}`);
-        alreadySynced.push(path);
-        const remotePath = path
-            .substring(0, path.indexOf("."))
-            .replaceAll(SEP, "/");
-        const language = inferContentTypeFromFilePath(path, opts?.defaultTs);
-        const codebase = language == "bun" ? findCodebase(path, codebases) : undefined;
-        let bundleContent = undefined;
-        if (codebase) {
-            if (codebase.customBundler) {
-                log.info(`Using custom bundler ${codebase.customBundler} for ${path}`);
-                bundleContent = execSync(codebase.customBundler + " " + path).toString();
-                log.info("Custom bundler executed for " + path);
-            }
-            else {
-                const esbuild = await import("esbuild");
-                log.info(`Started bundling ${path} ...`);
-                const startTime = performance.now();
-                const out = await esbuild.build({
-                    entryPoints: [path],
-                    format: "cjs",
-                    bundle: true,
-                    write: false,
-                    external: codebase.external,
-                    inject: codebase.inject,
-                    define: codebase.define,
-                    platform: "node",
-                    packages: "bundle",
-                    target: "node20.15.1",
-                });
-                const endTime = performance.now();
-                bundleContent = out.outputFiles[0].text;
-                log.info(`Finished bundling ${path}: ${(bundleContent.length / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
-            }
-            if (Array.isArray(codebase.assets) && codebase.assets.length > 0) {
-                const archiveNpm = await import("@ayonli/jsext/archive");
-                log.info(`Using the following asset configuration for ${path}: ${JSON.stringify(codebase.assets)}`);
-                const startTime = performance.now();
-                const tarball = new archiveNpm.Tarball();
-                tarball.append(new File([bundleContent], "main.js", { type: "text/plain" }));
-                for (const asset of codebase.assets) {
-                    const data = fs.readFileSync(asset.from);
-                    const blob = new Blob([data], { type: "text/plain" });
-                    const file = new File([blob], asset.to);
-                    tarball.append(file);
-                }
-                const endTime = performance.now();
-                log.info(`Finished creating tarball for ${path}: ${(tarball.size / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
-                bundleContent = tarball;
-            }
-        }
-        let typed = opts?.skipScriptsMetadata
-            ? undefined
-            : (await parseMetadataFile(remotePath, opts
-                ? {
-                    ...opts,
-                    path,
-                    workspaceRemote: workspace,
-                    schemaOnly: codebase ? true : undefined,
-                }
-                : undefined, globalDeps, codebases))?.payload;
-        const workspaceId = workspace.workspaceId;
-        let remote = undefined;
-        try {
-            remote = await wmill.getScriptByPath({
-                workspace: workspaceId,
-                path: remotePath,
-            });
-            log.debug(`Script ${remotePath} exists on remote`);
-        }
-        catch {
-            log.debug(`Script ${remotePath} does not exist on remote`);
-        }
-        const content = await dntShim.Deno.readTextFile(path);
-        if (opts?.skipScriptsMetadata) {
-            // if (codebase) {
-            //   const typedBefore = JSON.parse(JSON.stringify(typed.schema));
-            //   await updateScriptSchema(content, language, typed, path);
-            //   if (typedBefore != typed.schema) {
-            //     log.info(`Updated metadata for bundle ${path}`);
-            //     showDiff(
-            //       yamlStringify(typedBefore, yamlOptions),
-            //       yamlStringify(typed.schema, yamlOptions)
-            //     );
-            //     await Deno.writeTextFile(
-            //       remotePath + ".script.yaml",
-            //       yamlStringify(typed as Record<string, any>, yamlOptions)
-            //     );
-            //   }
-            // }
-            // else {
-            typed = structuredClone(remote);
-            // }
-        }
-        if (typed && codebase) {
-            typed.codebase = await codebase.getDigest();
-        }
-        const requestBodyCommon = {
-            content,
-            description: typed?.description ?? "",
-            language: language,
-            path: remotePath.replaceAll(SEP, "/"),
-            summary: typed?.summary ?? "",
-            kind: typed?.kind,
-            lock: typed?.lock,
-            schema: typed?.schema,
-            tag: typed?.tag,
-            ws_error_handler_muted: typed?.ws_error_handler_muted,
-            dedicated_worker: typed?.dedicated_worker,
-            cache_ttl: typed?.cache_ttl,
-            concurrency_time_window_s: typed?.concurrency_time_window_s,
-            concurrent_limit: typed?.concurrent_limit,
-            deployment_message: message,
-            restart_unless_cancelled: typed?.restart_unless_cancelled,
-            visible_to_runner_only: typed?.visible_to_runner_only,
-            no_main_func: typed?.no_main_func,
-            has_preprocessor: typed?.has_preprocessor,
-            priority: typed?.priority,
-            concurrency_key: typed?.concurrency_key,
-            codebase: await codebase?.getDigest(),
-            timeout: typed?.timeout,
-            on_behalf_of_email: typed?.on_behalf_of_email,
-        };
-        // log.info(JSON.stringify(requestBodyCommon, null, 2))
-        // log.info(JSON.stringify(opts, null, 2))
-        if (remote) {
-            if (content === remote.content) {
-                if (typed == undefined ||
-                    (typed.description === remote.description &&
-                        typed.summary === remote.summary &&
-                        typed.kind == remote.kind &&
-                        !remote.archived &&
-                        (Array.isArray(remote?.lock)
-                            ? remote?.lock?.join("\n")
-                            : remote?.lock ?? "").trim() == (typed?.lock ?? "").trim() &&
-                        deepEqual(typed.schema, remote.schema) &&
-                        typed.tag == remote.tag &&
-                        (typed.ws_error_handler_muted ?? false) ==
-                            remote.ws_error_handler_muted &&
-                        typed.dedicated_worker == remote.dedicated_worker &&
-                        typed.cache_ttl == remote.cache_ttl &&
-                        typed.concurrency_time_window_s ==
-                            remote.concurrency_time_window_s &&
-                        typed.concurrent_limit == remote.concurrent_limit &&
-                        Boolean(typed.restart_unless_cancelled) ==
-                            Boolean(remote.restart_unless_cancelled) &&
-                        Boolean(typed.visible_to_runner_only) ==
-                            Boolean(remote.visible_to_runner_only) &&
-                        Boolean(typed.no_main_func) == Boolean(remote.no_main_func) &&
-                        Boolean(typed.has_preprocessor) ==
-                            Boolean(remote.has_preprocessor) &&
-                        typed.priority == Boolean(remote.priority) &&
-                        typed.timeout == remote.timeout &&
-                        //@ts-ignore
-                        typed.concurrency_key == remote["concurrency_key"] &&
-                        typed.codebase == remote.codebase &&
-                        typed.on_behalf_of_email == remote.on_behalf_of_email)) {
-                    log.info(colors.green(`Script ${remotePath} is up to date`));
-                    return true;
-                }
-            }
-            log.info(`Updating script ${remotePath} ...`);
-            const body = {
-                ...requestBodyCommon,
-                parent_hash: remote.hash,
-            };
-            const execTime = await createScript(bundleContent, workspaceId, body, workspace);
-            log.info(colors.yellow.bold(`Updated script ${remotePath} (${execTime.toFixed(0)}ms)`));
-        }
-        else {
-            log.info(`Creating new script ${remotePath} ...`);
-            const body = {
-                ...requestBodyCommon,
-                parent_hash: undefined,
-            };
-            const execTime = await createScript(bundleContent, workspaceId, body, workspace);
-            log.info(colors.yellow.bold(`Created new script ${remotePath} (${execTime.toFixed(0)}ms)`));
-        }
-        return true;
-    }
-    return false;
-}
-async function streamToBlob(stream) {
-    // Create a reader from the stream
-    const reader = stream.getReader();
-    const chunks = [];
-    // Read the data from the stream
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            // If stream is finished, break the loop
-            break;
-        }
-        // Push the chunk to the array
-        chunks.push(value);
-    }
-    // Create a Blob from the chunks
-    const blob = new Blob(chunks);
-    return blob;
-}
-async function createScript(bundleContent, workspaceId, body, workspace) {
-    const start = performance.now();
-    if (!bundleContent) {
-        try {
-            // no parent hash
-            await wmill.createScript({
-                workspace: workspaceId,
-                requestBody: body,
-            });
-        }
-        catch (e) {
-            throw Error(`Script creation for ${body.path} with parent ${body.parent_hash}  was not successful: ${e.body ?? e.message} `);
-        }
-    }
-    else {
-        const form = new FormData();
-        form.append("script", JSON.stringify(body));
-        form.append("file", typeof bundleContent == "string"
-            ? bundleContent
-            : await streamToBlob(bundleContent.stream()));
-        const url = workspace.remote +
-            "api/w/" +
-            workspace.workspaceId +
-            "/scripts/create_snapshot";
-        const req = await fetch(url, {
-            method: "POST",
-            headers: { Authorization: `Bearer ${workspace.token} ` },
-            body: form,
-        });
-        if (req.status != 201) {
-            throw Error(`Script snapshot creation was not successful: ${req.status} - ${req.statusText} - ${await req.text()} `);
-        }
-    }
-    return performance.now() - start;
-}
-export async function findContentFile(filePath) {
-    const candidates = filePath.endsWith("script.json")
-        ? exts.map((x) => filePath.replace(".script.json", x))
-        : filePath.endsWith("script.lock")
-            ? exts.map((x) => filePath.replace(".script.lock", x))
-            : exts.map((x) => filePath.replace(".script.yaml", x));
-    const validCandidates = (await Promise.all(candidates.map((x) => {
-        return dntShim.Deno.stat(x)
-            .catch(() => undefined)
-            .then((x) => x?.isFile)
-            .then((e) => {
-            return { path: x, file: e };
-        });
-    })))
-        .filter((x) => x.file)
-        .map((x) => x.path);
-    if (validCandidates.length > 1) {
-        throw new Error("No content path given and more than one candidate found: " +
-            validCandidates.join(", "));
-    }
-    if (validCandidates.length < 1) {
-        throw new Error(`No content path given and no content file found for ${filePath}.`);
-    }
-    return validCandidates[0];
-}
-export function filePathExtensionFromContentType(language, defaultTs) {
-    if (language === "python3") {
-        return ".py";
-    }
-    else if (language === "nativets") {
-        return ".fetch.ts";
-    }
-    else if (language === "bun") {
-        if (defaultTs == "deno") {
-            return ".bun.ts";
-        }
-        else {
-            return ".ts";
-        }
-    }
-    else if (language === "deno") {
-        if (defaultTs == undefined || defaultTs == "bun") {
-            return ".deno.ts";
-        }
-        else {
-            return ".ts";
-        }
-    }
-    else if (language === "go") {
-        return ".go";
-    }
-    else if (language === "mysql") {
-        return ".my.sql";
-    }
-    else if (language === "bigquery") {
-        return ".bq.sql";
-    }
-    else if (language === "duckdb") {
-        return ".duckdb.sql";
-    }
-    else if (language === "oracledb") {
-        return ".odb.sql";
-    }
-    else if (language === "snowflake") {
-        return ".sf.sql";
-    }
-    else if (language === "mssql") {
-        return ".ms.sql";
-    }
-    else if (language === "postgresql") {
-        return ".pg.sql";
-    }
-    else if (language === "graphql") {
-        return ".gql";
-    }
-    else if (language === "bash") {
-        return ".sh";
-    }
-    else if (language === "powershell") {
-        return ".ps1";
-    }
-    else if (language === "php") {
-        return ".php";
-    }
-    else if (language === "rust") {
-        return ".rs";
-    }
-    else if (language === "ansible") {
-        return ".playbook.yml";
-    }
-    else if (language === "csharp") {
-        return ".cs";
-    }
-    else if (language === "nu") {
-        return ".nu";
-    }
-    else if (language === "java") {
-        return ".java";
-        // for related places search: ADD_NEW_LANG
-    }
-    else {
-        throw new Error("Invalid language: " + language);
-    }
-}
-export const exts = [
-    ".fetch.ts",
-    ".deno.ts",
-    ".bun.ts",
-    ".ts",
-    ".py",
-    ".go",
-    ".sh",
-    ".pg.sql",
-    ".my.sql",
-    ".bq.sql",
-    ".odb.sql",
-    ".sf.sql",
-    ".ms.sql",
-    ".duckdb.sql",
-    ".sql",
-    ".gql",
-    ".ps1",
-    ".php",
-    ".rs",
-    ".cs",
-    ".nu",
-    ".playbook.yml",
-    ".java",
-    // for related places search: ADD_NEW_LANG
-];
-export function removeExtensionToPath(path) {
-    for (const ext of exts) {
-        if (path.endsWith(ext)) {
-            return path.substring(0, path.length - ext.length);
-        }
-    }
-    throw new Error("Invalid extension: " + path);
-}
-async function list(opts) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    let page = 0;
-    const perPage = 10;
-    const total = [];
-    while (true) {
-        const res = await wmill.listScripts({
-            workspace: workspace.workspaceId,
-            page,
-            perPage,
-            showArchived: opts.showArchived ?? false,
-            includeWithoutMain: opts.includeWithoutMain ?? false,
-            includeDraftOnly: opts.includeDraftOnly ?? true,
-        });
-        page += 1;
-        total.push(...res);
-        if (res.length < perPage) {
-            break;
-        }
-    }
-    new Table()
-        .header(["path", "summary", "language", "created by"])
-        .padding(2)
-        .border(true)
-        .body(total.map((x) => [x.path, x.summary, x.language, x.created_by]))
-        .render();
-}
-export async function resolve(input) {
-    if (!input) {
-        throw new Error("No data given");
-    }
-    if (input == "@-") {
-        input = new TextDecoder().decode(await readAll(dntShim.Deno.stdin));
-    }
-    if (input[0] == "@") {
-        input = await dntShim.Deno.readTextFile(input.substring(1));
-    }
-    try {
-        return JSON.parse(input);
-    }
-    catch (e) {
-        console.error("Impossible to parse input as JSON", input);
-        throw e;
-    }
-}
-async function run(opts, path) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    const input = opts.data ? await resolve(opts.data) : {};
-    const id = await wmill.runScriptByPath({
-        workspace: workspace.workspaceId,
-        path,
-        requestBody: input,
-    });
-    if (!opts.silent) {
-        await track_job(workspace.workspaceId, id);
-    }
-    while (true) {
-        try {
-            const result = (await wmill.getCompletedJob({
-                workspace: workspace.workspaceId,
-                id,
-            })).result ?? {};
-            if (opts.silent) {
-                console.log(result);
-            }
-            else {
-                log.info(result);
-            }
-            break;
-        }
-        catch {
-            new Promise((resolve, _) => setTimeout(() => resolve(undefined), 100));
-        }
-    }
-}
-export async function track_job(workspace, id) {
-    try {
-        const result = await wmill.getCompletedJob({ workspace, id });
-        log.info(result.logs);
-        log.info("\n");
-        log.info(colors.bold.underline.green("Job Completed"));
-        log.info("\n");
-        return;
-    }
-    catch {
-        /* ignore */
-    }
-    log.info(colors.yellow("Waiting for Job " + id + " to start..."));
-    let logOffset = 0;
-    let running = false;
-    let retry = 0;
-    while (true) {
-        let updates;
-        try {
-            updates = await wmill.getJobUpdates({
-                workspace,
-                id,
-                logOffset,
-                running,
-            });
-        }
-        catch {
-            retry++;
-            if (retry > 3) {
-                log.info("failed to get job updated. skipping log streaming.");
-                break;
-            }
-            continue;
-        }
-        if (!running && updates.running === true) {
-            running = true;
-            log.info(colors.green("Job running. Streaming logs..."));
-        }
-        if (updates.new_logs) {
-            writeAllSync(dntShim.Deno.stdout, new TextEncoder().encode(updates.new_logs));
-            logOffset += updates.new_logs.length;
-        }
-        if (updates.completed === true) {
-            running = false;
-            break;
-        }
-        if (running && updates.running === false) {
-            running = false;
-            log.info(colors.yellow("Job suspended. Waiting for it to continue..."));
-        }
-    }
-    await new Promise((resolve, _) => setTimeout(() => resolve(undefined), 1000));
-    try {
-        const final_job = await wmill.getCompletedJob({ workspace, id });
-        if ((final_job.logs?.length ?? -1) > logOffset) {
-            log.info(final_job.logs.substring(logOffset));
-        }
-        log.info("\n");
-        if (final_job.success) {
-            log.info(colors.bold.underline.green("Job Completed"));
-        }
-        else {
-            log.info(colors.bold.underline.red("Job Completed"));
-        }
-        log.info("\n");
-    }
-    catch {
-        log.info("Job appears to have completed, but no data can be retrieved");
-    }
-}
-async function show(opts, path) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    const s = await wmill.getScriptByPath({
-        workspace: workspace.workspaceId,
-        path,
-    });
-    log.info(colors.underline(s.path));
-    if (s.description)
-        log.info(s.description);
-    log.info("");
-    log.info(s.content);
-}
-async function bootstrap(opts, scriptPath, language) {
-    if (!validatePath(scriptPath)) {
-        return;
-    }
-    const scriptInitialCode = scriptBootstrapCode[language];
-    if (scriptInitialCode === undefined) {
-        throw new Error("Language unknown");
-    }
-    const config = await readConfigFile();
-    const extension = filePathExtensionFromContentType(language, config.defaultTs);
-    const scriptCodeFileFullPath = scriptPath + extension;
-    const scriptMetadataFileFullPath = scriptPath + ".script.yaml";
-    try {
-        await dntShim.Deno.stat(scriptCodeFileFullPath);
-        await dntShim.Deno.stat(scriptMetadataFileFullPath);
-        throw new Error("File already exists in repository");
-    }
-    catch {
-        // file does not exist, we can continue
-    }
-    const scriptMetadata = defaultScriptMetadata();
-    if (opts.summary !== undefined) {
-        scriptMetadata.summary = opts.summary;
-    }
-    if (opts.description !== undefined) {
-        scriptMetadata.description = opts.description;
-    }
-    const scriptInitialMetadataYaml = yamlStringify(scriptMetadata, yamlOptions);
-    await dntShim.Deno.writeTextFile(scriptCodeFileFullPath, scriptInitialCode, {
-        createNew: true,
-    });
-    await dntShim.Deno.writeTextFile(scriptMetadataFileFullPath, scriptInitialMetadataYaml, {
-        createNew: true,
-    });
-}
-export async function findGlobalDeps() {
-    var globalDeps = new Map();
-    const els = await FSFSElement(dntShim.Deno.cwd(), [], false);
-    for await (const entry of readDirRecursiveWithIgnore((p, isDir) => {
-        p = SEP + p;
-        return (!isDir &&
-            // Skip if the filename is not one of lockfile names
-            !(languagesWithRawReqsSupport.some(lockfile => p.endsWith(SEP + lockfile.rrFilename))));
-    }, els)) {
-        if (entry.isDirectory || entry.ignored)
-            continue;
-        const content = await entry.getContentText();
-        // Iterate over available languages to find which lockfile
-        languagesWithRawReqsSupport.map((lock) => {
-            if (entry.path.endsWith(lock.rrFilename)) {
-                const current = globalDeps.get(lock) ?? {};
-                current[entry.path.substring(0, entry.path.length - lock.rrFilename.length)] = content;
-                globalDeps.set(lock, current);
-            }
-        });
-    }
-    return globalDeps;
-}
-async function generateMetadata(opts, scriptPath) {
-    log.info("This command only works for workspace scripts, for flows inline scripts use `wmill flow generate - locks`");
-    if (scriptPath == "") {
-        scriptPath = undefined;
-    }
-    if (scriptPath && !validatePath(scriptPath)) {
-        return;
-    }
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    opts = await mergeConfigWithConfigFile(opts);
-    const codebases = await listSyncCodebases(opts);
-    const globalDeps = await findGlobalDeps();
-    if (scriptPath) {
-        // read script metadata file
-        await generateScriptMetadataInternal(scriptPath, workspace, opts, false, false, globalDeps, codebases, false);
-    }
-    else {
-        const ignore = await ignoreF(opts);
-        const elems = await elementsToMap(await FSFSElement(dntShim.Deno.cwd(), codebases, false), (p, isD) => {
-            return ((!isD && !exts.some((ext) => p.endsWith(ext))) ||
-                ignore(p, isD) ||
-                p.includes(".flow" + SEP) ||
-                p.includes(".app" + SEP));
-        }, false, {});
-        let hasAny = false;
-        log.info("Generating metadata for all stale scripts:");
-        for (const e of Object.keys(elems)) {
-            const candidate = await generateScriptMetadataInternal(e, workspace, opts, true, true, globalDeps, codebases, false);
-            if (candidate) {
-                hasAny = true;
-                log.info(colors.green(`+ ${candidate} `));
-            }
-        }
-        if (hasAny) {
-            if (opts.dryRun) {
-                log.info(colors.gray(`Dry run complete.`));
-                return;
-            }
-            if (!opts.yes &&
-                !(await Confirm.prompt({
-                    message: "Update the metadata of the above scripts?",
-                    default: true,
-                }))) {
-                return;
-            }
-        }
-        else {
-            log.info(colors.green.bold("No metadata to update"));
-            return;
-        }
-        for (const e of Object.keys(elems)) {
-            await generateScriptMetadataInternal(e, workspace, opts, false, true, globalDeps, codebases, false);
-        }
-    }
-}
-const command = new Command()
-    .description("script related commands")
-    .option("--show-archived", "Enable archived scripts in output")
-    .action(list)
-    .command("push", "push a local script spec. This overrides any remote versions. Use the script file (.ts, .js, .py, .sh)")
-    .arguments("<path:file>")
-    .action(push)
-    .command("show", "show a scripts content")
-    .arguments("<path:file>")
-    .action(show)
-    .command("run", "run a script by path")
-    .arguments("<path:file>")
-    .option("-d --data <data:file>", "Inputs specified as a JSON string or a file using @<filename> or stdin using @-.")
-    .option("-s --silent", "Do not output anything other then the final output. Useful for scripting.")
-    .action(run)
-    .command("bootstrap", "create a new script")
-    .arguments("<path:file> <language:string>")
-    .option("--summary <summary:string>", "script summary")
-    .option("--description <description:string>", "script description")
-    .action(bootstrap)
-    .command("generate-metadata", "re-generate the metadata file updating the lock and the script schema (for flows, use `wmill flow generate-locks`)")
-    .arguments("[script:file]")
-    .option("--yes", "Skip confirmation prompt")
-    .option("--dry-run", "Perform a dry run without making changes")
-    .option("--lock-only", "re-generate only the lock")
-    .option("--schema-only", "re-generate only script schema")
-    .option("-i --includes <patterns:file[]>", "Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)")
-    .option("-e --excludes <patterns:file[]>", "Comma separated patterns to specify which file to NOT take into account.")
-    .action(generateMetadata);
-export default command;