@penpair/core 0.2.0 → 0.3.1

package/dist/instance/lifecycle.d.ts

@@ -1,129 +0,0 @@
-import { type ExternalConfig, type InstanceConfig, type ProjectConfig } from "./config.js";
-import type { Runner } from "./runner.js";
-export interface Context {
-    root: string;
-    config: InstanceConfig;
-    runner: Runner;
-    log?: (message: string) => void;
-    sleep?: (milliseconds: number) => Promise<void>;
-    fetch?: typeof fetch;
-    now?: () => Date;
-}
-export declare class LifecycleError extends Error {
-}
-/** `docker compose` arguments for this instance: its own project name, compose file and secrets. */
-export declare function composeArgs(c: Context, ...rest: string[]): string[];
-export declare const frontendUrl: (config: InstanceConfig) => string;
-/** The frontend answers a few seconds before the backend does (502 until then); /readyz is 200 only when the backend is ready. */
-export declare const readyUrl: (config: InstanceConfig) => string;
-export declare function waitForHttp(c: Context, url: string, timeoutMs?: number, stepMs?: number): Promise<boolean>;
-export declare function up(c: Context): Promise<{
-    url: string;
-    ready: boolean;
-}>;
-/** Stops and removes the containers. Volumes are never removed: the design data stays. */
-export declare function down(c: Context): Promise<void>;
-export interface ServiceState {
-    service: string;
-    state: string;
-    health: string;
-}
-export declare function parseComposePs(output: string): ServiceState[];
-export declare function status(c: Context): Promise<{
-    services: ServiceState[];
-    frontendReachable: boolean;
-    backendReady: boolean;
-    url: string;
-}>;
-export interface Counts {
-    files: number;
-    profiles: number;
-    teams: number;
-    storageObjects: number;
-    fileRevisions: {
-        id: string;
-        name: string;
-        revn: number;
-    }[];
-}
-export interface BackupManifest {
-    instance: string;
-    penpotVersion: string;
-    createdAt: string;
-    label?: string;
-    files: {
-        db: {
-            name: string;
-            sha256: string;
-            bytes: number;
-        };
-        assets: {
-            name: string;
-            sha256: string;
-            bytes: number;
-        };
-    };
-    counts: Counts;
-    note: string;
-}
-/**
- * A backup of the whole instance: a Postgres dump and a tarball of the asset volume, with checksums and the counts
- * that `backup verify` later checks a restore against. It holds account data (password hashes): never commit it.
- */
-export declare function backup(c: Context, label?: string): Promise<{
-    directory: string;
-    manifest: BackupManifest;
-}>;
-export interface Check {
-    check: string;
-    ok: boolean;
-    detail: string;
-}
-/** Proves a backup can be restored without touching the instance: restores the dump into a throwaway Postgres and compares. */
-export declare function verifyBackup(c: Context, directory: string): Promise<{
-    ok: boolean;
-    checks: Check[];
-}>;
-export interface RestoreOptions {
-    /** Restoring replaces the instance's data; it only runs when this is true. */
-    yes: boolean;
-    /** Skip the safety backup of the current data. */
-    skipSafetyBackup?: boolean;
-}
-/**
- * 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 declare function restore(c: Context, directory: string, options: RestoreOptions): Promise<{
-    ok: boolean;
-    checks: Check[];
-    safetyBackup?: string;
-}>;
-export interface DoctorCheck extends Check {
-    remedy?: string;
-}
-/**
- * A command that acts on a Penpot file must act on this project's instance. A key left in the agent's global configuration
- * (or any other key) can point at a different instance and silently drive the wrong file, so a mismatch is refused.
- */
-export declare function assertEndpointIsInstance(endpoint: {
-    source: string;
-    origin: string;
-}, config: ProjectConfig): void;
-export interface DoctorOptions {
-    /** Looks for the editor tab and the plugin through the MCP. `origin` is where the endpoint points, so a key for another instance is noticed. */
-    mcp?: {
-        origin: string;
-        connect: () => Promise<{
-            file: string;
-        }>;
-    };
-}
-/** Whether a configured MCP origin is this instance's frontend. */
-export declare function endpointIsInstance(origin: string, config: InstanceConfig): boolean;
-/** What is up, what is not, and what to do about it. */
-export declare function doctor(c: Context, options?: DoctorOptions): Promise<DoctorCheck[]>;
-/** The checks that make sense for a Penpot someone else runs: it answers, the key is for it, the editor and plugin are connected. */
-export declare function doctorExternal(config: ExternalConfig, options?: DoctorOptions & {
-    fetch?: typeof fetch;
-}): Promise<DoctorCheck[]>;

package/dist/instance/lifecycle.js

@@ -1,336 +0,0 @@
-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, instancePaths, isExternal } from "./config.js";
-import { readEnvValues } from "./secrets.js";
-const defaultSleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-const sleepOf = (c) => c.sleep ?? defaultSleep;
-const say = (c, message) => c.log?.(message);
-export class LifecycleError extends Error {
-}
-/** `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];
-}
-async function docker(c, args, what) {
-    const result = await c.runner.run("docker", args);
-    if (result.code !== 0)
-        throw new LifecycleError(`${what} failed: ${result.stderr.trim().split("\n").slice(-3).join(" ") || `exit ${result.code}`}`);
-    return result.stdout;
-}
-export const frontendUrl = (config) => `http://127.0.0.1:${config.ports.frontend}`;
-/** The frontend answers a few seconds before the backend does (502 until then); /readyz is 200 only when the backend is ready. */
-export const readyUrl = (config) => `${frontendUrl(config)}/readyz`;
-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)
-                return true;
-        }
-        catch {
-            // not up yet
-        }
-        await sleepOf(c)(stepMs);
-    }
-    return false;
-}
-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)) };
-}
-/** Stops and removes the containers. Volumes are never removed: the design data stays. */
-export async function down(c) {
-    await docker(c, composeArgs(c, "down"), "docker compose down");
-}
-export function parseComposePs(output) {
-    const rows = [];
-    const text = output.trim();
-    if (text.startsWith("["))
-        rows.push(...JSON.parse(text));
-    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 ?? "" };
-    });
-}
-export async function status(c) {
-    const output = await docker(c, composeArgs(c, "ps", "--all", "--format", "json"), "docker compose ps");
-    const services = output.trim() ? parseComposePs(output) : [];
-    const url = frontendUrl(c.config);
-    const answers = async (target, ok) => {
-        try {
-            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 };
-}
-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)
-        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");
-    return JSON.parse(out.trim());
-}
-async function sha256File(file) {
-    const hash = createHash("sha256");
-    for await (const chunk of createReadStream(file))
-        hash.update(chunk);
-    return hash.digest("hex");
-}
-/**
- * A backup of the whole instance: a Postgres dump and a tarball of the asset volume, with checksums and the counts
- * that `backup verify` later checks a restore against. It holds account data (password hashes): never commit it.
- */
-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 });
-    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)
-        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)
-        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 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") },
-        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 };
-}
-async function loadManifest(directory) {
-    try {
-        return JSON.parse(await readFile(path.join(directory, "manifest.json"), "utf8"));
-    }
-    catch {
-        throw new LifecycleError(`${directory} is not a penpair backup (no manifest.json)`);
-    }
-}
-async function checksumChecks(directory, manifest) {
-    const checks = [];
-    for (const key of ["db", "assets"]) {
-        const wanted = manifest.files[key];
-        let actual = "missing";
-        try {
-            actual = await sha256File(path.join(directory, wanted.name));
-        }
-        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)}` });
-    }
-    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"}` },
-];
-/** 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) {
-    const manifest = await loadManifest(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");
-    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)
-                await sleepOf(c)(1_000);
-        }
-        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"]);
-        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 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` });
-    }
-    finally {
-        await c.runner.run("docker", ["rm", "-f", name]);
-    }
-    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)
-        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 };
-    let safetyBackup;
-    if (!options.skipSafetyBackup) {
-        try {
-            say(c, "taking a safety backup of the current data first");
-            safetyBackup = (await backup(c, "pre-restore")).directory;
-        }
-        catch (error) {
-            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");
-        }
-    }
-    say(c, "stopping the application containers");
-    await docker(c, composeArgs(c, "stop", "penpot-frontend", "penpot-backend", "penpot-admin-console", "penpot-exporter", "penpot-mcp"), "stopping the application containers");
-    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)
-            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)
-        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)
-        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 } : {}) };
-}
-/**
- * A command that acts on a Penpot file must act on this project's instance. A key left in the agent's global configuration
- * (or any other key) can point at a different instance and silently drive the wrong file, so a mismatch is refused.
- */
-export function assertEndpointIsInstance(endpoint, config) {
-    if (isExternal(config)) {
-        if (sameOrigin(endpoint.origin, config.profile.origin))
-            return;
-        throw new LifecycleError(`The MCP endpoint (from ${endpoint.source}) points at ${endpoint.origin}, but this project uses ${config.profile.origin}. ` +
-            "Put that Penpot's MCP URL (Account, Integrations, MCP Server) in this project's .env.local as PENPAIR_MCP_URL, or run again with --any-instance if the other one is what you mean.");
-    }
-    if (endpointIsInstance(endpoint.origin, config))
-        return;
-    throw new LifecycleError(`The MCP endpoint (from ${endpoint.source}) points at ${endpoint.origin}, but this project's instance is ${frontendUrl(config)}. ` +
-        "Put this instance's MCP URL (Account, Integrations, MCP Server) in this project's .env.local as PENPAIR_MCP_URL, or run again with --any-instance if the other instance is what you mean.");
-}
-const sameOrigin = (a, b) => {
-    try {
-        return new URL(a).origin === new URL(b).origin;
-    }
-    catch {
-        return false;
-    }
-};
-/** Whether a configured MCP origin is this instance's frontend. */
-export function endpointIsInstance(origin, config) {
-    try {
-        const url = new URL(origin);
-        return ["localhost", "127.0.0.1"].includes(url.hostname) && Number(url.port || (url.protocol === "https:" ? 443 : 80)) === config.ports.frontend;
-    }
-    catch {
-        return false;
-    }
-}
-/** 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}}"]);
-    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)
-        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.");
-    }
-    catch {
-        add("secrets file", false, "missing", "Run `penpair init`.");
-    }
-    let state;
-    try {
-        state = await status(c);
-    }
-    catch (error) {
-        add("containers", false, String(error.message), "Run `penpair up`.");
-    }
-    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 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.");
-        add("backend", state.backendReady, state.backendReady ? "ready" : "not ready yet (the proxy answers, the backend does not)", "Wait a few seconds after `penpair up`; if it stays like this, read the backend log with `docker compose logs penpot-backend`.");
-    }
-    if (options.mcp && !endpointIsInstance(options.mcp.origin, c.config)) {
-        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.");
-        }
-    }
-    return out;
-}
-/** The checks that make sense for a Penpot someone else runs: it answers, the key is for it, the editor and plugin are connected. */
-export async function doctorExternal(config, options = {}) {
-    const out = [];
-    const add = (check, ok, detail, remedy) => void out.push({ check, ok, detail, ...(remedy && !ok ? { remedy } : {}) });
-    let reachable = false;
-    try {
-        reachable = (await (options.fetch ?? fetch)(config.profile.origin, { redirect: "manual" })).status < 500;
-    }
-    catch {
-        reachable = false;
-    }
-    add("penpot", reachable, reachable ? `${config.profile.origin} answers` : `${config.profile.origin} does not answer`, "Check the address and your network, then try again.");
-    if (!options.mcp)
-        return out;
-    if (!sameOrigin(options.mcp.origin, config.profile.origin)) {
-        add("editor and plugin", false, `the MCP endpoint points at ${options.mcp.origin}, which is not ${config.profile.origin}`, "Put this Penpot's MCP URL (Account, Integrations, MCP Server) in this project's .env.local as PENPAIR_MCP_URL.");
-        return out;
-    }
-    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.");
-    }
-    return out;
-}

package/dist/instance/secrets.d.ts

@@ -1,11 +0,0 @@
-import type { InstanceConfig } from "./config.js";
-export interface Secrets {
-    secretKey: string;
-    databasePassword: string;
-}
-/** A 512-bit master key for Penpot and a database password. Generated once; changing the password later breaks an existing database volume. */
-export declare function generateSecrets(): Secrets;
-export declare function renderEnv(config: InstanceConfig, secrets: Secrets): string;
-/** Writes a file readable by its owner only. Refuses to overwrite unless told to. */
-export declare function writeSecretFile(file: string, content: string, overwrite?: boolean): Promise<boolean>;
-export declare function readEnvValues(file: string): Promise<Record<string, string>>;

package/dist/instance/secrets.js

@@ -1,38 +0,0 @@
-import { randomBytes } from "node:crypto";
-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") };
-}
-export function renderEnv(config, secrets) {
-    return `# Generated by penpair. Secrets: never commit, never print. Keep this file with the backups; the database password
-# must stay the same for as long as the database volume exists.
-PENPOT_VERSION=${config.penpotVersion}
-PENPOT_SECRET_KEY=${secrets.secretKey}
-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 });
-    try {
-        await writeFile(file, content, { mode: 0o600, flag: overwrite ? "w" : "wx" });
-    }
-    catch (error) {
-        if (error.code === "EEXIST")
-            return false;
-        throw error;
-    }
-    await chmod(file, 0o600);
-    return true;
-}
-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)
-            out[match[1]] = match[2];
-    }
-    return out;
-}

package/dist/instance/template.d.ts

@@ -1,8 +0,0 @@
-import type { InstanceConfig } from "./config.js";
-/**
- * The compose file for one instance. It follows the official Penpot compose file; the local changes are the defaults
- * worth keeping: a pinned version, ports bound to 127.0.0.1, telemetry off, secrets only from `.env`, local mail capture,
- * the MCP server on. Container ports of the database, cache, admin console, exporter and MCP are not published; the
- * MCP is reached through the frontend at /mcp/stream.
- */
-export declare function renderCompose(config: InstanceConfig): string;