@yeaft/webchat-agent 0.1.942 → 0.1.944

package/cli.js

@@ -11,6 +11,15 @@ import { readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { platform, homedir } from 'os';
+import {
+  addOrUpdateProvider,
+  formatLlmConfig,
+  getDefaultYeaftConfigPath,
+  readLocalLlmConfig,
+  removeProvider,
+  setLocalModels,
+  writeLocalLlmConfig,
+} from './llm-config-cli.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
@@ -24,6 +33,8 @@ const SERVICE_COMMANDS = ['install', 'uninstall', 'start', 'stop', 'restart', 's
 
 if (command === 'doctor') {
   handleDoctorCommand();
+} else if (command === 'llm') {
+  handleLlmCommand(subArgs);
 } else if (command === 'upgrade') {
   upgrade();
 } else if (command === '--version' || command === '-v') {
@@ -51,6 +62,7 @@ function printHelp() {
     yeaft-agent status                 Show service status
     yeaft-agent logs                   View service logs (follow mode)
     yeaft-agent doctor                 Diagnose service configuration
+    yeaft-agent llm <command>          Configure local Yeaft LLM providers/models
     yeaft-agent upgrade                Upgrade to latest version
     yeaft-agent --version              Show version
 
@@ -75,6 +87,104 @@ function printHelp() {
 `);
 }
 
+function printLlmHelp() {
+  console.log(`
+  Configure local Yeaft LLM providers/models in ~/.yeaft/config.json.
+
+  Usage:
+    yeaft-agent llm show [--reveal]
+    yeaft-agent llm add-provider --name <name> --base-url <url> --models <m1,m2> \
+      [--api-key <key>|--api-key-env <ENV>|--credential-provider github-copilot] \
+      [--protocol anthropic|openai-responses] [--set-primary <model>] [--set-fast <model>]
+    yeaft-agent llm set-model [--primary <provider/model>] [--fast <provider/model>]
+    yeaft-agent llm remove-provider --name <name>
+
+  Behavior:
+    add-provider updates/replaces an existing provider with the same --name.
+    --api-key-env reads the environment variable value and writes it as apiKey.
+    set-model requires full provider/model references.
+    --config <path> can target a config file for tests or scripted setup.
+
+  Examples:
+    OPENAI_KEY=sk-... yeaft-agent llm add-provider --name openai --base-url https://api.openai.com/v1 --models gpt-5,gpt-4.1 --api-key-env OPENAI_KEY --protocol openai-responses --set-primary gpt-5
+    yeaft-agent llm add-provider --name copilot --base-url https://api.githubcopilot.com --models claude-sonnet-4.5,gpt-5 --credential-provider github-copilot
+    yeaft-agent llm set-model --primary openai/gpt-5 --fast openai/gpt-4.1
+    yeaft-agent llm show --reveal
+`);
+}
+
+function handleLlmCommand(args) {
+  const subcommand = args[0];
+
+  try {
+    const options = parseLlmArgs(args.slice(1));
+    const configPath = options.config || getDefaultYeaftConfigPath();
+    if (!subcommand || subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
+      printLlmHelp();
+      return;
+    }
+
+    if (subcommand === 'show') {
+      const config = readLocalLlmConfig(configPath);
+      console.log(formatLlmConfig({ ...config, __configPath: configPath }, { reveal: Boolean(options.reveal) }));
+      return;
+    }
+
+    const current = readLocalLlmConfig(configPath);
+    let result;
+    if (subcommand === 'add-provider') {
+      result = addOrUpdateProvider(current, options, process.env);
+      writeLocalLlmConfig(result.config, configPath);
+      console.log(`${result.replaced ? 'Updated' : 'Added'} provider: ${result.provider.name}`);
+      if (result.config.primaryModel) console.log(`Primary model: ${result.config.primaryModel}`);
+      if (result.config.fastModel) console.log(`Fast model: ${result.config.fastModel}`);
+      return;
+    }
+
+    if (subcommand === 'set-model') {
+      result = setLocalModels(current, options);
+      writeLocalLlmConfig(result.config, configPath);
+      if (result.config.primaryModel) console.log(`Primary model: ${result.config.primaryModel}`);
+      if (result.config.fastModel) console.log(`Fast model: ${result.config.fastModel}`);
+      return;
+    }
+
+    if (subcommand === 'remove-provider') {
+      result = removeProvider(current, options);
+      writeLocalLlmConfig(result.config, configPath);
+      console.log(result.removed ? `Removed provider: ${options.name}` : `Provider not found: ${options.name}`);
+      if (result.cleared.length) {
+        console.log(`Cleared ${result.cleared.join(', ')} because it referenced ${options.name}`);
+      }
+      return;
+    }
+
+    throw new Error(`Unknown llm command: ${subcommand}`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.error('Run `yeaft-agent llm --help` for usage.');
+    process.exit(1);
+  }
+}
+
+function parseLlmArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--reveal') {
+      options.reveal = true;
+      continue;
+    }
+    const key = arg.startsWith('--') ? arg.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase()) : null;
+    if (!key) throw new Error(`Unexpected argument: ${arg}`);
+    const value = args[i + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value`);
+    options[key] = value;
+    i += 1;
+  }
+  return options;
+}
+
 async function handleServiceCommand(command, args) {
   const service = await import('./service.js');
   switch (command) {

package/connection/message-router.js

@@ -335,27 +335,9 @@ export async function handleMessage(msg) {
       break;
     }
 
-    // LLM configuration (read/write ~/.yeaft/config.json)
+    // LLM configuration (read/write this agent's ~/.yeaft/config.json)
     case 'get_llm_config': {
-      if (msg.globalConfig && typeof msg.globalConfig === 'object') {
-        ctx.globalLlmConfig = msg.globalConfig;
-      }
-      const config = getLlmConfig(ctx.CONFIG?.yeaftDir, ctx.globalLlmConfig);
-      sendToServer({ type: 'llm_config', ...config });
-      break;
-    }
-
-    case 'llm_global_config_updated': {
-      ctx.globalLlmConfig = msg.globalConfig && typeof msg.globalConfig === 'object'
-        ? msg.globalConfig
-        : { providers: [] };
-      // Existing sessions cache AdapterRouter instances. Drop them so the
-      // next Yeaft turn sees the new global providers, without writing them
-      // to the node-local config.json.
-      resetYeaftSession().catch(err => {
-        console.error('[LLM] Failed to reload Yeaft session after global config update:', err.message);
-      });
-      const config = getLlmConfig(ctx.CONFIG?.yeaftDir, ctx.globalLlmConfig);
+      const config = getLlmConfig(ctx.CONFIG?.yeaftDir);
       sendToServer({ type: 'llm_config', ...config });
       break;
     }
@@ -369,10 +351,7 @@ export async function handleMessage(msg) {
       const incomingLanguage = typeof msg.config?.language === 'string' && msg.config.language
         ? msg.config.language
         : null;
-      if (msg.globalConfig && typeof msg.globalConfig === 'object') {
-        ctx.globalLlmConfig = msg.globalConfig;
-      }
-      const result = updateLlmConfig(msg.config || {}, ctx.CONFIG?.yeaftDir, ctx.globalLlmConfig);
+      const result = updateLlmConfig(msg.config || {}, ctx.CONFIG?.yeaftDir);
       // task-708: live locale propagation. When the user flips the UI
       // language dropdown, push the new value into every cached Engine
       // (per-VP pool + 1:1 chat session.engine) so the very next turn

package/context.js

@@ -18,8 +18,6 @@ export default {
   slashCommandDescriptions: {},
   // MCP servers 列表 (从 ~/.claude.json 读取): [{ name, enabled, source }]
   mcpServers: [],
-  // Server-owned user-global LLM providers. Runtime-only: never persisted to ~/.yeaft/config.json.
-  globalLlmConfig: { providers: [] },
   // 连接相关
   reconnectTimer: null,
   pendingAuthTempId: null,

package/llm-config-cli.js

@@ -0,0 +1,196 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+
+const VALID_PROTOCOLS = new Set(['anthropic', 'openai-responses']);
+const VALID_CREDENTIAL_PROVIDERS = new Set(['github-copilot']);
+
+export function getDefaultYeaftConfigPath() {
+  return join(homedir(), '.yeaft', 'config.json');
+}
+
+export function readLocalLlmConfig(configPath = getDefaultYeaftConfigPath()) {
+  if (!existsSync(configPath)) return {};
+  const raw = readFileSync(configPath, 'utf8');
+  if (!raw.trim()) return {};
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Invalid config file: expected JSON object at ${configPath}`);
+  }
+  return parsed;
+}
+
+export function writeLocalLlmConfig(config, configPath = getDefaultYeaftConfigPath()) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+
+export function parseModelsCsv(value) {
+  if (!value || typeof value !== 'string') {
+    throw new Error('--models is required and must be a comma-separated list');
+  }
+  const models = value.split(',').map(s => s.trim()).filter(Boolean);
+  if (models.length === 0) {
+    throw new Error('--models must include at least one model id');
+  }
+  return models;
+}
+
+export function maskApiKey(value) {
+  if (!value) return value;
+  if (value.length <= 8) return '********';
+  return `${value.slice(0, 4)}…${value.slice(-4)}`;
+}
+
+export function formatLlmConfig(config, { reveal = false } = {}) {
+  const providers = Array.isArray(config.providers) ? config.providers : [];
+  const lines = [];
+  lines.push(`Config: ${config.__configPath || getDefaultYeaftConfigPath()}`);
+  lines.push(`Primary model: ${config.primaryModel || '(not set)'}`);
+  lines.push(`Fast model: ${config.fastModel || '(not set)'}`);
+  lines.push('Providers:');
+
+  if (providers.length === 0) {
+    lines.push('  (none)');
+    return lines.join('\n');
+  }
+
+  for (const provider of providers) {
+    lines.push(`  - ${provider.name}`);
+    lines.push(`    baseUrl: ${provider.baseUrl || '(not set)'}`);
+    if (provider.protocol) lines.push(`    protocol: ${provider.protocol}`);
+    if (provider.credentialProvider) {
+      lines.push(`    credentialProvider: ${provider.credentialProvider}`);
+    } else if (provider.apiKey) {
+      lines.push(`    apiKey: ${reveal ? provider.apiKey : maskApiKey(provider.apiKey)}`);
+    } else {
+      lines.push('    apiKey: (not set)');
+    }
+    const models = Array.isArray(provider.models) ? provider.models.map(formatModelEntry) : [];
+    lines.push(`    models: ${models.length ? models.join(', ') : '(none)'}`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatModelEntry(model) {
+  if (typeof model === 'string') return model;
+  if (model && typeof model === 'object' && model.id) {
+    return model.protocol ? `${model.id} (${model.protocol})` : model.id;
+  }
+  return String(model);
+}
+
+export function addOrUpdateProvider(config, options, env = process.env) {
+  const name = requireNonEmpty(options.name, '--name');
+  const baseUrl = requireNonEmpty(options.baseUrl, '--base-url');
+  const models = parseModelsCsv(options.models);
+  validateProtocol(options.protocol);
+  validateCredentials(options, env);
+
+  const next = { ...config };
+  const providers = Array.isArray(config.providers) ? [...config.providers] : [];
+  const provider = {
+    name,
+    baseUrl,
+    models,
+  };
+  if (options.protocol) provider.protocol = options.protocol;
+  if (options.credentialProvider) provider.credentialProvider = options.credentialProvider;
+  if (options.apiKey) provider.apiKey = options.apiKey;
+  if (options.apiKeyEnv) provider.apiKey = env[options.apiKeyEnv];
+
+  const index = providers.findIndex(p => p && p.name === name);
+  if (index >= 0) providers[index] = provider;
+  else providers.push(provider);
+  next.providers = providers;
+
+  if (options.setPrimary) next.primaryModel = qualifyModelRef(options.setPrimary, name);
+  if (options.setFast) next.fastModel = qualifyModelRef(options.setFast, name);
+
+  return {
+    config: next,
+    replaced: index >= 0,
+    provider,
+  };
+}
+
+export function setLocalModels(config, options) {
+  const hasPrimary = Boolean(options.primary);
+  const hasFast = Boolean(options.fast);
+  if (!hasPrimary && !hasFast) {
+    throw new Error('set-model requires --primary and/or --fast');
+  }
+  const next = { ...config };
+  if (hasPrimary) next.primaryModel = requireFullModelRef(options.primary, '--primary');
+  if (hasFast) next.fastModel = requireFullModelRef(options.fast, '--fast');
+  return { config: next };
+}
+
+export function removeProvider(config, options) {
+  const name = requireNonEmpty(options.name, '--name');
+  const next = { ...config };
+  const providers = Array.isArray(config.providers) ? config.providers : [];
+  const kept = providers.filter(p => !p || p.name !== name);
+  const removed = kept.length !== providers.length;
+  next.providers = kept;
+
+  const cleared = [];
+  if (pointsAtProvider(next.primaryModel, name)) {
+    delete next.primaryModel;
+    cleared.push('primaryModel');
+  }
+  if (pointsAtProvider(next.fastModel, name)) {
+    delete next.fastModel;
+    cleared.push('fastModel');
+  }
+
+  return { config: next, removed, cleared };
+}
+
+export function qualifyModelRef(model, providerName) {
+  const value = requireNonEmpty(model, 'model');
+  return value.includes('/') ? value : `${providerName}/${value}`;
+}
+
+function requireFullModelRef(model, flagName) {
+  const value = requireNonEmpty(model, flagName);
+  if (!value.includes('/')) {
+    throw new Error(`${flagName} must be a full provider/model reference`);
+  }
+  return value;
+}
+
+function pointsAtProvider(modelRef, providerName) {
+  return typeof modelRef === 'string' && modelRef.startsWith(`${providerName}/`);
+}
+
+function requireNonEmpty(value, label) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`${label} is required`);
+  }
+  return value.trim();
+}
+
+function validateProtocol(protocol) {
+  if (protocol && !VALID_PROTOCOLS.has(protocol)) {
+    throw new Error(`--protocol must be one of: ${Array.from(VALID_PROTOCOLS).join(', ')}`);
+  }
+}
+
+function validateCredentials(options, env) {
+  const credentialCount = [options.apiKey, options.apiKeyEnv, options.credentialProvider]
+    .filter(Boolean).length;
+  if (credentialCount > 1) {
+    throw new Error('--api-key, --api-key-env, and --credential-provider are mutually exclusive');
+  }
+  if (options.credentialProvider && !VALID_CREDENTIAL_PROVIDERS.has(options.credentialProvider)) {
+    throw new Error(`--credential-provider must be one of: ${Array.from(VALID_CREDENTIAL_PROVIDERS).join(', ')}`);
+  }
+  if (options.apiKeyEnv) {
+    const envName = options.apiKeyEnv;
+    if (!env[envName]) {
+      throw new Error(`Environment variable ${envName} is not set`);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.942",
+  "version": "0.1.944",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/config-api.js

@@ -13,7 +13,6 @@ import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { normalizeProviderModels, serializeModelForPersistence } from './models.js';
 import { normaliseYeaftSection } from './config.js';
-import { mergeLlmConfigs } from './llm/provider-merge.js';
 
 /**
  * Read the LLM-relevant portion of config.json.
@@ -41,15 +40,13 @@ function readLocalLlmConfig(dir) {
   };
 }
 
-export function getLlmConfig(dir, globalConfig = {}) {
+export function getLlmConfig(dir) {
   try {
     const agentConfig = readLocalLlmConfig(dir);
-    const effectiveConfig = mergeLlmConfigs(globalConfig, agentConfig);
     return {
-      ...effectiveConfig,
+      ...agentConfig,
       agentConfig,
-      effectiveConfig,
-      globalConfig: { providers: Array.isArray(globalConfig.providers) ? globalConfig.providers : [] },
+      effectiveConfig: agentConfig,
     };
   } catch (e) {
     return { error: `Failed to read config.json: ${e.message}` };
@@ -64,7 +61,7 @@ export function getLlmConfig(dir, globalConfig = {}) {
  * @param {string} [dir] — Yeaft data directory
  * @returns {{ providers, primaryModel, fastModel, language } | { error: string }}
  */
-export function updateLlmConfig(update, dir, globalConfig = {}) {
+export function updateLlmConfig(update, dir) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
 
@@ -132,12 +129,10 @@ export function updateLlmConfig(update, dir, globalConfig = {}) {
     fastModel: existing.fastModel || null,
     language: existing.language || 'en',
   };
-  const effectiveConfig = mergeLlmConfigs(globalConfig, agentConfig);
   return {
-    ...effectiveConfig,
+    ...agentConfig,
     agentConfig,
-    effectiveConfig,
-    globalConfig: { providers: Array.isArray(globalConfig.providers) ? globalConfig.providers : [] },
+    effectiveConfig: agentConfig,
   };
 }
 

package/yeaft/config.js

@@ -23,7 +23,6 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
-import { mergeLlmConfigs } from './llm/provider-merge.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
@@ -295,39 +294,36 @@ export function loadConfig(overrides = {}) {
   }
 
   // ─── Build config from config.json ────────────────────────
-  const agentProviders = Array.isArray(jsonConfig.providers) ? jsonConfig.providers : [];
-  const mergedLlmConfig = mergeLlmConfigs(overrides.globalLlmConfig || {}, {
-    providers: agentProviders,
-    primaryModel: jsonConfig.primaryModel || null,
-    fastModel: jsonConfig.fastModel || null,
-    language: jsonConfig.language || DEFAULTS.language,
-  });
-  const providers = mergedLlmConfig.providers;
+  const providers = Array.isArray(jsonConfig.providers) ? jsonConfig.providers : [];
 
   // Resolve primary model
   let model = 'claude-sonnet-4-20250514';
   let modelIdForInfo = model;
-  let primaryModel = mergedLlmConfig.primaryModel || null;
+  let primaryModel = jsonConfig.primaryModel || null;
   if (primaryModel) {
     const parsed = parseModelRef(primaryModel);
-    model = parsed.providerName?.startsWith('global:') ? primaryModel : parsed.modelId;
+    // Global provider refs were removed. Old local config may still contain
+    // `global:<provider>/<model>` from previous UI versions; strip the dead
+    // namespace so runtime routing can match agent-local providers by model id.
+    const isRemovedGlobalRef = parsed.providerName?.startsWith('global:');
+    model = parsed.modelId;
+    if (isRemovedGlobalRef) primaryModel = parsed.modelId;
     modelIdForInfo = parsed.modelId;
   }
 
   // Resolve fast model
-  let fastModel = mergedLlmConfig.fastModel || primaryModel || null;
+  let fastModel = jsonConfig.fastModel || primaryModel || null;
   let fastModelId = null;
   if (fastModel) {
     const parsed = parseModelRef(fastModel);
-    fastModelId = parsed.providerName?.startsWith('global:') ? fastModel : parsed.modelId;
+    fastModel = parsed.providerName?.startsWith('global:') ? parsed.modelId : fastModel;
+    fastModelId = parsed.modelId;
   }
 
   // Resolve model info for adapter/baseUrl/thinking metadata. Token limits
   // (contextWindow / maxOutputTokens) are NOT read from here — they live in
   // models.dev and are resolved via resolveContextWindow / resolveMaxOutputTokens
   // a few lines below so the live models.dev snapshot is the source of truth.
-  // For disambiguated global provider refs (`global:<provider>/<model>`), keep
-  // the runtime model ref intact above but resolve metadata by the raw model id.
   const modelInfo = resolveModel(modelIdForInfo);
 
   // Pre-resolve token limits once so we can both write them onto config and

package/yeaft/web-bridge.js

@@ -2716,7 +2716,6 @@ async function ensureSessionLoaded() {
   const yeaftDir = ctx.CONFIG?.yeaftDir;
   session = await loadSession({
     ...(yeaftDir && { dir: yeaftDir }),
-    configOverrides: { globalLlmConfig: ctx.globalLlmConfig || { providers: [] } },
     skipMCP: false,
     skipSkills: false,
     serverMode: true,
@@ -3842,7 +3841,6 @@ export async function handleYeaftLoadHistory(msg) {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
-      configOverrides: { globalLlmConfig: ctx.globalLlmConfig || { providers: [] } },
       skipMCP: false,
       skipSkills: false,
       serverMode: true,
@@ -4158,7 +4156,6 @@ export async function resetYeaftSession() {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
-      configOverrides: { globalLlmConfig: ctx.globalLlmConfig || { providers: [] } },
       skipMCP: false,
       skipSkills: false,
       serverMode: true,

package/yeaft/llm/provider-merge.js

@@ -1,53 +0,0 @@
-function cloneProvider(provider, scope) {
-  return {
-    ...provider,
-    scope,
-    source: scope,
-    originalName: provider.name,
-    models: Array.isArray(provider.models)
-      ? provider.models.map(m => (m && typeof m === 'object' ? { ...m } : m))
-      : [],
-  };
-}
-
-function modelId(entry) {
-  if (typeof entry === 'string') return entry;
-  if (entry && typeof entry === 'object' && typeof entry.id === 'string') return entry.id;
-  return '';
-}
-
-export function buildModelRef(provider, entry) {
-  const id = modelId(entry);
-  return provider?.name && id ? `${provider.name}/${id}` : id;
-}
-
-export function mergeLlmConfigs(globalConfig = {}, agentConfig = {}) {
-  const agentProviders = Array.isArray(agentConfig.providers)
-    ? agentConfig.providers.map(p => cloneProvider(p, 'agent'))
-    : [];
-  const localNames = new Set(agentProviders.map(p => p.name).filter(Boolean));
-  const usedNames = new Set(localNames);
-  const globalProviders = [];
-
-  for (const raw of Array.isArray(globalConfig.providers) ? globalConfig.providers : []) {
-    if (!raw?.name) continue;
-    const provider = cloneProvider(raw, 'global');
-    if (usedNames.has(provider.name)) {
-      let candidate = `global:${provider.name}`;
-      let i = 2;
-      while (usedNames.has(candidate)) candidate = `global:${provider.name}:${i++}`;
-      provider.name = candidate;
-    }
-    usedNames.add(provider.name);
-    globalProviders.push(provider);
-  }
-
-  const providers = [...globalProviders, ...agentProviders];
-  return {
-    providers,
-    primaryModel: agentConfig.primaryModel || null,
-    fastModel: agentConfig.fastModel || null,
-    language: agentConfig.language || 'en',
-    needsSetup: providers.length === 0 || providers.every(p => (!p.apiKey || p.apiKey === 'proxy') && !p.credentialProvider && !p.githubToken),
-  };
-}