@supatype/cli 0.1.0-alpha.10

package/src/systemd.ts

@@ -0,0 +1,137 @@
+/**
+ * systemd.ts — generate systemd unit files for self-hosted deployments.
+ *
+ * Usage:
+ *   generateUnits(config, outputDir)
+ *   → writes supatype-postgres.service + supatype-server.service to outputDir
+ */
+
+import { writeFileSync, mkdirSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { homedir } from "node:os"
+import type { SupatypeProjectConfig } from "./project-config.js"
+
+export interface SystemdOptions {
+  /** Directory where unit files are written. Defaults to .supatype/systemd/. */
+  outputDir?: string
+  /** User to run services as. Defaults to current user. */
+  user?: string
+  /** EnvironmentFile path injected into the units. Defaults to project .env. */
+  envFile?: string
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate supatype-postgres.service and supatype-server.service.
+ *
+ * Returns the paths of the written files.
+ */
+export function generateUnits(
+  config: SupatypeProjectConfig,
+  projectDir: string,
+  opts: SystemdOptions = {},
+): { postgres: string; server: string } {
+  const outputDir = opts.outputDir ?? resolve(projectDir, ".supatype", "systemd")
+  mkdirSync(outputDir, { recursive: true })
+
+  const user = opts.user ?? process.env["USER"] ?? "supatype"
+  const envFile = opts.envFile ?? resolve(projectDir, ".env")
+  const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
+
+  const postgresPath = join(outputDir, "supatype-postgres.service")
+  const serverPath = join(outputDir, "supatype-server.service")
+
+  writeFileSync(postgresPath, postgresUnit(config, stateDir, user, envFile), "utf8")
+  writeFileSync(serverPath, serverUnit(config, stateDir, user, envFile), "utf8")
+
+  return { postgres: postgresPath, server: serverPath }
+}
+
+// ---------------------------------------------------------------------------
+// Unit templates
+// ---------------------------------------------------------------------------
+
+function postgresUnit(
+  config: SupatypeProjectConfig,
+  stateDir: string,
+  user: string,
+  envFile: string,
+): string {
+  const dataDir = config.database.data_dir ?? join(stateDir, "data")
+  const logDir = join(stateDir, "logs")
+  const pgBinDir = `%h/.supatype/cache/postgres/${config.versions?.postgres ?? "latest"}/bin`
+
+  return `[Unit]
+Description=Supatype Postgres (${config.project.name})
+After=network.target
+StartLimitIntervalSec=60
+StartLimitBurst=5
+
+[Service]
+Type=forking
+User=${user}
+EnvironmentFile=-${envFile}
+ExecStartPre=/bin/mkdir -p ${logDir}
+ExecStart=${pgBinDir}/pg_ctl start \\
+  -D ${dataDir} \\
+  -l ${logDir}/postgres.log \\
+  -w \\
+  -t 60
+ExecStop=${pgBinDir}/pg_ctl stop -D ${dataDir} -m fast
+ExecReload=${pgBinDir}/pg_ctl reload -D ${dataDir}
+PIDFile=${stateDir}/pid/postgres.pid
+Restart=on-failure
+RestartSec=5s
+TimeoutStartSec=90
+TimeoutStopSec=30
+
+[Install]
+WantedBy=multi-user.target
+`
+}
+
+function serverUnit(
+  config: SupatypeProjectConfig,
+  stateDir: string,
+  user: string,
+  envFile: string,
+): string {
+  const port = config.server.port ?? 54321
+  const serverBin = `%h/.supatype/cache/server/${config.versions?.server ?? "latest"}/supatype-server`
+  const logDir = join(stateDir, "logs")
+
+  const extraArgs: string[] = [`--mode ${config.server.mode}`]
+  if (config.server.domain) extraArgs.push(`--domain ${config.server.domain}`)
+
+  return `[Unit]
+Description=Supatype Server (${config.project.name})
+After=network.target supatype-postgres.service
+Requires=supatype-postgres.service
+StartLimitIntervalSec=60
+StartLimitBurst=5
+
+[Service]
+Type=simple
+User=${user}
+EnvironmentFile=-${envFile}
+ExecStartPre=/bin/mkdir -p ${logDir}
+ExecStart=${serverBin} \\
+  --port ${port} \\
+  ${extraArgs.join(" \\\n  ")}
+PIDFile=${stateDir}/pid/server.pid
+StandardOutput=append:${logDir}/server.log
+StandardError=append:${logDir}/server.log
+Restart=on-failure
+RestartSec=5s
+TimeoutStartSec=30
+TimeoutStopSec=15
+KillMode=mixed
+KillSignal=SIGTERM
+
+[Install]
+WantedBy=multi-user.target
+`
+}

package/src/tsx-runner.ts

@@ -0,0 +1,89 @@
+/**
+ * Locates the tsx binary shipped with this package and provides a helper
+ * to run TypeScript files at runtime.
+ */
+
+import { spawnSync, type SpawnSyncOptions } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { resolve, dirname } from "node:path"
+import { createRequire } from "node:module"
+import { fileURLToPath } from "node:url"
+import { writeFileSync, unlinkSync } from "node:fs"
+import { tmpdir } from "node:os"
+
+const _require = createRequire(import.meta.url)
+
+// The CLI's own source directory — workspace packages are
+// resolvable from here. Eval snippets are written here so ESM resolution finds them.
+const CLI_SRC_DIR = dirname(fileURLToPath(import.meta.url))
+
+/**
+ * Resolve the absolute path to the tsx CLI entry point.
+ * tsx is a direct dependency so this will always succeed after `npm install`.
+ */
+function findTsxBin(): string {
+  try {
+    const pkgPath = _require.resolve("tsx/package.json")
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
+      bin?: string | Record<string, string>
+    }
+    const binRelative =
+      typeof pkg.bin === "string"
+        ? pkg.bin
+        : (pkg.bin?.["tsx"] ?? "./dist/cli.mjs")
+    return resolve(dirname(pkgPath), binRelative)
+  } catch {
+    return "tsx" // last-resort: hope it's on PATH
+  }
+}
+
+const TSX_BIN = findTsxBin()
+
+
+export interface RunResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+}
+
+/** Run a TypeScript file with tsx and capture output. */
+export function runTsFile(
+  filePath: string,
+  opts: SpawnSyncOptions = {},
+): RunResult {
+  const result = spawnSync(process.execPath, [TSX_BIN, filePath], {
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+    ...opts,
+  })
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: result.status ?? 1,
+  }
+}
+
+/**
+ * Evaluate an ESM TypeScript snippet via tsx and return its stdout.
+ * The snippet should write JSON to process.stdout.
+ */
+export function evalTsSnippet(
+  snippet: string,
+  opts: SpawnSyncOptions = {},
+): RunResult {
+  // Always write the temp file into the CLI's source directory so that ESM
+  // resolution can find workspace packages from there.
+  // The subprocess CWD is kept as opts.cwd (the user's project dir) so that
+  // any relative paths in the snippet resolve correctly.
+  const tmpFile = resolve(CLI_SRC_DIR, `supatype-eval-${Date.now()}.mts`)
+  writeFileSync(tmpFile, snippet, "utf8")
+  try {
+    return runTsFile(tmpFile, opts)
+  } finally {
+    try {
+      unlinkSync(tmpFile)
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}