magpie-gemini-web 0.5.2 → 0.5.4

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.4",
   "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-managed-smoke.mjs

@@ -25,6 +25,7 @@ try {
   for (const query of ['', '?refresh=1']) {
     const update = await studioAdmin(local, 'GET', `/api/update${query}`);
     assert.equal(update.mode, 'managed');
+    assert.equal(update.managed_by, 'magpie-gemini-web');
     assert.equal(update.available, false);
     assert.equal(update.updating, false);
     assert.equal(update.current, STUDIO_VERSION);
@@ -36,8 +37,8 @@ try {
       if (String(args[0]).endsWith('/api/update')) updateHTTP = response.status;
       return response;
     }
-  }), /Magpie/);
-  assert.equal(updateHTTP, 403);
+  }), /magpie-gemini-web/);
+  assert.equal(updateHTTP, 409);
   assert.equal(computeFileHash(bin), pin.binarySha256, 'update must not replace the binary');
   assert.equal(fs.readFileSync(path.join(dataDir, 'backend.pid'), 'utf8'), pidBefore, 'update must not restart');
   const html = await (await fetch(local.origin)).text();
@@ -47,11 +48,12 @@ try {
   const versionPanel = /(?:\.\/|\/assets\/)?(VersionPanel-[\w-]+\.js)/.exec(js)?.[1];
   assert.ok(versionPanel, 'built admin version panel must exist');
   const panel = await (await fetch(`${local.origin}/assets/${versionPanel}`)).text();
-  assert.match(panel, /Online updates are disabled/);
-  assert.ok(!panel.includes('applyUpdate'), 'version panel must not offer online installation');
+  // Upstream's panel keeps its install button for other builds and shows a managed build's note
+  // in its place; the refusal above is what keeps the binary
+  assert.match(panel, /version\.managed/);
   assert.deepEqual(await stopStudio({ dataDir }), { stopped: true });
   assert.equal((await studioStatus({ dataDir })).status, 'stopped');
-  console.log(`PASS ${key}: ${STUDIO_VERSION}, managed status, update HTTP 403, unchanged executable/PID, managed UI, clean stop`);
+  console.log(`PASS ${key}: ${STUDIO_VERSION}, managed status, update HTTP 409, unchanged executable/PID, managed UI, clean stop`);
 } finally {
   let stopped = !local;
   if (local) stopped = (await stopStudio({ dataDir }).catch(() => ({ stopped: false }))).stopped;

package/scripts/studio-release.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
-// Clean upstream commit + reviewed patch -> managed archives, never a developer's dirty tree.
+// Clean upstream commit -> managed archives, never a developer's dirty tree. Upstream's own
+// distributor settings make the build managed: it reports this version, and its online updater
+// neither checks GitHub nor installs, saying the plugin manages updates.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,9 +36,9 @@ const hash = file => crypto.createHash('sha256').update(fs.readFileSync(file)).d
 const go = (argv, extra = {}) => execFileSync('go', argv, { cwd: source, env: { ...env, ...extra }, stdio: 'inherit' });
 const npm = argv => execFileSync(process.platform === 'win32' ? 'npm.cmd' : 'npm', argv,
   { cwd: path.join(source, 'web'), stdio: 'inherit', shell: process.platform === 'win32' });
-const patch = path.join(root, 'patches/studio-managed.patch');
+const MANAGED_BY = 'magpie-gemini-web';
 const flags = ['-mod=readonly', '-trimpath', '-buildvcs=false',
-  `-ldflags=-s -w -X github.com/Mag1cFall/AIStudio2API/internal/app.managedVersion=v${release.version}`];
+  `-ldflags=-s -w -X github.com/Mag1cFall/AIStudio2API/internal/app.version=v${release.version} -X github.com/Mag1cFall/AIStudio2API/internal/app.managedBy=${MANAGED_BY}`];
 
 try {
   let upstream = args.find(arg => arg.startsWith('--source='))?.slice(9);
@@ -50,8 +52,6 @@ try {
   }
   execFileSync('git', ['-C', upstream, 'archive', '--format=tar', `--output=${path.join(scratch, 'upstream.tar')}`, release.upstream.commit]);
   execFileSync('tar', ['-xf', 'upstream.tar', '-C', 'source'], { cwd: scratch });
-  execFileSync('git', ['apply', '--check', patch], { cwd: source, stdio: 'inherit' });
-  execFileSync('git', ['apply', patch], { cwd: source, stdio: 'inherit' });
   npm(['ci', '--no-audit', '--no-fund']);
   npm(['run', 'lint']);
   npm(['run', 'build']);
@@ -74,7 +74,7 @@ try {
   fs.copyFileSync(path.join(source, 'LICENSE'), path.join(output, 'LICENSE-AISTUDIO'));
   fs.writeFileSync(path.join(output, target ? `build-${target}.json` : 'build.json'), JSON.stringify({
     version: release.version, upstream: release.upstream, goVersion: release.goVersion,
-    nodeVersion: process.version, patchSha256: hash(patch), flags, binaries
+    nodeVersion: process.version, managedBy: MANAGED_BY, flags, binaries
   }, null, 2) + '\n');
   fs.writeFileSync(path.join(output, target ? `SHA256SUMS-${target}.txt` : 'SHA256SUMS.txt'),
     Object.values(binaries).map(pin => `${pin.sha256}  ${pin.asset}\n`).join(''));

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:`);