@yadurajfleetos/cli 0.4.0 → 0.5.0

package/dist/api.js

@@ -89,13 +89,32 @@ export async function requireFleet(explicit) {
     if (explicit)
         return explicit;
     const profile = await loadProfile();
-    if (profile.fleetId)
-        return profile.fleetId;
+    // A cached id is a hint, not a fact. It survives the fleet being deleted, the
+    // control plane being rebuilt, and signing in as somebody else — and the
+    // failure was a bare "Fleet not found" on every command, which names neither
+    // the cache nor the way out. Verify it, and fall through when it is stale.
+    if (profile.fleetId) {
+        try {
+            await request('GET', `/fleets/${profile.fleetId}`);
+            return profile.fleetId;
+        }
+        catch (err) {
+            if (!(err instanceof CliError) || err.exitCode !== EXIT.failure)
+                throw err;
+            await saveProfile({ ...profile, fleetId: undefined, fleetName: undefined });
+        }
+    }
     const { body } = await request('GET', '/fleets');
-    if (body.fleets.length === 1)
+    if (body.fleets.length === 1) {
+        // Remember it, so the next command does not pay for this lookup again.
+        await saveProfile({ ...profile, fleetId: body.fleets[0].id, fleetName: body.fleets[0].name });
         return body.fleets[0].id;
-    if (!body.fleets.length)
-        throw new CliError('You have no fleets yet.', EXIT.usage);
+    }
+    if (!body.fleets.length) {
+        throw new CliError('This account owns no fleets on ' + (profile.api ?? 'this control plane') + '.\n' +
+            '  If you expected one, you may be signed in as the wrong account — check with `fleet auth whoami`,\n' +
+            '  or create a fleet in the dashboard and run `fleet use <name>`.', EXIT.usage);
+    }
     throw new CliError(`You are in several fleets. Pass --fleet <id> or run \`fleet use <name>\`:\n` +
         body.fleets.map((f) => `  ${f.name}  ${f.id}`).join('\n'), EXIT.usage);
 }

package/dist/commands/index.js

@@ -10,7 +10,7 @@ import { downCommand } from './down.js';
 import { unpairCommand, agentCommand } from './unpair.js';
 import { secretsCommand } from './secrets.js';
 import { backupCommand, backupsCommand, restoreCommand } from './backups.js';
-import { applyCommand, deployCommand, deploymentsCommand, initCommand, logsCommand, removeServiceCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
+import { applyCommand, deployCommand, deploymentsCommand, initCommand, importCommand, logsCommand, removeServiceCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
 export const commands = {
     up: upCommand,
     open: openCommand,
@@ -21,6 +21,7 @@ export const commands = {
     use: useCommand,
     doctor: doctorCommand,
     init: initCommand,
+    import: importCommand,
     validate: validateCommand,
     apply: applyCommand,
     status: statusCommand,

package/dist/commands/services.js

@@ -473,3 +473,66 @@ export const removeServiceCommand = {
             console.log(c.dim(`  ${body.note}`));
     },
 };
+/**
+ * docker-compose.yml → fleet.yaml.
+ *
+ * The most common way to arrive at Fleet with several services, two languages
+ * and a database is to already have a compose file describing exactly that.
+ * Reading it is a transform rather than a guess, so this needs no network, no
+ * account, and no model — it works before you have signed in.
+ *
+ * It prints what it decided and what it could not answer. A converter that
+ * silently drops a bind mount or invents a node is worse than one that refuses,
+ * because the reader only finds out at deploy time.
+ */
+export const importCommand = {
+    async run(args, flags) {
+        const { composeToFleet } = await import('../compose.js');
+        const source = args[0] ?? 'docker-compose.yml';
+        let text;
+        try {
+            text = await readFile(source, 'utf8');
+        }
+        catch {
+            throw new CliError(`could not read ${source}\n  pass a path: fleet import path/to/docker-compose.yml`, EXIT.usage);
+        }
+        const out = manifestPath(typeof flags.out === 'string' ? flags.out : undefined);
+        const force = flags.force === true;
+        if (!force) {
+            try {
+                await access(out);
+                throw new CliError(`${out} already exists — pass --force to overwrite it.`, EXIT.usage);
+            }
+            catch (err) {
+                if (err instanceof CliError)
+                    throw err;
+            }
+        }
+        let result;
+        try {
+            result = composeToFleet(text, {
+                fleet: typeof flags.fleet === 'string' ? flags.fleet : undefined,
+                node: typeof flags.node === 'string' ? flags.node : undefined,
+            });
+        }
+        catch (err) {
+            throw new CliError(err.message, EXIT.usage);
+        }
+        // --dry-run prints and writes nothing, so the output can be piped or read
+        // before it lands next to the file it was derived from.
+        if (flags['dry-run'] === true) {
+            process.stdout.write(result.manifest);
+        }
+        else {
+            await writeFile(out, result.manifest);
+            console.log(`${c.green('created')} ${out}  ${c.dim(`from ${source}`)}`);
+        }
+        for (const note of result.notes)
+            console.log(`  ${c.dim('·')} ${c.dim(note)}`);
+        for (const q of result.questions)
+            console.log(`  ${c.yellow('?')} ${q}`);
+        if (!result.questions.length) {
+            console.log(c.dim(`\n  check it with: fleet apply --dry-run`));
+        }
+    },
+};

package/dist/compose.js

@@ -0,0 +1,324 @@
+import { parse as parseYaml } from 'yaml';
+/** Images Fleet manages as databases rather than as plain containers. */
+const ENGINE_IMAGES = {
+    postgres: 'postgres',
+    postgis: 'postgres',
+    'timescale/timescaledb': 'postgres',
+    mysql: 'mysql',
+    mariadb: 'mariadb',
+    redis: 'redis',
+    valkey: 'redis',
+    mongo: 'mongo',
+    mongodb: 'mongo',
+};
+/**
+ * Names that mean "this value is a credential".
+ *
+ * Compose has no notion of a secret, so a password sits in the file as plain
+ * text. Copying it into `env` would move a credential into a manifest people
+ * commit; these keys become `secrets`, which Fleet injects at deploy time.
+ */
+const SECRET_HINT = /(PASSWORD|PASSWD|SECRET|TOKEN|APIKEY|API_KEY|ACCESS_KEY|PRIVATE|CREDENTIAL|_DSN|_URI|_URL_AUTH|SALT|CERT)/i;
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const asRecord = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+/** compose accepts both `KEY=value` lists and `{KEY: value}` maps. */
+function readEnv(raw) {
+    const out = {};
+    if (Array.isArray(raw)) {
+        for (const entry of raw) {
+            if (typeof entry !== 'string')
+                continue;
+            const eq = entry.indexOf('=');
+            if (eq < 0)
+                out[entry] = '';
+            else
+                out[entry.slice(0, eq)] = entry.slice(eq + 1);
+        }
+    }
+    else {
+        const map = asRecord(raw);
+        if (map)
+            for (const [k, v] of Object.entries(map))
+                out[k] = v == null ? '' : String(v);
+    }
+    return out;
+}
+/**
+ * "127.0.0.1:8080:80/tcp" → { host: 8080, container: 80 }.
+ *
+ * Counted from the end because the optional bind address is on the front, so
+ * the last two numbers are always the pair that matters.
+ */
+function readPorts(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    for (const entry of raw) {
+        if (typeof entry === 'number')
+            return { host: entry, container: entry };
+        if (typeof entry !== 'string') {
+            const obj = asRecord(entry);
+            if (obj && typeof obj.target === 'number') {
+                return { host: Number(obj.published ?? obj.target), container: obj.target };
+            }
+            continue;
+        }
+        const parts = entry.split('/')[0].split(':').filter(Boolean);
+        const nums = parts.map(Number).filter((n) => Number.isFinite(n));
+        if (!nums.length)
+            continue;
+        if (nums.length === 1)
+            return { host: nums[0], container: nums[0] };
+        return { host: nums[nums.length - 2], container: nums[nums.length - 1] };
+    }
+    return null;
+}
+/**
+ * The first named volume, plus every mount that was left behind.
+ *
+ * Both halves are returned because dropping something quietly is the whole
+ * problem: a bind mount that disappears is a directory the service expected
+ * and will not find, and reporting it only when nothing else matched meant the
+ * common case - one real volume beside one bind mount - said nothing at all.
+ */
+function readVolumes(raw) {
+    const skipped = [];
+    let volume = null;
+    if (!Array.isArray(raw))
+        return { volume, skipped };
+    for (const entry of raw) {
+        if (typeof entry !== 'string') {
+            const obj = asRecord(entry);
+            if (obj?.type === 'volume' && typeof obj.source === 'string' && typeof obj.target === 'string') {
+                if (!volume)
+                    volume = { name: obj.source, path: obj.target };
+                else
+                    skipped.push(`${obj.source}:${obj.target}`);
+            }
+            else if (obj?.type === 'bind') {
+                skipped.push(String(obj.source ?? 'bind mount'));
+            }
+            continue;
+        }
+        const [source, target] = entry.split(':');
+        if (!source || !target)
+            continue;
+        // A path is a bind mount of the developer's own machine, and means nothing
+        // on a node that has never seen that directory.
+        if (source.startsWith('.') || source.startsWith('/') || source.startsWith('~')) {
+            skipped.push(entry);
+            continue;
+        }
+        if (!volume)
+            volume = { name: source, path: target };
+        else
+            skipped.push(entry);
+    }
+    return { volume, skipped };
+}
+/** compose memory limits are "512m", "2g", or a byte count. */
+function readMemory(raw) {
+    if (raw == null)
+        return null;
+    const s = String(raw).trim().toLowerCase();
+    const m = s.match(/^(\d+(?:\.\d+)?)\s*([kmg])?b?$/);
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    switch (m[2]) {
+        case 'g': return `${Math.round(n * 1024)}Mi`;
+        case 'm': return `${Math.round(n)}Mi`;
+        case 'k': return `${Math.max(1, Math.round(n / 1024))}Mi`;
+        default: return `${Math.max(1, Math.round(n / (1024 * 1024)))}Mi`;
+    }
+}
+/** A health path out of a compose healthcheck, when one is discoverable. */
+function readHealthPath(raw) {
+    const hc = asRecord(raw);
+    if (!hc)
+        return null;
+    const test = hc.test;
+    const line = Array.isArray(test) ? test.join(' ') : typeof test === 'string' ? test : '';
+    const url = line.match(/https?:\/\/[^\s"']+/);
+    if (url) {
+        try {
+            return new URL(url[0]).pathname || '/';
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+const engineFor = (image) => {
+    const name = image.split('@')[0].split(':')[0].toLowerCase();
+    const bare = name.replace(/^(docker\.io|library)\//, '');
+    return ENGINE_IMAGES[bare] ?? ENGINE_IMAGES[bare.split('/').pop() ?? ''] ?? null;
+};
+const versionOf = (image) => {
+    const tag = image.split('@')[0].split(':')[1];
+    if (!tag || tag === 'latest')
+        return null;
+    const major = tag.match(/^(\d+)/);
+    return major ? major[1] : null;
+};
+/** YAML-safe scalar. Quoted unless it is unambiguously a bare word. */
+const scalar = (v) => /^[A-Za-z0-9._/-]+$/.test(v) && v !== '' ? v : JSON.stringify(v);
+export function composeToFleet(source, opts = {}) {
+    const notes = [];
+    const questions = [];
+    let doc;
+    try {
+        doc = parseYaml(source);
+    }
+    catch (err) {
+        throw new Error(`that file is not valid YAML: ${err.message}`);
+    }
+    const root = asRecord(doc);
+    const servicesRaw = asRecord(root?.services);
+    if (!servicesRaw || !Object.keys(servicesRaw).length) {
+        throw new Error('no services found — is this a docker-compose file?');
+    }
+    const fleetName = opts.fleet ?? 'homelab';
+    const dbNode = opts.node ?? null;
+    const services = [];
+    const databases = [];
+    /** Compose names that became databases, so `depends_on` can point at them. */
+    const asDatabase = new Set();
+    // Databases first, so a service's `uses` can reference one by name.
+    for (const [name, raw] of Object.entries(servicesRaw)) {
+        const svc = (asRecord(raw) ?? {});
+        const image = typeof svc.image === 'string' ? svc.image : '';
+        const engine = image ? engineFor(image) : null;
+        if (engine)
+            asDatabase.add(name);
+    }
+    for (const [name, raw] of Object.entries(servicesRaw)) {
+        const svc = (asRecord(raw) ?? {});
+        const image = typeof svc.image === 'string' ? svc.image : '';
+        const env = readEnv(svc.environment);
+        if (asDatabase.has(name)) {
+            const engine = engineFor(image);
+            const major = versionOf(image);
+            const lines = [`  ${name}:`];
+            lines.push(`    engine: ${major ? `${engine}@${major}` : engine}`);
+            if (dbNode)
+                lines.push(`    node: ${scalar(dbNode)}`);
+            else {
+                lines.push(`    node: CHANGE_ME`);
+                questions.push(`${name}: a database must name the node that holds its data. Replace CHANGE_ME with a node name, or re-run with --node.`);
+            }
+            // Compose states these as env; Fleet takes them as fields and manages
+            // the credential itself, so they are lifted rather than copied.
+            const dbName = env.POSTGRES_DB ?? env.MYSQL_DATABASE ?? env.MARIADB_DATABASE ?? env.MONGO_INITDB_DATABASE;
+            const dbUser = env.POSTGRES_USER ?? env.MYSQL_USER ?? env.MARIADB_USER ?? env.MONGO_INITDB_ROOT_USERNAME;
+            if (dbName)
+                lines.push(`    database: ${scalar(dbName)}`);
+            if (dbUser)
+                lines.push(`    user: ${scalar(dbUser)}`);
+            lines.push(`    backup: daily`);
+            databases.push(lines.join('\n'));
+            notes.push(`${name} became a managed ${engine} database — Fleet owns its volume, credentials and backups, so the password from your compose file is not carried over.`);
+            continue;
+        }
+        const lines = [`  ${name}:`];
+        // build or image, never both: the schema rejects it, and they mean
+        // different things.
+        if (svc.build != null && !image) {
+            const b = asRecord(svc.build);
+            const context = typeof svc.build === 'string' ? svc.build : typeof b?.context === 'string' ? b.context : '.';
+            lines.push(`    build: ${scalar(context)}`);
+        }
+        else if (image) {
+            lines.push(`    image: ${scalar(image)}`);
+            if (svc.build != null) {
+                notes.push(`${name}: compose set both build and image; kept image, because that is what compose would have run.`);
+            }
+        }
+        else {
+            lines.push(`    build: .`);
+            questions.push(`${name}: compose named neither an image nor a build context — check the build path.`);
+        }
+        lines.push('    placement: flexible');
+        const ports = readPorts(svc.ports) ?? readPorts(svc.expose);
+        if (ports) {
+            lines.push(`    port: ${ports.host}`);
+            if (ports.container !== ports.host)
+                lines.push(`    container_port: ${ports.container}`);
+        }
+        const mem = readMemory(asRecord(asRecord(asRecord(svc.deploy)?.resources)?.limits)?.memory ?? svc.mem_limit);
+        const cpus = asRecord(asRecord(asRecord(svc.deploy)?.resources)?.limits)?.cpus ?? svc.cpus;
+        const ram = mem ?? '512Mi';
+        const cpu = cpus != null && Number.isFinite(Number(cpus)) ? Number(cpus) : 0.5;
+        lines.push(`    resources: { ram: ${ram}, cpu: ${cpu} }`);
+        if (!mem)
+            notes.push(`${name}: compose set no memory limit, so 512Mi was assumed — the scheduler needs a number to place against.`);
+        const health = readHealthPath(svc.healthcheck);
+        lines.push(`    health: { path: ${health ?? '/'} }`);
+        if (svc.healthcheck && !health) {
+            notes.push(`${name}: its healthcheck is a command Fleet cannot reuse, so health falls back to "/" — set a real path if that is wrong.`);
+        }
+        const { volume: vol, skipped } = readVolumes(svc.volumes);
+        if (vol)
+            lines.push(`    volume: { name: ${scalar(vol.name)}, path: ${scalar(vol.path)} }`);
+        if (skipped.length) {
+            notes.push(`${name}: dropped ${skipped.join(', ')} — a service carries one named volume, and a bind mount of your own machine means nothing on a node.`);
+        }
+        // env vs secrets. A value compose leaves to interpolation is not in the
+        // file at all, so it cannot be copied - it becomes a secret to supply.
+        const plain = [];
+        const secrets = [];
+        for (const [k, v] of Object.entries(env)) {
+            if (!ENV_NAME.test(k)) {
+                notes.push(`${name}: dropped env key "${k}" — not a usable variable name.`);
+                continue;
+            }
+            const unresolved = v === '' || /^\$\{?[A-Za-z_]/.test(v);
+            if (SECRET_HINT.test(k) || unresolved)
+                secrets.push(k);
+            else
+                plain.push([k, v]);
+        }
+        if (plain.length) {
+            lines.push('    env:');
+            for (const [k, v] of plain)
+                lines.push(`      ${k}: ${scalar(v)}`);
+        }
+        if (secrets.length) {
+            lines.push(`    secrets: [${secrets.join(', ')}]`);
+            notes.push(`${name}: ${secrets.join(', ')} moved to secrets — set them with \`fleet secret set\`, so no credential lives in this file.`);
+        }
+        // `uses` names databases, not services — the parser rejects anything else
+        // with "is not a database in this manifest". compose's depends_on covers
+        // both, so it has to be split: the database half becomes `uses`, and the
+        // service half is dropped, because Fleet works out deploy order itself
+        // rather than taking it from the file.
+        const deps = Array.isArray(svc.depends_on)
+            ? svc.depends_on.filter((d) => typeof d === 'string')
+            : Object.keys(asRecord(svc.depends_on) ?? {});
+        const dbDeps = deps.filter((d) => asDatabase.has(d));
+        const svcDeps = deps.filter((d) => !asDatabase.has(d));
+        if (dbDeps.length)
+            lines.push(`    uses: [${dbDeps.join(', ')}]`);
+        if (svcDeps.length) {
+            notes.push(`${name}: depends_on ${svcDeps.join(', ')} was dropped — "uses" declares databases, and Fleet decides deploy order from the manifest rather than being told.`);
+        }
+        const replicas = asRecord(svc.deploy)?.replicas;
+        if (typeof replicas === 'number' && replicas > 1)
+            lines.push(`    replicas: ${replicas}`);
+        services.push(lines.join('\n'));
+    }
+    // A manifest requires at least one service - "a manifest with no services
+    // has nothing to deploy" is the product's rule, not an accident. A compose
+    // file that is only databases would otherwise emit an empty `services:` key,
+    // which YAML reads as null and the parser rejects with a message about
+    // records that explains nothing about what the reader actually did.
+    if (!services.length) {
+        const only = [...asDatabase].join(', ');
+        throw new Error(`every service in that file is a database (${only}), and a manifest needs something to deploy. ` +
+            `Fleet manages those engines for you — declare them alongside the application that uses them.`);
+    }
+    const out = [`fleet: ${scalar(fleetName)}`, '', 'services:', services.join('\n\n')];
+    if (databases.length)
+        out.push('', 'databases:', databases.join('\n\n'));
+    return { manifest: out.join('\n') + '\n', notes, questions };
+}

package/dist/index.js

@@ -17,6 +17,7 @@ const GROUPS = [
         [
             ['up [service]', 'Deploy the whole fleet.yaml, in dependency order'],
             ['init', 'Scaffold a fleet.yaml and Dockerfile from this repository'],
+            ['import [file]', 'Convert a docker-compose.yml into a fleet.yaml'],
             ['config show', 'Show the saved control plane and selected fleet'],
             ['use <fleet>', 'Select the default fleet for later commands'],
             ['auth login', 'Sign in and save a secure local session'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadurajfleetos/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Fleet OS command-line interface for deploying and orchestrating services on user-owned hardware",
   "type": "module",
   "license": "MIT",