magpie-gemini-web 0.5.2 → 0.5.3

package/README.en.md

@@ -82,12 +82,17 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | `stripCitations` | `true` | `gemini-web` only | Strip `[cite: 1]` and `[cite_start]` markers from replies and tool arguments (not supported on AI Studio) |
 | `baseURL` | `http://127.0.0.1:8083/v1` | `gemini-web` only | Default Gemini Web backend URL |
 | `contextLimit` / `outputLimit` | `1000000` / `8192` | `gemini-web` only | Context and output limits reported to clients |
-| `studio.proxy` | none | `ai-studio` only | Proxy for reaching Google (`http` / `https` / `socks5`), or set `AI_STUDIO_PROXY` env var |
+| `studio.proxy` | none | `ai-studio` only | Proxy for reaching Google (`http` / `https` / `socks5`), or set `AI_STUDIO_PROXY` env var; when set, it takes precedence over the proxy saved in the admin page. An empty value counts as unset |
 | `studio.baseURL` | `http://127.0.0.1:2048/v1` | `ai-studio` only | Default URL when connecting an existing AIStudio2API instance |
 | `studio.contextLimit` / `studio.outputLimit` | Model catalog defaults | `ai-studio` only | Limits reported to clients (can only lower the catalog defaults) |
 
 **Using a proxy to reach Google:**
-- **AI Studio:** Set `studio.proxy` in plugin options or the `AI_STUDIO_PROXY` environment variable.
+- **AI Studio:** Preferably set it in the local admin page. Open the address on the usage card's "管理页" (admin page) line (default `http://127.0.0.1:2048`) and sign in as `magpie` with `adminPassword` from `config.json` in the data directory. Save the proxy, then restart the service from the admin page. The plugin keeps the saved value when it restarts the backend.
+  - Alternatively, `studio.proxy` or `AI_STUDIO_PROXY` take precedence over the saved proxy. A change applies after the local service restarts (`npm run studio:stop`; the next request starts it again).
+  - With neither set, the backend falls back to the `HTTPS_PROXY` environment variable or the system proxy (Windows proxy settings).
+  - **The provider proxy set for `ai-studio` in Magpie is not passed to the local backend**; use one of the options above.
+  - The usage card's "代理出口" (proxy) line, the Google sign-in instructions and failure messages, and `npm run studio:status` show the proxy the backend actually uses, where it comes from, and whether a new setting still needs a restart.
+  - The listen address, API key and admin credentials are managed by the plugin; changing them in the admin page has no effect.
 - **Gemini Web:** The backend ignores `HTTP_PROXY`. Add your proxy to the proxy pool in the local admin panel at `http://127.0.0.1:8083/admin` (password is `adminToken` in `secrets.json` inside the data directory).
   - *Note:* When using a proxy pool, send one request with a newly added account so the backend binds it to a proxy, then re-add it via "Add an existing Google account from the local backend" to load its email and usage (SOCKS proxies are not supported for usage reads).
 

package/README.md

@@ -82,12 +82,17 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | `stripCitations` | `true` | 仅 `gemini-web` | 剥离回复与工具参数中的 `[cite: 1]`、`[cite_start]` 标记（AI Studio 不支持剥离） |
 | `baseURL` | `http://127.0.0.1:8083/v1` | 仅 `gemini-web` | Gemini Web 默认后端地址 |
 | `contextLimit` / `outputLimit` | `1000000` / `8192` | 仅 `gemini-web` | 向客户端声明的上下文 / 输出上限 |
-| `studio.proxy` | 无 | 仅 `ai-studio` | 访问 Google 的代理（`http` / `https` / `socks5`），也可用环境变量 `AI_STUDIO_PROXY` |
+| `studio.proxy` | 无 | 仅 `ai-studio` | 访问 Google 的代理（`http` / `https` / `socks5`），也可用环境变量 `AI_STUDIO_PROXY`；设置后优先于管理页里保存的代理，留空等于不设置 |
 | `studio.baseURL` | `http://127.0.0.1:2048/v1` | 仅 `ai-studio` | 连接已有 AIStudio2API 时的默认地址 |
 | `studio.contextLimit` / `studio.outputLimit` | 模型目录默认值 | 仅 `ai-studio` | 向客户端声明的上限（仅支持在目录值基础上调低） |
 
 **配置代理访问 Google：**
-- **AI Studio**：配置上表中的 `studio.proxy` 或环境变量 `AI_STUDIO_PROXY`。
+- **AI Studio**：推荐在本地管理页设置。打开额度卡片「管理页」一行里的地址（默认 `http://127.0.0.1:2048`），用户名 `magpie`，密码是数据目录 `config.json` 里的 `adminPassword`；保存代理后在管理页重启服务即可生效，之后插件重启后端也不会覆盖它。
+  - 也可以用上表的 `studio.proxy` 或环境变量 `AI_STUDIO_PROXY`，它们优先于管理页里保存的代理。改了要重启本地服务才生效（`npm run studio:stop`，下一次请求会自动启动）。
+  - 都没设置时，后端自动使用 `HTTPS_PROXY` 环境变量或系统代理（Windows 的「代理」设置）。
+  - **Magpie 里给 `ai-studio` 设置的供应商代理不会传给本地后端**，请用上面两种方式之一设置。
+  - 额度卡片的「代理出口」一行会显示后端当前实际使用的代理、它来自哪里，以及新设置是否还要重启才生效；登录 Google 时的说明、登录失败的提示和 `npm run studio:status` 也会显示。
+  - 监听地址、API Key、管理员账号等由插件管理，在管理页修改不会生效。
 - **Gemini Web**：后端不读取 `HTTP_PROXY`，请打开本地管理面板 `http://127.0.0.1:8083/admin` 在代理池中添加（登录口令为数据目录 `secrets.json` 中的 `adminToken`）。
   - *注意*：配置代理池后，新添加的账号需先发送一次请求以绑定代理，再通过「添加本地后端里已有的 Google 账号」重新添加，才能正常读取邮箱和用量（不支持通过 SOCKS 代理读取用量）。
 

package/lib/studio-native.mjs

@@ -109,12 +109,36 @@ export function validateProxy(proxy) {
   return trimmed;
 }
 
-// effectiveProxy is the proxy the service and its downloads go through: the one given, else
-// AI_STUDIO_PROXY, else the one saved in config.json.
-function effectiveProxy(explicit, saved) {
+// pluginProxy is the proxy this plugin sets for the service over the one saved in its .env: the
+// one given (studio.proxy, or a CLI --proxy), else AI_STUDIO_PROXY, with where it comes from. An
+// empty one names none, so the saved one applies; null when neither names one.
+export function pluginProxy(explicit) {
+  const given = validateProxy(explicit);
+  if (given) return { proxy: given, source: 'option' };
+  const env = validateProxy(process.env.AI_STUDIO_PROXY);
+  if (env) return { proxy: env, source: 'env' };
+  return null;
+}
+
+// downloadProxy is the proxy an install downloads through: the one given (an empty one turns it
+// off), else AI_STUDIO_PROXY, else the service's saved one, else the one an older config.json kept.
+function downloadProxy(dataDir, explicit, savedConfig) {
   if (explicit !== undefined) return validateProxy(explicit);
   if (process.env.AI_STUDIO_PROXY !== undefined) return validateProxy(process.env.AI_STUDIO_PROXY);
-  return validateProxy(saved);
+  let saved;
+  try {
+    saved = readStudioEnv(dataDir).PROXY;
+  } catch {}
+  return saved !== undefined ? firstProxy(saved) : validateProxy(savedConfig?.proxy);
+}
+
+// firstProxy is the first of a PROXY list (upstream takes several, comma-separated, as a pool).
+function firstProxy(value) {
+  return proxyList(value)[0] ?? '';
+}
+
+function proxyList(value) {
+  return [...new Set(String(value ?? '').split(',').map(p => p.trim()).filter(Boolean))];
 }
 
 export function validateConfig(config) {
@@ -148,9 +172,34 @@ export function validateConfig(config) {
   };
 }
 
-// serviceEnv is the fixed settings the service runs with. The service is started with them and
-// they are written to its .env, which it reads again when its generation service restarts.
-function serviceEnv(dataDir, config, options = {}) {
+// ENV_KEYS are the settings upstream reads from .env, in the order it writes them (config.configKeys).
+const ENV_KEYS = [
+  'AISTUDIO_AUTH_STATES', 'LISTEN_ADDR', 'PROXY_API_KEY', 'PROXY', 'INIT_TIMEOUT', 'REQUEST_TIMEOUT',
+  'WARM_WORKER_LIMIT', 'MAX_ACTIVE_WORKERS', 'WARM_STARTUP_CONCURRENCY', 'PER_ACCOUNT_CONCURRENCY',
+  'ROUTING_STRATEGY', 'UPSTREAM_CHANNELS', 'MODEL_MAPPING', 'TEMPORARY_CHAT', 'WAA_BACKEND', 'AUTO_START',
+  'REQUEST_BODY_LOG', 'LOG_FILE', 'LOG_MAX_TOTAL_MB', 'ADMIN_AUTH_ENABLED', 'ADMIN_USERNAME', 'ADMIN_PASSWORD',
+  'BUILD_NATIVE_NONSTREAM'
+];
+
+// SETTING_DEFAULTS are the settings the admin page owns, as a new setup has them. They are written
+// to .env when it lacks them and left as the admin page saves them after that.
+const SETTING_DEFAULTS = {
+  REQUEST_BODY_LOG: 'false',
+  LOG_FILE: 'false',
+  TEMPORARY_CHAT: 'true',
+  PER_ACCOUNT_CONCURRENCY: '1',
+  WARM_WORKER_LIMIT: '1',
+  MAX_ACTIVE_WORKERS: '1',
+  WARM_STARTUP_CONCURRENCY: '1',
+  ROUTING_STRATEGY: 'fill-first',
+  REQUEST_TIMEOUT: '30m',
+  INIT_TIMEOUT: '2m'
+};
+
+// pluginEnv is the settings this plugin depends on to reach, trust and drive the service. The
+// service is started with them in its environment, which upstream reads over .env, so saving
+// others in the admin page can't break them.
+function pluginEnv(dataDir, config) {
   const authDir = path.resolve(dataDir, 'auth');
   if (/[\r\n]/.test(authDir) || /[\r\n]/.test(config.apiKey) || /[\r\n]/.test(config.adminUsername) || /[\r\n]/.test(config.adminPassword)) {
     throw new Error('Configuration paths or credentials must not contain newlines');
@@ -163,29 +212,103 @@ function serviceEnv(dataDir, config, options = {}) {
     ADMIN_USERNAME: config.adminUsername,
     ADMIN_PASSWORD: config.adminPassword,
     AUTO_START: 'true',
-    REQUEST_BODY_LOG: 'false',
-    LOG_FILE: 'false',
     WAA_BACKEND: 'go',
     UPSTREAM_CHANNELS: 'playground',
-    BUILD_NATIVE_NONSTREAM: 'false',
-    TEMPORARY_CHAT: 'true',
-    PER_ACCOUNT_CONCURRENCY: '1',
-    WARM_WORKER_LIMIT: '1',
-    MAX_ACTIVE_WORKERS: '1',
-    WARM_STARTUP_CONCURRENCY: '1',
-    ROUTING_STRATEGY: 'fill-first',
-    REQUEST_TIMEOUT: '30m',
-    INIT_TIMEOUT: '2m',
-    PROXY: effectiveProxy(options.proxy, config.proxy)
+    BUILD_NATIVE_NONSTREAM: 'false'
   };
 }
 
-export function generateEnv(dataDir, config, options = {}) {
-  return Object.entries(serviceEnv(dataDir, config, options)).map(([k, v]) => `${k}=${v}\n`).join('');
+// serviceEnv is the environment the service is started with: this plugin's settings, and PROXY
+// only when the plugin sets one (see pluginProxy). Without it the service takes the PROXY saved
+// in .env, which the admin page changes.
+export function serviceEnv(dataDir, config, options = {}) {
+  const env = pluginEnv(dataDir, config);
+  const owned = pluginProxy(options.proxy);
+  if (owned) env.PROXY = owned.proxy;
+  return env;
+}
+
+// parseEnvValue and formatEnvValue read and write a .env value as upstream does.
+function parseEnvValue(raw, where) {
+  if (!raw) return '';
+  if (raw[0] === "'") {
+    if (raw.length < 2 || !raw.endsWith("'")) throw new Error(`${where}: unterminated single quote`);
+    return raw.slice(1, -1);
+  }
+  if (raw[0] === '"') {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new Error(`${where}: invalid double-quoted value`);
+    }
+  }
+  const comment = raw.indexOf(' #');
+  return comment >= 0 ? raw.slice(0, comment).trim() : raw;
+}
+
+function formatEnvValue(value) {
+  return /[ \t\r\n#"']/.test(value) ? JSON.stringify(value) : value;
+}
+
+// readStudioEnv is the settings saved in the service's .env (none when it has no .env).
+export function readStudioEnv(dataDir) {
+  const envPath = path.join(dataDir, '.env');
+  let text;
+  try {
+    text = fs.readFileSync(envPath, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return {};
+    throw err;
+  }
+  const values = {};
+  text.split(/\r?\n/).forEach((line, i) => {
+    line = line.trim();
+    if (!line || line.startsWith('#')) return;
+    const eq = line.indexOf('=');
+    if (eq < 0) throw new Error(`${envPath}:${i + 1}: missing "="`);
+    const key = line.slice(0, eq).trim();
+    if (ENV_KEYS.includes(key)) values[key] = parseEnvValue(line.slice(eq + 1).trim(), `${envPath}:${i + 1}`);
+  });
+  return values;
+}
+
+function writeStudioEnv(dataDir, values) {
+  const envPath = path.join(dataDir, '.env');
+  const content = ENV_KEYS.filter(k => values[k] !== undefined).map(k => `${k}=${formatEnvValue(String(values[k]))}\n`).join('');
+  let current;
+  try {
+    current = fs.readFileSync(envPath, 'utf8');
+  } catch {}
+  if (current !== content) {
+    const tmpEnv = `${envPath}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+    fs.writeFileSync(tmpEnv, content, { mode: 0o600 });
+    fs.renameSync(tmpEnv, envPath);
+  }
+  fs.chmodSync(envPath, 0o600);
+}
+
+// syncStudioEnv brings .env up to date with config.json, keeping what the admin page saved: this
+// plugin's settings are written over, the others only when missing. A missing PROXY is the one
+// given, else the one an older config.json kept (which nothing reads after that).
+function syncStudioEnv(dataDir, config, seedProxy) {
+  const values = readStudioEnv(dataDir);
+  Object.assign(values, pluginEnv(dataDir, config));
+  for (const [key, value] of Object.entries(SETTING_DEFAULTS)) values[key] ??= value;
+  values.PROXY ??= validateProxy(seedProxy) || config.proxy;
+  writeStudioEnv(dataDir, values);
+}
+
+// saveStudioProxy saves the service's proxy in its .env, as the admin page does. The service
+// takes it the next time its generation service starts.
+export function saveStudioProxy(dataDir, proxy) {
+  const values = readStudioEnv(dataDir);
+  values.PROXY = validateProxy(proxy);
+  writeStudioEnv(dataDir, values);
 }
 
 // ensureStudioConfig reads config.json, writing a new one if there is none: on options.port when
-// given (see pickStudioPort), else on DEFAULT_STUDIO_PORT.
+// given (see pickStudioPort), else on DEFAULT_STUDIO_PORT. It then brings .env up to date (see
+// syncStudioEnv), with explicitProxy as the proxy to save if .env has none yet.
 export function ensureStudioConfig(dataDir, explicitProxy = undefined, options = {}) {
   fs.mkdirSync(dataDir, { recursive: true, mode: 0o700 });
   fs.chmodSync(dataDir, 0o700);
@@ -204,29 +327,24 @@ export function ensureStudioConfig(dataDir, explicitProxy = undefined, options =
     fs.chmodSync(configPath, 0o600);
   } catch (err) {
     if (err.code === 'ENOENT') {
-      config = {
+      const created = {
         version: 1,
         port: options.port ?? DEFAULT_STUDIO_PORT,
         apiKey: 'as_' + crypto.randomBytes(32).toString('hex'),
         adminUsername: 'magpie',
-        adminPassword: crypto.randomBytes(32).toString('hex'),
-        proxy: validateProxy(explicitProxy ?? '')
+        adminPassword: crypto.randomBytes(32).toString('hex')
       };
       const tmp = `${configPath}.${crypto.randomBytes(4).toString('hex')}.tmp`;
-      fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+      fs.writeFileSync(tmp, JSON.stringify(created, null, 2) + '\n', { mode: 0o600 });
       fs.renameSync(tmp, configPath);
       fs.chmodSync(configPath, 0o600);
+      config = validateConfig(created);
     } else {
       throw err;
     }
   }
 
-  const envPath = path.join(dataDir, '.env');
-  const envContent = generateEnv(dataDir, config, { proxy: explicitProxy });
-  const tmpEnv = `${envPath}.${crypto.randomBytes(4).toString('hex')}.tmp`;
-  fs.writeFileSync(tmpEnv, envContent, { mode: 0o600 });
-  fs.renameSync(tmpEnv, envPath);
-  fs.chmodSync(envPath, 0o600);
+  syncStudioEnv(dataDir, config, explicitProxy);
 
   const authDir = path.join(dataDir, 'auth');
   fs.mkdirSync(authDir, { recursive: true, mode: 0o700 });
@@ -425,6 +543,114 @@ export async function studioAccounts(options = {}) {
   return accounts.filter(a => a.enabled !== false);
 }
 
+// PROXY_SOURCES names where the proxy the service goes out through comes from.
+export const PROXY_SOURCES = {
+  option: '插件选项 studio.proxy',
+  env: '环境变量 AI_STUDIO_PROXY',
+  saved: '管理页',
+  startup: '服务启动时的设置',
+  unknown: '来源待确认',
+  system: '自动检测：HTTPS_PROXY 环境变量或系统代理',
+  direct: '直连'
+};
+
+// redactProxy hides the passwords in a PROXY list.
+export function redactProxy(value) {
+  return proxyList(value).map(p => {
+    try {
+      const u = new URL(p);
+      if (u.password) u.password = '***';
+      return u.toString().replace(/\/$/, '');
+    } catch {
+      return p;
+    }
+  }).join(',');
+}
+
+// LAUNCH_RECORD says, for the service process this plugin last started, whether it was started
+// with a PROXY of the plugin's over the saved one, and whose: 'option' or 'env' (see pluginProxy),
+// null for none. A caller that doesn't know the plugin's options (the CLI) reads it from there.
+const LAUNCH_RECORD = 'backend.launch.json';
+
+function writeLaunchRecord(dataDir, pid, proxy) {
+  const record = { pid, proxy: pluginProxy(proxy)?.source ?? null };
+  try {
+    fs.writeFileSync(path.join(dataDir, LAUNCH_RECORD), JSON.stringify(record) + '\n', { mode: 0o600 });
+  } catch {}
+}
+
+// launchRecord is the record of the running service's start, or null when the running service
+// isn't the one it was written for (or an older plugin started it, which wrote none).
+function launchRecord(dataDir) {
+  try {
+    const record = JSON.parse(fs.readFileSync(path.join(dataDir, LAUNCH_RECORD), 'utf8'));
+    if (record?.pid !== recordedPid(dataDir) || !(record.proxy === null || record.proxy in PROXY_SOURCES)) return null;
+    return record;
+  } catch {
+    return null;
+  }
+}
+
+// studioProxy is how the running service reaches Google:
+//   active  the proxy it goes out through now ('' for none), and source where that comes from (a
+//           PROXY_SOURCES key; 'unknown' when the service can't tell it from a change not yet applied);
+//   saved   the proxy saved in .env, as the admin page shows it;
+//   overridden, when another one is used over a saved one: whose it is ('option' or 'env'), or
+//           'unknown' when the service was started with another one in its environment and
+//           nothing tells whose;
+//   pending what it takes for the one set (wanted, from wantedSource) to apply: 'restart', the
+//           service must start again; 'generation', its generation service must; null, nothing.
+// A standalone caller (the CLI) doesn't know the plugin's options, so it can't tell what the
+// service will be started with next: it reads what it was started with from the launch record.
+// Passwords are hidden.
+export async function studioProxy(local, options = {}) {
+  const saved = proxyList(readStudioEnv(local.dataDir).PROXY).join(',');
+  const override = options.standalone ? null : pluginProxy(options.proxy);
+  const cfg = await studioAdmin(local, 'GET', '/api/config', null, { timeoutMs: 3000, fetchFn: options.fetchFn });
+  // What the service reads as its PROXY now: .env, or the environment it was started with over it
+  const loaded = proxyList(cfg?.proxy).join(',');
+  const active = proxyList(cfg?.active_proxy).join(',');
+
+  let want = override ? override.proxy : saved;
+  let wantedSource = override ? override.source : 'saved';
+  let overridden = override && saved && saved !== override.proxy ? override.source : null;
+  if (options.standalone && loaded !== saved) {
+    // Started with another proxy in its environment: one of the plugin's, which applies as long as
+    // it is set, or, with no record of whose, one a restart may or may not set again
+    const launched = launchRecord(local.dataDir)?.proxy;
+    overridden = launched || 'unknown';
+    if (launched) {
+      want = loaded;
+      wantedSource = launched;
+    }
+  }
+
+  let pending = null;
+  if (loaded !== want) pending = 'restart';
+  else if (want && active !== want) pending = 'generation';
+  // Saved none, going out through one: the system's, or one saved before that the generation
+  // service still has. A change not yet applied leaves which it is open.
+  const unsure = !want && active && cfg?.service_restart_required === true;
+  if (unsure) pending = 'generation';
+
+  let source;
+  if (!active) source = 'direct';
+  else if (unsure) source = 'unknown';
+  else if (pending) source = 'startup';
+  else if (!loaded) source = 'system';
+  else source = wantedSource;
+
+  return {
+    active: redactProxy(active),
+    source,
+    saved: redactProxy(saved),
+    overridden,
+    wanted: redactProxy(want),
+    wantedSource,
+    pending
+  };
+}
+
 export function isConnectRefused(err) {
   if (!err) return false;
   const visited = new Set();
@@ -799,7 +1025,7 @@ export async function installStudio(options = {}) {
     } else {
       const downloadUrl = `https://github.com/${release.repository}/releases/download/${release.tag}/${pin.asset}`;
       archivePath = path.join(stageDir, pin.asset);
-      const proxy = effectiveProxy(options.proxy, savedConfig?.proxy);
+      const proxy = downloadProxy(dataDir, options.proxy, savedConfig);
 
       if (options.fetchFn && options.fetchFn !== globalThis.fetch) {
         const res = await options.fetchFn(downloadUrl, { signal: AbortSignal.timeout(300000) });
@@ -1036,7 +1262,9 @@ function shared(map, key, fn) {
 }
 
 // ensureStudio makes sure the service is installed and running, and, unless managementOnly,
-// that it takes generation requests. Callers share one start of the service and one wait for
+// that it takes generation requests. options.proxy is a proxy it is started with over the saved
+// one (studio.proxy); options.savedProxy is one saved as the service's own before it starts, as
+// the admin page saves one. Callers share one start of the service and one wait for
 // it to take requests; a managementOnly caller doesn't wait for the latter.
 export async function ensureStudio(options = {}) {
   const dataDir = options.dataDir || studioDataDir();
@@ -1113,10 +1341,11 @@ async function launchStudio(options) {
     }
 
     if (!manifestValid) {
-      await installStudio({ dataDir, platform, arch, fetchFn, archivePath: options.archivePath, proxy: options.proxy, preferredPort: options.preferredPort });
+      await installStudio({ dataDir, platform, arch, fetchFn, archivePath: options.archivePath, proxy: options.proxy ?? options.savedProxy, preferredPort: options.preferredPort });
     }
 
     const config = ensureStudioConfig(dataDir, options.proxy, { port: await newConfigPort(dataDir, options) });
+    if (options.savedProxy !== undefined) saveStudioProxy(dataDir, options.savedProxy);
     local = localStudio({ dataDir, platform });
     if (!local) throw new Error(`Invalid AI Studio configuration in ${dataDir}`);
 
@@ -1128,10 +1357,11 @@ async function launchStudio(options) {
     assertStudioExited(dataDir, platform);
     protectPackage(dataDir, platform);
 
-    // Clean environment: no arbitrary host AISTUDIO_* or WAA_* vars
+    // Clean environment: no host AISTUDIO_* or WAA_* vars, nor any of upstream's settings, which
+    // would hide the ones saved in .env
     const cleanEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
-      if (!k.startsWith('AISTUDIO_') && !k.startsWith('WAA_')) {
+      if (!k.startsWith('AISTUDIO_') && !k.startsWith('WAA_') && !ENV_KEYS.includes(k.toUpperCase())) {
         cleanEnv[k] = v;
       }
     }
@@ -1161,6 +1391,7 @@ async function launchStudio(options) {
       });
       if (child.pid) {
         fs.writeFileSync(path.join(dataDir, 'backend.pid'), `${child.pid}\n`, { mode: 0o600 });
+        writeLaunchRecord(dataDir, child.pid, options.proxy);
       }
       child.unref?.();
     } finally {

package/lib/studio.mjs

@@ -1,5 +1,6 @@
 import { normalizeBaseURL, credentials, forward, makeOpenAIError, UNREACHABLE_HEADER } from './backend.mjs';
-import { localStudio, ensureStudio, studioAdmin, studioAccounts, validateProxy, isConnectRefused } from './studio-native.mjs';
+import path from 'node:path';
+import { localStudio, ensureStudio, studioAdmin, studioAccounts, studioProxy, studioCommand, validateProxy, isConnectRefused, PROXY_SOURCES } from './studio-native.mjs';
 
 export const STUDIO_ID = 'ai-studio';
 export const STUDIO_BASE = 'http://127.0.0.1:2048/v1';
@@ -454,6 +455,43 @@ export function poolUsage(accounts, cooldowns, now = Date.now()) {
   return { user, windows: cooldownWindows(cooldowns, accounts, now) };
 }
 
+// proxyLine says which proxy the local service goes out through, where that comes from, a saved
+// one set aside for another, and what it takes for the one set to apply (see studioProxy).
+export function proxyLine(proxy, local) {
+  const named = p => p || '不走代理';
+  const restart = `重启本地服务（${studioCommand('stop', { dataDir: local.dataDir })}，下一次请求会自动启动）`;
+  let line = `${named(proxy.active)}（${PROXY_SOURCES[proxy.source]}）`;
+  if (proxy.overridden === 'unknown') {
+    line += `；管理页保存的是 ${named(proxy.saved)}，但服务启动时的环境变量盖住了它（旧版插件启动的服务会这样）。${restart}后应按管理页设置生效；如果由 Magpie 再次启动后仍被盖住，检查插件选项 studio.proxy 和环境变量 AI_STUDIO_PROXY`;
+    return line;
+  }
+  if (proxy.pending === 'restart') {
+    line += `；${PROXY_SOURCES[proxy.wantedSource]}设置的是 ${named(proxy.wanted)}，${restart}后生效`;
+  } else if (proxy.pending === 'generation') {
+    line += proxy.source === 'unknown'
+      ? '；管理页有改动还没生效，在管理页重启服务后生效'
+      : `；管理页保存的 ${named(proxy.wanted)} 要在管理页重启服务后生效`;
+  }
+  if (proxy.overridden) {
+    const by = PROXY_SOURCES[proxy.overridden];
+    line += `；管理页保存的 ${proxy.saved} 被 ${by} 覆盖，不会生效。要改用它，先去掉 ${by}，再${restart}`;
+  }
+  return line;
+}
+
+// serviceWindows are the usage card's lines about the local service itself: the proxy it goes out
+// through (when it could be read), and where its admin page is.
+function serviceWindows(local, proxy) {
+  const windows = [];
+  if (proxy) windows.push({ name: '代理出口', used: 0, display: proxyLine(proxy, local) });
+  windows.push({
+    name: '管理页',
+    used: 0,
+    display: `${local.origin}（用户名 ${local.adminUsername}，密码是 ${path.join(local.dataDir, 'config.json')} 里的 adminPassword）`
+  });
+  return windows;
+}
+
 export const AIStudioPlugin = async (_input, options = {}) => {
   const opts = studioSettings(options);
 
@@ -473,14 +511,26 @@ export const AIStudioPlugin = async (_input, options = {}) => {
     return accountSignIn(local, account);
   }
 
+  // proxyNote is a line on the proxy the local service goes out through, for a sign-in to show
+  // before its login window opens and when it fails: a wrong proxy is the usual reason the window
+  // can't reach Google, and nothing else shows it before an account is signed in.
+  async function proxyNote(local) {
+    if (!local) return '';
+    try {
+      return `\n本地服务的代理出口：${proxyLine(await studioProxy(local, opts), local)}`;
+    } catch {
+      return '';
+    }
+  }
+
   // addAccount signs a new Google account in through the service's own login window, setting the
   // service up first if this is the first.
   async function addAccount() {
-    await ensureStudio({ proxy: opts.proxy, managementOnly: true });
+    const ready = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
     return {
       url: '',
       method: 'auto',
-      instructions: LOGIN_STEPS,
+      instructions: LOGIN_STEPS + await proxyNote(ready),
       async callback() {
         let local, account;
         try {
@@ -491,7 +541,7 @@ export const AIStudioPlugin = async (_input, options = {}) => {
             throw new Error('AIStudio2API did not return an enabled account');
           }
         } catch (err) {
-          return { type: 'failed', error: `Google 登录没有完成：${err.message}` };
+          return { type: 'failed', error: `Google 登录没有完成：${err.message}${await proxyNote(local)}` };
         }
         return afterLogin(local, account);
       }
@@ -499,11 +549,11 @@ export const AIStudioPlugin = async (_input, options = {}) => {
   }
 
   // signInAgain signs an account whose Google sign-in expired in again, in a login window.
-  function signInAgain(chosen) {
+  async function signInAgain(ready, chosen) {
     return {
       url: '',
       method: 'auto',
-      instructions: RELOGIN_STEPS,
+      instructions: RELOGIN_STEPS + await proxyNote(ready),
       async callback() {
         let local;
         try {
@@ -511,7 +561,7 @@ export const AIStudioPlugin = async (_input, options = {}) => {
           const res = await studioAdmin(local, 'POST', `/api/accounts/${encodeURIComponent(chosen.id)}/login`, {}, { timeoutMs: LOGIN_TIMEOUT_MS });
           if (res?.account?.state === 'auth_required') throw new Error(res.account.message || '账号仍然需要重新登录');
         } catch (err) {
-          return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}` };
+          return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}${await proxyNote(local)}` };
         }
         return afterLogin(local, chosen);
       }
@@ -564,7 +614,7 @@ export const AIStudioPlugin = async (_input, options = {}) => {
             const local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
             const chosen = (await studioAccounts(opts)).find(a => a.id === id);
             if (!chosen) throw new Error(`本地 Google AI Studio 里没有启用的账号 ${id}`);
-            if (chosen.state === 'auth_required') return signInAgain(chosen);
+            if (chosen.state === 'auth_required') return signInAgain(local, chosen);
             return { url: '', method: 'auto', instructions: '', callback: async () => accountSignIn(local, chosen) };
           }
         },
@@ -631,12 +681,13 @@ export const AIStudioPlugin = async (_input, options = {}) => {
           return { error: '本地 AI Studio 配置不匹配，请重新登录', windows: [], signIn: 'expired' };
         }
 
-        let accounts, cooldowns;
+        let accounts, cooldowns, proxy;
         try {
-          [accounts, cooldowns] = await Promise.all([
+          [accounts, cooldowns, proxy] = await Promise.all([
             studioAdmin(local, 'GET', '/api/accounts', null, { timeoutMs: 3000 }),
-            // Without its cooldowns the card still says whose accounts these are.
-            studioAdmin(local, 'GET', '/api/cooldowns', null, { timeoutMs: 3000 }).catch(() => null)
+            // Without its cooldowns or proxy the card still says whose accounts these are.
+            studioAdmin(local, 'GET', '/api/cooldowns', null, { timeoutMs: 3000 }).catch(() => null),
+            studioProxy(local, opts).catch(() => null)
           ]);
         } catch (err) {
           if (isConnectRefused(err)) {
@@ -647,15 +698,18 @@ export const AIStudioPlugin = async (_input, options = {}) => {
         const enabled = (Array.isArray(accounts?.accounts) ? accounts.accounts : []).filter(a => a && a.enabled !== false);
         const cooling = Array.isArray(cooldowns?.cooldowns) ? cooldowns.cooldowns : [];
         const id = auth.metadata.account;
+        const service = serviceWindows(local, proxy);
+        let card;
         if (typeof id !== 'string' || !id) {
           // A sign-in for the whole pool, as 0.5.0 made them
-          return { ...poolUsage(enabled, cooling), signIn: 'kept' };
-        }
-        const account = enabled.find(a => a.id === id);
-        if (!account) {
-          return { error: `本地 AI Studio 里已经没有这个账号（${auth.metadata.email || id}），可能被停用或删除了`, windows: [], signIn: 'kept' };
+          card = poolUsage(enabled, cooling);
+        } else {
+          const account = enabled.find(a => a.id === id);
+          card = account
+            ? accountUsage(account, cooling)
+            : { error: `本地 AI Studio 里已经没有这个账号（${auth.metadata.email || id}），可能被停用或删除了`, windows: [] };
         }
-        return { ...accountUsage(account, cooling), signIn: 'kept' };
+        return { ...card, windows: [...card.windows, ...service], signIn: 'kept' };
       }
     },
     provider: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-gemini-web",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Gemini Web and Google AI Studio provider for Magpie, backed by gemini-web2api-go and AIStudio2API",
   "type": "module",
   "main": "./index.mjs",

package/scripts/studio.mjs

@@ -11,11 +11,11 @@ import {
   studioAccounts,
   stopStudio,
   studioStatus,
-  validateConfig,
-  validateProxy,
-  generateEnv,
+  studioProxy,
+  saveStudioProxy,
   studioCommand
 } from '../lib/studio-native.mjs';
+import { proxyLine } from '../lib/studio.mjs';
 
 const LOGIN_TIMEOUT_MS = 15 * 60 * 1000;
 
@@ -63,22 +63,10 @@ function parseArgs(args) {
   return flags;
 }
 
-async function updateProxyConfig(dataDir, proxy) {
-  const configPath = path.join(dataDir, 'config.json');
-  if (!fs.existsSync(configPath)) return;
-  const config = validateConfig(JSON.parse(fs.readFileSync(configPath, 'utf8')));
-  config.proxy = validateProxy(proxy);
-  const tmp = `${configPath}.tmp.${Date.now()}.${crypto.randomBytes(4).toString('hex')}`;
-  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
-  fs.renameSync(tmp, configPath);
-  fs.chmodSync(configPath, 0o600);
-
-  const envPath = path.join(dataDir, '.env');
-  const envContent = generateEnv(dataDir, config, { proxy: config.proxy });
-  const tmpEnv = `${envPath}.tmp.${Date.now()}.${crypto.randomBytes(4).toString('hex')}`;
-  fs.writeFileSync(tmpEnv, envContent, { mode: 0o600 });
-  fs.renameSync(tmpEnv, envPath);
-  fs.chmodSync(envPath, 0o600);
+// saveProxy saves the proxy given with --proxy as the service's own, as its admin page does,
+// once the data directory is set up.
+function saveProxy(dataDir, proxy) {
+  if (proxy !== undefined && fs.existsSync(path.join(dataDir, 'config.json'))) saveStudioProxy(dataDir, proxy);
 }
 
 function validateStorageState(filePath) {
@@ -128,15 +116,13 @@ async function main() {
       if (status.status === 'running' || status.status === 'outdated' || status.status === 'unresponsive') {
         throw new Error('Cannot install or update AI Studio while service is running. Stop the service first.');
       }
-      if (flags.proxy !== undefined) {
-        await updateProxyConfig(dataDir, flags.proxy);
-      }
       console.log(`Installing AIStudio2API into ${dataDir}...`);
       const local = await installStudio({
         dataDir,
         archivePath: flags.archive,
         proxy: flags.proxy
       });
+      saveProxy(dataDir, flags.proxy);
       console.log(`AIStudio2API installed successfully.`);
       console.log(`Listen origin: ${local.origin}`);
       console.log(`Data directory: ${local.dataDir}`);
@@ -155,14 +141,12 @@ async function main() {
         console.log(`Management URL: ${local.origin}`);
         return;
       }
-      if (flags.proxy !== undefined) {
-        await updateProxyConfig(dataDir, flags.proxy);
-      }
       if (status.status === 'outdated') {
         console.log(`Replacing AIStudio2API ${status.version} from an earlier install with ${status.expected}...`);
       }
       console.log(`Starting AIStudio2API service in ${dataDir}...`);
-      const local = await ensureStudio({ dataDir, proxy: flags.proxy });
+      // --proxy is saved as the service's own, as its admin page saves one, not set over it
+      const local = await ensureStudio({ dataDir, savedProxy: flags.proxy });
       console.log(`AIStudio2API service is running.`);
       console.log(`API Base URL: ${local.baseURL}`);
       console.log(`Management URL: ${local.origin}`);
@@ -175,6 +159,13 @@ async function main() {
         console.log(`State: ${status.state || 'RUNNING'}`);
         console.log(`Listen port: ${status.port}`);
         console.log(`Accounts: ready=${status.accounts?.ready ?? 0}, total=${status.accounts?.total ?? 0}`);
+        const local = localStudio({ dataDir });
+        console.log(`Management URL: ${local.origin} (user ${local.adminUsername}, password: adminPassword in ${path.join(dataDir, 'config.json')})`);
+        try {
+          console.log(`Proxy: ${proxyLine(await studioProxy(local, { standalone: true }), local)}`);
+        } catch (err) {
+          console.log(`Proxy: could not be read (${err.message})`);
+        }
         const accounts = await studioAccounts({ dataDir });
         if (accounts.length > 0) {
           console.log(`Enabled accounts:`);