llm-tuner 0.4.3 → 0.5.0

package/src/cli/commands/help.js

@@ -4,4 +4,5 @@ import { t as translate } from '../../i18n/index.js';
 export async function helpCommand(args, { lang }) {
   const t = (key, params) => translate(lang, key, params);
   console.log(t('cli.help', { presetsDir: presetsDir() }));
+  console.log(t('cli.serverConnectionHelp'));
 }

package/src/cli/commands/load.js

@@ -18,6 +18,8 @@ import { profileChoices, profileNotes, profileSwitchNote, profileEventLines, sho
 import { getColors } from '../colors.js';
 import { withNav, NAV_BACK, backChoice } from '../nav.js';
 import { TerminalAnimation } from '../animation.js';
+import { createOllamaAuthorizer } from '../../platform/ollama-authorize.js';
+import { TunerApiClient } from '../../core/client.js';
 
 export async function loadCommand(args, { lang, theme }) {
   const c = getColors(theme);
@@ -63,12 +65,26 @@ export async function loadCommand(args, { lang, theme }) {
     out(c.dim(`    ${t('cli.updateCommand', { cmd: 'npm install -g llm-tuner' })}\n`));
   }
 
-  const hw = await detectHardware();
-  out(c.dim(`  ${hw.cpu.brand} · ${fmtBytes(hw.ram.totalBytes)} RAM`));
-  for (const g of hw.gpus) out(c.dim(`  GPU${g.index} ${g.name} · ${fmtBytes(g.totalBytes)}${g.pcieGen ? ` · PCIe ${g.pcieGen}.0 x${g.pcieWidth}` : ''}${g.displayAttached ? t('cli.display') : ''}`));
-  if (!hw.gpus.length) out(c.y(`  ${t('cli.noGpu')}`));
+  const settings = await readSettings();
+  const isRemote = settings.activeServerId !== 'local';
+  let client = null;
+  let hw;
+  let det;
+
+  if (isRemote) {
+    client = TunerApiClient.fromSettings(settings);
+    const state = await client.getState();
+    hw = state.hw;
+    det = state;
+  } else {
+    hw = await detectHardware();
+    det = await detectEngines(hw);
+  }
 
-  let det = await detectEngines(hw);
+  const cpuTitle = hw.cpu?.brand || (hw.cpu?.physicalCores ? `${hw.cpu.physicalCores} cores` : 'CPU');
+  out(c.dim(`  ${cpuTitle} · ${fmtBytes(hw.ram?.totalBytes)} RAM`));
+  for (const g of (hw.gpus || [])) out(c.dim(`  GPU${g.index} ${g.name} · ${fmtBytes(g.totalBytes)}${g.pcieGen ? ` · PCIe ${g.pcieGen}.0 x${g.pcieWidth}` : ''}${g.displayAttached ? t('cli.display') : ''}`));
+  if (!hw.gpus?.length) out(c.y(`  ${t('cli.noGpu')}`));
   let engineId = args.engine;
   let tuner = null;
   let models = [];
@@ -104,14 +120,20 @@ export async function loadCommand(args, { lang, theme }) {
       currentStep = 2;
     }
     else if (currentStep === 2) {
-      if (!tuner || tuner.engine.id !== engineId) {
-        if (!det.engines.find((e) => e.id === engineId)?.detection.installed) {
-          await installFlow(engineId, { args, t, c });
-          det = await detectEngines(hw);
-          if (!det.engines.find((e) => e.id === engineId).detection.installed) throw new TunerError('errors.installNotFinished');
+      if (!tuner || tuner.engine?.id !== engineId) {
+        if (isRemote) {
+          const res = await client.listModels(engineId);
+          models = res.models || [];
+          tuner = { engine: { id: engineId, name: engineId } };
+        } else {
+          if (!det.engines.find((e) => e.id === engineId)?.detection.installed) {
+            await installFlow(engineId, { args, t, c });
+            det = await detectEngines(hw);
+            if (!det.engines.find((e) => e.id === engineId).detection.installed) throw new TunerError('errors.installNotFinished');
+          }
+          tuner = await Tuner.create(engineId);
+          models = await tuner.listModels();
         }
-        tuner = await Tuner.create(engineId);
-        models = await tuner.listModels();
       }
 
       if (args.model) {
@@ -289,26 +311,54 @@ export async function loadCommand(args, { lang, theme }) {
 
   let result;
   try {
-    result = await tuner.load(modelKey, ctx, {
-      profile,
-      force: !!args.force,
-      dryRun: !!args['dry-run'],
-      maxCandidates: Number(args.candidates) || 3,
-      confirmApply: async (preview) => {
-        anim.stop();
-        out(c.b(`\n${t('cli.changes')}`));
-        if (engineId === 'lmstudio') {
-          preview.files.forEach((f) => out(`  ${f}`));
-          if (preview.restartsApp) out(c.y(`  ${t('cli.lmsRestart')}`));
-        } else {
-          out(`  ${t('cli.ollamaNewModel', { name: c.b(preview.tunedModel) })}`);
-          out(`  ${t('cli.ollamaServer', { env: Object.entries(preview.env).map(([k, v]) => `${k}=${v}`).join(' ') })}`);
-        }
-        const confirmed = args.yes || await confirm({ message: t('cli.confirmApply'), default: true });
-        if (confirmed) anim.start(t('status.applying'));
-        return confirmed;
-      },
-    });
+    if (isRemote) {
+      result = await client.loadModel({
+        engine: engineId,
+        model: modelKey,
+        ctx,
+        profile,
+        force: !!args.force,
+        candidates: Number(args.candidates) || 3,
+      }, (e) => {
+        if (e.type === 'progress') anim.update(e);
+        if (e.type === 'log') out(c.dim('  ' + e.line));
+      });
+    } else {
+      result = await tuner.load(modelKey, ctx, {
+        authorizeOllama: createOllamaAuthorizer({
+          mode: process.stdin.isTTY && process.stderr.isTTY && !args.json ? 'terminal' : 'noninteractive',
+          beforePrompt: () => anim.stop(),
+          afterPrompt: () => anim.start(t('status.applying')),
+        }),
+        profile,
+        force: !!args.force,
+        dryRun: !!args['dry-run'],
+        maxCandidates: Number(args.candidates) || 3,
+        confirmApply: async (preview) => {
+          anim.stop();
+          out(c.b(`\n${t('cli.changes')}`));
+          if (engineId === 'lmstudio') {
+            preview.files.forEach((f) => out(`  ${f}`));
+            if (preview.restartsApp) out(c.y(`  ${t('cli.lmsRestart')}`));
+          } else {
+            out(`  ${t('cli.ollamaNewModel', { name: c.b(preview.tunedModel) })}`);
+            out(`  ${t('cli.ollamaServer', { env: Object.entries(preview.env).map(([k, v]) => `${k}=${v}`).join(' ') })}`);
+          }
+          const confirmed = args.yes || await confirm({ message: t('cli.confirmApply'), default: true });
+          if (confirmed) anim.start(t('status.applying'));
+          return confirmed;
+        },
+      });
+    }
+  } catch (e) {
+    if (!/^errors\.ollama(?:Service|Authorization)/.test(e.code || '')) throw e;
+    if (args.json) {
+      console.log(JSON.stringify({ ok: false, code: e.code, params: e.params || {}, error: t(e.code, e.params) }));
+      process.exitCode = 1;
+      return;
+    }
+    e.message = t(e.code, e.params);
+    throw e;
   } finally {
     anim.stop();
   }

package/src/cli/commands/mcp.js

@@ -1,5 +1,5 @@
 import { select, checkbox, input, Separator } from '@inquirer/prompts';
-import { detectHardware, detectEngines, detectAgents, installMcpServer } from '../../core/index.js';
+import { detectHardware, detectEngines, detectAgents, installMcpServer, readSettings } from '../../core/index.js';
 import { t as translate } from '../../i18n/index.js';
 import { getColors } from '../colors.js';
 import { withNav, NAV_BACK, backChoice } from '../nav.js';
@@ -93,11 +93,25 @@ export async function mcpCommand(args, { lang, theme }) {
   }
 
   // Install MCP server configuration
+  let targetHost = args.host;
+  if (!targetHost) {
+    const settings = await readSettings().catch(() => null);
+    const activeSrv = (settings?.servers || []).find((s) => s.id === settings?.activeServerId);
+    if (activeSrv && activeSrv.id !== 'local' && activeSrv.url) {
+      try {
+        const hostname = new URL(activeSrv.url).hostname;
+        if (hostname && hostname !== '127.0.0.1' && hostname !== 'localhost') {
+          targetHost = engineId === 'lmstudio' ? `http://${hostname}:1234/v1` : `http://${hostname}:11434`;
+        }
+      } catch {}
+    }
+  }
+
   const result = await installMcpServer({
     engineId,
     customName,
     agentIds: selectedAgents,
-    host: args.host,
+    host: targetHost,
     apiKey: args.apiKey,
   });
 

package/src/cli/commands/presets.js

@@ -1,4 +1,5 @@
-import { listPresets } from '../../core/index.js';
+import { listPresets, readSettings } from '../../core/index.js';
+import { TunerApiClient } from '../../core/client.js';
 import { t as translate } from '../../i18n/index.js';
 import { getColors } from '../colors.js';
 
@@ -6,7 +7,16 @@ export async function presetsCommand(args, { lang, theme }) {
   const c = getColors(theme);
   const t = (key, params) => translate(lang, key, params);
 
-  const list = await listPresets({ engine: args.engine, modelKey: args.model });
+  const settings = await readSettings();
+  let list = [];
+  if (settings.activeServerId !== 'local') {
+    const client = TunerApiClient.fromSettings(settings);
+    const data = await client.listPresets({ engine: args.engine, model: args.model });
+    list = data.presets || [];
+  } else {
+    list = await listPresets({ engine: args.engine, modelKey: args.model });
+  }
+
   if (!list.length) {
     console.log(t('cli.noPresets'));
     return;

package/src/cli/commands/serve.js

@@ -0,0 +1,59 @@
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { configDir, readJson, resolveConnectableHost } from '../../core/util.js';
+import { startServer } from '../../web/server.js';
+
+export function serverConfigPath() {
+  return path.join(configDir(), 'server.json');
+}
+
+export async function readServerConfig() {
+  try {
+    return await readJson(serverConfigPath(), null);
+  } catch {
+    return null;
+  }
+}
+
+export async function writeServerConfig(cfg) {
+  await fs.mkdir(configDir(), { recursive: true });
+  await fs.writeFile(
+    serverConfigPath(),
+    JSON.stringify(cfg, null, 2),
+    'utf8'
+  );
+}
+
+export async function serveCommand(args = {}) {
+  const host = args.host || '0.0.0.0';
+  const port = args.port !== undefined ? Number(args.port) : 7860;
+
+  const existingConfig = await readServerConfig();
+  const token = args.token || existingConfig?.token || randomBytes(32).toString('hex');
+
+  await writeServerConfig({ port, host, token });
+
+  const serverResult = await startServer({
+    port,
+    host,
+    token,
+    serverMode: true,
+  });
+
+  const displayHost = resolveConnectableHost(host);
+  const resolvedPort = serverResult.port || port;
+  const connectableUrl = `http://${displayHost}:${resolvedPort}`;
+
+  console.log(`LLM Tuner server mode running on ${connectableUrl}`);
+  console.log(`Authentication Token: ${token}`);
+
+  return {
+    server: serverResult.server,
+    url: connectableUrl,
+    port: resolvedPort,
+    host,
+    connectableHost: displayHost,
+    token,
+  };
+}

package/src/cli/commands/settings.js

@@ -1,19 +1,35 @@
 import { select } from '@inquirer/prompts';
-import { writeSettings } from '../../core/index.js';
+import { writeSettings, resolveConnectableHost } from '../../core/index.js';
 import { t as translate } from '../../i18n/index.js';
+import { createServerAutostart } from '../../platform/server-autostart.js';
+import { serverConfigPath, readServerConfig } from './serve.js';
 import { getColors } from '../colors.js';
 import { withNav, NAV_BACK, backChoice } from '../nav.js';
 
-export async function settingsCommand(args, { lang, theme }) {
+export async function settingsCommand(args, { lang, theme }, dependencies = {}) {
+  const {
+    selectPrompt = select,
+    autostart = createServerAutostart({ configPath: serverConfigPath() }),
+    readConfig = readServerConfig
+  } = dependencies;
   const c = getColors(theme);
   const t = (key, params) => translate(lang, key, params);
+  let startupEnabled;
+  try {
+    startupEnabled = await autostart.status();
+  } catch (e) {
+    startupEnabled = null;
+    console.error(c.y(t('cli.autostartFailed', { error: e.message })));
+  }
 
   while (true) {
-    const action = await withNav(() => select({
+    const action = await withNav(() => selectPrompt({
       message: t('cli.settingsMenu'),
       choices: [
         { name: `${t('cli.settingsLanguage')}: ${lang === 'es' ? 'Español' : 'English'} (${lang})`, value: 'lang' },
         { name: `${t('cli.settingsTheme')}: ${theme.charAt(0).toUpperCase() + theme.slice(1)}`, value: 'theme' },
+        { name: `${t('cli.settingsAutostart')}: ${t(startupEnabled === null ? 'cli.unknown' : startupEnabled ? 'cli.enabled' : 'cli.disabled')}`, value: 'serverAutostart' },
+        { name: t('cli.serverConnection'), value: 'serverConnection' },
         { name: t('cli.settingsExit'), value: 'exit' },
       ],
     }));
@@ -24,7 +40,7 @@ export async function settingsCommand(args, { lang, theme }) {
     }
 
     if (action === 'lang') {
-      const res = await withNav(() => select({
+      const res = await withNav(() => selectPrompt({
         message: t('cli.settingsLanguage'),
         default: lang,
         choices: [
@@ -42,7 +58,7 @@ export async function settingsCommand(args, { lang, theme }) {
         }
       }
     } else if (action === 'theme') {
-      const res = await withNav(() => select({
+      const res = await withNav(() => selectPrompt({
         message: t('cli.settingsTheme'),
         default: theme,
         choices: [
@@ -60,6 +76,45 @@ export async function settingsCommand(args, { lang, theme }) {
           console.error(c.y(t('cli.themeNotSaved', { error: e.message })));
         }
       }
+    } else if (action === 'serverAutostart') {
+      const enabled = startupEnabled === true;
+      const res = await withNav(() => selectPrompt({
+        message: t('cli.settingsAutostart'),
+        default: enabled,
+        choices: [
+          { name: t('cli.settingsAutostartEnable'), value: true },
+          { name: t('cli.settingsAutostartDisable'), value: false },
+          backChoice(t, c),
+        ],
+      }));
+      if (res !== NAV_BACK) {
+        try {
+          const updated = await autostart.setEnabled(res);
+          if (updated !== res) throw new Error('The operating system did not confirm the requested startup state.');
+          startupEnabled = res;
+          console.log(c.g(t(res ? 'cli.autostartEnabled' : 'cli.autostartDisabled')));
+        } catch (e) {
+          console.error(c.y(t('cli.autostartFailed', { error: e.message })));
+        }
+      }
+    } else if (action === 'serverConnection') {
+      try {
+        const cfg = await readConfig();
+        if (!cfg) {
+          console.log(c.y(t('cli.serverNoConfig')));
+        } else {
+          const isValid = typeof cfg.host === 'string' && cfg.host.length > 0 &&
+                          Number.isInteger(cfg.port) && cfg.port >= 1 && cfg.port <= 65535 &&
+                          typeof cfg.token === 'string' && cfg.token.length > 0;
+          if (!isValid) {
+            throw new Error(t('cli.serverConnectionInvalid'));
+          }
+          const displayHost = resolveConnectableHost(cfg.host);
+          console.log(t('cli.serverConnectionDetails', { host: displayHost, port: cfg.port, token: cfg.token }));
+        }
+      } catch (e) {
+        console.error(c.y(t('common.error', { message: e.message })));
+      }
     }
   }
 }

package/src/cli/router.js

@@ -4,6 +4,7 @@ import { t as translate, LOCALES, errorText } from '../i18n/index.js';
 import { loadCommand } from './commands/load.js';
 import { mcpCommand } from './commands/mcp.js';
 import { presetsCommand } from './commands/presets.js';
+import { serveCommand } from './commands/serve.js';
 import { settingsCommand } from './commands/settings.js';
 import { helpCommand } from './commands/help.js';
 import { withNav } from './nav.js';
@@ -30,6 +31,10 @@ export function parseCliArgs(argv) {
       command = 'presets';
       continue;
     }
+    if (a === '/serve' || a === 'serve') {
+      command = 'serve';
+      continue;
+    }
     if (a === '/settings' || a === 'settings' || a === '/setting' || a === 'setting') {
       command = 'settings';
       args.settings = true;
@@ -62,6 +67,10 @@ export function parseCliArgs(argv) {
         command = 'presets';
         continue;
       }
+      if (k === 'serve') {
+        command = 'serve';
+        continue;
+      }
       if (k === 'help') {
         args.help = true;
         command = 'help';
@@ -131,6 +140,20 @@ export async function routeCli(argv, env = {}) {
     }
   }
 
+  if ('server' in args) {
+    const s = await readSettings();
+    const target = s.servers.find((srv) => srv.id === args.server || srv.name === args.server);
+    if (!target) {
+      console.error(`Unknown server "${args.server}". Valid servers: ${s.servers.map((x) => x.id).join(', ')}`);
+      return 1;
+    }
+    try {
+      await writeSettings({ activeServerId: target.id });
+    } catch (e) {
+      console.error(`Warning: ${e.message}`);
+    }
+  }
+
   if (command === 'version' || args.version) {
     console.log(CURRENT_VERSION);
     return 0;
@@ -141,6 +164,11 @@ export async function routeCli(argv, env = {}) {
     return 0;
   }
 
+  if (command === 'serve') {
+    await serveCommand(args);
+    return 0;
+  }
+
   // Interactive menu mode when run bare (persistent loop until /exit)
   if (command === 'menu') {
     const isInteractive = process.stdin.isTTY || env.forceInteractive;
@@ -163,6 +191,7 @@ export async function routeCli(argv, env = {}) {
             { name: `/load     ${activeT('cli.cmdLoadDesc')}`, value: 'load' },
             { name: `/mcp      ${activeT('cli.cmdMcpDesc')}`, value: 'mcp' },
             { name: `/presets  ${activeT('cli.cmdPresetsDesc')}`, value: 'presets' },
+            { name: `/serve    ${activeT('cli.cmdServeDesc')}`, value: 'serve' },
             { name: `/settings ${activeT('cli.cmdSettingsDesc')}`, value: 'settings' },
             { name: `/help     ${activeT('cli.cmdHelpDesc')}`, value: 'help' },
             { name: `/exit     ${activeT('cli.cmdExitDesc')}`, value: 'exit' },
@@ -190,6 +219,9 @@ export async function routeCli(argv, env = {}) {
           case 'presets':
             await presetsCommand(args, { lang: currentLang, theme: currentTheme });
             break;
+          case 'serve':
+            await serveCommand(args);
+            break;
           case 'settings':
             await settingsCommand(args, { lang: currentLang, theme: currentTheme });
             {

package/src/cli/server-login.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { serveCommand } from './commands/serve.js';
+
+function validConfig(config) {
+  return config && typeof config === 'object' && !Array.isArray(config)
+    && typeof config.host === 'string' && config.host.length > 0
+    && Number.isInteger(config.port) && config.port > 0 && config.port <= 65535
+    && typeof config.token === 'string' && config.token.length > 0;
+}
+
+export async function startSavedServer({ configDir, environment = process.env, readConfig, start = serveCommand } = {}) {
+  if (!configDir) throw new Error('A configuration directory is required to start the saved server.');
+  environment.LLM_TUNER_CONFIG_DIR = configDir;
+  const config = readConfig
+    ? await readConfig()
+    : await fs.readFile(path.join(configDir, 'server.json'), 'utf8').then(JSON.parse).catch((error) => {
+      throw new Error(`Could not read the saved server configuration at ${configDir}: ${error.message}`);
+    });
+  if (!validConfig(config)) throw new Error(`The saved server configuration at ${configDir} is invalid; the server was not started.`);
+  const options = { host: config.host, port: config.port, token: config.token };
+  if (start !== serveCommand) return start(options);
+  // Manual /serve prints the token; a login launcher must not leak it to startup logs.
+  const log = console.log;
+  console.log = () => {};
+  try {
+    return await start(options);
+  } finally {
+    console.log = log;
+  }
+}
+
+function configDirectoryFrom(argv) {
+  const index = argv.indexOf('--config-dir');
+  const value = index >= 0 ? argv[index + 1] : null;
+  if (!value) throw new Error('Missing --config-dir for the login-started server.');
+  return value;
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
+  startSavedServer({ configDir: configDirectoryFrom(process.argv.slice(2)) }).catch((error) => {
+    console.error(`Could not start the login-configured server: ${error.message}`);
+    process.exitCode = 1;
+  });
+}

package/src/core/client.js

@@ -0,0 +1,127 @@
+import { getActiveServer } from './settings.js';
+
+export class TunerApiClient {
+  constructor({ baseUrl = 'http://127.0.0.1:7860', token = null } = {}) {
+    this.baseUrl = String(baseUrl || '').replace(/\/+$/, '');
+    this.token = token;
+  }
+
+  async _request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { ...options.headers };
+
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`;
+    }
+
+    if (options.body && typeof options.body === 'object') {
+      headers['Content-Type'] = 'application/json';
+      options.body = JSON.stringify(options.body);
+    }
+
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      let errMessage = `HTTP ${response.status}: ${response.statusText}`;
+      let errCode = null;
+      try {
+        const errJson = await response.json();
+        if (errJson?.error) errMessage = errJson.error;
+        if (errJson?.code) errCode = errJson.code;
+      } catch {}
+      const err = new Error(errMessage);
+      err.status = response.status;
+      if (errCode) err.code = errCode;
+      throw err;
+    }
+
+    return response.json();
+  }
+
+  async getState() {
+    return this._request('/api/state');
+  }
+
+  async listModels(engine) {
+    const query = engine ? `?engine=${encodeURIComponent(engine)}` : '';
+    return this._request(`/api/models${query}`);
+  }
+
+  async planModel({ engine, model, ctx }) {
+    return this._request('/api/plan', {
+      method: 'POST',
+      body: { engine, model, ctx },
+    });
+  }
+
+  async listPresets({ engine, model } = {}) {
+    const params = new URLSearchParams();
+    if (engine) params.set('engine', engine);
+    if (model) params.set('model', model);
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/presets${query}`);
+  }
+
+  async chat({ engine, model, messages }) {
+    return this._request('/api/chat', {
+      method: 'POST',
+      body: { engine, model, messages },
+    });
+  }
+
+  async loadModel({ engine, model, ctx, profile, force, candidates }, onProgress) {
+    const { jobId } = await this._request('/api/load', {
+      method: 'POST',
+      body: { engine, model, ctx, profile, force, candidates },
+    });
+
+    if (!onProgress) return { jobId };
+
+    const response = await fetch(`${this.baseUrl}/api/jobs/${jobId}/events`, {
+      headers: this.token ? { 'Authorization': `Bearer ${this.token}` } : {},
+    });
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data: ')) continue;
+
+          const data = JSON.parse(trimmed.slice(6));
+          if (typeof onProgress === 'function') {
+            onProgress(data);
+          }
+
+          if (data.type === 'finished') {
+            if (data.ok === false) {
+              const err = new Error(data.error || 'Job failed');
+              if (data.code) err.code = data.code;
+              throw err;
+            }
+            return data.result;
+          }
+        }
+      }
+    } finally {
+      await reader.cancel();
+    }
+  }
+
+  static fromSettings(settings) {
+    const active = getActiveServer(settings);
+    return new TunerApiClient({
+      baseUrl: active.url,
+      token: active.token,
+    });
+  }
+}