@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/route-map.js

@@ -0,0 +1,195 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { inspectControllerOwnership } from "./controller-ownership.js";
+import { routeMapLoaderFailed, routeMapLoaderInvalidJson, routeMapLoaderSignal, routeOwnerPlanUnresolved, routesFileNotFound, } from "./errors.js";
+export async function loadRouteMap(cwd = process.cwd()) {
+    let manifest = await loadRouteManifest(cwd);
+    let ownership = await inspectControllerOwnership(manifest.appRoot, manifest.tree);
+    let tree = decorateRouteTree(manifest.tree, ownership.subtrees);
+    return {
+        appRoot: manifest.appRoot,
+        routesFile: manifest.routesFile,
+        tree,
+    };
+}
+export async function loadRouteManifest(cwd = process.cwd()) {
+    let appRoot = await findRemixAppRoot(cwd);
+    return loadRouteManifestFromAppRoot(appRoot);
+}
+export async function loadRouteManifestFromAppRoot(appRoot) {
+    let routesFile = path.join(appRoot, 'app', 'routes.ts');
+    let tree = await loadRawRouteMap(appRoot, routesFile);
+    return {
+        appRoot,
+        routesFile,
+        tree,
+    };
+}
+async function loadRawRouteMap(appRoot, routesFile) {
+    let workerPath = getRouteMapWorkerPath();
+    let child = spawn(process.execPath, [workerPath, routesFile], {
+        cwd: appRoot,
+        env: createRouteMapWorkerEnv(),
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk;
+    });
+    let exitResult = await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            resolve({ code, signal });
+        });
+    });
+    if (exitResult.signal != null) {
+        throw routeMapLoaderSignal(exitResult.signal);
+    }
+    if (exitResult.code !== 0) {
+        let message = stderr.trim();
+        if (message.length === 0) {
+            message = 'Route-map loader failed.';
+        }
+        throw routeMapLoaderFailed(message);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw routeMapLoaderInvalidJson();
+    }
+    return assertRawRouteTree(parsed);
+}
+function decorateRouteTree(rawTree, subtrees, parentSegments = []) {
+    let subtreesByRouteName = new Map(subtrees.map((subtree) => [subtree.routeName, subtree]));
+    return decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegments);
+}
+function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegments = []) {
+    return rawTree.map((rawNode) => {
+        let owner = getRouteOwner(rawNode, parentSegments, subtreesByRouteName);
+        let nextParentSegments = rawNode.kind === 'group' ? [...parentSegments, rawNode.key] : parentSegments;
+        return {
+            children: rawNode.kind === 'group'
+                ? decorateRouteTreeWithLookup(rawNode.children, subtreesByRouteName, nextParentSegments)
+                : [],
+            key: rawNode.key,
+            kind: rawNode.kind,
+            method: rawNode.method,
+            name: rawNode.name,
+            owner,
+            pattern: rawNode.pattern,
+        };
+    });
+}
+function getRouteOwner(rawNode, parentSegments, subtreesByRouteName) {
+    let ownerRouteName = rawNode.kind === 'group'
+        ? rawNode.name
+        : parentSegments.length === 0
+            ? rawNode.name
+            : parentSegments.join('.');
+    let subtree = subtreesByRouteName.get(ownerRouteName);
+    if (subtree == null) {
+        throw routeOwnerPlanUnresolved(rawNode.name);
+    }
+    return {
+        exists: subtree.actualEntryPath != null,
+        kind: subtree.kind,
+        path: subtree.actualEntryPath ?? subtree.entryDisplayPath,
+    };
+}
+function assertRawRouteTree(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Route-map loader returned an invalid tree.');
+    }
+    return value.map((entry) => assertRawRouteTreeNode(entry));
+}
+function assertRawRouteTreeNode(value) {
+    if (typeof value !== 'object' || value == null) {
+        throw new Error('Route-map loader returned an invalid route node.');
+    }
+    let key = Reflect.get(value, 'key');
+    let name = Reflect.get(value, 'name');
+    let kind = Reflect.get(value, 'kind');
+    let children = Reflect.get(value, 'children');
+    if (typeof key !== 'string' || typeof name !== 'string') {
+        throw new Error('Route-map loader returned a route node without a valid name.');
+    }
+    if (kind !== 'group' && kind !== 'route') {
+        throw new Error(`Route-map loader returned an unknown node kind for "${name}".`);
+    }
+    if (!Array.isArray(children)) {
+        throw new Error(`Route-map loader returned invalid children for "${name}".`);
+    }
+    if (kind === 'group') {
+        return {
+            children: children.map((child) => assertRawRouteTreeNode(child)),
+            key,
+            kind,
+            name,
+        };
+    }
+    let method = Reflect.get(value, 'method');
+    let pattern = Reflect.get(value, 'pattern');
+    if (typeof method !== 'string' || typeof pattern !== 'string') {
+        throw new Error(`Route-map loader returned an invalid route leaf for "${name}".`);
+    }
+    return {
+        children: [],
+        key,
+        kind,
+        method,
+        name,
+        pattern,
+    };
+}
+async function findRemixAppRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        if (await pathExists(path.join(currentDir, 'app', 'routes.ts'))) {
+            return currentDir;
+        }
+        let parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw routesFileNotFound(startDir);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function getRouteMapWorkerPath() {
+    let currentFilePath = fileURLToPath(import.meta.url);
+    let extension = currentFilePath.endsWith('.ts') ? '.ts' : '.js';
+    return fileURLToPath(new URL(`./load-route-map-worker${extension}`, import.meta.url));
+}
+function createRouteMapWorkerEnv() {
+    let env = { ...process.env };
+    for (let key of Object.keys(env)) {
+        if (key.startsWith('NODE_TEST_')) {
+            delete env[key];
+        }
+    }
+    return env;
+}

package/dist/lib/terminal.d.ts

@@ -0,0 +1,17 @@
+export declare function configureColors(options: {
+    disabled: boolean;
+}): void;
+export declare function bold(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightGreen(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightBlue(text: string, target?: NodeJS.WriteStream): string;
+export declare function boldLightBlue(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightGray(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightMagenta(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightRed(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightYellow(text: string, target?: NodeJS.WriteStream): string;
+export declare function reset(target: NodeJS.WriteStream): string;
+export declare function remixWordmark(target?: NodeJS.WriteStream): string;
+export declare function clearCurrentLine(): string;
+export declare function restoreTerminalFormatting(): void;
+export declare function canUseAnsi(target: NodeJS.WriteStream): boolean;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/lib/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/lib/terminal.ts"],"names":[],"mappings":"AAMA,wBAAgB,eAAe,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAEpE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAEtF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE5F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE3F;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE/F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE3F;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE9F;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE1F;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE7F;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,MAAM,CAExD;AAED,wBAAgB,aAAa,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAYjF;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAShD;AAUD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAE9D"}

package/dist/lib/terminal.js

@@ -0,0 +1,66 @@
+import * as process from 'node:process';
+import { ansi, createTerminal, shouldUseColors } from '@remix-run/terminal';
+let colorDisabledByFlag = false;
+export function configureColors(options) {
+    colorDisabledByFlag = options.disabled;
+}
+export function bold(text, target = process.stdout) {
+    return paint(text, ansi.bold, target);
+}
+export function lightGreen(text, target = process.stdout) {
+    return paint(text, ansi.greenBright, target);
+}
+export function lightBlue(text, target = process.stdout) {
+    return paint(text, ansi.blueBright, target);
+}
+export function boldLightBlue(text, target = process.stdout) {
+    return isColorDisabled(target) ? text : `${ansi.bold}${ansi.blueBright}${text}${ansi.reset}`;
+}
+export function lightGray(text, target = process.stdout) {
+    return paint(text, ansi.gray, target);
+}
+export function lightMagenta(text, target = process.stdout) {
+    return paint(text, ansi.magentaBright, target);
+}
+export function lightRed(text, target = process.stdout) {
+    return paint(text, ansi.redBright, target);
+}
+export function lightYellow(text, target = process.stdout) {
+    return paint(text, ansi.yellowBright, target);
+}
+export function reset(target) {
+    return isColorDisabled(target) ? '' : ansi.reset;
+}
+export function remixWordmark(target = process.stdout) {
+    if (isColorDisabled(target)) {
+        return 'REMIX';
+    }
+    return [
+        paint('R', ansi.blueBright, target),
+        paint('E', ansi.greenBright, target),
+        paint('M', ansi.yellowBright, target),
+        paint('I', ansi.magentaBright, target),
+        paint('X', ansi.redBright, target),
+    ].join('');
+}
+export function clearCurrentLine() {
+    return `\r${ansi.clearLine}`;
+}
+export function restoreTerminalFormatting() {
+    if (canUseAnsi(process.stdout)) {
+        createTerminal({ stdout: process.stdout }).write(ansi.reset);
+        return;
+    }
+    if (canUseAnsi(process.stderr)) {
+        createTerminal({ stderr: process.stderr }).error(ansi.reset);
+    }
+}
+function paint(text, colorCode, target) {
+    return isColorDisabled(target) ? text : `${colorCode}${text}${ansi.reset}`;
+}
+function isColorDisabled(target) {
+    return colorDisabledByFlag || !shouldUseColors({ stream: target });
+}
+export function canUseAnsi(target) {
+    return process.env.TERM !== 'dumb' && target.isTTY === true;
+}

package/package.json

@@ -1,14 +1,56 @@
 {
   "name": "@remix-run/cli",
-  "version": "0.0.0",
-  "description": "Placeholder package for Remix CI/OIDC setup",
+  "version": "0.2.0",
+  "description": "Command-line interface for Remix",
+  "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/remix-run/remix.git",
     "directory": "packages/cli"
   },
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/remix-run/remix/tree/main/packages/cli#readme",
+  "files": [
+    "bootstrap",
+    "LICENSE",
+    "README.md",
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=24.3.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "semver": "^7.7.4",
+    "@remix-run/test": "^0.3.0",
+    "@remix-run/terminal": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "@types/semver": "^7.5.8",
+    "@typescript/native-preview": "7.0.0-dev.20251125.1",
+    "@remix-run/assert": "^0.2.0"
+  },
+  "keywords": [
+    "remix",
+    "cli",
+    "scaffold",
+    "project",
+    "command-line"
+  ],
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json",
+    "clean": "git clean -fdX",
+    "test": "remix-test --concurrency 1",
+    "typecheck": "tsgo --noEmit"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { runRemix, type RunRemixOptions } from './lib/cli.ts'

package/src/lib/bootstrap-project.ts

@@ -0,0 +1,222 @@
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import * as process from 'node:process'
+import { fileURLToPath } from 'node:url'
+import semver from 'semver'
+
+import {
+  appNameUnavailable,
+  invalidPackageName,
+  targetDirectoryNotEmpty,
+  targetPathNotDirectory,
+} from './errors.ts'
+import { runProgressStep, type StepProgressReporter } from './reporter.ts'
+
+const BOOTSTRAP_DIRECTORY = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../../bootstrap',
+)
+const BOOTSTRAP_EXCLUDED_NAMES = new Set(['.gitkeep', 'node_modules'])
+export const MINIMUM_SUPPORTED_NODE_VERSION = '24.3.0'
+
+export interface BootstrapProjectOptions {
+  appName: string | null
+  cwd?: string
+  force: boolean
+  remixVersion?: string
+  targetDir: string
+}
+
+export type BootstrapProjectPhase =
+  | 'prepare-target-directory'
+  | 'generate-scaffold-files'
+  | 'finalize-package-json'
+
+export interface BootstrappedProject {
+  appDisplayName: string
+  targetDir: string
+}
+
+export type BootstrapProgressReporter = StepProgressReporter<BootstrapProjectPhase>
+
+interface BootstrapConfig {
+  appDisplayName: string
+  packageName: string
+  remixVersion: string
+}
+
+type TemplateValues = Record<string, string>
+
+export async function bootstrapProject(
+  options: BootstrapProjectOptions,
+  progress?: BootstrapProgressReporter,
+): Promise<BootstrappedProject> {
+  let cwd = options.cwd ?? process.cwd()
+  let targetDir = path.resolve(cwd, options.targetDir)
+  let rawAppName = options.appName ?? path.basename(targetDir)
+  if (rawAppName.length === 0) {
+    throw appNameUnavailable(targetDir)
+  }
+
+  let config = {
+    appDisplayName: options.appName ?? humanizeName(rawAppName),
+    packageName: toPackageName(rawAppName),
+    remixVersion: readDefaultRemixVersion(options.remixVersion),
+  } satisfies BootstrapConfig
+
+  await runProgressStep(progress, 'prepare-target-directory', () =>
+    ensureTargetDirectory(targetDir, options.force),
+  )
+  await runProgressStep(progress, 'generate-scaffold-files', () =>
+    copyBootstrapDirectory({
+      sourceDir: BOOTSTRAP_DIRECTORY,
+      targetDir,
+      templateValues: createTemplateValues(config),
+    }),
+  )
+  await runProgressStep(progress, 'finalize-package-json', () =>
+    writeScaffoldPackageJson(targetDir, config),
+  )
+
+  return {
+    appDisplayName: config.appDisplayName,
+    targetDir,
+  }
+}
+
+function readDefaultRemixVersion(runtimeVersion: string | undefined): string {
+  let overriddenVersion = process.env.REMIX_VERSION?.trim()
+  if (overriddenVersion) {
+    return overriddenVersion
+  }
+
+  if (runtimeVersion == null) {
+    return 'latest'
+  }
+
+  let validRuntimeVersion = semver.valid(runtimeVersion)
+  return validRuntimeVersion == null ? runtimeVersion : `^${validRuntimeVersion}`
+}
+
+function createTemplateValues(config: BootstrapConfig): TemplateValues {
+  return {
+    '%%RMX_APP_DISPLAY_NAME%%': config.appDisplayName,
+    '%%RMX_APP_DISPLAY_NAME_URI_COMPONENT%%': encodeURIComponent(config.appDisplayName),
+  }
+}
+
+async function writeScaffoldPackageJson(targetDir: string, config: BootstrapConfig): Promise<void> {
+  let packageJsonPath = path.join(targetDir, 'package.json')
+  let packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8')) as {
+    dependencies?: Record<string, string>
+    devDependencies?: Record<string, string>
+    engines?: Record<string, string>
+    name?: string
+  }
+
+  packageJson.name = config.packageName
+  packageJson.dependencies = {
+    ...packageJson.dependencies,
+    remix: config.remixVersion,
+    tsx: 'latest',
+  }
+  packageJson.devDependencies = {
+    ...packageJson.devDependencies,
+    '@types/node': 'latest',
+    typescript: 'latest',
+  }
+  packageJson.engines = {
+    ...packageJson.engines,
+    node: `>=${MINIMUM_SUPPORTED_NODE_VERSION}`,
+  }
+
+  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8')
+}
+
+async function ensureTargetDirectory(targetDir: string, force: boolean): Promise<void> {
+  try {
+    let stats = await fs.stat(targetDir)
+    if (!stats.isDirectory()) {
+      throw targetPathNotDirectory(targetDir)
+    }
+
+    let entries = await fs.readdir(targetDir)
+    if (entries.length > 0 && !force) {
+      throw targetDirectoryNotEmpty(targetDir)
+    }
+  } catch (error) {
+    let nodeError = error as NodeJS.ErrnoException
+    if (nodeError.code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  await fs.mkdir(targetDir, { recursive: true })
+}
+
+async function copyBootstrapDirectory({
+  sourceDir,
+  targetDir,
+  templateValues,
+}: {
+  sourceDir: string
+  targetDir: string
+  templateValues: TemplateValues
+}): Promise<void> {
+  let entries = await fs.readdir(sourceDir, { withFileTypes: true })
+
+  for (let entry of entries) {
+    let sourcePath = path.join(sourceDir, entry.name)
+    let targetPath = path.join(targetDir, entry.name)
+
+    if (BOOTSTRAP_EXCLUDED_NAMES.has(entry.name)) {
+      continue
+    }
+
+    if (entry.isDirectory()) {
+      await fs.mkdir(targetPath, { recursive: true })
+      await copyBootstrapDirectory({ sourceDir: sourcePath, targetDir: targetPath, templateValues })
+      continue
+    }
+
+    let content = await fs.readFile(sourcePath, 'utf8')
+    await fs.writeFile(targetPath, replaceTemplateValues(content, templateValues), 'utf8')
+  }
+}
+
+function replaceTemplateValues(content: string, templateValues: TemplateValues): string {
+  for (let [token, value] of Object.entries(templateValues)) {
+    content = content.split(token).join(value)
+  }
+
+  return content
+}
+
+function humanizeName(value: string): string {
+  let parts = value.split(/[-_\s]+/).filter(Boolean)
+  if (parts.length === 0) {
+    return 'Remix App'
+  }
+
+  return parts
+    .map((part) => {
+      let head = part.slice(0, 1).toUpperCase()
+      let tail = part.slice(1)
+      return `${head}${tail}`
+    })
+    .join(' ')
+}
+
+function toPackageName(value: string): string {
+  let packageName = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+  if (packageName.length === 0) {
+    throw invalidPackageName(value)
+  }
+
+  return packageName
+}

package/src/lib/cli-context.ts

@@ -0,0 +1,38 @@
+import * as path from 'node:path'
+import * as process from 'node:process'
+
+import { resolveDefaultRemixVersion } from './remix-version.ts'
+
+interface ResolveCliContextOptions {
+  cwd?: string
+  remixVersion?: string
+}
+
+export interface CliContext {
+  cwd: string
+  remixVersion?: string
+}
+
+export async function resolveCliContext(
+  options: ResolveCliContextOptions = {},
+): Promise<CliContext> {
+  let cwd = resolveCwd(options.cwd)
+  let remixVersion = normalizeRemixVersion(options.remixVersion)
+
+  return {
+    cwd,
+    remixVersion: remixVersion ?? (await resolveDefaultRemixVersion(cwd)),
+  }
+}
+
+function resolveCwd(cwd: string | undefined): string {
+  let normalizedCwd = cwd?.trim()
+  return path.resolve(
+    normalizedCwd == null || normalizedCwd.length === 0 ? process.cwd() : normalizedCwd,
+  )
+}
+
+function normalizeRemixVersion(remixVersion: string | undefined): string | undefined {
+  let normalizedVersion = remixVersion?.trim()
+  return normalizedVersion == null || normalizedVersion.length === 0 ? undefined : normalizedVersion
+}