wyxrouter 0.4.71

package/scripts/compact-request-details.mjs

@@ -0,0 +1,71 @@
+import path from "node:path";
+
+import Database from "better-sqlite3";
+
+const apply = process.argv.includes("--apply");
+const keepArg = process.argv.find((arg) => arg.startsWith("--keep="));
+const keep = Math.max(0, Number.parseInt(keepArg?.split("=")[1] || "200", 10));
+const dbPath = path.join(process.env.APPDATA, "9router", "db", "data.sqlite");
+const db = new Database(dbPath, apply ? {} : { readonly: true });
+const fields = ["latency", "tokens", "request", "providerRequest", "providerResponse", "response"];
+
+function compactField(value, limit) {
+  const serialized = JSON.stringify(value ?? {});
+  if (serialized.length <= limit) return value ?? {};
+  return {
+    _truncated: true,
+    _originalSize: serialized.length,
+    _preview: serialized.substring(0, 200),
+  };
+}
+
+try {
+  const before = db.prepare(`
+    SELECT COUNT(*) AS count, COALESCE(SUM(LENGTH(data)), 0) AS bytes
+    FROM requestDetails
+  `).get();
+
+  console.log(JSON.stringify({ dbPath, apply, keep, before }));
+  if (!apply) process.exit(0);
+
+  db.pragma("journal_mode = DELETE");
+  let rewritten = 0;
+  db.transaction(() => {
+    db.prepare(`
+      DELETE FROM requestDetails
+      WHERE id NOT IN (
+        SELECT id FROM requestDetails ORDER BY timestamp DESC LIMIT ?
+      )
+    `).run(keep);
+  })();
+
+  const rows = db.prepare("SELECT id, provider, data FROM requestDetails").all();
+  db.transaction(() => {
+    const update = db.prepare("UPDATE requestDetails SET data = ? WHERE id = ?");
+    for (const row of rows) {
+      const detail = JSON.parse(row.data);
+      const limit = row.provider === "kiro" ? 16 * 1024 : 64 * 1024;
+      let changed = false;
+      for (const field of fields) {
+        const compacted = compactField(detail[field], limit);
+        if (compacted !== detail[field]) {
+          detail[field] = compacted;
+          changed = true;
+        }
+      }
+      if (changed) {
+        update.run(JSON.stringify(detail), row.id);
+        rewritten += 1;
+      }
+    }
+  })();
+  db.exec("VACUUM");
+
+  const after = db.prepare(`
+    SELECT COUNT(*) AS count, COALESCE(SUM(LENGTH(data)), 0) AS bytes
+    FROM requestDetails
+  `).get();
+  console.log(JSON.stringify({ after, rewritten }));
+} finally {
+  db.close();
+}

package/scripts/import-codex-gptjson.mjs

@@ -0,0 +1,342 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
+
+import { DATA_FILE } from "../src/lib/db/paths.js";
+import { makeBackupDir, backupFile, pruneOldBackups } from "../src/lib/db/backup.js";
+import { getAdapter } from "../src/lib/db/driver.js";
+import { getProviderConnections } from "../src/lib/localDb.js";
+
+const DEFAULT_SOURCE = "D:\\TeraBoxDownload\\GPTJson";
+const SOURCE_DIR = process.argv.find((arg) => !arg.startsWith("--") && arg !== process.argv[0] && arg !== process.argv[1]) || DEFAULT_SOURCE;
+const DRY_RUN = process.argv.includes("--dry-run");
+const NO_BACKUP = process.argv.includes("--no-backup");
+const KEEP_TEMP = process.argv.includes("--keep-temp");
+
+function usage() {
+  console.log("Usage: node scripts/import-codex-gptjson.mjs [sourceDir] [--dry-run] [--no-backup] [--keep-temp]");
+}
+
+function toIsoTime(value) {
+  if (value === undefined || value === null || value === "") return null;
+  if (typeof value === "number") {
+    const ms = value < 1e12 ? value * 1000 : value;
+    const date = new Date(ms);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+  }
+  const date = new Date(String(value));
+  return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+
+function decodeJwtPayload(token) {
+  if (!token || typeof token !== "string") return null;
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const json = Buffer.from(parts[1], "base64url").toString("utf8");
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+
+function jwtExpiryIso(...tokens) {
+  for (const token of tokens) {
+    const payload = decodeJwtPayload(token);
+    if (payload?.exp) {
+      const iso = toIsoTime(payload.exp);
+      if (iso) return iso;
+    }
+  }
+  return null;
+}
+
+function normalizeEmail(email) {
+  return typeof email === "string" ? email.trim().toLowerCase() : "";
+}
+
+function compareRecordFreshness(a, b) {
+  const aSaved = Date.parse(a.savedAt || "") || 0;
+  const bSaved = Date.parse(b.savedAt || "") || 0;
+  if (aSaved !== bSaved) return aSaved - bSaved;
+  const aExp = Date.parse(a.expiresAt || "") || 0;
+  const bExp = Date.parse(b.expiresAt || "") || 0;
+  return aExp - bExp;
+}
+
+function runPowerShell(args, env = {}) {
+  const result = spawnSync("powershell.exe", args, {
+    encoding: "utf8",
+    windowsHide: true,
+    env: { ...process.env, ...env },
+  });
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || "PowerShell command failed").trim());
+  }
+}
+
+function extractZips(sourceDir, tempRoot) {
+  const zipFiles = fs.readdirSync(sourceDir)
+    .filter((name) => name.toLowerCase().endsWith(".zip"))
+    .map((name) => path.join(sourceDir, name));
+
+  for (let i = 0; i < zipFiles.length; i++) {
+    const zipPath = zipFiles[i];
+    const dest = path.join(tempRoot, String(i + 1).padStart(4, "0"));
+    fs.mkdirSync(dest, { recursive: true });
+    runPowerShell([
+      "-NoProfile",
+      "-Command",
+      "$ErrorActionPreference='Stop'; Expand-Archive -LiteralPath $env:ZIP_PATH -DestinationPath $env:DEST_PATH -Force",
+    ], { ZIP_PATH: zipPath, DEST_PATH: dest });
+  }
+
+  return zipFiles.length;
+}
+
+function walkFiles(dir, out = []) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === "__MACOSX") continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walkFiles(full, out);
+    else if (entry.isFile() && entry.name.toLowerCase().endsWith(".json") && !entry.name.startsWith("._")) out.push(full);
+  }
+  return out;
+}
+
+function parseTokenFile(filePath, sourceRoot) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const obj = JSON.parse(raw);
+
+  const email = normalizeEmail(obj.email);
+  const refreshToken = obj.refresh_token || obj.refreshToken;
+  const accessToken = obj.access_token || obj.accessToken;
+  const idToken = obj.id_token || obj.idToken;
+
+  if (obj.type && String(obj.type).toLowerCase() !== "codex") {
+    return { skipped: true, reason: "non_codex" };
+  }
+  if (!email || !refreshToken) {
+    return { skipped: true, reason: "missing_email_or_refresh_token" };
+  }
+
+  const idPayload = decodeJwtPayload(idToken) || {};
+  const authClaims = idPayload["https://api.openai.com/auth"] || {};
+  const savedAt = toIsoTime(obj.saved_at || obj.savedAt) || new Date().toISOString();
+  const expiresAt = toIsoTime(obj.expired || obj.expires_at || obj.expiresAt)
+    || jwtExpiryIso(accessToken, idToken);
+
+  return {
+    email,
+    name: email,
+    accessToken,
+    refreshToken,
+    idToken,
+    expiresAt,
+    savedAt,
+    tokenSource: obj.token_source || obj.tokenSource || null,
+    chatgptAccountId: authClaims.chatgpt_account_id || null,
+    chatgptPlanType: authClaims.chatgpt_plan_type || (String(obj.token_source || "").toLowerCase().includes("team") ? "team" : null),
+    sourceEntry: path.relative(sourceRoot, filePath),
+  };
+}
+
+function stringifyJson(value) {
+  return JSON.stringify(value ?? {});
+}
+
+function buildConnectionRow({ record, existing, priority, now }) {
+  const createdAt = existing?.createdAt || now;
+  const updatedAt = now;
+  const expiresIn = record.expiresAt
+    ? Math.max(1, Math.floor((Date.parse(record.expiresAt) - Date.now()) / 1000))
+    : undefined;
+
+  const data = {
+    ...(existing || {}),
+    accessToken: record.accessToken,
+    refreshToken: record.refreshToken,
+    idToken: record.idToken,
+    lastRefreshAt: record.savedAt,
+    testStatus: existing?.testStatus || "active",
+    providerSpecificData: {
+      ...(existing?.providerSpecificData || {}),
+      ...(record.chatgptAccountId ? { chatgptAccountId: record.chatgptAccountId } : {}),
+      ...(record.chatgptPlanType ? { chatgptPlanType: record.chatgptPlanType } : {}),
+      ...(record.tokenSource ? { tokenSource: record.tokenSource } : {}),
+      importedFrom: "GPTJson",
+      importedAt: now,
+      sourceEntry: record.sourceEntry,
+    },
+  };
+  if (record.expiresAt) {
+    data.expiresAt = record.expiresAt;
+    data.expiresIn = expiresIn;
+  }
+
+  const {
+    id: _id,
+    provider: _provider,
+    authType: _authType,
+    name: _name,
+    email: _email,
+    priority: _priority,
+    isActive: _isActive,
+    createdAt: _createdAt,
+    updatedAt: _updatedAt,
+    ...rest
+  } = data;
+
+  return {
+    id: existing?.id || randomUUID(),
+    provider: "codex",
+    authType: "oauth",
+    name: existing?.name || record.name,
+    email: record.email,
+    priority: existing?.priority || priority,
+    isActive: existing?.isActive === false ? 0 : 1,
+    data: stringifyJson(rest),
+    createdAt,
+    updatedAt,
+  };
+}
+
+async function main() {
+  if (!fs.existsSync(SOURCE_DIR)) {
+    usage();
+    throw new Error(`Source directory not found: ${SOURCE_DIR}`);
+  }
+
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "9router-gptjson-"));
+  const stats = {
+    zipFiles: 0,
+    jsonFiles: 0,
+    parsed: 0,
+    invalid: 0,
+    skipped: 0,
+    duplicateEmails: 0,
+    uniqueEmails: 0,
+    inserted: 0,
+    updated: 0,
+  };
+
+  try {
+    stats.zipFiles = extractZips(SOURCE_DIR, tempRoot);
+    const jsonFiles = walkFiles(tempRoot);
+    stats.jsonFiles = jsonFiles.length;
+
+    const byEmail = new Map();
+    const skipReasons = new Map();
+
+    for (const file of jsonFiles) {
+      try {
+        const record = parseTokenFile(file, tempRoot);
+        if (record.skipped) {
+          stats.skipped++;
+          skipReasons.set(record.reason, (skipReasons.get(record.reason) || 0) + 1);
+          continue;
+        }
+        stats.parsed++;
+        const previous = byEmail.get(record.email);
+        if (previous) {
+          stats.duplicateEmails++;
+          if (compareRecordFreshness(previous, record) <= 0) byEmail.set(record.email, record);
+        } else {
+          byEmail.set(record.email, record);
+        }
+      } catch {
+        stats.invalid++;
+      }
+    }
+
+    stats.uniqueEmails = byEmail.size;
+
+    const db = await getAdapter();
+    db.checkpoint?.();
+
+    let backupPath = null;
+    if (!DRY_RUN && !NO_BACKUP) {
+      const backupDir = makeBackupDir("before-codex-gptjson-import");
+      backupPath = backupFile(DATA_FILE, backupDir, "data.sqlite");
+      pruneOldBackups();
+    }
+
+    const existingCodex = await getProviderConnections({ provider: "codex" });
+    const existingByEmail = new Map(existingCodex.map((conn) => [normalizeEmail(conn.email), conn]).filter(([email]) => email));
+    let nextPriority = existingCodex.reduce((max, conn) => Math.max(max, conn.priority || 0), 0) + 1;
+    const rows = [];
+    const now = new Date().toISOString();
+
+    for (const record of byEmail.values()) {
+      const existing = existingByEmail.get(record.email);
+      if (existing) stats.updated++;
+      else stats.inserted++;
+      rows.push(buildConnectionRow({
+        record,
+        existing,
+        priority: existing?.priority || nextPriority++,
+        now,
+      }));
+    }
+
+    if (!DRY_RUN) {
+      db.transaction(() => {
+        for (const row of rows) {
+          db.run(
+            `INSERT INTO providerConnections(id, provider, authType, name, email, priority, isActive, data, createdAt, updatedAt)
+             VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET
+               provider=excluded.provider,
+               authType=excluded.authType,
+               name=excluded.name,
+               email=excluded.email,
+               priority=excluded.priority,
+               isActive=excluded.isActive,
+               data=excluded.data,
+               updatedAt=excluded.updatedAt`,
+            [
+              row.id,
+              row.provider,
+              row.authType,
+              row.name,
+              row.email,
+              row.priority,
+              row.isActive,
+              row.data,
+              row.createdAt,
+              row.updatedAt,
+            ]
+          );
+        }
+      });
+      db.checkpoint?.();
+    }
+
+    const after = DRY_RUN
+      ? existingCodex.length
+      : (await getProviderConnections({ provider: "codex" })).length;
+
+    console.log(JSON.stringify({
+      sourceDir: SOURCE_DIR,
+      dryRun: DRY_RUN,
+      backupPath,
+      ...stats,
+      codexBefore: existingCodex.length,
+      codexAfter: after,
+      skipReasons: Object.fromEntries(skipReasons.entries()),
+    }, null, 2));
+  } finally {
+    if (!KEEP_TEMP) {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    } else {
+      console.log(`Temp kept at: ${tempRoot}`);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(`[import-codex-gptjson] ${error.message}`);
+  process.exit(1);
+});

package/scripts/start-standalone.mjs

@@ -0,0 +1,25 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const standaloneRoot = path.join(projectRoot, ".next", "standalone");
+
+function ensureLinkedDir(source, destination) {
+  if (!fs.existsSync(source) || fs.existsSync(destination)) return;
+
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+
+  try {
+    fs.symlinkSync(source, destination, process.platform === "win32" ? "junction" : "dir");
+  } catch {
+    fs.cpSync(source, destination, { recursive: true });
+  }
+}
+
+ensureLinkedDir(path.join(projectRoot, ".next", "static"), path.join(standaloneRoot, ".next", "static"));
+ensureLinkedDir(path.join(projectRoot, "public"), path.join(standaloneRoot, "public"));
+
+require(path.join(standaloneRoot, "server.js"));

package/scripts/translate-readme.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// ============ CONFIGURATION ============
+const API_ENDPOINT = process.env.GLM_API_ENDPOINT || 'https://api.z.ai/api/anthropic/v1/messages';
+const API_MODEL = process.env.GLM_API_MODEL || 'glm-5';
+const API_KEY = process.env.GLM_API_KEY;
+const MAX_TOKENS = parseInt(process.env.GLM_MAX_TOKENS || '32000');
+const TEMPERATURE = parseFloat(process.env.GLM_TEMPERATURE || '0.3');
+const BATCH_SIZE = parseInt(process.env.TRANSLATE_BATCH_SIZE || '2'); // Number of languages to translate in parallel
+
+const SUPPORTED_LANGUAGES = {
+  vi: 'Vietnamese',
+  'zh-CN': 'Simplified Chinese'
+};
+
+// ============ VALIDATION ============
+if (!API_KEY) {
+  console.error('Error: GLM_API_KEY environment variable not set');
+  process.exit(1);
+}
+
+const targetLangs = process.argv.slice(2);
+if (targetLangs.length === 0) {
+  console.error('Usage: node translate-readme.js <lang1> [lang2] ...');
+  console.error(`Supported languages: ${Object.keys(SUPPORTED_LANGUAGES).join(', ')}`);
+  process.exit(1);
+}
+
+for (const lang of targetLangs) {
+  if (!SUPPORTED_LANGUAGES[lang]) {
+    console.error(`Unsupported language: ${lang}`);
+    process.exit(1);
+  }
+}
+
+// ============ TRANSLATION FUNCTION ============
+async function translateToLanguage(readmeContent, targetLang) {
+  const langName = SUPPORTED_LANGUAGES[targetLang];
+  console.log(`\n[${targetLang}] Translating to ${langName}...`);
+  console.log(`[${targetLang}] README size: ${readmeContent.length} characters`);
+  
+  const prompt = `Translate this entire Markdown document to ${langName}.
+
+CRITICAL RULES:
+- Keep ALL markdown syntax EXACTLY as is (##, \`\`\`, -, *, |, tables, etc.)
+- Do NOT modify code blocks, ASCII diagrams, or code fences
+- Only translate human-readable text content
+- Keep all URLs, links, and technical terms unchanged
+
+${readmeContent}`;
+  
+  const response = await fetch(API_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': API_KEY,
+      'anthropic-version': '2023-06-01'
+    },
+    body: JSON.stringify({
+      model: API_MODEL,
+      messages: [{ role: 'user', content: prompt }],
+      temperature: TEMPERATURE,
+      max_tokens: MAX_TOKENS,
+      stream: true
+    })
+  });
+  
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`[${targetLang}] API Error: ${response.status} ${error}`);
+  }
+  
+  console.log(`[${targetLang}] Receiving translation stream...`);
+  
+  let translatedContent = '';
+  let chunkCount = 0;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split('\n');
+    
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        const data = line.slice(6);
+        if (data === '[DONE]') continue;
+        
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+            translatedContent += parsed.delta.text;
+            chunkCount++;
+            if (chunkCount % 100 === 0) {
+              process.stdout.write(`\r[${targetLang}] Received ${translatedContent.length} chars...`);
+            }
+          }
+        } catch (e) {
+          // Skip invalid JSON
+        }
+      }
+    }
+  }
+  
+  process.stdout.write('\n');
+  
+  console.log(`\n[${targetLang}] Stream complete, received ${translatedContent.length} characters`);
+  
+  if (!translatedContent) {
+    throw new Error(`[${targetLang}] No translation received`);
+  }
+  
+  console.log(`[${targetLang}] Fixing image paths...`);
+  
+  // Fix image paths
+  translatedContent = translatedContent
+    .replace(/!\[([^\]]*)\]\(\.\/images\//g, '![$1](../images/')
+    .replace(/!\[([^\]]*)\]\(\.\/public\//g, '![$1](../public/')
+    .replace(/<img src="\.\/images\//g, '<img src="../images/')
+    .replace(/<img src="\.\/public\//g, '<img src="../public/');
+  
+  const i18nDir = path.join(__dirname, '../i18n');
+  if (!fs.existsSync(i18nDir)) {
+    fs.mkdirSync(i18nDir, { recursive: true });
+  }
+  
+  const outputPath = path.join(i18nDir, `README.${targetLang}.md`);
+  fs.writeFileSync(outputPath, translatedContent, 'utf8');
+  
+  console.log(`[${targetLang}] ✅ Complete: ${outputPath}`);
+  return { lang: targetLang, success: true, path: outputPath };
+}
+
+// ============ MAIN ============
+async function main() {
+  console.log('='.repeat(60));
+  console.log('README Translation Tool (Streaming Mode)');
+  console.log('='.repeat(60));
+  console.log(`API Endpoint: ${API_ENDPOINT}`);
+  console.log(`Model: ${API_MODEL}`);
+  console.log(`Max Tokens: ${MAX_TOKENS}`);
+  console.log(`Batch Size: ${BATCH_SIZE}`);
+  console.log(`Languages: ${targetLangs.join(', ')}`);
+  console.log('='.repeat(60));
+  
+  const readmePath = path.join(__dirname, '../README.md');
+  const readmeContent = fs.readFileSync(readmePath, 'utf8');
+  
+  // Translate languages in batches (parallel within batch)
+  const results = [];
+  for (let i = 0; i < targetLangs.length; i += BATCH_SIZE) {
+    const batch = targetLangs.slice(i, i + BATCH_SIZE);
+    console.log(`\nBatch ${Math.floor(i / BATCH_SIZE) + 1}/${Math.ceil(targetLangs.length / BATCH_SIZE)}: ${batch.join(', ')}`);
+    console.log('Starting translations in parallel...\n');
+    
+    // Start all translations in parallel (don't await yet)
+    const batchPromises = batch.map(lang => translateToLanguage(readmeContent, lang));
+    
+    // Wait for all to complete
+    const batchResults = await Promise.allSettled(batchPromises);
+    
+    results.push(...batchResults);
+    
+    // Wait between batches to avoid rate limit
+    if (i + BATCH_SIZE < targetLangs.length) {
+      console.log('\nWaiting 3s before next batch...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+  }
+  
+  console.log('\n' + '='.repeat(60));
+  console.log('SUMMARY');
+  console.log('='.repeat(60));
+  
+  results.forEach((result) => {
+    if (result.status === 'fulfilled') {
+      console.log(`✅ ${result.value.lang}: ${result.value.path}`);
+    } else {
+      console.log(`❌ ${result.lang}: ${result.reason.message}`);
+    }
+  });
+  
+  const failed = results.filter(r => r.status === 'rejected').length;
+  if (failed > 0) {
+    console.log(`\n⚠️  ${failed} translation(s) failed`);
+    process.exit(1);
+  }
+  
+  console.log('\n✅ All translations completed successfully!');
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});