@take-out/scripts 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "main": "./src/cmd.ts",
   "sideEffects": false,
@@ -30,8 +30,8 @@
   "dependencies": {
     "@clack/prompts": "^0.8.2",
     "@lydell/node-pty": "^1.2.0-beta.3",
-    "@take-out/helpers": "0.2.1",
-    "@take-out/run": "0.2.1",
+    "@take-out/helpers": "0.2.2",
+    "@take-out/run": "0.2.2",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/env-update.ts

@@ -1,12 +1,35 @@
 #!/usr/bin/env bun
 
 import fs from 'node:fs'
+import path from 'node:path'
 
 import { cmd } from './cmd'
 import { resolveDepVersion } from './helpers/resolve-dep-version'
 
-await cmd`sync environment variables from package.json to CI and server configs`.run(
-  async () => {
+const PRESETS: Record<string, string[]> = {
+  takeout: [
+    '.github/workflows/*.yml',
+    'src/uncloud/*.yml',
+    '.env*',
+    'src/env.ts',
+    'src/constants/env-server.ts',
+    'src/server/env-server.ts',
+  ],
+}
+
+const IGNORE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.cache',
+  '.docker',
+])
+
+await cmd`sync environment variables from package.json to matching files`
+  .args('--preset string')
+  .run(async ({ args }) => {
     const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
     const envVars = packageJson.env as Record<string, boolean | string>
 
@@ -15,75 +38,192 @@ await cmd`sync environment variables from package.json to CI and server configs`
       process.exit(1)
     }
 
+    // resolve $dep: values
+    const depResolved: Record<string, string> = {}
+    for (const [key, value] of Object.entries(envVars)) {
+      const dep = resolveDepVersion(value, packageJson.dependencies)
+      if (dep) {
+        depResolved[key] = dep
+      }
+    }
+
+    // load .gitignore patterns
+    const gitignorePatterns: string[] = []
+    try {
+      const gi = fs.readFileSync('.gitignore', 'utf-8')
+      for (const line of gi.split('\n')) {
+        const trimmed = line.trim()
+        if (trimmed && !trimmed.startsWith('#')) {
+          gitignorePatterns.push(trimmed.replace(/\/$/, ''))
+        }
+      }
+    } catch {}
+
+    function isIgnored(filePath: string): boolean {
+      const parts = filePath.split('/')
+      for (const part of parts) {
+        if (IGNORE_DIRS.has(part)) return true
+      }
+      for (const pattern of gitignorePatterns) {
+        if (filePath.startsWith(pattern) || parts.some((p) => p === pattern)) {
+          return true
+        }
+      }
+      return false
+    }
+
+    // simple glob: supports *.ext, dir/*.ext, dir/**/*.ext, .prefix*
+    function expandPattern(pattern: string): string[] {
+      const results: string[] = []
+
+      if (!pattern.includes('*')) {
+        if (fs.existsSync(pattern)) results.push(pattern)
+        return results
+      }
+
+      const isRecursive = pattern.includes('**')
+      const parts = pattern.split('**/')
+      const baseDir = parts.length > 1 ? parts[0]!.replace(/\/$/, '') || '.' : '.'
+      const filePattern =
+        parts.length > 1
+          ? parts[1]!
+          : pattern.includes('/')
+            ? pattern.split('/').pop()!
+            : pattern
+
+      // for non-recursive patterns with a dir prefix like "src/uncloud/*.yml"
+      const nonRecursiveDir =
+        !isRecursive && pattern.includes('/')
+          ? pattern.slice(0, pattern.lastIndexOf('/'))
+          : null
+
+      const matchRe = new RegExp(
+        '^' + filePattern.replace(/\./g, '\\.').replace(/\*/g, '[^/]*') + '$'
+      )
+
+      function walk(dir: string) {
+        let entries: fs.Dirent[]
+        try {
+          entries = fs.readdirSync(dir, { withFileTypes: true })
+        } catch {
+          return
+        }
+        for (const entry of entries) {
+          const full = dir === '.' ? entry.name : `${dir}/${entry.name}`
+          if (isRecursive && isIgnored(full)) continue
+          if (entry.isDirectory()) {
+            if (isRecursive) walk(full)
+          } else if (matchRe.test(entry.name)) {
+            results.push(full)
+          }
+        }
+      }
+
+      walk(nonRecursiveDir || baseDir)
+      return results
+    }
+
+    // resolve file list: --preset > CLI args > package.json config > preset:takeout
+    let patterns: string[]
+    if (args.preset) {
+      const preset = PRESETS[args.preset]
+      if (!preset) {
+        console.error(
+          `Unknown preset: ${args.preset}\nAvailable: ${Object.keys(PRESETS).join(', ')}`
+        )
+        process.exit(1)
+      }
+      patterns = preset
+    } else if (args.rest.length) {
+      patterns = args.rest
+    } else {
+      patterns = packageJson.envUpdateFiles || PRESETS.takeout!
+    }
+
+    // expand all patterns
+    const files: string[] = []
+    for (const p of patterns) {
+      files.push(...expandPattern(p))
+    }
+
+    // markers
     const markerStart = '🔒 start - this is generated by "bun env:update"'
     const markerEnd = '🔒 end - this is generated by "bun env:update"'
+    const yamlStart = `# ${markerStart}`
+    const yamlEnd = `# ${markerEnd}`
+    const jsStart = `// ${markerStart}`
+    const jsEnd = `// ${markerEnd}`
 
-    const yamlStartMarker = `# ${markerStart}`
-    const yamlEndMarker = `# ${markerEnd}`
+    type Strategy = 'yaml-markers' | 'js-markers' | 'dotenv-inline' | 'ts-inline'
 
-    const jsStartMarker = `// ${markerStart}`
-    const jsEndMarker = `// ${markerEnd}`
+    function detectStrategy(filePath: string, content: string): Strategy | null {
+      if (content.includes(yamlStart) && content.includes(yamlEnd)) {
+        return 'yaml-markers'
+      }
+      if (content.includes(jsStart) && content.includes(jsEnd)) {
+        return 'js-markers'
+      }
+      if (/^\.env/.test(path.basename(filePath))) {
+        return 'dotenv-inline'
+      }
+      if (filePath.endsWith('.ts') && Object.keys(depResolved).length > 0) {
+        return 'ts-inline'
+      }
+      return null
+    }
 
-    function replaceYamlSection(
+    function escapeRegExp(s: string): string {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    }
+
+    function replaceMarkerSection(
       content: string,
-      lines: string,
-      options: { indent: string }
+      startMarker: string,
+      endMarker: string,
+      newSection: string
     ): string {
-      return content.replace(
-        new RegExp(`${yamlStartMarker}(.|\n)*?${yamlEndMarker}`, 'gm'),
-        `${yamlStartMarker}\n${lines}\n${options.indent}${yamlEndMarker}`
+      const re = new RegExp(
+        `^([ \\t]*)${escapeRegExp(startMarker)}(.|\n)*?${escapeRegExp(endMarker)}`,
+        'gm'
       )
+      return content.replace(re, (_match, indent) => {
+        return `${indent}${startMarker}\n${newSection}\n${indent}${endMarker}`
+      })
     }
 
-    function updateDeployYml() {
-      const deployYmlPath = '.github/workflows/ci.yml'
-      let deployYml = fs.readFileSync(deployYmlPath, 'utf-8')
+    function applyYamlMarkers(filePath: string, content: string): string {
+      const markerMatch = content.match(
+        new RegExp(`^(\\s*)${escapeRegExp(yamlStart)}`, 'm')
+      )
+      const indent = markerMatch?.[1] || '      '
 
-      if (!deployYml.includes(yamlStartMarker) || !deployYml.includes(yamlEndMarker)) {
-        throw new Error(`Markers not found in ${deployYmlPath}`)
-      }
+      const beforeMarker = content.slice(0, content.indexOf(yamlStart))
+      const isMap = /x-[\w-]+:.*&[\w-]+/s.test(beforeMarker)
+      const isGithubActions = filePath.includes('.github/workflows')
 
-      const indent = `          `
-      const envSection = Object.entries(envVars)
+      const envLines = Object.entries(envVars)
         .map(([key, value]) => {
-          const resolved = resolveDepVersion(value, packageJson.dependencies)
-          if (resolved) {
-            return `${indent}${key}: \${{ secrets.${key} || '${resolved}' }}`
+          const dep = resolveDepVersion(value, packageJson.dependencies)
+          const defaultVal = dep || (typeof value === 'string' ? value : '')
+
+          if (isGithubActions) {
+            return dep
+              ? `${indent}${key}: \${{ secrets.${key} || '${dep}' }}`
+              : `${indent}${key}: \${{ secrets.${key} }}`
           }
-          return `${indent}${key}: \${{ secrets.${key} }}`
+
+          return isMap
+            ? `${indent}${key}: \${${key}:-${defaultVal}}`
+            : `${indent}- ${key}=\${${key}:-${defaultVal}}`
         })
         .join('\n')
 
-      const newDeployYml = replaceYamlSection(deployYml, envSection, { indent })
-
-      fs.writeFileSync(deployYmlPath, newDeployYml, 'utf-8')
-      console.info('✅ Updated Github workflow')
+      return replaceMarkerSection(content, yamlStart, yamlEnd, envLines)
     }
 
-    function updateEnvServerTs() {
-      const candidates = ['src/constants/env-server.ts', 'src/server/env-server.ts']
-      let envServerPath = ''
-      let envServer = ''
-
-      for (const p of candidates) {
-        try {
-          envServer = fs.readFileSync(p, 'utf-8')
-          envServerPath = p
-          break
-        } catch {}
-      }
-
-      if (!envServerPath) {
-        throw new Error(`env-server.ts not found at ${candidates.join(' or ')}`)
-      }
-
-      if (!envServer.includes(jsStartMarker) || !envServer.includes(jsEndMarker)) {
-        throw new Error(`Markers not found in ${envServerPath}`)
-      }
-
+    function applyJsMarkers(_filePath: string, content: string): string {
       const envExports = Object.entries(envVars)
         .map(([key, value]) => {
-          // $dep: values have no compile-time default — resolved into .env at runtime
           if (typeof value === 'string' && value.startsWith('$dep:')) {
             return `export const ${key} = ensureEnv('${key}')`
           }
@@ -91,69 +231,64 @@ await cmd`sync environment variables from package.json to CI and server configs`
         })
         .join('\n')
 
-      const newEnvServer = envServer.replace(
-        new RegExp(`${jsStartMarker}(.|\n)*?${jsEndMarker}`, 'm'),
-        `${jsStartMarker}\n${envExports}\n${jsEndMarker}`
-      )
-
-      fs.writeFileSync(envServerPath, newEnvServer, 'utf-8')
-      console.info('✅ Updated server env')
+      return replaceMarkerSection(content, jsStart, jsEnd, envExports)
     }
 
-    function updateDockerCompose() {
-      const dockerComposePath = 'src/uncloud/docker-compose.yml'
-
-      let dockerCompose = ''
-      try {
-        dockerCompose = fs.readFileSync(dockerComposePath, 'utf-8')
-      } catch (_error) {
-        // file doesn't exist, skip
-        return
+    function applyDotenvInline(_filePath: string, content: string): string {
+      let result = content
+      for (const [key, value] of Object.entries(depResolved)) {
+        const re = new RegExp(`^(${key})=(.+)$`, 'm')
+        const match = result.match(re)
+        if (match && match[2] !== value) {
+          result = result.replace(re, `$1=${value}`)
+        }
       }
+      return result
+    }
 
-      if (
-        !dockerCompose.includes(yamlStartMarker) ||
-        !dockerCompose.includes(yamlEndMarker)
-      ) {
-        // no markers, skip
-        return
+    function applyTsInline(_filePath: string, content: string): string {
+      let result = content
+      for (const [key, value] of Object.entries(depResolved)) {
+        const re = new RegExp(`(${key}:\\s*)(['"])([^'"]+)\\2`, 'g')
+        result = result.replace(re, (_match, prefix, quote, oldValue) => {
+          if (oldValue !== value) return `${prefix}${quote}${value}${quote}`
+          return _match
+        })
       }
+      return result
+    }
 
-      // detect indent from the marker line
-      const markerMatch = dockerCompose.match(
-        new RegExp(`^(\\s*)${yamlStartMarker}`, 'm')
-      )
-      const indent = markerMatch?.[1] || '      '
+    const strategies: Record<Strategy, (filePath: string, content: string) => string> = {
+      'yaml-markers': applyYamlMarkers,
+      'js-markers': applyJsMarkers,
+      'dotenv-inline': applyDotenvInline,
+      'ts-inline': applyTsInline,
+    }
 
-      // detect format: if markers are under an x- anchor block, use map syntax (KEY: val)
-      // otherwise use list syntax (- KEY=val)
-      const beforeMarker = dockerCompose.slice(0, dockerCompose.indexOf(yamlStartMarker))
-      const isMap = /x-[\w-]+:.*&[\w-]+/s.test(beforeMarker)
+    let updated = 0
 
-      const envLines = Object.entries(envVars)
-        .map(([key, value]) => {
-          const resolved = resolveDepVersion(value, packageJson.dependencies)
-          const defaultVal = resolved || (typeof value === 'string' ? value : '')
-          return isMap
-            ? `${indent}${key}: \${${key}:-${defaultVal}}`
-            : `${indent}- ${key}=\${${key}:-${defaultVal}}`
-        })
-        .join('\n')
+    for (const filePath of files) {
+      let content = ''
+      try {
+        content = fs.readFileSync(filePath, 'utf-8')
+      } catch {
+        continue
+      }
 
-      const newDockerCompose = replaceYamlSection(dockerCompose, envLines, { indent })
+      const strategy = detectStrategy(filePath, content)
+      if (!strategy) continue
 
-      fs.writeFileSync(dockerComposePath, newDockerCompose, 'utf-8')
-      console.info('✅ Updated docker-compose.yml')
+      const newContent = strategies[strategy](filePath, content)
+      if (newContent !== content) {
+        fs.writeFileSync(filePath, newContent, 'utf-8')
+        console.info(`✅ ${filePath} (${strategy})`)
+        updated++
+      }
     }
 
-    try {
-      updateDeployYml()
-      updateEnvServerTs()
-      updateDockerCompose()
-      console.info('✅ All files updated successfully')
-    } catch (error: any) {
-      console.error('❌ Update failed:', error.message)
-      process.exit(1)
+    if (updated > 0) {
+      console.info(`\n✅ Updated ${updated} file${updated > 1 ? 's' : ''}`)
+    } else {
+      console.info('All files up to date')
     }
-  }
-)
+  })