@coreframe/scripts 0.0.0 → 0.1.0

package/dist/deploy.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+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 { createProjectDeployDatabase } from "./db/project.js";
+import { runPostDeployChecks } from "./deploy/checks.js";
+import { resolveDeployConfig } from "./deploy/config.js";
+import { collectDeployMigrationFiles, formatMigrationList, formatMigrationScanFailures, scanDeployMigrationFiles, } from "./deploy/migrations.js";
+import { filterPendingMigrations, readAppliedMigrationNames } from "./deploy/pending-migrations.js";
+import { parseTauriReleasePlatform, prepareTauriRelease, resolveTauriReleasePlan, restoreTauriReleaseMetadata, uploadTauriReleaseToB2, validateTauriReleasePlan, writeTauriReleaseMetadata, } from "./deploy/tauri-release.js";
+import { nextReleaseVersion, readPackageJson, releaseName, writePackageVersion, } from "./deploy/version.js";
+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 = { 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() {
+    const configPath = resolve(projectConfigPath);
+    try {
+        await access(configPath);
+    }
+    catch {
+        return {};
+    }
+    const configUrl = pathToFileURL(configPath).href;
+    const module = (await import(__rewriteRelativeImportExtension(configUrl)));
+    return module.default ?? {};
+}
+export function parseDeployArgs(argv) {
+    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, name) {
+    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, name) {
+    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) {
+    try {
+        return await collectPendingMigrations(database);
+    }
+    finally {
+        await database.close?.();
+    }
+}
+async function collectPendingMigrations(database) {
+    const migrations = await collectDeployMigrationFiles();
+    const appliedMigrations = await readAppliedMigrationNames(database);
+    return filterPendingMigrations(migrations, appliedMigrations);
+}
+async function chooseMigrationExecution(args, pendingMigrations) {
+    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) {
+    if (args.runMigrations && args.skipMigrations) {
+        throw new Error("Use only one of --run-migrations, --skip-migrations, or --yes.");
+    }
+}
+function requireEnv(env, names) {
+    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]]));
+}
+function createReleaseEnv(env, name, packageName, version) {
+    return {
+        ...env,
+        POSTHOG_RELEASE: name,
+        POSTHOG_RELEASE_NAME: env.POSTHOG_RELEASE_NAME ?? packageName,
+        POSTHOG_RELEASE_VERSION: env.POSTHOG_RELEASE_VERSION ?? version,
+    };
+}
+function createBuildCheckEnv(env) {
+    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/dist/dev.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { spawn as nodeSpawn } from "node:child_process";
+type Spawn = typeof nodeSpawn;
+export type DevServerOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    logPath?: string;
+    platform?: DevPlatform;
+    spawn?: Spawn;
+};
+export type DevPlatform = "android" | "desktop" | "ios" | "web";
+export declare function runDevServer({ cwd, env, logPath, platform, spawn, }?: DevServerOptions): Promise<void>;
+export {};

package/dist/dev.js

@@ -0,0 +1,96 @@
+#!/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";
+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, } = {}) {
+    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) {
+    await mkdir(path.dirname(logPath), { recursive: true });
+    return createWriteStream(logPath, { flags: "w" });
+}
+function closeLog(log) {
+    if (!log) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        log.once("error", reject);
+        log.end(resolve);
+    });
+}
+function tauriDevArgs(platform) {
+    return ["--dir=tauri", "tauri", ...(platform === "desktop" ? [] : [platform]), "dev"];
+}
+function runDevProcess(spawn, command, args, { cwd, env, log, }) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            env,
+            stdio: log ? ["inherit", "pipe", "pipe"] : "inherit",
+        });
+        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/image-generator.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export declare function imageGenerator(): Plugin;

package/dist/image-generator.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import { glob } from "tinyglobby";
+export function imageGenerator() {
+    return {
+        name: "image-generator",
+        async buildStart() {
+            const files = await glob(["src/**/*@3x.{png,webp}", "public/**/*@3x.{png,webp}"]);
+            console.log(`[image-generator] Found ${files.length} @3x images.`);
+            await Promise.all(files.map((file) => generateDensityImages(file)));
+        },
+    };
+}
+async function generateDensityImages(file) {
+    const dir = path.dirname(file);
+    const ext = path.extname(file);
+    const base = path.basename(file, `@3x${ext}`);
+    const outputImages = [
+        {
+            outputPath: path.join(dir, `${base}@2x${ext}`),
+            scale: 2 / 3,
+        },
+        {
+            outputPath: path.join(dir, `${base}@1x${ext}`),
+            scale: 1 / 3,
+        },
+    ].filter((image) => !fs.existsSync(image.outputPath));
+    if (outputImages.length === 0) {
+        return;
+    }
+    const { default: sharp } = await import("sharp");
+    let width;
+    try {
+        width = (await sharp(file).metadata()).width;
+    }
+    catch (error) {
+        console.error(`[image-generator] Failed to read metadata for ${file}`, error);
+        return;
+    }
+    if (!width) {
+        console.error(`[image-generator] Skipping ${file}; image width could not be read.`);
+        return;
+    }
+    await Promise.all(outputImages.map((image) => generateDensityImage({
+        file,
+        outputPath: image.outputPath,
+        sharp,
+        width: Math.round(width * image.scale),
+    })));
+}
+async function generateDensityImage(options) {
+    try {
+        console.log(`[image-generator] Generating ${options.outputPath} (${options.width}w)`);
+        await options.sharp(options.file).resize({ width: options.width }).toFile(options.outputPath);
+    }
+    catch (error) {
+        console.error(`[image-generator] Failed to process ${options.file} for ${options.outputPath}`, error);
+    }
+}

package/dist/project.d.ts

@@ -0,0 +1 @@
+export declare function importProjectModule<T>(path: string): Promise<T>;

package/dist/project.js

@@ -0,0 +1,13 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+export async function importProjectModule(path) {
+    return (await import(__rewriteRelativeImportExtension(pathToFileURL(resolve(process.cwd(), path)).href)));
+}

package/dist/typecheck.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function typecheckProject(): Promise<void>;

package/dist/typecheck.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { access } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { supervise } from "procband";
+const nodeModulesBinPath = path.resolve("node_modules", ".bin");
+process.env.PATH = nodeModulesBinPath + path.delimiter + process.env.PATH;
+const tscCommand = process.platform === "win32" ? "tsc.cmd" : "tsc";
+const projects = [
+    { name: "scripts", path: "scripts/tsconfig.json" },
+    { name: "shared", path: "src/shared/tsconfig.json" },
+    { name: "api", path: "src/api/tsconfig.json" },
+    { name: "worker", path: "src/api/worker/tsconfig.json" },
+    { name: "web", path: "src/web/tsconfig.json" },
+];
+export async function typecheckProject() {
+    const existingProjects = [];
+    for (const project of projects) {
+        try {
+            await access(project.path);
+            existingProjects.push(project);
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+                throw error;
+            }
+        }
+    }
+    const checks = existingProjects.map((project) => supervise({
+        name: project.name,
+        command: tscCommand,
+        args: ["-p", project.path],
+    }));
+    const results = await Promise.all(checks.map((check) => check.wait()));
+    const failed = results.filter((result) => result.exitCode !== 0);
+    if (failed.length > 0) {
+        process.exitCode = failed[0].exitCode;
+    }
+}
+if (import.meta.main) {
+    typecheckProject().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/upgrade/check-skill-current.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export type CheckUpgradeSkillOptions = {
+    apply: boolean;
+    target: string;
+};
+export declare function checkUpgradeSkillCurrent({ apply, target }: CheckUpgradeSkillOptions): 0 | 20;

package/dist/upgrade/check-skill-current.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const skillPath = ".agents/skills/coreframe-upgrade/SKILL.md";
+function git(args, options = {}) {
+    return spawnSync("git", args, options);
+}
+function errorDetail(result) {
+    return result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim();
+}
+function readGitFile(ref, path) {
+    const result = git(["show", `${ref}:${path}`], { encoding: "utf8" });
+    if (result.status !== 0) {
+        const detail = errorDetail(result);
+        throw new Error(`Could not read ${path} at ${ref}.${detail ? ` ${detail}` : ""}`);
+    }
+    return result.stdout.toString();
+}
+function getRepoRoot() {
+    const result = git(["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+    if (result.status !== 0) {
+        const detail = errorDetail(result);
+        throw new Error(`Could not find git repository root.${detail ? ` ${detail}` : ""}`);
+    }
+    return result.stdout.toString().trim();
+}
+function printDiff(localPath, targetText) {
+    const dir = mkdtempSync(join(tmpdir(), "coreframe-upgrade-skill-"));
+    const targetPath = join(dir, "SKILL.md");
+    try {
+        writeFileSync(targetPath, targetText);
+        const diff = git([
+            "--no-pager",
+            "diff",
+            "--no-index",
+            "--color=never",
+            "--",
+            localPath,
+            targetPath,
+        ]);
+        const output = errorDetail(diff);
+        if (output) {
+            console.log(output);
+        }
+    }
+    finally {
+        rmSync(dir, { force: true, recursive: true });
+    }
+}
+export function checkUpgradeSkillCurrent({ apply, target }) {
+    const repoRoot = getRepoRoot();
+    const localPath = join(repoRoot, skillPath);
+    if (!existsSync(localPath)) {
+        throw new Error(`Local ${skillPath} does not exist.`);
+    }
+    const localText = readFileSync(localPath, "utf8");
+    const targetText = readGitFile(target, skillPath);
+    if (localText === targetText) {
+        console.log(`Coreframe upgrade skill matches ${target}:${skillPath}.`);
+        return 0;
+    }
+    if (apply) {
+        writeFileSync(localPath, targetText);
+        console.error(`Updated ${skillPath} from ${target}. Reread it before continuing the upgrade.`);
+        return 20;
+    }
+    console.error(`Coreframe upgrade skill differs from ${target}:${skillPath}.`);
+    console.error(`Run again with --apply to update it, then reread ${skillPath} before continuing.`);
+    printDiff(localPath, targetText);
+    return 20;
+}
+if (import.meta.main) {
+    const targetIndex = process.argv.indexOf("--target");
+    const target = targetIndex === -1 ? null : process.argv[targetIndex + 1];
+    if (!target) {
+        console.error("Usage: coreframe upgrade check-skill-current --target <git-ref> [--apply]");
+        process.exit(64);
+    }
+    try {
+        process.exit(checkUpgradeSkillCurrent({ apply: process.argv.includes("--apply"), target }));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(65);
+    }
+}

package/dist/upgrade/ensure-template-remote.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export type EnsureTemplateRemoteOptions = {
+    fetch: boolean;
+    remote: string;
+};
+export declare function ensureTemplateRemote({ fetch, remote, }?: Partial<EnsureTemplateRemoteOptions>): void;

package/dist/upgrade/ensure-template-remote.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+const defaultRemote = "template";
+const defaultUrl = "https://github.com/airlock-labs/coreframe.git";
+function git(args) {
+    return spawnSync("git", args, { encoding: "utf8" });
+}
+function runGit(args) {
+    const result = git(args);
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim();
+        throw new Error(`Git command failed: git ${args.join(" ")}${detail ? `\n${detail}` : ""}`);
+    }
+    return result.stdout;
+}
+function getRemoteUrl(remote) {
+    const result = git(["remote", "get-url", remote]);
+    if (result.status === 2) {
+        return null;
+    }
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim();
+        throw new Error(`Could not inspect remote ${remote}.${detail ? `\n${detail}` : ""}`);
+    }
+    return result.stdout.trim();
+}
+export function ensureTemplateRemote({ fetch = true, remote = defaultRemote, } = {}) {
+    if (remote.length === 0) {
+        throw new Error("Remote name must not be empty.");
+    }
+    runGit(["rev-parse", "--show-toplevel"]);
+    const existingUrl = getRemoteUrl(remote);
+    if (existingUrl === null) {
+        runGit(["remote", "add", remote, defaultUrl]);
+        console.log(`Added ${remote} remote: ${defaultUrl}`);
+    }
+    else if (existingUrl === defaultUrl) {
+        console.log(`${remote} remote already points at ${defaultUrl}`);
+    }
+    else {
+        throw new Error(`${remote} remote points at ${existingUrl}, not ${defaultUrl}.\n` +
+            "Choose the intended template source before continuing, then update or rename the remote manually.");
+    }
+    if (fetch) {
+        runGit(["fetch", remote, "--tags", "--prune"]);
+        console.log(`Fetched ${remote}.`);
+    }
+}
+if (import.meta.main) {
+    try {
+        ensureTemplateRemote({ fetch: !process.argv.includes("--no-fetch") });
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(65);
+    }
+}

package/dist/upgrade/fast-forward-template-files.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export type FastForwardTemplateFilesOptions = {
+    apply: boolean;
+    base?: string;
+    target: string;
+};
+export declare function fastForwardTemplateFiles(args: FastForwardTemplateFilesOptions): void;