magpie-gemini-web 0.5.0 → 0.5.2

package/lib/studio-native.mjs

@@ -30,9 +30,14 @@ export function computeFileHash(filePath) {
 // studioCommand is a command line for this plugin's own management CLI, to quote in messages.
 // Magpie installs the plugin where its user doesn't look, so `npm run studio:*` from a checkout
 // is no help to them; the CLI's full path also keeps its pinned version the plugin's own.
-export function studioCommand(action) {
+export function studioCommand(action, { dataDir } = {}) {
   const script = fileURLToPath(new URL('../scripts/studio.mjs', import.meta.url));
-  return `node "${script}" ${action}`;
+  const command = `node "${script}" ${action}`;
+  if (!dataDir) return command;
+  const quoted = process.platform === 'win32'
+    ? `"${dataDir.replaceAll('"', '""')}"`
+    : `'${dataDir.replaceAll("'", "'\\''")}'`;
+  return `${command} --data-dir ${quoted}`;
 }
 
 // pickStudioPort is the port for a new setup: preferred when nothing uses it, else one the system
@@ -169,7 +174,7 @@ function serviceEnv(dataDir, config, options = {}) {
     MAX_ACTIVE_WORKERS: '1',
     WARM_STARTUP_CONCURRENCY: '1',
     ROUTING_STRATEGY: 'fill-first',
-    REQUEST_TIMEOUT: '5m',
+    REQUEST_TIMEOUT: '30m',
     INIT_TIMEOUT: '2m',
     PROXY: effectiveProxy(options.proxy, config.proxy)
   };
@@ -438,7 +443,8 @@ export function isConnectRefused(err) {
 }
 
 // checkStudioHealth says what answers on the setup's port: 'down' (nothing), 'up' (this setup's
-// service, at the pinned version), 'outdated' (this setup's service, at another version),
+// service, at the pinned version), 'outdated' (an older official version),
+// 'version_conflict' (a newer or custom version installed outside this plugin),
 // 'foreign' (something else) or 'unresponsive' (something that times out or fails, as the
 // service can while it starts or when it hangs).
 export async function checkStudioHealth(local, fetchFn) {
@@ -481,10 +487,15 @@ export async function checkStudioHealth(local, fetchFn) {
     }
   }
 
-  // The service took this setup's own admin credentials, so this plugin installed it. Another
-  // version is an earlier install still running, as after a plugin update pinned a new one.
-  if (String(status.version).replace(/^v/, '') !== release.version) {
-    return { state: 'outdated', status, reason: `Running version ${status.version}, expected ${STUDIO_VERSION}` };
+  // Official releases at or below our upstream base can move to the managed
+  // build. Newer/custom installations require an explicit recovery decision.
+  const runningVersion = String(status.version).replace(/^v/, '');
+  if (runningVersion !== release.version) {
+    const parts = /^\d+\.\d+\.\d+$/.test(runningVersion) ? runningVersion.split('.').map(Number) : null;
+    const expected = release.upstream.version.split('.').map(Number);
+    const different = parts?.findIndex((n, i) => n !== expected[i]);
+    const older = parts && (different === -1 || parts[different] < expected[different]);
+    return { state: older ? 'outdated' : 'version_conflict', status, reason: `Running version ${status.version}, expected ${STUDIO_VERSION}` };
   }
 
   return { state: 'up', status };
@@ -504,8 +515,9 @@ export async function studioStatus(options = {}) {
   if (health.state === 'down') {
     return { status: 'stopped', port: local.port, dataDir };
   }
-  if (health.state === 'outdated') {
-    return { ...health.status, status: 'outdated', expected: STUDIO_VERSION, port: local.port, dataDir };
+  if (health.state === 'outdated' || health.state === 'version_conflict') {
+    return { ...health.status, status: health.state, expected: STUDIO_VERSION, port: local.port, dataDir,
+      ...(health.state === 'version_conflict' ? { reason: studioVersionConflict(local, health).message } : {}) };
   }
   return { status: health.state, reason: health.reason, port: local.port, dataDir };
 }
@@ -526,6 +538,7 @@ export function verifyProcessIdentity(pid, expectedBinaryPath, platform = proces
       ], {
         env: { ...process.env, TARGET_PID: String(pid) },
         encoding: 'utf8',
+        timeout: 20000,
         windowsHide: true
       }).trim();
       if (!out) return false;
@@ -563,6 +576,102 @@ export function verifyProcessIdentity(pid, expectedBinaryPath, platform = proces
   return false;
 }
 
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (err) { return err.code === 'EPERM'; }
+}
+
+function recordedPid(dataDir) {
+  try { return Number(fs.readFileSync(path.join(dataDir, 'backend.pid'), 'utf8').trim()); } catch { return NaN; }
+}
+
+// A self-update can close HTTP before exec (Unix), or spawn a replacement PID
+// (Windows). Inspect processes as well as the port before replacing or launching.
+export function studioProcessPids(bin, platform = process.platform, run = execFileSync) {
+  const opts = { encoding: 'utf8', timeout: platform === 'win32' ? 20000 : 5000, windowsHide: true };
+  let output;
+  if (platform === 'win32') {
+    try {
+      output = run('powershell', ['-NoProfile', '-NonInteractive', '-Command',
+        '$ErrorActionPreference = "Stop"; Get-CimInstance Win32_Process -Filter "Name=\'aistudio2api.exe\'" | Where-Object { $_.ExecutablePath -eq $env:TARGET_BINARY } | Select-Object -ExpandProperty ProcessId'],
+      { ...opts, env: { ...process.env, TARGET_BINARY: path.resolve(bin) } });
+    } catch (err) {
+      const dataDir = path.dirname(path.dirname(bin));
+      throw new Error(`Cannot check for remaining AIStudio2API processes. Check that PowerShell/CIM is available and permitted, then run: ${studioCommand('stop', { dataDir })}. No binary was replaced or new process started.`, { cause: err });
+    }
+    return [...new Set(String(output).trim().split(/\s+/).map(Number).filter(n => Number.isInteger(n) && n > 0))];
+  }
+  if (platform === 'linux' && run === execFileSync) {
+    // Linux ps comm is often only a basename. /proc retains the launch path
+    // even while the updater has renamed/unlinked the running executable.
+    return fs.readdirSync('/proc').filter(n => /^\d+$/.test(n)).flatMap(n => {
+      try {
+        const command = fs.readFileSync(`/proc/${n}/cmdline`, 'utf8').split('\0')[0];
+        return path.isAbsolute(command) && path.resolve(command) === path.resolve(bin) ? [Number(n)] : [];
+      } catch { return []; }
+    });
+  }
+  output = run('ps', ['-axo', 'pid=,comm='], opts);
+  return String(output).split('\n').flatMap(line => {
+    const match = line.trim().match(/^(\d+)\s+(.+)$/);
+    if (!match) return [];
+    const command = match[2].replace(/ \(deleted\)$/, '');
+    return path.isAbsolute(command) && path.resolve(command) === path.resolve(bin) ? [Number(match[1])] : [];
+  });
+}
+
+export function studioListenerPids(port, platform = process.platform, run = execFileSync) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('Invalid listener port');
+  const opts = { encoding: 'utf8', timeout: platform === 'win32' ? 20000 : 5000, windowsHide: true };
+  let output;
+  if (platform === 'win32') {
+    output = run('powershell', ['-NoProfile', '-NonInteractive', '-Command',
+      '$ErrorActionPreference = "Stop"; Get-NetTCPConnection -State Listen -LocalPort $env:TARGET_PORT | Select-Object -ExpandProperty OwningProcess -Unique'],
+    { ...opts, env: { ...process.env, TARGET_PORT: String(port) } });
+  } else {
+    try {
+      output = run('lsof', ['-nP', '-t', `-iTCP:${port}`, '-sTCP:LISTEN'], opts);
+    } catch (err) {
+      if (platform !== 'linux') throw err;
+      const rows = run('ss', ['-H', '-ltnp', `sport = :${port}`], opts);
+      output = [...String(rows).matchAll(/pid=(\d+)/g)].map(m => m[1]).join('\n');
+    }
+  }
+  return [...new Set(String(output).trim().split(/\s+/).map(Number).filter(n => Number.isInteger(n) && n > 0))];
+}
+
+function assertStudioExited(dataDir, platform) {
+  const tracked = recordedPid(dataDir);
+  const bin = binaryPath(dataDir, platform);
+  let pids;
+  if (processAlive(tracked) && verifyProcessIdentity(tracked, bin, platform)) {
+    pids = [tracked];
+  } else {
+    // A live PID can belong to an unrelated process after a crash or reboot.
+    fs.rmSync(path.join(dataDir, 'backend.pid'), { force: true });
+    pids = studioProcessPids(bin, platform);
+  }
+  if (pids.length) {
+    throw new Error(`AI Studio may still be running or restarting (PID ${pids.join(', ')}), even though its HTTP port is closed. Wait for it to finish restarting, or run: ${studioCommand('stop', { dataDir })}. No binary was replaced or new process started.`);
+  }
+}
+
+function protectPackage(dataDir, platform) {
+  if (platform === 'win32') return;
+  // Best-effort package hardening. Online updates are disabled in the managed
+  // backend itself; this permission is not the mechanism enforcing that policy.
+  try {
+    const pkg = path.join(dataDir, 'package');
+    if ((fs.statSync(pkg).mode & 0o777) !== 0o555) fs.chmodSync(pkg, 0o555);
+  } catch {}
+}
+
+function removePackage(dir, platform) {
+  if (!fs.existsSync(dir)) return;
+  if (platform !== 'win32') fs.chmodSync(dir, 0o755);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
 async function withLock(dataDir, fn, timeoutMs = 600000) {
@@ -654,6 +763,7 @@ export async function installStudio(options = {}) {
     if (health.state === 'up') {
       throw new Error('Cannot install or update AIStudio2API while service is running. Stop the service first.');
     }
+    if (health.state === 'version_conflict') throw studioVersionConflict(localExisting, health);
     if (health.state === 'outdated') {
       throw new Error(`Cannot install AIStudio2API ${STUDIO_VERSION} while ${health.status.version} from an earlier install is running. Stop the service first.`);
     }
@@ -665,6 +775,7 @@ export async function installStudio(options = {}) {
     }
   }
 
+  assertStudioExited(dataDir, platform);
   const expectedHash = pin.sha256;
   let archivePath = options.archivePath;
   // The archive kept from an earlier install sets a damaged binary right again without a download.
@@ -785,16 +896,23 @@ export async function installStudio(options = {}) {
     const stagePackageDir = path.join(dataDir, `.package.stage.${crypto.randomBytes(4).toString('hex')}`);
     const backupPackageDir = path.join(dataDir, `.package.backup.${crypto.randomBytes(4).toString('hex')}`);
 
+    // Download/extraction can take minutes: recheck before the actual swap too.
+    assertStudioExited(dataDir, platform);
     fs.renameSync(topDir, stagePackageDir);
 
     let hasBackup = false;
     let installedNewFinal = false;
-    if (fs.existsSync(finalPackageDir)) {
-      fs.renameSync(finalPackageDir, backupPackageDir);
-      hasBackup = true;
-    }
+    const oldPackageMode = platform !== 'win32' && fs.existsSync(finalPackageDir)
+      ? fs.statSync(finalPackageDir).mode & 0o777 : null;
 
     try {
+      if (fs.existsSync(finalPackageDir)) {
+        // macOS can reject renaming a read-only directory even when its parent
+        // is writable. Unlock only for this controlled swap and restore on failure.
+        if (oldPackageMode !== null) fs.chmodSync(finalPackageDir, oldPackageMode | 0o700);
+        fs.renameSync(finalPackageDir, backupPackageDir);
+        hasBackup = true;
+      }
       fs.renameSync(stagePackageDir, finalPackageDir);
       installedNewFinal = true;
 
@@ -811,18 +929,23 @@ export async function installStudio(options = {}) {
       fs.chmodSync(manifestPath, 0o600);
 
       ensureStudioConfig(dataDir, options.proxy, { port });
+      protectPackage(dataDir, platform);
 
       if (hasBackup) {
-        fs.rmSync(backupPackageDir, { recursive: true, force: true });
+        removePackage(backupPackageDir, platform);
       }
       removeOtherArchives(dataDir, pin.asset);
     } catch (swapErr) {
       if (installedNewFinal) {
-        try { fs.rmSync(finalPackageDir, { recursive: true, force: true }); } catch {}
+        try { removePackage(finalPackageDir, platform); } catch {}
       }
       if (hasBackup) {
         try { fs.renameSync(backupPackageDir, finalPackageDir); } catch {}
       }
+      if (oldPackageMode !== null && fs.existsSync(finalPackageDir)) {
+        try { fs.chmodSync(finalPackageDir, oldPackageMode); } catch {}
+      }
+      try { removePackage(stagePackageDir, platform); } catch {}
       if (oldManifestExists && oldManifestBytes) {
         try { fs.writeFileSync(manifestPath, oldManifestBytes, { mode: 0o600 }); } catch {}
       } else {
@@ -860,7 +983,7 @@ async function readyStudio(local, initial, options = {}) {
   for (;;) {
     if (status.running) return local;
     if (needsSignIn(status.accounts)) {
-      throw new Error(`AI Studio cannot start: its Google accounts need to sign in again (${status.accounts.auth_required} of ${status.accounts.total}). In Magpie, sign in to AI Studio with "重新登录失效的 AI Studio 账号", or run: ${studioCommand('relogin')}`);
+      throw new Error(`AI Studio cannot start: its Google accounts need to sign in again (${status.accounts.auth_required} of ${status.accounts.total}). In Magpie, sign in to Google AI Studio with "用 Google 账号登录（推荐）" and choose the account, or run: ${studioCommand('relogin', { dataDir: local.dataDir })}`);
     }
     if (Date.now() >= deadline) {
       throw new Error(`AI Studio generation did not become ready (state ${status.state}, ${status.accounts.ready ?? 0}/${status.accounts.total} accounts ready); see ${path.join(local.dataDir, 'backend.log')}`);
@@ -896,7 +1019,7 @@ function portTaken(local) {
 }
 
 function notResponding(local, health) {
-  return new Error(`The AI Studio service on port ${local.port} is not responding (${health.reason}). If it is stuck, run: ${studioCommand('stop')}; if another program uses the port, change "port" in ${path.join(local.dataDir, 'config.json')}`);
+  return new Error(`The AI Studio service on port ${local.port} is not responding (${health.reason}). If it is stuck, run: ${studioCommand('stop', { dataDir: local.dataDir })}; if another program uses the port, change "port" in ${path.join(local.dataDir, 'config.json')}`);
 }
 
 // rotateLog sets a log past LOG_ROTATE_BYTES aside as <log>.1, replacing the one before.
@@ -935,7 +1058,11 @@ async function launchStudio(options) {
   let local = localStudio({ dataDir, platform });
   if (local) {
     const health = await checkStudioHealth(local, fetchFn);
-    if (health.state === 'up') return { local, status: health.status };
+    if (health.state === 'up') {
+      protectPackage(dataDir, platform);
+      return { local, status: health.status };
+    }
+    if (health.state === 'version_conflict') throw studioVersionConflict(local, health);
     if (health.state === 'foreign') throw portTaken(local);
   }
 
@@ -944,10 +1071,16 @@ async function launchStudio(options) {
     local = localStudio({ dataDir, platform });
     if (local) {
       const health = await settle(local, await checkStudioHealth(local, fetchFn), fetchFn, options.unresponsiveTimeoutMs ?? 10000);
-      if (health.state === 'up') return { local, status: health.status };
+      if (health.state === 'up') {
+        protectPackage(dataDir, platform);
+        return { local, status: health.status };
+      }
+      if (health.state === 'version_conflict') throw studioVersionConflict(local, health);
+      if (health.state === 'foreign') throw portTaken(local);
       if (health.state === 'unresponsive') throw notResponding(local, health);
       if (health.state === 'outdated') await stopOutdated(local, health, { dataDir, platform, fetchFn });
     }
+    assertStudioExited(dataDir, platform);
 
     // Check config validity before touching binaries
     const configPath = path.join(dataDir, 'config.json');
@@ -970,14 +1103,12 @@ async function launchStudio(options) {
           manifest.arch === arch &&
           manifest.archiveSha256 === pin.sha256
         ) {
-          if (currentHash === manifest.binarySha256) {
-            manifestValid = true;
-          } else {
-            throw new Error('Binary checksum verification failed (mutated binary refused on launch)');
-          }
+          // A stopped service may have self-updated. Restore the pinned archive below;
+          // never bless the replacement by rewriting its hash into the manifest.
+          manifestValid = currentHash === manifest.binarySha256;
         }
-      } catch (err) {
-        if (err.message.includes('mutated binary')) throw err;
+      } catch {
+        // Missing/invalid installation metadata also requires a verified reinstall.
       }
     }
 
@@ -991,8 +1122,11 @@ async function launchStudio(options) {
 
     const health = await checkStudioHealth(local, fetchFn);
     if (health.state === 'up') return { local, status: health.status };
+    if (health.state === 'version_conflict') throw studioVersionConflict(local, health);
     if (health.state === 'foreign') throw portTaken(local);
     if (health.state !== 'down') throw notResponding(local, health);
+    assertStudioExited(dataDir, platform);
+    protectPackage(dataDir, platform);
 
     // Clean environment: no arbitrary host AISTUDIO_* or WAA_* vars
     const cleanEnv = {};
@@ -1006,6 +1140,7 @@ async function launchStudio(options) {
     const logPath = path.join(dataDir, 'backend.log');
     rotateLog(logPath);
     const logFd = fs.openSync(logPath, 'a', 0o600);
+    let launchError;
     try {
       const child = spawnFn(binPath, ['-open-ui=false'], {
         cwd: dataDir,
@@ -1014,7 +1149,16 @@ async function launchStudio(options) {
         stdio: ['ignore', logFd, logFd],
         windowsHide: true
       });
-      child.on?.('error', () => {});
+      const clearChildPid = () => {
+        if (child.pid && recordedPid(dataDir) === child.pid) {
+          try { fs.rmSync(path.join(dataDir, 'backend.pid'), { force: true }); } catch {}
+        }
+      };
+      child.on?.('error', err => { launchError = err; clearChildPid(); });
+      child.on?.('exit', (code, signal) => {
+        launchError = new Error(`AIStudio2API exited during startup (${signal || code}); see ${logPath}`);
+        clearChildPid();
+      });
       if (child.pid) {
         fs.writeFileSync(path.join(dataDir, 'backend.pid'), `${child.pid}\n`, { mode: 0o600 });
       }
@@ -1029,15 +1173,26 @@ async function launchStudio(options) {
       const h = await checkStudioHealth(local, fetchFn);
       if (h.state === 'up') return { local, status: h.status };
       if (h.state === 'foreign') throw portTaken(local);
+      if (h.state === 'version_conflict') throw studioVersionConflict(local, h);
       if (h.state === 'outdated') {
         throw new Error(`AIStudio2API on port ${local.port} reports version ${h.status.version}, expected ${STUDIO_VERSION}`);
       }
+      if (launchError) throw launchError;
       await sleep(250);
     }
     throw new Error(`AI Studio service did not start within ${Math.round(startTimeoutMs / 1000)}s; see ${logPath}`);
   });
 }
 
+function studioVersionConflict(local, health) {
+  return new Error(`AI Studio is running ${health.status.version}, but this plugin manages ${STUDIO_VERSION}. ` +
+    `Update magpie-gemini-web instead of using the backend admin's online updater. ` +
+    `To restore ${STUDIO_VERSION}, run: ${studioCommand('stop', { dataDir: local.dataDir })}; ` +
+    `after it stops, back up ${local.dataDir}, then run: ${studioCommand('install', { dataDir: local.dataDir })}; ` +
+    `then ${studioCommand('start', { dataDir: local.dataDir })}. ` +
+    `Existing data files are kept, but an older backend may not read data migrated by a newer release.`);
+}
+
 // stopOutdated stops an earlier install of the service that is still running, so the pinned
 // version can be installed and started in its place.
 async function stopOutdated(local, health, options) {
@@ -1071,29 +1226,35 @@ export async function stopStudio(options = {}) {
     throw new Error(`Cannot stop unknown or foreign process listening on port ${local.port}`);
   }
 
-  let pid = NaN;
-  try {
-    pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
-  } catch {}
-
-  let alive = Number.isInteger(pid) && pid > 0;
-  if (alive) {
+  let pid = recordedPid(dataDir);
+  const bin = binaryPath(dataDir, platform);
+  let alive = processAlive(pid) && verifyProcessIdentity(pid, bin, platform);
+  let discoveryError;
+  let discovered = [];
+  if (!alive) {
+    fs.rmSync(pidFile, { force: true });
+    // Upstream's Windows updater starts a new PID. Recover only an executable
+    // at this installation's exact path; never signal a port owner by name alone.
     try {
-      process.kill(pid, 0);
-    } catch {
-      alive = false;
-    }
+      const candidates = health.state === 'down'
+        ? studioProcessPids(bin, platform)
+        : studioListenerPids(local.port, platform);
+      discovered = candidates;
+      const verified = candidates.filter(p => processAlive(p) && verifyProcessIdentity(p, bin, platform));
+      if (verified.length === 1) {
+        pid = verified[0];
+        alive = true;
+        fs.writeFileSync(pidFile, `${pid}\n`, { mode: 0o600 });
+      }
+    } catch (err) { discoveryError = err.message; }
   }
 
-  // Without a live process in backend.pid there is nothing this setup can signal. That only
-  // means stopped when nothing answers on the port either.
   if (!alive) {
     fs.rmSync(pidFile, { force: true });
-    if (health.state === 'down') return { stopped: true };
-    return { stopped: false, reported: `AIStudio2API still answers on port ${local.port}, but ${pidFile} names no running process; end it yourself` };
+    if (health.state === 'down' && !discoveryError && discovered.length === 0) return { stopped: true };
+    return { stopped: false, reported: `Cannot identify a verified AIStudio2API process for port ${local.port}. Wait for any update/restart to finish, then retry: ${studioCommand('stop', { dataDir })}. ${discoveryError ? `Process inspection failed: ${discoveryError}` : 'Check the listener PID and its executable path if this persists.'}` };
   }
 
-  const bin = binaryPath(dataDir, platform);
   if (!verifyProcessIdentity(pid, bin, platform)) {
     throw new Error(`Process ${pid} does not match expected binary path ${bin}; refusal to signal unverified process`);
   }
@@ -1103,7 +1264,7 @@ export async function stopStudio(options = {}) {
     throw new Error(`Cannot stop unknown or foreign process listening on port ${local.port}`);
   }
 
-  if (health.state === 'up' || health.state === 'outdated') {
+  if (health.state === 'up' || health.state === 'outdated' || health.state === 'version_conflict') {
     try {
       await studioAdmin(local, 'POST', '/api/control/stop', null, { fetchFn, timeoutMs: 5000 });
     } catch {}
@@ -1133,5 +1294,17 @@ export async function stopStudio(options = {}) {
   }
 
   fs.rmSync(pidFile, { force: true });
+  // A pooled HTTP connection may reset just after the process exits (especially
+  // on Windows). Wait for a confirmed refusal, without treating a reset as proof
+  // that the port is free or overlooking a replacement listener.
+  let after = await checkStudioHealth(local, fetchFn);
+  const closeDeadline = Date.now() + 5000;
+  while (after.state === 'unresponsive' && Date.now() < closeDeadline) {
+    await sleep(150);
+    after = await checkStudioHealth(local, fetchFn);
+  }
+  if (after.state !== 'down') {
+    return { stopped: false, reported: `Port ${local.port} is not confirmed closed (${after.state}: ${after.reason || 'service responds'}); retry: ${studioCommand('stop', { dataDir })}` };
+  }
   return { stopped: true };
 }

package/lib/studio-release.json

@@ -1,27 +1,38 @@
 {
-  "version": "0.2.12",
-  "repository": "Mag1cFall/AIStudio2API",
-  "tag": "v0.2.12",
+  "version": "0.2.13-magpie.1",
+  "repository": "BUKOWSKIREAL/magpie-gemini-web",
+  "tag": "studio-v0.2.13-magpie.1",
+  "goVersion": "1.27.1",
+  "upstream": {
+    "version": "0.2.13",
+    "repository": "https://github.com/Mag1cFall/AIStudio2API.git",
+    "commit": "a784c5193b3ba5c4894d536b2f4cd73e87f99475"
+  },
   "binaries": {
-    "darwin-x64": {
-      "asset": "aistudio2api-v0.2.12-darwin-amd64.tar.gz",
-      "sha256": "d7700be498293539c551671c582c4112997873593dcea6dee5cf9f23562f0331"
-    },
     "darwin-arm64": {
-      "asset": "aistudio2api-v0.2.12-darwin-arm64.tar.gz",
-      "sha256": "a24bdc093e024e6c5d737ebdaed719c9cf5d6418c4f2edbf907f3c2979a9bb63"
+      "asset": "aistudio2api-v0.2.13-magpie.1-darwin-arm64.tar.gz",
+      "sha256": "3145f1fc3e88dafc1c43ecfa4ed7c6f82d1126a2d8add02605d05f1c5c404144",
+      "binarySha256": "7d727bf1cc5a86d9c1a2a99d73d645f38a0597489ef62e2bf20b0d33dd87369d"
+    },
+    "darwin-x64": {
+      "asset": "aistudio2api-v0.2.13-magpie.1-darwin-amd64.tar.gz",
+      "sha256": "96994351570105a6de4e1c95800231ad20d762ee010cfa238bfef11101124c27",
+      "binarySha256": "428963b5bd3c9c35b88c7a7f29923c5a5a6bef5d0fcd511274daa8a8ebc9f686"
     },
     "linux-x64": {
-      "asset": "aistudio2api-v0.2.12-linux-amd64.tar.gz",
-      "sha256": "fa2de6053b2bf8c8188cef39751a31bd0f88a07c67f34ad59a8bce29b0069b6a"
+      "asset": "aistudio2api-v0.2.13-magpie.1-linux-amd64.tar.gz",
+      "sha256": "9e24fb139abb0bcd8f6cbab23ac1875136f3ecacd30919fbcc25fe342feb369c",
+      "binarySha256": "de8c25f07870d83dd2ebc03b9be1f6e15b4f93f454dfe8f5c4182c72261bcbfa"
     },
     "linux-arm64": {
-      "asset": "aistudio2api-v0.2.12-linux-arm64.tar.gz",
-      "sha256": "32c9cbe63fa0b864f201e917aaa2c9b3b5a2be6c3f7734ad4f2328df7ed5e19c"
+      "asset": "aistudio2api-v0.2.13-magpie.1-linux-arm64.tar.gz",
+      "sha256": "7b7057abd8e298685f4ca835e014a48c9b1904a253ebfbc053e4b1d7712c532c",
+      "binarySha256": "151fd830cf0da8801d49e448021d73cde0adb51e982b3a8604cdcbc5babd21c4"
     },
     "win32-x64": {
-      "asset": "aistudio2api-v0.2.12-windows-amd64.zip",
-      "sha256": "e03235bc5aecc6e81c2c609ca4cc010afb6b88ce98ac87934603a59fe625b493"
+      "asset": "aistudio2api-v0.2.13-magpie.1-windows-amd64.zip",
+      "sha256": "aa337556362ce9c16cae71117a9c12e20b623b12665dd5f36cf01bf152d72fbb",
+      "binarySha256": "4a0c32be722dcc27c9046fe410d6af7efd576c4192cb1158c84468cada4fbd30"
     }
   }
 }