@coreframe/scripts 0.0.0 → 0.1.0

package/deploy/version.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest"
+
+import { formatReleaseDate, nextReleaseVersion, releaseName } from "./version.ts"
+
+describe("nextReleaseVersion", () => {
+  it("starts a date release at patch zero", () => {
+    expect(nextReleaseVersion("0.0.0", new Date("2026-07-04T12:00:00"))).toBe("0.20260704.0")
+  })
+
+  it("increments same-day patches", () => {
+    expect(nextReleaseVersion("0.20260704.0", new Date("2026-07-04T18:00:00"))).toBe("0.20260704.1")
+  })
+
+  it("keeps the current major version", () => {
+    expect(nextReleaseVersion("2.20260703.7", new Date("2026-07-04T12:00:00"))).toBe("2.20260704.0")
+  })
+})
+
+describe("releaseName", () => {
+  it("combines package name and version", () => {
+    expect(releaseName("coreframe", "0.20260704.0")).toBe("coreframe@0.20260704.0")
+  })
+})
+
+describe("formatReleaseDate", () => {
+  it("formats the local date as YYYYMMDD", () => {
+    expect(formatReleaseDate(new Date(2026, 6, 4, 12))).toBe("20260704")
+  })
+})

package/deploy/version.ts

@@ -0,0 +1,65 @@
+import { readFile, writeFile } from "node:fs/promises"
+
+type PackageJson = {
+  name?: string
+  version?: string
+  [key: string]: unknown
+}
+
+type ReleasePackageJson = PackageJson & {
+  name: string
+  version: string
+}
+
+export function nextReleaseVersion(currentVersion: string, now = new Date()) {
+  const current = parseVersion(currentVersion)
+  const releaseDate = formatReleaseDate(now)
+  const patch = current.minor === releaseDate ? current.patch + 1 : 0
+
+  return `${current.major}.${releaseDate}.${patch}`
+}
+
+export function releaseName(packageName: string, version: string) {
+  return `${packageName}@${version}`
+}
+
+export function formatReleaseDate(date: Date) {
+  const year = String(date.getFullYear())
+  const month = String(date.getMonth() + 1).padStart(2, "0")
+  const day = String(date.getDate()).padStart(2, "0")
+
+  return `${year}${month}${day}`
+}
+
+export async function readPackageJson(path = "package.json") {
+  const source = await readFile(path, "utf8")
+  const packageJson = JSON.parse(source) as PackageJson
+
+  if (!packageJson.name) {
+    throw new Error(`${path} is missing a package name.`)
+  }
+
+  if (!packageJson.version) {
+    throw new Error(`${path} is missing a package version.`)
+  }
+
+  return { packageJson: packageJson as ReleasePackageJson, source }
+}
+
+export async function writePackageVersion(path: string, packageJson: PackageJson, version: string) {
+  await writeFile(path, `${JSON.stringify({ ...packageJson, version }, null, 2)}\n`)
+}
+
+function parseVersion(version: string) {
+  const match = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u.exec(version)
+
+  if (!match?.groups) {
+    throw new Error(`Invalid package version "${version}". Expected major.minor.patch.`)
+  }
+
+  return {
+    major: Number(match.groups.major),
+    minor: match.groups.minor,
+    patch: Number(match.groups.patch),
+  }
+}

package/deploy.test.ts

@@ -0,0 +1,101 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { describe, expect, it } from "vitest"
+
+import { parseDeployArgs, readProjectConfig } from "./deploy.ts"
+
+describe("parseDeployArgs", () => {
+  it("treats --yes as noninteractive migration approval", () => {
+    expect(parseDeployArgs(["--yes"])).toEqual({
+      runMigrations: true,
+      skipMigrations: false,
+      skipPostDeployChecks: false,
+      tauriLocalPlatforms: [],
+      tauriWorkflowName: undefined,
+      tauriWorkflowPlatforms: [],
+      tauriWorkflowRef: undefined,
+      yes: true,
+    })
+  })
+
+  it("supports explicit migration and post-deploy flags", () => {
+    expect(parseDeployArgs(["--skip-migrations", "--skip-post-deploy-checks"])).toEqual({
+      runMigrations: false,
+      skipMigrations: true,
+      skipPostDeployChecks: true,
+      tauriLocalPlatforms: [],
+      tauriWorkflowName: undefined,
+      tauriWorkflowPlatforms: [],
+      tauriWorkflowRef: undefined,
+      yes: false,
+    })
+  })
+
+  it("supports local and workflow Tauri platform selections", () => {
+    expect(
+      parseDeployArgs([
+        "--tauri-local-platform",
+        "macos,ios",
+        "--tauri-workflow-platform=windows",
+        "--tauri-workflow-platform",
+        "linux",
+        "--tauri-workflow-name",
+        "release-tauri.yml",
+        "--tauri-workflow-ref=main",
+      ]),
+    ).toEqual({
+      runMigrations: false,
+      skipMigrations: false,
+      skipPostDeployChecks: false,
+      tauriLocalPlatforms: ["macos", "ios"],
+      tauriWorkflowName: "release-tauri.yml",
+      tauriWorkflowPlatforms: ["windows", "linux"],
+      tauriWorkflowRef: "main",
+      yes: false,
+    })
+  })
+
+  it("rejects unknown Tauri platforms", () => {
+    expect(() => parseDeployArgs(["--tauri-local-platform", "solaris"])).toThrow(
+      'Invalid Tauri release platform "solaris".',
+    )
+  })
+})
+
+describe("readProjectConfig", () => {
+  it("returns empty config when coreframe.config.ts is missing", async () => {
+    const root = await mkdtemp(join(tmpdir(), "coreframe-config-missing-"))
+    const originalCwd = process.cwd()
+
+    try {
+      process.chdir(root)
+      await expect(readProjectConfig()).resolves.toEqual({})
+    } finally {
+      process.chdir(originalCwd)
+    }
+  })
+
+  it("loads coreframe.config.ts with dynamic import", async () => {
+    const root = await mkdtemp(join(tmpdir(), "coreframe-config-"))
+    const originalCwd = process.cwd()
+
+    await mkdir(root, { recursive: true })
+    await writeFile(
+      join(root, "coreframe.config.ts"),
+      "export default { deploy: { smokeChecks: [{ name: 'api', path: '/api/health' }] } }\n",
+    )
+
+    try {
+      process.chdir(root)
+      await expect(readProjectConfig()).resolves.toEqual({
+        deploy: {
+          smokeChecks: [{ name: "api", path: "/api/health" }],
+        },
+      })
+    } finally {
+      process.chdir(originalCwd)
+    }
+  })
+})

package/deploy.ts

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+import { access, writeFile } from "node:fs/promises"
+import { resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+
+import * as clack from "@clack/prompts"
+import nanoSpawn from "nano-spawn"
+
+import type { CoreframeConfig } from "./config.ts"
+import type { CoreframeDatabaseClient } from "./db/client.ts"
+import { createProjectDeployDatabase } from "./db/project.ts"
+import { runPostDeployChecks } from "./deploy/checks.ts"
+import { resolveDeployConfig } from "./deploy/config.ts"
+import type { TauriReleasePlatform } from "./deploy/config.ts"
+import {
+  collectDeployMigrationFiles,
+  formatMigrationList,
+  formatMigrationScanFailures,
+  scanDeployMigrationFiles,
+} from "./deploy/migrations.ts"
+import { filterPendingMigrations, readAppliedMigrationNames } from "./deploy/pending-migrations.ts"
+import {
+  parseTauriReleasePlatform,
+  prepareTauriRelease,
+  resolveTauriReleasePlan,
+  restoreTauriReleaseMetadata,
+  uploadTauriReleaseToB2,
+  validateTauriReleasePlan,
+  writeTauriReleaseMetadata,
+} from "./deploy/tauri-release.ts"
+import type { TauriReleaseMetadataSnapshot } from "./deploy/tauri-release.ts"
+import {
+  nextReleaseVersion,
+  readPackageJson,
+  releaseName,
+  writePackageVersion,
+} from "./deploy/version.ts"
+
+type DeployArgs = {
+  runMigrations: boolean
+  skipMigrations: boolean
+  skipPostDeployChecks: boolean
+  tauriLocalPlatforms: TauriReleasePlatform[]
+  tauriWorkflowName?: string
+  tauriWorkflowPlatforms: TauriReleasePlatform[]
+  tauriWorkflowRef?: string
+  yes: boolean
+}
+
+const packagePath = "package.json"
+const projectConfigPath = "coreframe.config.ts"
+
+export async function deployProject(argv = process.argv.slice(2), env = process.env) {
+  const args = parseDeployArgs(argv)
+  const { packageJson, source: originalPackageSource } = await readPackageJson(packagePath)
+  const version = nextReleaseVersion(packageJson.version)
+  const name = releaseName(packageJson.name, version)
+  const environment = env.DEPLOY_ENV ?? "production"
+  const releaseEnv = createReleaseEnv(env, name, packageJson.name, version)
+  const projectConfig = await readProjectConfig()
+  const config = resolveDeployConfig(projectConfig.deploy ?? {}, env)
+  const tauriReleasePlan = resolveTauriReleasePlan({
+    args,
+    config: config.tauriRelease,
+    env,
+  })
+  let externalMutated = false
+  let tauriMetadataSnapshot: TauriReleaseMetadataSnapshot = { files: [] }
+
+  clack.intro(`Deploy ${name}`)
+
+  validateDeployArgs(args)
+  requireEnv(env, ["POSTHOG_API_KEY", "POSTHOG_PROJECT_ID"])
+  await ensureCleanGit()
+  await validateTauriReleasePlan(tauriReleasePlan)
+
+  const database = await createProjectDeployDatabase({ env })
+  const pendingMigrations = await collectPendingMigrationsWithClose(database)
+  const migrationFailures = await scanDeployMigrationFiles(pendingMigrations)
+
+  if (migrationFailures.length > 0) {
+    throw new Error(
+      `Pending deploy migrations contain unsafe SQL. Move unsafe statements to held migrations.\n${formatMigrationScanFailures(migrationFailures)}`,
+    )
+  }
+
+  const shouldRunMigrations = await chooseMigrationExecution(args, pendingMigrations)
+
+  try {
+    await writePackageVersion(packagePath, packageJson, version)
+    tauriMetadataSnapshot = await writeTauriReleaseMetadata(tauriReleasePlan, version)
+
+    clack.log.step("Running pre-deploy build")
+    await nanoSpawn("pnpm", ["build"], {
+      env: createBuildCheckEnv(releaseEnv),
+      stdio: "inherit",
+    })
+
+    const tauriRelease = tauriReleasePlan.enabled
+      ? await prepareTauriRelease({
+          env: createBuildCheckEnv(releaseEnv),
+          plan: tauriReleasePlan,
+          releaseName: name,
+          version,
+        })
+      : undefined
+
+    clack.log.step("Running release build and uploading PostHog source maps")
+    externalMutated = true
+    await nanoSpawn("pnpm", ["build"], {
+      env: releaseEnv,
+      stdio: "inherit",
+    })
+
+    if (shouldRunMigrations) {
+      clack.log.step("Running deploy-safe database migrations")
+      await nanoSpawn("pnpm", ["db", "migrate"], {
+        env: releaseEnv,
+        stdio: "inherit",
+      })
+    }
+
+    clack.log.step("Deploying Worker and static assets to Cloudflare")
+    await nanoSpawn(
+      "pnpm",
+      [
+        "exec",
+        "wrangler",
+        "deploy",
+        "--strict",
+        "--keep-vars",
+        "--tag",
+        name,
+        "--message",
+        `Deploy ${name}`,
+        "--var",
+        `POSTHOG_RELEASE:${name}`,
+      ],
+      {
+        env: releaseEnv,
+        stdio: "inherit",
+      },
+    )
+
+    if (!args.skipPostDeployChecks) {
+      clack.log.step("Running post-deploy checks")
+      await runPostDeployChecks(config, {
+        environment,
+        productionUrl: config.productionUrl,
+        releaseName: name,
+        version,
+      })
+    }
+
+    if (tauriRelease) {
+      clack.log.step("Uploading Tauri release artifacts to Backblaze B2")
+      await uploadTauriReleaseToB2(tauriReleasePlan, tauriRelease)
+    }
+
+    clack.outro(`Deployed ${name}`)
+  } catch (error) {
+    if (!externalMutated) {
+      await writeFile(packagePath, originalPackageSource)
+      await restoreTauriReleaseMetadata(tauriMetadataSnapshot)
+    }
+
+    throw error
+  }
+}
+
+export async function readProjectConfig(): Promise<CoreframeConfig> {
+  const configPath = resolve(projectConfigPath)
+
+  try {
+    await access(configPath)
+  } catch {
+    return {}
+  }
+
+  const configUrl = pathToFileURL(configPath).href
+  const module = (await import(configUrl)) as { default?: CoreframeConfig }
+
+  return module.default ?? {}
+}
+
+export function parseDeployArgs(argv: string[]): DeployArgs {
+  return {
+    runMigrations: argv.includes("--run-migrations") || argv.includes("--yes"),
+    skipMigrations: argv.includes("--skip-migrations"),
+    skipPostDeployChecks: argv.includes("--skip-post-deploy-checks"),
+    tauriLocalPlatforms: parseRepeatedOption(argv, "--tauri-local-platform").map((platform) =>
+      parseTauriReleasePlatform(platform),
+    ),
+    tauriWorkflowName: parseOptionalOption(argv, "--tauri-workflow-name"),
+    tauriWorkflowPlatforms: parseRepeatedOption(argv, "--tauri-workflow-platform").map((platform) =>
+      parseTauriReleasePlatform(platform),
+    ),
+    tauriWorkflowRef: parseOptionalOption(argv, "--tauri-workflow-ref"),
+    yes: argv.includes("--yes"),
+  }
+}
+
+function parseRepeatedOption(argv: string[], name: string) {
+  const values = []
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+
+    if (arg === name) {
+      const value = argv[index + 1]
+
+      if (!value || value.startsWith("--")) {
+        throw new Error(`${name} requires a value.`)
+      }
+
+      values.push(...value.split(",").filter(Boolean))
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith(`${name}=`)) {
+      values.push(
+        ...arg
+          .slice(name.length + 1)
+          .split(",")
+          .filter(Boolean),
+      )
+    }
+  }
+
+  return values
+}
+
+function parseOptionalOption(argv: string[], name: string) {
+  const values = parseRepeatedOption(argv, name)
+
+  if (values.length > 1) {
+    throw new Error(`${name} can only be provided once.`)
+  }
+
+  return values[0]
+}
+
+async function collectPendingMigrationsWithClose(database: CoreframeDatabaseClient) {
+  try {
+    return await collectPendingMigrations(database)
+  } finally {
+    await database.close?.()
+  }
+}
+
+async function collectPendingMigrations(database: CoreframeDatabaseClient) {
+  const migrations = await collectDeployMigrationFiles()
+  const appliedMigrations = await readAppliedMigrationNames(database)
+
+  return filterPendingMigrations(migrations, appliedMigrations)
+}
+
+async function chooseMigrationExecution(
+  args: DeployArgs,
+  pendingMigrations: Awaited<ReturnType<typeof collectPendingMigrations>>,
+) {
+  if (pendingMigrations.length === 0) {
+    clack.log.info("No pending deploy migrations.")
+    return false
+  }
+
+  clack.note(formatMigrationList(pendingMigrations), "Pending deploy migrations")
+
+  if (args.runMigrations) {
+    return true
+  }
+
+  if (args.skipMigrations) {
+    return false
+  }
+
+  if (!process.stdout.isTTY) {
+    throw new Error(
+      "Pending migrations require --run-migrations or --skip-migrations in noninteractive deploys.",
+    )
+  }
+
+  const answer = await clack.confirm({
+    initialValue: true,
+    message: "Run these deploy-safe database migrations before Cloudflare deploy?",
+  })
+
+  if (clack.isCancel(answer)) {
+    clack.cancel("Deploy cancelled.")
+    throw new Error("Deploy cancelled.")
+  }
+
+  return answer
+}
+
+async function ensureCleanGit() {
+  const { stdout: status } = await nanoSpawn("git", ["status", "--porcelain"], { stdin: "ignore" })
+
+  if (status.trim().length > 0) {
+    throw new Error("Deploy requires a clean git tree before the release version is applied.")
+  }
+}
+
+function validateDeployArgs(args: DeployArgs) {
+  if (args.runMigrations && args.skipMigrations) {
+    throw new Error("Use only one of --run-migrations, --skip-migrations, or --yes.")
+  }
+}
+
+function requireEnv<const Name extends string>(env: NodeJS.ProcessEnv, names: readonly Name[]) {
+  const missing = names.filter((name) => !env[name])
+
+  if (missing.length > 0) {
+    throw new Error(`Missing required deploy environment variables: ${missing.join(", ")}`)
+  }
+
+  return Object.fromEntries(names.map((name) => [name, env[name]])) as Record<Name, string>
+}
+
+function createReleaseEnv(
+  env: NodeJS.ProcessEnv,
+  name: string,
+  packageName: string,
+  version: string,
+): NodeJS.ProcessEnv {
+  return {
+    ...env,
+    POSTHOG_RELEASE: name,
+    POSTHOG_RELEASE_NAME: env.POSTHOG_RELEASE_NAME ?? packageName,
+    POSTHOG_RELEASE_VERSION: env.POSTHOG_RELEASE_VERSION ?? version,
+  }
+}
+
+function createBuildCheckEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+  const { POSTHOG_API_KEY: _apiKey, POSTHOG_PROJECT_ID: _projectId, ...buildEnv } = env
+
+  return buildEnv
+}
+
+if (import.meta.main) {
+  deployProject().catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })
+}

package/dev.test.ts

@@ -0,0 +1,153 @@
+import type { spawn as nodeSpawn } from "node:child_process"
+import { EventEmitter } from "node:events"
+import { mkdtemp, readFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { PassThrough } from "node:stream"
+
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+import { runDevServer } from "./dev.ts"
+
+type SpawnCall = {
+  args: readonly string[]
+  command: string
+  options: { cwd?: string; env?: NodeJS.ProcessEnv; stdio?: unknown }
+}
+
+const stdioSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true)
+const stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true)
+
+afterEach(() => {
+  stdioSpy.mockClear()
+  stderrSpy.mockClear()
+})
+
+describe("runDevServer", () => {
+  it("ensures the database before starting React Router and tees output to a local log", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "coreframe-dev-"))
+    const logPath = path.join(tempDir, ".agents/logs/dev-server.log")
+    const calls: SpawnCall[] = []
+    const spawn = createSpawn(calls, 0)
+
+    await runDevServer({
+      cwd: tempDir,
+      env: { PATH: "/usr/bin" },
+      logPath,
+      spawn,
+    })
+
+    expect(calls).toEqual([
+      expect.objectContaining({
+        args: ["db", "ensure"],
+        command: process.platform === "win32" ? "pnpm.cmd" : "pnpm",
+        options: expect.objectContaining({ cwd: tempDir }),
+      }),
+      expect.objectContaining({
+        args: ["dev"],
+        command: process.platform === "win32" ? "react-router.cmd" : "react-router",
+        options: expect.objectContaining({
+          cwd: tempDir,
+          env: expect.objectContaining({
+            CLOUDFLARE_ENV: "development",
+            PATH: expect.stringContaining(`node_modules${path.sep}.bin`),
+          }),
+        }),
+      }),
+    ])
+
+    await expect(readFile(logPath, "utf8")).resolves.toContain("pnpm db ensure stdout")
+    await expect(readFile(logPath, "utf8")).resolves.toContain("react-router dev stderr")
+  })
+
+  it("runs Tauri dev for a requested platform and tees its output", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "coreframe-dev-"))
+    const logPath = path.join(tempDir, ".agents/logs/dev-server.log")
+    const calls: SpawnCall[] = []
+    const spawn = createSpawn(calls, 0)
+
+    await runDevServer({
+      cwd: tempDir,
+      logPath,
+      platform: "ios",
+      spawn,
+    })
+
+    expect(calls).toEqual([
+      expect.objectContaining({
+        args: ["--dir=tauri", "tauri", "ios", "dev"],
+        command: process.platform === "win32" ? "pnpm.cmd" : "pnpm",
+        options: expect.objectContaining({ cwd: tempDir }),
+      }),
+    ])
+
+    await expect(readFile(logPath, "utf8")).resolves.toContain(
+      "pnpm --dir=tauri tauri ios dev stdout",
+    )
+  })
+
+  it("does not tee again when Tauri starts the web dev command", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "coreframe-dev-"))
+    const logPath = path.join(tempDir, ".agents/logs/dev-server.log")
+    const calls: SpawnCall[] = []
+    const spawn = createSpawn(calls, 0)
+
+    await runDevServer({
+      cwd: tempDir,
+      env: { PATH: "/usr/bin", TAURI_ENV_PLATFORM: "ios" },
+      logPath,
+      spawn,
+    })
+
+    expect(calls).toEqual([
+      expect.objectContaining({
+        args: ["db", "ensure"],
+        options: expect.objectContaining({ stdio: "inherit" }),
+      }),
+      expect.objectContaining({
+        args: ["dev"],
+        options: expect.objectContaining({ stdio: "inherit" }),
+      }),
+    ])
+    await expect(readFile(logPath, "utf8")).rejects.toMatchObject({ code: "ENOENT" })
+  })
+
+  it("does not start React Router when database setup fails", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "coreframe-dev-"))
+    const calls: SpawnCall[] = []
+    const spawn = createSpawn(calls, 1)
+
+    await expect(
+      runDevServer({
+        cwd: tempDir,
+        logPath: path.join(tempDir, ".agents/logs/dev-server.log"),
+        spawn,
+      }),
+    ).rejects.toThrow("pnpm db ensure failed")
+
+    expect(calls).toHaveLength(1)
+  })
+})
+
+function createSpawn(calls: SpawnCall[], firstExitCode: number): typeof nodeSpawn {
+  return ((command: string, args: readonly string[], options: SpawnCall["options"]) => {
+    calls.push({ args, command, options })
+
+    const child = new EventEmitter() as EventEmitter & {
+      stderr: PassThrough
+      stdout: PassThrough
+    }
+    child.stderr = new PassThrough()
+    child.stdout = new PassThrough()
+
+    queueMicrotask(() => {
+      child.stdout.write(`${command} ${args.join(" ")} stdout\n`)
+      child.stderr.write(`${command} ${args.join(" ")} stderr\n`)
+      child.stdout.end()
+      child.stderr.end()
+      child.emit("close", calls.length === 1 ? firstExitCode : 0, null)
+    })
+
+    return child
+  }) as unknown as typeof nodeSpawn
+}