kirby-deploy 0.0.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { runMain } from "citty";
+
+// src/commands/main.ts
+import { defineCommand as defineCommand3 } from "citty";
+import consola8 from "consola";
+import { colors as colors5 } from "consola/utils";
+import { readFileSync } from "fs";
+import { join as join5, relative } from "path/posix";
+import { cwd as cwd2 } from "process";
+
+// src/config.ts
+import { loadConfig as load } from "c12";
+import consola from "consola";
+import { flatten, parse } from "valibot";
+
+// src/types.ts
+import {
+  any,
+  array,
+  boolean,
+  literal,
+  number,
+  object,
+  optional,
+  record,
+  string,
+  union
+} from "valibot";
+var FolderStructureSchema = object({
+  content: string(),
+  media: string(),
+  accounts: string(),
+  sessions: string(),
+  cache: string()
+});
+var ConfigSchema = object({
+  host: string(),
+  user: string(),
+  password: string(),
+  url: optional(string()),
+  token: optional(string()),
+  remoteDir: optional(string()),
+  folderStructure: optional(
+    union([literal("flat"), literal("public"), FolderStructureSchema])
+  ),
+  checkComposerLock: optional(boolean()),
+  callWebhooks: optional(boolean()),
+  dryRun: optional(boolean()),
+  verbose: optional(boolean()),
+  parallel: optional(number()),
+  exclude: optional(array(string())),
+  excludeGlob: optional(array(string())),
+  include: optional(array(string())),
+  includeGlob: optional(array(string())),
+  lftpSettings: optional(record(string(), any())),
+  lftpFlags: optional(array(string()))
+});
+
+// src/config.ts
+var loadConfig = async () => {
+  let { config, configFile } = await load({
+    name: "kirby-deploy",
+    dotenv: true
+  });
+  if (!config) {
+    consola.error(new Error("no config file found"));
+    return null;
+  }
+  try {
+    parse(ConfigSchema, config);
+  } catch (e) {
+    const issues = flatten(e).nested;
+    const info = Object.entries(issues).map(([key, messages]) => `  - ${key} (${messages.join(", ")})`).join("\n");
+    consola.error(`Invalid properties in ${configFile}
+${info}`);
+    return null;
+  }
+  config.folderStructure ??= "flat";
+  if (config.folderStructure === "public") {
+    config.folderStructure = {
+      content: "content",
+      media: "public/media",
+      accounts: "storage/accounts",
+      sessions: "storage/sessions",
+      cache: "storage/cache"
+    };
+  } else if (config.folderStructure === "flat") {
+    config.folderStructure = {
+      content: "content",
+      media: "site/media",
+      accounts: "site/accounts",
+      sessions: "site/sessions",
+      cache: "site/cache"
+    };
+  }
+  config = {
+    remoteDir: "./",
+    dryRun: true,
+    parallel: 10,
+    checkComposerLock: true,
+    callWebhooks: true,
+    exclude: [],
+    excludeGlob: [],
+    include: [],
+    includeGlob: [],
+    ...config,
+    lftpSettings: {
+      "ftp:ssl-force": true,
+      ...config.lftpSettings
+    },
+    lftpFlags: ["--parallel=10", "--dereference", ...config.lftpFlags ?? []]
+  };
+  return config;
+};
+
+// src/lftp/cat.ts
+import { spawnSync } from "child_process";
+import consola2 from "consola";
+import { platform } from "os";
+var cat = (file, { host, user, password, lftpSettings }) => {
+  const commands = [
+    ...Object.entries(lftpSettings).map(
+      ([key, value]) => `set ${key} ${value}`
+    ),
+    `open ${host}`,
+    `user ${user} ${password}`,
+    `cat ${file}`,
+    "bye"
+  ];
+  const isWindows = platform() === "win32";
+  const child = isWindows ? spawnSync("wsl", ["lftp", "-c", commands.join("; ")], {
+    encoding: "utf-8"
+  }) : spawnSync("lftp", ["-c", commands.join("; ")], { encoding: "utf-8" });
+  if (child.stderr)
+    consola2.error(child.stderr);
+  return child.stdout;
+};
+
+// src/sync.ts
+import consola5 from "consola";
+import { join as join2 } from "path/posix";
+
+// src/lftp/mirror.ts
+import consola3 from "consola";
+import { colors } from "consola/utils";
+import { spawn } from "node:child_process";
+import { platform as platform2 } from "node:os";
+var mirror = (source, destination, flags, { lftpSettings, host, user, password, verbose }) => {
+  const commands = [
+    ...Object.entries(lftpSettings).map(
+      ([key, value]) => `set ${key} ${value}`
+    ),
+    `open ${host}`,
+    `user ${user} ${password}`,
+    // mask credentials
+    `mirror ${flags.join(" ")} ${source} ${destination}`,
+    "bye"
+  ];
+  const isWindows = platform2() === "win32";
+  const child = isWindows ? spawn("wsl", ["lftp", "-c", commands.join("; ")]) : spawn("lftp", ["-c", commands.join("; ")]);
+  let hasErrors = false;
+  let hasChanges = false;
+  const handleData = (data) => {
+    if (verbose)
+      consola3.log(`${colors.bgBlue(" LFTP ")} ${data}
+`);
+    data.toString().split("\n").forEach((line) => {
+      let match = null;
+      if (match = line.match(/Transferring file `(.*)'/)) {
+        hasChanges = true;
+        consola3.log(colors.blue(`\u2192 ${match[1]}`));
+      } else if (match = line.match(/Removing old (?:file|directory) `(.*)'/)) {
+        hasChanges = true;
+        consola3.log(colors.red(`\u2A2F ${match[1]}`));
+      }
+    });
+  };
+  const handleError = (data) => {
+    consola3.error(data.toString());
+    hasErrors = true;
+  };
+  return new Promise((resolve) => {
+    child.stdout.on("data", handleData);
+    child.stderr.on("data", handleError);
+    child.on("exit", () => resolve({ hasChanges, hasErrors }));
+  });
+};
+var logMirror = (source, destination, flags, { lftpSettings, host }) => {
+  const commands = [
+    ...Object.entries(lftpSettings).map(
+      ([key, value]) => `set ${key} ${value}`
+    ),
+    `open ${host}`,
+    `user <user> <password>`,
+    // mask credentials
+    `mirror ${flags.join(" ")} ${source} ${destination}`,
+    "bye"
+  ];
+  consola3.log(`
+${colors.bgBlue(" LFTP ")} ${commands.join("; ")}
+`);
+};
+
+// src/utils.ts
+import consola4 from "consola";
+import { colors as colors2 } from "consola/utils";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { cwd, stdin as input, stdout as output } from "node:process";
+import * as readline from "node:readline";
+var upperFirst = (string2) => string2.charAt(0).toUpperCase() + string2.slice(1);
+var isGit = () => existsSync(join(cwd(), ".git"));
+var getBranch = () => {
+  if (!isGit())
+    return;
+  const { stderr, stdout } = spawnSync2("git", ["branch", "--show-current"], {
+    encoding: "utf-8"
+  });
+  if (stderr) {
+    consola4.log(stderr);
+    return;
+  }
+  return stdout.trim();
+};
+var confirm = (question) => new Promise((resolve) => {
+  const rl = readline.createInterface({ input, output });
+  const formattedQuestion = `
+${question} ${colors2.yellow("(y/n)")} `;
+  rl.question(formattedQuestion, (answer) => {
+    rl.close();
+    const hasAgreed = ["yes", "y"].includes(answer.toLowerCase());
+    resolve(hasAgreed);
+  });
+});
+var callWebhook = async (url, token) => {
+  const result = await fetch(url, {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (result.status < 200 || result.status >= 300) {
+    consola4.error(`Failed to call webhook ${url}, status: ${result.status}`);
+    return false;
+  }
+  return true;
+};
+
+// src/sync.ts
+var sync = async (source, mode, config) => {
+  const reverse = mode === "push";
+  const targetName = mode === "push" ? "remote" : "local";
+  const webhook = `${config.url}/plugin-kirby-deploy`;
+  const destination = source === "./" ? config.remoteDir : `./${join2(config.remoteDir, source)}`;
+  const flags = [
+    "--continue",
+    "--only-newer",
+    "--overwrite",
+    "--use-cache",
+    "--delete",
+    "--verbose",
+    reverse && "--reverse",
+    ...config.exclude.map((path) => `--exclude ${path}`),
+    ...config.excludeGlob.map((path) => `--exclude-glob ${path}`),
+    ...config.includeGlob.map((path) => `--include-glob ${path}`),
+    ...config.include.map((path) => `--include ${path}`),
+    ...config.lftpFlags
+  ].filter(Boolean);
+  if (config.verbose) {
+    logMirror(source, destination, flags, config);
+  }
+  if (config.dryRun) {
+    consola5.log("Review changes...");
+    consola5.log("");
+    const { hasChanges: hasChanges2 } = await mirror(
+      source,
+      destination,
+      [...flags, "--dry-run"],
+      config
+    );
+    if (!hasChanges2) {
+      consola5.success(`${upperFirst(targetName)} already up to date`);
+      return false;
+    }
+    const shouldContinue = await confirm(`Apply changes to ${targetName}?`);
+    if (!shouldContinue)
+      return false;
+    consola5.log("");
+  }
+  consola5.log("Apply changes...\n");
+  if (config.callWebhooks)
+    await callWebhook(`${webhook}/start`, config.token);
+  let hasChanges, hasErrors;
+  try {
+    ;
+    ({ hasChanges, hasErrors } = await mirror(
+      source,
+      destination,
+      flags,
+      config
+    ));
+  } catch (e) {
+    consola5.error(e);
+    return false;
+  } finally {
+    if (config.callWebhooks) {
+      await callWebhook(`${webhook}/finish`, config.token);
+    }
+  }
+  if (!hasChanges) {
+    consola5.success(`${upperFirst(targetName)} already up to date`);
+    return false;
+  }
+  consola5.log("");
+  consola5.success(
+    hasErrors ? "All done (but with errors, see output above)!" : "All done!"
+  );
+  return true;
+};
+
+// src/commands/accounts.ts
+import { defineCommand } from "citty";
+import consola6 from "consola";
+import { colors as colors3 } from "consola/utils";
+import { join as join3 } from "path/posix";
+var syncAccounts = async (mode) => {
+  const config = await loadConfig();
+  if (!config)
+    return;
+  const { accounts } = config.folderStructure;
+  const source = `./${accounts}/`;
+  const branch = getBranch();
+  const displaySource = colors3.magenta(
+    `${source}${branch ? colors3.cyan(` (${branch})`) : ""}`
+  );
+  const displayDestination = colors3.magenta(
+    join3(config.host, config.remoteDir, source)
+  );
+  const direction = mode === "pull" ? "from" : "to";
+  consola6.log(
+    `\u{1F511} ${upperFirst(mode)} ${displaySource} ${direction} ${displayDestination}
+`
+  );
+  return sync(source, mode, {
+    ...config,
+    // User provided includes/excludes can only be used in the main command
+    // because they are relative to the base directory, so we reset them.
+    exclude: [],
+    excludeGlob: [".*", ".*/"],
+    include: [".htpasswd"],
+    // Make sure account passwords are synced.
+    includeGlob: []
+  });
+};
+var accountsPush = defineCommand({ run: () => syncAccounts("push") });
+var accountsPull = defineCommand({ run: () => syncAccounts("pull") });
+
+// src/commands/content.ts
+import { defineCommand as defineCommand2 } from "citty";
+import consola7 from "consola";
+import { colors as colors4 } from "consola/utils";
+import { join as join4 } from "path/posix";
+var syncContent = async (mode) => {
+  const config = await loadConfig();
+  if (!config)
+    return;
+  const { content } = config.folderStructure;
+  const source = `./${content}/`;
+  const branch = getBranch();
+  const displaySource = colors4.magenta(
+    `${source}${branch ? colors4.cyan(` (${branch})`) : ""}`
+  );
+  const displayDestination = colors4.magenta(
+    join4(config.host, config.remoteDir, source)
+  );
+  const direction = mode === "pull" ? "from" : "to";
+  consola7.log(
+    `\u{1F5C2}\uFE0F  ${upperFirst(mode)} ${displaySource} ${direction} ${displayDestination}
+`
+  );
+  return sync(source, mode, {
+    ...config,
+    // User provided includes/excludes can only be used in the main command
+    // because they are relative to the base directory, so we reset them.
+    exclude: [],
+    excludeGlob: [".*", ".*/"],
+    include: [],
+    includeGlob: []
+  });
+};
+var contentPush = defineCommand2({ run: () => syncContent("push") });
+var contentPull = defineCommand2({ run: () => syncContent("pull") });
+
+// src/commands/main.ts
+var main = defineCommand3({
+  run: async ({ rawArgs, cmd }) => {
+    const [firstArg] = rawArgs;
+    const subCommands = Object.keys(cmd.subCommands ?? {});
+    const isSubCommand = subCommands.includes(firstArg);
+    if (isSubCommand)
+      return;
+    const config = await loadConfig();
+    if (!config)
+      return;
+    const { folderStructure } = config;
+    const exclude = [
+      ...config.exclude,
+      "^node_modules/",
+      `^${relative(cwd2(), folderStructure.content)}`,
+      `^${relative(cwd2(), folderStructure.media)}`,
+      `^${relative(cwd2(), folderStructure.accounts)}`,
+      `^${relative(cwd2(), folderStructure.sessions)}`,
+      `^${relative(cwd2(), folderStructure.cache)}`
+    ];
+    const excludeGlob = [...config.excludeGlob, ".*", ".*/"];
+    const include = config.include;
+    const includeGlob = [...config.includeGlob, ".htaccess"];
+    const branch = getBranch();
+    const displaySource = branch ? colors5.cyan(` ${branch} `) : " ";
+    const displayDestination = colors5.magenta(
+      join5(config.host, config.remoteDir)
+    );
+    consola8.log(`\u{1F680} Deploy${displaySource}to ${displayDestination}
+`);
+    if (config.checkComposerLock) {
+      const localComposerLock = readFileSync("./composer.lock", {
+        encoding: "utf-8"
+      });
+      const remoteComposerLock = cat("./composer.lock", config);
+      const skipVendor = localComposerLock === remoteComposerLock;
+      if (skipVendor) {
+        exclude.push("^vendor/", "^kirby/");
+        consola8.info("Skipping vendor\n");
+      }
+    }
+    await sync("./", "push", {
+      ...config,
+      exclude,
+      excludeGlob,
+      include,
+      includeGlob
+    });
+  },
+  subCommands: {
+    ["content-push"]: contentPush,
+    ["content-pull"]: contentPull,
+    ["accounts-push"]: accountsPush,
+    ["accounts-pull"]: accountsPull
+  }
+});
+
+// src/cli.ts
+runMain(main);

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import * as valibot from 'valibot';
+import { Output } from 'valibot';
+
+declare const ConfigSchema: valibot.ObjectSchema<{
+    host: valibot.StringSchema<string>;
+    user: valibot.StringSchema<string>;
+    password: valibot.StringSchema<string>;
+    url: valibot.OptionalSchema<valibot.StringSchema<string>, undefined, string | undefined>;
+    token: valibot.OptionalSchema<valibot.StringSchema<string>, undefined, string | undefined>;
+    remoteDir: valibot.OptionalSchema<valibot.StringSchema<string>, undefined, string | undefined>;
+    folderStructure: valibot.OptionalSchema<valibot.UnionSchema<(valibot.LiteralSchema<"flat", "flat"> | valibot.LiteralSchema<"public", "public"> | valibot.ObjectSchema<{
+        content: valibot.StringSchema<string>;
+        media: valibot.StringSchema<string>;
+        accounts: valibot.StringSchema<string>;
+        sessions: valibot.StringSchema<string>;
+        cache: valibot.StringSchema<string>;
+    }, undefined, {
+        content: string;
+        media: string;
+        accounts: string;
+        sessions: string;
+        cache: string;
+    }>)[], "flat" | "public" | {
+        content: string;
+        media: string;
+        accounts: string;
+        sessions: string;
+        cache: string;
+    }>, undefined, "flat" | "public" | {
+        content: string;
+        media: string;
+        accounts: string;
+        sessions: string;
+        cache: string;
+    } | undefined>;
+    checkComposerLock: valibot.OptionalSchema<valibot.BooleanSchema<boolean>, undefined, boolean | undefined>;
+    callWebhooks: valibot.OptionalSchema<valibot.BooleanSchema<boolean>, undefined, boolean | undefined>;
+    dryRun: valibot.OptionalSchema<valibot.BooleanSchema<boolean>, undefined, boolean | undefined>;
+    verbose: valibot.OptionalSchema<valibot.BooleanSchema<boolean>, undefined, boolean | undefined>;
+    parallel: valibot.OptionalSchema<valibot.NumberSchema<number>, undefined, number | undefined>;
+    exclude: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<string>, string[]>, undefined, string[] | undefined>;
+    excludeGlob: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<string>, string[]>, undefined, string[] | undefined>;
+    include: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<string>, string[]>, undefined, string[] | undefined>;
+    includeGlob: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<string>, string[]>, undefined, string[] | undefined>;
+    lftpSettings: valibot.OptionalSchema<valibot.RecordSchema<valibot.StringSchema<string>, valibot.AnySchema<any>, {
+        [x: string]: any;
+    }>, undefined, {
+        [x: string]: any;
+    } | undefined>;
+    lftpFlags: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<string>, string[]>, undefined, string[] | undefined>;
+}, undefined, {
+    host: string;
+    user: string;
+    password: string;
+    url?: string | undefined;
+    token?: string | undefined;
+    remoteDir?: string | undefined;
+    folderStructure?: "flat" | "public" | {
+        content: string;
+        media: string;
+        accounts: string;
+        sessions: string;
+        cache: string;
+    } | undefined;
+    checkComposerLock?: boolean | undefined;
+    callWebhooks?: boolean | undefined;
+    dryRun?: boolean | undefined;
+    verbose?: boolean | undefined;
+    parallel?: number | undefined;
+    exclude?: string[] | undefined;
+    excludeGlob?: string[] | undefined;
+    include?: string[] | undefined;
+    includeGlob?: string[] | undefined;
+    lftpSettings?: {
+        [x: string]: any;
+    } | undefined;
+    lftpFlags?: string[] | undefined;
+}>;
+type Config = Output<typeof ConfigSchema>;
+
+declare const defineConfig: (config: Config) => {
+    host: string;
+    user: string;
+    password: string;
+    url?: string | undefined;
+    token?: string | undefined;
+    remoteDir?: string | undefined;
+    folderStructure?: "flat" | "public" | {
+        content: string;
+        media: string;
+        accounts: string;
+        sessions: string;
+        cache: string;
+    } | undefined;
+    checkComposerLock?: boolean | undefined;
+    callWebhooks?: boolean | undefined;
+    dryRun?: boolean | undefined;
+    verbose?: boolean | undefined;
+    parallel?: number | undefined;
+    exclude?: string[] | undefined;
+    excludeGlob?: string[] | undefined;
+    include?: string[] | undefined;
+    includeGlob?: string[] | undefined;
+    lftpSettings?: {
+        [x: string]: any;
+    } | undefined;
+    lftpFlags?: string[] | undefined;
+};
+
+export { defineConfig };

package/dist/index.js

@@ -0,0 +1,5 @@
+// src/index.ts
+var defineConfig = (config) => config;
+export {
+  defineConfig
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "kirby-deploy",
+  "version": "0.0.0",
+  "main": "./dist/index.js",
+  "type": "module",
+  "bin": {
+    "kirby-deploy": "./dist/cli.js"
+  },
+  "keywords": [],
+  "author": "Arno Schlipf",
+  "license": "MIT",
+  "devDependencies": {
+    "@prettier/plugin-php": "^0.22.2",
+    "@types/node": "^20.11.19",
+    "prettier": "^3.2.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "c12": "^1.8.0",
+    "citty": "^0.1.6",
+    "consola": "^3.2.3",
+    "valibot": "^0.28.1"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts",
+    "dev": "tsup src/index.ts src/cli.ts --format esm --watch",
+    "type-check": "tsc --noEmit"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { runMain } from 'citty'
+import { main } from './commands/main'
+
+runMain(main)

package/src/commands/accounts.ts

@@ -0,0 +1,40 @@
+import { defineCommand } from 'citty'
+import consola from 'consola'
+import { colors } from 'consola/utils'
+import { join } from 'path/posix'
+import { loadConfig } from '../config'
+import { sync } from '../sync'
+import { getBranch, upperFirst } from '../utils'
+
+const syncAccounts = async (mode: 'pull' | 'push') => {
+  const config = await loadConfig()
+  if (!config) return
+
+  const { accounts } = config.folderStructure
+  const source = `./${accounts}/`
+
+  const branch = getBranch()
+  const displaySource = colors.magenta(
+    `${source}${branch ? colors.cyan(` (${branch})`) : ''}`,
+  )
+  const displayDestination = colors.magenta(
+    join(config.host, config.remoteDir, source),
+  )
+  const direction = mode === 'pull' ? 'from' : 'to'
+  consola.log(
+    `🔑 ${upperFirst(mode)} ${displaySource} ${direction} ${displayDestination}\n`,
+  )
+
+  return sync(source, mode, {
+    ...config,
+    // User provided includes/excludes can only be used in the main command
+    // because they are relative to the base directory, so we reset them.
+    exclude: [],
+    excludeGlob: ['.*', '.*/'],
+    include: ['.htpasswd'], // Make sure account passwords are synced.
+    includeGlob: [],
+  })
+}
+
+export const accountsPush = defineCommand({ run: () => syncAccounts('push') })
+export const accountsPull = defineCommand({ run: () => syncAccounts('pull') })

package/src/commands/content.ts

@@ -0,0 +1,40 @@
+import { defineCommand } from 'citty'
+import consola from 'consola'
+import { colors } from 'consola/utils'
+import { join } from 'path/posix'
+import { loadConfig } from '../config'
+import { sync } from '../sync'
+import { getBranch, upperFirst } from '../utils'
+
+const syncContent = async (mode: 'pull' | 'push') => {
+  const config = await loadConfig()
+  if (!config) return
+
+  const { content } = config.folderStructure
+  const source = `./${content}/`
+
+  const branch = getBranch()
+  const displaySource = colors.magenta(
+    `${source}${branch ? colors.cyan(` (${branch})`) : ''}`,
+  )
+  const displayDestination = colors.magenta(
+    join(config.host, config.remoteDir, source),
+  )
+  const direction = mode === 'pull' ? 'from' : 'to'
+  consola.log(
+    `🗂️  ${upperFirst(mode)} ${displaySource} ${direction} ${displayDestination}\n`,
+  )
+
+  return sync(source, mode, {
+    ...config,
+    // User provided includes/excludes can only be used in the main command
+    // because they are relative to the base directory, so we reset them.
+    exclude: [],
+    excludeGlob: ['.*', '.*/'],
+    include: [],
+    includeGlob: [],
+  })
+}
+
+export const contentPush = defineCommand({ run: () => syncContent('push') })
+export const contentPull = defineCommand({ run: () => syncContent('pull') })

package/src/commands/main.ts

@@ -0,0 +1,73 @@
+import { defineCommand } from 'citty'
+import consola from 'consola'
+import { colors } from 'consola/utils'
+import { readFileSync } from 'fs'
+import { join, relative } from 'path/posix'
+import { cwd } from 'process'
+import { loadConfig } from '../config'
+import { cat } from '../lftp/cat'
+import { sync } from '../sync'
+import { getBranch } from '../utils'
+import { accountsPull, accountsPush } from './accounts'
+import { contentPull, contentPush } from './content'
+
+export const main = defineCommand({
+  run: async ({ rawArgs, cmd }) => {
+    // Todo: find a cleaner way to prevent the main command from running when
+    // when a sub command is run.
+    const [firstArg] = rawArgs
+    const subCommands = Object.keys(cmd.subCommands ?? {})
+    const isSubCommand = subCommands.includes(firstArg)
+    if (isSubCommand) return
+
+    const config = await loadConfig()
+    if (!config) return
+
+    const { folderStructure } = config
+    const exclude = [
+      ...config.exclude,
+      '^node_modules/',
+      `^${relative(cwd(), folderStructure.content)}`,
+      `^${relative(cwd(), folderStructure.media)}`,
+      `^${relative(cwd(), folderStructure.accounts)}`,
+      `^${relative(cwd(), folderStructure.sessions)}`,
+      `^${relative(cwd(), folderStructure.cache)}`,
+    ]
+    const excludeGlob = [...config.excludeGlob, '.*', '.*/']
+    const include = config.include
+    const includeGlob = [...config.includeGlob, '.htaccess']
+
+    const branch = getBranch()
+    const displaySource = branch ? colors.cyan(` ${branch} `) : ' '
+    const displayDestination = colors.magenta(
+      join(config.host, config.remoteDir),
+    )
+    consola.log(`🚀 Deploy${displaySource}to ${displayDestination}\n`)
+
+    if (config.checkComposerLock) {
+      const localComposerLock = readFileSync('./composer.lock', {
+        encoding: 'utf-8',
+      })
+      const remoteComposerLock = cat('./composer.lock', config)
+      const skipVendor = localComposerLock === remoteComposerLock
+      if (skipVendor) {
+        exclude.push('^vendor/', '^kirby/')
+        consola.info('Skipping vendor\n')
+      }
+    }
+
+    await sync('./', 'push', {
+      ...config,
+      exclude,
+      excludeGlob,
+      include,
+      includeGlob,
+    })
+  },
+  subCommands: {
+    ['content-push']: contentPush,
+    ['content-pull']: contentPull,
+    ['accounts-push']: accountsPush,
+    ['accounts-pull']: accountsPull,
+  },
+})

package/src/config.ts

@@ -0,0 +1,68 @@
+import { loadConfig as load } from 'c12'
+import consola from 'consola'
+import { flatten, parse } from 'valibot'
+import { Config, ConfigResolved, ConfigSchema } from './types'
+
+export const loadConfig = async (): Promise<ConfigResolved | null> => {
+  let { config, configFile } = await load<Config>({
+    name: 'kirby-deploy',
+    dotenv: true,
+  })
+
+  if (!config) {
+    consola.error(new Error('no config file found'))
+    return null
+  }
+
+  // Validate
+  try {
+    parse(ConfigSchema, config)
+  } catch (e: any) {
+    const issues = flatten<typeof ConfigSchema>(e).nested
+    const info = Object.entries(issues)
+      .map(([key, messages]) => `  - ${key} (${messages.join(', ')})`)
+      .join('\n')
+    consola.error(`Invalid properties in ${configFile}\n${info}`)
+    return null
+  }
+
+  // Resolve shorthands
+  config.folderStructure ??= 'flat'
+  if (config.folderStructure === 'public') {
+    config.folderStructure = {
+      content: 'content',
+      media: 'public/media',
+      accounts: 'storage/accounts',
+      sessions: 'storage/sessions',
+      cache: 'storage/cache',
+    }
+  } else if (config.folderStructure === 'flat') {
+    config.folderStructure = {
+      content: 'content',
+      media: 'site/media',
+      accounts: 'site/accounts',
+      sessions: 'site/sessions',
+      cache: 'site/cache',
+    }
+  }
+
+  config = {
+    remoteDir: './',
+    dryRun: true,
+    parallel: 10,
+    checkComposerLock: true,
+    callWebhooks: true,
+    exclude: [],
+    excludeGlob: [],
+    include: [],
+    includeGlob: [],
+    ...config,
+    lftpSettings: {
+      'ftp:ssl-force': true,
+      ...config.lftpSettings,
+    },
+    lftpFlags: ['--parallel=10', '--dereference', ...(config.lftpFlags ?? [])],
+  }
+
+  return config as ConfigResolved
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { Config } from './types'
+
+export const defineConfig = (config: Config) => config

package/src/lftp/cat.ts

@@ -0,0 +1,29 @@
+import { spawnSync } from 'child_process'
+import consola from 'consola'
+import { platform } from 'os'
+import { ConfigResolved } from '../types'
+
+export const cat = (
+  file: string,
+  { host, user, password, lftpSettings }: ConfigResolved,
+) => {
+  const commands = [
+    ...Object.entries(lftpSettings).map(
+      ([key, value]) => `set ${key} ${value}`,
+    ),
+    `open ${host}`,
+    `user ${user} ${password}`,
+    `cat ${file}`,
+    'bye',
+  ]
+
+  const isWindows = platform() === 'win32'
+  const child = isWindows
+    ? spawnSync('wsl', ['lftp', '-c', commands.join('; ')], {
+        encoding: 'utf-8',
+      })
+    : spawnSync('lftp', ['-c', commands.join('; ')], { encoding: 'utf-8' })
+
+  if (child.stderr) consola.error(child.stderr)
+  return child.stdout
+}

package/src/lftp/mirror.ts

@@ -0,0 +1,82 @@
+import consola from 'consola'
+import { colors } from 'consola/utils'
+import { spawn } from 'node:child_process'
+import { platform } from 'node:os'
+import { ConfigResolved } from '../types'
+
+interface Result {
+  hasChanges: boolean
+  hasErrors: boolean
+}
+
+export const mirror = (
+  source: string,
+  destination: string,
+  flags: string[],
+  { lftpSettings, host, user, password, verbose }: ConfigResolved,
+): Promise<Result> => {
+  const commands = [
+    ...Object.entries(lftpSettings).map(
+      ([key, value]) => `set ${key} ${value}`,
+    ),
+    `open ${host}`,
+    `user ${user} ${password}`, // mask credentials
+    `mirror ${flags.join(' ')} ${source} ${destination}`,
+    'bye',
+  ]
+  const isWindows = platform() === 'win32'
+  const child = isWindows
+    ? spawn('wsl', ['lftp', '-c', commands.join('; ')])
+    : spawn('lftp', ['-c', commands.join('; ')])
+
+  let hasErrors = false
+  let hasChanges = false
+
+  const handleData = (data: any) => {
+    if (verbose) consola.log(`${colors.bgBlue(' LFTP ')} ${data}\n`)
+    data
+      .toString()
+      .split('\n')
+      .forEach((line: string) => {
+        let match: RegExpMatchArray | null = null
+        if ((match = line.match(/Transferring file `(.*)'/))) {
+          hasChanges = true
+          consola.log(colors.blue(`→ ${match[1]}`))
+        } else if (
+          (match = line.match(/Removing old (?:file|directory) `(.*)'/))
+        ) {
+          hasChanges = true
+          consola.log(colors.red(`⨯ ${match[1]}`))
+        }
+      })
+  }
+
+  const handleError = (data: any) => {
+    consola.error(data.toString())
+    hasErrors = true
+  }
+
+  return new Promise<Result>((resolve) => {
+    child.stdout.on('data', handleData)
+    child.stderr.on('data', handleError)
+    child.on('exit', () => resolve({ hasChanges, hasErrors }))
+  })
+}
+
+export const logMirror = (
+  source: string,
+  destination: string,
+  flags: string[],
+  { lftpSettings, host }: ConfigResolved,
+) => {
+  const commands = [
+    ...Object.entries(lftpSettings).map(
+      ([key, value]) => `set ${key} ${value}`,
+    ),
+    `open ${host}`,
+    `user <user> <password>`, // mask credentials
+    `mirror ${flags.join(' ')} ${source} ${destination}`,
+    'bye',
+  ]
+  consola.log(`\n${colors.bgBlue(' LFTP ')} ${commands.join('; ')}\n`)
+}

package/src/sync.ts

@@ -0,0 +1,89 @@
+import consola from 'consola'
+import { join } from 'path/posix'
+import { logMirror, mirror } from './lftp/mirror'
+import { ConfigResolved } from './types'
+import { callWebhook, confirm, upperFirst } from './utils'
+
+export const sync = async (
+  source: string,
+  mode: 'pull' | 'push',
+  config: ConfigResolved,
+): Promise<boolean> => {
+  const reverse = mode === 'push'
+  const targetName = mode === 'push' ? 'remote' : 'local'
+  const webhook = `${config.url}/plugin-kirby-deploy`
+  const destination =
+    source === './' ? config.remoteDir : `./${join(config.remoteDir, source)}`
+
+  const flags = [
+    '--continue',
+    '--only-newer',
+    '--overwrite',
+    '--use-cache',
+    '--delete',
+    '--verbose',
+    reverse && '--reverse',
+    ...config.exclude.map((path: string) => `--exclude ${path}`),
+    ...config.excludeGlob.map((path: string) => `--exclude-glob ${path}`),
+    ...config.includeGlob.map((path: string) => `--include-glob ${path}`),
+    ...config.include.map((path: string) => `--include ${path}`),
+    ...config.lftpFlags,
+  ].filter(Boolean) as string[]
+
+  if (config.verbose) {
+    logMirror(source, destination, flags, config)
+  }
+
+  if (config.dryRun) {
+    consola.log('Review changes...')
+    consola.log('') // empty line
+
+    const { hasChanges } = await mirror(
+      source,
+      destination,
+      [...flags, '--dry-run'],
+      config,
+    )
+
+    if (!hasChanges) {
+      consola.success(`${upperFirst(targetName)} already up to date`)
+      return false
+    }
+
+    const shouldContinue = await confirm(`Apply changes to ${targetName}?`)
+    if (!shouldContinue) return false
+    consola.log('') // empty line
+  }
+
+  consola.log('Apply changes...\n')
+
+  // Make sure the finish hook is called even if an unexpected error occurs.
+  if (config.callWebhooks) await callWebhook(`${webhook}/start`, config.token)
+  let hasChanges, hasErrors
+  try {
+    ;({ hasChanges, hasErrors } = await mirror(
+      source,
+      destination,
+      flags,
+      config,
+    ))
+  } catch (e) {
+    consola.error(e)
+    return false
+  } finally {
+    if (config.callWebhooks) {
+      await callWebhook(`${webhook}/finish`, config.token)
+    }
+  }
+
+  if (!hasChanges) {
+    consola.success(`${upperFirst(targetName)} already up to date`)
+    return false
+  }
+
+  consola.log('') // empty line
+  consola.success(
+    hasErrors ? 'All done (but with errors, see output above)!' : 'All done!',
+  )
+  return true
+}

package/src/types.ts

@@ -0,0 +1,52 @@
+import {
+  Output,
+  any,
+  array,
+  boolean,
+  literal,
+  number,
+  object,
+  optional,
+  record,
+  string,
+  union,
+} from 'valibot'
+
+export const FolderStructureSchema = object({
+  content: string(),
+  media: string(),
+  accounts: string(),
+  sessions: string(),
+  cache: string(),
+})
+
+export type FolderStructure = Output<typeof FolderStructureSchema>
+
+export const ConfigSchema = object({
+  host: string(),
+  user: string(),
+  password: string(),
+  url: optional(string()),
+  token: optional(string()),
+  remoteDir: optional(string()),
+  folderStructure: optional(
+    union([literal('flat'), literal('public'), FolderStructureSchema]),
+  ),
+  checkComposerLock: optional(boolean()),
+  callWebhooks: optional(boolean()),
+  dryRun: optional(boolean()),
+  verbose: optional(boolean()),
+  parallel: optional(number()),
+  exclude: optional(array(string())),
+  excludeGlob: optional(array(string())),
+  include: optional(array(string())),
+  includeGlob: optional(array(string())),
+  lftpSettings: optional(record(string(), any())),
+  lftpFlags: optional(array(string())),
+})
+
+export type Config = Output<typeof ConfigSchema>
+
+export type ConfigResolved = Required<Omit<Config, 'folderStructure'>> & {
+  folderStructure: FolderStructure
+}

package/src/utils.ts

@@ -0,0 +1,54 @@
+import consola from 'consola'
+import { colors } from 'consola/utils'
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd, stdin as input, stdout as output } from 'node:process'
+import * as readline from 'node:readline'
+
+export const upperFirst = (string: string) =>
+  string.charAt(0).toUpperCase() + string.slice(1)
+
+export const isGit = () => existsSync(join(cwd(), '.git'))
+
+export const getBranch = (): string | undefined => {
+  if (!isGit()) return
+  const { stderr, stdout } = spawnSync('git', ['branch', '--show-current'], {
+    encoding: 'utf-8',
+  })
+  if (stderr) {
+    consola.log(stderr)
+    return
+  }
+  return stdout.trim()
+}
+
+export const confirm = (question: string): Promise<boolean> =>
+  new Promise((resolve) => {
+    const rl = readline.createInterface({ input, output })
+    const formattedQuestion = `\n${question} ${colors.yellow('(y/n)')} `
+    rl.question(formattedQuestion, (answer) => {
+      rl.close()
+      const hasAgreed = ['yes', 'y'].includes(answer.toLowerCase())
+      resolve(hasAgreed)
+    })
+  })
+
+export const callWebhook = async (
+  url: string,
+  token: string,
+): Promise<boolean> => {
+  const result = await fetch(url, {
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+  })
+
+  if (result.status < 200 || result.status >= 300) {
+    consola.error(`Failed to call webhook ${url}, status: ${result.status}`)
+    return false
+  }
+
+  return true
+}