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 608 days ago Viewed 91774 times

Submitted by rubenfiszel Bun

Verified 325 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";

type GpgKey = {
  email: string;
  private_key: string;
  passphrase: string;
};

type PathType =
  | "script"
  | "flow"
  | "app"
  | "folder"
  | "resource"
  | "variable"
  | "resourcetype"
  | "schedule"
  | "user"
  | "group"
  | "httptrigger"
  | "websockettrigger"
  | "kafkatrigger"
  | "natstrigger"
  | "postgrestrigger"
  | "mqtttrigger"
  | "sqstrigger"
  | "gcptrigger";

let gpgFingerprint: string | undefined = undefined;

export async function main(
  workspace_id: string,
  repo_url_resource_path: string,
  path_type: PathType,
  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 ?? ""}`
  );

  if (repo_resource.is_github_app) {
    const token = await get_gh_app_token();
    const authRepoUrl = prependTokenToGitHubUrl(repo_resource.url, token);
    repo_resource.url = authRepoUrl;
  }

  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,
    repo_url_resource_path
  );
  try {
    await git_push(path, parent_path, commit_msg, repo_resource);
  } catch (e) {
    throw e;
  } finally {
    await delete_pgp_keys();
  }
  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: PathType,
  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,
  repo_resource: any
) {
  let user_email = process.env["WM_EMAIL"] ?? "";
  let user_name = process.env["WM_USERNAME"] ?? "";

  if (repo_resource.gpg_key) {
    await set_gpg_signing_secret(repo_resource.gpg_key);
    // Configure git with GPG key email for signing
    await sh_run(
      undefined,
      "git",
      "config",
      "user.email",
      repo_resource.gpg_key.email
    );
    await sh_run(undefined, "git", "config", "user.name", user_name);
  } else {
    await sh_run(undefined, "git", "config", "user.email", user_email);
    await sh_run(undefined, "git", "config", "user.name", user_name);
  }

  if (path !== undefined && path !== null && path !== "") {
    try {
      await sh_run(undefined, "git", "add", "wmill-lock.yaml", `${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",
        "wmill-lock.yaml",
        `${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
    const commitArgs = ["git", "commit"];

    // Always use --author to set consistent authorship
    commitArgs.push("--author", `"${user_name} <${user_email}>"`);
    commitArgs.push(
      "-m",
      `"${commit_msg == undefined || commit_msg == "" ? "no commit msg" : commit_msg}"`
    );

    await sh_run(undefined, ...commitArgs);
    try {
      await sh_run(undefined, "git", "push", "--porcelain");
    } catch (e) {
      console.log(`Could not push, trying to rebase first: ${e}`);
      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;
  }
  let secret: string | undefined = undefined;
  if (secret_position != undefined) {
    nargs[secret_position] = "***";
    secret = args[secret_position];
  }

  console.log(`Running '${cmd} ${nargs.join(" ")} ...'`);
  const command = exec(`${cmd} ${args.join(" ")}`);
  // new Deno.Command(cmd, {
  //   args: args,
  // });
  try {
    const { stdout, stderr } = await command;
    if (stdout.length > 0) {
      console.log(stdout);
    }
    if (stderr.length > 0) {
      console.log(stderr);
    }
    console.log("Command successfully executed");
    return stdout;
  } catch (error) {
    let errorString = error.toString();
    if (secret) {
      errorString = errorString.replace(secret, "***");
    }
    const err = `SH command '${cmd} ${nargs.join(
      " "
    )}' returned with error ${errorString}`;
    throw Error(err);
  }
}

function regexFromPath(path_type: PathType, 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 if (path_type == "httptrigger") {
    return `${path}.http_trigger.*`;
  } else if (path_type == "websockettrigger") {
    return `${path}.websocket_trigger.*`;
  } else if (path_type == "kafkatrigger") {
    return `${path}.kafka_trigger.*`;
  } else if (path_type == "natstrigger") {
    return `${path}.nats_trigger.*`;
  } else if (path_type == "postgrestrigger") {
    return `${path}.postgres_trigger.*`;
  } else if (path_type == "mqtttrigger") {
    return `${path}.mqtt_trigger.*`;
  } else if (path_type == "sqstrigger") {
    return `${path}.sqs_trigger.*`;
  } else if (path_type == "gcptrigger") {
    return `${path}.gcp_trigger.*`;
  } else {
    return `${path}.*`;
  }
}

async function wmill_sync_pull(
  path_type: PathType,
  workspace_id: string,
  path: string | undefined,
  parent_path: string | undefined,
  skip_secret: boolean,
  repo_url_resource_path: string
) {
  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");
  const args = [
    "sync",
    "pull",
    "--token",
    process.env["WM_TOKEN"] ?? "",
    "--workspace",
    workspace_id,
    "--repository",
    repo_url_resource_path,
    "--yes",
    skip_secret ? "--skip-secrets" : "",
    "--include-schedules",
    "--include-users",
    "--include-groups",
    "--include-triggers",
  ];

  // Only include settings when specifically deploying settings
  if (path_type === "settings") {
    args.push("--include-settings");
  }

  // Only include key when specifically deploying keys
  if (path_type === "key") {
    args.push("--include-key");
  }

  args.push("--extra-includes", includes.join(","));

  await wmill_run(3, ...args);
}

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");
}

// Function to set up GPG signing
async function set_gpg_signing_secret(gpg_key: GpgKey) {
  try {
    console.log("Setting GPG private key for git commits");

    const formattedGpgContent = gpg_key.private_key.replace(
      /(-----BEGIN PGP PRIVATE KEY BLOCK-----)([\s\S]*?)(-----END PGP PRIVATE KEY BLOCK-----)/,
      (_: string, header: string, body: string, footer: string) =>
        header +
        "\n" +
        "\n" +
        body.replace(/ ([^\s])/g, "\n$1").trim() +
        "\n" +
        footer
    );

    const gpg_path = `/tmp/gpg`;
    await sh_run(undefined, "mkdir", "-p", gpg_path);
    await sh_run(undefined, "chmod", "700", gpg_path);
    process.env.GNUPGHOME = gpg_path;
    // process.env.GIT_TRACE = 1;

    try {
      await sh_run(
        1,
        "bash",
        "-c",
        `cat <<EOF | gpg --batch --import \n${formattedGpgContent}\nEOF`
      );
    } catch (e) {
      // Original error would contain sensitive data
      throw new Error("Failed to import GPG key!");
    }

    const listKeysOutput = await sh_run(
      undefined,
      "gpg",
      "--list-secret-keys",
      "--with-colons",
      "--keyid-format=long"
    );

    const keyInfoMatch = listKeysOutput.match(
      /sec:[^:]*:[^:]*:[^:]*:([A-F0-9]+):.*\nfpr:::::::::([A-F0-9]{40}):/
    );

    if (!keyInfoMatch) {
      throw new Error("Failed to extract GPG Key ID and Fingerprint");
    }

    const keyId = keyInfoMatch[1];
    gpgFingerprint = keyInfoMatch[2];

    if (gpg_key.passphrase) {
      // This is adummy command to unlock the key
      // with passphrase to load it into agent
      await sh_run(
        1,
        "bash",
        "-c",
        `echo "dummy" | gpg --batch --pinentry-mode loopback --passphrase '${gpg_key.passphrase}' --status-fd=2 -bsau ${keyId}`
      );
    }

    // Configure Git to use the extracted key
    await sh_run(undefined, "git", "config", "user.signingkey", keyId);
    await sh_run(undefined, "git", "config", "commit.gpgsign", "true");
    console.log(`GPG signing configured with key ID: ${keyId} `);
  } catch (e) {
    console.error(`Failure while setting GPG key: ${e} `);
    await delete_pgp_keys();
  }
}

async function delete_pgp_keys() {
  console.log("deleting gpg keys");
  if (gpgFingerprint) {
    await sh_run(
      undefined,
      "gpg",
      "--batch",
      "--yes",
      "--pinentry-mode",
      "loopback",
      "--delete-secret-key",
      gpgFingerprint
    );
    await sh_run(
      undefined,
      "gpg",
      "--batch",
      "--yes",
      "--delete-key",
      "--pinentry-mode",
      "loopback",
      gpgFingerprint
    );
  }
}

async function get_gh_app_token() {
  const workspace = process.env["WM_WORKSPACE"];
  const jobToken = process.env["WM_TOKEN"];

  const baseUrl =
    process.env["BASE_INTERNAL_URL"] ??
    process.env["BASE_URL"] ??
    "http://localhost:8000";

  const url = `${baseUrl}/api/w/${workspace}/github_app/token`;

  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${jobToken}`,
    },
    body: JSON.stringify({
      job_token: jobToken,
    }),
  });

  if (!response.ok) {
    throw new Error(`Error: ${response.statusText}`);
  }

  const data = await response.json();

  return data.token;
}

function prependTokenToGitHubUrl(gitHubUrl: string, installationToken: string) {
  if (!gitHubUrl || !installationToken) {
    throw new Error("Both GitHub URL and Installation Token are required.");
  }

  try {
    const url = new URL(gitHubUrl);

    // GitHub repository URL should be in the format: https://github.com/owner/repo.git
    if (url.hostname !== "github.com") {
      throw new Error(
        "Invalid GitHub URL. Must be in the format 'https://github.com/owner/repo.git'."
      );
    }

    // Convert URL to include the installation token
    return `https://x-access-token:${installationToken}@github.com${url.pathname}`;
  } catch (e) {
    const error = e as Error;
    throw new Error(`Invalid URL: ${error.message}`);
  }
}


Other submissions

Submitted by hugo697 Deno

Created 608 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`	`type GpgKey = {`
`9`	`email: string;`
`10`	`private_key: string;`
`11`	`passphrase: string;`
`12`	`};`
`13`
`14`	`type PathType =`
`15`	`\| "script"`
`16`	`\| "flow"`
`17`	`\| "app"`
`18`	`\| "folder"`
`19`	`\| "resource"`
`20`	`\| "variable"`
`21`	`\| "resourcetype"`
`22`	`\| "schedule"`
`23`	`\| "user"`
`24`	`\| "group"`
`25`	`\| "httptrigger"`
`26`	`\| "websockettrigger"`
`27`	`\| "kafkatrigger"`
`28`	`\| "natstrigger"`
`29`	`\| "postgrestrigger"`
`30`	`\| "mqtttrigger"`
`31`	`\| "sqstrigger"`
`32`	`\| "gcptrigger";`
`33`
`34`	`let gpgFingerprint: string \| undefined = undefined;`
`35`
`36`	`export async function main(`
`37`	`workspace_id: string,`
`38`	`repo_url_resource_path: string,`
`39`	`path_type: PathType,`
`40`	`skip_secret = true,`
`41`	`path: string \| undefined,`
`42`	`parent_path: string \| undefined,`
`43`	`commit_msg: string,`
`44`	`use_individual_branch = false,`
`45`	`group_by_folder = false`
`46`	`) {`
`47`	`const repo_resource = await wmillclient.getResource(repo_url_resource_path);`
`48`	`const cwd = process.cwd();`
`49`	`process.env["HOME"] = ".";`
`50`	`console.log(`
`51`	`Syncing ${path_type} ${path ?? ""} with parent ${parent_path ?? ""}`
`52`	`);`
`53`
`54`	`if (repo_resource.is_github_app) {`
`55`	`const token = await get_gh_app_token();`
`56`	`const authRepoUrl = prependTokenToGitHubUrl(repo_resource.url, token);`
`57`	`repo_resource.url = authRepoUrl;`
`58`	`}`
`59`
`60`	`const repo_name = await git_clone(cwd, repo_resource, use_individual_branch);`
`61`	`await move_to_git_branch(`
`62`	`workspace_id,`
`63`	`path_type,`
`64`	`path,`
`65`	`parent_path,`
`66`	`use_individual_branch,`
`67`	`group_by_folder`
`68`	`);`
`69`	`const subfolder = repo_resource.folder ?? "";`
`70`	`const branch_or_default = repo_resource.branch ?? "<DEFAULT>";`
`71`	`console.log(`
`72`	`Pushing to repository ${repo_name} in subfolder ${subfolder} on branch ${branch_or_default}`
`73`	`);`
`74`	`await wmill_sync_pull(`
`75`	`path_type,`
`76`	`workspace_id,`
`77`	`path,`
`78`	`parent_path,`
`79`	`skip_secret,`
`80`	`repo_url_resource_path`
`81`	`);`
`82`	`try {`
`83`	`await git_push(path, parent_path, commit_msg, repo_resource);`
`84`	`} catch (e) {`
`85`	`throw e;`
`86`	`} finally {`
`87`	`await delete_pgp_keys();`
`88`	`}`
`89`	`console.log("Finished syncing");`
`90`	process.chdir(`${cwd}`);
`91`	`}`
`92`	`async function git_clone(`
`93`	`cwd: string,`
`94`	`repo_resource: any,`
`95`	`use_individual_branch: boolean`
`96`	`): Promise<string> {`
`97`	`// TODO: handle private SSH keys as well`
`98`	`let repo_url = repo_resource.url;`
`99`	`const subfolder = repo_resource.folder ?? "";`
`100`	`const branch = repo_resource.branch ?? "";`
`101`	`const repo_name = basename(repo_url, ".git");`
`102`	`const azureMatch = repo_url.match(/AZURE_DEVOPS_TOKEN\((?<url>.+)\)/);`
`103`	`if (azureMatch) {`
`104`	`console.log(`
`105`	`"Requires Azure DevOps service account access token, requesting..."`
`106`	`);`
`107`	`const azureResource = await wmillclient.getResource(azureMatch.groups.url);`
`108`	`const response = await fetch(`
`109`	`https://login.microsoftonline.com/${azureResource.azureTenantId}/oauth2/token`,
`110`	`{`
`111`	`method: "POST",`
`112`	`body: new URLSearchParams({`
`113`	`client_id: azureResource.azureClientId,`
`114`	`client_secret: azureResource.azureClientSecret,`
`115`	`grant_type: "client_credentials",`
`116`	`resource: "499b84ac-1321-427f-aa17-267ca6975798/.default",`
`117`	`}),`
`118`	`}`
`119`	`);`
`120`	`const { access_token } = await response.json();`
`121`	`repo_url = repo_url.replace(azureMatch[0], access_token);`
`122`	`}`
`123`	`const args = ["clone", "--quiet", "--depth", "1"];`
`124`	`if (use_individual_branch) {`
`125`	`args.push("--no-single-branch"); // needed in case the asset branch already exists in the repo`
`126`	`}`
`127`	`if (subfolder !== "") {`
`128`	`args.push("--sparse");`
`129`	`}`
`130`	`if (branch !== "") {`
`131`	`args.push("--branch");`
`132`	`args.push(branch);`
`133`	`}`
`134`	`args.push(repo_url);`
`135`	`args.push(repo_name);`
`136`	`await sh_run(-1, "git", ...args);`
`137`	`try {`
`138`	process.chdir(`${cwd}/${repo_name}`);
`139`	`} catch (err) {`
`140`	`console.log(`
`141`	`Error changing directory to '${cwd}/${repo_name}'. Error was:\n${err}`
`142`	`);`
`143`	`throw err;`
`144`	`}`
`145`	process.chdir(`${cwd}/${repo_name}`);
`146`	`if (subfolder !== "") {`
`147`	`await sh_run(undefined, "git", "sparse-checkout", "add", subfolder);`
`148`	`}`
`149`	`try {`
`150`	process.chdir(`${cwd}/${repo_name}/${subfolder}`);
`151`	`} catch (err) {`
`152`	`console.log(`
`153`	`Error changing directory to '${cwd}/${repo_name}/${subfolder}'. Error was:\n${err}`
`154`	`);`
`155`	`throw err;`
`156`	`}`
`157`	`return repo_name;`
`158`	`}`
`159`	`async function move_to_git_branch(`
`160`	`workspace_id: string,`
`161`	`path_type: PathType,`
`162`	`path: string \| undefined,`
`163`	`parent_path: string \| undefined,`
`164`	`use_individual_branch: boolean,`
`165`	`group_by_folder: boolean`
`166`	`) {`
`167`	`if (!use_individual_branch \|\| path_type === "user" \|\| path_type === "group") {`
`168`	`return;`
`169`	`}`
`170`	`const branchName = group_by_folder`
`171`	? `wm_deploy/${workspace_id}/${(path ?? parent_path)
`172`	`?.split("/")`
`173`	`.slice(0, 2)`
`174`	.join("__")}`
`175`	: `wm_deploy/${workspace_id}/${path_type}/${(
`176`	`path ?? parent_path`
`177`	)?.replaceAll("/", "__")}`;
`178`	`try {`
`179`	`await sh_run(undefined, "git", "checkout", branchName);`
`180`	`} catch (err) {`
`181`	`console.log(`
`182`	`Error checking out branch ${branchName}. It is possible it doesn't exist yet, tentatively creating it... Error was:\n${err}`
`183`	`);`
`184`	`try {`
`185`	`await sh_run(undefined, "git", "checkout", "-b", branchName);`
`186`	`await sh_run(`
`187`	`undefined,`
`188`	`"git",`
`189`	`"config",`
`190`	`"--add",`
`191`	`"--bool",`
`192`	`"push.autoSetupRemote",`
`193`	`"true"`
`194`	`);`
`195`	`} catch (err) {`
`196`	`console.log(`
`197`	`Error checking out branch '${branchName}'. Error was:\n${err}`
`198`	`);`
`199`	`throw err;`
`200`	`}`
`201`	`}`
`202`	console.log(`Successfully switched to branch ${branchName}`);
`203`	`}`
`204`	`async function git_push(`
`205`	`path: string \| undefined,`
`206`	`parent_path: string \| undefined,`
`207`	`commit_msg: string,`
`208`	`repo_resource: any`
`209`	`) {`
`210`	`let user_email = process.env["WM_EMAIL"] ?? "";`
`211`	`let user_name = process.env["WM_USERNAME"] ?? "";`
`212`
`213`	`if (repo_resource.gpg_key) {`
`214`	`await set_gpg_signing_secret(repo_resource.gpg_key);`
`215`	`// Configure git with GPG key email for signing`
`216`	`await sh_run(`
`217`	`undefined,`
`218`	`"git",`
`219`	`"config",`
`220`	`"user.email",`
`221`	`repo_resource.gpg_key.email`
`222`	`);`
`223`	`await sh_run(undefined, "git", "config", "user.name", user_name);`
`224`	`} else {`
`225`	`await sh_run(undefined, "git", "config", "user.email", user_email);`
`226`	`await sh_run(undefined, "git", "config", "user.name", user_name);`
`227`	`}`
`228`
`229`	`if (path !== undefined && path !== null && path !== "") {`
`230`	`try {`
`231`	await sh_run(undefined, "git", "add", "wmill-lock.yaml", `${path}**`);
`232`	`} catch (e) {`
`233`	console.log(`Unable to stage files matching ${path}**, ${e}`);
`234`	`}`
`235`	`}`
`236`	`if (parent_path !== undefined && parent_path !== null && parent_path !== "") {`
`237`	`try {`
`238`	`await sh_run(`
`239`	`undefined,`
`240`	`"git",`
`241`	`"add",`
`242`	`"wmill-lock.yaml",`
`243`	`${parent_path}**`
`244`	`);`
`245`	`} catch (e) {`
`246`	console.log(`Unable to stage files matching ${parent_path}, ${e}`);
`247`	`}`
`248`	`}`
`249`	`try {`
`250`	`await sh_run(undefined, "git", "diff", "--cached", "--quiet");`
`251`	`} catch {`
`252`	`// git diff returns exit-code = 1 when there's at least one staged changes`
`253`	`const commitArgs = ["git", "commit"];`
`254`
`255`	`// Always use --author to set consistent authorship`
`256`	commitArgs.push("--author", `"${user_name} <${user_email}>"`);
`257`	`commitArgs.push(`
`258`	`"-m",`
`259`	`"${commit_msg == undefined \|\| commit_msg == "" ? "no commit msg" : commit_msg}"`
`260`	`);`
`261`
`262`	`await sh_run(undefined, ...commitArgs);`
`263`	`try {`
`264`	`await sh_run(undefined, "git", "push", "--porcelain");`
`265`	`} catch (e) {`
`266`	console.log(`Could not push, trying to rebase first: ${e}`);
`267`	`await sh_run(undefined, "git", "pull", "--rebase");`
`268`	`await sh_run(undefined, "git", "push", "--porcelain");`
`269`	`}`
`270`	`return;`
`271`	`}`
`272`	`console.log("No changes detected, nothing to commit. Returning...");`
`273`	`}`
`274`	`async function sh_run(`
`275`	`secret_position: number \| undefined,`
`276`	`cmd: string,`
`277`	`...args: string[]`
`278`	`) {`
`279`	`const nargs = secret_position != undefined ? args.slice() : args;`
`280`	`if (secret_position && secret_position < 0) {`
`281`	`secret_position = nargs.length - 1 + secret_position;`
`282`	`}`
`283`	`let secret: string \| undefined = undefined;`
`284`	`if (secret_position != undefined) {`
`285`	`nargs[secret_position] = "***";`
`286`	`secret = args[secret_position];`
`287`	`}`
`288`
`289`	console.log(`Running '${cmd} ${nargs.join(" ")} ...'`);
`290`	const command = exec(`${cmd} ${args.join(" ")}`);
`291`	`// new Deno.Command(cmd, {`
`292`	`// args: args,`
`293`	`// });`
`294`	`try {`
`295`	`const { stdout, stderr } = await command;`
`296`	`if (stdout.length > 0) {`
`297`	`console.log(stdout);`
`298`	`}`
`299`	`if (stderr.length > 0) {`
`300`	`console.log(stderr);`
`301`	`}`
`302`	`console.log("Command successfully executed");`
`303`	`return stdout;`
`304`	`} catch (error) {`
`305`	`let errorString = error.toString();`
`306`	`if (secret) {`
`307`	`errorString = errorString.replace(secret, "***");`
`308`	`}`
`309`	const err = `SH command '${cmd} ${nargs.join(
`310`	`" "`
`311`	)}' returned with error ${errorString}`;
`312`	`throw Error(err);`
`313`	`}`
`314`	`}`
`315`
`316`	`function regexFromPath(path_type: PathType, path: string) {`
`317`	`if (path_type == "flow") {`
`318`	return `${path}.flow/*`;
`319`	`}`
`320`	`if (path_type == "app") {`
`321`	return `${path}.app/*`;
`322`	`} else if (path_type == "folder") {`
`323`	return `${path}/folder.meta.*`;
`324`	`} else if (path_type == "resourcetype") {`
`325`	return `${path}.resource-type.*`;
`326`	`} else if (path_type == "resource") {`
`327`	return `${path}.resource.*`;
`328`	`} else if (path_type == "variable") {`
`329`	return `${path}.variable.*`;
`330`	`} else if (path_type == "schedule") {`
`331`	return `${path}.schedule.*`;
`332`	`} else if (path_type == "user") {`
`333`	return `${path}.user.*`;
`334`	`} else if (path_type == "group") {`
`335`	return `${path}.group.*`;
`336`	`} else if (path_type == "httptrigger") {`
`337`	return `${path}.http_trigger.*`;
`338`	`} else if (path_type == "websockettrigger") {`
`339`	return `${path}.websocket_trigger.*`;
`340`	`} else if (path_type == "kafkatrigger") {`
`341`	return `${path}.kafka_trigger.*`;
`342`	`} else if (path_type == "natstrigger") {`
`343`	return `${path}.nats_trigger.*`;
`344`	`} else if (path_type == "postgrestrigger") {`
`345`	return `${path}.postgres_trigger.*`;
`346`	`} else if (path_type == "mqtttrigger") {`
`347`	return `${path}.mqtt_trigger.*`;
`348`	`} else if (path_type == "sqstrigger") {`
`349`	return `${path}.sqs_trigger.*`;
`350`	`} else if (path_type == "gcptrigger") {`
`351`	return `${path}.gcp_trigger.*`;
`352`	`} else {`
`353`	return `${path}.*`;
`354`	`}`
`355`	`}`
`356`
`357`	`async function wmill_sync_pull(`
`358`	`path_type: PathType,`
`359`	`workspace_id: string,`
`360`	`path: string \| undefined,`
`361`	`parent_path: string \| undefined,`
`362`	`skip_secret: boolean,`
`363`	`repo_url_resource_path: string`
`364`	`) {`
`365`	`const includes = [];`
`366`	`if (path !== undefined && path !== null && path !== "") {`
`367`	`includes.push(regexFromPath(path_type, path));`
`368`	`}`
`369`	`if (parent_path !== undefined && parent_path !== null && parent_path !== "") {`
`370`	`includes.push(regexFromPath(path_type, parent_path));`
`371`	`}`
`372`	`await wmill_run(`
`373`	`6,`
`374`	`"workspace",`
`375`	`"add",`
`376`	`workspace_id,`
`377`	`workspace_id,`
`378`	`process.env["BASE_URL"] + "/",`
`379`	`"--token",`
`380`	`process.env["WM_TOKEN"] ?? ""`
`381`	`);`
`382`	`console.log("Pulling workspace into git repo");`
`383`	`const args = [`
`384`	`"sync",`
`385`	`"pull",`
`386`	`"--token",`
`387`	`process.env["WM_TOKEN"] ?? "",`
`388`	`"--workspace",`
`389`	`workspace_id,`
`390`	`"--repository",`
`391`	`repo_url_resource_path,`
`392`	`"--yes",`
`393`	`skip_secret ? "--skip-secrets" : "",`
`394`	`"--include-schedules",`
`395`	`"--include-users",`
`396`	`"--include-groups",`
`397`	`"--include-triggers",`
`398`	`];`
`399`
`400`	`// Only include settings when specifically deploying settings`
`401`	`if (path_type === "settings") {`
`402`	`args.push("--include-settings");`
`403`	`}`
`404`
`405`	`// Only include key when specifically deploying keys`
`406`	`if (path_type === "key") {`
`407`	`args.push("--include-key");`
`408`	`}`
`409`
`410`	`args.push("--extra-includes", includes.join(","));`
`411`
`412`	`await wmill_run(3, ...args);`
`413`	`}`
`414`
`415`	`async function wmill_run(secret_position: number, ...cmd: string[]) {`
`416`	`cmd = cmd.filter((elt) => elt !== "");`
`417`	`const cmd2 = cmd.slice();`
`418`	`cmd2[secret_position] = "***";`
`419`	console.log(`Running 'wmill ${cmd2.join(" ")} ...'`);
`420`	`await wmill.parse(cmd);`
`421`	`console.log("Command successfully executed");`
`422`	`}`
`423`
`424`	`// Function to set up GPG signing`
`425`	`async function set_gpg_signing_secret(gpg_key: GpgKey) {`
`426`	`try {`
`427`	`console.log("Setting GPG private key for git commits");`
`428`
`429`	`const formattedGpgContent = gpg_key.private_key.replace(`
`430`	`/(-----BEGIN PGP PRIVATE KEY BLOCK-----)([\s\S]*?)(-----END PGP PRIVATE KEY BLOCK-----)/,`
`431`	`(_: string, header: string, body: string, footer: string) =>`
`432`	`header +`
`433`	`"\n" +`
`434`	`"\n" +`
`435`	`body.replace(/ ([^\s])/g, "\n$1").trim() +`
`436`	`"\n" +`
`437`	`footer`
`438`	`);`
`439`
`440`	const gpg_path = `/tmp/gpg`;
`441`	`await sh_run(undefined, "mkdir", "-p", gpg_path);`
`442`	`await sh_run(undefined, "chmod", "700", gpg_path);`
`443`	`process.env.GNUPGHOME = gpg_path;`
`444`	`// process.env.GIT_TRACE = 1;`
`445`
`446`	`try {`
`447`	`await sh_run(`
`448`	`1,`
`449`	`"bash",`
`450`	`"-c",`
`451`	`cat <<EOF \| gpg --batch --import \n${formattedGpgContent}\nEOF`
`452`	`);`
`453`	`} catch (e) {`
`454`	`// Original error would contain sensitive data`
`455`	`throw new Error("Failed to import GPG key!");`
`456`	`}`
`457`
`458`	`const listKeysOutput = await sh_run(`
`459`	`undefined,`
`460`	`"gpg",`
`461`	`"--list-secret-keys",`
`462`	`"--with-colons",`
`463`	`"--keyid-format=long"`
`464`	`);`
`465`
`466`	`const keyInfoMatch = listKeysOutput.match(`
`467`	`/sec:[^:]:[^:]:[^:]:([A-F0-9]+):.\nfpr:::::::::([A-F0-9]{40}):/`
`468`	`);`
`469`
`470`	`if (!keyInfoMatch) {`
`471`	`throw new Error("Failed to extract GPG Key ID and Fingerprint");`
`472`	`}`
`473`
`474`	`const keyId = keyInfoMatch[1];`
`475`	`gpgFingerprint = keyInfoMatch[2];`
`476`
`477`	`if (gpg_key.passphrase) {`
`478`	`// This is adummy command to unlock the key`
`479`	`// with passphrase to load it into agent`
`480`	`await sh_run(`
`481`	`1,`
`482`	`"bash",`
`483`	`"-c",`
`484`	`echo "dummy" \| gpg --batch --pinentry-mode loopback --passphrase '${gpg_key.passphrase}' --status-fd=2 -bsau ${keyId}`
`485`	`);`
`486`	`}`
`487`
`488`	`// Configure Git to use the extracted key`
`489`	`await sh_run(undefined, "git", "config", "user.signingkey", keyId);`
`490`	`await sh_run(undefined, "git", "config", "commit.gpgsign", "true");`
`491`	console.log(`GPG signing configured with key ID: ${keyId} `);
`492`	`} catch (e) {`
`493`	console.error(`Failure while setting GPG key: ${e} `);
`494`	`await delete_pgp_keys();`
`495`	`}`
`496`	`}`
`497`
`498`	`async function delete_pgp_keys() {`
`499`	`console.log("deleting gpg keys");`
`500`	`if (gpgFingerprint) {`
`501`	`await sh_run(`
`502`	`undefined,`
`503`	`"gpg",`
`504`	`"--batch",`
`505`	`"--yes",`
`506`	`"--pinentry-mode",`
`507`	`"loopback",`
`508`	`"--delete-secret-key",`
`509`	`gpgFingerprint`
`510`	`);`
`511`	`await sh_run(`
`512`	`undefined,`
`513`	`"gpg",`
`514`	`"--batch",`
`515`	`"--yes",`
`516`	`"--delete-key",`
`517`	`"--pinentry-mode",`
`518`	`"loopback",`
`519`	`gpgFingerprint`
`520`	`);`
`521`	`}`
`522`	`}`
`523`
`524`	`async function get_gh_app_token() {`
`525`	`const workspace = process.env["WM_WORKSPACE"];`
`526`	`const jobToken = process.env["WM_TOKEN"];`
`527`
`528`	`const baseUrl =`
`529`	`process.env["BASE_INTERNAL_URL"] ??`
`530`	`process.env["BASE_URL"] ??`
`531`	`"http://localhost:8000";`
`532`
`533`	const url = `${baseUrl}/api/w/${workspace}/github_app/token`;
`534`
`535`	`const response = await fetch(url, {`
`536`	`method: "POST",`
`537`	`headers: {`
`538`	`"Content-Type": "application/json",`
`539`	Authorization: `Bearer ${jobToken}`,
`540`	`},`
`541`	`body: JSON.stringify({`
`542`	`job_token: jobToken,`
`543`	`}),`
`544`	`});`
`545`
`546`	`if (!response.ok) {`
`547`	throw new Error(`Error: ${response.statusText}`);
`548`	`}`
`549`
`550`	`const data = await response.json();`
`551`
`552`	`return data.token;`
`553`	`}`
`554`
`555`	`function prependTokenToGitHubUrl(gitHubUrl: string, installationToken: string) {`
`556`	`if (!gitHubUrl \|\| !installationToken) {`
`557`	`throw new Error("Both GitHub URL and Installation Token are required.");`
`558`	`}`
`559`
`560`	`try {`
`561`	`const url = new URL(gitHubUrl);`
`562`
`563`	`// GitHub repository URL should be in the format: https://github.com/owner/repo.git`
`564`	`if (url.hostname !== "github.com") {`
`565`	`throw new Error(`
`566`	`"Invalid GitHub URL. Must be in the format 'https://github.com/owner/repo.git'."`
`567`	`);`
`568`	`}`
`569`
`570`	`// Convert URL to include the installation token`
`571`	return `https://x-access-token:${installationToken}@github.com${url.pathname}`;
`572`	`} catch (e) {`
`573`	`const error = e as Error;`
`574`	throw new Error(`Invalid URL: ${error.message}`);
`575`	`}`
`576`	`}`
`577`

`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`