@open-mercato/cli 0.6.5-develop.5116.1.f0af9e5080 → 0.6.5-develop.5155.1.148d10a46d

package/src/lib/deploy/railway/source.ts

@@ -0,0 +1,143 @@
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import type { RailwaySource, RailwaySourceMode } from './types'
+
+type CommandRunner = (command: string, args: string[], cwd: string) => string
+
+const defaultRunner: CommandRunner = (command, args, cwd) =>
+  execFileSync(command, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+
+function tryRun(runner: CommandRunner, command: string, args: string[], cwd: string): string | null {
+  try {
+    return runner(command, args, cwd)
+  } catch {
+    return null
+  }
+}
+
+export function normalizeGitRepository(remoteUrl: string): string | null {
+  const trimmed = remoteUrl.trim().replace(/\.git$/, '')
+  const sshMatch = trimmed.match(/^git@github\.com:([^/]+\/[^/]+)$/)
+  if (sshMatch) return sshMatch[1] ?? null
+  try {
+    const parsed = new URL(trimmed)
+    if (parsed.hostname !== 'github.com') return null
+    return parsed.pathname.replace(/^\/+/, '') || null
+  } catch {
+    return null
+  }
+}
+
+export function inspectGitSource(cwd: string, runner: CommandRunner = defaultRunner): RailwaySource | null {
+  const branch = tryRun(runner, 'git', ['branch', '--show-current'], cwd)
+  const remoteUrl = tryRun(runner, 'git', ['remote', 'get-url', 'origin'], cwd)
+  if (!branch || !remoteUrl) return null
+  const repo = normalizeGitRepository(remoteUrl)
+  if (!repo) return null
+  const commitSha = tryRun(runner, 'git', ['rev-parse', 'HEAD'], cwd) ?? undefined
+  return {
+    mode: 'git',
+    reason: `GitHub remote origin and branch ${branch} detected`,
+    repo,
+    branch,
+    commitSha,
+  }
+}
+
+export function assertGitDeployReady(cwd: string, runner: CommandRunner = defaultRunner): void {
+  const status = tryRun(runner, 'git', ['status', '--porcelain'], cwd)
+  if (status === null) throw new Error('Git is required for --source git.')
+  if (status.length > 0) throw new Error('Git-backed deploy requires a clean working tree.')
+  const upstream = tryRun(runner, 'git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], cwd)
+  if (!upstream) throw new Error('The current branch has no upstream. Push it before a Git-backed deploy.')
+  const ahead = tryRun(runner, 'git', ['rev-list', '--count', '@{u}..HEAD'], cwd)
+  if (ahead === null || Number.parseInt(ahead, 10) > 0) {
+    throw new Error('The current branch has local commits that are not pushed to its upstream.')
+  }
+  const behind = tryRun(runner, 'git', ['rev-list', '--count', 'HEAD..@{u}'], cwd)
+  if (behind === null || Number.parseInt(behind, 10) > 0) {
+    throw new Error('The current branch is behind its upstream. Pull the latest commits before a Git-backed deploy.')
+  }
+}
+
+export function isRailwayCliAvailable(cwd: string, runner: CommandRunner = defaultRunner): boolean {
+  return tryRun(runner, 'railway', ['--version'], cwd) !== null
+}
+
+export function resolveRailwaySource(
+  mode: RailwaySourceMode,
+  cwd: string,
+  runner: CommandRunner = defaultRunner,
+): RailwaySource {
+  const gitSource = inspectGitSource(cwd, runner)
+  if (mode === 'git') {
+    if (!gitSource) {
+      throw new Error('--source git requires a GitHub origin remote and a current branch.')
+    }
+    assertGitDeployReady(cwd, runner)
+    return gitSource
+  }
+  if (mode === 'local') {
+    if (!isRailwayCliAvailable(cwd, runner)) {
+      throw new Error('--source local requires the Railway CLI. Install it from https://docs.railway.com/reference/cli-api.')
+    }
+    return { mode: 'local', reason: 'Local upload explicitly requested' }
+  }
+  if (gitSource) {
+    try {
+      assertGitDeployReady(cwd, runner)
+      return gitSource
+    } catch (error) {
+      if (!isRailwayCliAvailable(cwd, runner)) throw error
+      const reason = error instanceof Error ? error.message : 'Git source is not deployable'
+      return {
+        mode: 'local',
+        reason: `${reason} Falling back to railway up.`,
+      }
+    }
+  }
+  if (!isRailwayCliAvailable(cwd, runner)) {
+    throw new Error('No usable GitHub remote found and the Railway CLI is unavailable for local upload.')
+  }
+  return { mode: 'local', reason: 'No usable GitHub remote found; falling back to railway up' }
+}
+
+const REQUIRED_IGNORE_ENTRIES = [
+  { label: '.env', matches: (line: string) => line === '.env' || line === '.env*' },
+  { label: '.env.*', matches: (line: string) => line === '.env.*' || line === '.env*' },
+  { label: '*.pem', matches: (line: string) => line === '*.pem' },
+  { label: '*.key', matches: (line: string) => line === '*.key' },
+  { label: 'id_rsa', matches: (line: string) => line === 'id_*' || line === 'id_rsa' },
+  { label: 'id_ed25519', matches: (line: string) => line === 'id_*' || line === 'id_ed25519' },
+  { label: '.git', matches: (line: string) => line === '.git' },
+  { label: '.railway', matches: (line: string) => line === '.railway' },
+  { label: 'node_modules', matches: (line: string) => line === 'node_modules' },
+  { label: '.yarn/cache', matches: (line: string) => line === '.yarn/cache' },
+  { label: '.next', matches: (line: string) => line === '.next' },
+  { label: '.turbo', matches: (line: string) => line === '.turbo' },
+  { label: '*.db', matches: (line: string) => line === '*.db' },
+  { label: '*.sqlite', matches: (line: string) => line === '*.sqlite' || line === '*.sqlite*' },
+  { label: '*.sqlite3', matches: (line: string) => line === '*.sqlite3' || line === '*.sqlite*' },
+  { label: '.mercato/railway.json', matches: (line: string) =>
+    line === '.mercato/railway.json' || line === '.mercato/railway.json*' },
+  { label: '.mercato/railway.json.local', matches: (line: string) =>
+    line === '.mercato/railway.json.local' || line === '.mercato/railway.json*' },
+]
+
+export function assertLocalUploadSafe(cwd: string): void {
+  const ignorePath = resolve(cwd, '.railwayignore')
+  if (!existsSync(ignorePath)) {
+    throw new Error('Local Railway upload requires a .railwayignore file.')
+  }
+  const entries = readFileSync(ignorePath, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim().replace(/^\/+|\/+$/g, ''))
+    .filter((line) => line.length > 0 && !line.startsWith('#') && !line.startsWith('!'))
+  const missing = REQUIRED_IGNORE_ENTRIES
+    .filter((requirement) => !entries.some(requirement.matches))
+    .map((requirement) => requirement.label)
+  if (missing.length > 0) {
+    throw new Error(`.railwayignore is missing required safety entries: ${missing.join(', ')}`)
+  }
+}

package/src/lib/deploy/railway/state.ts

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import type { RailwayState } from './types'
+
+export function railwayStatePath(cwd: string, track: boolean): string {
+  return resolve(cwd, '.mercato', track ? 'railway.json' : 'railway.json.local')
+}
+
+function isRailwayState(value: unknown): value is RailwayState {
+  if (!value || typeof value !== 'object') return false
+  const record = value as Record<string, unknown>
+  return (
+    record.schemaVersion === 1 &&
+    record.provider === 'railway' &&
+    typeof record.projectName === 'string' &&
+    typeof record.environments === 'object' &&
+    record.environments !== null
+  )
+}
+
+export function loadRailwayState(path: string): RailwayState | null {
+  if (!existsSync(path)) return null
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
+  if (!isRailwayState(parsed)) {
+    throw new Error(`Unsupported or invalid Railway state file: ${path}`)
+  }
+  return parsed
+}
+
+export function createRailwayState(projectName: string, cliVersion: string): RailwayState {
+  return {
+    schemaVersion: 1,
+    provider: 'railway',
+    projectName,
+    environments: {},
+    writtenBy: { cliVersion },
+  }
+}
+
+export function saveRailwayState(path: string, state: RailwayState): void {
+  mkdirSync(dirname(path), { recursive: true })
+  const temporaryPath = `${path}.tmp`
+  writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 })
+  renameSync(temporaryPath, path)
+}

package/src/lib/deploy/railway/token.ts

@@ -0,0 +1,49 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export function railwayTokenConfigPath(
+  environment: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (platform === 'win32') {
+    return join(environment.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'open-mercato', 'railway.json')
+  }
+  return join(environment.XDG_CONFIG_HOME || join(homedir(), '.config'), 'open-mercato', 'railway.json')
+}
+
+export function readCachedRailwayToken(path: string, platform: NodeJS.Platform = process.platform): string | null {
+  if (!existsSync(path)) return null
+  if (platform !== 'win32') {
+    const mode = statSync(path).mode & 0o777
+    if ((mode & 0o077) !== 0) {
+      throw new Error(`Refusing to read ${path}: permissions must be 0600.`)
+    }
+  }
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
+  if (!parsed || typeof parsed !== 'object') return null
+  const token = (parsed as Record<string, unknown>).token
+  return typeof token === 'string' && token.trim() ? token.trim() : null
+}
+
+export function writeCachedRailwayToken(path: string, token: string): void {
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, `${JSON.stringify({ token }, null, 2)}\n`, { mode: 0o600 })
+  if (process.platform !== 'win32') chmodSync(path, 0o600)
+}
+
+export function resolveRailwayToken(input: {
+  flagToken?: string
+  environment?: NodeJS.ProcessEnv
+  configPath?: string
+}): { token: string | null; source: 'flag' | 'environment' | 'cache' | null } {
+  const environment = input.environment ?? process.env
+  if (input.flagToken?.trim()) return { token: input.flagToken.trim(), source: 'flag' }
+  if (environment.RAILWAY_API_TOKEN?.trim()) {
+    return { token: environment.RAILWAY_API_TOKEN.trim(), source: 'environment' }
+  }
+  const configPath = input.configPath ?? railwayTokenConfigPath(environment)
+  const cached = readCachedRailwayToken(configPath)
+  if (cached) return { token: cached, source: 'cache' }
+  return { token: null, source: null }
+}

package/src/lib/deploy/railway/types.ts

@@ -0,0 +1,87 @@
+export type RailwaySourceMode = 'auto' | 'git' | 'local'
+export type ResolvedRailwaySourceMode = Exclude<RailwaySourceMode, 'auto'>
+
+export type RailwayDeployOptions = {
+  project?: string
+  environment: string
+  service: string
+  worker: boolean
+  source: RailwaySourceMode
+  region?: string
+  envFile?: string
+  domain?: string
+  waitDomain: boolean
+  volume?: string
+  token?: string
+  nonInteractive: boolean
+  dryRun: boolean
+  cleanup: boolean
+  yes: boolean
+  writeEnv: boolean
+  track: boolean
+  forceRename: boolean
+  timeoutSeconds: number
+  allowedSecretKeys: string[]
+  verbose: boolean
+  help: boolean
+}
+
+export type RailwaySource = {
+  mode: ResolvedRailwaySourceMode
+  reason: string
+  repo?: string
+  branch?: string
+  commitSha?: string
+}
+
+export type RailwayEnvironmentState = {
+  environmentId?: string
+  appServiceId?: string
+  workerServiceId?: string
+  postgresServiceId?: string
+  redisServiceId?: string
+  domainId?: string
+  volumeId?: string
+  appUrl?: string
+  source?: RailwaySource
+  lastDeployIds?: {
+    app?: string
+    worker?: string
+  }
+}
+
+export type RailwayState = {
+  schemaVersion: 1
+  provider: 'railway'
+  projectId?: string
+  workspaceId?: string
+  projectName: string
+  environments: Record<string, RailwayEnvironmentState>
+  writtenBy: {
+    cliVersion: string
+  }
+}
+
+export type RailwayGraphqlOperation = {
+  name: string
+  query: string
+  mutation?: boolean
+}
+
+export type RailwayGraphqlClient = {
+  request<T>(operation: RailwayGraphqlOperation, variables?: Record<string, unknown>): Promise<T>
+}
+
+export type RailwayService = {
+  id: string
+  name: string
+}
+
+export type RailwayDeployment = {
+  id: string
+  status: string
+  staticUrl?: string | null
+  url?: string | null
+  serviceId?: string | null
+  environmentId?: string | null
+}

package/src/mercato.ts

@@ -83,7 +83,7 @@ const TURBOPACK_CORRUPTION_PATTERNS = [
   'TurbopackInternalError',
 ]
 
-const BUILTIN_CLI_MODULE_IDS = new Set(['queue', 'generate', 'db', 'server', 'test'])
+const BUILTIN_CLI_MODULE_IDS = new Set(['queue', 'generate', 'deploy', 'db', 'server', 'test'])
 
 function collectNestedErrors(error: unknown, seen = new Set<unknown>()): ErrorWithCause[] {
   if (!error || seen.has(error)) {
@@ -254,10 +254,13 @@ function removeTurbopackDevCache(appDir: string): void {
   fs.rmSync(path.join(appDir, '.mercato', 'next', 'dev'), { recursive: true, force: true })
 }
 
-async function ensureEnvLoaded() {
+async function ensureEnvLoaded(options: { createIfMissing?: boolean; quiet?: boolean } = {}) {
   if (envLoaded) return
   envLoaded = true
-  const quietDotenv = process.env.DOTENV_CONFIG_QUIET === '1' || process.env.DOTENV_CONFIG_QUIET === 'true'
+  const quietDotenv =
+    options.quiet === true ||
+    process.env.DOTENV_CONFIG_QUIET === '1' ||
+    process.env.DOTENV_CONFIG_QUIET === 'true'
 
   // Try to find and load .env from the app directory
   // First, try to find the app directory via resolver
@@ -268,7 +271,11 @@ async function ensureEnvLoaded() {
 
     // Load .env from app directory if it exists
     const envPath = path.join(appDir, '.env')
-    if (!fs.existsSync(envPath) && process.env.NODE_ENV !== 'production') {
+    if (
+      options.createIfMissing !== false &&
+      !fs.existsSync(envPath) &&
+      process.env.NODE_ENV !== 'production'
+    ) {
       const examplePath = path.join(appDir, '.env.example')
       if (fs.existsSync(examplePath)) {
         fs.copyFileSync(examplePath, envPath)
@@ -751,9 +758,9 @@ async function buildAllModules(): Promise<Module[]> {
 }
 
 export async function run(argv = process.argv) {
-  await ensureEnvLoaded()
   const [, , ...parts] = argv
   const [first, second, ...remaining] = parts
+  await ensureEnvLoaded({ createIfMissing: first !== 'deploy', quiet: first === 'deploy' })
   
   // Handle init command directly
   if (first === 'init') {
@@ -1461,6 +1468,19 @@ export async function run(argv = process.argv) {
     } catch { /* @/cli may not exist in standalone apps — safe to ignore */ }
   }
   const all = modules.slice()
+
+  all.push({
+    id: 'deploy',
+    cli: [
+      {
+        command: 'railway',
+        run: async (args: string[]) => {
+          const { runRailwayDeploy } = await import('./lib/deploy/railway/index')
+          await runRailwayDeploy(args)
+        },
+      },
+    ],
+  } as Module)
   
   // Built-in CLI module: queue
   all.push({
@@ -2365,11 +2385,16 @@ export async function run(argv = process.argv) {
 
   console.log('')
   const started = Date.now()
-  console.log(`🚀 Running ${modName}:${cmdName} ${rest.join(' ')}`)
+  const loggedArgs = modName === 'deploy' && cmdName === 'railway'
+    ? (await import('./lib/deploy/railway/options')).redactRailwayCliArgs(rest)
+    : rest
+  console.log(`🚀 Running ${modName}:${cmdName} ${loggedArgs.join(' ')}`)
   try {
     await cmd.run(rest)
-    const ms = Date.now() - started
-    console.log(`⏱️ Done in ${ms}ms`)
+    if (modName !== 'deploy' || cmdName !== 'railway') {
+      const ms = Date.now() - started
+      console.log(`⏱️ Done in ${ms}ms`)
+    }
     return 0
   } catch (e: any) {
     console.error(`💥 Failed: ${formatCliFailureMessage(modName, cmdName, e)}`)