@vercel/fs-detectors 6.15.10 → 7.0.0

package/dist/services/detect-procfile.js

@@ -1,249 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var detect_procfile_exports = {};
-__export(detect_procfile_exports, {
-  detectProcfileServices: () => detectProcfileServices
-});
-module.exports = __toCommonJS(detect_procfile_exports);
-var import_detect_framework = require("../detect-framework");
-var import_utils = require("./utils");
-const PROCFILE = "Procfile";
-const PROCFILE_LINE_RE = /^\s*([A-Za-z_][A-Za-z0-9_-]*):\s*(.+)/;
-const PY_IDENT = "[A-Za-z_][A-Za-z0-9_]*";
-const PY_MODULE_RE = new RegExp(
-  `^${PY_IDENT}(?:\\.${PY_IDENT})*(?::${PY_IDENT})?$`
-);
-const SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".cjs",
-  ".mjs",
-  ".ts",
-  ".cts",
-  ".mts",
-  ".py",
-  ".go",
-  ".rs",
-  ".rb",
-  ".ru"
-]);
-const SUPPORTED_WORKER_COMMANDS = /* @__PURE__ */ new Set(["celery", "dramatiq"]);
-async function detectProcfileServices(options) {
-  const { fs } = options;
-  const raw = await readProcfile(fs);
-  if (raw.warning) {
-    return { services: null, errors: [], warnings: [raw.warning] };
-  }
-  if (!raw.content) {
-    return { services: null, errors: [], warnings: [] };
-  }
-  const entries = parseProcfile(raw.content);
-  if (entries.length === 0) {
-    return { services: null, errors: [], warnings: [] };
-  }
-  const services = {};
-  const errors = [];
-  const warnings = [];
-  let releaseCommand;
-  const serviceEntries = [];
-  for (const entry of entries) {
-    if (entry.processType === "release") {
-      releaseCommand = entry.command;
-    } else {
-      serviceEntries.push(entry);
-    }
-  }
-  if (serviceEntries.length === 0 && releaseCommand) {
-    warnings.push({
-      code: "PROCFILE_RELEASE_ONLY",
-      message: `Found only a release process in Procfile (command: "${releaseCommand}"). The release command can be used as a build step. You can add it as part of a web service if you add it to "buildCommand".`
-    });
-    return { services: null, errors: [], warnings };
-  }
-  if (serviceEntries.length === 0) {
-    return { services: null, errors: [], warnings: [] };
-  }
-  const frameworks = await (0, import_detect_framework.detectFrameworks)({
-    fs,
-    frameworkList: import_utils.DETECTION_FRAMEWORKS,
-    useExperimentalFrameworks: true
-  });
-  if (frameworks.length > 1) {
-    const names = frameworks.map((f) => f.name).join(", ");
-    return {
-      services: null,
-      errors: [
-        {
-          code: "MULTIPLE_FRAMEWORKS_SERVICE",
-          message: `Multiple frameworks detected: ${names}. Use explicit services config.`
-        }
-      ],
-      warnings
-    };
-  }
-  const detectedFramework = frameworks.length === 1 ? frameworks[0] : null;
-  const serviceNames = /* @__PURE__ */ new Set();
-  for (const entry of serviceEntries) {
-    const { processType, command } = entry;
-    const tokens = command.split(/\s+/).filter(Boolean);
-    const entrypoint = await extractEntrypoint(tokens, fs);
-    const isWorkerLikeProcess = processType.includes("worker") || hasSupportedWorkerCommand(tokens);
-    if (serviceNames.has(processType)) {
-      errors.push({
-        code: "DUPLICATE_SERVICE",
-        message: `Duplicate process type "${processType}" in Procfile.`,
-        serviceName: processType
-      });
-      continue;
-    }
-    serviceNames.add(processType);
-    if (isWorkerLikeProcess) {
-      if (hasSupportedWorkerCommand(tokens) && entrypoint?.endsWith(".py")) {
-        services[processType] = {
-          root: ".",
-          type: "worker",
-          entrypoint,
-          runtime: "python"
-        };
-      } else {
-        emitWorkerHint(processType, command, entrypoint, warnings);
-      }
-      continue;
-    }
-    if (!detectedFramework && !entrypoint) {
-      warnings.push({
-        code: "SERVICE_SKIPPED",
-        message: `Skipped Procfile process "${processType}": no framework detected and could not infer entrypoint from command "${command}". Configure it manually in services.`
-      });
-      continue;
-    }
-    services[processType] = {
-      root: ".",
-      type: "web",
-      ...detectedFramework?.slug ? { framework: detectedFramework.slug } : {},
-      entrypoint: entrypoint ?? "."
-    };
-  }
-  if (errors.length > 0) {
-    return { services: null, errors, warnings };
-  }
-  if (Object.keys(services).length === 0) {
-    return { services: null, errors: [], warnings };
-  }
-  if (releaseCommand && services.web) {
-    services.web.buildCommand = releaseCommand;
-  } else if (releaseCommand) {
-    const firstService = Object.values(services)[0];
-    if (firstService) {
-      firstService.buildCommand = releaseCommand;
-    }
-  }
-  warnings.push(...(0, import_utils.assignMountPaths)(services));
-  return { services, errors: [], warnings };
-}
-function parseProcfile(content) {
-  const entries = [];
-  for (const rawLine of content.split("\n")) {
-    const match = rawLine.match(PROCFILE_LINE_RE);
-    if (match) {
-      entries.push({ processType: match[1], command: match[2].trim() });
-    }
-  }
-  return entries;
-}
-async function extractEntrypoint(tokens, fs) {
-  let firstModulePath;
-  let lastFilePath;
-  for (const token of tokens) {
-    if (!firstModulePath && PY_MODULE_RE.test(token)) {
-      const resolved = await resolvePythonModule(token, fs);
-      if (resolved)
-        firstModulePath = resolved;
-    }
-    if (hasSupportedExtension(token)) {
-      lastFilePath = token;
-    }
-  }
-  return firstModulePath ?? lastFilePath;
-}
-async function resolvePythonModule(spec, fs) {
-  const [modulePart] = spec.split(":");
-  const filePath = `${modulePart.replace(/\./g, "/")}.py`;
-  const initPath = `${modulePart.replace(/\./g, "/")}/__init__.py`;
-  try {
-    if (await fs.isFile(filePath))
-      return filePath;
-    if (await fs.isFile(initPath))
-      return initPath;
-  } catch {
-  }
-  return void 0;
-}
-function hasSupportedExtension(token) {
-  const dot = token.lastIndexOf(".");
-  return dot > 0 && SUPPORTED_EXTENSIONS.has(token.slice(dot));
-}
-function hasSupportedWorkerCommand(tokens) {
-  return tokens.some((t) => SUPPORTED_WORKER_COMMANDS.has(baseCommand(t)));
-}
-function emitWorkerHint(processType, command, entrypoint, warnings) {
-  const hint = {
-    type: "worker",
-    entrypoint: entrypoint ?? "<path-to-handler>",
-    runtime: "python"
-  };
-  if (entrypoint?.endsWith(".py")) {
-    warnings.push({
-      code: "PROCFILE_WORKER_HINT",
-      message: `Found Procfile worker process "${processType}". Python workers that use Celery, Dramatiq and Django tasks are supported. You can add the following to define this worker:
-"${processType}": ${JSON.stringify(hint, null, 2)}`
-    });
-    return;
-  }
-  warnings.push({
-    code: "PROCFILE_WORKER_HINT",
-    message: `Found Procfile worker process "${processType}" (command: "${command}"). Could not determine runtime. Only Python workers are currently supported.`
-  });
-}
-function baseCommand(token) {
-  if (!token)
-    return "";
-  const parts = token.split("/");
-  return parts[parts.length - 1];
-}
-async function readProcfile(fs) {
-  try {
-    const exists = await fs.isFile(PROCFILE);
-    if (!exists)
-      return { content: null };
-    const buf = await fs.readFile(PROCFILE);
-    return { content: buf.toString("utf-8") };
-  } catch (err) {
-    return {
-      content: null,
-      warning: {
-        code: "PROCFILE_READ_ERROR",
-        message: `Failed to read ${PROCFILE}: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectProcfileServices
-});

package/dist/services/detect-railway.d.ts

@@ -1,22 +0,0 @@
-import type { DetectEntrypointFn } from '@vercel/build-utils';
-import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
-export interface RailwayDetectResult {
-    services: InferredServicesConfig | null;
-    errors: ServiceDetectionError[];
-    warnings: ServiceDetectionWarning[];
-}
-/**
- * Detect Railway service configurations in the project.
- *
- * Scans for railway.{json,toml} files, parses them,
- * tries to detect frameworks in each service directory, and maps to
- * services format.
- *
- * When a Railway config has `deploy.preDeployCommand`, it's added to
- * `buildCommand` since we don't have a separate pre-deploy yet.
- */
-export declare function detectRailwayServices(options: {
-    fs: DetectorFilesystem;
-    detectEntrypoint?: DetectEntrypointFn;
-}): Promise<RailwayDetectResult>;

package/dist/services/detect-railway.js

@@ -1,241 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var detect_railway_exports = {};
-__export(detect_railway_exports, {
-  detectRailwayServices: () => detectRailwayServices
-});
-module.exports = __toCommonJS(detect_railway_exports);
-var import_path = require("path");
-var import_smol_toml = __toESM(require("smol-toml"));
-var import_detect_framework = require("../detect-framework");
-var import_utils = require("./utils");
-const RAILWAY_JSON = "railway.json";
-const RAILWAY_TOML = "railway.toml";
-const MAX_SCAN_DEPTH = 5;
-const SKIP_DIRS = /* @__PURE__ */ new Set([
-  ".hg",
-  ".git",
-  ".svn",
-  ".cache",
-  ".next",
-  ".now",
-  ".vercel",
-  ".venv",
-  ".yarn",
-  ".turbo",
-  ".output",
-  "node_modules",
-  "__pycache__",
-  "venv",
-  "CVS"
-]);
-async function detectRailwayServices(options) {
-  const { fs, detectEntrypoint } = options;
-  const { configs, warnings } = await findRailwayConfigs(fs);
-  if (configs.length === 0) {
-    return { services: null, errors: [], warnings };
-  }
-  const services = {};
-  const serviceDirs = /* @__PURE__ */ new Map();
-  const errors = [];
-  for (const cf of configs) {
-    const serviceFs = cf.dirPath === "." ? fs : fs.chdir(cf.dirPath);
-    const dirLabel = cf.dirPath === "." ? "root" : cf.dirPath;
-    const frameworks = await (0, import_detect_framework.detectFrameworks)({
-      fs: serviceFs,
-      frameworkList: import_utils.DETECTION_FRAMEWORKS,
-      useExperimentalFrameworks: true
-    });
-    if (cf.config.deploy?.cronSchedule) {
-      const schedule = cf.config.deploy.cronSchedule;
-      const runtime = frameworks.length === 1 ? (0, import_utils.inferRuntimeFromFramework)(frameworks[0].slug) : void 0;
-      const hint = {
-        type: "job",
-        trigger: "schedule",
-        schedule,
-        entrypoint: "<path-to-handler>"
-      };
-      if (runtime) {
-        hint.runtime = runtime;
-      }
-      warnings.push({
-        code: "RAILWAY_CRON_HINT",
-        message: `Found Railway cron in ${dirLabel}/ (schedule: "${schedule}"). Vercel crons work with a file entrypoint. You can add the following to define this scheduled job service:
-"${deriveServiceName(cf.dirPath)}": ${JSON.stringify(hint, null, 2)}`
-      });
-      continue;
-    }
-    const serviceName = deriveServiceName(cf.dirPath);
-    const existingDir = serviceDirs.get(serviceName);
-    if (existingDir) {
-      errors.push({
-        code: "DUPLICATE_SERVICE",
-        message: `Duplicate service name "${serviceName}" derived from ${existingDir}/ and ${dirLabel}/. Rename one of the directories to avoid conflicts.`,
-        serviceName
-      });
-      continue;
-    }
-    serviceDirs.set(serviceName, dirLabel);
-    if (frameworks.length === 0) {
-      warnings.push({
-        code: "SERVICE_SKIPPED",
-        message: `Skipped service in ${dirLabel}/: no framework detected. Configure it manually in services.`
-      });
-      continue;
-    }
-    if (frameworks.length > 1) {
-      const names = frameworks.map((f) => f.name).join(", ");
-      errors.push({
-        code: "MULTIPLE_FRAMEWORKS_SERVICE",
-        message: `Multiple frameworks detected in ${dirLabel}/: ${names}. Use explicit services config.`,
-        serviceName
-      });
-      continue;
-    }
-    const framework = frameworks[0];
-    const slug = framework.slug ?? void 0;
-    const serviceConfig = {
-      root: cf.dirPath,
-      framework: slug
-    };
-    if (cf.dirPath !== "." && detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug)) {
-      const detected = await detectEntrypoint({
-        workPath: cf.dirPath,
-        framework: slug
-      });
-      if (detected) {
-        serviceConfig.entrypoint = detected.entrypoint;
-      }
-    }
-    if (cf.config.build?.buildCommand) {
-      serviceConfig.buildCommand = cf.config.build.buildCommand;
-    }
-    const railwayPreDeploy = cf.config.deploy?.preDeployCommand;
-    if (railwayPreDeploy) {
-      serviceConfig.preDeployCommand = Array.isArray(railwayPreDeploy) ? railwayPreDeploy.join(" && ") : railwayPreDeploy;
-    }
-    services[serviceName] = serviceConfig;
-  }
-  if (errors.length > 0) {
-    return { services: null, errors, warnings };
-  }
-  const serviceNames = Object.keys(services);
-  if (serviceNames.length === 0) {
-    return { services: null, errors: [], warnings };
-  }
-  warnings.push(...(0, import_utils.assignMountPaths)(services));
-  return { services, errors: [], warnings };
-}
-async function findRailwayConfigs(fs, dirPath = ".", depth = 0) {
-  const configs = [];
-  const warnings = [];
-  const readResult = await readRailwayConfigRaw(fs, dirPath);
-  warnings.push(...readResult.warnings);
-  const { config, warning } = tryParseRailwayConfig(readResult.raw);
-  if (warning) {
-    warnings.push(warning);
-  }
-  if (config) {
-    configs.push({ dirPath, config });
-  }
-  if (depth >= MAX_SCAN_DEPTH) {
-    return { configs, warnings };
-  }
-  const readPath = dirPath === "." ? "/" : dirPath;
-  let entries;
-  try {
-    entries = await fs.readdir(readPath);
-  } catch {
-    return { configs, warnings };
-  }
-  for (const entry of entries) {
-    if (entry.type !== "dir" || SKIP_DIRS.has(entry.name)) {
-      continue;
-    }
-    const childPath = dirPath === "." ? entry.name : import_path.posix.join(dirPath, entry.name);
-    const child = await findRailwayConfigs(fs, childPath, depth + 1);
-    configs.push(...child.configs);
-    warnings.push(...child.warnings);
-  }
-  return { configs, warnings };
-}
-async function readRailwayConfigRaw(fs, dirPath) {
-  const warnings = [];
-  for (const filename of [RAILWAY_JSON, RAILWAY_TOML]) {
-    const filePath = dirPath === "." ? filename : import_path.posix.join(dirPath, filename);
-    try {
-      const exists = await fs.isFile(filePath);
-      if (!exists)
-        continue;
-    } catch {
-      continue;
-    }
-    try {
-      const buf = await fs.readFile(filePath);
-      return {
-        raw: { path: filePath, content: buf.toString("utf-8") },
-        warnings
-      };
-    } catch (err) {
-      warnings.push({
-        code: "RAILWAY_CONFIG_ERROR",
-        message: `Failed to read ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-      });
-    }
-  }
-  return { raw: null, warnings };
-}
-function tryParseRailwayConfig(raw) {
-  if (!raw) {
-    return { config: null };
-  }
-  try {
-    const config = raw.path.endsWith(".toml") ? import_smol_toml.default.parse(raw.content) : JSON.parse(raw.content);
-    return { config };
-  } catch (err) {
-    return {
-      config: null,
-      warning: {
-        code: "RAILWAY_PARSE_ERROR",
-        message: `Failed to parse ${raw.path}: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-function deriveServiceName(dirPath) {
-  if (dirPath === ".") {
-    return "web";
-  }
-  const segments = dirPath.split("/");
-  return segments[segments.length - 1];
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectRailwayServices
-});

package/dist/services/detect-render.d.ts

@@ -1,14 +0,0 @@
-import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { DetectEntrypointFn, InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
-export interface RenderDetectResult {
-    services: InferredServicesConfig | null;
-    errors: ServiceDetectionError[];
-    warnings: ServiceDetectionWarning[];
-}
-/**
- * Detect Render service configurations from render.yaml.
- */
-export declare function detectRenderServices(options: {
-    fs: DetectorFilesystem;
-    detectEntrypoint?: DetectEntrypointFn;
-}): Promise<RenderDetectResult>;