@yina-npm/openrouterx 0.4.33 → 0.4.35

package/app/src/mitm/handlers/base.js

@@ -1,6 +1,6 @@
 const { log, err } = require("../logger");
 
-const DEFAULT_LOCAL_ROUTER = "http://127.0.0.1:20502";
+const DEFAULT_LOCAL_ROUTER = "http://localhost:20502";
 const ROUTER_BASE = String(process.env.MITM_ROUTER_BASE || DEFAULT_LOCAL_ROUTER)
   .trim()
   .replace(/\/+$/, "") || DEFAULT_LOCAL_ROUTER;
@@ -12,34 +12,33 @@ const STRIP_HEADERS = new Set([
   "content-type", "authorization"
 ]);
 
+function normalizeRouterPath(path) {
+  const rawPath = String(path || "").trim() || "/v1/chat/completions";
+  if (rawPath === "/v1") return "/api/v1";
+  if (rawPath.startsWith("/v1/")) return `/api${rawPath}`;
+  return rawPath;
+}
+
 /**
  * Send body to OpenrouterX at the given path and return the fetch Response object.
  * Optionally forwards client headers (stripped of hop-by-hop / overridden keys).
  */
 async function fetchRouter(openaiBody, path = "/v1/chat/completions", clientHeaders = {}) {
+  const routerPath = normalizeRouterPath(path);
   const forwarded = {};
   for (const [k, v] of Object.entries(clientHeaders)) {
     if (!STRIP_HEADERS.has(k.toLowerCase())) forwarded[k] = v;
   }
 
-  let response;
-  try {
-    response = await fetch(`${ROUTER_BASE}${path}`, {
-      method: "POST",
-      headers: {
-        ...forwarded,
-        "Content-Type": "application/json",
-        ...(API_KEY && { "Authorization": `Bearer ${API_KEY}` })
-      },
-      body: JSON.stringify(openaiBody)
-    });
-  } catch (error) {
-    const cause = error.cause;
-    const causeDetail = cause
-      ? ` (cause: ${cause.code || cause.name || "unknown"}: ${cause.message || cause})`
-      : "";
-    throw new Error(`Router fetch failed for ${ROUTER_BASE}${path}: ${error.message}${causeDetail}`);
-  }
+  const response = await fetch(`${ROUTER_BASE}${routerPath}`, {
+    method: "POST",
+    headers: {
+      ...forwarded,
+      "Content-Type": "application/json",
+      ...(API_KEY && { "Authorization": `Bearer ${API_KEY}` })
+    },
+    body: JSON.stringify(openaiBody)
+  });
 
   // Forward response as-is (status + body). pipeSSE will propagate status.
   return response;
@@ -74,4 +73,4 @@ async function pipeSSE(routerRes, res, dumper) {
   }
 }
 
-module.exports = { fetchRouter, pipeSSE };
+module.exports = { fetchRouter, normalizeRouterPath, pipeSSE };

package/app/src/mitm/manager.js

@@ -16,31 +16,90 @@ const { isCertExpired } = require("./cert/rootCA");
 const { DATA_DIR, MITM_DIR } = require("./paths");
 const { log, err } = require("./logger");
 
-const DEFAULT_MITM_ROUTER_BASE = "http://127.0.0.1:20502";
-const LEGACY_DEFAULT_MITM_ROUTER_BASES = new Set([
-  "http://localhost:20128",
-  "http://127.0.0.1:20128",
-]);
+const DEFAULT_MITM_ROUTER_BASE = "http://localhost:20502";
 
 function shellQuoteSingle(str) {
   if (str == null || str === "") return "''";
   return `'${String(str).replace(/'/g, "'\\''")}'`;
 }
 
+function normalizeHttpBaseUrl(input) {
+  const raw = input == null ? "" : String(input).trim();
+  if (!raw) return "";
+  try {
+    const u = new URL(raw.replace(/\/+$/, ""));
+    if (u.protocol !== "http:" && u.protocol !== "https:") return "";
+    return u.toString().replace(/\/+$/, "");
+  } catch {
+    return "";
+  }
+}
+
+function isLoopbackBaseUrl(baseUrl) {
+  try {
+    const host = new URL(baseUrl).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function readCurrentServerBaseUrl() {
+  try {
+    const file = path.join(DATA_DIR, "server.json");
+    if (!fs.existsSync(file)) return "";
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return normalizeHttpBaseUrl(parsed && parsed.baseUrl);
+  } catch {
+    return "";
+  }
+}
+
+function canConnectBaseUrl(baseUrl, timeoutMs = 350) {
+  return new Promise((resolve) => {
+    let u;
+    try {
+      u = new URL(baseUrl);
+    } catch {
+      resolve(false);
+      return;
+    }
+
+    const port = Number(u.port || (u.protocol === "https:" ? 443 : 80));
+    const socket = net.connect({ host: u.hostname, port });
+    const done = (ok) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.setTimeout(timeoutMs, () => done(false));
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+  });
+}
+
 async function resolveMitmRouterBaseUrl() {
-  if (!_getSettings) return DEFAULT_MITM_ROUTER_BASE;
+  const currentServerBase = readCurrentServerBaseUrl();
+  if (!_getSettings) return currentServerBase || DEFAULT_MITM_ROUTER_BASE;
   try {
     const s = await _getSettings();
-    const raw = s && s.mitmRouterBaseUrl != null ? String(s.mitmRouterBaseUrl).trim() : "";
-    if (!raw) return DEFAULT_MITM_ROUTER_BASE;
-    if (LEGACY_DEFAULT_MITM_ROUTER_BASES.has(raw.replace(/\/+$/, ""))) {
-      return DEFAULT_MITM_ROUTER_BASE;
+    const configuredBase = normalizeHttpBaseUrl(s && s.mitmRouterBaseUrl);
+    if (!configuredBase) return currentServerBase || DEFAULT_MITM_ROUTER_BASE;
+
+    if (isLoopbackBaseUrl(configuredBase) && currentServerBase && configuredBase !== currentServerBase) {
+      const configuredAlive = await canConnectBaseUrl(configuredBase);
+      if (!configuredAlive && await canConnectBaseUrl(currentServerBase)) {
+        if (_updateSettings) {
+          _updateSettings({ mitmRouterBaseUrl: currentServerBase }).catch(() => { });
+        }
+        log(`🚀 MITM router base auto-corrected: ${configuredBase} → ${currentServerBase}`);
+        return currentServerBase;
+      }
     }
-    const u = new URL(raw);
-    if (u.protocol !== "http:" && u.protocol !== "https:") return DEFAULT_MITM_ROUTER_BASE;
-    return raw.replace(/\/+$/, "");
+
+    return configuredBase;
   } catch {
-    return DEFAULT_MITM_ROUTER_BASE;
+    return currentServerBase || DEFAULT_MITM_ROUTER_BASE;
   }
 }
 
@@ -405,7 +464,7 @@ async function scheduleMitmRestart(apiKey) {
       mitmIsRestarting = false;
       return;
     }
-    await startServer(apiKey, password, false, { restart: true });
+    await startServer(apiKey, password);
     log("🔄 Restarted successfully");
     mitmRestartCount = 0;
     mitmIsRestarting = false;
@@ -439,23 +498,7 @@ async function killPort443Owner(owner, sudoPassword) {
   await new Promise(r => setTimeout(r, 800));
 }
 
-async function adoptHealthyExistingServer(sudoPassword) {
-  const health = await pollMitmHealth(1000, MITM_PORT);
-  if (!health) return null;
-
-  const pid = health.pid || serverPid || (() => {
-    try { return parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10); } catch { return null; }
-  })();
-  if (pid) {
-    serverPid = pid;
-    try { fs.writeFileSync(PID_FILE, String(pid)); } catch { /* ignore */ }
-  }
-  await saveMitmSettings(true, sudoPassword);
-  return { running: true, pid: serverPid || pid };
-}
-
-async function startServer(apiKey, sudoPassword, forceKillPort443 = false, options = {}) {
-  const isRestart = options.restart === true;
+async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
   if (!serverProcess || serverProcess.killed) {
     try {
       if (fs.existsSync(PID_FILE)) {
@@ -474,13 +517,7 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false, optio
   }
 
   if (serverProcess && !serverProcess.killed) {
-    const healthy = await adoptHealthyExistingServer(sudoPassword);
-    if (healthy) return healthy;
-    if (isRestart) {
-      await killLeftoverMitm(sudoPassword);
-    } else {
-      throw new Error("MITM server is already running");
-    }
+    throw new Error("MITM server is already running");
   }
 
   await killLeftoverMitm(sudoPassword);
@@ -673,18 +710,12 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false, optio
   const health = await pollMitmHealth(8000, MITM_PORT);
   if (!health) {
     if (serverProcess && !serverProcess.killed) { try { serverProcess.kill(); } catch { /* ignore */ } serverProcess = null; }
-    serverPid = null;
     const processUsing443 = getProcessUsingPort443();
     const portInfo = processUsing443 ? ` Port 443 already in use by ${processUsing443}.` : "";
     const reason = startError || `Check sudo password or port 443 access.${portInfo}`;
     throw new Error(`MITM server failed to start. ${reason}`);
   }
 
-  if (health.pid && health.pid !== serverPid) {
-    serverPid = health.pid;
-    try { fs.writeFileSync(PID_FILE, String(serverPid)); } catch { /* ignore */ }
-  }
-
   if (_updateSettings) await _updateSettings({ mitmCertInstalled: true }).catch(() => { });
 
   log(`✅ Server healthy (PID: ${serverPid || health.pid})`);
@@ -827,4 +858,7 @@ module.exports = {
   restoreToolDNS,
   hasDnsPrivilege,
   removeAllDNSEntriesSync,
+  resolveMitmRouterBaseUrl,
+  normalizeHttpBaseUrl,
+  readCurrentServerBaseUrl,
 };

package/app/src/mitm/server.js

@@ -344,47 +344,47 @@ async function passthrough(req, res, bodyBuffer, onResponse, transformResponse)
       servername: targetHost,
       rejectUnauthorized: false
     }, (forwardRes) => {
-    // When transformResponse is provided, buffer the full response so we can
-    // modify it before sending to the client.
-    const shouldBuffer = transformResponse != null;
-    if (!shouldBuffer) res.writeHead(forwardRes.statusCode, forwardRes.headers);
+      // When transformResponse is provided, buffer the full response so we can
+      // modify it before sending to the client.
+      const shouldBuffer = transformResponse != null;
+      if (!shouldBuffer) res.writeHead(forwardRes.statusCode, forwardRes.headers);
 
-    if (!onResponse && !dumper && !shouldBuffer) {
-      forwardRes.pipe(res);
-      return;
-    }
+      if (!onResponse && !dumper && !shouldBuffer) {
+        forwardRes.pipe(res);
+        return;
+      }
 
-    const chunks = [];
-    forwardRes.on("data", chunk => {
-      if (dumper) dumper.writeChunk(chunk);
-      if (onResponse || shouldBuffer) chunks.push(chunk);
-      if (!shouldBuffer) res.write(chunk);
-    });
-    forwardRes.on("end", () => {
-      const rawBuffer = Buffer.concat(chunks);
-
-      if (shouldBuffer) {
-        try {
-          const modified = transformResponse(rawBuffer, forwardRes.headers);
-          // Update Content-Length if present to match modified body
-          const headers = { ...forwardRes.headers };
-          if (headers["content-length"] != null) {
-            headers["content-length"] = String(Buffer.byteLength(modified));
+      const chunks = [];
+      forwardRes.on("data", chunk => {
+        if (dumper) dumper.writeChunk(chunk);
+        if (onResponse || shouldBuffer) chunks.push(chunk);
+        if (!shouldBuffer) res.write(chunk);
+      });
+      forwardRes.on("end", () => {
+        const rawBuffer = Buffer.concat(chunks);
+
+        if (shouldBuffer) {
+          try {
+            const modified = transformResponse(rawBuffer, forwardRes.headers);
+            // Update Content-Length if present to match modified body
+            const headers = { ...forwardRes.headers };
+            if (headers["content-length"] != null) {
+              headers["content-length"] = String(Buffer.byteLength(modified));
+            }
+            res.writeHead(forwardRes.statusCode, headers);
+            res.end(modified);
+          } catch (e) {
+            err(`transformResponse error: ${e.message}`);
+            if (!res.headersSent) res.writeHead(502);
+            res.end("Bad Gateway");
           }
-          res.writeHead(forwardRes.statusCode, headers);
-          res.end(modified);
-        } catch (e) {
-          err(`transformResponse error: ${e.message}`);
-          if (!res.headersSent) res.writeHead(502);
-          res.end("Bad Gateway");
+        } else {
+          res.end();
         }
-      } else {
-        res.end();
-      }
 
-      if (dumper) dumper.end();
-      if (onResponse) try { onResponse(rawBuffer, forwardRes.headers); } catch { /* ignore */ }
-    });
+        if (dumper) dumper.end();
+        if (onResponse) try { onResponse(rawBuffer, forwardRes.headers); } catch { /* ignore */ }
+      });
     });
 
     forwardReq.on("error", (e) => {

package/cli.js

@@ -2,7 +2,6 @@
 
 const { spawn } = require("node:child_process");
 const fs = require("node:fs");
-const https = require("node:https");
 const os = require("node:os");
 const path = require("node:path");
 const net = require("node:net");
@@ -18,17 +17,8 @@ const PID_FILE = path.join(DATA_DIR, "server.pid");
 const META_FILE = path.join(DATA_DIR, "server.json");
 const LOG_FILE = path.join(DATA_DIR, "server.log");
 const MITM_PID_FILE = path.join(DATA_DIR, "mitm", ".mitm.pid");
-const STARTUP_NOTICE_DIR = path.join(DATA_DIR, "notices");
-const PORT_MIGRATION_NOTICE_FILE = path.join(STARTUP_NOTICE_DIR, "port-migration.json");
 const DEFAULT_PORT = "20502";
 const DEFAULT_HOST = "0.0.0.0";
-const NPM_PACKAGE_NAME = "@yina-npm/openrouterx";
-const INSTALL_CMD_LATEST = `npm i -g ${NPM_PACKAGE_NAME}@latest --prefer-online --registry=https://registry.npmjs.org/`;
-const DEFAULT_MITM_ROUTER_BASE_URL = `http://localhost:${DEFAULT_PORT}`;
-const LEGACY_DEFAULT_MITM_ROUTER_BASE_URLS = new Set([
-  "http://localhost:20128",
-  "http://127.0.0.1:20128",
-]);
 
 function parseArgs(argv = process.argv.slice(2)) {
   const options = {
@@ -129,156 +119,6 @@ function ensureDataDir() {
   fs.mkdirSync(DATA_DIR, { recursive: true });
 }
 
-function stripTrailingSlash(value) {
-  return String(value || "").trim().replace(/\/+$/, "");
-}
-
-function normalizeMitmRouterBaseUrl(value) {
-  const raw = stripTrailingSlash(value);
-  if (!raw || LEGACY_DEFAULT_MITM_ROUTER_BASE_URLS.has(raw)) {
-    return DEFAULT_MITM_ROUTER_BASE_URL;
-  }
-  return raw;
-}
-
-function migrateJsonSettingsFile() {
-  const jsonDbFile = path.join(DATA_DIR, "db.json");
-  if (!fs.existsSync(jsonDbFile)) return false;
-
-  try {
-    const data = JSON.parse(fs.readFileSync(jsonDbFile, "utf8"));
-    if (!data || typeof data !== "object") return false;
-    if (!data.settings || typeof data.settings !== "object" || Array.isArray(data.settings)) {
-      data.settings = {};
-    }
-    const current = data.settings.mitmRouterBaseUrl;
-    const next = normalizeMitmRouterBaseUrl(current);
-    if (current === next) return false;
-    data.settings.mitmRouterBaseUrl = next;
-    fs.writeFileSync(jsonDbFile, `${JSON.stringify(data, null, 2)}\n`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function migrateSqliteSettingsFile() {
-  const sqliteFile = path.join(DATA_DIR, "db", "data.sqlite");
-  if (!fs.existsSync(sqliteFile)) return false;
-
-  let Database;
-  try {
-    Database = require("better-sqlite3");
-  } catch {
-    return false;
-  }
-
-  let db;
-  try {
-    db = new Database(sqliteFile);
-    const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'settings'").get();
-    if (!table) return false;
-    const row = db.prepare("SELECT id, data FROM settings WHERE id = 1").get();
-    if (!row) return false;
-    const settings = JSON.parse(row.data || "{}");
-    const current = settings.mitmRouterBaseUrl;
-    const next = normalizeMitmRouterBaseUrl(current);
-    if (current === next) return false;
-    settings.mitmRouterBaseUrl = next;
-    db.prepare("UPDATE settings SET data = ? WHERE id = ?").run(JSON.stringify(settings), row.id);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    try {
-      db?.close();
-    } catch {}
-  }
-}
-
-function writePortMigrationNotice(changedStores) {
-  if (!changedStores.length) return;
-  try {
-    fs.mkdirSync(STARTUP_NOTICE_DIR, { recursive: true });
-    fs.writeFileSync(PORT_MIGRATION_NOTICE_FILE, `${JSON.stringify({
-      id: "port-migration-20128-20502",
-      type: "port-migration",
-      fromPort: 20128,
-      toPort: Number(DEFAULT_PORT),
-      fromBaseUrl: "http://localhost:20128",
-      toBaseUrl: DEFAULT_MITM_ROUTER_BASE_URL,
-      stores: changedStores,
-      createdAt: new Date().toISOString(),
-    }, null, 2)}\n`);
-  } catch {}
-}
-
-function refreshRuntimePortSettings({ quiet = true } = {}) {
-  ensureDataDir();
-  const changed = [];
-  if (migrateJsonSettingsFile()) changed.push("db.json");
-  if (migrateSqliteSettingsFile()) changed.push("data.sqlite");
-  writePortMigrationNotice(changed);
-  if (!quiet && changed.length > 0) {
-    console.log(`Refreshed MITM router port settings: ${changed.join(", ")} -> ${DEFAULT_MITM_ROUTER_BASE_URL}`);
-  }
-  return changed;
-}
-
-function compareVersions(a, b) {
-  const pa = String(a || "").split(".").map(Number);
-  const pb = String(b || "").split(".").map(Number);
-  for (let i = 0; i < 3; i += 1) {
-    const av = Number.isFinite(pa[i]) ? pa[i] : 0;
-    const bv = Number.isFinite(pb[i]) ? pb[i] : 0;
-    if (av > bv) return 1;
-    if (av < bv) return -1;
-  }
-  return 0;
-}
-
-function checkForUpdate({ skipUpdate } = {}) {
-  return new Promise((resolve) => {
-    if (skipUpdate) {
-      resolve(null);
-      return;
-    }
-
-    let resolved = false;
-    const done = (version) => {
-      if (resolved) return;
-      resolved = true;
-      resolve(version);
-    };
-
-    const req = https.get(
-      `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE_NAME).replace("%40", "@")}/latest`,
-      { timeout: 3000 },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          try {
-            const latest = JSON.parse(data);
-            const latestVersion = latest?.version;
-            done(latestVersion && compareVersions(latestVersion, pkg.version) > 0 ? latestVersion : null);
-          } catch {
-            done(null);
-          }
-        });
-      }
-    );
-
-    req.on("error", () => done(null));
-    req.on("timeout", () => {
-      req.destroy();
-      done(null);
-    });
-  });
-}
-
 function readMeta() {
   try {
     return JSON.parse(fs.readFileSync(META_FILE, "utf8"));
@@ -548,7 +388,6 @@ function printChooser(serverUrl) {
 
 async function runCli() {
   const options = parseArgs();
-  refreshRuntimePortSettings({ quiet: true });
 
   if (options.help) {
     console.log(formatHelp());
@@ -600,7 +439,6 @@ async function runCli() {
   const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || `http://localhost:${port}`;
   const foreground = options.foreground || (process.env.ORX_CHOOSER_ACTION !== undefined && process.env.ORX_CHOOSER_ACTION !== "hide");
   const runningPid = readPid();
-  const latestVersion = await checkForUpdate({ skipUpdate: options.skipUpdate });
 
   if (isProcessRunning(runningPid) && options.command !== "restart") {
     const runningMeta = readMeta();
@@ -618,10 +456,6 @@ async function runCli() {
   }
 
   printChooser(baseUrl);
-  if (latestVersion) {
-    console.log(`Update available: v${pkg.version} -> v${latestVersion}`);
-    console.log(`Run: ${INSTALL_CMD_LATEST}`);
-  }
 
   const stdio = foreground ? "inherit" : createLogFileDescriptors();
   const child = spawn(process.execPath, [serverEntry], {
@@ -682,8 +516,4 @@ module.exports = {
   isProcessRunning,
   printStatus,
   stopServer,
-  refreshRuntimePortSettings,
-  normalizeMitmRouterBaseUrl,
-  compareVersions,
-  checkForUpdate,
 };

package/hooks/postinstall.js

@@ -2,102 +2,10 @@
 
 const { execSync } = require("node:child_process");
 const fs = require("node:fs");
-const os = require("node:os");
 const path = require("node:path");
 
 const appDir = path.join(__dirname, "..", "app");
 const betterSqlitePath = path.join(appDir, "node_modules", "better-sqlite3");
-const defaultMitmRouterBaseUrl = "http://localhost:20502";
-const portMigrationNoticeName = "port-migration.json";
-const legacyMitmRouterBaseUrls = new Set([
-  "http://localhost:20128",
-  "http://127.0.0.1:20128",
-]);
-
-function getDataDir() {
-  return process.platform === "win32"
-    ? path.join(process.env.APPDATA || os.homedir(), "openrouterx")
-    : path.join(os.homedir(), ".openrouterx");
-}
-
-function normalizeMitmRouterBaseUrl(value) {
-  const raw = String(value || "").trim().replace(/\/+$/, "");
-  if (!raw || legacyMitmRouterBaseUrls.has(raw)) return defaultMitmRouterBaseUrl;
-  return raw;
-}
-
-function refreshJsonSettings(dataDir) {
-  const filePath = path.join(dataDir, "db.json");
-  if (!fs.existsSync(filePath)) return false;
-  try {
-    const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    if (!data || typeof data !== "object") return false;
-    if (!data.settings || typeof data.settings !== "object" || Array.isArray(data.settings)) {
-      data.settings = {};
-    }
-    const next = normalizeMitmRouterBaseUrl(data.settings.mitmRouterBaseUrl);
-    if (data.settings.mitmRouterBaseUrl === next) return false;
-    data.settings.mitmRouterBaseUrl = next;
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function refreshSqliteSettings(dataDir) {
-  const filePath = path.join(dataDir, "db", "data.sqlite");
-  if (!fs.existsSync(filePath)) return false;
-  let Database;
-  try {
-    Database = require(path.join(appDir, "node_modules", "better-sqlite3"));
-  } catch {
-    try { Database = require("better-sqlite3"); } catch { return false; }
-  }
-
-  let db;
-  try {
-    db = new Database(filePath);
-    const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'settings'").get();
-    if (!table) return false;
-    const row = db.prepare("SELECT id, data FROM settings WHERE id = 1").get();
-    if (!row) return false;
-    const settings = JSON.parse(row.data || "{}");
-    const next = normalizeMitmRouterBaseUrl(settings.mitmRouterBaseUrl);
-    if (settings.mitmRouterBaseUrl === next) return false;
-    settings.mitmRouterBaseUrl = next;
-    db.prepare("UPDATE settings SET data = ? WHERE id = ?").run(JSON.stringify(settings), row.id);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    try { db?.close(); } catch {}
-  }
-}
-
-function refreshRuntimePortSettings() {
-  const dataDir = getDataDir();
-  const changed = [];
-  if (refreshJsonSettings(dataDir)) changed.push("db.json");
-  if (refreshSqliteSettings(dataDir)) changed.push("data.sqlite");
-  if (changed.length > 0) {
-    const noticeDir = path.join(dataDir, "notices");
-    fs.mkdirSync(noticeDir, { recursive: true });
-    fs.writeFileSync(path.join(noticeDir, portMigrationNoticeName), JSON.stringify({
-      id: "port-migration-20128-20502",
-      type: "port-migration",
-      fromPort: 20128,
-      toPort: 20502,
-      fromBaseUrl: "http://localhost:20128",
-      toBaseUrl: defaultMitmRouterBaseUrl,
-      stores: changed,
-      createdAt: new Date().toISOString(),
-    }, null, 2) + "\n");
-    console.log("refreshed MITM router port settings: " + changed.join(", ") + " -> " + defaultMitmRouterBaseUrl);
-  }
-}
-
-refreshRuntimePortSettings();
 
 if (!fs.existsSync(betterSqlitePath)) {
   console.log("better-sqlite3 not found, skipping rebuild");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yina-npm/openrouterx",
-  "version": "0.4.33",
+  "version": "0.4.35",
   "description": "openrouterX CLI - Start and manage 9Router server",
   "bin": {
     "openrouterX": "./cli.js"