Script 'Sync script to Git repo' for windmill

Sync script to Git repo

Verified

This script will pull the script from the current workspace in a temporary folder, then commit it to the remote Git repository and push it. Only the script-related file will be pushed, nothing else. It takes as input the git_repository resource containing the repository URL, the script path, and the commit message to use for the commit. All params are mandatory.

Created by hugo697 356 days ago Viewed 26537 times

Submitted by rubenfiszel Bun

Verified 73 days ago

All edits

Permalink

import * as wmillclient from "windmill-client";
import wmill from "windmill-cli";
import { basename } from "node:path"
const util = require('util');
const exec = util.promisify(require('child_process').exec);
import process from "process";

export async function main(
  workspace_id: string,
  repo_url_resource_path: string,
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  skip_secret = true,
  path: string | undefined,
  parent_path: string | undefined,
  commit_msg: string,
  use_individual_branch = false,
  group_by_folder = false
) {
  const repo_resource = await wmillclient.getResource(repo_url_resource_path);
  const cwd = process.cwd();
  process.env["HOME"] = "."
  console.log(
    `Syncing ${path_type} ${path ?? ""} with parent ${parent_path ?? ""}`
  );
  const repo_name = await git_clone(cwd, repo_resource, use_individual_branch);
  await move_to_git_branch(
    workspace_id,
    path_type,
    path,
    parent_path,
    use_individual_branch,
    group_by_folder
  );
  const subfolder = repo_resource.folder ?? "";
  const branch_or_default = repo_resource.branch ?? "<DEFAULT>";
  console.log(
    `Pushing to repository ${repo_name} in subfolder ${subfolder} on branch ${branch_or_default}`
  );
  await wmill_sync_pull(
    path_type,
    workspace_id,
    path,
    parent_path,
    skip_secret
  );
  await git_push(path, parent_path, commit_msg);
  console.log("Finished syncing");
  process.chdir(`${cwd}`);
}
async function git_clone(
  cwd: string,
  repo_resource: any,
  use_individual_branch: boolean
): Promise<string> {
  // TODO: handle private SSH keys as well
  let repo_url = repo_resource.url;
  const subfolder = repo_resource.folder ?? "";
  const branch = repo_resource.branch ?? "";
  const repo_name = basename(repo_url, ".git");
  const azureMatch = repo_url.match(/AZURE_DEVOPS_TOKEN\((?<url>.+)\)/);
  if (azureMatch) {
    console.log(
      "Requires Azure DevOps service account access token, requesting..."
    );
    const azureResource = await wmillclient.getResource(azureMatch.groups.url);
    const response = await fetch(
      `https://login.microsoftonline.com/${azureResource.azureTenantId}/oauth2/token`,
      {
        method: "POST",
        body: new URLSearchParams({
          client_id: azureResource.azureClientId,
          client_secret: azureResource.azureClientSecret,
          grant_type: "client_credentials",
          resource: "499b84ac-1321-427f-aa17-267ca6975798/.default",
        }),
      }
    );
    const { access_token } = await response.json();
    repo_url = repo_url.replace(azureMatch[0], access_token);
  }
  const args = ["clone", "--quiet", "--depth", "1"];
  if (use_individual_branch) {
    args.push("--no-single-branch"); // needed in case the asset branch already exists in the repo
  }
  if (subfolder !== "") {
    args.push("--sparse");
  }
  if (branch !== "") {
    args.push("--branch");
    args.push(branch);
  }
  args.push(repo_url);
  args.push(repo_name);
  await sh_run(-1, "git", ...args);
  try {
    process.chdir(`${cwd}/${repo_name}`);
  } catch (err) {
    console.log(
      `Error changing directory to '${cwd}/${repo_name}'. Error was:\n${err}`
    );
    throw err;
  }
  process.chdir(`${cwd}/${repo_name}`);
  if (subfolder !== "") {
    await sh_run(undefined, "git", "sparse-checkout", "add", subfolder);
  }
  try {
    process.chdir(`${cwd}/${repo_name}/${subfolder}`);
  } catch (err) {
    console.log(
      `Error changing directory to '${cwd}/${repo_name}/${subfolder}'. Error was:\n${err}`
    );
    throw err;
  }
  return repo_name;
}
async function move_to_git_branch(
  workspace_id: string,
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  path: string | undefined,
  parent_path: string | undefined,
  use_individual_branch: boolean,
  group_by_folder: boolean
) {
  if (!use_individual_branch || path_type === "user" || path_type === "group") {
    return;
  }
  const branchName = group_by_folder
    ? `wm_deploy/${workspace_id}/${(path ?? parent_path)
      ?.split("/")
      .slice(0, 2)
      .join("__")}`
    : `wm_deploy/${workspace_id}/${path_type}/${(
      path ?? parent_path
    )?.replaceAll("/", "__")}`;
  try {
    await sh_run(undefined, "git", "checkout", branchName);
  } catch (err) {
    console.log(
      `Error checking out branch ${branchName}. It is possible it doesn't exist yet, tentatively creating it... Error was:\n${err}`
    );
    try {
      await sh_run(undefined, "git", "checkout", "-b", branchName);
      await sh_run(
        undefined,
        "git",
        "config",
        "--add",
        "--bool",
        "push.autoSetupRemote",
        "true"
      );
    } catch (err) {
      console.log(
        `Error checking out branch '${branchName}'. Error was:\n${err}`
      );
      throw err;
    }
  }
  console.log(`Successfully switched to branch ${branchName}`);
}
async function git_push(
  path: string | undefined,
  parent_path: string | undefined,
  commit_msg: string
) {
  await sh_run(
    undefined,
    "git",
    "config",
    "user.email",
    process.env["WM_EMAIL"] ?? ""
  );
  await sh_run(
    undefined,
    "git",
    "config",
    "user.name",
    process.env["WM_USERNAME"] ?? ""
  );
  if (path !== undefined && path !== null && path !== "") {
    try {
      await sh_run(undefined, "git", "add", `${path}**`);
    } catch (e) {
      console.log(`Unable to stage files matching ${path}**, ${e}`);
    }
  }
  if (parent_path !== undefined && parent_path !== null && parent_path !== "") {
    try {
      await sh_run(undefined, "git", "add", `${parent_path}**`);
    } catch (e) {
      console.log(`Unable to stage files matching ${parent_path}, ${e}`);
    }
  }
  try {
    await sh_run(undefined, "git", "diff", "--cached", "--quiet");
  } catch {
    // git diff returns exit-code = 1 when there's at least one staged changes
    await sh_run(undefined, "git", "commit", "-m", `"${commit_msg == undefined || commit_msg == "" ? "no commit msg" : commit_msg}"`);
    try {
      await sh_run(undefined, "git", "push", "--porcelain");
    } catch {
      console.log("Could not push, trying to rebase first");
      await sh_run(undefined, "git", "pull", "--rebase");
      await sh_run(undefined, "git", "push", "--porcelain");
    }
    return;
  }
  console.log("No changes detected, nothing to commit. Returning...");
}
async function sh_run(
  secret_position: number | undefined,
  cmd: string,
  ...args: string[]
) {
  const nargs = secret_position != undefined ? args.slice() : args;
  if (secret_position && secret_position < 0) {
    secret_position = nargs.length - 1 + secret_position;
  }
  if (secret_position != undefined) {
    nargs[secret_position] = "***";
  }
  
  console.log(`Running '${cmd} ${nargs.join(" ")} ...'`);
  const command = exec(`${cmd} ${args.join(" ")}`)
  // new Deno.Command(cmd, {
  //   args: args,
  // });
  const { error, stdout, stderr } = await command
  if (stdout.length > 0) {
    console.log(stdout);
  }
  if (stderr.length > 0) {
    console.log(stderr);
  }
  if (error) {
    const err = `SH command '${cmd} ${nargs.join(
      " "
    )}' returned with error ${error}`;
    throw Error(err);
  }
  console.log("Command successfully executed");
}

function regexFromPath(
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  path: string
) {
  if (path_type == "flow") {
    return `${path}.flow/*`;
  } if (path_type == "app") {
    return `${path}.app/*`;
  } else if (path_type == "folder") {
    return `${path}/folder.meta.*`;
  } else if (path_type == "resourcetype") {
    return `${path}.resource-type.*`;
  } else if (path_type == "resource") {
    return `${path}.resource.*`;
  } else if (path_type == "variable") {
    return `${path}.variable.*`;
  } else if (path_type == "schedule") {
    return `${path}.schedule.*`;
  } else if (path_type == "user") {
    return `${path}.user.*`;
  } else if (path_type == "group") {
    return `${path}.group.*`;
  } else {
    return `${path}.*`;
  }
}
async function wmill_sync_pull(
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  workspace_id: string,
  path: string | undefined,
  parent_path: string | undefined,
  skip_secret: boolean
) {
  const includes = [];
  if (path !== undefined && path !== null && path !== "") {
    includes.push(regexFromPath(path_type, path));
  }
  if (parent_path !== undefined && parent_path !== null && parent_path !== "") {
    includes.push(regexFromPath(path_type, parent_path));
  }
  await wmill_run(
    6,
    "workspace",
    "add",
    workspace_id,
    workspace_id,
    process.env["BASE_URL"] + "/",
    "--token",
    process.env["WM_TOKEN"] ?? ""
  );
  console.log("Pulling workspace into git repo");
  await wmill_run(
    3,
    "sync",
    "pull",
    "--token",
    process.env["WM_TOKEN"] ?? "",
    "--workspace",
    workspace_id,
    "--yes",
    "--raw",
    skip_secret ? "--skip-secrets" : "",
    "--include-schedules",
    "--include-users",
    "--include-groups",
    "--extra-includes",
    includes.join(",")
  );
}

async function wmill_run(secret_position: number, ...cmd: string[]) {
  cmd = cmd.filter((elt) => elt !== "");
  const cmd2 = cmd.slice();
  cmd2[secret_position] = "***";
  console.log(`Running 'wmill ${cmd2.join(" ")} ...'`);
  await wmill.parse(cmd);
  console.log("Command successfully executed");
}

Other submissions

Submitted by hugo697 Deno

Created 356 days ago

All edits

Permalink

import * as wmillclient from "npm:windmill-client@1.333.4";
import wmill from "https://deno.land/x/wmill@v1.333.4/main.ts";
import { basename } from "https://deno.land/std@0.208.0/path/mod.ts";

export async function main(
  workspace_id: string,
  repo_url_resource_path: string,
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  skip_secret = true,
  path: string | undefined,
  parent_path: string | undefined,
  commit_msg: string,
  use_individual_branch = false,
  group_by_folder = false
) {
  const repo_resource = await wmillclient.getResource(repo_url_resource_path);

  const cwd = Deno.cwd();
  Deno.env.set("HOME", ".");
  console.log(
    `Syncing ${path_type} ${path ?? ""} with parent ${parent_path ?? ""}`
  );

  const repo_name = await git_clone(cwd, repo_resource, use_individual_branch);
  await move_to_git_branch(
    workspace_id,
    path_type,
    path,
    parent_path,
    use_individual_branch,
    group_by_folder
  );

  const subfolder = repo_resource.folder ?? "";
  const branch_or_default = repo_resource.branch ?? "<DEFAULT>";
  console.log(
    `Pushing to repository ${repo_name} in subfolder ${subfolder} on branch ${branch_or_default}`
  );

  await wmill_sync_pull(
    path_type,
    workspace_id,
    path,
    parent_path,
    skip_secret
  );

  await git_push(path, parent_path, commit_msg);

  console.log("Finished syncing");
  Deno.chdir(`${cwd}`);
}

async function git_clone(
  cwd: string,
  repo_resource: any,
  use_individual_branch: boolean
): Promise<string> {
  // TODO: handle private SSH keys as well
  let repo_url = repo_resource.url;
  const subfolder = repo_resource.folder ?? "";
  const branch = repo_resource.branch ?? "";
  const repo_name = basename(repo_url, ".git");

  const azureMatch = repo_url.match(/AZURE_DEVOPS_TOKEN\((?<url>.+)\)/);

  if (azureMatch) {
    console.log(
      "Requires Azure DevOps service account access token, requesting..."
    );
    const azureResource = await wmillclient.getResource(azureMatch.groups.url);

    const response = await fetch(
      `https://login.microsoftonline.com/${azureResource.azureTenantId}/oauth2/token`,
      {
        method: "POST",
        body: new URLSearchParams({
          client_id: azureResource.azureClientId,
          client_secret: azureResource.azureClientSecret,
          grant_type: "client_credentials",
          resource: "499b84ac-1321-427f-aa17-267ca6975798/.default",
        }),
      }
    );

    const { access_token } = await response.json();

    repo_url = repo_url.replace(azureMatch[0], access_token);
  }

  const args = ["clone", "--quiet", "--depth", "1"];
  if (use_individual_branch) {
    args.push("--no-single-branch"); // needed in case the asset branch already exists in the repo
  }
  if (subfolder !== "") {
    args.push("--sparse");
  }
  if (branch !== "") {
    args.push("--branch");
    args.push(branch);
  }
  args.push(repo_url);
  args.push(repo_name);
  await sh_run(-1, "git", ...args);

  try {
    Deno.chdir(`${cwd}/${repo_name}`);
  } catch (err) {
    console.log(
      `Error changing directory to '${cwd}/${repo_name}'. Error was:\n${err}`
    );
    throw err;
  }
  Deno.chdir(`${cwd}/${repo_name}`);
  if (subfolder !== "") {
    await sh_run(undefined, "git", "sparse-checkout", "add", subfolder);
  }
  try {
    Deno.chdir(`${cwd}/${repo_name}/${subfolder}`);
  } catch (err) {
    console.log(
      `Error changing directory to '${cwd}/${repo_name}/${subfolder}'. Error was:\n${err}`
    );
    throw err;
  }

  return repo_name;
}

async function move_to_git_branch(
  workspace_id: string,
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  path: string | undefined,
  parent_path: string | undefined,
  use_individual_branch: boolean,
  group_by_folder: boolean
) {
  if (!use_individual_branch || path_type === "user" || path_type === "group") {
    return;
  }

  const branchName = group_by_folder
    ? `wm_deploy/${workspace_id}/${(path ?? parent_path)
        ?.split("/")
        .slice(0, 2)
        .join("__")}`
    : `wm_deploy/${workspace_id}/${path_type}/${(
        path ?? parent_path
      )?.replaceAll("/", "__")}`;

  try {
    await sh_run(undefined, "git", "checkout", branchName);
  } catch (err) {
    console.log(
      `Error checking out branch ${branchName}. It is possible it doesn't exist yet, tentatively creating it... Error was:\n${err}`
    );
    try {
      await sh_run(undefined, "git", "checkout", "-b", branchName);
      await sh_run(
        undefined,
        "git",
        "config",
        "--add",
        "--bool",
        "push.autoSetupRemote",
        "true"
      );
    } catch (err) {
      console.log(
        `Error checking out branch '${branchName}'. Error was:\n${err}`
      );
      throw err;
    }
  }
  console.log(`Successfully switched to branch ${branchName}`);
}

async function git_push(
  path: string | undefined,
  parent_path: string | undefined,
  commit_msg: string
) {
  await sh_run(
    undefined,
    "git",
    "config",
    "user.email",
    Deno.env.get("WM_EMAIL") ?? ""
  );
  await sh_run(
    undefined,
    "git",
    "config",
    "user.name",
    Deno.env.get("WM_USERNAME") ?? ""
  );
  if (path !== undefined && path !== null && path !== "") {
    try {
      await sh_run(undefined, "git", "add", `${path}**`);
    } catch (e) {
      console.log(`Unable to stage files matching ${path}**, ${e}`);
    }
  }
  if (parent_path !== undefined && parent_path !== null && parent_path !== "") {
    try {
      await sh_run(undefined, "git", "add", `${parent_path}**`);
    } catch (e) {
      console.log(`Unable to stage files matching ${parent_path}, ${e}`);
    }
  }
  try {
    await sh_run(undefined, "git", "diff", "--cached", "--quiet");
  } catch {
    // git diff returns exit-code = 1 when there's at least one staged changes
    await sh_run(undefined, "git", "commit", "-m", commit_msg);
    try {
        await sh_run(undefined, "git", "push", "--porcelain");
    } catch {
        console.log("Could not push, trying to rebase first");
        await sh_run(undefined, "git", "pull", "--rebase");
        await sh_run(undefined, "git", "push", "--porcelain");
    }
    return;
  }
  console.log("No changes detected, nothing to commit. Returning...");
}

async function sh_run(
  secret_position: number | undefined,
  cmd: string,
  ...args: string[]
) {
  const nargs = secret_position != undefined ? args.slice() : args;
  if (secret_position < 0) {
    secret_position = nargs.length - 1 + secret_position;
  }
  if (secret_position != undefined) {
    nargs[secret_position] = "***";
  }
  console.log(`Running '${cmd} ${nargs.join(" ")} ...'`);
  const command = new Deno.Command(cmd, {
    args: args,
  });

  const { code, stdout, stderr } = await command.output();
  if (stdout.length > 0) {
    console.log(new TextDecoder().decode(stdout));
  }
  if (stderr.length > 0) {
    console.log(new TextDecoder().decode(stderr));
  }
  if (code !== 0) {
    const err = `SH command '${cmd} ${nargs.join(
      " "
    )}' returned with a non-zero status ${code}.`;
    throw Error(err);
  }
  console.log("Command successfully executed");
}

function regexFromPath(
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  path: string
) {
  if (path_type == "flow") {
    return `${path}.flow/*`;
  } if (path_type == "app") {
    return `${path}.app/*`;
  } else if (path_type == "folder") {
    return `${path}/folder.meta.*`;
  } else if (path_type == "resourcetype") {
    return `${path}.resource-type.*`;
  } else if (path_type == "resource") {
    return `${path}.resource.*`;
  } else if (path_type == "variable") {
    return `${path}.variable.*`;
  } else if (path_type == "schedule") {
    return `${path}.schedule.*`;
  } else if (path_type == "user") {
    return `${path}.user.*`;
  } else if (path_type == "group") {
    return `${path}.group.*`;
  } else {
    return `${path}.*`;
  }
}
async function wmill_sync_pull(
  path_type:
    | "script"
    | "flow"
    | "app"
    | "folder"
    | "resource"
    | "variable"
    | "resourcetype"
    | "schedule"
    | "user"
    | "group",
  workspace_id: string,
  path: string | undefined,
  parent_path: string | undefined,
  skip_secret: boolean
) {
  const includes = [];
  if (path !== undefined && path !== null && path !== "") {
    includes.push(regexFromPath(path_type, path));
  }
  if (parent_path !== undefined && parent_path !== null && parent_path !== "") {
    includes.push(regexFromPath(path_type, parent_path));
  }

  await wmill_run(
    6,
    "workspace",
    "add",
    workspace_id,
    workspace_id,
    Deno.env.get("BASE_INTERNAL_URL") + "/",
    "--token",
    Deno.env.get("WM_TOKEN") ?? ""
  );
  console.log("Pulling workspace into git repo");
  await wmill_run(
    3,
    "sync",
    "pull",
    "--token",
    Deno.env.get("WM_TOKEN") ?? "",
    "--workspace",
    workspace_id,
    "--yes",
    "--raw",
    skip_secret ? "--skip-secrets" : "",
    "--include-schedules",
    "--include-users",
    "--include-groups",
    "--includes",
    includes.join(",")
  );
}

async function wmill_run(secret_position: number, ...cmd: string[]) {
  cmd = cmd.filter((elt) => elt !== "");
  const cmd2 = cmd.slice();
  cmd2[secret_position] = "***";
  console.log(`Running 'wmill ${cmd2.join(" ")} ...'`);
  await wmill.parse(cmd);
  console.log("Command successfully executed");
}


`1`	`import * as wmillclient from "windmill-client";`
`2`	`import wmill from "windmill-cli";`
`3`	`import { basename } from "node:path"`
`4`	`const util = require('util');`
`5`	`const exec = util.promisify(require('child_process').exec);`
`6`	`import process from "process";`
`7`
`8`	`export async function main(`
`9`	`workspace_id: string,`
`10`	`repo_url_resource_path: string,`
`11`	`path_type:`
`12`	`\| "script"`
`13`	`\| "flow"`
`14`	`\| "app"`
`15`	`\| "folder"`
`16`	`\| "resource"`
`17`	`\| "variable"`
`18`	`\| "resourcetype"`
`19`	`\| "schedule"`
`20`	`\| "user"`
`21`	`\| "group",`
`22`	`skip_secret = true,`
`23`	`path: string \| undefined,`
`24`	`parent_path: string \| undefined,`
`25`	`commit_msg: string,`
`26`	`use_individual_branch = false,`
`27`	`group_by_folder = false`
`28`	`) {`
`29`	`const repo_resource = await wmillclient.getResource(repo_url_resource_path);`
`30`	`const cwd = process.cwd();`
`31`	`process.env["HOME"] = "."`
`32`	`console.log(`
`33`	`Syncing ${path_type} ${path ?? ""} with parent ${parent_path ?? ""}`
`34`	`);`
`35`	`const repo_name = await git_clone(cwd, repo_resource, use_individual_branch);`
`36`	`await move_to_git_branch(`
`37`	`workspace_id,`
`38`	`path_type,`
`39`	`path,`
`40`	`parent_path,`
`41`	`use_individual_branch,`
`42`	`group_by_folder`
`43`	`);`
`44`	`const subfolder = repo_resource.folder ?? "";`
`45`	`const branch_or_default = repo_resource.branch ?? "<DEFAULT>";`
`46`	`console.log(`
`47`	`Pushing to repository ${repo_name} in subfolder ${subfolder} on branch ${branch_or_default}`
`48`	`);`
`49`	`await wmill_sync_pull(`
`50`	`path_type,`
`51`	`workspace_id,`
`52`	`path,`
`53`	`parent_path,`
`54`	`skip_secret`
`55`	`);`
`56`	`await git_push(path, parent_path, commit_msg);`
`57`	`console.log("Finished syncing");`
`58`	process.chdir(`${cwd}`);
`59`	`}`
`60`	`async function git_clone(`
`61`	`cwd: string,`
`62`	`repo_resource: any,`
`63`	`use_individual_branch: boolean`
`64`	`): Promise<string> {`
`65`	`// TODO: handle private SSH keys as well`
`66`	`let repo_url = repo_resource.url;`
`67`	`const subfolder = repo_resource.folder ?? "";`
`68`	`const branch = repo_resource.branch ?? "";`
`69`	`const repo_name = basename(repo_url, ".git");`
`70`	`const azureMatch = repo_url.match(/AZURE_DEVOPS_TOKEN\((?<url>.+)\)/);`
`71`	`if (azureMatch) {`
`72`	`console.log(`
`73`	`"Requires Azure DevOps service account access token, requesting..."`
`74`	`);`
`75`	`const azureResource = await wmillclient.getResource(azureMatch.groups.url);`
`76`	`const response = await fetch(`
`77`	`https://login.microsoftonline.com/${azureResource.azureTenantId}/oauth2/token`,
`78`	`{`
`79`	`method: "POST",`
`80`	`body: new URLSearchParams({`
`81`	`client_id: azureResource.azureClientId,`
`82`	`client_secret: azureResource.azureClientSecret,`
`83`	`grant_type: "client_credentials",`
`84`	`resource: "499b84ac-1321-427f-aa17-267ca6975798/.default",`
`85`	`}),`
`86`	`}`
`87`	`);`
`88`	`const { access_token } = await response.json();`
`89`	`repo_url = repo_url.replace(azureMatch[0], access_token);`
`90`	`}`
`91`	`const args = ["clone", "--quiet", "--depth", "1"];`
`92`	`if (use_individual_branch) {`
`93`	`args.push("--no-single-branch"); // needed in case the asset branch already exists in the repo`
`94`	`}`
`95`	`if (subfolder !== "") {`
`96`	`args.push("--sparse");`
`97`	`}`
`98`	`if (branch !== "") {`
`99`	`args.push("--branch");`
`100`	`args.push(branch);`
`101`	`}`
`102`	`args.push(repo_url);`
`103`	`args.push(repo_name);`
`104`	`await sh_run(-1, "git", ...args);`
`105`	`try {`
`106`	process.chdir(`${cwd}/${repo_name}`);
`107`	`} catch (err) {`
`108`	`console.log(`
`109`	`Error changing directory to '${cwd}/${repo_name}'. Error was:\n${err}`
`110`	`);`
`111`	`throw err;`
`112`	`}`
`113`	process.chdir(`${cwd}/${repo_name}`);
`114`	`if (subfolder !== "") {`
`115`	`await sh_run(undefined, "git", "sparse-checkout", "add", subfolder);`
`116`	`}`
`117`	`try {`
`118`	process.chdir(`${cwd}/${repo_name}/${subfolder}`);
`119`	`} catch (err) {`
`120`	`console.log(`
`121`	`Error changing directory to '${cwd}/${repo_name}/${subfolder}'. Error was:\n${err}`
`122`	`);`
`123`	`throw err;`
`124`	`}`
`125`	`return repo_name;`
`126`	`}`
`127`	`async function move_to_git_branch(`
`128`	`workspace_id: string,`
`129`	`path_type:`
`130`	`\| "script"`
`131`	`\| "flow"`
`132`	`\| "app"`
`133`	`\| "folder"`
`134`	`\| "resource"`
`135`	`\| "variable"`
`136`	`\| "resourcetype"`
`137`	`\| "schedule"`
`138`	`\| "user"`
`139`	`\| "group",`
`140`	`path: string \| undefined,`
`141`	`parent_path: string \| undefined,`
`142`	`use_individual_branch: boolean,`
`143`	`group_by_folder: boolean`
`144`	`) {`
`145`	`if (!use_individual_branch \|\| path_type === "user" \|\| path_type === "group") {`
`146`	`return;`
`147`	`}`
`148`	`const branchName = group_by_folder`
`149`	? `wm_deploy/${workspace_id}/${(path ?? parent_path)
`150`	`?.split("/")`
`151`	`.slice(0, 2)`
`152`	.join("__")}`
`153`	: `wm_deploy/${workspace_id}/${path_type}/${(
`154`	`path ?? parent_path`
`155`	)?.replaceAll("/", "__")}`;
`156`	`try {`
`157`	`await sh_run(undefined, "git", "checkout", branchName);`
`158`	`} catch (err) {`
`159`	`console.log(`
`160`	`Error checking out branch ${branchName}. It is possible it doesn't exist yet, tentatively creating it... Error was:\n${err}`
`161`	`);`
`162`	`try {`
`163`	`await sh_run(undefined, "git", "checkout", "-b", branchName);`
`164`	`await sh_run(`
`165`	`undefined,`
`166`	`"git",`
`167`	`"config",`
`168`	`"--add",`
`169`	`"--bool",`
`170`	`"push.autoSetupRemote",`
`171`	`"true"`
`172`	`);`
`173`	`} catch (err) {`
`174`	`console.log(`
`175`	`Error checking out branch '${branchName}'. Error was:\n${err}`
`176`	`);`
`177`	`throw err;`
`178`	`}`
`179`	`}`
`180`	console.log(`Successfully switched to branch ${branchName}`);
`181`	`}`
`182`	`async function git_push(`
`183`	`path: string \| undefined,`
`184`	`parent_path: string \| undefined,`
`185`	`commit_msg: string`
`186`	`) {`
`187`	`await sh_run(`
`188`	`undefined,`
`189`	`"git",`
`190`	`"config",`
`191`	`"user.email",`
`192`	`process.env["WM_EMAIL"] ?? ""`
`193`	`);`
`194`	`await sh_run(`
`195`	`undefined,`
`196`	`"git",`
`197`	`"config",`
`198`	`"user.name",`
`199`	`process.env["WM_USERNAME"] ?? ""`
`200`	`);`
`201`	`if (path !== undefined && path !== null && path !== "") {`
`202`	`try {`
`203`	await sh_run(undefined, "git", "add", `${path}**`);
`204`	`} catch (e) {`
`205`	console.log(`Unable to stage files matching ${path}**, ${e}`);
`206`	`}`
`207`	`}`
`208`	`if (parent_path !== undefined && parent_path !== null && parent_path !== "") {`
`209`	`try {`
`210`	await sh_run(undefined, "git", "add", `${parent_path}**`);
`211`	`} catch (e) {`
`212`	console.log(`Unable to stage files matching ${parent_path}, ${e}`);
`213`	`}`
`214`	`}`
`215`	`try {`
`216`	`await sh_run(undefined, "git", "diff", "--cached", "--quiet");`
`217`	`} catch {`
`218`	`// git diff returns exit-code = 1 when there's at least one staged changes`
`219`	await sh_run(undefined, "git", "commit", "-m", `"${commit_msg == undefined \|\| commit_msg == "" ? "no commit msg" : commit_msg}"`);
`220`	`try {`
`221`	`await sh_run(undefined, "git", "push", "--porcelain");`
`222`	`} catch {`
`223`	`console.log("Could not push, trying to rebase first");`
`224`	`await sh_run(undefined, "git", "pull", "--rebase");`
`225`	`await sh_run(undefined, "git", "push", "--porcelain");`
`226`	`}`
`227`	`return;`
`228`	`}`
`229`	`console.log("No changes detected, nothing to commit. Returning...");`
`230`	`}`
`231`	`async function sh_run(`
`232`	`secret_position: number \| undefined,`
`233`	`cmd: string,`
`234`	`...args: string[]`
`235`	`) {`
`236`	`const nargs = secret_position != undefined ? args.slice() : args;`
`237`	`if (secret_position && secret_position < 0) {`
`238`	`secret_position = nargs.length - 1 + secret_position;`
`239`	`}`
`240`	`if (secret_position != undefined) {`
`241`	`nargs[secret_position] = "***";`
`242`	`}`
`243`
`244`	console.log(`Running '${cmd} ${nargs.join(" ")} ...'`);
`245`	const command = exec(`${cmd} ${args.join(" ")}`)
`246`	`// new Deno.Command(cmd, {`
`247`	`// args: args,`
`248`	`// });`
`249`	`const { error, stdout, stderr } = await command`
`250`	`if (stdout.length > 0) {`
`251`	`console.log(stdout);`
`252`	`}`
`253`	`if (stderr.length > 0) {`
`254`	`console.log(stderr);`
`255`	`}`
`256`	`if (error) {`
`257`	const err = `SH command '${cmd} ${nargs.join(
`258`	`" "`
`259`	)}' returned with error ${error}`;
`260`	`throw Error(err);`
`261`	`}`
`262`	`console.log("Command successfully executed");`
`263`	`}`
`264`
`265`	`function regexFromPath(`
`266`	`path_type:`
`267`	`\| "script"`
`268`	`\| "flow"`
`269`	`\| "app"`
`270`	`\| "folder"`
`271`	`\| "resource"`
`272`	`\| "variable"`
`273`	`\| "resourcetype"`
`274`	`\| "schedule"`
`275`	`\| "user"`
`276`	`\| "group",`
`277`	`path: string`
`278`	`) {`
`279`	`if (path_type == "flow") {`
`280`	return `${path}.flow/*`;
`281`	`} if (path_type == "app") {`
`282`	return `${path}.app/*`;
`283`	`} else if (path_type == "folder") {`
`284`	return `${path}/folder.meta.*`;
`285`	`} else if (path_type == "resourcetype") {`
`286`	return `${path}.resource-type.*`;
`287`	`} else if (path_type == "resource") {`
`288`	return `${path}.resource.*`;
`289`	`} else if (path_type == "variable") {`
`290`	return `${path}.variable.*`;
`291`	`} else if (path_type == "schedule") {`
`292`	return `${path}.schedule.*`;
`293`	`} else if (path_type == "user") {`
`294`	return `${path}.user.*`;
`295`	`} else if (path_type == "group") {`
`296`	return `${path}.group.*`;
`297`	`} else {`
`298`	return `${path}.*`;
`299`	`}`
`300`	`}`
`301`	`async function wmill_sync_pull(`
`302`	`path_type:`
`303`	`\| "script"`
`304`	`\| "flow"`
`305`	`\| "app"`
`306`	`\| "folder"`
`307`	`\| "resource"`
`308`	`\| "variable"`
`309`	`\| "resourcetype"`
`310`	`\| "schedule"`
`311`	`\| "user"`
`312`	`\| "group",`
`313`	`workspace_id: string,`
`314`	`path: string \| undefined,`
`315`	`parent_path: string \| undefined,`
`316`	`skip_secret: boolean`
`317`	`) {`
`318`	`const includes = [];`
`319`	`if (path !== undefined && path !== null && path !== "") {`
`320`	`includes.push(regexFromPath(path_type, path));`
`321`	`}`
`322`	`if (parent_path !== undefined && parent_path !== null && parent_path !== "") {`
`323`	`includes.push(regexFromPath(path_type, parent_path));`
`324`	`}`
`325`	`await wmill_run(`
`326`	`6,`
`327`	`"workspace",`
`328`	`"add",`
`329`	`workspace_id,`
`330`	`workspace_id,`
`331`	`process.env["BASE_URL"] + "/",`
`332`	`"--token",`
`333`	`process.env["WM_TOKEN"] ?? ""`
`334`	`);`
`335`	`console.log("Pulling workspace into git repo");`
`336`	`await wmill_run(`
`337`	`3,`
`338`	`"sync",`
`339`	`"pull",`
`340`	`"--token",`
`341`	`process.env["WM_TOKEN"] ?? "",`
`342`	`"--workspace",`
`343`	`workspace_id,`
`344`	`"--yes",`
`345`	`"--raw",`
`346`	`skip_secret ? "--skip-secrets" : "",`
`347`	`"--include-schedules",`
`348`	`"--include-users",`
`349`	`"--include-groups",`
`350`	`"--extra-includes",`
`351`	`includes.join(",")`
`352`	`);`
`353`	`}`
`354`
`355`	`async function wmill_run(secret_position: number, ...cmd: string[]) {`
`356`	`cmd = cmd.filter((elt) => elt !== "");`
`357`	`const cmd2 = cmd.slice();`
`358`	`cmd2[secret_position] = "***";`
`359`	console.log(`Running 'wmill ${cmd2.join(" ")} ...'`);
`360`	`await wmill.parse(cmd);`
`361`	`console.log("Command successfully executed");`
`362`	`}`

`1`	`import * as wmillclient from "npm:windmill-client@1.333.4";`
`2`	`import wmill from "https://deno.land/x/wmill@v1.333.4/main.ts";`
`3`	`import { basename } from "https://deno.land/std@0.208.0/path/mod.ts";`
`4`
`5`	`export async function main(`
`6`	`workspace_id: string,`
`7`	`repo_url_resource_path: string,`
`8`	`path_type:`
`9`	`\| "script"`
`10`	`\| "flow"`
`11`	`\| "app"`
`12`	`\| "folder"`
`13`	`\| "resource"`
`14`	`\| "variable"`
`15`	`\| "resourcetype"`
`16`	`\| "schedule"`
`17`	`\| "user"`
`18`	`\| "group",`
`19`	`skip_secret = true,`
`20`	`path: string \| undefined,`
`21`	`parent_path: string \| undefined,`
`22`	`commit_msg: string,`
`23`	`use_individual_branch = false,`
`24`	`group_by_folder = false`
`25`	`) {`
`26`	`const repo_resource = await wmillclient.getResource(repo_url_resource_path);`
`27`
`28`	`const cwd = Deno.cwd();`
`29`	`Deno.env.set("HOME", ".");`
`30`	`console.log(`
`31`	`Syncing ${path_type} ${path ?? ""} with parent ${parent_path ?? ""}`
`32`	`);`
`33`
`34`	`const repo_name = await git_clone(cwd, repo_resource, use_individual_branch);`
`35`	`await move_to_git_branch(`
`36`	`workspace_id,`
`37`	`path_type,`
`38`	`path,`
`39`	`parent_path,`
`40`	`use_individual_branch,`
`41`	`group_by_folder`
`42`	`);`
`43`
`44`	`const subfolder = repo_resource.folder ?? "";`
`45`	`const branch_or_default = repo_resource.branch ?? "<DEFAULT>";`
`46`	`console.log(`
`47`	`Pushing to repository ${repo_name} in subfolder ${subfolder} on branch ${branch_or_default}`
`48`	`);`
`49`
`50`	`await wmill_sync_pull(`
`51`	`path_type,`
`52`	`workspace_id,`
`53`	`path,`
`54`	`parent_path,`
`55`	`skip_secret`
`56`	`);`
`57`
`58`	`await git_push(path, parent_path, commit_msg);`
`59`
`60`	`console.log("Finished syncing");`
`61`	Deno.chdir(`${cwd}`);
`62`	`}`
`63`
`64`	`async function git_clone(`
`65`	`cwd: string,`
`66`	`repo_resource: any,`
`67`	`use_individual_branch: boolean`
`68`	`): Promise<string> {`
`69`	`// TODO: handle private SSH keys as well`
`70`	`let repo_url = repo_resource.url;`
`71`	`const subfolder = repo_resource.folder ?? "";`
`72`	`const branch = repo_resource.branch ?? "";`
`73`	`const repo_name = basename(repo_url, ".git");`
`74`
`75`	`const azureMatch = repo_url.match(/AZURE_DEVOPS_TOKEN\((?<url>.+)\)/);`
`76`
`77`	`if (azureMatch) {`
`78`	`console.log(`
`79`	`"Requires Azure DevOps service account access token, requesting..."`
`80`	`);`
`81`	`const azureResource = await wmillclient.getResource(azureMatch.groups.url);`
`82`
`83`	`const response = await fetch(`
`84`	`https://login.microsoftonline.com/${azureResource.azureTenantId}/oauth2/token`,
`85`	`{`
`86`	`method: "POST",`
`87`	`body: new URLSearchParams({`
`88`	`client_id: azureResource.azureClientId,`
`89`	`client_secret: azureResource.azureClientSecret,`
`90`	`grant_type: "client_credentials",`
`91`	`resource: "499b84ac-1321-427f-aa17-267ca6975798/.default",`
`92`	`}),`
`93`	`}`
`94`	`);`
`95`
`96`	`const { access_token } = await response.json();`
`97`
`98`	`repo_url = repo_url.replace(azureMatch[0], access_token);`
`99`	`}`
`100`
`101`	`const args = ["clone", "--quiet", "--depth", "1"];`
`102`	`if (use_individual_branch) {`
`103`	`args.push("--no-single-branch"); // needed in case the asset branch already exists in the repo`
`104`	`}`
`105`	`if (subfolder !== "") {`
`106`	`args.push("--sparse");`
`107`	`}`
`108`	`if (branch !== "") {`
`109`	`args.push("--branch");`
`110`	`args.push(branch);`
`111`	`}`
`112`	`args.push(repo_url);`
`113`	`args.push(repo_name);`
`114`	`await sh_run(-1, "git", ...args);`
`115`
`116`	`try {`
`117`	Deno.chdir(`${cwd}/${repo_name}`);
`118`	`} catch (err) {`
`119`	`console.log(`
`120`	`Error changing directory to '${cwd}/${repo_name}'. Error was:\n${err}`
`121`	`);`
`122`	`throw err;`
`123`	`}`
`124`	Deno.chdir(`${cwd}/${repo_name}`);
`125`	`if (subfolder !== "") {`
`126`	`await sh_run(undefined, "git", "sparse-checkout", "add", subfolder);`
`127`	`}`
`128`	`try {`
`129`	Deno.chdir(`${cwd}/${repo_name}/${subfolder}`);
`130`	`} catch (err) {`
`131`	`console.log(`
`132`	`Error changing directory to '${cwd}/${repo_name}/${subfolder}'. Error was:\n${err}`
`133`	`);`
`134`	`throw err;`
`135`	`}`
`136`
`137`	`return repo_name;`
`138`	`}`
`139`
`140`	`async function move_to_git_branch(`
`141`	`workspace_id: string,`
`142`	`path_type:`
`143`	`\| "script"`
`144`	`\| "flow"`
`145`	`\| "app"`
`146`	`\| "folder"`
`147`	`\| "resource"`
`148`	`\| "variable"`
`149`	`\| "resourcetype"`
`150`	`\| "schedule"`
`151`	`\| "user"`
`152`	`\| "group",`
`153`	`path: string \| undefined,`
`154`	`parent_path: string \| undefined,`
`155`	`use_individual_branch: boolean,`
`156`	`group_by_folder: boolean`
`157`	`) {`
`158`	`if (!use_individual_branch \|\| path_type === "user" \|\| path_type === "group") {`
`159`	`return;`
`160`	`}`
`161`
`162`	`const branchName = group_by_folder`
`163`	? `wm_deploy/${workspace_id}/${(path ?? parent_path)
`164`	`?.split("/")`
`165`	`.slice(0, 2)`
`166`	.join("__")}`
`167`	: `wm_deploy/${workspace_id}/${path_type}/${(
`168`	`path ?? parent_path`
`169`	)?.replaceAll("/", "__")}`;
`170`
`171`	`try {`
`172`	`await sh_run(undefined, "git", "checkout", branchName);`
`173`	`} catch (err) {`
`174`	`console.log(`
`175`	`Error checking out branch ${branchName}. It is possible it doesn't exist yet, tentatively creating it... Error was:\n${err}`
`176`	`);`
`177`	`try {`
`178`	`await sh_run(undefined, "git", "checkout", "-b", branchName);`
`179`	`await sh_run(`
`180`	`undefined,`
`181`	`"git",`
`182`	`"config",`
`183`	`"--add",`
`184`	`"--bool",`
`185`	`"push.autoSetupRemote",`
`186`	`"true"`
`187`	`);`
`188`	`} catch (err) {`
`189`	`console.log(`
`190`	`Error checking out branch '${branchName}'. Error was:\n${err}`
`191`	`);`
`192`	`throw err;`
`193`	`}`
`194`	`}`
`195`	console.log(`Successfully switched to branch ${branchName}`);
`196`	`}`
`197`
`198`	`async function git_push(`
`199`	`path: string \| undefined,`
`200`	`parent_path: string \| undefined,`
`201`	`commit_msg: string`
`202`	`) {`
`203`	`await sh_run(`
`204`	`undefined,`
`205`	`"git",`
`206`	`"config",`
`207`	`"user.email",`
`208`	`Deno.env.get("WM_EMAIL") ?? ""`
`209`	`);`
`210`	`await sh_run(`
`211`	`undefined,`
`212`	`"git",`
`213`	`"config",`
`214`	`"user.name",`
`215`	`Deno.env.get("WM_USERNAME") ?? ""`
`216`	`);`
`217`	`if (path !== undefined && path !== null && path !== "") {`
`218`	`try {`
`219`	await sh_run(undefined, "git", "add", `${path}**`);
`220`	`} catch (e) {`
`221`	console.log(`Unable to stage files matching ${path}**, ${e}`);
`222`	`}`
`223`	`}`
`224`	`if (parent_path !== undefined && parent_path !== null && parent_path !== "") {`
`225`	`try {`
`226`	await sh_run(undefined, "git", "add", `${parent_path}**`);
`227`	`} catch (e) {`
`228`	console.log(`Unable to stage files matching ${parent_path}, ${e}`);
`229`	`}`
`230`	`}`
`231`	`try {`
`232`	`await sh_run(undefined, "git", "diff", "--cached", "--quiet");`
`233`	`} catch {`
`234`	`// git diff returns exit-code = 1 when there's at least one staged changes`
`235`	`await sh_run(undefined, "git", "commit", "-m", commit_msg);`
`236`	`try {`
`237`	`await sh_run(undefined, "git", "push", "--porcelain");`
`238`	`} catch {`
`239`	`console.log("Could not push, trying to rebase first");`
`240`	`await sh_run(undefined, "git", "pull", "--rebase");`
`241`	`await sh_run(undefined, "git", "push", "--porcelain");`
`242`	`}`
`243`	`return;`
`244`	`}`
`245`	`console.log("No changes detected, nothing to commit. Returning...");`
`246`	`}`
`247`
`248`	`async function sh_run(`
`249`	`secret_position: number \| undefined,`
`250`	`cmd: string,`
`251`	`...args: string[]`
`252`	`) {`
`253`	`const nargs = secret_position != undefined ? args.slice() : args;`
`254`	`if (secret_position < 0) {`
`255`	`secret_position = nargs.length - 1 + secret_position;`
`256`	`}`
`257`	`if (secret_position != undefined) {`
`258`	`nargs[secret_position] = "***";`
`259`	`}`
`260`	console.log(`Running '${cmd} ${nargs.join(" ")} ...'`);
`261`	`const command = new Deno.Command(cmd, {`
`262`	`args: args,`
`263`	`});`
`264`
`265`	`const { code, stdout, stderr } = await command.output();`
`266`	`if (stdout.length > 0) {`
`267`	`console.log(new TextDecoder().decode(stdout));`
`268`	`}`
`269`	`if (stderr.length > 0) {`
`270`	`console.log(new TextDecoder().decode(stderr));`
`271`	`}`
`272`	`if (code !== 0) {`
`273`	const err = `SH command '${cmd} ${nargs.join(
`274`	`" "`
`275`	)}' returned with a non-zero status ${code}.`;
`276`	`throw Error(err);`
`277`	`}`
`278`	`console.log("Command successfully executed");`
`279`	`}`
`280`
`281`	`function regexFromPath(`
`282`	`path_type:`
`283`	`\| "script"`
`284`	`\| "flow"`
`285`	`\| "app"`
`286`	`\| "folder"`
`287`	`\| "resource"`
`288`	`\| "variable"`
`289`	`\| "resourcetype"`
`290`	`\| "schedule"`
`291`	`\| "user"`
`292`	`\| "group",`
`293`	`path: string`
`294`	`) {`
`295`	`if (path_type == "flow") {`
`296`	return `${path}.flow/*`;
`297`	`} if (path_type == "app") {`
`298`	return `${path}.app/*`;
`299`	`} else if (path_type == "folder") {`
`300`	return `${path}/folder.meta.*`;
`301`	`} else if (path_type == "resourcetype") {`
`302`	return `${path}.resource-type.*`;
`303`	`} else if (path_type == "resource") {`
`304`	return `${path}.resource.*`;
`305`	`} else if (path_type == "variable") {`
`306`	return `${path}.variable.*`;
`307`	`} else if (path_type == "schedule") {`
`308`	return `${path}.schedule.*`;
`309`	`} else if (path_type == "user") {`
`310`	return `${path}.user.*`;
`311`	`} else if (path_type == "group") {`
`312`	return `${path}.group.*`;
`313`	`} else {`
`314`	return `${path}.*`;
`315`	`}`
`316`	`}`
`317`	`async function wmill_sync_pull(`
`318`	`path_type:`
`319`	`\| "script"`
`320`	`\| "flow"`
`321`	`\| "app"`
`322`	`\| "folder"`
`323`	`\| "resource"`
`324`	`\| "variable"`
`325`	`\| "resourcetype"`
`326`	`\| "schedule"`
`327`	`\| "user"`
`328`	`\| "group",`
`329`	`workspace_id: string,`
`330`	`path: string \| undefined,`
`331`	`parent_path: string \| undefined,`
`332`	`skip_secret: boolean`
`333`	`) {`
`334`	`const includes = [];`
`335`	`if (path !== undefined && path !== null && path !== "") {`
`336`	`includes.push(regexFromPath(path_type, path));`
`337`	`}`
`338`	`if (parent_path !== undefined && parent_path !== null && parent_path !== "") {`
`339`	`includes.push(regexFromPath(path_type, parent_path));`
`340`	`}`
`341`
`342`	`await wmill_run(`
`343`	`6,`
`344`	`"workspace",`
`345`	`"add",`
`346`	`workspace_id,`
`347`	`workspace_id,`
`348`	`Deno.env.get("BASE_INTERNAL_URL") + "/",`
`349`	`"--token",`
`350`	`Deno.env.get("WM_TOKEN") ?? ""`
`351`	`);`
`352`	`console.log("Pulling workspace into git repo");`
`353`	`await wmill_run(`
`354`	`3,`
`355`	`"sync",`
`356`	`"pull",`
`357`	`"--token",`
`358`	`Deno.env.get("WM_TOKEN") ?? "",`
`359`	`"--workspace",`
`360`	`workspace_id,`
`361`	`"--yes",`
`362`	`"--raw",`
`363`	`skip_secret ? "--skip-secrets" : "",`
`364`	`"--include-schedules",`
`365`	`"--include-users",`
`366`	`"--include-groups",`
`367`	`"--includes",`
`368`	`includes.join(",")`
`369`	`);`
`370`	`}`
`371`
`372`	`async function wmill_run(secret_position: number, ...cmd: string[]) {`
`373`	`cmd = cmd.filter((elt) => elt !== "");`
`374`	`const cmd2 = cmd.slice();`
`375`	`cmd2[secret_position] = "***";`
`376`	console.log(`Running 'wmill ${cmd2.join(" ")} ...'`);
`377`	`await wmill.parse(cmd);`
`378`	`console.log("Command successfully executed");`
`379`	`}`
`380`