@coreframe/scripts 0.0.0 → 0.1.0

package/dev.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import { spawn as nodeSpawn } from "node:child_process"
+import { createWriteStream } from "node:fs"
+import { mkdir } from "node:fs/promises"
+import path from "node:path"
+import process from "node:process"
+import type { Readable } from "node:stream"
+
+type Spawn = typeof nodeSpawn
+type TeeProcess = {
+  on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): void
+  on(event: "error", listener: (error: Error) => void): void
+  stderr: Readable | null
+  stdout: Readable | null
+}
+
+export type DevServerOptions = {
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  logPath?: string
+  platform?: DevPlatform
+  spawn?: Spawn
+}
+
+export type DevPlatform = "android" | "desktop" | "ios" | "web"
+
+const defaultLogPath = ".agents/logs/dev-server.log"
+const nodeModulesBinPath = path.resolve("node_modules", ".bin")
+const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm"
+const reactRouterCommand =
+  process.platform === "win32" ? "react-router.cmd" : "react-router"
+
+export async function runDevServer({
+  cwd = process.cwd(),
+  env = process.env,
+  logPath = defaultLogPath,
+  platform = "web",
+  spawn = nodeSpawn,
+}: DevServerOptions = {}) {
+  const pathEnvValue = env.PATH ?? env.Path ?? ""
+  const shouldTee = !("TAURI_ENV_PLATFORM" in env)
+  const log = shouldTee ? await createDevLog(logPath) : undefined
+
+  try {
+    if (platform === "web") {
+      await runDevProcess(spawn, pnpmCommand, ["db", "ensure"], {
+        cwd,
+        env,
+        log,
+      })
+
+      await runDevProcess(spawn, reactRouterCommand, ["dev"], {
+        cwd,
+        env: {
+          ...env,
+          CLOUDFLARE_ENV: "development",
+          PATH: nodeModulesBinPath + path.delimiter + pathEnvValue,
+        },
+        log,
+      })
+      return
+    }
+
+    await runDevProcess(spawn, pnpmCommand, tauriDevArgs(platform), {
+      cwd,
+      env,
+      log,
+    })
+  } finally {
+    await closeLog(log)
+  }
+}
+
+async function createDevLog(logPath: string) {
+  await mkdir(path.dirname(logPath), { recursive: true })
+  return createWriteStream(logPath, { flags: "w" })
+}
+
+function closeLog(log: NodeJS.WritableStream | undefined) {
+  if (!log) {
+    return Promise.resolve()
+  }
+
+  return new Promise<void>((resolve, reject) => {
+    log.once("error", reject)
+    log.end(resolve)
+  })
+}
+
+function tauriDevArgs(platform: Exclude<DevPlatform, "web">) {
+  return ["--dir=tauri", "tauri", ...(platform === "desktop" ? [] : [platform]), "dev"]
+}
+
+function runDevProcess(
+  spawn: Spawn,
+  command: string,
+  args: string[],
+  {
+    cwd,
+    env,
+    log,
+  }: {
+    cwd: string
+    env: NodeJS.ProcessEnv
+    log: NodeJS.WritableStream | undefined
+  },
+) {
+  return new Promise<void>((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      stdio: log ? ["inherit", "pipe", "pipe"] : "inherit",
+    }) as unknown as TeeProcess
+
+    if (log) {
+      if (!child.stdout || !child.stderr) {
+        reject(new Error(`${[command, ...args].join(" ")} did not provide output streams`))
+        return
+      }
+
+      child.stdout.on("data", (chunk) => {
+        process.stdout.write(chunk)
+        log.write(chunk)
+      })
+
+      child.stderr.on("data", (chunk) => {
+        process.stderr.write(chunk)
+        log.write(chunk)
+      })
+    }
+
+    child.on("error", reject)
+
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve()
+        return
+      }
+
+      const commandText = [command, ...args].join(" ")
+      reject(
+        new Error(
+          `${commandText} failed${signal ? ` with signal ${signal}` : ` with exit code ${code ?? 1}`}`,
+        ),
+      )
+    })
+  })
+}
+
+if (import.meta.main) {
+  runDevServer().catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { DeployConfig } from "./deploy/config.ts";
+export type CoreframeConfig = {
+    deploy?: DeployConfig;
+};
+export declare function defineConfig(config: CoreframeConfig): CoreframeConfig;

package/dist/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/coreframe.d.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+export declare const coreframeCli: Partial<import("cmd-ts/dist/cjs/argparser").Register> & {
+    parse(context: import("cmd-ts/dist/cjs/argparser").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser").ParsingResult<{
+        command: "db";
+        args: {
+            command: "generate";
+            args: {
+                args: string[];
+            };
+        } | {
+            command: "migrate";
+            args: {
+                args: string[];
+            };
+        } | {
+            command: "studio";
+            args: {
+                args: string[];
+            };
+        } | {
+            command: "ensure";
+            args: {};
+        } | {
+            command: "migrate-held";
+            args: {
+                confirm: "run-held-migrations" | undefined;
+            };
+        } | {
+            command: "migrate-local";
+            args: {};
+        } | {
+            command: "migrations-check";
+            args: {};
+        } | {
+            command: "reset";
+            args: {};
+        } | {
+            command: "seed";
+            args: {};
+        } | {
+            command: "setup";
+            args: {};
+        };
+    } | {
+        command: "deploy";
+        args: {
+            runMigrations: boolean;
+            skipMigrations: boolean;
+            skipPostDeployChecks: boolean;
+            tauriLocalPlatforms: ("macos" | "windows" | "linux" | "ios" | "android")[];
+            tauriWorkflowName: string | undefined;
+            tauriWorkflowPlatforms: ("macos" | "windows" | "linux" | "ios" | "android")[];
+            tauriWorkflowRef: string | undefined;
+            yes: boolean;
+        };
+    } | {
+        command: "dev";
+        args: {
+            platform: "ios" | "android" | "desktop" | "web" | undefined;
+        };
+    } | {
+        command: "typecheck";
+        args: {};
+    } | {
+        command: "upgrade";
+        args: {
+            command: "ensure-template-remote";
+            args: {
+                remote: string;
+                noFetch: boolean;
+            };
+        } | {
+            command: "check-skill-current";
+            args: {
+                target: string;
+                apply: boolean;
+            };
+        } | {
+            command: "fast-forward-template-files";
+            args: {
+                target: string;
+                base: string | undefined;
+                apply: boolean;
+            };
+        };
+    }>>;
+} & import("cmd-ts/dist/cjs/helpdoc").Named & Partial<import("cmd-ts/dist/cjs/helpdoc").Descriptive & import("cmd-ts/dist/cjs/helpdoc").Versioned> & import("cmd-ts/dist/cjs/helpdoc").PrintHelp & Partial<import("cmd-ts/dist/cjs/helpdoc").Versioned> & import("cmd-ts/dist/cjs/argparser").Register & import("cmd-ts/dist/cjs/runner").Handling<{
+    command: "db";
+    args: {
+        command: "generate";
+        args: {
+            args: string[];
+        };
+    } | {
+        command: "migrate";
+        args: {
+            args: string[];
+        };
+    } | {
+        command: "studio";
+        args: {
+            args: string[];
+        };
+    } | {
+        command: "ensure";
+        args: {};
+    } | {
+        command: "migrate-held";
+        args: {
+            confirm: "run-held-migrations" | undefined;
+        };
+    } | {
+        command: "migrate-local";
+        args: {};
+    } | {
+        command: "migrations-check";
+        args: {};
+    } | {
+        command: "reset";
+        args: {};
+    } | {
+        command: "seed";
+        args: {};
+    } | {
+        command: "setup";
+        args: {};
+    };
+} | {
+    command: "deploy";
+    args: {
+        runMigrations: boolean;
+        skipMigrations: boolean;
+        skipPostDeployChecks: boolean;
+        tauriLocalPlatforms: ("macos" | "windows" | "linux" | "ios" | "android")[];
+        tauriWorkflowName: string | undefined;
+        tauriWorkflowPlatforms: ("macos" | "windows" | "linux" | "ios" | "android")[];
+        tauriWorkflowRef: string | undefined;
+        yes: boolean;
+    };
+} | {
+    command: "dev";
+    args: {
+        platform: "ios" | "android" | "desktop" | "web" | undefined;
+    };
+} | {
+    command: "typecheck";
+    args: {};
+} | {
+    command: "upgrade";
+    args: {
+        command: "ensure-template-remote";
+        args: {
+            remote: string;
+            noFetch: boolean;
+        };
+    } | {
+        command: "check-skill-current";
+        args: {
+            target: string;
+            apply: boolean;
+        };
+    } | {
+        command: "fast-forward-template-files";
+        args: {
+            target: string;
+            base: string | undefined;
+            apply: boolean;
+        };
+    };
+}, {
+    command: "db";
+    value: {
+        command: "generate";
+        value: Promise<void>;
+    } | {
+        command: "migrate";
+        value: Promise<void>;
+    } | {
+        command: "studio";
+        value: Promise<void>;
+    } | {
+        command: "ensure";
+        value: Promise<void>;
+    } | {
+        command: "migrate-held";
+        value: Promise<void>;
+    } | {
+        command: "migrate-local";
+        value: Promise<void>;
+    } | {
+        command: "migrations-check";
+        value: Promise<void>;
+    } | {
+        command: "reset";
+        value: Promise<void>;
+    } | {
+        command: "seed";
+        value: Promise<void>;
+    } | {
+        command: "setup";
+        value: Promise<void>;
+    };
+} | {
+    command: "deploy";
+    value: Promise<void>;
+} | {
+    command: "dev";
+    value: Promise<void>;
+} | {
+    command: "typecheck";
+    value: Promise<void>;
+} | {
+    command: "upgrade";
+    value: {
+        command: "ensure-template-remote";
+        value: void;
+    } | {
+        command: "check-skill-current";
+        value: void;
+    } | {
+        command: "fast-forward-template-files";
+        value: void;
+    };
+}> & {
+    run(context: import("cmd-ts/dist/cjs/argparser").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser").ParsingResult<{
+        command: "db";
+        value: {
+            command: "generate";
+            value: Promise<void>;
+        } | {
+            command: "migrate";
+            value: Promise<void>;
+        } | {
+            command: "studio";
+            value: Promise<void>;
+        } | {
+            command: "ensure";
+            value: Promise<void>;
+        } | {
+            command: "migrate-held";
+            value: Promise<void>;
+        } | {
+            command: "migrate-local";
+            value: Promise<void>;
+        } | {
+            command: "migrations-check";
+            value: Promise<void>;
+        } | {
+            command: "reset";
+            value: Promise<void>;
+        } | {
+            command: "seed";
+            value: Promise<void>;
+        } | {
+            command: "setup";
+            value: Promise<void>;
+        };
+    } | {
+        command: "deploy";
+        value: Promise<void>;
+    } | {
+        command: "dev";
+        value: Promise<void>;
+    } | {
+        command: "typecheck";
+        value: Promise<void>;
+    } | {
+        command: "upgrade";
+        value: {
+            command: "ensure-template-remote";
+            value: void;
+        } | {
+            command: "check-skill-current";
+            value: void;
+        } | {
+            command: "fast-forward-template-files";
+            value: void;
+        };
+    }>>;
+};

package/dist/coreframe.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+import { array, binary, command, flag, multioption, oneOf, option, optional, positional, rest, run, string, subcommands, } from "cmd-ts";
+import { runDrizzleKitCommand } from "./db/drizzle-kit.js";
+import { ensureLocalDb } from "./db/ensure.js";
+import { migrateHeldMigrations } from "./db/migrate-held.js";
+import { migrateLocalDb } from "./db/migrate.js";
+import { resetLocalDb } from "./db/reset.js";
+import { seedLocalDb } from "./db/seed.js";
+import { setupLocalDb } from "./db/setup.js";
+import { deployProject } from "./deploy.js";
+import { checkDeployMigrations } from "./deploy/check-migrations.js";
+import { tauriReleasePlatforms } from "./deploy/config.js";
+import { runDevServer } from "./dev.js";
+import { typecheckProject } from "./typecheck.js";
+import { checkUpgradeSkillCurrent } from "./upgrade/check-skill-current.js";
+import { ensureTemplateRemote } from "./upgrade/ensure-template-remote.js";
+import { fastForwardTemplateFiles } from "./upgrade/fast-forward-template-files.js";
+const heldMigrationConfirmation = "run-held-migrations";
+const devPlatforms = ["web", "desktop", "ios", "android"];
+export const coreframeCli = subcommands({
+    name: "coreframe",
+    cmds: {
+        deploy: command({
+            name: "deploy",
+            args: {
+                runMigrations: flag({
+                    long: "run-migrations",
+                    description: "Run pending deploy-safe database migrations before deploying.",
+                    defaultValue: () => false,
+                }),
+                skipMigrations: flag({
+                    long: "skip-migrations",
+                    description: "Deploy without running pending deploy-safe database migrations.",
+                    defaultValue: () => false,
+                }),
+                skipPostDeployChecks: flag({
+                    long: "skip-post-deploy-checks",
+                    description: "Skip post-deploy checks after Cloudflare deployment.",
+                    defaultValue: () => false,
+                }),
+                tauriLocalPlatforms: multioption({
+                    long: "tauri-local-platform",
+                    type: array(oneOf(tauriReleasePlatforms)),
+                    description: "Build one Tauri release platform locally. Repeat for multiple platforms.",
+                    defaultValue: () => [],
+                }),
+                tauriWorkflowName: option({
+                    long: "tauri-workflow-name",
+                    type: optional(string),
+                    description: "GitHub Actions workflow file or name for remote Tauri release builds.",
+                }),
+                tauriWorkflowPlatforms: multioption({
+                    long: "tauri-workflow-platform",
+                    type: array(oneOf(tauriReleasePlatforms)),
+                    description: "Build one Tauri release platform with GitHub Actions. Repeat for multiple platforms.",
+                    defaultValue: () => [],
+                }),
+                tauriWorkflowRef: option({
+                    long: "tauri-workflow-ref",
+                    type: optional(string),
+                    description: "Git ref used when dispatching remote Tauri release builds.",
+                }),
+                yes: flag({
+                    long: "yes",
+                    short: "y",
+                    description: "Approve noninteractive deploy prompts.",
+                    defaultValue: () => false,
+                }),
+            },
+            handler: ({ runMigrations, skipMigrations, skipPostDeployChecks, tauriLocalPlatforms, tauriWorkflowName, tauriWorkflowPlatforms, tauriWorkflowRef, yes, }) => deployProject([
+                ...(runMigrations ? ["--run-migrations"] : []),
+                ...(skipMigrations ? ["--skip-migrations"] : []),
+                ...(skipPostDeployChecks ? ["--skip-post-deploy-checks"] : []),
+                ...tauriLocalPlatforms.flatMap((platform) => ["--tauri-local-platform", platform]),
+                ...(tauriWorkflowName ? ["--tauri-workflow-name", tauriWorkflowName] : []),
+                ...tauriWorkflowPlatforms.flatMap((platform) => ["--tauri-workflow-platform", platform]),
+                ...(tauriWorkflowRef ? ["--tauri-workflow-ref", tauriWorkflowRef] : []),
+                ...(yes ? ["--yes"] : []),
+            ]),
+        }),
+        typecheck: command({
+            name: "typecheck",
+            args: {},
+            handler: typecheckProject,
+        }),
+        dev: command({
+            name: "dev",
+            args: {
+                platform: positional({
+                    type: optional(oneOf(devPlatforms)),
+                    displayName: "platform",
+                    description: "Development target platform. Defaults to web.",
+                }),
+            },
+            handler: ({ platform }) => runDevServer({ platform: platform ?? "web" }),
+        }),
+        upgrade: subcommands({
+            name: "upgrade",
+            cmds: {
+                "ensure-template-remote": command({
+                    name: "ensure-template-remote",
+                    args: {
+                        remote: option({
+                            long: "remote",
+                            type: string,
+                            defaultValue: () => "template",
+                            description: "Remote name to ensure.",
+                        }),
+                        noFetch: flag({
+                            long: "no-fetch",
+                            description: "Do not fetch the remote after ensuring it exists.",
+                            defaultValue: () => false,
+                        }),
+                    },
+                    handler: ({ noFetch, remote }) => ensureTemplateRemote({ fetch: !noFetch, remote }),
+                }),
+                "check-skill-current": command({
+                    name: "check-skill-current",
+                    args: {
+                        target: option({
+                            long: "target",
+                            type: string,
+                            description: "Target Coreframe template git ref.",
+                        }),
+                        apply: flag({
+                            long: "apply",
+                            description: "Replace the local upgrade skill with the target version when it differs.",
+                            defaultValue: () => false,
+                        }),
+                    },
+                    handler: ({ apply, target }) => {
+                        process.exitCode = checkUpgradeSkillCurrent({ apply, target });
+                    },
+                }),
+                "fast-forward-template-files": command({
+                    name: "fast-forward-template-files",
+                    args: {
+                        target: option({
+                            long: "target",
+                            type: string,
+                            description: "Target Coreframe template git ref.",
+                        }),
+                        base: option({
+                            long: "base",
+                            type: optional(string),
+                            description: "Previous Coreframe template git ref. Defaults to package.json engines.coreframe.",
+                        }),
+                        apply: flag({
+                            long: "apply",
+                            description: "Write clean fast-forwards to the worktree.",
+                            defaultValue: () => false,
+                        }),
+                    },
+                    handler: ({ apply, base, target }) => fastForwardTemplateFiles({ apply, base, target }),
+                }),
+            },
+        }),
+        db: subcommands({
+            name: "db",
+            cmds: {
+                ensure: command({
+                    name: "ensure",
+                    args: {},
+                    handler: ensureLocalDb,
+                }),
+                generate: command({
+                    name: "generate",
+                    args: {
+                        args: rest({
+                            displayName: "drizzle-kit args",
+                            description: "Additional arguments passed to drizzle-kit generate.",
+                        }),
+                    },
+                    handler: ({ args }) => runDrizzleKitCommand("generate", args),
+                }),
+                migrate: command({
+                    name: "migrate",
+                    args: {
+                        args: rest({
+                            displayName: "drizzle-kit args",
+                            description: "Additional arguments passed to drizzle-kit migrate.",
+                        }),
+                    },
+                    handler: ({ args }) => runDrizzleKitCommand("migrate", args),
+                }),
+                "migrate-held": command({
+                    name: "migrate-held",
+                    args: {
+                        confirm: option({
+                            long: "confirm",
+                            type: optional(oneOf([heldMigrationConfirmation])),
+                            description: "Required confirmation value for held migrations.",
+                        }),
+                    },
+                    handler: ({ confirm }) => migrateHeldMigrations({
+                        argv: confirm ? [`--confirm=${confirm}`] : [],
+                    }),
+                }),
+                "migrate-local": command({
+                    name: "migrate-local",
+                    args: {},
+                    handler: migrateLocalDb,
+                }),
+                "migrations-check": command({
+                    name: "migrations-check",
+                    args: {},
+                    handler: checkDeployMigrations,
+                }),
+                reset: command({
+                    name: "reset",
+                    args: {},
+                    handler: resetLocalDb,
+                }),
+                seed: command({
+                    name: "seed",
+                    args: {},
+                    handler: () => seedLocalDb(),
+                }),
+                setup: command({
+                    name: "setup",
+                    args: {},
+                    handler: () => setupLocalDb(),
+                }),
+                studio: command({
+                    name: "studio",
+                    args: {
+                        args: rest({
+                            displayName: "drizzle-kit args",
+                            description: "Additional arguments passed to drizzle-kit studio.",
+                        }),
+                    },
+                    handler: ({ args }) => runDrizzleKitCommand("studio", args),
+                }),
+            },
+        }),
+    },
+});
+if (import.meta.main) {
+    run(binary(coreframeCli), process.argv);
+}