@faable/faable 1.5.27 → 1.5.29

package/README.md

@@ -21,6 +21,54 @@ To install the latest version of Faable CLI:
 npm i -g @faable/faable
 ```
 
+## Runtimes
+
+`faable deploy` auto-detects the runtime from the files in your project (no
+config needed in the common case):
+
+| Detected by | Runtime |
+| --- | --- |
+| `package.json` | Node.js (Next.js, Vite, Astro, Gatsby, CRA, Vue, Angular, …) |
+| `requirements.txt` / `pyproject.toml` / `Pipfile` | Python |
+| `Dockerfile` | Your own image (any language) |
+
+> A project with a `package.json` is always treated as Node. To deploy a Python
+> backend that also has a `package.json`, ship a `Dockerfile` instead.
+
+### Node.js / static frameworks
+
+SPA frameworks are built and served automatically. If the project has **no
+`start` script**, the built output is served statically (e.g. Vite → `npx vite
+preview`, CRA/Vue/Angular → `serve`). If it defines a `start` script (custom SSR,
+Next.js, Nuxt, Remix, …), that command is used.
+
+### Python
+
+The start command is detected from your framework:
+
+| Framework | Detected from | Start command |
+| --- | --- | --- |
+| Django | `manage.py` + the package with `wsgi.py` | `gunicorn <pkg>.wsgi:application` |
+| FastAPI / ASGI | `fastapi`/`uvicorn`/`starlette` dep | `uvicorn <module>:app` |
+| Flask | `flask` dep | `gunicorn <module>:app` |
+
+Dependencies are installed inside the image from `requirements.txt`,
+`pyproject.toml` or `Pipfile`. `gunicorn`/`uvicorn` are installed automatically
+if missing.
+
+Pin the Python version with a `runtime.txt` (`python-3.11.3`), a
+`.python-version`, or `requires-python` in `pyproject.toml`.
+
+### Overriding detection
+
+When auto-detection doesn't fit, set the commands explicitly:
+
+- `faable.json` — `{ "buildCommand": "...", "startCommand": "..." }`
+- `Procfile` — a `web:` line, e.g. `web: gunicorn app:app --bind 0.0.0.0:$PORT`
+
+Precedence: `faable.json` → `Procfile` → auto-detection. The container listens on
+`$PORT` (80).
+
 ## Documentation
 
 For details on how to use Faable CLI, check out our

package/dist/commands/deploy/git_context.js

@@ -14,7 +14,9 @@ const gitRunner = (workdir) => command => new Promise(resolve => {
 // Resolve the commit / ref / actor for the current deploy. In GitHub Actions
 // these come from the standard env vars; locally we fall back to git so manual
 // deploys still record a commit. `github_actor` is CI-only (a GitHub login),
-// left undefined locally where no reliable login is available.
+// left undefined locally where no reliable login is available. The commit
+// message has no standard CI env var, so it is always read from git (for the
+// resolved commit, falling back to HEAD) — the dashboard shows its first line.
 const git_context = async (opts) => {
     const env = opts?.env ?? process.env;
     const run = opts?.run ?? gitRunner(opts?.workdir);
@@ -26,6 +28,12 @@ const git_context = async (opts) => {
             github_ref = `refs/heads/${branch}`;
     }
     const github_actor = env.GITHUB_ACTOR || undefined;
+    // Full commit message (subject + body) for the resolved commit; the dashboard
+    // renders only the subject line. Fall back to HEAD when the SHA isn't
+    // resolvable in the local checkout (e.g. shallow clones).
+    const github_commit_message = (github_commit &&
+        (await run(`git show -s --format=%B ${github_commit}`))) ||
+        (await run("git log -1 --pretty=%B"));
     const ctx = {};
     if (github_commit)
         ctx.github_commit = github_commit;
@@ -33,6 +41,8 @@ const git_context = async (opts) => {
         ctx.github_ref = github_ref;
     if (github_actor)
         ctx.github_actor = github_actor;
+    if (github_commit_message)
+        ctx.github_commit_message = github_commit_message;
     return ctx;
 };
 

package/dist/commands/deploy/index.js

@@ -4,6 +4,7 @@ import { log } from '../../log.js';
 import { check_environment } from './check_environment.js';
 import { git_context } from './git_context.js';
 import { build_node } from './node-pipeline/index.js';
+import { build_python } from './python-pipeline/index.js';
 import { runtime_detection } from './runtime-detect/runtime_detection.js';
 import { upload_tag } from './upload_tag.js';
 
@@ -48,6 +49,12 @@ const deploy = {
             });
             type = node_result.type;
         }
+        else if (runtime.name == 'python') {
+            const python_result = await build_python(app, {
+                workdir,
+                runtime});
+            type = python_result.type;
+        }
         else if (runtime.name == 'docker') {
             type = 'node';
             await cmd(`docker build -t ${app.id} .`, {

package/dist/commands/deploy/node-pipeline/analyze_package.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import path__default from 'path';
 import { log } from '../../../log.js';
-import * as R from 'ramda';
+import { detect_framework } from './frameworks.js';
 
 const analyze_package = async (params) => {
     const workdir = params.workdir;
@@ -11,23 +11,24 @@ const analyze_package = async (params) => {
     // Check if build is required to run
     const build_script = process.env.FAABLE_NPM_BUILD_SCRIPT
         ? process.env.FAABLE_NPM_BUILD_SCRIPT
-        : pkg?.scripts["build"]
+        : pkg?.scripts?.["build"]
             ? "build"
             : null;
     if (!build_script) {
         log.info(`No build script on package.json`);
     }
-    let type = "node";
-    // Detect nextjs deployment type
-    const next_dep = R.lensPath(["dependencies", "next"]);
-    const next_devdep = R.lensPath(["devDependencies", "next"]);
-    if (R.view(next_dep, pkg) || R.view(next_devdep, pkg)) {
-        type = "next";
-    }
+    const has_start = Boolean(pkg?.scripts?.["start"]);
+    const { type, start_command, inject_serve } = detect_framework({
+        pkg,
+        workdir,
+        has_start,
+    });
     log.info(`⚡️ Detected deployment type=${type}`);
     return {
         build_script,
         type,
+        start_command,
+        inject_serve,
     };
 };
 

package/dist/commands/deploy/node-pipeline/build_docker.js

@@ -27,7 +27,11 @@ const entrypoint_template = Handlebars.compile(entrypoint);
 const build_docker = async (props) => {
     const { app, workdir, template_context } = props;
     const entrypoint_custom = entrypoint_template(template_context);
-    const start_command = Configuration.instance().startCommand;
+    // Precedence: explicit faable.json startCommand > framework-detected command
+    // (e.g. serving a static SPA) > default `npm run start`.
+    const start_command = Configuration.instance().configuredStartCommand ??
+        props.start_command ??
+        "npm run start";
     log.info(`⚙️ Start command: ${start_command}`);
     // NOTE: use slim to build projects
     const linux_distro = "slim";

package/dist/commands/deploy/node-pipeline/frameworks.js

@@ -0,0 +1,108 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import * as R from 'ramda';
+import { log } from '../../../log.js';
+
+const has_dep = (pkg, name) => Boolean(R.view(R.lensPath(["dependencies", name]), pkg) ||
+    R.view(R.lensPath(["devDependencies", name]), pkg));
+/**
+ * Read Angular's build output path from angular.json. Defaults to `dist` when
+ * it can't be resolved. Angular ≥17 (application builder) emits into
+ * `<outputPath>/browser`, so we append it when the project uses that builder.
+ */
+const resolve_angular_output = (workdir) => {
+    const fallback = "dist";
+    try {
+        const angular_json = fs.readJSONSync(path__default.join(workdir, "angular.json"));
+        const projects = angular_json?.projects ?? {};
+        const project_name = angular_json?.defaultProject ?? Object.keys(projects)[0];
+        const build = projects?.[project_name]?.architect?.build;
+        const output = build?.options?.outputPath;
+        if (!output)
+            return fallback;
+        const builder = build?.builder ?? "";
+        const is_application_builder = builder.includes("application") || builder.includes("browser-esbuild");
+        return is_application_builder ? path__default.join(output, "browser") : output;
+    }
+    catch {
+        return fallback;
+    }
+};
+/**
+ * Framework registry, evaluated in order. Order matters: Astro/SvelteKit/CRA
+ * pull Vite in transitively, so Vite must be the last static fallback.
+ */
+const FRAMEWORKS = [
+    // Next.js: handled by its own runtime_strategy/PVC, never static-served here.
+    { type: "next", deps: ["next"] },
+    {
+        type: "astro",
+        deps: ["astro"],
+        outputDir: "dist",
+        serveCommand: (dir) => `npx astro preview --host 0.0.0.0 --port $PORT`,
+    },
+    {
+        type: "gatsby",
+        deps: ["gatsby"],
+        outputDir: "public",
+        serveCommand: (dir) => `npx gatsby serve --host 0.0.0.0 --port $PORT`,
+    },
+    {
+        type: "cra",
+        deps: ["react-scripts"],
+        outputDir: "build",
+        injectServe: true,
+        serveCommand: (dir) => `npx serve -s ${dir} -l $PORT`,
+    },
+    {
+        type: "vue",
+        deps: ["@vue/cli-service"],
+        outputDir: "dist",
+        injectServe: true,
+        serveCommand: (dir) => `npx serve -s ${dir} -l $PORT`,
+    },
+    {
+        type: "angular",
+        deps: ["@angular/cli", "@angular-devkit/build-angular"],
+        injectServe: true,
+        resolveOutput: resolve_angular_output,
+        serveCommand: (dir) => `npx serve -s ${dir} -l $PORT`,
+    },
+    {
+        type: "vite",
+        deps: ["vite"],
+        outputDir: "dist",
+        serveCommand: (dir) => `npx vite preview --host 0.0.0.0 --port $PORT`,
+    },
+];
+/**
+ * Detect the framework from package.json and compute how to serve it.
+ *
+ * When the project defines its own `start` script we never override it (the app
+ * ships a real server — custom SSR, Nuxt, Remix, SvelteKit node-adapter, etc.),
+ * so `start_command`/`inject_serve` stay neutral.
+ */
+const detect_framework = (params) => {
+    const { pkg, workdir, has_start } = params;
+    const framework = FRAMEWORKS.find((fw) => fw.deps.some((dep) => has_dep(pkg, dep)));
+    if (!framework) {
+        return { type: "node", start_command: null, inject_serve: false };
+    }
+    // Static frameworks only override the start command when the project doesn't
+    // ship its own server.
+    if (framework.serveCommand && !has_start) {
+        const output_dir = framework.resolveOutput
+            ? framework.resolveOutput(workdir)
+            : framework.outputDir ?? "dist";
+        const start_command = framework.serveCommand(output_dir);
+        log.info(`No start script on package.json, serving ${framework.type} output (${output_dir}) with [${start_command}]`);
+        return {
+            type: framework.type,
+            start_command,
+            inject_serve: Boolean(framework.injectServe),
+        };
+    }
+    return { type: framework.type, start_command: null, inject_serve: false };
+};
+
+export { FRAMEWORKS, detect_framework, resolve_angular_output };

package/dist/commands/deploy/node-pipeline/index.js

@@ -1,6 +1,7 @@
 import { build_docker } from './build_docker.js';
 import { analyze_package } from './analyze_package.js';
 import { build_project } from './build_project.js';
+import { inject_serve } from './inject_serve.js';
 import * as R from 'ramda';
 import { log } from '../../../log.js';
 
@@ -11,16 +12,24 @@ const build_node = async (app, options) => {
         throw new Error("Runtime version not specified for node");
     }
     // Analyze package.json to check if build is needed
-    const { build_script, type } = await analyze_package({ workdir });
+    const { build_script, type, start_command, inject_serve: needs_serve } = await analyze_package({
+        workdir,
+    });
     // Environment variables
     const env = R.fromPairs(env_vars.map((e) => [e.name, e.value]));
     log.info(`Building with env variables ${Object.keys(env).join(",")}`);
     // Do build
     await build_project({ build_script, env });
+    // Frameworks without a bundled static server (CRA/Vue/Angular) need `serve`
+    // installed into node_modules before packaging, so it ships in the image.
+    if (needs_serve) {
+        await inject_serve(workdir);
+    }
     // Bundle project inside a docker image
     await build_docker({
         app,
         workdir,
+        start_command,
         template_context: {
             from: `node:${runtime.version}`,
         },

package/dist/commands/deploy/node-pipeline/inject_serve.js

@@ -0,0 +1,20 @@
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
+
+// Pinned for reproducible builds. `serve` is the standalone static server used
+// for frameworks without a bundled preview tool (CRA, Vue, Angular).
+const SERVE_VERSION = "14";
+/**
+ * Install `serve` into the project's node_modules so it ships inside the image
+ * via `COPY . .` (the Dockerfile does no `npm install`). This lets `npx serve`
+ * resolve the local copy at container start — no runtime download needed.
+ *
+ * `--no-save` keeps the user's package.json/lockfile untouched.
+ */
+const inject_serve = async (workdir) => {
+    log.info(`📥 Injecting static server (serve@${SERVE_VERSION}) into image`);
+    const timeout = 5 * 60 * 1000; // 5 minute timeout
+    await cmd(`npm install serve@${SERVE_VERSION} --no-save --no-audit --no-fund`, { cwd: workdir, timeout, enableOutput: true });
+};
+
+export { inject_serve };

package/dist/commands/deploy/python-pipeline/analyze_python.js

@@ -0,0 +1,158 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { log } from '../../../log.js';
+import { Configuration } from '../../../lib/Configuration.js';
+import { parse_procfile } from './parse_procfile.js';
+
+/** Combine all dependency manifests into one lowercased blob for cheap lookups. */
+const read_dependencies_text = (workdir) => {
+    const files = ["requirements.txt", "pyproject.toml", "Pipfile"];
+    return files
+        .map((f) => path__default.join(workdir, f))
+        .filter((p) => fs.existsSync(p))
+        .map((p) => fs.readFileSync(p).toString())
+        .join("\n")
+        .toLowerCase();
+};
+const has_token = (deps, token) => new RegExp(`\\b${token}\\b`).test(deps);
+/** Identify which server binary a start command relies on, to ensure it's installed. */
+const server_from_command = (command) => {
+    const bin = command.trim().split(/\s+/)[0];
+    if (bin === "gunicorn")
+        return "gunicorn";
+    if (bin === "uvicorn")
+        return "uvicorn";
+    return null;
+};
+/** Django project package = the directory that contains wsgi.py. */
+const find_django_package = (workdir) => {
+    const entries = fs.readdirSync(workdir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() &&
+            fs.existsSync(path__default.join(workdir, entry.name, "wsgi.py"))) {
+            return entry.name;
+        }
+    }
+    return null;
+};
+/**
+ * Find the module that defines the app object, returning its dotted module path
+ * (e.g. `main`, `app.main`). Prefers a file matching `pattern`, else the first
+ * existing candidate.
+ */
+const find_app_module = (workdir, pattern) => {
+    const candidates = [
+        "main.py",
+        "app.py",
+        "asgi.py",
+        "wsgi.py",
+        "application.py",
+        "server.py",
+        path__default.join("app", "main.py"),
+        path__default.join("app", "app.py"),
+        path__default.join("src", "main.py"),
+    ];
+    let first_existing = null;
+    for (const rel of candidates) {
+        const abs = path__default.join(workdir, rel);
+        if (!fs.existsSync(abs))
+            continue;
+        const module = rel.replace(/\.py$/, "").split(path__default.sep).join(".");
+        if (!first_existing)
+            first_existing = module;
+        if (pattern.test(fs.readFileSync(abs).toString()))
+            return module;
+    }
+    return first_existing;
+};
+/** Resolve the container start command and which server it needs installed. */
+const resolve_start = (workdir, deps) => {
+    // 1. Explicit override in faable.json
+    const configured = Configuration.instance().configuredStartCommand;
+    if (configured) {
+        log.info(`Using start command from faable.json`);
+        return { start_command: configured, server: server_from_command(configured) };
+    }
+    // 2. Procfile `web:` line
+    const procfile = parse_procfile(workdir);
+    if (procfile) {
+        log.info(`Using start command from Procfile`);
+        return { start_command: procfile, server: server_from_command(procfile) };
+    }
+    // 3. Framework detection
+    // Django: manage.py + the package holding wsgi.py
+    if (fs.existsSync(path__default.join(workdir, "manage.py"))) {
+        const pkg = find_django_package(workdir);
+        if (!pkg) {
+            throw new Error("Detected Django (manage.py) but couldn't find the wsgi.py package. Set `startCommand` in faable.json or add a Procfile.");
+        }
+        return {
+            start_command: `gunicorn ${pkg}.wsgi:application --bind 0.0.0.0:$PORT`,
+            server: "gunicorn",
+        };
+    }
+    // FastAPI / ASGI
+    if (has_token(deps, "fastapi") ||
+        has_token(deps, "starlette") ||
+        has_token(deps, "uvicorn")) {
+        const module = find_app_module(workdir, /app\s*=\s*(FastAPI|Starlette)\(/i);
+        if (module) {
+            return {
+                start_command: `uvicorn ${module}:app --host 0.0.0.0 --port $PORT`,
+                server: "uvicorn",
+            };
+        }
+    }
+    // Flask
+    if (has_token(deps, "flask")) {
+        const module = find_app_module(workdir, /app\s*=\s*Flask\(/i);
+        if (module) {
+            return {
+                start_command: `gunicorn ${module}:app --bind 0.0.0.0:$PORT`,
+                server: "gunicorn",
+            };
+        }
+    }
+    throw new Error("Could not detect how to start this Python app. Set `startCommand` in faable.json or add a Procfile with a `web:` line.");
+};
+/** Build the dependency-install command run during the Docker build. */
+const build_install_command = (workdir, server, deps) => {
+    const steps = [];
+    const configured_build = Configuration.instance().buildCommand;
+    if (configured_build) {
+        steps.push(configured_build);
+    }
+    else if (fs.existsSync(path__default.join(workdir, "requirements.txt"))) {
+        steps.push("pip install --no-cache-dir -r requirements.txt");
+    }
+    else if (fs.existsSync(path__default.join(workdir, "pyproject.toml"))) {
+        steps.push("pip install --no-cache-dir .");
+    }
+    else if (fs.existsSync(path__default.join(workdir, "Pipfile"))) {
+        steps.push("pip install --no-cache-dir pipenv && pipenv install --system --deploy");
+    }
+    // Ensure the WSGI/ASGI server is available when not already declared.
+    if (server === "gunicorn" && !has_token(deps, "gunicorn")) {
+        steps.push("pip install --no-cache-dir gunicorn");
+    }
+    if (server === "uvicorn" && !has_token(deps, "uvicorn")) {
+        steps.push("pip install --no-cache-dir uvicorn[standard]");
+    }
+    if (steps.length === 0) {
+        // No manifest found — nothing to install, but warn the user.
+        log.warn("No requirements.txt/pyproject.toml/Pipfile found");
+        return "true";
+    }
+    return steps.join(" && ");
+};
+const analyze_python = async (params) => {
+    const { workdir } = params;
+    const deps = read_dependencies_text(workdir);
+    const { start_command, server } = resolve_start(workdir, deps);
+    const install_command = build_install_command(workdir, server, deps);
+    log.info(`📦 Install command: ${install_command}`);
+    log.info(`⚙️ Start command: ${start_command}`);
+    return { install_command, start_command };
+};
+
+export { analyze_python };

package/dist/commands/deploy/python-pipeline/build_docker.js

@@ -0,0 +1,42 @@
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
+import fs from 'fs-extra';
+import Handlebars from 'handlebars';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const templates_dir = path.join(__dirname$1, "templates");
+const dockerfile = fs.readFileSync(`${templates_dir}/Dockerfile`).toString();
+const entrypoint = fs
+    .readFileSync(`${templates_dir}/entrypoint.sh`)
+    .toString("utf-8");
+Handlebars.registerHelper("escape", function (variable) {
+    const escaped_lines = variable
+        .replace(/(['`\\])/g, "\\$1")
+        .replace(/([$])/g, "\\$1");
+    return escaped_lines.split("\n").join("\\n");
+});
+const docker_template = Handlebars.compile(dockerfile);
+const entrypoint_template = Handlebars.compile(entrypoint);
+const build_docker = async (props) => {
+    const { app, workdir, install_command, start_command, template_context } = props;
+    const entrypoint_custom = entrypoint_template({});
+    log.info(`⚙️ Start command: ${start_command}`);
+    // NOTE: use slim to build projects
+    const linux_distro = "slim";
+    const from = [template_context.from, linux_distro].filter((e) => e).join("-");
+    log.info(`Using docker image ${from}`);
+    const dockerfile = docker_template({
+        from,
+        entry_script: entrypoint_custom,
+        install_command,
+        start_command,
+    });
+    log.info(`📦 Packaging inside a docker image`);
+    const timeout = 10 * 60 * 1000; // 10 minute timeout
+    await cmd(`docker build --platform linux/amd64 -t ${app.id} ${workdir} -f -<<EOF\n${dockerfile}\nEOF`, { timeout, enableOutput: true });
+};
+
+export { build_docker };

package/dist/commands/deploy/python-pipeline/index.js

@@ -0,0 +1,25 @@
+import { analyze_python } from './analyze_python.js';
+import { build_docker } from './build_docker.js';
+
+const build_python = async (app, options) => {
+    const { workdir, runtime } = options;
+    if (!runtime.version) {
+        throw new Error("Runtime version not specified for python");
+    }
+    // Resolve how to install deps and start the app. Unlike node, there is no
+    // separate local build step: dependency install happens inside the Docker
+    // build (where network is available), so we go straight to packaging.
+    const { install_command, start_command } = await analyze_python({ workdir });
+    await build_docker({
+        app,
+        workdir,
+        install_command,
+        start_command,
+        template_context: {
+            from: `python:${runtime.version}`,
+        },
+    });
+    return { type: "python" };
+};
+
+export { build_python };

package/dist/commands/deploy/python-pipeline/parse_procfile.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+
+/**
+ * Read the `web:` process command from a Procfile, if present. Returns null when
+ * there's no Procfile or no `web` entry. Used as a manual start-command override
+ * (Heroku-style) before falling back to framework detection.
+ */
+const parse_procfile = (workdir) => {
+    const procfile = path__default.join(workdir, "Procfile");
+    if (!fs.existsSync(procfile))
+        return null;
+    const content = fs.readFileSync(procfile).toString();
+    for (const line of content.split("\n")) {
+        const match = line.match(/^\s*web\s*:\s*(.+?)\s*$/);
+        if (match?.[1])
+            return match[1];
+    }
+    return null;
+};
+
+export { parse_procfile };

package/dist/commands/deploy/python-pipeline/templates/Dockerfile

@@ -0,0 +1,24 @@
+FROM {{from}}
+LABEL com.faable.cloud="FaableCloud"
+LABEL description="Faablecloud automatic deployment"
+
+WORKDIR /faable/app
+
+# Environment variables for runtime
+ENV PORT=80
+ENV PYTHONUNBUFFERED=1
+# `escape` keeps `$PORT` literal so the build heredoc (unquoted bash) doesn't
+# eat it; Docker then expands $PORT (=80) when building the ENV value.
+ENV START_COMMAND="{{{escape start_command}}}"
+
+# Copy Usercode
+COPY . .
+
+# Install dependencies (Python needs them built into the image, unlike node_modules).
+# Triple-stache + escape: keep `&&` intact and any `$` heredoc-safe.
+RUN {{{escape install_command}}}
+
+# Entrypoint stript
+RUN echo '{{{escape entry_script}}}' >> entrypoint.sh
+
+CMD ["/bin/sh", "./entrypoint.sh"]

package/dist/commands/deploy/python-pipeline/templates/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+PYTHON_VERSION=$(python --version 2>&1)
+PIP_VERSION=$(pip --version 2>&1)
+
+echo "Faable Cloud · [$PYTHON_VERSION] [$PIP_VERSION]"
+eval $START_COMMAND

package/dist/commands/deploy/runtime-detect/runtime_detection.js

@@ -2,12 +2,18 @@ import * as R from 'ramda';
 import { has_any_of_files } from './helpers/has_any_of_files.js';
 import { strategy_docker } from './strategies/docker.js';
 import { strategy_nodejs } from './strategies/nodejs.js';
+import { strategy_python } from './strategies/python.js';
 
 const runtime_detection = async (workdir) => {
     const has = R.curry(has_any_of_files);
+    // Order matters: node wins for full-stack apps that ship both a package.json
+    // and Python deps; Dockerfile is the explicit escape hatch evaluated last.
     const strategy = R.cond([
         [has(['package.json']), R.always(strategy_nodejs)],
-        // [has(["requirements.txt"]), R.always(strategy_python)],
+        [
+            has(['requirements.txt', 'pyproject.toml', 'Pipfile']),
+            R.always(strategy_python)
+        ],
         [has(['Dockerfile']), R.always(strategy_docker)]
     ])(workdir);
     if (!strategy) {

package/dist/commands/deploy/runtime-detect/strategies/python.js

@@ -0,0 +1,48 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { log } from '../../../../log.js';
+
+const DEFAULT_VERSION = "3.11.3";
+/**
+ * Resolve the Python version from (in order):
+ *  1. runtime.txt          → `python-3.11.3`
+ *  2. .python-version      → `3.11.3` (pyenv)
+ *  3. pyproject.toml       → `requires-python = ">=3.11"` (first concrete X.Y[.Z])
+ * Falls back to DEFAULT_VERSION.
+ */
+const resolve_python_version = (workdir) => {
+    const runtime_config = path__default.join(workdir, "runtime.txt");
+    if (fs.existsSync(runtime_config)) {
+        const runtime_data = fs.readFileSync(runtime_config).toString().trim();
+        if (!runtime_data.startsWith("python-")) {
+            throw new Error("runtime.txt must have runtime format with python-<version>");
+        }
+        return runtime_data.split("-")[1];
+    }
+    const python_version_file = path__default.join(workdir, ".python-version");
+    if (fs.existsSync(python_version_file)) {
+        const version = fs.readFileSync(python_version_file).toString().trim();
+        if (version)
+            return version;
+    }
+    const pyproject = path__default.join(workdir, "pyproject.toml");
+    if (fs.existsSync(pyproject)) {
+        const toml = fs.readFileSync(pyproject).toString();
+        const match = toml.match(/requires-python\s*=\s*["'][^0-9]*([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+        if (match?.[1])
+            return match[1];
+    }
+    return DEFAULT_VERSION;
+};
+const strategy_python = async (workdir) => {
+    const runtime_version = resolve_python_version(workdir);
+    log.info(`Using python@${runtime_version}`);
+    return {
+        runtime: {
+            name: "python",
+            version: runtime_version,
+        },
+    };
+};
+
+export { strategy_python };

package/dist/lib/Configuration.js

@@ -38,6 +38,10 @@ class Configuration {
     get startCommand() {
         return this.config.startCommand || "npm run start";
     }
+    /** Start command explicitly set in faable.json, or undefined when relying on the default. */
+    get configuredStartCommand() {
+        return this.config.startCommand;
+    }
     get buildCommand() {
         return this.config.buildCommand;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.5.27",
+  "version": "1.5.29",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",