bdy 1.22.84-dev → 1.22.84-dev-buddy-auth-me-869dq96dc

package/distTs/detect-rules.json

@@ -0,0 +1,351 @@
+{
+  "BUILD": {
+    "files": ["package.json", "requirements.txt", "pyproject.toml", "go.mod", "Gemfile", "pom.xml", "build.gradle", "build.gradle.kts", "Cargo.toml", "composer.json", "pubspec.yaml", "Makefile", "CMakeLists.txt"],
+    "packages": ["eslint", "oxlint", "@oxlint/cli", "@biomejs/biome", "prettier", "stylelint", "xo", "standard", "typescript"]
+  },
+  "DOCKERFILE": {
+    "files": ["Dockerfile", "Containerfile", "compose.yaml", "compose.yml", "docker-compose.yml", "docker-compose.yaml"]
+  },
+  "DOCKER_PUSH": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "RUN_DOCKER_CONTAINER": {
+    "files": ["Dockerfile", "Containerfile", "compose.yaml", "compose.yml", "docker-compose.yml"]
+  },
+  "DOCKERFILE_LINTER": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "DOCKER": {
+    "files": ["Dockerfile", "Containerfile", "compose.yaml", "compose.yml", "docker-compose.yml"]
+  },
+  "DOCKER_BUILD_MULTI_ARCH": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "NATIVE_BUILD_DOCKER_CLI": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "PROMOTE_IMAGE": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "KUBERNETES_APPLY": {
+    "files": ["k8s/", "kubernetes/", "kustomization.yaml", "kustomization.yml", "Kustomization"],
+    "packages": ["@aws-sdk/client-eks", "@google-cloud/container", "@azure/arm-containerservice"]
+  },
+  "KUBERNETES_SET_IMAGE": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "KUBERNETES_RUN_POD": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "KUBERNETES_RUN_JOB": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "KUBERNETES_CLI": {
+    "files": ["k8s/", "kubernetes/", "kustomization.yaml", "kustomization.yml", "Kustomization"],
+    "packages": ["@kubernetes/client-node", "@aws-sdk/client-eks", "@google-cloud/container", "@azure/arm-containerservice"]
+  },
+  "HELM": {
+    "files": ["Chart.yaml", "helm/", "charts/"]
+  },
+  "WAIT_FOR_APPLY": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "AMAZON_S3": {
+    "packages": ["aws-sdk", "@aws-sdk/client-s3"]
+  },
+  "AWS_CLI": {
+    "files": ["buildspec.yml"],
+    "packages": ["aws-sdk", "@aws-sdk/*"]
+  },
+  "AWS_CLI_2": {
+    "files": ["buildspec.yml"],
+    "packages": ["aws-sdk", "@aws-sdk/*"]
+  },
+  "AWS_LAMBDA_DEPLOY": {
+    "files": ["serverless.yml", "serverless.yaml", "samconfig.toml", "sam-template.yaml"],
+    "packages": ["aws-sdk", "@aws-sdk/client-lambda"]
+  },
+  "LAMBDA": {
+    "files": ["serverless.yml", "samconfig.toml"],
+    "packages": ["@aws-sdk/client-lambda"]
+  },
+  "AWS_ECS": {
+    "files": ["ecs-task-definition.json", "task-definition.json"],
+    "packages": ["@aws-sdk/client-ecs"]
+  },
+  "CODE_DEPLOY": {
+    "files": ["appspec.yml", "appspec.yaml"]
+  },
+  "ELASTIC_BEANSTALK": {
+    "files": [".elasticbeanstalk/"]
+  },
+  "MONITOR": {
+    "files": [".elasticbeanstalk/"]
+  },
+  "AWS_CLOUD_FORMATION": {
+    "files": ["cloudformation/"]
+  },
+  "CLOUD_FRONT": {
+    "packages": ["aws-sdk", "@aws-sdk/client-cloudfront"]
+  },
+  "CODE_PIPELINE": {
+    "files": ["buildspec.yml"]
+  },
+  "AWS_APP_RUNNER_DEPLOY": {
+    "packages": ["@aws-sdk/client-apprunner"]
+  },
+  "AWS_APP_RUNNER_MONITOR": {
+    "packages": ["@aws-sdk/client-apprunner"]
+  },
+  "AWS_CDK_CLI": {
+    "files": ["cdk.json"],
+    "packages": ["aws-cdk-lib", "aws-cdk"]
+  },
+  "DOWNLOAD_S3": {
+    "packages": ["aws-sdk", "@aws-sdk/client-s3"]
+  },
+  "GOOGLE_CLOUD_STORAGE": {
+    "packages": ["@google-cloud/storage"]
+  },
+  "GOOGLE_CLOUD_CLI": {
+    "packages": ["@google-cloud/*"]
+  },
+  "GOOGLE_APP_DEPLOY": {
+    "files": ["app.yaml"]
+  },
+  "GOOGLE_FUNCTION_DEPLOY": {
+    "files": ["firebase.json"],
+    "packages": ["@google-cloud/functions-framework"]
+  },
+  "GOOGLE_FUNCTION_INVOKE": {
+    "packages": ["@google-cloud/functions-framework"]
+  },
+  "GOOGLE_CLOUD_RUN_DEPLOY": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "GOOGLE_CDN_INVALIDATE": {
+    "packages": ["@google-cloud/compute"]
+  },
+  "FIREBASE": {
+    "files": ["firebase.json", ".firebaserc"],
+    "packages": ["firebase", "firebase-admin"]
+  },
+  "DOWNLOAD_GCS": {
+    "packages": ["@google-cloud/storage"]
+  },
+  "AZURE": {
+    "files": ["azure-pipelines.yml"]
+  },
+  "AZURE_CLI": {
+    "files": ["azure-pipelines.yml"],
+    "packages": ["@azure/*"]
+  },
+  "AZURE_STORAGE": {
+    "packages": ["@azure/storage-blob"]
+  },
+  "HEROKU": {
+    "files": ["Procfile"]
+  },
+  "HEROKU_CLI": {
+    "files": ["Procfile"]
+  },
+  "NETLIFY": {
+    "files": ["netlify.toml"]
+  },
+  "TERRAFORM": {
+    "files": ["*.tf", "*.tofu", "terraform/", ".terraform/"]
+  },
+  "ANDROID_SIGN": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "ANDROID_SIGN_BUNDLE": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "ANDROID_PUBLISH_APK": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "ANDROID_PUBLISH_APP_BUNDLE": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "FASTLANE_ANDROID": {
+    "files": ["fastlane/", "android/"]
+  },
+  "NATIVE_BUILD_MAC": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_VM": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_SIGN": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_DEPLOY": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_REACT": {
+    "files": ["ios/"],
+    "packages": ["react-native"]
+  },
+  "NATIVE_BUILD_MAC_CORDOVA": {
+    "packages": ["cordova"]
+  },
+  "NATIVE_BUILD_MAC_FASTLANE": {
+    "files": ["fastlane/Fastfile"]
+  },
+  "NATIVE_BUILD_MAC_FLUTTER": {
+    "files": ["pubspec.yaml", "ios/"]
+  },
+  "PLAYWRIGHT": {
+    "files": ["playwright.config.*"],
+    "packages": ["@playwright/test", "playwright"]
+  },
+  "CYPRESS": {
+    "files": ["cypress.config.*", "cypress/"],
+    "packages": ["cypress"]
+  },
+  "STORYBOOK": {
+    "files": [".storybook/"],
+    "packages": ["storybook", "@storybook/react"]
+  },
+  "LIGHTHOUSE": {
+    "packages": ["lighthouse"]
+  },
+  "JMETER_CLI": {
+    "files": ["*.jmx"]
+  },
+  "SNYK_CLI": {
+    "files": [".snyk"],
+    "packages": ["snyk"]
+  },
+  "STACK_HAWK_CLI": {
+    "files": ["stackhawk.yml"]
+  },
+  "BLACKFIRE_PHP": {
+    "packages": ["blackfire/php-sdk"]
+  },
+  "BLACKFIRE_PYTHON": {
+    "packages": ["blackfire"]
+  },
+  "BLACKFIRE_GO": {
+    "packages": ["github.com/blackfireio/go-blackfire"]
+  },
+  "SENTRY": {
+    "packages": ["@sentry/node", "@sentry/browser", "@sentry/react"]
+  },
+  "SENTRY_ENTERPRISE": {
+    "packages": ["@sentry/node", "@sentry/browser"]
+  },
+  "NEW_RELIC": {
+    "packages": ["newrelic"]
+  },
+  "NEW_RELIC_CLI": {
+    "packages": ["newrelic"]
+  },
+  "DATADOG": {
+    "packages": ["dd-trace", "datadog-metrics"]
+  },
+  "DATADOG_STATUS_CHECK": {
+    "packages": ["dd-trace"]
+  },
+  "ROLLBAR": {
+    "packages": ["rollbar"]
+  },
+  "HONEYBADGER": {
+    "packages": ["@honeybadger-io/js"]
+  },
+  "BUGSNAG": {
+    "packages": ["@bugsnag/js", "@bugsnag/node"]
+  },
+  "RAYGUN": {
+    "packages": ["raygun"]
+  },
+  "LOGGLY": {
+    "packages": ["node-loggly-bulk", "winston-loggly-bulk"]
+  },
+  "DO_SPACES": {
+    "packages": ["aws-sdk", "@aws-sdk/client-s3"]
+  },
+  "GIT_HUB_RELEASE": {
+    "files": [".github/workflows/"]
+  },
+  "GIT_HUB_CLI": {
+    "files": [".github/workflows/"]
+  },
+  "GIT_LAB_CLI": {
+    "files": [".gitlab-ci.yml"]
+  },
+  "SHOPIFY": {
+    "files": ["shopify.app.toml"],
+    "packages": ["@shopify/shopify-api"]
+  },
+  "SHOPIFY_CLI": {
+    "files": ["shopify.app.toml"],
+    "packages": ["@shopify/cli"]
+  },
+  "SHOPIFY_THEMEKIT_CLI": {
+    "files": ["shopify.app.toml"]
+  },
+  "WP_CLI": {
+    "files": ["wp-config.php", "wp-content/"]
+  },
+  "CONTENTFUL_CLI": {
+    "packages": ["contentful", "contentful-management"]
+  },
+  "MYSQL_CLI": {
+    "packages": ["mysql", "mysql2", "sequelize", "typeorm", "prisma", "drizzle-orm"]
+  },
+  "CLOUDFLARE": {
+    "files": ["wrangler.toml", "wrangler.json", "wrangler.jsonc"],
+    "packages": ["wrangler"]
+  },
+  "NATIVE_BUILD_WINDOWS": {
+    "files": ["*.sln", "*.slnx", "*.csproj"]
+  },
+  "GIT_CRYPT_UNLOCK": {
+    "files": [".git-crypt/"]
+  },
+  "GIT_CRYPT_LOCK": {
+    "files": [".git-crypt/"]
+  },
+  "JIRA_BUILD": {
+    "files": [".jira/"]
+  },
+  "JIRA_DEPLOYMENT": {
+    "files": [".jira/"]
+  },
+  "NPM_PUBLISH": {
+    "files": ["package.json"]
+  },
+  "DOCTL": {
+    "files": [".do/"],
+    "packages": ["digitalocean", "do-wrapper"]
+  },
+  "DIGITAL_OCEAN_CDN": {
+    "files": [".do/"],
+    "packages": ["digitalocean", "do-wrapper"]
+  },
+  "SLACK": {
+    "packages": ["@slack/web-api", "@slack/bolt", "@slack/webhook"]
+  },
+  "DISCORD2": {
+    "packages": ["discord.js", "discord-webhook-node"]
+  },
+  "MICROSOFT_TEAMS": {
+    "packages": ["botbuilder", "@microsoft/teams-js"]
+  },
+  "TELEGRAM": {
+    "packages": ["telegraf", "node-telegram-bot-api", "grammy"]
+  },
+  "EMAIL": {
+    "packages": ["nodemailer", "@sendgrid/mail", "postmark", "mailgun-js"]
+  },
+  "POWERSHELL": {
+    "files": ["*.ps1", "*.psm1"]
+  },
+  "GHOST_INSPECTOR_CLI": {
+    "packages": ["ghost-inspector"]
+  },
+  "BACKBLAZE_B2": {
+    "packages": ["backblaze-b2"]
+  }
+}

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.22.84-dev",
+  "version": "1.22.84-dev-buddy-auth-me-869dq96dc",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",

package/distTs/src/command/pipeline/run/apply.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const input_1 = __importDefault(require("../../../input"));
+const output_1 = __importDefault(require("../../../output"));
+const pipeline_1 = require("../../../types/pipeline");
+const commandPipelineRunApply = (0, utils_1.newCommand)('apply', texts_1.DESC_COMMAND_PIPELINE_RUN_APPLY);
+commandPipelineRunApply.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPipelineRunApply.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPipelineRunApply.option('-n, --no-wait', texts_1.OPTION_PIPELINE_RUN_NO_WAIT);
+commandPipelineRunApply.argument('<identifier>', texts_1.OPTION_PIPELINE_RUN_ARGUMENT);
+commandPipelineRunApply.argument('<run-id>', texts_1.OPTION_PIPELINE_RUN_ID);
+commandPipelineRunApply.argument('<run-action-id>', texts_1.OPTION_PIPELINE_RUN_ACTION_ID);
+commandPipelineRunApply.option('-v,--variable <variables...>', texts_1.OPTION_PIPELINE_RUN_VAR);
+commandPipelineRunApply.addHelpText('after', texts_1.EXAMPLE_PIPELINE_RUN_APPLY);
+commandPipelineRunApply.action(async (identifier, runId, runActionId, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const rid = input_1.default.pipelineRunId(runId);
+    const variables = input_1.default.pipelineRunVariable(options.variable || [], false);
+    const client = input_1.default.restApiTokenClient();
+    const data = await client.getPipelineByIdentifier(workspace, project, identifier);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (!data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    if (!data.pipeline_id) {
+        output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+    }
+    const a = await client.getPipelineRunActionExecution(workspace, project, data.pipeline_id, rid, runActionId);
+    let type;
+    if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY) {
+        type = 'APPLY';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VT_SESSION) {
+        type = 'APPROVE_VT';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VARIABLES) {
+        type = 'APPLY_VARIABLES';
+    }
+    else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_SETTABLE_VARIABLES) {
+        type = 'SET_VARIABLES';
+    }
+    else {
+        output_1.default.exitError(texts_1.ERR_CANT_APPLY_ACTION_EXECUTION);
+    }
+    const body = {
+        operation: type,
+        approve_action_id: runActionId,
+        variables,
+    };
+    await client.pipelineRunApply(workspace, project, data.pipeline_id, rid, body);
+    const OutputPipeline = require('../../../output/pipeline').default;
+    await OutputPipeline.runStatus(client, workspace, project, data.pipeline_id, rid, !options.wait);
+});
+exports.default = commandPipelineRunApply;

package/distTs/src/command/yaml/actions/detect.js

@@ -0,0 +1,268 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectActions = detectActions;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const picomatch_1 = __importDefault(require("picomatch"));
+const utils_1 = require("../../../utils");
+const cache_1 = require("../cache");
+const DETECT_CACHE_TTL = 10 * 60 * 1000; // 10 minutes
+const DETECT_CACHE_PREFIX = 'detect:';
+let cachedRules = null;
+function loadDetectRules() {
+    if (cachedRules)
+        return cachedRules;
+    const filePath = path_1.default.resolve((0, utils_1.getRootDir)(), 'detect-rules.json');
+    cachedRules = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf8'));
+    return cachedRules;
+}
+function safeReadDir(dir) {
+    try {
+        return (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function readDirIndex(dir) {
+    const names = [];
+    const lowerNames = new Set();
+    const lowerDirs = new Set();
+    for (const entry of safeReadDir(dir)) {
+        names.push(entry.name);
+        lowerNames.add(entry.name.toLowerCase());
+        if (entry.isDirectory())
+            lowerDirs.add(entry.name.toLowerCase());
+    }
+    return { names, lowerNames, lowerDirs };
+}
+function existsCaseInsensitive(dir, relPath, mustBeDir) {
+    const segments = relPath.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return false;
+    let current = dir;
+    for (let i = 0; i < segments.length; i++) {
+        const lower = segments[i].toLowerCase();
+        const found = safeReadDir(current).find((e) => e.name.toLowerCase() === lower);
+        if (!found)
+            return false;
+        if (i === segments.length - 1 && mustBeDir && !found.isDirectory())
+            return false;
+        current = path_1.default.join(current, found.name);
+    }
+    return true;
+}
+function fileMatchesAny(patterns, dir, index) {
+    for (const pattern of patterns) {
+        if (pattern.includes('*')) {
+            const isMatch = (0, picomatch_1.default)(pattern, { nocase: true, dot: true });
+            if (index.names.some((name) => isMatch(name)))
+                return true;
+        }
+        else if (pattern.includes('/')) {
+            const mustBeDir = pattern.endsWith('/');
+            const rel = mustBeDir ? pattern.slice(0, -1) : pattern;
+            if (rel.includes('/')) {
+                if (existsCaseInsensitive(dir, rel, mustBeDir))
+                    return true;
+            }
+            else if (mustBeDir) {
+                if (index.lowerDirs.has(rel.toLowerCase()))
+                    return true;
+            }
+            else if (index.lowerNames.has(rel.toLowerCase())) {
+                return true;
+            }
+        }
+        else if (index.lowerNames.has(pattern.toLowerCase())) {
+            return true;
+        }
+    }
+    return false;
+}
+function parsePackageJson(content) {
+    const pkg = JSON.parse(content);
+    return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+}
+function parseRequirementsTxt(content) {
+    const names = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('-')) {
+            names.push(trimmed.split(/[>=<!~[;]/)[0].trim());
+        }
+    }
+    return names;
+}
+function parseComposerJson(content) {
+    const composer = JSON.parse(content);
+    return Object.keys({ ...composer.require, ...composer['require-dev'] });
+}
+function parseGoMod(content) {
+    const names = [];
+    const requireBlocks = content.match(/require\s*\(([\s\S]*?)\)/g);
+    if (requireBlocks) {
+        for (const block of requireBlocks) {
+            for (const line of block.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('require') && trimmed !== ')') {
+                    names.push(trimmed.split(/\s/)[0]);
+                }
+            }
+        }
+    }
+    const singleReqs = content.match(/^require\s+(\S+)/gm);
+    if (singleReqs) {
+        for (const req of singleReqs)
+            names.push(req.replace(/^require\s+/, '').trim());
+    }
+    return names;
+}
+function parseGemfile(content) {
+    const names = [];
+    for (const line of content.split('\n')) {
+        const match = line.match(/^\s*gem\s+['"]([^'"]+)['"]/);
+        if (match)
+            names.push(match[1]);
+    }
+    return names;
+}
+function parsePubspec(content) {
+    const YAML = require('yaml');
+    const pubspec = YAML.parse(content) || {};
+    return [
+        ...Object.keys(pubspec.dependencies || {}),
+        ...Object.keys(pubspec.dev_dependencies || {}),
+    ];
+}
+function parseCargoToml(content) {
+    const names = [];
+    const depSection = content.match(/\[dependencies]([\s\S]*?)(?=\n\[|$)/);
+    if (depSection) {
+        for (const line of depSection[1].split('\n')) {
+            const match = line.match(/^(\S+)\s*=/);
+            if (match)
+                names.push(match[1]);
+        }
+    }
+    return names;
+}
+function parsePomXml(content) {
+    const names = [];
+    const artifacts = content.match(/<artifactId>([^<]+)<\/artifactId>/g);
+    if (artifacts) {
+        for (const a of artifacts)
+            names.push(a.replace(/<\/?artifactId>/g, ''));
+    }
+    return names;
+}
+function parseGradle(content) {
+    const names = [];
+    const deps = content.match(/(?:implementation|api|compile|testImplementation)\s*[('"]([^'"()]+)['")\s]/g);
+    if (deps) {
+        for (const d of deps) {
+            const match = d.match(/['"]([^'"]+)['"]/);
+            if (match)
+                names.push(match[1]);
+        }
+    }
+    return names;
+}
+function parsePyproject(content) {
+    const names = [];
+    const depMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)]/);
+    if (depMatch) {
+        const items = depMatch[1].match(/["']([^"'>=<![;]+)/g);
+        if (items) {
+            for (const item of items)
+                names.push(item.replace(/^["']/, '').trim());
+        }
+    }
+    return names;
+}
+const MANIFEST_PARSERS = [
+    { file: 'package.json', parse: parsePackageJson },
+    { file: 'requirements.txt', parse: parseRequirementsTxt },
+    { file: 'composer.json', parse: parseComposerJson },
+    { file: 'go.mod', parse: parseGoMod },
+    { file: 'Gemfile', parse: parseGemfile },
+    { file: 'pubspec.yaml', parse: parsePubspec },
+    { file: 'Cargo.toml', parse: parseCargoToml },
+    { file: 'pom.xml', parse: parsePomXml },
+    { file: 'build.gradle', parse: parseGradle },
+    { file: 'build.gradle.kts', parse: parseGradle },
+    { file: 'pyproject.toml', parse: parsePyproject },
+];
+const LOCKFILES = ['package-lock.json', 'composer.lock', 'go.sum', 'Gemfile.lock', 'pubspec.lock', 'Cargo.lock'];
+const MANIFEST_FILES = [...new Set(MANIFEST_PARSERS.map((p) => p.file)), ...LOCKFILES];
+function readPackageNames(dir) {
+    const packages = new Set();
+    for (const { file, parse } of MANIFEST_PARSERS) {
+        const filePath = path_1.default.join(dir, file);
+        if (!(0, fs_1.existsSync)(filePath))
+            continue;
+        try {
+            for (const name of parse((0, fs_1.readFileSync)(filePath, 'utf8'))) {
+                if (name)
+                    packages.add(name);
+            }
+        }
+        catch {
+            // ignore malformed manifests
+        }
+    }
+    return packages;
+}
+function packageMatchesPattern(pkg, pattern) {
+    if (pattern.endsWith('/*')) {
+        const prefix = pattern.slice(0, -2);
+        return pkg.startsWith(prefix + '/');
+    }
+    return pkg === pattern;
+}
+function scanActions(dir) {
+    const rules = loadDetectRules();
+    const packages = readPackageNames(dir);
+    const detectedTypes = [];
+    const index = readDirIndex(dir);
+    for (const [type, rule] of Object.entries(rules)) {
+        let matched = false;
+        if (rule.files) {
+            matched = fileMatchesAny(rule.files, dir, index);
+        }
+        if (!matched && rule.packages) {
+            for (const pkgPattern of rule.packages) {
+                for (const pkg of packages) {
+                    if (packageMatchesPattern(pkg, pkgPattern)) {
+                        matched = true;
+                        break;
+                    }
+                }
+                if (matched)
+                    break;
+            }
+        }
+        if (matched) {
+            detectedTypes.push(type);
+        }
+    }
+    return detectedTypes;
+}
+let pruneScheduled = false;
+function detectActions(dir) {
+    const cacheKey = DETECT_CACHE_PREFIX + dir;
+    const fingerprint = (0, cache_1.fingerprintFiles)(dir, MANIFEST_FILES);
+    const cached = (0, cache_1.getCache)(cacheKey, fingerprint);
+    if (cached)
+        return new Set(cached);
+    const detected = scanActions(dir);
+    (0, cache_1.setCache)(cacheKey, fingerprint, detected, DETECT_CACHE_TTL);
+    if (!pruneScheduled) {
+        pruneScheduled = true;
+        process.nextTick(() => (0, cache_1.pruneCache)());
+    }
+    return new Set(detected);
+}