docs-i18n 0.6.2 → 0.7.0

package/admin/server/functions/status.ts

@@ -0,0 +1,61 @@
+import { createServerFn } from '@tanstack/react-start';
+import {
+  getCache,
+  getFileBlocks,
+  getFileCoverage,
+  getLangs,
+  getOverview,
+  getVersions,
+  rescan,
+} from '../services/status';
+import { ensureInit } from '../init';
+
+export const fetchStatus = createServerFn({ method: 'GET' }).handler(async () => {
+  await ensureInit();
+  return {
+    versions: getVersions(),
+    langs: ['en', ...getLangs()],
+    data: getOverview(),
+  };
+});
+
+export const fetchFileCoverage = createServerFn({ method: 'GET' })
+  .inputValidator((d: { version: string; lang: string }) => d)
+  .handler(async ({ data }) => {
+    await ensureInit();
+    const { version, lang } = data;
+    if (lang === 'en') {
+      const anyLang = getLangs()[0];
+      const coverage = getFileCoverage(version, anyLang);
+      return coverage.map((f) => ({ file: f.file, total: f.total, translated: f.total }));
+    }
+    return getFileCoverage(version, lang);
+  });
+
+export const fetchFileBlocks = createServerFn({ method: 'GET' })
+  .inputValidator((d: { version: string; lang: string; path: string }) => d)
+  .handler(async ({ data }) => {
+    await ensureInit();
+    const { version, lang, path } = data;
+    const blocks = getFileBlocks(version, lang, path);
+    if (!blocks) throw new Error('File not found');
+    return { file: path, lang, version, blocks };
+  });
+
+export const deleteCacheEntry = createServerFn({ method: 'POST' })
+  .inputValidator((d: { version: string; lang: string; key: string }) => d)
+  .handler(async ({ data }) => {
+    await ensureInit();
+    const { lang, key } = data;
+    const cache = getCache();
+    cache.db.prepare('DELETE FROM translations WHERE lang = ? AND key = ?').run(lang, key);
+    return { deleted: key, lang };
+  });
+
+export const rescanVersion = createServerFn({ method: 'POST' })
+  .inputValidator((d: { version: string }) => d)
+  .handler(async ({ data }) => {
+    await ensureInit();
+    const count = rescan(data.version);
+    return { version: data.version, files: count };
+  });

package/admin/server/index.ts

@@ -0,0 +1,35 @@
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import type { DocsI18nConfig } from 'docs-i18n';
+import { initAdmin } from './init';
+
+/**
+ * Start the admin dashboard dev server.
+ * Called by the CLI `docs-i18n admin` command.
+ */
+export async function startAdmin(config: DocsI18nConfig, port: number) {
+  initAdmin(config);
+
+  const thisFile = fileURLToPath(import.meta.url);
+  // Admin package root is the directory containing this server/ folder
+  const adminRoot = resolve(dirname(thisFile), '..');
+
+  // Write project root so the admin server functions can find config + content.
+  const tmpFile = resolve(tmpdir(), 'docs-i18n-project-root');
+  writeFileSync(tmpFile, process.cwd());
+
+  const child = spawn('npx', ['vite', '--port', String(port)], {
+    cwd: adminRoot,
+    stdio: 'inherit',
+    env: { ...process.env, DOCS_I18N_PROJECT_ROOT: process.cwd() },
+    shell: true,
+  });
+
+  child.on('exit', (code) => process.exit(code ?? 0));
+
+  // Keep the process alive until the child exits.
+  await new Promise<void>(() => {});
+}

package/admin/server/init.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { DocsI18nConfig } from 'docs-i18n';
+import { initStatus } from './services/status';
+import { setConfig } from './services/job-manager';
+
+let _initialized = false;
+let _config: DocsI18nConfig | undefined;
+
+/**
+ * Initialize admin server services with the project config.
+ */
+export function initAdmin(config: DocsI18nConfig) {
+  _config = config;
+  initStatus(config);
+  setConfig(config);
+  _initialized = true;
+}
+
+export function getConfig(): DocsI18nConfig | undefined {
+  return _config;
+}
+
+export function getProjectRoot(): string {
+  if (process.env.DOCS_I18N_PROJECT_ROOT) return process.env.DOCS_I18N_PROJECT_ROOT;
+  // Read from temp file written by CLI at startup
+  try {
+    const tmpDir = process.env.TMPDIR || process.env.TEMP || '/tmp';
+    return readFileSync(resolve(tmpDir, 'docs-i18n-project-root'), 'utf-8').trim();
+  } catch {}
+  return process.cwd();
+}
+
+/**
+ * Ensure admin is initialized. Lazy-loads config on first call.
+ */
+export async function ensureInit() {
+  if (_initialized) return;
+  if (typeof window !== 'undefined') return;
+  const projectRoot = getProjectRoot();
+  const configPath = `${projectRoot}/docs-i18n.config.ts`;
+  const mod = await import(/* @vite-ignore */ configPath);
+  const config: DocsI18nConfig = mod.default ?? mod;
+  initAdmin(config);
+}

package/{src/admin → admin}/server/services/job-manager.ts

@@ -1,10 +1,16 @@
 import { type ChildProcess, spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import type { DocsI18nConfig } from '../../../config';
-
-const PROJECT_ROOT = process.cwd();
-// CLI binary path — reuse the same entry that started this process
-const CLI_BIN = process.argv[1] ?? 'docs-i18n';
+import type { DocsI18nConfig } from 'docs-i18n';
+
+function getProjectRoot(): string {
+  if (process.env.DOCS_I18N_PROJECT_ROOT) return process.env.DOCS_I18N_PROJECT_ROOT;
+  try {
+    const tmpDir = process.env.TMPDIR || process.env.TEMP || '/tmp';
+    return readFileSync(resolve(tmpDir, 'docs-i18n-project-root'), 'utf-8').trim();
+  } catch {}
+  return process.cwd();
+}
 
 let _config: DocsI18nConfig | undefined;
 export function setConfig(config: DocsI18nConfig) { _config = config; }
@@ -70,15 +76,25 @@ export class JobManager {
     };
     this.jobs.set(id, job);
 
+    // The version may be a compound key "project/version" from the admin UI.
+    // Split it into separate --project and --version args for the CLI.
+    let projectArg = opts.project ?? '';
+    let versionArg = opts.version;
+    if (!projectArg && opts.version.includes('/')) {
+      const parts = opts.version.split('/');
+      projectArg = parts.slice(0, -1).join('/');
+      versionArg = parts[parts.length - 1];
+    }
+
     const args = [
       'translate',
       '--lang', opts.lang,
-      '--version', opts.version,
+      '--version', versionArg,
       '--max', String(opts.max ?? 999),
       '--concurrency', String(opts.concurrency ?? 3),
     ];
 
-    if (opts.project) args.push('--project', opts.project);
+    if (projectArg) args.push('--project', projectArg);
     if (opts.model) args.push('--model', opts.model);
     if (opts.files?.length) args.push('--files', opts.files.join(','));
 
@@ -86,10 +102,23 @@ export class JobManager {
     const apiKey = _config?.llm?.apiKey || process.env.OPENROUTER_API_KEY || process.env.OPENAI_API_KEY || '';
     if (apiKey) args.push('--api-key', apiKey);
 
-    const proc = spawn(CLI_BIN, args, {
-      cwd: PROJECT_ROOT,
+    const projectRoot = getProjectRoot();
+
+    // Load .env from project root so child process has access to env vars
+    const childEnv: Record<string, string> = { ...process.env, NO_TTY: '1', FORCE_COLOR: '0' };
+    try {
+      const envContent = readFileSync(resolve(projectRoot, '.env'), 'utf-8');
+      for (const line of envContent.split('\n')) {
+        const match = line.match(/^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)\s*$/);
+        if (match && !childEnv[match[1]]) childEnv[match[1]] = match[2];
+      }
+    } catch {}
+
+    const proc = spawn('npx', ['docs-i18n', ...args], {
+      cwd: projectRoot,
       stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env, NO_TTY: '1', FORCE_COLOR: '0' },
+      env: childEnv,
+      shell: true,
     });
     this.processes.set(id, proc);
 

package/{src/admin → admin}/server/services/status.ts

@@ -1,16 +1,16 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import type { DocsI18nConfig } from '../../../config';
-import { flattenSources } from '../../../config';
-import { TranslationCache } from '../../../core/cache';
-import { parseMdx } from '../../../core/parser';
+import type { DocsI18nConfig } from 'docs-i18n';
+import { flattenSources, TranslationCache, parseMdx } from 'docs-i18n';
 
 let _config: DocsI18nConfig;
 let _cache: TranslationCache | null = null;
+let _projectRoot: string = process.cwd();
 
 export function initStatus(config: DocsI18nConfig) {
   _config = config;
   _cache = null; // reset
+  _projectRoot = process.env.DOCS_I18N_PROJECT_ROOT || process.cwd();
 }
 
 export function getVersions(): string[] {
@@ -23,14 +23,14 @@ export function getLangs(): string[] {
 
 export function getCache(): TranslationCache {
   if (!_cache) {
-    _cache = new TranslationCache(resolve(_config.cacheDir ?? '.cache'));
+    _cache = new TranslationCache(resolve(_projectRoot, _config.cacheDir ?? '.cache'));
   }
   return _cache;
 }
 
 function getSourcePath(versionKey: string): string | null {
   const source = flattenSources(_config).find((s) => s.versionKey === versionKey);
-  return source ? resolve(source.sourcePath) : null;
+  return source ? resolve(_projectRoot, source.sourcePath) : null;
 }
 
 function walkFiles(dir: string): string[] {

package/admin/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "paths": {
+      "docs-i18n": ["../core/src/index.ts"]
+    }
+  },
+  "include": ["app", "server"],
+  "exclude": ["node_modules"]
+}

package/{src/admin → admin}/vite.config.ts

@@ -1,7 +1,13 @@
 // @ts-nocheck — Vite config, not checked by project tsc
-import react from '@vitejs/plugin-react';
 import { defineConfig } from 'vite';
+import { tanstackStart } from '@tanstack/react-start/plugin/vite';
+import react from '@vitejs/plugin-react';
 
 export default defineConfig({
-  plugins: [react()],
+  plugins: [
+    tanstackStart({
+      srcDirectory: 'app',
+    }),
+    react(),
+  ],
 });

package/dist/{assemble-7H4QCW35.js → assemble-CP2BRYQJ.js}

@@ -1,13 +1,15 @@
 import {
   assemble
-} from "./chunk-A3YQNPKZ.js";
-import "./chunk-YN4VJHCQ.js";
+} from "./chunk-CLYUAWZE.js";
+import "./chunk-JHBSHTXC.js";
 import {
   TranslationCache
-} from "./chunk-XEOYZUHS.js";
+} from "./chunk-QKIR7RKQ.js";
 import {
   flattenSources
-} from "./chunk-SKKZIV3L.js";
+} from "./chunk-TRURQFP4.js";
+import "./chunk-L64GJ4OB.js";
+import "./chunk-PNKVD2UK.js";
 
 // src/commands/assemble.ts
 import {

package/dist/{chunk-A3YQNPKZ.js → chunk-CLYUAWZE.js}

@@ -3,7 +3,7 @@ import {
   init_parser,
   normalize,
   parseMdx
-} from "./chunk-YN4VJHCQ.js";
+} from "./chunk-JHBSHTXC.js";
 
 // src/core/assembler.ts
 init_normalize();

package/dist/{chunk-YN4VJHCQ.js → chunk-JHBSHTXC.js}

@@ -1,6 +1,6 @@
 import {
   __esm
-} from "./chunk-SKKZIV3L.js";
+} from "./chunk-PNKVD2UK.js";
 
 // src/core/normalize.ts
 function normalize(content) {

package/dist/chunk-L64GJ4OB.js

@@ -0,0 +1,32 @@
+// src/core/sqlite.ts
+import { createRequire } from "module";
+var isBun = typeof globalThis.Bun !== "undefined";
+function openDatabase(filepath) {
+  if (isBun) {
+    const req2 = createRequire(import.meta.url);
+    const mod = req2("bun:sqlite");
+    const Database2 = mod.Database ?? mod.default ?? mod;
+    const raw = new Database2(filepath);
+    return {
+      prepare: (sql) => {
+        const stmt = raw.query(sql);
+        return {
+          run: (...params) => stmt.run(...params),
+          get: (...params) => stmt.get(...params),
+          all: (...params) => stmt.all(...params)
+        };
+      },
+      exec: (sql) => raw.run(sql),
+      pragma: (p) => raw.run(`PRAGMA ${p}`),
+      transaction: (fn) => raw.transaction(fn),
+      close: () => raw.close()
+    };
+  }
+  const req = createRequire(import.meta.url);
+  const Database = req("better-sqlite3");
+  return new Database(filepath);
+}
+
+export {
+  openDatabase
+};

package/dist/{chunk-SKKZIV3L.js → chunk-PNKVD2UK.js}

@@ -19,36 +19,8 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/config.ts
-async function loadConfig(path) {
-  const configPath = path ?? "docs-i18n.config.ts";
-  try {
-    const mod = await import(
-      /* @vite-ignore */
-      `${process.cwd()}/${configPath}`
-    );
-    return mod.default ?? mod;
-  } catch {
-    throw new Error(`Cannot load config from ${configPath}. Create a docs-i18n.config.ts file.`);
-  }
-}
-function flattenSources(config) {
-  const projects = Object.entries(config.projects);
-  const singleProject = projects.length === 1;
-  return projects.flatMap(
-    ([projectId, project]) => Object.entries(project.sources).map(([version, sourcePath]) => ({
-      project: projectId,
-      version,
-      sourcePath,
-      versionKey: singleProject ? version : `${projectId}/${version}`
-    }))
-  );
-}
-
 export {
   __esm,
   __export,
-  __toCommonJS,
-  loadConfig,
-  flattenSources
+  __toCommonJS
 };

package/dist/{chunk-XEOYZUHS.js → chunk-QKIR7RKQ.js}

@@ -1,37 +1,10 @@
+import {
+  openDatabase
+} from "./chunk-L64GJ4OB.js";
+
 // src/core/cache.ts
 import fs from "fs";
 import path from "path";
-
-// src/core/sqlite.ts
-import { createRequire } from "module";
-var isBun = typeof globalThis.Bun !== "undefined";
-function openDatabase(filepath) {
-  if (isBun) {
-    const req2 = createRequire(import.meta.url);
-    const mod = req2("bun:sqlite");
-    const Database2 = mod.Database ?? mod.default ?? mod;
-    const raw = new Database2(filepath);
-    return {
-      prepare: (sql) => {
-        const stmt = raw.query(sql);
-        return {
-          run: (...params) => stmt.run(...params),
-          get: (...params) => stmt.get(...params),
-          all: (...params) => stmt.all(...params)
-        };
-      },
-      exec: (sql) => raw.run(sql),
-      pragma: (p) => raw.run(`PRAGMA ${p}`),
-      transaction: (fn) => raw.transaction(fn),
-      close: () => raw.close()
-    };
-  }
-  const req = createRequire(import.meta.url);
-  const Database = req("better-sqlite3");
-  return new Database(filepath);
-}
-
-// src/core/cache.ts
 var TranslationCache = class {
   db;
   cacheDir;

package/dist/chunk-TRURQFP4.js

@@ -0,0 +1,31 @@
+// src/config.ts
+async function loadConfig(path) {
+  const configPath = path ?? "docs-i18n.config.ts";
+  const fullPath = configPath.startsWith("/") ? configPath : `${process.cwd()}/${configPath}`;
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      fullPath
+    );
+    return mod.default ?? mod;
+  } catch {
+    throw new Error(`Cannot load config from ${fullPath}. Create a docs-i18n.config.ts file.`);
+  }
+}
+function flattenSources(config) {
+  const projects = Object.entries(config.projects);
+  const singleProject = projects.length === 1;
+  return projects.flatMap(
+    ([projectId, project]) => Object.entries(project.sources).map(([version, sourcePath]) => ({
+      project: projectId,
+      version,
+      sourcePath,
+      versionKey: singleProject ? version : `${projectId}/${version}`
+    }))
+  );
+}
+
+export {
+  loadConfig,
+  flattenSources
+};

package/dist/cli.js

@@ -1,26 +1,11 @@
 #!/usr/bin/env node
 import {
   loadConfig
-} from "./chunk-SKKZIV3L.js";
+} from "./chunk-TRURQFP4.js";
+import "./chunk-PNKVD2UK.js";
 
 // src/cli.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
 import { createRequire } from "module";
-var envPath = resolve(process.cwd(), ".env");
-if (existsSync(envPath)) {
-  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eq = trimmed.indexOf("=");
-    if (eq < 0) continue;
-    const key = trimmed.slice(0, eq).trim();
-    let val = trimmed.slice(eq + 1).trim();
-    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'"))
-      val = val.slice(1, -1);
-    if (!process.env[key]) process.env[key] = val;
-  }
-}
 var args = process.argv.slice(2);
 if (args[0] === "--version" || args[0] === "-v") {
   const require2 = createRequire(import.meta.url);
@@ -36,6 +21,92 @@ function getOpt(name, def = "") {
 function hasFlag(name) {
   return args.includes(`--${name}`);
 }
+async function handleSiteCommand() {
+  const validSub = /* @__PURE__ */ new Set(["dev", "build", "upload", "deploy"]);
+  const subCommand = args.slice(1).find((a) => validSub.has(a));
+  const port = Number(getOpt("port", "3000"));
+  const { resolve, dirname } = await import("path");
+  const { fileURLToPath } = await import("url");
+  const { writeFileSync } = await import("fs");
+  const { spawn } = await import("child_process");
+  const os = await import("os");
+  const thisFile = fileURLToPath(import.meta.url);
+  const pkgRoot = resolve(dirname(thisFile), "..");
+  const { existsSync: exists } = await import("fs");
+  let templateRoot;
+  const nmPath = resolve(pkgRoot, "node_modules", "@docs-i18n", "template");
+  if (exists(nmPath)) {
+    const { realpathSync } = await import("fs");
+    templateRoot = realpathSync(nmPath);
+  } else {
+    templateRoot = resolve(pkgRoot, "template");
+  }
+  const tmpFile = resolve(os.tmpdir(), "docs-i18n-project-root");
+  writeFileSync(tmpFile, process.cwd());
+  const { existsSync } = await import("fs");
+  const { execSync } = await import("child_process");
+  if (!existsSync(resolve(templateRoot, "node_modules"))) {
+    console.log("Installing template dependencies...");
+    execSync("npm install --no-audit --no-fund", {
+      cwd: templateRoot,
+      stdio: "inherit"
+    });
+  }
+  if (!subCommand || subCommand === "dev") {
+    const child = spawn("npx", ["vite", "--port", String(port)], {
+      cwd: templateRoot,
+      stdio: "inherit",
+      env: { ...process.env, DOCS_I18N_PROJECT_ROOT: process.cwd() },
+      shell: true
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+  } else if (subCommand === "build") {
+    const child = spawn("npx", ["vite", "build"], {
+      cwd: templateRoot,
+      stdio: "inherit",
+      env: { ...process.env, DOCS_I18N_PROJECT_ROOT: process.cwd() },
+      shell: true
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+  } else if (subCommand === "upload") {
+    console.log("Uploading content to D1...");
+    const { collectContentFiles, generateContentSql, collectTranslations, generateTranslationSql } = await import("./upload-XL6KG6S2.js");
+    const projectRoot = process.cwd();
+    const contentRows = collectContentFiles(projectRoot);
+    const contentSql = generateContentSql(contentRows);
+    console.log(`Collected ${contentRows.length} content files.`);
+    const translationData = collectTranslations(projectRoot);
+    const translationSql = generateTranslationSql(translationData);
+    console.log(`Collected ${translationData.sources.length} sources, ${translationData.translations.length} translations.`);
+    const allSql = [...contentSql, ...translationSql];
+    const sqlFile = resolve(os.tmpdir(), "docs-i18n-upload.sql");
+    writeFileSync(sqlFile, allSql.join("\n"));
+    const dbName = getOpt("db", "docs-i18n-db");
+    const child = spawn("npx", ["wrangler", "d1", "execute", dbName, "--file", sqlFile], {
+      cwd: templateRoot,
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        console.log("Upload complete.");
+      }
+      process.exit(code ?? 0);
+    });
+  } else if (subCommand === "deploy") {
+    const child = spawn("npx", ["wrangler", "deploy"], {
+      cwd: templateRoot,
+      stdio: "inherit",
+      env: { ...process.env },
+      shell: true
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+  } else {
+    console.error(`Unknown site subcommand: ${subCommand}`);
+    console.log("Usage: docs-i18n site [dev|build|upload|deploy]");
+    process.exit(1);
+  }
+}
 async function main() {
   if (!command || command === "--help" || command === "-h") {
     console.log(`
@@ -47,6 +118,7 @@ Commands:
   rescan       Rescan source files and clean orphans
   status       Show translation coverage
   admin        Start admin dashboard
+  site         Manage documentation site (dev, build, upload, deploy)
 
 Options:
   --lang <code>         Target language (e.g., zh-hans)
@@ -59,10 +131,14 @@ Options:
   --max-tokens <n>      Max output tokens (default: 16384)
   --context-length <n>  Model context window (default: 32768)
   --dry-run             Preview without making changes
-  --port <n>            Admin dashboard port (default: 3456)
+  --port <n>            Admin dashboard port (default: 3456) / Site dev port (default: 3000)
 `);
     return;
   }
+  if (command === "site") {
+    await handleSiteCommand();
+    return;
+  }
   const configPath = getOpt("config") || void 0;
   const config = await loadConfig(configPath);
   switch (command) {
@@ -72,7 +148,7 @@ Options:
         console.error("Error: --lang is required");
         process.exit(1);
       }
-      const { translate } = await import("./translate-ZIVKNAC4.js");
+      const { translate } = await import("./translate-A5X6MX4Y.js");
       await translate(config, {
         lang,
         project: getOpt("project") || void 0,
@@ -89,7 +165,7 @@ Options:
       break;
     }
     case "assemble": {
-      const { assembleAll } = await import("./assemble-7H4QCW35.js");
+      const { assembleAll } = await import("./assemble-CP2BRYQJ.js");
       await assembleAll(config, {
         project: getOpt("project") || void 0,
         version: getOpt("version") || void 0,
@@ -98,7 +174,7 @@ Options:
       break;
     }
     case "rescan": {
-      const { rescan } = await import("./rescan-O5D3CYC2.js");
+      const { rescan } = await import("./rescan-HXMWFAOC.js");
       await rescan(config, {
         project: getOpt("project") || void 0,
         version: getOpt("version") || void 0
@@ -106,13 +182,22 @@ Options:
       break;
     }
     case "status": {
-      const { status } = await import("./status-F4MYIAAY.js");
+      const { status } = await import("./status-AGZDXOTZ.js");
       await status(config, { lang: getOpt("lang") || void 0 });
       break;
     }
     case "admin": {
       const port = Number(getOpt("port", "3456"));
-      const { startAdmin } = await import("./server-73AVSOL5.js");
+      const { resolve: res, dirname: dn } = await import("path");
+      const { fileURLToPath: toPath } = await import("url");
+      const { existsSync: ex, realpathSync: rp } = await import("fs");
+      const coreRoot = res(dn(toPath(import.meta.url)), "..");
+      const adminNm = res(coreRoot, "node_modules", "@docs-i18n", "admin");
+      const adminRoot = ex(adminNm) ? rp(adminNm) : res(coreRoot, "admin");
+      const { startAdmin } = await import(
+        /* @vite-ignore */
+        res(adminRoot, "server", "index.ts")
+      );
       await startAdmin(config, port);
       break;
     }