@penpair/docker 0.1.3 → 0.3.0

package/dist/cli.js

@@ -2,4 +2,6 @@
 import { runCli } from "@penpair/core";
 import { dockerProfile } from "./index.js";
 // The same `penpair` command as @penpair/core, with the commands that run Penpot in Docker added.
-process.exitCode = await runCli(process.argv.slice(2), { local: dockerProfile });
+process.exitCode = await runCli(process.argv.slice(2), {
+    local: dockerProfile,
+});

package/dist/index.js

@@ -10,9 +10,14 @@ export { renderCompose } from "./template.js";
 /** The Docker way of running Penpot: what the `penpair` command is started with. */
 export const dockerProfile = {
     async preflight(runner) {
-        const version = await runner.run("docker", ["version", "--format", "{{.Server.Version}}"]);
-        if (version.code !== 0)
+        const version = await runner.run("docker", [
+            "version",
+            "--format",
+            "{{.Server.Version}}",
+        ]);
+        if (version.code !== 0) {
             throw new ConfigError("Docker is not running. Start Docker Desktop, wait until it says it is running, then run the command again.");
+        }
     },
     init: initDocker,
     up,

package/dist/init.js

@@ -13,12 +13,17 @@ export async function isPortFree(port, host = "127.0.0.1") {
     });
 }
 export async function firstFreePort(from, avoid = [], free = isPortFree) {
-    for (let port = from; port < from + 200; port++)
-        if (!avoid.includes(port) && (await free(port)))
+    for (let port = from; port < from + 200; port++) {
+        if (!avoid.includes(port) && (await free(port))) {
             return port;
+        }
+    }
     throw new Error(`no free port from ${from}`);
 }
-const ensureGitignore = (root, entry) => ensureGitignoreEntry(root, entry, { directory: true, comment: "penpair: generated compose file, secrets and backups" });
+const ensureGitignore = (root, entry) => ensureGitignoreEntry(root, entry, {
+    directory: true,
+    comment: "penpair: generated compose file, secrets and backups",
+});
 /**
  * Sets an instance up in a project: config (committed), then the generated compose file and secrets (in a git-ignored
  * directory). Running it again rewrites the compose file from the config; existing secrets are never replaced.
@@ -30,27 +35,43 @@ export async function initDocker(root, options = {}) {
         config = await loadConfig(root);
     }
     catch (error) {
-        if (!(error instanceof ConfigError) || !/No penpair\.config\.json/.test(error.message))
+        if (!(error instanceof ConfigError) || error.code !== "missing") {
             throw error;
+        }
         const free = options.isFree ?? isPortFree;
         const frontend = options.port ?? (await firstFreePort(9001, [], free));
-        const mail = options.mailPort ?? (await firstFreePort(1080, [frontend], free));
+        const mail = options.mailPort ??
+            (await firstFreePort(1080, [
+                frontend,
+            ], free));
         config = validateConfig({
             instance: options.instance ?? defaultInstanceName(root),
             penpotVersion: options.penpotVersion ?? testedPenpotVersion,
-            ports: { frontend, mail },
+            ports: {
+                frontend,
+                mail,
+            },
             directory: options.directory ?? ".penpair",
-            ...(options.composeProject ? { composeProject: options.composeProject } : {}),
+            ...(options.composeProject
+                ? {
+                    composeProject: options.composeProject,
+                }
+                : {}),
         });
         await writeFile(path.join(root, configFileName), `${JSON.stringify(config, null, 2)}\n`);
         createdConfig = true;
     }
-    if (isExternal(config))
+    if (isExternal(config)) {
         throw new ConfigError("This project uses a Penpot that someone else runs; there is nothing for Docker to set up.");
+    }
     const paths = instancePaths(root, config);
-    await mkdir(paths.directory, { recursive: true });
+    await mkdir(paths.directory, {
+        recursive: true,
+    });
     await writeFile(paths.compose, renderCompose(config));
-    const files = [paths.compose];
+    const files = [
+        paths.compose,
+    ];
     const createdSecrets = await writeSecretFile(paths.env, renderEnv(config, generateSecrets()));
     files.push(paths.env);
     let gitignoreAdded = false;
@@ -58,5 +79,11 @@ export async function initDocker(root, options = {}) {
         const directoryAdded = await ensureGitignore(root, config.directory);
         gitignoreAdded = (await ensureKeyFileIgnored(root)) || directoryAdded;
     }
-    return { config, createdConfig, createdSecrets, files, gitignoreAdded };
+    return {
+        config,
+        createdConfig,
+        createdSecrets,
+        files,
+        gitignoreAdded,
+    };
 }

package/dist/lifecycle.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { composeProjectOf, endpointIsInstance, frontendUrl, instancePaths, LifecycleError, } from "@penpair/core";
+import { composeProjectOf, endpointIsInstance, frontendUrl, doctorEditor, instancePaths, LifecycleError, } from "@penpair/core";
 import { readEnvValues } from "./secrets.js";
 const defaultSleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 const sleepOf = (c) => c.sleep ?? defaultSleep;
@@ -10,12 +10,22 @@ const say = (c, message) => c.log?.(message);
 /** `docker compose` arguments for this instance: its own project name, compose file and secrets. */
 export function composeArgs(c, ...rest) {
     const paths = instancePaths(c.root, c.config);
-    return ["compose", "-p", composeProjectOf(c.config), "-f", paths.compose, "--env-file", paths.env, ...rest];
+    return [
+        "compose",
+        "-p",
+        composeProjectOf(c.config),
+        "-f",
+        paths.compose,
+        "--env-file",
+        paths.env,
+        ...rest,
+    ];
 }
 async function docker(c, args, what) {
     const result = await c.runner.run("docker", args);
-    if (result.code !== 0)
+    if (result.code !== 0) {
         throw new LifecycleError(`${what} failed: ${result.stderr.trim().split("\n").slice(-3).join(" ") || `exit ${result.code}`}`);
+    }
     return result.stdout;
 }
 /** The frontend answers a few seconds before the backend does (502 until then); /readyz is 200 only when the backend is ready. */
@@ -24,9 +34,12 @@ export async function waitForHttp(c, url, timeoutMs = 240_000, stepMs = 3_000) {
     const doFetch = c.fetch ?? fetch;
     for (let waited = 0; waited <= timeoutMs; waited += stepMs) {
         try {
-            const response = await doFetch(url, { redirect: "manual" });
-            if (response.status < 500)
+            const response = await doFetch(url, {
+                redirect: "manual",
+            });
+            if (response.status < 500) {
                 return true;
+            }
         }
         catch {
             // not up yet
@@ -39,7 +52,10 @@ export async function up(c) {
     say(c, "starting the containers");
     await docker(c, composeArgs(c, "up", "-d"), "docker compose up");
     say(c, "waiting for Penpot to answer (the first start can take a few minutes)");
-    return { url: frontendUrl(c.config), ready: await waitForHttp(c, readyUrl(c.config)) };
+    return {
+        url: frontendUrl(c.config),
+        ready: await waitForHttp(c, readyUrl(c.config)),
+    };
 }
 /** Stops and removes the containers. Volumes are never removed: the design data stays. */
 export async function down(c) {
@@ -48,14 +64,21 @@ export async function down(c) {
 export function parseComposePs(output) {
     const rows = [];
     const text = output.trim();
-    if (text.startsWith("["))
+    if (text.startsWith("[")) {
         rows.push(...JSON.parse(text));
-    else
-        for (const line of text.split("\n").filter(Boolean))
+    }
+    else {
+        for (const line of text.split("\n").filter(Boolean)) {
             rows.push(JSON.parse(line));
+        }
+    }
     return rows.map((row) => {
         const r = row;
-        return { service: r.Service ?? r.Name ?? "?", state: r.State ?? "?", health: r.Health ?? "" };
+        return {
+            service: r.Service ?? r.Name ?? "?",
+            state: r.State ?? "?",
+            health: r.Health ?? "",
+        };
     });
 }
 export async function status(c) {
@@ -64,29 +87,50 @@ export async function status(c) {
     const url = frontendUrl(c.config);
     const answers = async (target, ok) => {
         try {
-            return ok((await (c.fetch ?? fetch)(target, { redirect: "manual" })).status);
+            return ok((await (c.fetch ?? fetch)(target, {
+                redirect: "manual",
+            })).status);
         }
         catch {
             return false;
         }
     };
-    return { services, frontendReachable: await answers(url, (code) => code < 500), backendReady: await answers(readyUrl(c.config), (code) => code === 200), url };
+    return {
+        services,
+        frontendReachable: await answers(url, (code) => code < 500),
+        backendReady: await answers(readyUrl(c.config), (code) => code === 200),
+        url,
+    };
 }
 async function containerOf(c, service) {
-    const id = (await docker(c, composeArgs(c, "ps", "-q", service), `docker compose ps ${service}`)).trim().split("\n")[0];
-    if (!id)
+    const id = (await docker(c, composeArgs(c, "ps", "-q", service), `docker compose ps ${service}`))
+        .trim()
+        .split("\n")[0];
+    if (!id) {
         throw new LifecycleError(`The ${service} container is not running. Run \`penpair up\` first.`);
+    }
     return id;
 }
 const countsSql = `select json_build_object('files',(select count(*) from file where deleted_at is null),'profiles',(select count(*) from profile),'teams',(select count(*) from team),'storageObjects',(select count(*) from storage_object),'fileRevisions',(select coalesce(json_agg(json_build_object('id',id,'name',name,'revn',revn) order by name,id),'[]'::json) from file where deleted_at is null))`;
 async function readCounts(c, container) {
-    const out = await docker(c, ["exec", container, "psql", "-U", "penpot", "-d", "penpot", "-tAc", countsSql], "reading the database counts");
+    const out = await docker(c, [
+        "exec",
+        container,
+        "psql",
+        "-U",
+        "penpot",
+        "-d",
+        "penpot",
+        "-tAc",
+        countsSql,
+    ], "reading the database counts");
     return JSON.parse(out.trim());
 }
 async function sha256File(file) {
     const hash = createHash("sha256");
-    for await (const chunk of createReadStream(file))
+    for await (const chunk of createReadStream(file)) {
         hash.update(chunk);
+    }
     return hash.digest("hex");
 }
 /**
@@ -97,29 +141,69 @@ export async function backup(c, label) {
     const paths = instancePaths(c.root, c.config);
     const stamp = (c.now?.() ?? new Date()).toISOString().replace(/[:.]/g, "-");
     const directory = path.join(paths.backups, label ? `${stamp}-${label}` : stamp);
-    await mkdir(directory, { recursive: true });
+    await mkdir(directory, {
+        recursive: true,
+    });
     const postgres = await containerOf(c, "penpot-postgres");
     const backend = await containerOf(c, "penpot-backend");
     say(c, "dumping the database");
-    const dump = await c.runner.run("docker", ["exec", postgres, "pg_dump", "-U", "penpot", "-d", "penpot", "-Fc"], { outFile: path.join(directory, "db.dump") });
-    if (dump.code !== 0)
+    const dump = await c.runner.run("docker", [
+        "exec",
+        postgres,
+        "pg_dump",
+        "-U",
+        "penpot",
+        "-d",
+        "penpot",
+        "-Fc",
+    ], {
+        outFile: path.join(directory, "db.dump"),
+    });
+    if (dump.code !== 0) {
         throw new LifecycleError(`pg_dump failed: ${dump.stderr.trim().slice(-200)}`);
+    }
     say(c, "archiving the assets");
-    const assets = await c.runner.run("docker", ["exec", backend, "tar", "czf", "-", "-C", "/opt/data/assets", "."], { outFile: path.join(directory, "assets.tgz") });
-    if (assets.code !== 0)
+    const assets = await c.runner.run("docker", [
+        "exec",
+        backend,
+        "tar",
+        "czf",
+        "-",
+        "-C",
+        "/opt/data/assets",
+        ".",
+    ], {
+        outFile: path.join(directory, "assets.tgz"),
+    });
+    if (assets.code !== 0) {
         throw new LifecycleError(`archiving the assets failed: ${assets.stderr.trim().slice(-200)}`);
-    const entry = async (name) => ({ name, sha256: await sha256File(path.join(directory, name)), bytes: (await stat(path.join(directory, name))).size });
+    }
+    const entry = async (name) => ({
+        name,
+        sha256: await sha256File(path.join(directory, name)),
+        bytes: (await stat(path.join(directory, name))).size,
+    });
     const manifest = {
         instance: c.config.instance,
         penpotVersion: c.config.penpotVersion,
         createdAt: (c.now?.() ?? new Date()).toISOString(),
-        ...(label ? { label } : {}),
-        files: { db: await entry("db.dump"), assets: await entry("assets.tgz") },
+        ...(label
+            ? {
+                label,
+            }
+            : {}),
+        files: {
+            db: await entry("db.dump"),
+            assets: await entry("assets.tgz"),
+        },
         counts: await readCounts(c, postgres),
         note: "Contains account data (password hashes). Never commit it. Keep the instance's .env with it.",
     };
     await writeFile(path.join(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
-    return { directory, manifest };
+    return {
+        directory,
+        manifest,
+    };
 }
 async function loadManifest(directory) {
     try {
@@ -131,7 +215,10 @@ async function loadManifest(directory) {
 }
 async function checksumChecks(directory, manifest) {
     const checks = [];
-    for (const key of ["db", "assets"]) {
+    for (const key of [
+        "db",
+        "assets",
+    ]) {
         const wanted = manifest.files[key];
         let actual = "missing";
         try {
@@ -140,13 +227,32 @@ async function checksumChecks(directory, manifest) {
         catch {
             // reported below
         }
-        checks.push({ check: `${wanted.name} checksum`, ok: actual === wanted.sha256, detail: actual === wanted.sha256 ? "matches the manifest" : `expected ${wanted.sha256.slice(0, 12)}, found ${actual.slice(0, 12)}` });
+        checks.push({
+            check: `${wanted.name} checksum`,
+            ok: actual === wanted.sha256,
+            detail: actual === wanted.sha256
+                ? "matches the manifest"
+                : `expected ${wanted.sha256.slice(0, 12)}, found ${actual.slice(0, 12)}`,
+        });
     }
     return checks;
 }
 const compareCounts = (wanted, found) => [
-    ...["files", "profiles", "teams", "storageObjects"].map((key) => ({ check: `restored ${key}`, ok: wanted[key] === found[key], detail: `${found[key]} (backup says ${wanted[key]})` })),
-    { check: "file revisions", ok: JSON.stringify(wanted.fileRevisions) === JSON.stringify(found.fileRevisions), detail: `${found.fileRevisions.length} files, ids, names and revisions ${JSON.stringify(wanted.fileRevisions) === JSON.stringify(found.fileRevisions) ? "match" : "differ"}` },
+    ...[
+        "files",
+        "profiles",
+        "teams",
+        "storageObjects",
+    ].map((key) => ({
+        check: `restored ${key}`,
+        ok: wanted[key] === found[key],
+        detail: `${found[key]} (backup says ${wanted[key]})`,
+    })),
+    {
+        check: "file revisions",
+        ok: JSON.stringify(wanted.fileRevisions) === JSON.stringify(found.fileRevisions),
+        detail: `${found.fileRevisions.length} files, ids, names and revisions ${JSON.stringify(wanted.fileRevisions) === JSON.stringify(found.fileRevisions) ? "match" : "differ"}`,
+    },
 ];
 /** Proves a backup can be restored without touching the instance: restores the dump into a throwaway Postgres and compares. */
 export async function verifyBackup(c, directory) {
@@ -154,39 +260,93 @@ export async function verifyBackup(c, directory) {
     const checks = await checksumChecks(directory, manifest);
     const name = `penpair-verify-${Math.random().toString(36).slice(2, 8)}`;
     say(c, "starting a throwaway Postgres");
-    await docker(c, ["run", "-d", "--name", name, "-e", "POSTGRES_USER=penpot", "-e", "POSTGRES_PASSWORD=verify", "-e", "POSTGRES_DB=penpot", "-v", `${path.resolve(directory)}:/backup:ro`, "postgres:15"], "starting the throwaway Postgres");
+    await docker(c, [
+        "run",
+        "-d",
+        "--name",
+        name,
+        "-e",
+        "POSTGRES_USER=penpot",
+        "-e",
+        "POSTGRES_PASSWORD=verify",
+        "-e",
+        "POSTGRES_DB=penpot",
+        "-v",
+        `${path.resolve(directory)}:/backup:ro`,
+        "postgres:15",
+    ], "starting the throwaway Postgres");
     try {
         let ready = false;
         for (let i = 0; i < 40 && !ready; i++) {
-            ready = (await c.runner.run("docker", ["exec", name, "pg_isready", "-U", "penpot", "-d", "penpot"])).code === 0;
-            if (!ready)
+            ready =
+                (await c.runner.run("docker", [
+                    "exec",
+                    name,
+                    "pg_isready",
+                    "-U",
+                    "penpot",
+                    "-d",
+                    "penpot",
+                ])).code === 0;
+            if (!ready) {
                 await sleepOf(c)(1_000);
+            }
         }
-        if (!ready)
+        if (!ready) {
             throw new LifecycleError("the throwaway Postgres did not become ready");
+        }
         say(c, "restoring the dump");
-        await c.runner.run("docker", ["exec", name, "pg_restore", "-U", "penpot", "-d", "penpot", "--no-owner", "/backup/db.dump"]);
+        await c.runner.run("docker", [
+            "exec",
+            name,
+            "pg_restore",
+            "-U",
+            "penpot",
+            "-d",
+            "penpot",
+            "--no-owner",
+            "/backup/db.dump",
+        ]);
         checks.push(...compareCounts(manifest.counts, await readCounts(c, name)));
-        const listing = await c.runner.run("tar", ["tzf", path.join(directory, manifest.files.assets.name)]);
+        const listing = await c.runner.run("tar", [
+            "tzf",
+            path.join(directory, manifest.files.assets.name),
+        ]);
         const entries = listing.stdout.split("\n").filter((line) => line && !line.endsWith("/")).length;
-        checks.push({ check: "asset files", ok: entries === manifest.counts.storageObjects, detail: `${entries} files in the tarball, ${manifest.counts.storageObjects} storage objects` });
+        checks.push({
+            check: "asset files",
+            ok: entries === manifest.counts.storageObjects,
+            detail: `${entries} files in the tarball, ${manifest.counts.storageObjects} storage objects`,
+        });
     }
     finally {
-        await c.runner.run("docker", ["rm", "-f", name]);
+        await c.runner.run("docker", [
+            "rm",
+            "-f",
+            name,
+        ]);
     }
-    return { ok: checks.every((check) => check.ok), checks };
+    return {
+        ok: checks.every((check) => check.ok),
+        checks,
+    };
 }
 /**
  * Replaces the instance's database and assets with a backup. A backup of the current data is taken first unless told
  * not to, the checksums are checked before anything is touched, and the counts are compared afterwards.
  */
 export async function restore(c, directory, options) {
-    if (!options.yes)
+    if (!options.yes) {
         throw new LifecycleError("Restoring replaces this instance's data. Run again with --yes to confirm.");
+    }
     const manifest = await loadManifest(directory);
     const checks = await checksumChecks(directory, manifest);
-    if (!checks.every((check) => check.ok))
-        return { ok: false, checks };
+    if (!checks.every((check) => check.ok)) {
+        return {
+            ok: false,
+            checks,
+        };
+    }
     let safetyBackup;
     if (!options.skipSafetyBackup) {
         try {
@@ -194,8 +354,9 @@ export async function restore(c, directory, options) {
             safetyBackup = (await backup(c, "pre-restore")).directory;
         }
         catch (error) {
-            if (!(error instanceof LifecycleError) || !/not running/.test(error.message))
+            if (!(error instanceof LifecycleError) || !/not running/.test(error.message)) {
                 throw error;
+            }
             say(c, "the instance is not running, so there is no current data to back up");
         }
     }
@@ -204,39 +365,119 @@ export async function restore(c, directory, options) {
     await docker(c, composeArgs(c, "up", "-d", "penpot-postgres", "penpot-valkey"), "starting the database");
     const postgres = await containerOf(c, "penpot-postgres");
     for (let i = 0; i < 60; i++) {
-        if ((await c.runner.run("docker", ["exec", postgres, "pg_isready", "-U", "penpot", "-d", "penpot"])).code === 0)
+        if ((await c.runner.run("docker", [
+            "exec",
+            postgres,
+            "pg_isready",
+            "-U",
+            "penpot",
+            "-d",
+            "penpot",
+        ])).code === 0) {
             break;
+        }
         await sleepOf(c)(1_000);
     }
     say(c, "replacing the database");
-    await docker(c, ["exec", postgres, "psql", "-U", "penpot", "-d", "postgres", "-c", "drop database penpot with (force)"], "dropping the database");
-    await docker(c, ["exec", postgres, "psql", "-U", "penpot", "-d", "postgres", "-c", "create database penpot"], "creating the database");
-    const loaded = await c.runner.run("docker", ["exec", "-i", postgres, "pg_restore", "-U", "penpot", "-d", "penpot", "--no-owner"], { inFile: path.join(directory, manifest.files.db.name) });
-    if (loaded.code !== 0)
+    await docker(c, [
+        "exec",
+        postgres,
+        "psql",
+        "-U",
+        "penpot",
+        "-d",
+        "postgres",
+        "-c",
+        "drop database penpot with (force)",
+    ], "dropping the database");
+    await docker(c, [
+        "exec",
+        postgres,
+        "psql",
+        "-U",
+        "penpot",
+        "-d",
+        "postgres",
+        "-c",
+        "create database penpot",
+    ], "creating the database");
+    const loaded = await c.runner.run("docker", [
+        "exec",
+        "-i",
+        postgres,
+        "pg_restore",
+        "-U",
+        "penpot",
+        "-d",
+        "penpot",
+        "--no-owner",
+    ], {
+        inFile: path.join(directory, manifest.files.db.name),
+    });
+    if (loaded.code !== 0) {
         throw new LifecycleError(`pg_restore failed: ${loaded.stderr.trim().slice(-200)}`);
+    }
     say(c, "replacing the assets");
     const volume = `${composeProjectOf(c.config)}_penpot_assets`;
-    const assets = await c.runner.run("docker", ["run", "--rm", "-i", "-v", `${volume}:/data`, "--entrypoint", "sh", `penpotapp/backend:${c.config.penpotVersion}`, "-c", "find /data -mindepth 1 -delete && tar xzf - -C /data"], { inFile: path.join(directory, manifest.files.assets.name) });
-    if (assets.code !== 0)
+    const assets = await c.runner.run("docker", [
+        "run",
+        "--rm",
+        "-i",
+        "-v",
+        `${volume}:/data`,
+        "--entrypoint",
+        "sh",
+        `penpotapp/backend:${c.config.penpotVersion}`,
+        "-c",
+        "find /data -mindepth 1 -delete && tar xzf - -C /data",
+    ], {
+        inFile: path.join(directory, manifest.files.assets.name),
+    });
+    if (assets.code !== 0) {
         throw new LifecycleError(`restoring the assets failed: ${assets.stderr.trim().slice(-200)}`);
+    }
     say(c, "starting everything again");
     await up(c);
     checks.push(...compareCounts(manifest.counts, await readCounts(c, await containerOf(c, "penpot-postgres"))));
-    return { ok: checks.every((check) => check.ok), checks, ...(safetyBackup ? { safetyBackup } : {}) };
+    return {
+        ok: checks.every((check) => check.ok),
+        checks,
+        ...(safetyBackup
+            ? {
+                safetyBackup,
+            }
+            : {}),
+    };
 }
 /** What is up, what is not, and what to do about it. */
 export async function doctor(c, options = {}) {
     const out = [];
-    const add = (check, ok, detail, remedy) => void out.push({ check, ok, detail, ...(remedy && !ok ? { remedy } : {}) });
-    const version = await c.runner.run("docker", ["version", "--format", "{{.Server.Version}}"]);
+    const add = (check, ok, detail, remedy) => void out.push({
+        check,
+        ok,
+        detail,
+        ...(remedy && !ok
+            ? {
+                remedy,
+            }
+            : {}),
+    });
+    const version = await c.runner.run("docker", [
+        "version",
+        "--format",
+        "{{.Server.Version}}",
+    ]);
     add("docker", version.code === 0, version.code === 0 ? `engine ${version.stdout.trim()}` : "not answering", "Start Docker Desktop (or the Docker daemon).");
-    if (version.code !== 0)
+    if (version.code !== 0) {
         return out;
+    }
     const paths = instancePaths(c.root, c.config);
     try {
         const mode = (await stat(paths.env)).mode & 0o777;
         const values = await readEnvValues(paths.env);
-        add("secrets file", mode === 0o600 && Boolean(values.PENPOT_SECRET_KEY) && Boolean(values.PENPOT_DATABASE_PASSWORD), `permissions ${mode.toString(8)}, keys ${values.PENPOT_SECRET_KEY && values.PENPOT_DATABASE_PASSWORD ? "present" : "missing"}`, "Run `penpair init` to create it, and `chmod 600` the file.");
+        add("secrets file", mode === 0o600 &&
+            Boolean(values.PENPOT_SECRET_KEY) &&
+            Boolean(values.PENPOT_DATABASE_PASSWORD), `permissions ${mode.toString(8)}, keys ${values.PENPOT_SECRET_KEY && values.PENPOT_DATABASE_PASSWORD ? "present" : "missing"}`, "Run `penpair init` to create it, and `chmod 600` the file.");
     }
     catch {
         add("secrets file", false, "missing", "Run `penpair init`.");
@@ -250,7 +491,12 @@ export async function doctor(c, options = {}) {
     }
     if (state) {
         const running = state.services.filter((s) => s.state === "running").map((s) => s.service);
-        const needed = ["penpot-frontend", "penpot-backend", "penpot-postgres", "penpot-mcp"];
+        const needed = [
+            "penpot-frontend",
+            "penpot-backend",
+            "penpot-postgres",
+            "penpot-mcp",
+        ];
         const missing = needed.filter((service) => !running.includes(service));
         add("containers", missing.length === 0, missing.length === 0 ? `${running.length} running` : `not running: ${missing.join(", ")}`, "Run `penpair up`.");
         add("frontend", state.frontendReachable, state.frontendReachable ? state.url : `${state.url} does not answer`, "Run `penpair up` and wait for Penpot to start.");
@@ -260,13 +506,7 @@ export async function doctor(c, options = {}) {
         add("editor and plugin", false, `the MCP endpoint points at ${options.mcp.origin}, which is not this instance (${frontendUrl(c.config)})`, "Put this instance's MCP URL (Account, Integrations, MCP Server) in this project's .env.local as PENPAIR_MCP_URL.");
     }
     else if (options.mcp) {
-        try {
-            const { file } = await options.mcp.connect();
-            add("editor and plugin", true, `connected to file "${file}"`);
-        }
-        catch (error) {
-            add("editor and plugin", false, String(error.message).split("\n")[0] ?? "not connected", "Open a file in Penpot, choose File, MCP Server, Connect, and keep the tab visible.");
-        }
+        out.push(...(await doctorEditor(c.config, options)));
     }
     return out;
 }

package/dist/secrets.js

@@ -3,7 +3,10 @@ import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** A 512-bit master key for Penpot and a database password. Generated once; changing the password later breaks an existing database volume. */
 export function generateSecrets() {
-    return { secretKey: randomBytes(64).toString("base64url"), databasePassword: randomBytes(24).toString("base64url") };
+    return {
+        secretKey: randomBytes(64).toString("base64url"),
+        databasePassword: randomBytes(24).toString("base64url"),
+    };
 }
 export function renderEnv(config, secrets) {
     return `# Generated by penpair. Secrets: never commit, never print. Keep this file with the backups; the database password
@@ -15,13 +18,19 @@ PENPOT_DATABASE_PASSWORD=${secrets.databasePassword}
 }
 /** Writes a file readable by its owner only. Refuses to overwrite unless told to. */
 export async function writeSecretFile(file, content, overwrite = false) {
-    await mkdir(path.dirname(file), { recursive: true });
+    await mkdir(path.dirname(file), {
+        recursive: true,
+    });
     try {
-        await writeFile(file, content, { mode: 0o600, flag: overwrite ? "w" : "wx" });
+        await writeFile(file, content, {
+            mode: 0o600,
+            flag: overwrite ? "w" : "wx",
+        });
     }
     catch (error) {
-        if (error.code === "EEXIST")
+        if (error.code === "EEXIST") {
             return false;
+        }
         throw error;
     }
     await chmod(file, 0o600);
@@ -31,8 +40,9 @@ export async function readEnvValues(file) {
     const out = {};
     for (const line of (await readFile(file, "utf8")).split(/\r?\n/)) {
         const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line.trim());
-        if (match)
+        if (match) {
             out[match[1]] = match[2];
+        }
     }
     return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@penpair/docker",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Everything in @penpair/core, plus running Penpot in Docker on your computer: one instance per project, generated secrets, up and down, backup, verify and restore.",
   "license": "MIT",
   "repository": {
@@ -42,7 +42,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@penpair/core": "0.1.3"
+    "@penpair/core": "0.3.0"
   },
   "bin": {
     "penpair": "dist/cli.js"