i18n-dashboard 0.1.0 → 0.3.7

package/assets/locales/en.json

@@ -376,5 +376,20 @@
   "scan.unused": "unused",
   "scan.files_scanned": "files scanned",
   "scan.errors": "errors",
-  "scan.run": "Scan"
+  "scan.run": "Scan",
+  "scan.mode_git": "Git",
+  "scan.git_hint": "Enter the Git repository URL. The scanner will clone it and detect all translation key usages in source files.",
+  "scan.git_url_label": "Repository URL",
+  "scan.git_url_hint": "Example: https://github.com/user/repo.git",
+  "scan.git_branch_label": "Branch",
+  "scan.git_branch_hint": "Leave empty to use main",
+  "scan.git_token_label": "Access token",
+  "scan.git_token_hint": "Required for private repositories",
+  "scan.git_token_placeholder": "ghp_xxxxxxxxxxxx",
+  "settings.git_url": "Git repository URL",
+  "settings.git_url_hint": "Used for Git scan mode",
+  "settings.git_branch": "Git branch",
+  "settings.git_branch_hint": "Default: main",
+  "settings.git_token": "Git access token",
+  "settings.git_token_hint": "For private repositories"
 }

package/components/ScanModal.vue

@@ -34,7 +34,7 @@
           <p class="text-sm text-gray-500 dark:text-gray-400">
             {{ t('scan.url_hint', 'Enter the base URL of your app. The scanner will fetch each configured locale file (en.json, fr.json…) and import all keys it finds.') }}
           </p>
-          <UFormField :label="t('scan.url_label', 'Base URL')" :hint="t('scan.url_hint2', 'Example: https://my-app.com')">
+          <UFormField :label="t('scan.url_label', 'Base URL')" :hint="t('scan.url_hint2', 'First configured URL is used by default')">
             <UInput v-model="remoteUrl" class="w-full" placeholder="https://my-app.com" />
           </UFormField>
           <div v-if="!project?.languages?.length" class="flex items-start gap-2 bg-amber-50 dark:bg-amber-900/20 rounded-lg px-3 py-2 text-xs text-amber-700 dark:text-amber-300">
@@ -109,7 +109,7 @@ const open = defineModel<boolean>('open', { default: false })
 
 const mode = ref<'local' | 'url'>('local')
 const localPath = ref(props.project?.root_path ?? '')
-const remoteUrl = ref(props.project?.source_url ?? '')
+const remoteUrl = ref(props.project?.source_url?.split(/[\n,]+/).map(u => u.trim()).filter(Boolean)[0] ?? '')
 const loading = ref(false)
 const result = ref<any>(null)
 const error = ref('')
@@ -124,7 +124,7 @@ watch(open, (val) => {
     result.value = null
     error.value = ''
     localPath.value = props.project?.root_path ?? ''
-    remoteUrl.value = props.project?.source_url ?? ''
+    remoteUrl.value = props.project?.source_url?.split(/[\n,]+/).map(u => u.trim()).filter(Boolean)[0] ?? ''
     mode.value = props.project?.root_path ? 'local' : props.project?.source_url ? 'url' : 'local'
   }
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-dashboard",
-  "version": "0.1.0",
+  "version": "0.3.7",
   "description": "A web dashboard to manage vue-i18n translation keys with database persistence",
   "type": "module",
   "bin": {

package/pages/projects/[id]/settings.vue

@@ -36,8 +36,8 @@
             <UFormField :label="t('settings.root_path', 'Root path')" :hint="t('settings.root_path_hint', 'Absolute path to the project root')">
               <PathPicker v-model="form.root_path" class="w-full" />
             </UFormField>
-            <UFormField :label="t('settings.source_url', 'Source URL')" :hint="t('settings.source_url_hint', 'App URL (for CORS auto-detection)')">
-              <UInput v-model="form.source_url" class="w-full" placeholder="https://my-app.com"/>
+            <UFormField class="col-span-2" :label="t('settings.source_url', 'App URLs')" :hint="t('settings.source_url_hint', 'One URL per line — all allowed for CORS, first used for scan/sync')">
+              <UTextarea v-model="form.source_url" class="w-full" :rows="3" placeholder="https://my-app.com&#10;https://staging.my-app.com"/>
             </UFormField>
             <UFormField :label="t('settings.locales_folder', 'Locales folder')" :hint="t('settings.locales_folder_hint', 'Relative to root')">
               <UInput v-model="form.locales_path" class="w-full" placeholder="src/locales"/>

package/server/api/projects/[id].put.ts

@@ -5,7 +5,7 @@ import { resolve } from 'path'
 export default defineEventHandler(async (event) => {
   const id = Number(getRouterParam(event, 'id'))
   const body = await readBody(event)
-  const { name, root_path, source_url, locales_path, key_separator, color, description, enable_number_formats, enable_datetime_formats, enable_modifiers } = body
+  const { name, root_path, source_url, locales_path, key_separator, color, description, enable_number_formats, enable_datetime_formats, enable_modifiers, git_url, git_token, git_branch } = body
 
   const db = getDb()
   const project = await db('projects').where({ id }).first()
@@ -22,6 +22,9 @@ export default defineEventHandler(async (event) => {
   if (enable_number_formats !== undefined) updates.enable_number_formats = enable_number_formats
   if (enable_datetime_formats !== undefined) updates.enable_datetime_formats = enable_datetime_formats
   if (enable_modifiers !== undefined) updates.enable_modifiers = enable_modifiers
+  if (git_url !== undefined) updates.git_url = git_url?.trim() || null
+  if (git_token !== undefined) updates.git_token = git_token?.trim() || null
+  if (git_branch !== undefined) updates.git_branch = git_branch?.trim() || null
 
   if (root_path !== undefined) {
     if (root_path.trim() === '') {

package/server/api/scan.post.ts

@@ -1,10 +1,13 @@
 import { resolve } from 'path'
+import { mkdtempSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { execSync } from 'child_process'
 import { getDb } from '../db/index'
 import { scanProject, detectLanguages } from '../utils/scanner.uti'
 
 export default defineEventHandler(async (event) => {
   const body = await readBody(event)
-  const { project_id, mode = 'local', root_path: bodyRootPath, url: bodyUrl } = body
+  const { project_id, mode = 'local', root_path: bodyRootPath, url: bodyUrl, git_url: bodyGitUrl, git_token: bodyGitToken, git_branch: bodyGitBranch } = body
 
   if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
 
@@ -15,7 +18,8 @@ export default defineEventHandler(async (event) => {
 
   // ── URL mode: fetch locale files and import keys ───────────────────────
   if (mode === 'url') {
-    const baseUrl = (bodyUrl || project.source_url || '').replace(/\/$/, '')
+    const rawUrl = bodyUrl || project.source_url?.split(/[\n,]+/).map((u: string) => u.trim()).filter(Boolean)[0] || ''
+    const baseUrl = rawUrl.replace(/\/$/, '')
     if (!baseUrl) throw createError({ statusCode: 400, message: 'No URL provided' })
 
     const languages = await db('languages').where({ project_id: Number(project_id) }).select('code')
@@ -59,6 +63,124 @@ export default defineEventHandler(async (event) => {
     return { keysImported: keysFound, keysAdded, total: Number((totalKeys as any)?.count || 0) }
   }
 
+  // ── Git mode: clone repo and scan source files ────────────────────────
+  if (mode === 'git') {
+    const gitUrl = bodyGitUrl || project.git_url
+    if (!gitUrl) throw createError({ statusCode: 400, message: 'No git URL provided' })
+
+    const token = bodyGitToken || project.git_token || ''
+    const branch = bodyGitBranch || project.git_branch || 'main'
+
+    // Inject token into URL for private repos
+    let authUrl = gitUrl
+    if (token) {
+      try {
+        const parsed = new URL(gitUrl)
+        parsed.username = 'oauth2'
+        parsed.password = token
+        authUrl = parsed.toString()
+      } catch {
+        authUrl = gitUrl.replace('https://', `https://oauth2:${token}@`)
+      }
+    }
+
+    const tmpDir = mkdtempSync(resolve(tmpdir(), 'i18n-scan-'))
+    try {
+      execSync(
+        `git clone --depth 1 --branch ${branch} --single-branch ${authUrl} ${tmpDir}`,
+        { stdio: 'pipe', timeout: 60000 },
+      )
+    } catch (e: any) {
+      rmSync(tmpDir, { recursive: true, force: true })
+      const msg = e?.stderr?.toString() || e?.message || 'Git clone failed'
+      throw createError({ statusCode: 400, message: msg.replace(/https?:\/\/[^@]+@/, 'https://***@') })
+    }
+
+    try {
+      const settings = await db('settings').select('*')
+      const settingsMap: Record<string, string> = {}
+      for (const s of settings) settingsMap[s.key] = s.value
+
+      const excludeDirs = (settingsMap['scan_exclude'] || 'node_modules,dist,.nuxt,.output,.git')
+        .split(',').map((s) => s.trim()).filter(Boolean)
+
+      const detectedLangs = detectLanguages({ projectRoot: tmpDir, localesPath: project.locales_path })
+      let langsAdded = 0
+      for (const lang of detectedLangs) {
+        const existing = await db('languages').where({ project_id: Number(project_id), code: lang.code }).first()
+        if (!existing) {
+          await db('languages').insert({ project_id: Number(project_id), code: lang.code, name: lang.name, is_default: false })
+          langsAdded++
+        }
+      }
+
+      const { usages, scannedFiles, errors } = scanProject({
+        projectRoot: tmpDir,
+        excludeDirs,
+        extensions: ['.vue', '.ts', '.js', '.mts', '.mjs'],
+      })
+
+      const keyMap = new Map<string, typeof usages>()
+      for (const usage of usages) {
+        const list = keyMap.get(usage.key) || []
+        list.push(usage)
+        keyMap.set(usage.key, list)
+      }
+
+      const now = db.fn.now()
+      let keysAdded = 0
+      let keysFound = 0
+
+      const existingKeys = await db('translation_keys').where({ project_id: Number(project_id) }).select('id', 'key')
+      const existingKeyMap = new Map<string, number>()
+      for (const k of existingKeys) existingKeyMap.set(k.key, k.id)
+
+      if (existingKeys.length > 0) {
+        await db('key_usages').whereIn('key_id', existingKeys.map(k => k.id)).delete()
+      }
+
+      for (const [key, keyUsages] of keyMap.entries()) {
+        let keyId = existingKeyMap.get(key)
+        if (!keyId) {
+          const [id] = await db('translation_keys').insert({ project_id: Number(project_id), key, is_unused: false, last_scanned_at: now })
+          keyId = id
+          keysAdded++
+        } else {
+          await db('translation_keys').where({ id: keyId }).update({ is_unused: false, last_scanned_at: now })
+        }
+        keysFound++
+        await db('key_usages').insert(keyUsages.map(u => ({
+          key_id: keyId,
+          file_path: u.filePath,
+          line_number: u.lineNumber,
+          detected_function: u.detectedFunction,
+          scanned_at: now,
+        })))
+      }
+
+      const foundKeys = new Set(keyMap.keys())
+      const unusedIds = existingKeys.filter(k => !foundKeys.has(k.key)).map(k => k.id)
+      if (unusedIds.length > 0) {
+        await db('translation_keys').whereIn('id', unusedIds).update({ is_unused: true, last_scanned_at: now })
+      }
+
+      const totalKeys = await db('translation_keys').where({ project_id: Number(project_id) }).count('* as count').first()
+
+      return {
+        keysFound,
+        keysAdded,
+        unusedKeys: unusedIds.length,
+        scannedFiles: scannedFiles.length,
+        total: Number((totalKeys as any)?.count || 0),
+        langsDetected: detectedLangs.length,
+        langsAdded,
+        errors: errors.slice(0, 10),
+      }
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  }
+
   // ── Local mode: scan source files ─────────────────────────────────────
   const rootPath = bodyRootPath || project.root_path
   if (!rootPath) {

package/server/api/sync.post.ts

@@ -109,7 +109,8 @@ export default defineEventHandler(async (event) => {
     }
 
     for (const lang of languages) {
-      const remoteData = await fetchRemoteLocale(project.source_url, lang.code)
+      const primaryUrl = project.source_url?.split(/[\n,]+/).map((u: string) => u.trim()).filter(Boolean)[0] || project.source_url
+      const remoteData = await fetchRemoteLocale(primaryUrl, lang.code)
       if (!remoteData) continue
 
       const flattened = flattenObject(remoteData, separator)

package/server/db/index.ts

@@ -669,4 +669,15 @@ export async function initDb(): Promise<void> {
   await addColumnIfMissing(db, 'projects', 'enable_modifiers', (t) =>
     t.boolean('enable_modifiers').defaultTo(false),
   )
+
+  // ── migration: git columns on projects ───────────────────────────────────
+  await addColumnIfMissing(db, 'projects', 'git_url', (t) =>
+    t.text('git_url').nullable(),
+  )
+  await addColumnIfMissing(db, 'projects', 'git_token', (t) =>
+    t.text('git_token').nullable(),
+  )
+  await addColumnIfMissing(db, 'projects', 'git_branch', (t) =>
+    t.text('git_branch').nullable(),
+  )
 }

package/server/routes/locale/[lang].get.ts

@@ -111,7 +111,7 @@ export default defineEventHandler(async (event) => {
       if (p) projectId = p.id
     }
 
-    // 2. Match by request Origin / Referer against project source_url
+    // 2. Match by request Origin / Referer against project source_url (supports multiple URLs, one per line)
     if (!projectId) {
       const requestOrigin = getHeader(event, 'origin') || getHeader(event, 'referer') || ''
       if (requestOrigin) {
@@ -122,7 +122,8 @@ export default defineEventHandler(async (event) => {
           .select('id', 'source_url')
 
         for (const p of projectsWithUrl) {
-          if (normalizeOrigin(p.source_url) === normalizedRequest) {
+          const urls = p.source_url.split(/[\n,]+/).map((u: string) => u.trim()).filter(Boolean)
+          if (urls.some((u: string) => normalizeOrigin(u) === normalizedRequest)) {
             projectId = p.id
             break
           }