apify-test-tools 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+This Actor has essentially 2 separate parts
+
+1. The Actor loads GitHub actions binary on build. When it is started, it will run `runner.ts` which spawns the GitHub actions server as a separate process. Then it only listens for migrations and does nothing else.
+2. The GitHub actions server binary (which we don't control) is then triggered by GitHub action and that subsequently calls `main.ts` (via calling it from `.github/workflows/apify.yaml` and `gha:start:build` command). This runs rest of the code in the files.
+
+## Run locally to test
+1. Choose if you want to emulate PR or push to master workflow.
+2. Copy appropriate example from `./example-github-events` to `INPUT.json`
+3. To mimic actual PR or push you care about, you should update the input
+    - PR: Update `pull_request.head.ref` (source branch of the PR), `repository.full_name`, `pull_request.base.sha`, `pull_request.head.sha`
+    - push: Update `ref`, `repository.full_name`
+4. Start the Actor with `TESTER_APIFY_TOKEN=<TOKEN> APIFY_TOKEN_${username}=<TOKEN> apify run -p` (possibly other apify users as well)
+
+## Testing real Actor
+Do anything to https://github.com/apify-projects/store-testing-repo-for-github
+
+## Runner on Apify
+We run GitHub Actions in Apify Actor that loads the GitHub Actions server binary. This server is then triggered by GitHub Actions and runs the rest of the code. There is one production forever running instance of this Actor (https://console.apify.com/admin/users/xRGg9iAfJSymqartk/actors/ANeZceuSfUd7i64qs/runs/hcTVcLB94TsOvPQFJ#log). If you need to update the build, just abort and resurrect the run with rebuilt `latest` version.
+
+For testing on platform, build the beta version (you can change the branch) and then resurrect the test task of the runner. Don't forget to abort the run after the test is done.
+
+### Multiple production runners
+It is possible to run multiple production runners at the same time. We might need this to scale up in the future since we are currently limited by only running one GitHub Action at a time.

package/bin/build.ts

@@ -0,0 +1,287 @@
+import { ACTOR_SOURCE_TYPES } from '@apify/consts';
+import { ApifyClient, Build } from 'apify-client';
+import type { ActorConfig, BuildData } from './types.js';
+import { getEnvVar } from './utils.js';
+
+type BuildPrActorOptions = {
+    buildTag?: string
+    versionNumber: string
+    gitRepoUrl: string
+    actorName: string
+}
+class ApifyBuilder {
+    // eslint-disable-next-line no-empty-function
+    private constructor(private readonly apifyClient: ApifyClient, private readonly actorName: string) { }
+
+    // Usually 'latest' but not necessarily (can be e.g. 'version-0')
+    getDefaultVersionAndTag = async (): Promise<{ defaultBuildNumber: string, defaultVersionNumber: string, defaultBuildTag: string }> => {
+        const actorClient = this.apifyClient.actor(this.actorName);
+        const actorInfo = await actorClient.get();
+
+        if (!actorInfo) {
+            throw new Error(`[${this.actorName}] not found. It is not published or we are missing token to access it privately or its name is misspelled`);
+        }
+
+        const defaultBuildTag = actorInfo.defaultRunOptions.build;
+        console.error(`Default build tag for ${this.actorName} is ${defaultBuildTag}`);
+
+        // We could technically allow this but in most cases this is accidentally set wrongly and there is a workaround
+        if (defaultBuildTag.match(/\d+\.\d+\.\d+/)) {
+            throw new Error(`[${this.actorName}] Default build is a build number, not a tag. While this could work, `
+                + `we want to have a default as tag so this is often an accidental misconfiguration from the dev`);
+        }
+        // I reported that buildNumber should probably not be optional
+        const defaultBuildNumber = actorInfo.taggedBuilds![defaultBuildTag].buildNumber!;
+        const defaultVersionNumber = defaultBuildNumber.match(/(\d+\.\d+)\.\d+/)![1];
+        console.error(`Default version for ${this.actorName} is ${defaultVersionNumber}`);
+
+        return { defaultBuildNumber, defaultVersionNumber, defaultBuildTag };
+    };
+
+    startActorBuild = async ({
+        buildTag,
+        versionNumber,
+        gitRepoUrl,
+    }: BuildPrActorOptions): Promise<BuildData> => {
+        const actorClient = this.apifyClient.actor(this.actorName);
+        const actorInfo = await actorClient.get();
+        if (!actorInfo) {
+            throw new Error(`No actor named '${this.actorName}' was found on the platform. If this`
+                + ' is unexpected, make sure the actor you are targeting is spelled the'
+                + ' same as the folder in the repository.');
+        }
+
+        // NOTE: I couldn't find this type, so I had to extract it :(
+        type ActorVersion = Parameters<ReturnType<typeof actorClient.version>['update']>[0];
+        const actorVersion: ActorVersion = {
+            buildTag,
+            versionNumber,
+            gitRepoUrl,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore: coudn't find this type either :(
+            sourceType: ACTOR_SOURCE_TYPES.GIT_REPO,
+        };
+
+        // Prepare version
+        const versionExists = !actorInfo.versions.find((version) => version.versionNumber === versionNumber);
+        if (versionExists) {
+            // create new version
+            await actorClient.versions().create(actorVersion);
+        } else {
+            const version = actorClient.version(versionNumber);
+            await version.update(actorVersion);
+        }
+
+        console.error(`[BUILD][${this.actorName}]: Will be built with version ${versionNumber}`);
+        console.error(`[BUILD][${this.actorName}]: ${JSON.stringify(actorVersion)}`);
+
+        // We also get back actId so the testing actor can both match by actor ID and name
+        const { id, actId, buildNumber } = await actorClient.build(versionNumber);
+
+        console.error(`[BUILD][${this.actorName}]: Build ${id} (${versionNumber}) has started`);
+        return { buildId: id, actorId: actId, buildNumber, actorName: this.actorName };
+    };
+
+    waitForBuildToFinish = async (buildId: string, actorName: string): Promise<Build> => {
+        console.error(`[BUILD][${actorName}]: Waiting for build ${buildId} to finish`);
+        const build = await this.apifyClient.build(buildId).waitForFinish();
+        const versionNumber = build.buildNumber;
+        if (build.status === 'FAILED' || build.status === 'TIMED-OUT') {
+            const message = `[BUILD][${actorName}]: Build ${buildId} (${versionNumber}) failed. `
+                + `Not continuing with other builds and tests.`;
+            console.warn(`D€LIV€RY_$L&CK: Webhook-to-build: ${message}`);
+            throw new Error(message);
+        }
+
+        console.error(`[BUILD][${actorName}]: Build ${build.id} (${versionNumber}) finished successfully.`);
+        return build;
+    };
+
+    /**
+    * Create ApifyBuilder with actor owner's token
+    */
+    static fromActorName = (actorName: string): ApifyBuilder => {
+        const username = actorName.split('/')[0];
+        // GitHib secrets only allow word characters (alphanum + underscore)
+        const usernameInGitHubSecretsFormat = username.replaceAll(/\W/g, '_').toUpperCase();
+        const usernameEnvVar = `APIFY_TOKEN_${usernameInGitHubSecretsFormat}`;
+        const token = process.env[usernameEnvVar];
+        if (!token) {
+            throw new Error(`Cannot find Apify API token for username: ${username}. `
+                + `Have you set secret env var to this GitHub repo with key: ${usernameEnvVar}?`);
+        }
+        const apifyClient = new ApifyClient({ token });
+        const builder = new ApifyBuilder(apifyClient, actorName);
+        return builder;
+    };
+
+    /**
+     * Deletes build of all versions. Apify API doesn't allow to delete default build and we explicitly skip it
+     * We delete devel builds faster because we used the for every PR until recently so just to get rid of them faster
+     */
+    async deleteOldBuilds(): Promise<void> {
+        // Even though we don't version our current Actors, if we ever such Actors to GitHub CI, we would accidentally delete old supported versions
+        // This hardcoded solution is not ideal, but it should prevent most imaginable cases
+        // All currently popular versioned Actors use `version-${number}` format
+        const PROTECTED_TAGS_PREFIX = ['latest', 'v-', 'version', 'v0', 'v1', 'v2', 'v3', 'v4', 'v5', 'v6', 'v7', 'v8', 'v9'];
+
+        // We don't want to be too short because we might to debug something
+        // but also not too long because it increases the risk of users using outdated versions
+        const DEFAULT_DAYS_BACK_PROD_VERSIONS = 30;
+        const DEFAULT_DAYS_BACK_DEVEL = 7;
+
+        const actorInfo = (await this.apifyClient.actor(this.actorName).get())!;
+
+        // 'devel' used to be hardcoded for testing version 0.99, once we get rid of this tag everywhere, we can remove this code
+        const taggedDevelBuildNumber: string | undefined = actorInfo.taggedBuilds!.devel?.buildNumber;
+
+        const allTags = Object.keys(actorInfo.taggedBuilds ?? {});
+        const protectedTags = allTags.filter((tag) => PROTECTED_TAGS_PREFIX.some((prefix) => tag.startsWith(prefix)));
+        const protectedBuildNumbers = protectedTags.map((tag) => ({ buildNumber: actorInfo.taggedBuilds![tag]!.buildNumber, tag }));
+
+        const { items } = (await this.apifyClient.actor(this.actorName).builds().list());
+
+        // Deleting default build throws an error, so we skip it
+        const { defaultBuildNumber, defaultBuildTag } = await ApifyBuilder.fromActorName(this.actorName).getDefaultVersionAndTag();
+
+        const daysAgoUnixProd = Date.now() - DEFAULT_DAYS_BACK_PROD_VERSIONS * 24 * 60 * 60 * 1000;
+        const daysAgoUnixDevel = Date.now() - DEFAULT_DAYS_BACK_DEVEL * 24 * 60 * 60 * 1000;
+
+        // Fixing API client missing buildNumber field
+        type CorrectBuildColletionItem = typeof items[0] & { buildNumber: string };
+        const buildsToDelete = (items as CorrectBuildColletionItem[]).filter((build) => {
+            if (build.buildNumber === defaultBuildNumber) {
+                console.error(`[DELETE OLD BUILDS][${this.actorName}]: Skipping default build ${defaultBuildNumber} (${defaultBuildTag}). `
+                    + `We never delete default builds`);
+                return false;
+            }
+
+            const protectedTagFound = protectedBuildNumbers.find((protectedBuildNumber) => protectedBuildNumber.buildNumber === build.buildNumber);
+            if (protectedTagFound) {
+                console.error(`[DELETE OLD BUILDS][${this.actorName}]: Skipping protected build ${protectedTagFound.buildNumber} (${protectedTagFound.tag}).`);
+                return false;
+            }
+
+            if (taggedDevelBuildNumber && build.buildNumber === taggedDevelBuildNumber) {
+                const shouldDeleteDevelBuild = build.startedAt.getTime() < daysAgoUnixDevel;
+                if (shouldDeleteDevelBuild) {
+                    console.error(`[DELETE OLD BUILDS][${this.actorName}]: Removing olf devel build ${taggedDevelBuildNumber}.`);
+                }
+                return shouldDeleteDevelBuild;
+            }
+            return build.startedAt.getTime() < daysAgoUnixProd;
+        });
+
+        console.error(`[DELETE OLD BUILDS][${this.actorName}]: Deleting ${buildsToDelete.length} old builds that are non-default and `
+            + `older than 30 days from total ${items.length}`);
+        for (const build of buildsToDelete) {
+            await this.apifyClient.build(build.id).delete();
+        }
+    }
+}
+
+type RunBuildsOptions = {
+    actorConfigs: ActorConfig[]
+    isLatest?: boolean
+    repoUrl: string
+    branch: string
+    dryRun: boolean
+}
+
+export const runBuilds = async ({
+    repoUrl,
+    branch,
+    actorConfigs,
+    isLatest = false,
+    dryRun,
+}: RunBuildsOptions) => {
+    const buildConfigs: BuildPrActorOptions[] = [];
+
+    const circleActors = isLatest ? await findCircleApifyManaged(actorConfigs) : [];
+
+    for (const { actorName, folder } of actorConfigs.concat(circleActors)) {
+        let versionNumber: string;
+        let buildTag: string | undefined;
+
+        if (isLatest) {
+            const { defaultVersionNumber, defaultBuildTag } = await ApifyBuilder.fromActorName(actorName).getDefaultVersionAndTag();
+            versionNumber = defaultVersionNumber;
+            buildTag = defaultBuildTag;
+        } else {
+            versionNumber = '0.99';
+        }
+
+        // Depending on if these are miniactors or standaloneActors
+        let gitRepoUrl = `${repoUrl}#${branch}`;
+        if (folder) {
+            gitRepoUrl = `${gitRepoUrl}:${folder}`;
+        }
+        buildConfigs.push({ actorName, gitRepoUrl, versionNumber, buildTag });
+    }
+
+    if (dryRun) {
+        return buildConfigs;
+    }
+
+    const startedBuilds = await Promise.all(buildConfigs.map(async (buildConfig) => {
+        const builder = ApifyBuilder.fromActorName(buildConfig.actorName);
+        const buildData = await builder.startActorBuild(buildConfig);
+        return buildData;
+    }));
+
+    await Promise.all(startedBuilds.map(async (buildData) => {
+        const builder = ApifyBuilder.fromActorName(buildData.actorName);
+        await builder.waitForBuildToFinish(buildData.buildId, buildData.actorName);
+    }));
+
+    return startedBuilds;
+};
+
+export const deleteOldBuilds = async (actorConfigs: ActorConfig[]) => {
+    for (const { actorName } of actorConfigs) {
+        await ApifyBuilder.fromActorName(actorName).deleteOldBuilds();
+    }
+};
+
+/**
+ * We will read all Actors in the circ_le account and build those that match by name pattern
+ * There are many ways to approach this, a more robust one would be to have a map of Actors
+ * which would allow to have more than one special user per Actor
+ * But since that use-case might never be needed, I went with the simplest solution that doesn't require maintaining the map
+ * NOTE: One issue is that if any Actor is renamed, we will not match it in the circ_le account nor throw any error
+ */
+const findCircleApifyManaged = async (actorConfigs: ActorConfig[]): Promise<ActorConfig[]> => {
+    // This token is hardcoded in the runner Actor, locally you have to inject it
+    const client = new ApifyClient({ token: getEnvVar('APIFY_TOKEN_CIRC_LE') });
+
+    const { items: circleActors } = await client.actors().list();
+
+    const actorsToBuild = circleActors.map<ActorConfig | undefined>((circleActor) => {
+        // They prefix all with apify-managed---, I communicated with Jacques to keep doing that
+        let actorConfigFound = actorConfigs.find((actorConfig) => circleActor.name.replace('apify-managed---', '') === actorConfig.actorName.split('/')[1]);
+
+        // Hack for bad naming of circ_le/apify-managed-google-search, we don't want to rename now to break customers
+        if (!actorConfigFound && circleActor.name === 'apify-managed-google-search') {
+            actorConfigFound = actorConfigs.find((actorConfig) => actorConfig.actorName.split('/')[1] === 'google-search-scraper');
+        }
+
+        if (actorConfigFound) {
+            return {
+                // We point the circle Actor to the repo folder
+                actorName: `${circleActor.username}/${circleActor.name}`,
+                folder: actorConfigFound.folder,
+                isStandalone: actorConfigFound.isStandalone,
+            };
+        }
+        return undefined;
+    }).filter((config) => config !== undefined);
+
+    console.error(`Found ${actorsToBuild.length} circ_le actors that match Actors we built out of total ${circleActors.length} circ_le actors`);
+    console.error(`All circ_le actors: ${circleActors.map((actor) => actor.name).join(', ')}`);
+    console.error(`circ_le Actors to build: ${actorsToBuild.map((actor) => actor.actorName).join(', ')}`);
+
+    if (actorsToBuild.length === 0) {
+        console.error('No circ_le actors to build');
+    }
+    return actorsToBuild;
+};

package/bin/consts.ts

@@ -0,0 +1,6 @@
+// Technically, upgrades in shared or packages might not need impact every actor
+// but we cannot really know that
+export const DEFAULT_BUILD_ALL_FOLDERS = ['code', 'shared', 'packages'];
+
+export const PERSISTED_GH_JOBS_KVS_ID = 'XIBdO8EJePdD0KiAI';
+export const MINIACTORS_LIST_STORE_ID = 'ftXklt2f2mN30Oc3y';

package/bin/git.ts

@@ -0,0 +1,56 @@
+import { Commit, Config } from './types';
+import { spawnCommandInGhWorkspace } from './utils.js';
+
+const GIT_LOG_FORMAT = `{"sha":"%H","author":"%aN<%aE>","date":"%aD","message":"%s"}`;
+
+export const getBranchLastCommit = (branch: string): Commit => {
+    const lastCommit = JSON.parse(spawnCommandInGhWorkspace(`git log -1 --pretty=format:'${GIT_LOG_FORMAT}' ${branch}`)) as Commit;
+    return lastCommit;
+};
+
+export const getChangedFiles = (commits: Commit[]) => {
+    const changedFiles = commits.length === 1
+        ? spawnCommandInGhWorkspace(`git show --pretty='format:' --name-only ${commits[0].sha}`)
+        : spawnCommandInGhWorkspace(`git diff --name-only ${commits[0].sha}..${commits[commits.length - 1].sha}`);
+    return changedFiles.split('\n');
+};
+
+export const getCommits = ({
+    sourceBranch,
+    targetBranch,
+    baseCommit: baseCommitSha,
+}: Config): Commit[] => {
+    const targetBranchCommit = getBranchLastCommit(targetBranch);
+    const sourceBranchCommit = getBranchLastCommit(sourceBranch);
+    let baseCommit: Commit | undefined;
+    if (baseCommitSha) {
+        try {
+            baseCommit = getCommitInfo(baseCommitSha);
+        } catch (err) {
+            console.warn(`Failed to get base commit "${baseCommitSha}", it will not be used: ${err}`);
+        }
+    }
+    // const baseCommit = baseCommitSha !== undefined ?  : undefined;
+    // const gitOutputFormat = '{"sha":"%H","author":"%aN<%aE>","date":"%aD","message":"%f"}';
+    // console.log(`git log --pretty=format:"${gitOutputFormat}" ${targetBranch}..${sourceBranch}`);
+    // return [];
+    const base = getBaseCommit(sourceBranchCommit, targetBranchCommit);
+    const commitsStrings = spawnCommandInGhWorkspace(`git log --pretty=format:'${GIT_LOG_FORMAT}' ${base.sha}..${sourceBranchCommit.sha}`)
+        .split('\n');
+    const commits = JSON.parse(`[${commitsStrings.join(',')}]`) as Commit[];
+    commits.reverse();
+    const baseCommitIndex = baseCommit
+        ? commits.findIndex(({ sha }) => sha === baseCommit.sha)
+        : -1;
+    return commits.slice(baseCommitIndex + 1);
+};
+
+export const getBaseCommit = (target: Commit, source: Commit): Commit => {
+    const baseCommitSha = spawnCommandInGhWorkspace(`git merge-base ${target.sha} ${source.sha}`);
+    const baseCommit = getCommitInfo(baseCommitSha);
+    return baseCommit;
+};
+
+export const getCommitInfo = (commitSha: string): Commit => {
+    return JSON.parse(spawnCommandInGhWorkspace(`git log -1 --pretty=format:'${GIT_LOG_FORMAT}' ${commitSha}`));
+};

package/bin/github.ts

@@ -0,0 +1,75 @@
+import fs from 'fs/promises';
+import { Commit, GitHubEventPush } from './types';
+import { spawnCommandInGhWorkspace } from './utils.js';
+
+export const getPushData = async (path: string) => {
+    const event = await loadGitHubEvent(path);
+    const branch = event.ref.replace('refs/heads/', '');
+    const {
+        commits: ghCommits,
+        repository: { ssh_url: repoUrl, name },
+    } = event;
+    const commits: Commit[] = ghCommits.map(({ author, message, id, timestamp }) => ({
+        author: author.username,
+        sha: id,
+        message,
+        date: timestamp,
+    }));
+    const changedFiles = getChangedFiles(event);
+    const changelog = getChangelogChanges(changedFiles, event);
+    return {
+        branch,
+        commits,
+        changedFiles,
+        repoUrl,
+        changelog,
+        repository: name,
+    };
+};
+
+export const loadGitHubEvent = async (path: string): Promise<GitHubEventPush> => {
+    const pushEvent = JSON.parse((await fs.readFile(path)).toString()) as GitHubEventPush;
+    return pushEvent;
+};
+
+const getChangedFiles = ({ after, before }: GitHubEventPush): string[] => {
+    const changedFiles = spawnCommandInGhWorkspace(`git diff --name-only ${after}..${before}`);
+    return changedFiles.split('\n');
+};
+
+export const getChangelogChanges = (
+    changedFiles: string[],
+    event: GitHubEventPush,
+): string | null => {
+    const changelogPath = 'CHANGELOG.md';
+    if (!changedFiles.includes(changelogPath)) {
+        return null;
+    }
+    const { after, before } = event;
+    const diff = spawnCommandInGhWorkspace('git', [
+        'diff',
+        before,
+        after,
+        '--',
+        changelogPath,
+    ]);
+
+    const added: string[] = [];
+    let startedChangelog = false;
+    for (const line of diff.split('\n')) {
+        // We should already get only files we care about from getLastCommitDiffForFile but better to double check
+        if (line.startsWith('+++') && line.toLowerCase().includes(changelogPath.toLowerCase())) {
+            startedChangelog = true;
+            continue;
+        }
+        if (startedChangelog) {
+            if (line.startsWith('diff')) {
+                break;
+            }
+            if (line.startsWith('+')) {
+                added.push(line.slice(1).trim());
+            }
+        }
+    }
+    return added.join('\n').trim();
+};

package/bin/main.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import process from 'process';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+import {
+    getRepoActors,
+    getChangedActors,
+    spawnCommandInGhWorkspace,
+} from './utils.js';
+import { runBuilds } from './build.js';
+import { getChangedFiles, getCommits } from './git.js';
+import { getPushData } from './github.js';
+import { notifyToSlack } from './slack.js';
+import { reportTestRestuls } from './test-report.js';
+
+const buildOptions = (y: yargs.Argv) => {
+    return y
+        .option('target-branch', {
+            type: 'string',
+            demandOption: true,
+        })
+        .option('source-branch', {
+            type: 'string',
+            demandOption: true,
+        })
+        .option('base-commit', {
+            type: 'string',
+        });
+};
+
+await yargs()
+    .scriptName('public-actors-utils')
+    .option('dry-run', {
+        type: 'boolean',
+        default: false,
+    })
+    .command('get-commits', '', buildOptions, (args) => {
+        const commits = getCommits(args);
+        console.log(JSON.stringify(commits));
+    })
+    .command('get-latest-commit', '', buildOptions, (args) => {
+        const commits = getCommits(args);
+        if (commits.length > 0) {
+            console.log(JSON.stringify(commits[commits.length - 1]));
+        }
+    })
+    .command('get-changed-files', '', buildOptions, (args) => {
+        const commits = getCommits(args);
+        const changedFiles = getChangedFiles(commits);
+        console.log(JSON.stringify(changedFiles));
+    })
+    .command('get-actor-configs', '', (_) => _, async () => {
+        const actorConfigs = await getRepoActors();
+        console.log(JSON.stringify(actorConfigs));
+    })
+    .command('get-affected-actors', '', buildOptions, async (args) => {
+        const commits = getCommits(args);
+        const changedFiles = getChangedFiles(commits);
+        const actorConfigs = await getRepoActors();
+        const { actorsChanged } = getChangedActors({ filepathsChanged: changedFiles, actorConfigs, isLatest: false });
+        console.log(JSON.stringify(actorsChanged));
+    })
+    .command(
+        'report-tests',
+        '',
+        (args) => args
+            .option('report-file', { type: 'string', demandOption: true })
+            .option('job-url', { type: 'string' })
+            .option('workflow-name', { type: 'string' })
+            .option('repository', { type: 'string' }),
+        async (args) => {
+            await reportTestRestuls(args);
+        })
+    .command(
+        'build',
+        '',
+        (args) => buildOptions(args)
+            .option('dry-run', { type: 'boolean', default: false }),
+        async (args) => {
+            const commits = getCommits(args);
+            const changedFiles = getChangedFiles(commits);
+            const actorConfigs = await getRepoActors();
+            const { actorsChanged } = getChangedActors({
+                filepathsChanged: changedFiles,
+                actorConfigs,
+            });
+            // https://github.com/apify-store/google-maps#:actors/lukaskrivka_google-maps-with-contact-details
+            // git@github.com:apify-store/google-maps#:actors/lukaskrivka_google-maps-with-contact-details
+            const repoUrl = spawnCommandInGhWorkspace(`git remote get-url origin`)
+                .replace(/^https:\/\/github\.com\//, 'git@github.com:');
+
+            const builds = await runBuilds({
+                repoUrl,
+                actorConfigs: actorsChanged,
+                branch: args.sourceBranch.replace('origin/', ''),
+                dryRun: args.dryRun,
+            });
+            console.log(JSON.stringify(builds));
+        })
+    .command(
+        'release',
+        '',
+        (args) => args
+            .option('push-event-path', { type: 'string', demandOption: true })
+            .option('dry-run', { type: 'boolean', default: false }),
+        async (args) => {
+            const {
+                branch,
+                changedFiles,
+                repoUrl,
+                commits,
+                changelog,
+                repository,
+            } = await getPushData(args.pushEventPath);
+            const isLatest = true;
+            const actorConfigs = await getRepoActors();
+            const { actorsChanged } = getChangedActors({
+                filepathsChanged: changedFiles,
+                actorConfigs,
+                isLatest,
+            });
+            const { dryRun } = args;
+            const builds = await runBuilds({
+                isLatest,
+                repoUrl,
+                actorConfigs: actorsChanged,
+                branch,
+                dryRun,
+            });
+            console.error(JSON.stringify(builds));
+
+            // TODO: build circle actors
+            await notifyToSlack({
+                changedFiles,
+                commits,
+                changelog,
+                repository,
+                dryRun,
+            });
+        })
+    .strictCommands()
+    .demandCommand(1, 'Command is required')
+    .parse(hideBin(process.argv));

package/bin/slack.ts

@@ -0,0 +1,72 @@
+import { WebClient } from '@slack/web-api';
+import { Commit } from './types';
+import { getEnvVar } from './utils.js';
+
+type NotifyToSlackOptions = {
+    repository: string
+    changedFiles: string[]
+    changelog: string | null
+    commits: Commit[]
+    dryRun: boolean
+}
+
+export const notifyToSlack = async ({
+    changedFiles,
+    commits,
+    changelog,
+    repository,
+    dryRun,
+}: NotifyToSlackOptions) => {
+    const slack = new WebClient(getEnvVar('SLACK_TOKEN_RELEASES_BOT'));
+
+    if (!changelog) {
+        console.warn('No new changelog entries found, haven\'t you forgotten to update it?');
+    }
+
+    let shortMessage = `${repository}: new release:\n`;
+
+    // This one is just for broader public that only cares about public facing changes
+    if (changelog) {
+        console.error(`New changelog entries: ${changelog}`);
+        shortMessage += `Changelog:\n\n${changelog}\n`;
+        const channel = '#delivery-public-actors';
+        console.error(`Sending slack message to channel: ${channel}. Message: ${shortMessage}`);
+        if (!dryRun) {
+            await slack.chat.postMessage({
+                channel,
+                text: shortMessage,
+            });
+        }
+    }
+
+    const commitsMessage = `${commits.map(({ author, message }, index) => `  ${index + 1} Commit message: ${message}\n  Author: ${author}.`).join('\n')}`;
+    const changedFilesMessage = `Files changed: ${changedFiles.join(', ')}`;
+    const longMessage = `${shortMessage}\nCommits:\n\n${commitsMessage}\n\n${changedFilesMessage}`;
+
+    // This one is for devs and project managers that need to know more details
+    const notifChannel = `#notif-${repository.toLowerCase()}`;
+    console.error(`Sending slack message to channel: ${notifChannel}. Message: ${longMessage}`);
+    if (!dryRun) {
+        await slack.chat.postMessage({
+            text: longMessage,
+            channel: notifChannel,
+        });
+    }
+};
+
+export const sendSlackMessage = async (
+    channel: string,
+    text: string,
+    blocks: string[],
+    token: string,
+) => {
+    const slack = new WebClient(token);
+    const { ts } = await slack.chat.postMessage({ text, channel });
+    if (blocks.length > 0 && ts) {
+        await slack.chat.postMessage({
+            channel,
+            thread_ts: ts,
+            blocks: blocks.map((t) => ({ text: { type: 'mrkdwn', text: t }, type: 'section' })),
+        });
+    }
+};