@flisk-sh/flisk-import 0.0.0-stage → 0.2.2

package/dist/merge.js

@@ -0,0 +1,156 @@
+import { basename } from "node:path/posix";
+import { precedence } from "./registry.js";
+function slug(raw) {
+    return raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function toResourceName(raw) {
+    let name = slug(raw) || "svc";
+    // Resource names must start with a letter and be at least 3 characters (service schema).
+    if (!/^[a-z]/.test(name))
+        name = `svc-${name}`;
+    if (name.length < 3)
+        name = `${name}-svc`;
+    return name;
+}
+/**
+ * Maps every raw name in one project to a distinct resource name. Names that are already valid
+ * claim their spelling first; the rest get a numeric suffix when they would collide (for example
+ * `db` and `db-svc` both normalise to `db-svc`).
+ */
+export function assignResourceNames(rawNames) {
+    const unique = [...new Set(rawNames)].sort();
+    const claimed = new Set();
+    const out = new Map();
+    const claim = (raw) => {
+        const base = toResourceName(raw);
+        let final = base;
+        for (let n = 2; claimed.has(final); n++)
+            final = `${base}-${n}`;
+        claimed.add(final);
+        out.set(raw, final);
+    };
+    const isValid = (raw) => toResourceName(raw) === raw;
+    unique.filter(isValid).forEach(claim);
+    unique.filter((raw) => !isValid(raw)).forEach(claim);
+    return out;
+}
+const SCALAR_FIELDS = [
+    "image",
+    "dockerfile",
+    "command",
+    "port",
+    "language",
+    "healthCheckPath",
+];
+function rank(candidate) {
+    return Math.min(...candidate.sources.map((s) => precedence(s.detector)));
+}
+function mergeGroup(name, dir, members, resolve) {
+    const ordered = [...members].sort((a, b) => rank(a) - rank(b));
+    const originalName = ordered.find((c) => c.name !== undefined && c.name !== name)?.name;
+    const merged = {
+        name,
+        ...(originalName ? { originalName } : {}),
+        dir,
+        kind: ordered[0].kind,
+        envKeys: [...new Set(ordered.flatMap((c) => c.envKeys ?? []))].sort(),
+        dependsOn: [...new Set(ordered.flatMap((c) => (c.dependsOn ?? []).map(resolve)))].sort(),
+        exposeViaProxy: ordered.find((c) => c.exposeViaProxy !== undefined)?.exposeViaProxy,
+        procfileCommands: ordered.flatMap((c) => c.sources.some((source) => source.detector === "procfile") && c.command ? [c.command] : []),
+        conflicts: [],
+        sources: [],
+        confidence: ordered.every((c) => c.confidence === "high") ? "high" : "low",
+    };
+    for (const field of SCALAR_FIELDS) {
+        const values = new Map();
+        for (const c of ordered) {
+            const v = c[field];
+            if (v === undefined)
+                continue;
+            values.set(String(v), [...(values.get(String(v)) ?? []), ...c.sources]);
+        }
+        if (values.size === 1) {
+            const holder = ordered.find((c) => c[field] !== undefined);
+            merged[field] = holder[field];
+        }
+        else if (values.size > 1) {
+            merged.conflicts.push({
+                field,
+                values: [...values].map(([value, sources]) => ({ value, sources })),
+            });
+        }
+    }
+    for (const c of ordered) {
+        for (const s of c.sources) {
+            if (!merged.sources.some((m) => m.file === s.file && m.detector === s.detector)) {
+                merged.sources.push(s);
+            }
+        }
+    }
+    return merged;
+}
+/**
+ * Groups candidates by directory and name. An anonymous candidate (Dockerfile, package.json)
+ * joins the one named service in its directory, or becomes a service named after the directory.
+ * It is never guessed onto one of several. A field two sources disagree on is a conflict and is omitted.
+ */
+export function mergeCandidates(candidates, rootName) {
+    const skips = [];
+    const table = assignResourceNames([
+        ...candidates.flatMap((c) => (c.name === undefined ? [] : [c.name])),
+        ...candidates.flatMap((c) => c.dependsOn ?? []),
+        ...candidates.flatMap((c) => (c.name === undefined ? [basename(c.dir) || rootName] : [])),
+    ]);
+    const resolve = (raw) => table.get(raw) ?? toResourceName(raw);
+    const groups = new Map();
+    const keyOf = (dir, name) => `${dir}\0${name}`;
+    for (const c of candidates) {
+        if (c.name === undefined)
+            continue;
+        const name = resolve(c.name);
+        const first = c.sources[0];
+        if (!name) {
+            skips.push({ ...first, reason: `"${c.name}" is not usable as a service name` });
+            continue;
+        }
+        const key = keyOf(c.dir, name);
+        const group = groups.get(key) ?? { name, dir: c.dir, members: [] };
+        group.members.push(c);
+        groups.set(key, group);
+    }
+    const anonymous = candidates.filter((c) => c.name === undefined);
+    for (const c of anonymous) {
+        const targets = [...groups.values()].filter((g) => g.dir === c.dir && !g.members.every((m) => m.standalone));
+        if (targets.length === 1) {
+            targets[0].members.push(c);
+        }
+        else if (targets.length === 0) {
+            const name = resolve(basename(c.dir) || rootName);
+            if (!name) {
+                skips.push({
+                    ...c.sources[0],
+                    reason: "no usable service name for this directory",
+                });
+                continue;
+            }
+            const key = keyOf(c.dir, name);
+            const group = groups.get(key) ?? { name, dir: c.dir, members: [] };
+            group.members.push(c);
+            groups.set(key, group);
+        }
+        else {
+            const names = targets.map((g) => g.name).join(", ");
+            skips.push({
+                ...c.sources[0],
+                reason: `directory has several services (${names}); not guessed which one this file describes`,
+            });
+        }
+    }
+    const services = [...groups.values()]
+        .map((g) => mergeGroup(g.name, g.dir, g.members, resolve))
+        .sort((a, b) => (a.dir === b.dir ? (a.name < b.name ? -1 : 1) : a.dir < b.dir ? -1 : 1));
+    return { services, skips };
+}

package/dist/plan.js

@@ -0,0 +1,105 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import "./detectors/index.js";
+import { ImportError } from "./errors.js";
+import { mergeCandidates } from "./merge.js";
+import { selectDetectors } from "./registry.js";
+import { scanTree } from "./scan.js";
+import { findUnsupported } from "./unsupported.js";
+const COMPOSE_FILE = "docker-compose.yml";
+/** Names `docker compose` also picks up, in its own order of preference; none of them is read. */
+const OTHER_COMPOSE_FILES = ["compose.yaml", "compose.yml", "docker-compose.yaml"];
+/** Files `docker compose up` merges over the main file; none of them is applied. */
+const OVERRIDE_FILES = [
+    "compose.override.yaml",
+    "compose.override.yml",
+    "docker-compose.override.yaml",
+    "docker-compose.override.yml",
+];
+/** Read the one supported input, root docker-compose.yml. This function writes nothing. */
+export function buildPlan(dir) {
+    const root = resolve(dir);
+    if (!statSync(root, { throwIfNoEntry: false })?.isDirectory()) {
+        throw new Error(`${dir} is not a directory`);
+    }
+    const composePath = COMPOSE_FILE;
+    const detectors = selectDetectors(["compose"]);
+    const candidates = [];
+    const skips = [];
+    const isFile = (name) => statSync(resolve(root, name), { throwIfNoEntry: false })?.isFile() ?? false;
+    if (!isFile(composePath)) {
+        const others = OTHER_COMPOSE_FILES.filter(isFile);
+        throw new ImportError(`No root docker-compose.yml found in ${root}${others.length ? ` (found ${others.join(", ")})` : ""}; tdk import reads only that file`, others.length
+            ? [
+                `Other Compose file names are not read yet. To import ${others[0]}, link it: ln -s ${others[0]} docker-compose.yml`,
+            ]
+            : ["Run tdk import in the directory that holds docker-compose.yml"]);
+    }
+    for (const name of OTHER_COMPOSE_FILES.filter(isFile)) {
+        skips.push({
+            file: name,
+            detector: "compose",
+            reason: `not read; \`docker compose\` prefers it over ${COMPOSE_FILE}, so what it runs may differ from this plan`,
+        });
+    }
+    for (const name of OVERRIDE_FILES.filter(isFile)) {
+        skips.push({
+            file: name,
+            detector: "compose",
+            reason: `not applied; \`docker compose up\` merges it over ${COMPOSE_FILE}, tdk import does not`,
+        });
+    }
+    for (const detector of detectors) {
+        if (!detector.claim(composePath))
+            continue;
+        try {
+            const result = detector.parse(resolve(root, composePath), composePath);
+            candidates.push(...result.candidates);
+            skips.push(...result.skips);
+        }
+        catch (err) {
+            skips.push({
+                file: composePath,
+                detector: detector.id,
+                reason: `could not be read: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    const unsupported = findUnsupported(scanTree(root).files);
+    const merged = mergeCandidates(candidates, basename(root));
+    const services = merged.services;
+    return {
+        root,
+        services,
+        skips: [...skips, ...merged.skips, ...unsupported.skips],
+        unsupported: unsupported.labels,
+        skippedProcfileProcesses: 0,
+        notes: [],
+        files: [composePath],
+    };
+}
+/** Ports already claimed by service.json files under `dir` (best effort). */
+export function usedManifestPorts(dir) {
+    const ports = new Map();
+    let entries;
+    try {
+        entries = readdirSync(dir, { recursive: true }).map(String);
+    }
+    catch {
+        return ports;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith("service.json") || entry.split(/[\\/]/).includes("node_modules"))
+            continue;
+        const abs = resolve(dir, entry);
+        try {
+            const port = JSON.parse(readFileSync(abs, "utf8")).port;
+            if (typeof port === "number")
+                ports.set(abs, port);
+        }
+        catch {
+            // unreadable or not JSON: it claims no port
+        }
+    }
+    return ports;
+}

package/dist/registry.js

@@ -0,0 +1,29 @@
+import { ImportError } from "./errors.js";
+const detectors = [];
+/** Detectors register themselves from `detectors/index.ts`; the order is the merge precedence. */
+export function registerDetector(detector) {
+    if (detectors.some((d) => d.id === detector.id)) {
+        throw new Error(`Import detector "${detector.id}" is already registered`);
+    }
+    detectors.push(detector);
+}
+export function detectorIds() {
+    return detectors.map((d) => d.id);
+}
+/** Resolves `--only`. An unknown id fails here, before any file is read. */
+export function selectDetectors(only) {
+    if (!only || only.length === 0)
+        return [...detectors];
+    const unknown = only.filter((id) => !detectors.some((d) => d.id === id));
+    if (unknown.length > 0) {
+        throw new ImportError(`Unknown import detector: ${unknown.join(", ")}`, [
+            `Registered detectors: ${detectorIds().join(", ")}`,
+        ]);
+    }
+    return detectors.filter((d) => only.includes(d.id));
+}
+/** Lower number wins a field. Unregistered ids rank last. */
+export function precedence(detectorId) {
+    const index = detectors.findIndex((d) => d.id === detectorId);
+    return index === -1 ? detectors.length : index;
+}

package/dist/scan.js

@@ -0,0 +1,137 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, posix } from "node:path";
+export const HARD_SKIPS = new Set([
+    ".git",
+    "node_modules",
+    "vendor",
+    "target",
+    "dist",
+    ".autogenerated",
+    // Output of `tdk project`: never a source of services.
+    ".tdk",
+    "shared-platform-engineering",
+]);
+export const MAX_DEPTH = 8;
+export const MAX_FILES = 5000;
+function globToRegex(glob) {
+    let out = "";
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === "*" && glob[i + 1] === "*") {
+            if (glob[i + 2] === "/") {
+                out += "(?:.*/)?";
+                i += 2;
+            }
+            else {
+                out += ".*";
+                i += 1;
+            }
+        }
+        else if (c === "*")
+            out += "[^/]*";
+        else if (c === "?")
+            out += "[^/]";
+        else
+            out += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return out;
+}
+function readIgnoreRules(absDir, base, notes) {
+    let text;
+    try {
+        text = readFileSync(join(absDir, ".gitignore"), "utf8");
+    }
+    catch {
+        return [];
+    }
+    const rules = [];
+    for (const raw of text.split(/\r?\n/)) {
+        let pattern = raw.trim();
+        if (!pattern || pattern.startsWith("#"))
+            continue;
+        if (pattern.startsWith("!")) {
+            notes.push(`${posix.join(base, ".gitignore")}: negation (${pattern}) is not supported`);
+            continue;
+        }
+        const dirOnly = pattern.endsWith("/");
+        if (dirOnly)
+            pattern = pattern.slice(0, -1);
+        const anchored = pattern.includes("/");
+        if (pattern.startsWith("/"))
+            pattern = pattern.slice(1);
+        rules.push({ base, regex: new RegExp(`^${globToRegex(pattern)}$`), anchored, dirOnly });
+    }
+    return rules;
+}
+function isIgnored(rules, rel, name, isDir) {
+    return rules.some((rule) => {
+        if (rule.dirOnly && !isDir)
+            return false;
+        const underBase = rule.base === "" ? rel : rel.slice(rule.base.length + 1);
+        if (rule.base !== "" && !rel.startsWith(`${rule.base}/`))
+            return false;
+        return rule.regex.test(rule.anchored ? underBase : name);
+    });
+}
+/**
+ * Lists the files under `root` that detectors may claim. Skips build and dependency
+ * directories and `.gitignore`d paths, never follows symlinks, and caps depth and file count.
+ */
+export function scanTree(root, limits = { depth: MAX_DEPTH, files: MAX_FILES }) {
+    const files = [];
+    const notes = [];
+    const managed = [];
+    let depthCapped = false;
+    let fileCapped = false;
+    // In a TDK project, `services/` holds manifests and generated compose files, not sources.
+    const isTdkProject = existsSync(join(root, ".tdk", "project.json"));
+    if (isTdkProject)
+        notes.push("TDK project detected: services/ was not scanned");
+    const walk = (rel, depth, inherited) => {
+        const abs = join(root, rel);
+        const rules = [...inherited, ...readIgnoreRules(abs, rel, notes)];
+        const entries = readdirSync(abs, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        // A directory with a service.json is already a TDK service (possibly written by an earlier
+        // import, with a scaffolded Dockerfile): re-importing it would not be idempotent.
+        if (rel !== "" && entries.some((e) => e.isFile() && e.name === "service.json")) {
+            managed.push(rel);
+            return;
+        }
+        for (const entry of entries) {
+            if (fileCapped)
+                return;
+            if (entry.isSymbolicLink())
+                continue;
+            const entryRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
+            if (entry.isDirectory()) {
+                if (HARD_SKIPS.has(entry.name) || isIgnored(rules, entryRel, entry.name, true))
+                    continue;
+                if (isTdkProject && entryRel === "services")
+                    continue;
+                if (depth >= limits.depth) {
+                    depthCapped = true;
+                    continue;
+                }
+                walk(entryRel, depth + 1, rules);
+            }
+            else if (entry.isFile()) {
+                if (isIgnored(rules, entryRel, entry.name, false))
+                    continue;
+                if (files.length >= limits.files) {
+                    fileCapped = true;
+                    return;
+                }
+                files.push(entryRel);
+            }
+        }
+    };
+    walk("", 0, []);
+    if (managed.length) {
+        notes.push(`${managed.length} director${managed.length === 1 ? "y" : "ies"} with a service.json skipped (already TDK services)`);
+    }
+    if (depthCapped)
+        notes.push(`directories deeper than ${limits.depth} levels were not scanned`);
+    if (fileCapped)
+        notes.push(`stopped after ${limits.files} files; later files were not scanned`);
+    return { files: files.sort(), notes };
+}

package/dist/tdk.js

@@ -0,0 +1,40 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+/** Manifest constants of the TDK service.json this tool writes. */
+export const SERVICE_MANIFEST_SCHEMA_VERSION = 1;
+export const SERVICE_MANIFEST_SCHEMA_URL = "https://flisk.sh/schema.service.json";
+/**
+ * Oldest TDK core that starts an imported project: 1.3.104 added `buildContext`, and 1.3.145
+ * (flisk#1018) bootstraps a project that has `.tdk/project.json` but no Tiltfile yet.
+ * Stated, not checked: the importer does not read the installed core version.
+ */
+export const MIN_CORE_VERSION = "1.3.145";
+/** TDK's bring-your-own port range. */
+export const BYO_PORT_RANGE = { min: 4000, max: 5999, label: "4000-5999" };
+/**
+ * Values TDK copies into generated Compose and Traefik config must match these, or `tdk up` refuses
+ * the manifest (flisk `cli/src/utils/service-manifest.ts`, engine `manifest/parser.star`).
+ */
+export const HEALTH_CHECK_PATH_PATTERN = /^\/[a-z0-9/-]*$/;
+export const IMAGE_PATTERN = /^[A-Za-z0-9._/:@-]+$/;
+const KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function validateName(label, name) {
+    return KEBAB.test(name)
+        ? { valid: true }
+        : {
+            valid: false,
+            error: `${label} "${name}" must use lowercase letters, numbers, and hyphens only`,
+        };
+}
+/** Nearest directory at or above `start` holding `.tdk/project.json`. */
+export function findProjectRoot(start) {
+    let dir = resolve(start);
+    while (true) {
+        if (existsSync(join(dir, ".tdk", "project.json")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/unsupported.js

@@ -0,0 +1,25 @@
+import { posix } from "node:path";
+/** Orchestration formats people expect to import. They are named and skipped, never translated. */
+const UNSUPPORTED = [
+    { label: "Helm", matches: (name) => name === "Chart.yaml" },
+    { label: "Kustomize", matches: (name) => /^kustomization\.ya?ml$/.test(name) },
+];
+/** Skips for recognised-but-unsupported files, so a repo is never silently reported as empty. */
+export function findUnsupported(files) {
+    const skips = [];
+    const labels = new Set();
+    for (const file of files) {
+        const name = posix.basename(file);
+        for (const format of UNSUPPORTED) {
+            if (!format.matches(name))
+                continue;
+            labels.add(format.label);
+            skips.push({
+                file,
+                detector: "unsupported",
+                reason: `${format.label} is not imported`,
+            });
+        }
+    }
+    return { skips, labels: [...labels] };
+}

package/dist/write.js

@@ -0,0 +1,183 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { ImportError } from "./errors.js";
+import { toResourceName } from "./merge.js";
+import { usedManifestPorts } from "./plan.js";
+import { BYO_PORT_RANGE, findProjectRoot, IMAGE_PATTERN, SERVICE_MANIFEST_SCHEMA_URL, SERVICE_MANIFEST_SCHEMA_VERSION, validateName, } from "./tdk.js";
+function existingPort(path) {
+    try {
+        const port = JSON.parse(readFileSync(path, "utf8")).port;
+        return typeof port === "number" ? port : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Maps merged services onto TDK bring-your-own manifests. This is the only stage that knows the
+ * layout `<project>/services/<stack>/<name>/service.json`. Nothing is written here.
+ */
+/** Images that serve a protocol other than HTTP. Matched against the image name, not its tag. */
+const NON_HTTP_IMAGE = /(^|\/)(postgres|mysql|mariadb|mongo|mongodb|redis|valkey|memcached|minio|mailpit|mailhog|rabbitmq|kafka|zookeeper|elasticsearch|opensearch|openssh-server)(:|@|$)/i;
+export function planWrites(plan, force) {
+    const projectRoot = findProjectRoot(plan.root) ?? plan.root;
+    const stack = toResourceName(basename(plan.root));
+    const stackCheck = validateName("Stack name", stack);
+    if (!stackCheck.valid) {
+        throw new ImportError(`Cannot derive a stack name from "${basename(plan.root)}"`, [
+            "Run import from a directory whose name has letters or digits",
+        ]);
+    }
+    const servicesDir = join(projectRoot, "services");
+    const projectConfigPath = join(projectRoot, ".tdk", "project.json");
+    const projectConfig = existsSync(projectConfigPath)
+        ? undefined
+        : {
+            path: projectConfigPath,
+            content: `${JSON.stringify({
+                version: "1.0",
+                project: { name: basename(projectRoot), version: "1.0.0" },
+                phases: {
+                    pre_alpha: {
+                        name: "Pre-Alpha",
+                        description: "TDK proxy and imported Compose services",
+                        enabledStacks: ["proxy", stack],
+                    },
+                    alpha: { name: "Alpha", description: "", enabledStacks: [] },
+                    beta: { name: "Beta", description: "", enabledStacks: [] },
+                    out_of_scope: { name: "Out of Scope", description: "", enabledStacks: [] },
+                },
+                optional_infra: {
+                    monitoring: false,
+                    elk: false,
+                    debezium: false,
+                    golden_image: false,
+                    verdaccio: false,
+                },
+                discovery: { paths: ["services/*/*"] },
+                overrides: {},
+            }, null, 2)}\n`,
+        };
+    const used = usedManifestPorts(servicesDir);
+    const items = [];
+    const rejected = [];
+    // Reject first, so no written service depends on one that is not written.
+    const accepted = plan.services.filter((service) => {
+        const check = validateName("Resource name", service.name);
+        const reason = !check.valid
+            ? (check.error ?? "invalid name")
+            : service.dockerfile
+                ? undefined
+                : !service.image
+                    ? "Compose gives it neither `image` nor a usable `build`"
+                    : !IMAGE_PATTERN.test(service.image)
+                        ? `image "${service.image}" uses Compose variables or characters TDK does not accept; set a literal image in docker-compose.yml, or write this service.json by hand`
+                        : undefined;
+        if (reason)
+            rejected.push({ name: service.name, reason });
+        return !reason;
+    });
+    const names = new Set(accepted.map((s) => s.name));
+    for (const service of accepted) {
+        const path = resolve(servicesDir, stack, service.name, "service.json");
+        const exists = existsSync(path);
+        const status = !exists ? "create" : force ? "overwrite" : "exists";
+        const notes = [];
+        if (service.originalName && service.originalName !== service.name)
+            notes.push(`renamed from "${service.originalName}" (Compose names must be lowercase kebab-case)`);
+        // A file this run replaces does not count against itself; a kept one keeps its port.
+        if (status === "overwrite")
+            used.delete(path);
+        const keep = status === "overwrite" ? existingPort(path) : undefined;
+        const isPrivate = service.exposeViaProxy === false;
+        const taken = new Set(used.values());
+        const free = (p) => p >= BYO_PORT_RANGE.min && p <= BYO_PORT_RANGE.max && !taken.has(p);
+        let port;
+        if (status === "exists") {
+            // Never written, so no port is needed; keep the one on disk for the plan.
+            port = existingPort(path) ?? BYO_PORT_RANGE.min;
+        }
+        else if (service.port !== undefined && free(service.port)) {
+            // The schema accepts this port for bring-your-own and no other service in the project uses it.
+            port = service.port;
+        }
+        else if (keep !== undefined && free(keep)) {
+            port = keep;
+        }
+        else {
+            for (let p = BYO_PORT_RANGE.min; p <= BYO_PORT_RANGE.max; p++) {
+                if (free(p)) {
+                    port = p;
+                    break;
+                }
+            }
+        }
+        if (status !== "exists" &&
+            service.port !== undefined &&
+            port !== undefined &&
+            port !== service.port)
+            notes.push(`Compose port ${service.port} is outside ${BYO_PORT_RANGE.label} or already used; assigned ${port}. The container must listen on $PORT (${port}) or it will not answer`);
+        if (port === undefined) {
+            rejected.push({ name: service.name, reason: `no free port in ${BYO_PORT_RANGE.label}` });
+            continue;
+        }
+        if (status !== "exists")
+            used.set(path, port);
+        const dependsOn = service.dependsOn.filter((d) => d !== service.name && names.has(d));
+        const dropped = service.dependsOn.filter((d) => d !== service.name && !names.has(d));
+        if (dropped.length)
+            notes.push(`dependsOn not written, not in this import: ${dropped.join(", ")}`);
+        // Infrastructure images and one-shot jobs do not serve HTTP, so an assumed "/" would only
+        // fail the probe. Leave the path out; the runtime then skips the HTTP probe.
+        const nonHttp = service.kind === "job" || (service.image !== undefined && NON_HTTP_IMAGE.test(service.image));
+        const healthCheckPath = isPrivate || nonHttp ? undefined : (service.healthCheckPath ?? "/");
+        if (nonHttp && !isPrivate)
+            notes.push("no health path: the service does not serve HTTP (non-HTTP image or job)");
+        if (!isPrivate && !nonHttp && !service.healthCheckPath)
+            notes.push("health path / is assumed: no HTTP health path could be read from Compose. Traefik routes only while it answers 2xx or 3xx");
+        if (service.envKeys.length)
+            notes.push("environment values are not written; put them in the project .env");
+        if (service.dockerfile && service.image)
+            notes.push(`image "${service.image}" is not written: with build and image, TDK builds from ${service.dockerfile} and does not pull the tag`);
+        // With both build and image, Compose builds the Dockerfile and tags the result as `image`.
+        // Omit `image` from service.json so TDK builds from the Dockerfile instead of pulling the tag.
+        const source = service.dockerfile
+            ? {
+                buildContext: relative(dirname(path), resolve(plan.root, service.dir)).split("\\").join("/") || ".",
+                dockerfile: service.dockerfile,
+            }
+            : { image: service.image };
+        const manifest = {
+            $schema: SERVICE_MANIFEST_SCHEMA_URL,
+            schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION,
+            appName: service.name,
+            appType: "bring-your-own",
+            stack,
+            port,
+            ...(healthCheckPath ? { healthCheckPath } : {}),
+            ...source,
+            ...(isPrivate ? { exposeViaProxy: false } : {}),
+            ...(dependsOn.length ? { dependsOn } : {}),
+        };
+        items.push({ service, path, manifest, status, notes });
+    }
+    return { projectRoot, stack, items, projectConfig, rejected };
+}
+export function applyWrites(writes) {
+    const written = [];
+    if (writes.projectConfig) {
+        mkdirSync(dirname(writes.projectConfig.path), { recursive: true });
+        writeFileSync(writes.projectConfig.path, writes.projectConfig.content, { flag: "wx" });
+    }
+    for (const item of writes.items) {
+        if (item.status === "exists")
+            continue;
+        mkdirSync(dirname(item.path), { recursive: true });
+        writeFileSync(item.path, `${JSON.stringify(item.manifest, null, 2)}\n`);
+        written.push(item);
+    }
+    return written;
+}
+export function manifestRelPath(plan, item) {
+    return relative(plan.root, item.path).split("\\").join("/");
+}