devpush 0.0.0-stage → 1.0.0-beta.3

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# devpush
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Deploy Docker Compose applications to your own servers with a git push. Run the dashboard on Node or Cloudflare Workers.
+
+- [Installation](https://devpu.sh/docs/self-hosting/)
+- [Package integration](https://devpu.sh/docs/package-installation/)
+- [Source and contributing](https://github.com/hunvreus/devpush)

package/agent-release.json

@@ -0,0 +1,37 @@
+{
+  "schemaVersion": 1,
+  "repository": "hunvreus/devpush",
+  "version": "1.0.0-beta.3",
+  "goVersion": "go1.27.3",
+  "protocolVersion": 1,
+  "capabilities": [
+    "jobs.compose.deploy.v1",
+    "jobs.compose.cleanup.v2",
+    "jobs.backup.v1",
+    "jobs.backup.archive.v1",
+    "jobs.backup.cleanup.v1",
+    "jobs.restore.v1",
+    "runtime.logs.v1",
+    "metrics.history.v1",
+    "ingress.certificates.v1",
+    "ingress.inactive-redirects.v1"
+  ],
+  "assets": [
+    {
+      "os": "linux",
+      "arch": "amd64",
+      "filename": "devpush-agent-linux-amd64",
+      "url": "https://github.com/hunvreus/devpush/releases/download/v1.0.0-beta.3/devpush-agent-linux-amd64",
+      "sha256": "0f7f68305fa23525dbb5701460df6dc37d533a183af01ee615638948d746ffac",
+      "size": 8212604
+    },
+    {
+      "os": "linux",
+      "arch": "arm64",
+      "filename": "devpush-agent-linux-arm64",
+      "url": "https://github.com/hunvreus/devpush/releases/download/v1.0.0-beta.3/devpush-agent-linux-arm64",
+      "sha256": "03893adc1cb03e4e453fe687912b4b2b687d94b47bab3f4a99b841ec2c57f36f",
+      "size": 7536764
+    }
+  ]
+}

package/dist/package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ronan Berder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/package/migrate.mjs

@@ -0,0 +1,182 @@
+// src/package/migrate.ts
+import { createClient } from "@libsql/client/web";
+
+// src/server/db/migrate-libsql.ts
+import { drizzle } from "drizzle-orm/libsql/web";
+import { migrate } from "drizzle-orm/libsql/migrator";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+
+// src/server/db/migration-history.ts
+function assertKnownMigrationHistory(appliedHashes, availableHashes, hasUntrackedTables) {
+  const known = new Set(availableHashes);
+  if (hasUntrackedTables || appliedHashes.some((hash) => !known.has(hash))) {
+    throw new Error(
+      "Database migration history does not match this release. The flattened baseline requires fresh main and log databases; back up/export existing data before recreating them. No migration was applied."
+    );
+  }
+}
+
+// src/server/db/migrate-libsql.ts
+async function migrateLibsql(client, migrationsFolder) {
+  const tracked = await client.execute(
+    "select name from sqlite_master where type='table' and name='__drizzle_migrations'"
+  );
+  const applied = tracked.rows.length ? (await client.execute("select hash from __drizzle_migrations")).rows.map(
+    (row) => String(row.hash)
+  ) : [];
+  const untracked = applied.length === 0 && (await client.execute(
+    "select name from sqlite_master where type='table' and name not like 'sqlite_%' and name <> '__drizzle_migrations' limit 1"
+  )).rows.length > 0;
+  assertKnownMigrationHistory(
+    applied,
+    readMigrationFiles({ migrationsFolder }).map((migration) => migration.hash),
+    untracked
+  );
+  await migrate(drizzle(client), { migrationsFolder });
+}
+
+// src/server/db/remote-config.ts
+function remoteDatabaseConfig(env) {
+  const main = env.DEVPUSH_DATABASE_URL?.trim();
+  const logs = env.DEVPUSH_LOG_DATABASE_URL?.trim();
+  if (!main && !logs) {
+    if (env.DEVPUSH_DATABASE_AUTH_TOKEN || env.DEVPUSH_LOG_DATABASE_AUTH_TOKEN)
+      throw new Error(
+        "Database authentication tokens require remote database URLs."
+      );
+    return void 0;
+  }
+  if (!main || !logs)
+    throw new Error(
+      "Configure both DEVPUSH_DATABASE_URL and DEVPUSH_LOG_DATABASE_URL."
+    );
+  function identity(value) {
+    let url;
+    try {
+      url = new URL(value);
+    } catch {
+      throw new Error("Invalid remote database URL.");
+    }
+    if (!["libsql:", "https:", "http:"].includes(url.protocol) || !url.hostname || url.username || url.password || url.hash)
+      throw new Error(
+        "Remote databases require libsql://, https:// or http:// URLs without embedded credentials or fragments."
+      );
+    return `${url.hostname}:${url.port || (url.protocol === "http:" ? "80" : "443")}${url.pathname.replace(/\/$/, "")}`;
+  }
+  if (identity(main) === identity(logs))
+    throw new Error("Main data and logs must use different remote databases.");
+  return {
+    main: { url: main, authToken: env.DEVPUSH_DATABASE_AUTH_TOKEN },
+    logs: { url: logs, authToken: env.DEVPUSH_LOG_DATABASE_AUTH_TOKEN }
+  };
+}
+
+// src/package/migrate.ts
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+
+// src/server/db/migrate-sqlite.ts
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Sqlite from "better-sqlite3";
+import { drizzle as drizzle2 } from "drizzle-orm/better-sqlite3";
+import { migrate as migrate2 } from "drizzle-orm/better-sqlite3/migrator";
+import { readMigrationFiles as readMigrationFiles2 } from "drizzle-orm/migrator";
+function migrateSqliteFile(path, migrationsFolder) {
+  if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+  const connection = new Sqlite(path);
+  try {
+    const tracked = connection.prepare(
+      "select name from sqlite_master where type='table' and name='__drizzle_migrations'"
+    ).get();
+    const applied = tracked ? connection.prepare("select hash from __drizzle_migrations").all() : [];
+    const untracked = applied.length === 0 && Boolean(
+      connection.prepare(
+        "select name from sqlite_master where type='table' and name not like 'sqlite_%' and name <> '__drizzle_migrations' limit 1"
+      ).get()
+    );
+    assertKnownMigrationHistory(
+      applied.map((row) => row.hash),
+      readMigrationFiles2({ migrationsFolder }).map(
+        (migration) => migration.hash
+      ),
+      untracked
+    );
+    connection.pragma("foreign_keys = ON");
+    connection.pragma("journal_mode = WAL");
+    connection.pragma("synchronous = FULL");
+    migrate2(drizzle2(connection), { migrationsFolder });
+  } finally {
+    connection.close();
+  }
+}
+
+// src/server/db/sqlite-files.ts
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname as dirname2, resolve } from "node:path";
+function assertSeparateSqliteFiles(mainPath, logPath) {
+  if (mainPath === ":memory:" || logPath === ":memory:") return;
+  let same = canonicalPath(mainPath) === canonicalPath(logPath);
+  if (!same && existsSync(mainPath) && existsSync(logPath)) {
+    const main = statSync(mainPath);
+    const logs = statSync(logPath);
+    same = main.dev === logs.dev && main.ino === logs.ino;
+  }
+  if (same) {
+    throw new Error(
+      "DEVPUSH_DATABASE_PATH and DEVPUSH_LOG_DATABASE_PATH must identify separate SQLite files."
+    );
+  }
+}
+function canonicalPath(path) {
+  const absolute = resolve(path);
+  if (existsSync(absolute)) return realpathSync(absolute);
+  const parent = dirname2(absolute);
+  if (parent === absolute) return absolute;
+  return resolve(canonicalPath(parent), basename(absolute));
+}
+
+// src/package/migrate.ts
+async function migrateNode(environment = process.env, options = {}) {
+  const migrationsDirectory = options.migrationsDirectory ?? fileURLToPath(new URL("../../src/server/db", import.meta.url));
+  const remote = remoteDatabaseConfig(environment);
+  if (remote) {
+    for (const [database, directory] of [
+      [remote.main, "migrations-sqlite"],
+      [remote.logs, "migrations-logs"]
+    ]) {
+      const client = createClient(database);
+      try {
+        await migrateLibsql(client, join(migrationsDirectory, directory));
+      } finally {
+        client.close();
+      }
+    }
+    console.log("Remote libSQL database migrations applied.");
+  } else {
+    const path = environment.DEVPUSH_DATABASE_PATH;
+    const logPath = environment.DEVPUSH_LOG_DATABASE_PATH;
+    if (!path && environment.NODE_ENV === "production") {
+      throw new Error("DEVPUSH_DATABASE_PATH is required in production.");
+    }
+    if (!logPath && environment.NODE_ENV === "production") {
+      throw new Error("DEVPUSH_LOG_DATABASE_PATH is required in production.");
+    }
+    assertSeparateSqliteFiles(
+      path ?? ".data/devpush.sqlite",
+      logPath ?? ".data/logs.sqlite"
+    );
+    migrateSqliteFile(
+      path ?? ".data/devpush.sqlite",
+      join(migrationsDirectory, "migrations-sqlite")
+    );
+    migrateSqliteFile(
+      logPath ?? ".data/logs.sqlite",
+      join(migrationsDirectory, "migrations-logs")
+    );
+    console.log("SQLite database migrations applied.");
+  }
+}
+export {
+  migrateNode
+};

package/dist/package/plugins.mjs

@@ -0,0 +1,125 @@
+// src/package/plugins.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/plugins/version.ts
+var pluginApiVersion = 3;
+
+// src/package/plugins.ts
+function definePlugin(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Plugin declaration must be an object.");
+  const plugin = value;
+  if (typeof plugin.id !== "string" || !/^[a-z][a-z0-9-]*$/.test(plugin.id))
+    throw new Error(
+      "Plugin IDs must use lowercase letters, numbers and hyphens."
+    );
+  if (plugin.apiVersion !== pluginApiVersion)
+    throw new Error(`Incompatible plugin API: ${plugin.id}`);
+  if (!Array.isArray(plugin.runtimes) || !plugin.runtimes.length || plugin.runtimes.some(
+    (runtime) => runtime !== "node" && runtime !== "cloudflare"
+  ))
+    throw new Error(`Invalid plugin runtimes: ${plugin.id}`);
+  for (const side of ["server", "client"]) {
+    const entry = plugin[side];
+    if (entry !== void 0 && typeof entry !== "string" && !(entry instanceof URL))
+      throw new Error(`Invalid ${side} entry for plugin ${plugin.id}.`);
+    if (entry instanceof URL && entry.protocol !== "file:")
+      throw new Error(`Plugin ${plugin.id} entries must use file URLs.`);
+  }
+  if (!plugin.server && !plugin.client)
+    throw new Error(`Plugin has no entry modules: ${plugin.id}`);
+  return Object.freeze({
+    ...plugin,
+    runtimes: Object.freeze([...plugin.runtimes])
+  });
+}
+function generatePlugins(plugins, target, root) {
+  const seen = /* @__PURE__ */ new Set();
+  const entries = plugins.map((value) => {
+    const plugin = definePlugin(value);
+    if (seen.has(plugin.id)) throw new Error(`Duplicate plugin: ${plugin.id}`);
+    seen.add(plugin.id);
+    if (!plugin.runtimes.includes(target))
+      throw new Error(`Plugin ${plugin.id} does not support ${target}.`);
+    function entry(module) {
+      if (module === void 0) return void 0;
+      const path = module instanceof URL ? fileURLToPath(module) : module;
+      if (!isAbsolute(path) || !existsSync(path) || !statSync(path).isFile())
+        throw new Error(
+          `Plugin ${plugin.id} entry must be an existing absolute file: ${path}`
+        );
+      return path.replaceAll("\\", "/");
+    }
+    return {
+      id: plugin.id,
+      server: entry(plugin.server),
+      client: entry(plugin.client)
+    };
+  });
+  const directory = resolve(root, ".devpush");
+  mkdirSync(directory, { recursive: true });
+  const paths = {
+    server: resolve(directory, "plugins.server.ts"),
+    client: resolve(directory, "plugins.ui.ts")
+  };
+  for (const side of ["server", "client"]) {
+    const selected = entries.filter((entry) => entry[side]);
+    const imports = selected.map(
+      (entry, index) => `import plugin${index} from ${JSON.stringify(entry[side])}`
+    );
+    const declarations = selected.map(
+      (entry, index) => `{ id: ${JSON.stringify(entry.id)}, implementation: plugin${index} }`
+    );
+    writeFileSync(
+      paths[side],
+      `${imports.join("\n")}
+export default [${declarations.join(",\n")}]
+`
+    );
+  }
+  return {
+    ...paths,
+    clientDirectories: [
+      ...new Set(
+        entries.flatMap(
+          (entry) => entry.client ? [dirname(entry.client)] : []
+        )
+      )
+    ],
+    serverEntries: entries.flatMap(
+      (entry) => entry.server ? [entry.server] : []
+    ),
+    packageNames: [
+      ...new Set(
+        entries.flatMap((entry) => {
+          const file = entry.server ?? entry.client;
+          if (!file) return [];
+          let packageDirectory = dirname(file);
+          for (; ; ) {
+            const manifest = resolve(packageDirectory, "package.json");
+            if (existsSync(manifest)) {
+              const metadata = JSON.parse(readFileSync(manifest, "utf8"));
+              return typeof metadata.name === "string" ? [metadata.name] : [];
+            }
+            const parent = dirname(packageDirectory);
+            if (parent === packageDirectory) return [];
+            packageDirectory = parent;
+          }
+        })
+      )
+    ]
+  };
+}
+export {
+  definePlugin,
+  generatePlugins,
+  pluginApiVersion
+};