@flisk-sh/flisk-import 0.7.0 → 0.9.0

package/README.md

@@ -15,7 +15,7 @@ flisk import . --yes         # write service.json files and project setup
 - **Keeps:** the service names (`db` stays `db`, so it stays the hostname), the build context and Dockerfile (or the image), the container port as written (3000, 80, 5432), `depends_on`, and an HTTP health path. Databases and brokers are private, with no proxy route.
 - **Runtime keys:** named volumes and bind mounts inside the project (`volumes`), `cap_add`, `cap_drop`, `init`, `read_only`, `user`, `security_opt` and `shm_size` (`container`), extra published ports (`extraPorts`, on 127.0.0.1 only), `network_mode: service:<name>` (`sidecarOf`) and `restart`.
 - **Environment:** values that cannot be secrets go into the committed `service.json` `env`: numbers, `true`/`false`, another imported service's address without a user, password or query (`http://invidious:3000`, `redis:6379`), and pure `${VAR}` references. Every other name, and any name that looks like a credential (`PASSWORD`, `TOKEN`, `KEY`, ...), goes into `secrets.required`, with its literal value copied to the project `.env`, which is added to `.gitignore`. Values in `.env` already are kept.
-- **Keeps:** a `command` on an image as the `CMD` of a one-line `Dockerfile` next to `service.json` (Flisk sets no container command), a `healthcheck` as `healthCheck.command`, a published database port as `extraPorts`, and `restart: on-failure:N` as `on-failure`.
+- **Keeps:** a `command` or `entrypoint` on an image as the `CMD`/`ENTRYPOINT` of a small `Dockerfile` next to `service.json` (Flisk sets no container command), a `healthcheck` as `healthCheck.command`, a published database port as `extraPorts`, and `restart: on-failure:N` as `on-failure`.
 - **Drops, and says so:** `command` on a service with a `build`, `env_file` and every other untranslated key; anonymous volumes and paths outside the project; `network_mode` other than `service:<name>`; services with `profiles`, `extends`, an out-of-tree build or a `${VAR}` image.
 - **Does not start anything.** Run `flisk up` with Flisk core **1.4.24 or later**. The importer does not check the core version.
 - **Exit codes:** `0` when the plan succeeds (`--dry-run`, files written, or all `service.json` files already exist), `1` when no root `docker-compose.yml` or mappable service is found, and `2` when the write prompt is declined or closed without an answer (`Nothing written.`).

package/dist/detectors/compose.js

@@ -45,6 +45,11 @@ const TRANSLATED_KEYS = new Set([
     "volumes",
     "restart",
     "command",
+    "entrypoint",
+    "models",
+    // Flisk gives every service its own stack network and container name, so these change nothing it needs.
+    "networks",
+    "expose",
 ]);
 const CAPABILITY = /^[A-Z_]+$/;
 const USER = /^[A-Za-z0-9_.:-]+$/;
@@ -286,6 +291,20 @@ function healthProbeOf(healthcheck) {
         ...(retries ? { retries } : {}),
     };
 }
+/** The models a service uses, joined to their top-level definitions. A model without a literal `model` is skipped. */
+function modelsOf(uses, defined) {
+    const names = Array.isArray(uses) ? uses : isObj(uses) ? Object.keys(uses) : [];
+    const out = [];
+    for (const name of names) {
+        const def = isObj(defined) && typeof name === "string" ? defined[name] : undefined;
+        if (typeof name === "string" &&
+            isObj(def) &&
+            typeof def.model === "string" &&
+            /^[A-Za-z0-9_.-]+$/.test(name))
+            out.push({ name, model: def.model });
+    }
+    return out.length ? out : undefined;
+}
 function healthPathOf(healthcheck) {
     if (!isObj(healthcheck) || !Array.isArray(healthcheck.test))
         return undefined;
@@ -413,7 +432,9 @@ registerDetector({
                     ? Object.keys(raw.depends_on)
                     : [];
             const command = commandOf(raw.command);
+            const models = modelsOf(raw.models, isObj(root) ? root.models : undefined);
             const containerCommand = containerCommandOf(raw.command);
+            const containerEntrypoint = containerCommandOf(raw.entrypoint);
             const healthProbe = healthProbeOf(raw.healthcheck);
             const envKeys = envNames(raw.environment);
             const env = envValues(raw.environment);
@@ -502,6 +523,8 @@ registerDetector({
                 ...(dockerfile ? { dockerfile } : {}),
                 ...(command ? { command } : {}),
                 ...(containerCommand ? { containerCommand } : {}),
+                ...(containerEntrypoint ? { containerEntrypoint } : {}),
+                ...(models ? { models } : {}),
                 ...(healthProbe ? { healthCheck: healthProbe } : {}),
                 ...(selectedPort !== undefined ? { port: selectedPort } : {}),
                 ...(healthCheckPath ? { healthCheckPath } : {}),

package/dist/merge.js

@@ -72,6 +72,8 @@ function mergeGroup(name, dir, members, resolve) {
         ...firstOf(ordered, "volumes"),
         ...firstOf(ordered, "restart"),
         ...firstOf(ordered, "containerCommand"),
+        ...firstOf(ordered, "containerEntrypoint"),
+        ...firstOf(ordered, "models"),
         ...firstOf(ordered, "healthCheck"),
         ...(ordered.find((c) => c.sidecarOf)?.sidecarOf
             ? { sidecarOf: resolve(ordered.find((c) => c.sidecarOf)?.sidecarOf) }

package/dist/write.js

@@ -207,16 +207,18 @@ export function planWrites(plan, force) {
         // Omit `image` from service.json so Flisk builds from the Dockerfile instead of pulling the tag.
         // Flisk has no container `command`, so a Compose `command` on an image becomes the CMD of a one-line Dockerfile.
         const files = [];
-        const wrapWithCommand = !service.dockerfile && service.image && service.containerCommand;
+        const wrapWithCommand = !service.dockerfile &&
+            service.image &&
+            (service.containerCommand || service.containerEntrypoint);
         if (wrapWithCommand) {
             files.push({
                 path: resolve(dirname(path), "Dockerfile"),
-                content: `# From the Compose \`command\` of this service (flisk import). Flisk sets no container command, so it lives here.\nFROM ${service.image}\nCMD ${JSON.stringify(service.containerCommand)}\n`,
+                content: `# From the Compose \`command\` of this service (flisk import). Flisk sets no container command, so it lives here.\nFROM ${service.image}\n${service.containerEntrypoint ? `ENTRYPOINT ${JSON.stringify(service.containerEntrypoint)}\n` : ""}${service.containerCommand ? `CMD ${JSON.stringify(service.containerCommand)}\n` : ""}`,
             });
-            notes.push(`command ${JSON.stringify(service.containerCommand)} is written as the CMD of a Dockerfile on ${service.image}`);
+            notes.push(`${service.containerEntrypoint ? "entrypoint" : "command"} ${JSON.stringify(service.containerEntrypoint ?? service.containerCommand)} is written to a Dockerfile on ${service.image}`);
         }
-        else if (service.dockerfile && service.containerCommand) {
-            notes.push(`command ${JSON.stringify(service.containerCommand)} not written: set it as CMD in ${service.dockerfile}`);
+        else if (service.dockerfile && (service.containerCommand || service.containerEntrypoint)) {
+            notes.push(`command/entrypoint not written: set it as CMD/ENTRYPOINT in ${service.dockerfile}`);
         }
         const source = wrapWithCommand
             ? { buildContext: ".", dockerfile: "Dockerfile" }
@@ -269,6 +271,7 @@ export function planWrites(plan, force) {
             ...(secretNames.length ? { secrets: { required: secretNames } } : {}),
             ...(service.restart ? { restart: service.restart } : {}),
             ...(service.container ? { container: service.container } : {}),
+            ...(service.models ? { models: service.models } : {}),
             ...(extraPorts.length ? { extraPorts } : {}),
             ...(sidecarOf ? { sidecarOf } : {}),
             ...(volumes.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk-sh/flisk-import",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Import a repository's root docker-compose.yml into Flisk service.json files, or register its Tiltfile.",
   "type": "module",
   "license": "MIT",