set-agent-provider 0.1.0

package/src/adapters/dsh.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const path = require('path');
+const { home } = require('../util/paths');
+const { exists, readText, writeText } = require('../util/fs');
+
+const ID = 'dsh';
+const NAMESPACE = 'llm-pi-ai';
+
+function settingsFile() { return path.join(home(), '.dsh', 'settings.yaml'); }
+function credsFile() { return path.join(home(), '.dsh', '.credentials.yaml'); }
+
+function yq(v) {
+  return "'" + String(v).replace(/'/g, "''") + "'";
+}
+
+function credentialRef(name) {
+  let n = String(name).replace(/[^A-Za-z0-9_]/g, '_').toUpperCase();
+  if (!/^[A-Za-z_]/.test(n)) n = 'P_' + n;
+  return n + '_API_KEY';
+}
+
+function topKey(line) {
+  const m = /^([^\s:#][^:]*):(\s|$)/.exec(line);
+  return m ? m[1] : null;
+}
+
+function upsertNamespace(text, key, innerYaml) {
+  const lines = (text || '').split(/\r?\n/);
+  while (lines.length && lines[lines.length - 1].trim() === '') lines.pop();
+
+  const result = [];
+  let done = false;
+  let i = 0;
+  while (i < lines.length) {
+    if (topKey(lines[i]) === key) {
+      result.push(key + ':');
+      for (const bl of innerYaml.split('\n')) result.push(bl === '' ? '' : '  ' + bl);
+      i++;
+      while (i < lines.length && topKey(lines[i]) === null) i++;
+      done = true;
+      continue;
+    }
+    result.push(lines[i]);
+    i++;
+  }
+  if (!done) {
+    if (result.length) result.push('');
+    result.push(key + ':');
+    for (const bl of innerYaml.split('\n')) result.push(bl === '' ? '' : '  ' + bl);
+  }
+  return result.join('\n') + '\n';
+}
+
+function buildProviderYaml(ctx, ref) {
+  const out = [];
+  out.push('providers:');
+  out.push('  ' + ctx.name + ':');
+  out.push('    displayName: ' + yq(ctx.name));
+  out.push('    api: ' + yq('openai-completions'));
+  out.push('    baseURL: ' + yq(String(ctx.baseUrl).replace(/\/+$/, '')));
+  out.push('    apiKeyEnv: ' + yq(ref));
+  out.push('    models:');
+  for (const m of ctx.models) {
+    out.push('      - id: ' + yq(m.id));
+    out.push('        name: ' + yq(m.name));
+    if (m.limit && m.limit.context != null) out.push('        contextWindow: ' + Number(m.limit.context));
+    if (m.limit && m.limit.output != null) out.push('        maxTokens: ' + Number(m.limit.output));
+  }
+  return out.join('\n');
+}
+
+function buildDefaultModelYaml(ctx) {
+  return ['provider: ' + yq(ctx.name), 'model: ' + yq(ctx.defaultModel)].join('\n');
+}
+
+function unquoteScalar(s) {
+  s = String(s).trim();
+  if (s.length >= 2 && s[0] === "'" && s[s.length - 1] === "'") return s.slice(1, -1).replace(/''/g, "'");
+  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') return s.slice(1, -1);
+  return s;
+}
+
+function parseCreds(text) {
+  const refs = {};
+  const records = [];
+  let section = null;
+  for (const line of (text || '').split(/\r?\n/)) {
+    const k = topKey(line);
+    if (k) {
+      section = k;
+      continue;
+    }
+    if (section === 'refs') {
+      const m = /^\s+([A-Za-z0-9_]+)\s*:\s*(.+?)\s*$/.exec(line);
+      if (m) refs[m[1]] = unquoteScalar(m[2]);
+    } else if (section === 'records') {
+      records.push(line);
+    }
+  }
+  return { refs: refs, recordsRaw: records.join('\n').replace(/^\n+|\s+$/g, '') };
+}
+
+function writeCreds(refs, recordsRaw) {
+  let out = 'version: 1\nrefs:\n';
+  for (const k of Object.keys(refs)) out += '  ' + k + ': ' + yq(refs[k]) + '\n';
+  if (recordsRaw) out += 'records:\n' + recordsRaw + '\n';
+  return out;
+}
+
+function write(ctx) {
+  const sf = settingsFile();
+  const cf = credsFile();
+  const ref = credentialRef(ctx.name);
+
+  let settings = exists(sf) ? readText(sf) : '';
+  settings = upsertNamespace(settings, NAMESPACE, buildProviderYaml(ctx, ref));
+  settings = upsertNamespace(settings, 'agent-default-model', buildDefaultModelYaml(ctx));
+  let changed = writeText(sf, settings);
+
+  if (ctx.apiKey) {
+    let credsText = exists(cf) ? readText(cf) : '';
+    const parsed = parseCreds(credsText);
+    parsed.refs[ref] = ctx.apiKey;
+    if (writeText(cf, writeCreds(parsed.refs, parsed.recordsRaw))) changed = true;
+  }
+
+  return changed;
+}
+
+function readStatus() {
+  const sf = settingsFile();
+  if (!exists(sf)) return null;
+  const text = readText(sf);
+  const dmMatch = text.match(/agent-default-model:\s*\n\s+provider:\s*'?([^'\n]+)'?\s*\n\s+model:\s*'?([^'\n]+)'?/);
+  if (!dmMatch) return null;
+  const provider = dmMatch[1].trim();
+  const model = dmMatch[2].trim();
+  const baseMatch = text.match(new RegExp(provider.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ':\\s*\\n(?:\\s+.*\\n)*?\\s+baseURL:\\s*\'?([^\'\\n]+)'));
+  return {
+    configured: true,
+    name: provider,
+    baseUrl: baseMatch ? baseMatch[1].trim() : null,
+    defaultModel: model,
+    modelCount: 1
+  };
+}
+
+module.exports = {
+  id: ID,
+  name: 'dsh',
+  configPaths: ['~/.dsh/settings.yaml', '~/.dsh'],
+  supports: { reasoning: false, limit: true },
+  writeFiles: function () { return [settingsFile(), credsFile()]; },
+  write: write,
+  readStatus: readStatus,
+  credentialRef: credentialRef
+};

package/src/adapters/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const opencode = require('./opencode');
+const claude = require('./claude');
+const codex = require('./codex');
+const pi = require('./pi');
+const dsh = require('./dsh');
+
+const adapters = [claude, codex, opencode, pi, dsh];
+
+function getAdapter(id) {
+  return adapters.find(function (a) { return a.id === id; }) || null;
+}
+
+module.exports = { adapters, getAdapter };

package/src/adapters/opencode.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const path = require('path');
+const { home } = require('../util/paths');
+const { exists, readJson, writeJson } = require('../util/fs');
+
+const ID = 'opencode';
+
+function file() {
+  return path.join(home(), '.config', 'opencode', 'opencode.json');
+}
+
+function write(ctx) {
+  const f = file();
+  let cfg = {};
+  if (exists(f)) {
+    try { cfg = readJson(f); } catch (e) { cfg = {}; }
+  }
+  if (!cfg.provider || typeof cfg.provider !== 'object') cfg.provider = {};
+
+  const provider = {
+    name: ctx.name,
+    npm: '@ai-sdk/openai-compatible',
+    options: { baseURL: trimTrailing(ctx.baseUrl) }
+  };
+  if (ctx.apiKey) provider.options.apiKey = ctx.apiKey;
+
+  if (ctx.models && ctx.models.length) {
+    const models = {};
+    for (const m of ctx.models) {
+      const entry = { name: m.name };
+      if (m.reasoning) entry.reasoning = true;
+      if (m.limit && (m.limit.context != null || m.limit.output != null)) {
+        entry.limit = {};
+        if (m.limit.context != null) entry.limit.context = m.limit.context;
+        if (m.limit.output != null) entry.limit.output = m.limit.output;
+      }
+      models[m.id] = entry;
+    }
+    provider.models = models;
+  }
+
+  cfg.provider[ctx.name] = provider;
+  if (ctx.defaultModel) cfg.model = ctx.name + '/' + ctx.defaultModel;
+  return writeJson(f, cfg);
+}
+
+function readStatus() {
+  const f = file();
+  if (!exists(f)) return null;
+  let cfg;
+  try { cfg = readJson(f); } catch (e) { return null; }
+  if (!cfg.model || typeof cfg.model !== 'string') return null;
+  const name = cfg.model.split('/')[0];
+  const p = cfg.provider && cfg.provider[name];
+  if (!p) return null;
+  return {
+    configured: true,
+    name: name,
+    baseUrl: p.options && p.options.baseURL,
+    defaultModel: cfg.model.split('/').slice(1).join('/'),
+    modelCount: p.models ? Object.keys(p.models).length : 0
+  };
+}
+
+function trimTrailing(s) {
+  return String(s).replace(/\/+$/, '');
+}
+
+module.exports = {
+  id: ID,
+  name: 'OpenCode',
+  configPaths: ['~/.config/opencode/opencode.json', '~/.config/opencode'],
+  supports: { reasoning: true, limit: true },
+  writeFiles: function () { return [file()]; },
+  write: write,
+  readStatus: readStatus
+};

package/src/adapters/pi.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const path = require('path');
+const { home } = require('../util/paths');
+const { exists, readJson, writeJson } = require('../util/fs');
+
+const ID = 'pi';
+
+function file() {
+  return path.join(home(), '.pi', 'agent', 'models.json');
+}
+
+function trim(s) {
+  return String(s).replace(/\/+$/, '');
+}
+
+function write(ctx) {
+  const f = file();
+  let cfg = {};
+  if (exists(f)) {
+    try { cfg = readJson(f); } catch (e) { cfg = {}; }
+  }
+  if (!cfg.providers || typeof cfg.providers !== 'object') cfg.providers = {};
+
+  const provider = {
+    name: ctx.name,
+    baseUrl: trim(ctx.baseUrl),
+    api: 'openai-completions'
+  };
+  if (ctx.apiKey) provider.apiKey = ctx.apiKey;
+
+  if (ctx.models && ctx.models.length) {
+    provider.models = ctx.models.map(function (m) {
+      const entry = { id: m.id, name: m.name };
+      if (m.reasoning) entry.reasoning = true;
+      if (m.limit && m.limit.context != null) entry.contextWindow = m.limit.context;
+      if (m.limit && m.limit.output != null) entry.maxTokens = m.limit.output;
+      return entry;
+    });
+  }
+
+  cfg.providers[ctx.name] = provider;
+  return writeJson(f, cfg);
+}
+
+function readStatus() {
+  const f = file();
+  if (!exists(f)) return null;
+  let cfg;
+  try { cfg = readJson(f); } catch (e) { return null; }
+  const providers = (cfg && cfg.providers) || {};
+  const names = Object.keys(providers);
+  if (!names.length) return null;
+  const name = names[names.length - 1];
+  const p = providers[name];
+  return {
+    configured: true,
+    name: name,
+    baseUrl: p.baseUrl,
+    defaultModel: null,
+    modelCount: p.models ? p.models.length : 0
+  };
+}
+
+module.exports = {
+  id: ID,
+  name: 'pi',
+  configPaths: ['~/.pi/agent/models.json', '~/.pi'],
+  supports: { reasoning: true, limit: true },
+  writeFiles: function () { return [file()]; },
+  write: write,
+  readStatus: readStatus
+};

package/src/apply.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { resolveTargets } = require('./discover');
+const { backupFile, localTimestamp } = require('./backup');
+const { setBackupHook } = require('./util/fs');
+
+async function applyProvider(cfg, opts) {
+  opts = opts || {};
+  const resolved = resolveTargets(opts.targetArg);
+  const interactive = Boolean(opts.interactive);
+  const results = [];
+
+  for (const adapter of resolved.selected) {
+    try {
+      let extra = {};
+      if (typeof adapter.resolveOptions === 'function') {
+        extra = (await adapter.resolveOptions({
+          baseUrl: cfg.baseUrl,
+          apiKey: cfg.apiKey,
+          models: cfg.models,
+          defaultModel: opts.defaultModel,
+          interactive: interactive
+        })) || {};
+      }
+
+      const ts = localTimestamp(new Date());
+      const backedUp = [];
+      setBackupHook(function (file) {
+        const dest = backupFile(file, ts);
+        if (dest) backedUp.push(dest);
+      });
+
+      let changed;
+      try {
+        changed = adapter.write(Object.assign({
+          name: cfg.name,
+          baseUrl: cfg.baseUrl,
+          apiKey: cfg.apiKey,
+          models: cfg.models,
+          defaultModel: opts.defaultModel
+        }, extra));
+      } finally {
+        setBackupHook(null);
+      }
+
+      results.push({
+        id: adapter.id,
+        name: adapter.name,
+        ok: true,
+        changed: changed !== false,
+        backedUp: backedUp,
+        detection: extra.detection,
+        wireApi: extra.wireApi
+      });
+    } catch (e) {
+      setBackupHook(null);
+      results.push({ id: adapter.id, name: adapter.name, ok: false, error: e.message });
+    }
+  }
+
+  for (const m of resolved.missing) {
+    results.push({ id: m, name: m, ok: false, skipped: true, error: 'Not installed / unknown target' });
+  }
+
+  return { results: results, selected: resolved.selected, missing: resolved.missing };
+}
+
+module.exports = { applyProvider };

package/src/backup.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const fs = require('fs');
+
+function localTimestamp(d) {
+  const p = function (n) { return String(n).padStart(2, '0'); };
+  return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) +
+    '_' + p(d.getHours()) + '-' + p(d.getMinutes()) + '-' + p(d.getSeconds());
+}
+
+function backupFile(file, ts) {
+  if (!fs.existsSync(file)) return null;
+  const dest = file + '.bak-' + ts;
+  fs.copyFileSync(file, dest);
+  return dest;
+}
+
+function backupFiles(files) {
+  const ts = localTimestamp(new Date());
+  const backedUp = [];
+  for (const file of files) {
+    const dest = backupFile(file, ts);
+    if (dest) backedUp.push(dest);
+  }
+  return backedUp;
+}
+
+module.exports = { backupFiles, backupFile, localTimestamp };

package/src/cli/args.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const SPEC = {
+  '--name': 'name', '--baseUrl': 'baseUrl', '--baseurl': 'baseUrl',
+  '--apiKey': 'apiKey', '--apikey': 'apiKey',
+  '--models': 'models', '--target': 'target', '--config': 'config',
+  '--domain': 'domain', '--status': 'status', '--help': 'help',
+  '--version': 'version',
+  '-N': 'name', '-U': 'baseUrl', '-K': 'apiKey', '-M': 'models',
+  '-T': 'target', '-C': 'config', '-D': 'domain', '-h': 'help', '-v': 'version'
+};
+
+const FLAGS = { status: true, help: true, version: true };
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    let key = tok;
+    let val = null;
+    if (tok.indexOf('--') === 0 && tok.indexOf('=') !== -1) {
+      const idx = tok.indexOf('=');
+      key = tok.slice(0, idx);
+      val = tok.slice(idx + 1);
+    }
+    const field = SPEC[key];
+    if (!field) {
+      throw new Error('Unknown option: ' + tok);
+    }
+    if (FLAGS[field]) {
+      out[field] = true;
+      continue;
+    }
+    if (val == null) val = argv[++i];
+    if (val == null || val === '') {
+      throw new Error('Missing value for ' + key);
+    }
+    out[field] = val;
+  }
+  return out;
+}
+
+module.exports = { parseArgs };

package/src/cli/help.js

@@ -0,0 +1,33 @@
+'use strict';
+
+function printHelp() {
+  const text = [
+    'set-agent-provider — configure a model provider across all installed AI CLIs',
+    '',
+    'Usage:',
+    '  set-agent-provider [options]',
+    '',
+    'Options:',
+    '  -N, --name <name>        Provider name (default: hostname of baseUrl)',
+    '  -U, --baseUrl <url>      Provider base URL (required; prompted if omitted interactively)',
+    '  -K, --apiKey <key>       Provider API key (optional; prompted if omitted, may be blank)',
+    '  -M, --models <json>      Models as strict JSON array',
+    '  -T, --target <list>      Comma-separated targets (claude,codex,opencode,pi,dsh)',
+    '  -C, --config <source>    Config source: file path, URL, or bare domain',
+    '  -D, --domain <domain>    Auto-detect from a bare domain (config, then POST /v1/chat/completions)',
+    '      --status             Show current provider config for each installed CLI',
+    '  -h, --help               Show this help',
+    '  -v, --version            Show version',
+    '',
+    'Examples:',
+    '  set-agent-provider -N foo -U https://api.example.com/v1 -K sk-xxx \\',
+    '    -M \'[{"id":"gpt-5.6-sol","name":"GPT-5.6 SOL","reasoning":true,"limit":{"context":272000,"output":128000}}]\'',
+    '  set-agent-provider -C ./config.json',
+    '  set-agent-provider -C https://example.com/set-agent-provider-config.json -T opencode',
+    '  set-agent-provider -D api.deepseek.com -K sk-xxx',
+    ''
+  ].join('\n');
+  process.stdout.write(text + '\n');
+}
+
+module.exports = { printHelp: printHelp };

package/src/cli/prompt.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const readline = require('readline');
+const { maskKey } = require('../output');
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function ask(question, defaultValue) {
+  return new Promise(function (resolve) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const q = defaultValue ? question + ' [' + defaultValue + ']: ' : question + ': ';
+    rl.question(q, function (ans) {
+      rl.close();
+      const v = String(ans).trim();
+      resolve(v || defaultValue || '');
+    });
+  });
+}
+
+function askYes(question, def) {
+  return new Promise(function (resolve) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question + ' [' + (def ? 'Y/n' : 'y/N') + ']: ', function (ans) {
+      rl.close();
+      const v = String(ans).trim().toLowerCase();
+      if (!v) return resolve(Boolean(def));
+      resolve(v === 'y' || v === 'yes');
+    });
+  });
+}
+
+async function askBaseUrl() {
+  if (!isInteractive()) return null;
+  let baseUrl = '';
+  while (!baseUrl) {
+    baseUrl = await ask('Base URL (e.g. https://api.example.com/v1)');
+    if (!baseUrl) process.stdout.write('Base URL is required.\n');
+  }
+  return baseUrl;
+}
+
+async function askApiKey(reason) {
+  if (!isInteractive()) return undefined;
+  const label = reason
+    ? 'API key (' + reason + ', optional, Enter to skip)'
+    : 'API key (optional, Enter to skip)';
+  const value = await ask(label);
+  return value || undefined;
+}
+
+async function confirm(cfg) {
+  if (!isInteractive()) return true;
+  process.stdout.write('\n');
+  process.stdout.write('  Name   : ' + cfg.name + '\n');
+  process.stdout.write('  BaseUrl: ' + cfg.baseUrl + '\n');
+  process.stdout.write('  API Key: ' + (cfg.apiKey ? maskKey(cfg.apiKey) : '(none)') + '\n\n');
+  return askYes('Apply this configuration?', true);
+}
+
+module.exports = {
+  isInteractive: isInteractive,
+  ask: ask,
+  askYes: askYes,
+  askBaseUrl: askBaseUrl,
+  askApiKey: askApiKey,
+  confirm: confirm
+};

package/src/config/baseurl.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { loadConfigSource } = require('./load');
+const { resolveDomain } = require('../domain/resolve');
+const { isInteractive, askBaseUrl } = require('../cli/prompt');
+
+async function resolveBaseUrl(args) {
+  if (args.config && args.domain) {
+    throw new Error('Use either -C/--config or -D/--domain, not both.');
+  }
+
+  let config = null;
+  let domainBase = null;
+
+  if (args.config) {
+    config = await loadConfigSource(args.config);
+  } else if (args.domain) {
+    const resolved = await resolveDomain(args.domain, {
+      probe: args.baseUrl == null,
+      apiKey: args.apiKey
+    });
+    config = resolved.config;
+    domainBase = resolved.baseUrl;
+  }
+
+  let baseUrl = null;
+  let source = null;
+  if (args.baseUrl != null) {
+    baseUrl = String(args.baseUrl).trim();
+    source = 'flag';
+  } else if (config && config.baseUrl) {
+    baseUrl = String(config.baseUrl).trim();
+    source = 'config';
+  } else if (domainBase) {
+    baseUrl = domainBase;
+    source = 'domain';
+  } else if (isInteractive()) {
+    baseUrl = await askBaseUrl();
+    source = 'prompt';
+  }
+
+  if (!baseUrl) {
+    throw new Error('baseUrl is required. Provide -U/--baseUrl, a config source, or run interactively.');
+  }
+
+  return { baseUrl: baseUrl, config: config, source: source };
+}
+
+module.exports = { resolveBaseUrl: resolveBaseUrl };

package/src/config/load.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('fs');
+const { get } = require('../util/http');
+const { normalizeConfig } = require('./schema');
+
+const CONFIG_PATH = '/set-agent-provider-config.json';
+
+async function loadConfigSource(source) {
+  if (!source) return {};
+  if (/^https?:\/\//i.test(source)) {
+    return normalizeConfig(await fetchConfigUrl(source));
+  }
+  if (fs.existsSync(source)) {
+    return normalizeConfig(parseJson(fs.readFileSync(source, 'utf8'), source));
+  }
+  const domain = String(source).replace(/\/+$/, '');
+  let lastErr;
+  for (const scheme of ['https', 'http']) {
+    try {
+      return normalizeConfig(await fetchConfigUrl(scheme + '://' + domain + CONFIG_PATH));
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw new Error('Could not load config from "' + source + '"' + (lastErr ? ' (' + lastErr.message + ')' : ''));
+}
+
+async function fetchConfigUrl(url) {
+  let res;
+  try {
+    res = await get(url, { headers: { Accept: 'application/json' } });
+  } catch (e) {
+    throw new Error('Failed to fetch ' + url + ': ' + e.message);
+  }
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error('Config fetch returned HTTP ' + res.status + ' for ' + url);
+  }
+  return parseJson(res.body, url);
+}
+
+function parseJson(text, label) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new Error('Invalid JSON' + (label ? ' in ' + label : '') + ': ' + e.message);
+  }
+}
+
+module.exports = { loadConfigSource: loadConfigSource, CONFIG_PATH: CONFIG_PATH };

package/src/config/name.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function hostOf(baseUrl) {
+  if (!baseUrl) return null;
+  try {
+    return new URL(baseUrl).hostname || null;
+  } catch (e) {
+    return String(baseUrl).replace(/\/+$/, '') || null;
+  }
+}
+
+function resolveName(args, config, baseUrl) {
+  if (args.name != null) return args.name;
+  if (config && config.name) return config.name;
+  return hostOf(baseUrl) || 'local';
+}
+
+module.exports = { resolveName: resolveName, hostOf: hostOf };