set-agent-provider 0.1.0

package/src/config/resolve.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { resolveBaseUrl } = require('./baseurl');
+const { resolveName } = require('./name');
+const { parseModels } = require('./schema');
+const { askApiKey } = require('../cli/prompt');
+const { fetchModels } = require('../models/fetch');
+const { multiSelect } = require('../models/select');
+
+async function resolveConfig(args) {
+  const resolved = await resolveBaseUrl(args);
+  const config = resolved.config;
+  const baseUrl = resolved.baseUrl;
+
+  const apiKey = await resolveApiKey(args, config);
+  const models = await resolveModels(args, config, baseUrl, apiKey);
+  const name = resolveName(args, config, baseUrl);
+
+  return {
+    name: name,
+    baseUrl: baseUrl,
+    apiKey: apiKey,
+    models: models
+  };
+}
+
+async function resolveApiKey(args, config) {
+  if (args.apiKey != null) return args.apiKey;
+  if (config && config.apiKey) return config.apiKey;
+  return askApiKey();
+}
+
+async function resolveModels(args, config, baseUrl, apiKey) {
+  if (args.models != null) return parseModelsArg(args.models);
+  if (config && config.models) return config.models;
+
+  const fetched = await fetchModels(baseUrl, apiKey);
+  if (!fetched.length) {
+    throw new Error('No models returned from ' + baseUrl + ' (use -M/--models to provide them).');
+  }
+  const picked = await multiSelect(fetched);
+  if (!picked.length) {
+    throw new Error('No models selected.');
+  }
+  return parseModels(picked);
+}
+
+function parseModelsArg(str) {
+  let raw;
+  try {
+    raw = JSON.parse(str);
+  } catch (e) {
+    throw new Error('Invalid JSON for --models: ' + e.message);
+  }
+  return parseModels(raw);
+}
+
+module.exports = { resolveConfig: resolveConfig };

package/src/config/schema.js

@@ -0,0 +1,47 @@
+'use strict';
+
+function normalizeConfig(cfg) {
+  if (!cfg || typeof cfg !== 'object') {
+    throw new Error('Config must be an object');
+  }
+  const out = {
+    name: typeof cfg.name === 'string' && cfg.name ? cfg.name.trim() : null,
+    baseUrl: typeof cfg.baseUrl === 'string' && cfg.baseUrl ? cfg.baseUrl.trim() : null,
+    apiKey: typeof cfg.apiKey === 'string' && cfg.apiKey ? cfg.apiKey : undefined,
+    models: cfg.models != null ? parseModels(cfg.models) : undefined
+  };
+  return out;
+}
+
+function parseModels(models) {
+  let arr;
+  if (Array.isArray(models)) {
+    arr = models;
+  } else if (typeof models === 'object') {
+    arr = Object.keys(models).map(function (id) {
+      const v = models[id];
+      if (v && typeof v === 'object') return Object.assign({ id: id }, v);
+      return { id: id, name: v };
+    });
+  } else {
+    throw new Error('models must be an array or object');
+  }
+  return arr.map(normalizeModel);
+}
+
+function normalizeModel(m, i) {
+  if (typeof m === 'string') return { id: m, name: m, reasoning: false, limit: undefined };
+  if (!m || typeof m !== 'object') throw new Error('Invalid model at index ' + i);
+  const id = m.id != null ? m.id : m.name;
+  if (id == null) throw new Error('Model missing id/name at index ' + i);
+  return {
+    id: String(id),
+    name: m.name != null ? String(m.name) : String(id),
+    reasoning: m.reasoning === true,
+    limit: m.limit && typeof m.limit === 'object'
+      ? { context: m.limit.context, output: m.limit.output }
+      : undefined
+  };
+}
+
+module.exports = { normalizeConfig, parseModels };

package/src/discover.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { adapters } = require('./adapters');
+const { expandHome } = require('./util/paths');
+const { exists } = require('./util/fs');
+
+function detectInstalled() {
+  const out = [];
+  for (const a of adapters) {
+    const installed = (a.configPaths || []).some(function (p) {
+      return exists(expandHome(p));
+    });
+    if (installed) out.push(a);
+  }
+  return out;
+}
+
+function resolveTargets(targetArg) {
+  const installed = detectInstalled();
+  const byId = new Map(installed.map(function (a) { return [a.id, a]; }));
+  if (targetArg) {
+    const wanted = String(targetArg).split(',').map(function (s) { return s.trim().toLowerCase(); }).filter(Boolean);
+    const selected = [];
+    const missing = [];
+    for (const w of wanted) {
+      if (byId.has(w)) selected.push(byId.get(w));
+      else missing.push(w);
+    }
+    return { selected: selected, missing: missing, all: installed };
+  }
+  return { selected: installed, missing: [], all: installed };
+}
+
+module.exports = { detectInstalled, resolveTargets };

package/src/domain/resolve.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const { get, post } = require('../util/http');
+const { normalizeConfig } = require('../config/schema');
+
+const CONFIG_PATH = '/set-agent-provider-config.json';
+const SCHEMES = ['https', 'http'];
+const NON_EXISTENT = [404, 405, 501];
+
+function normalizeHost(domain) {
+  let s = String(domain == null ? '' : domain).trim();
+  s = s.replace(/^https?:\/\//i, '');
+  s = s.replace(/[/?#].*$/, '');
+  s = s.replace(/\/+$/, '');
+  return s;
+}
+
+async function getSafe(url, apiKey) {
+  const headers = { Accept: 'application/json' };
+  if (apiKey) headers.Authorization = 'Bearer ' + apiKey;
+  try {
+    return await get(url, { headers: headers, timeout: 10000 });
+  } catch (e) {
+    return null;
+  }
+}
+
+async function postSafe(url, apiKey) {
+  const headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+  if (apiKey) headers.Authorization = 'Bearer ' + apiKey;
+  try {
+    return await post(url, { headers: headers, body: {}, timeout: 10000 });
+  } catch (e) {
+    return null;
+  }
+}
+
+async function probeConfig(host) {
+  for (const scheme of SCHEMES) {
+    const url = scheme + '://' + host + CONFIG_PATH;
+    const res = await getSafe(url);
+    if (!res || res.status < 200 || res.status >= 300) continue;
+    let raw;
+    try {
+      raw = JSON.parse(res.body);
+    } catch (e) {
+      continue;
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+    try {
+      return normalizeConfig(raw);
+    } catch (e) {
+      continue;
+    }
+  }
+  return null;
+}
+
+async function probeChat(host, apiKey) {
+  for (const scheme of SCHEMES) {
+    const origin = scheme + '://' + host;
+    const res = await postSafe(origin + '/v1/chat/completions', apiKey);
+    if (!res) continue;
+    if (NON_EXISTENT.indexOf(res.status) !== -1) continue;
+    try {
+      JSON.parse(res.body);
+    } catch (e) {
+      continue;
+    }
+    return origin + '/v1';
+  }
+  return null;
+}
+
+async function resolveDomain(domain, opts) {
+  opts = opts || {};
+  const host = normalizeHost(domain);
+  if (!host) {
+    throw new Error('Invalid domain: ' + domain);
+  }
+
+  const config = await probeConfig(host);
+  if (config) {
+    return { config: config, baseUrl: config.baseUrl || null };
+  }
+
+  if (opts.probe === false) {
+    return { config: null, baseUrl: null };
+  }
+
+  const baseUrl = await probeChat(host, opts.apiKey);
+  if (!baseUrl) {
+    throw new Error('Could not detect an OpenAI-compatible API at ' + host +
+      ' (no /set-agent-provider-config.json or POST /v1/chat/completions).');
+  }
+  return { config: null, baseUrl: baseUrl };
+}
+
+module.exports = { resolveDomain: resolveDomain, normalizeHost: normalizeHost };

package/src/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { parseArgs } = require('./cli/args');
+const { printHelp } = require('./cli/help');
+const { resolveConfig } = require('./config/resolve');
+const { promptDefault, isInteractive } = require('./models/select');
+const { confirm } = require('./cli/prompt');
+const { runStatus } = require('./status');
+const { applyProvider } = require('./apply');
+const { printSummary } = require('./output');
+
+async function run(argv) {
+  const args = parseArgs(argv);
+
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (args.version) {
+    process.stdout.write(require('../package.json').version + '\n');
+    return;
+  }
+  if (args.status) {
+    runStatus(args);
+    return;
+  }
+
+  const cfg = await resolveConfig(args);
+
+  if (isInteractive()) {
+    const ok = await confirm(cfg);
+    if (!ok) {
+      process.stdout.write('Aborted.\n');
+      return;
+    }
+  }
+
+  const defaultModel = (await promptDefault(cfg.models)) || cfg.models[0].id;
+
+  const applied = await applyProvider(cfg, {
+    targetArg: args.target,
+    defaultModel: defaultModel,
+    interactive: isInteractive()
+  });
+  printSummary(cfg, applied.results);
+}
+
+module.exports = { run: run };

package/src/models/fetch.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { get } = require('../util/http');
+
+function modelsUrl(baseUrl) {
+  const b = String(baseUrl).replace(/\/+$/, '');
+  if (/\/v1$/i.test(b)) return b + '/models';
+  return b + '/v1/models';
+}
+
+async function fetchModels(baseUrl, apiKey) {
+  const url = modelsUrl(baseUrl);
+  const headers = { Accept: 'application/json' };
+  if (apiKey) headers.Authorization = 'Bearer ' + apiKey;
+
+  let res;
+  try {
+    res = await get(url, { headers: headers, timeout: 15000 });
+  } catch (e) {
+    throw new Error('Failed to fetch models from ' + url + ': ' + e.message);
+  }
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error('Model list request returned HTTP ' + res.status + ' for ' + url);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(res.body);
+  } catch (e) {
+    throw new Error('Invalid JSON from ' + url);
+  }
+
+  const list = Array.isArray(data) ? data : (data.data || data.models || []);
+  return list
+    .map(function (m) {
+      if (typeof m === 'string') return { id: m, name: m };
+      const id = m && (m.id || m.name);
+      return id ? { id: String(id), name: String(m.name || id) } : null;
+    })
+    .filter(Boolean);
+}
+
+module.exports = { fetchModels: fetchModels, modelsUrl: modelsUrl };

package/src/models/select.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const readline = require('readline');
+const { isInteractive } = require('../cli/prompt');
+
+async function multiSelect(items) {
+  if (!items.length) return [];
+  if (!isInteractive()) return items.slice();
+  return tuiSelect(items);
+}
+
+function tuiSelect(items) {
+  return new Promise(function (resolve, reject) {
+    let cursor = 0;
+    const selected = new Set();
+    let rendered = 0;
+
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    function lineFor(i) {
+      const it = items[i];
+      const box = selected.has(i) ? '[x]' : '[ ]';
+      const pointer = i === cursor ? '>' : ' ';
+      const label = it.name && it.name !== it.id ? '  ' + it.name : '';
+      return '  ' + pointer + ' ' + box + ' ' + it.id + label;
+    }
+
+    function render() {
+      if (rendered > 0) stdout.write('\x1b[' + rendered + 'A');
+      const lines = ['Select models (Space toggle, a=all, Enter confirm, Ctrl-C cancel):'];
+      for (let i = 0; i < items.length; i++) lines.push(lineFor(i));
+      let out = '';
+      for (const l of lines) out += '\x1b[2K' + l + '\n';
+      stdout.write(out);
+      rendered = lines.length;
+    }
+
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('keypress', onKey);
+    }
+
+    function onKey(str, key) {
+      if (!key) return;
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        stdout.write('\n');
+        return reject(new Error('Cancelled by user'));
+      }
+      if (key.name === 'up' || key.name === 'k') {
+        cursor = (cursor - 1 + items.length) % items.length; render();
+      } else if (key.name === 'down' || key.name === 'j') {
+        cursor = (cursor + 1) % items.length; render();
+      } else if (key.name === 'space') {
+        if (selected.has(cursor)) selected.delete(cursor); else selected.add(cursor);
+        render();
+      } else if (key.name === 'a') {
+        if (selected.size === items.length) selected.clear();
+        else items.forEach(function (_v, i) { selected.add(i); });
+        render();
+      } else if (key.name === 'return' || key.name === 'enter') {
+        if (selected.size === 0) selected.add(cursor);
+        cleanup();
+        stdout.write('\n');
+        resolve(items.filter(function (_v, i) { return selected.has(i); }));
+      }
+    }
+
+    render();
+    stdin.on('keypress', onKey);
+  });
+}
+
+function promptDefault(models) {
+  if (!models || !models.length) return Promise.resolve(null);
+  if (!isInteractive()) return Promise.resolve(models[0].id);
+
+  return new Promise(function (resolve) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const lines = models.map(function (m, i) {
+      const label = m.name && m.name !== m.id ? '  (' + m.name + ')' : '';
+      return '  ' + (i + 1) + ') ' + m.id + label;
+    });
+    process.stdout.write('Choose the default model:\n' + lines.join('\n') + '\n');
+    rl.question('Default model [1]: ', function (ans) {
+      rl.close();
+      const n = parseInt(String(ans).trim(), 10);
+      if (!isNaN(n) && n >= 1 && n <= models.length) resolve(models[n - 1].id);
+      else resolve(models[0].id);
+    });
+  });
+}
+
+function promptChoice(question, choices) {
+  if (!choices || !choices.length) return Promise.resolve(-1);
+  if (!isInteractive()) return Promise.resolve(0);
+  return new Promise(function (resolve) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const lines = choices.map(function (c, i) { return '  ' + (i + 1) + ') ' + c; });
+    process.stdout.write(question + '\n' + lines.join('\n') + '\n');
+    rl.question('Choice [1]: ', function (ans) {
+      rl.close();
+      const n = parseInt(String(ans).trim(), 10);
+      if (!isNaN(n) && n >= 1 && n <= choices.length) resolve(n - 1);
+      else resolve(0);
+    });
+  });
+}
+
+module.exports = {
+  multiSelect: multiSelect,
+  promptDefault: promptDefault,
+  promptChoice: promptChoice,
+  isInteractive: isInteractive
+};

package/src/output.js

@@ -0,0 +1,47 @@
+'use strict';
+
+function maskKey(apiKey) {
+  if (!apiKey) return null;
+  const s = String(apiKey);
+  if (s.length <= 6) return '****';
+  return s.slice(0, 3) + '...' + s.slice(-3);
+}
+
+function printSummary(cfg, results) {
+  const lines = [];
+  lines.push('');
+  lines.push('Provider : ' + cfg.name);
+  lines.push('Base URL : ' + cfg.baseUrl);
+  lines.push('API key  : ' + (cfg.apiKey ? maskKey(cfg.apiKey) : '(none)'));
+  lines.push('Models   : ' + (cfg.models ? cfg.models.length : 0));
+  lines.push('');
+
+  for (const r of results) {
+    if (r.ok) {
+      const b = r.backedUp && r.backedUp.length ? '  [backed up ' + r.backedUp.length + ' file(s)]' : '';
+      const d = r.wireApi ? '  [wire_api=' + r.wireApi + ']' : '';
+      const u = r.changed === false ? '  [unchanged]' : '';
+      lines.push('  OK   ' + r.name + d + u + b);
+    } else if (r.skipped) {
+      lines.push('  SKIP ' + r.name + ' — ' + r.error);
+    } else {
+      lines.push('  FAIL ' + r.name + ' — ' + r.error);
+    }
+  }
+
+  const okCount = results.filter(function (r) { return r.ok; }).length;
+  const failCount = results.filter(function (r) { return !r.ok && !r.skipped; }).length;
+  lines.push('');
+  lines.push('Done: ' + okCount + ' configured, ' + failCount + ' failed.');
+
+  const failed = results.filter(function (r) { return !r.ok && !r.skipped; });
+  if (failed.length) {
+    lines.push('');
+    lines.push('Failed targets:');
+    for (const f of failed) lines.push('  - ' + f.name + ': ' + f.error);
+  }
+
+  process.stdout.write(lines.join('\n') + '\n');
+}
+
+module.exports = { maskKey: maskKey, printSummary: printSummary };

package/src/status.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { adapters } = require('./adapters');
+const { resolveTargets } = require('./discover');
+
+function pad(s, n) {
+  s = String(s);
+  while (s.length < n) s += ' ';
+  return s;
+}
+
+function readOne(adapter) {
+  try {
+    return adapter.readStatus();
+  } catch (e) {
+    return null;
+  }
+}
+
+function runStatus(args) {
+  const resolved = resolveTargets(args.target);
+  const showAll = !args.target;
+  const lines = [];
+  lines.push('');
+  lines.push('Provider status:');
+
+  const list = showAll ? adapters : resolved.selected;
+  for (const a of list) {
+    const s = readOne(a);
+    if (s && s.configured) {
+      const parts = ['name=' + (s.name || '?')];
+      if (s.baseUrl) parts.push('baseUrl=' + s.baseUrl);
+      if (s.defaultModel) parts.push('default=' + s.defaultModel);
+      if (s.modelCount != null) parts.push('models=' + s.modelCount);
+      lines.push('  ' + pad(a.name, 14) + ': ' + parts.join('  '));
+    } else {
+      lines.push('  ' + pad(a.name, 14) + ': (not configured)');
+    }
+  }
+
+  if (!showAll) {
+    for (const m of resolved.missing) {
+      lines.push('  ' + pad(m, 14) + ': (unknown target)');
+    }
+  }
+
+  lines.push('');
+  process.stdout.write(lines.join('\n') + '\n');
+}
+
+module.exports = { runStatus: runStatus };

package/src/util/fs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+let backupFileHook = null;
+
+function setBackupHook(fn) {
+  backupFileHook = typeof fn === 'function' ? fn : null;
+}
+
+function exists(file) {
+  return fs.existsSync(file);
+}
+
+function readText(file) {
+  return fs.readFileSync(file, 'utf8');
+}
+
+function writeText(file, text) {
+  if (exists(file)) {
+    let current = null;
+    try { current = readText(file); } catch (e) { current = null; }
+    if (current === text) return false;
+    if (backupFileHook) backupFileHook(file);
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, text, 'utf8');
+  return true;
+}
+
+function readJson(file) {
+  return JSON.parse(readText(file));
+}
+
+function writeJson(file, obj) {
+  return writeText(file, JSON.stringify(obj, null, 2) + '\n');
+}
+
+module.exports = { exists, readText, writeText, readJson, writeJson, setBackupHook };

package/src/util/http.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+function request(method, url, opts) {
+  opts = opts || {};
+  const headers = opts.headers || {};
+  const body = opts.body == null ? null : (typeof opts.body === 'string' ? opts.body : JSON.stringify(opts.body));
+  const timeout = opts.timeout || 15000;
+  const maxRedirects = opts.maxRedirects == null ? 5 : opts.maxRedirects;
+
+  return new Promise(function (resolve, reject) {
+    let u;
+    try {
+      u = new URL(url);
+    } catch (e) {
+      return reject(new Error('Invalid URL: ' + url));
+    }
+    const lib = u.protocol === 'https:' ? https : http;
+    const reqHeaders = Object.assign({}, headers);
+    if (body != null) {
+      if (reqHeaders['Content-Length'] == null) reqHeaders['Content-Length'] = Buffer.byteLength(body);
+    }
+
+    const req = lib.request({
+      hostname: u.hostname,
+      port: u.port || (u.protocol === 'https:' ? 443 : 80),
+      path: u.pathname + u.search,
+      method: method,
+      headers: reqHeaders
+    }, function (res) {
+      const code = res.statusCode;
+      if ([301, 302, 303, 307, 308].indexOf(code) !== -1 && res.headers.location && maxRedirects > 0) {
+        res.resume();
+        const next = new URL(res.headers.location, url).toString();
+        return resolve(request(method, next, {
+          headers: headers,
+          body: opts.body,
+          timeout: timeout,
+          maxRedirects: maxRedirects - 1
+        }));
+      }
+      const chunks = [];
+      res.on('data', function (c) { chunks.push(c); });
+      res.on('end', function () {
+        resolve({ status: code, body: Buffer.concat(chunks).toString('utf8'), headers: res.headers });
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(timeout, function () { req.destroy(new Error('Request timeout')); });
+    if (body != null) req.write(body);
+    req.end();
+  });
+}
+
+function get(url, opts) { return request('GET', url, opts); }
+function post(url, opts) { return request('POST', url, opts); }
+
+module.exports = { request, get, post };

package/src/util/paths.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+function home() {
+  return os.homedir();
+}
+
+function expandHome(p) {
+  if (p === '~') return home();
+  if (typeof p === 'string' && (p.startsWith('~/') || p.startsWith('~\\'))) {
+    return path.join(home(), p.slice(2));
+  }
+  return p;
+}
+
+module.exports = { home, expandHome };