@vierratale/ai 0.1.0-beta.14 → 0.1.0-beta.16

package/src/cmd/executor.js

@@ -1,271 +0,0 @@
-import { spawn } from 'child_process';
-import { dirname, resolve, sep } from 'path';
-
-const ALLOWED_BINS = new Set([
-  'mkdir', 'touch', 'ls', 'pwd', 'cat', 'cp', 'mv', 'rm',
-  'npm', 'npx', 'node', 'python', 'python3', 'git', 'echo', 'printf',
-  'apt', 'apt-get', 'pkg',
-]);
-
-// Package-manager commands never run interactively (no TTY), so auto-append a
-// confirm flag to mutating subcommands instead of letting apt/pkg block on a
-// prompt. pkg is the Termux/Android wrapper, apt/apt-get the Linux ones.
-const INSTALL_MANAGERS = new Set(['apt', 'apt-get', 'pkg']);
-const INSTALL_SUBCOMMANDS = new Set(['install', 'upgrade', 'remove', 'autoremove', 'purge']);
-const INSTALL_CONFIRM_FLAGS = /^-y$|^--yes$|^-dy$|^--assume-yes$/i;
-
-const SHELL_META = /[;&|<>`$]|\$\{|\(\)|\|\||&&/;
-
-// Bins whose *path arguments* must stay inside the workspace. Reads like `ls`
-// are unrestricted on purpose; writes/deletes are contained.
-const PATH_CONTAINED_BINS = new Set(['mkdir', 'touch', 'cat', 'cp', 'mv', 'rm']);
-
-const MAX_CAPTURE = 200 * 1024;
-
-export function toolResult(overrides = {}) {
-  return {
-    success: false,
-    command: '',
-    stdout: '',
-    stderr: '',
-    exitCode: 0,
-    cwd: '',
-    timedOut: false,
-    ...overrides,
-  };
-}
-
-// Tokenizer for a single command line. Supports single/double quotes and
-// backslash escaping so arguments with spaces are handled without a shell.
-export function parseCommandLine(line) {
-  const argv = [];
-  let buf = null;
-  let quote = null;
-  const flush = () => {
-    if (buf !== null) {
-      argv.push(buf);
-      buf = null;
-    }
-  };
-  for (let i = 0; i < line.length; i++) {
-    const c = line[i];
-    if (quote) {
-      if (c === quote) {
-        quote = null;
-      } else if (c === '\\' && quote === '"') {
-        if (i + 1 < line.length) buf += line[++i];
-        else buf += c;
-      } else {
-        buf += c;
-      }
-      continue;
-    }
-    if (c === "'" || c === '"') {
-      if (buf === null) buf = '';
-      quote = c;
-      continue;
-    }
-    if (c === ' ' || c === '\t' || c === '\n') {
-      flush();
-      continue;
-    }
-    if (c === '\\') {
-      if (buf === null) buf = '';
-      if (i + 1 < line.length) buf += line[++i];
-      else buf += c;
-      continue;
-    }
-    if (buf === null) buf = '';
-    buf += c;
-  }
-  flush();
-  return argv;
-}
-
-export function isAllowedBin(bin) {
-  if (!/^[A-Za-z0-9._-]+$/.test(bin || '')) return false;
-  return ALLOWED_BINS.has(bin);
-}
-
-export class SafeCommandExecutor {
-  constructor({ cwd, timeoutMs } = {}) {
-    this.cwd = resolve(cwd || process.cwd());
-    this.timeoutMs = timeoutMs || 60000;
-  }
-
-  // Validate a command line and normalize it to an argv array, or throw with a
-  // human-readable reason.
-  validate(argv) {
-    if (!argv.length) {
-      throw new Error('Empty command — nothing to run.');
-    }
-    const bin = argv[0];
-    if (!isAllowedBin(bin)) {
-      throw new Error(`Command "${bin}" is not on the allowed list. Use one of: ${[...ALLOWED_BINS].join(', ')}.`);
-    }
-    const args = argv.slice(1);
-
-    for (const a of args) {
-      if (SHELL_META.test(a)) {
-        throw new Error(`Shell operators and variable syntax are not allowed in arguments: ${JSON.stringify(a)}`);
-      }
-    }
-
-    if ((bin === 'node' || bin === 'python' || bin === 'python3') && args.includes('-e') || args.includes('-c')) {
-      throw new Error(`Inline code (-e/-c) is disabled for ${bin}. Run a file inside the workspace instead (e.g. ${bin} script.js).`);
-    }
-    if (bin === 'git' && args.includes('clean')) {
-      throw new Error('`git clean` is disabled by the safety policy.');
-    }
-    if (bin === 'rm') {
-      this._checkRm(args);
-    }
-    if (PATH_CONTAINED_BINS.has(bin)) {
-      this._checkPaths(bin, args);
-    }
-    if (INSTALL_MANAGERS.has(bin)) {
-      const subIdx = argv.findIndex((a) => INSTALL_SUBCOMMANDS.has(a));
-      if (subIdx !== -1 && !argv.some((a) => INSTALL_CONFIRM_FLAGS.test(a))) {
-        argv.splice(subIdx + 1, 0, '-y');
-      }
-    }
-    return argv;
-  }
-
-  _resolve(argvIdxArg) {
-    const base = resolve(this.cwd);
-    const target = resolve(base, argvIdxArg);
-    const outside = target !== base && !target.startsWith(base + sep);
-    return { base, target, outside };
-  }
-
-  _isHomeish(p) {
-    return p === '~' || p.startsWith('~/');
-  }
-
-  _checkRm(args) {
-    const targets = args.filter((a) => !a.startsWith('-'));
-    if (!targets.length) {
-      throw new Error('`rm` needs a target path.');
-    }
-    for (const t of targets) {
-      if (this._isHomeish(t)) {
-        throw new Error(`Refusing to remove ${t} — that path is outside the workspace.`);
-      }
-      if (t === '*' || t.includes('*')) {
-        throw new Error('Wildcards are not expanded (commands run without a shell). Give an explicit path for `rm`.');
-      }
-      const { base, target, outside } = this._resolve(t);
-      if (outside || target === base) {
-        throw new Error(`Refusing to remove ${t} — it resolves outside the workspace (${base}).`);
-      }
-    }
-  }
-
-  _checkPaths(bin, args) {
-    for (const a of args) {
-      if (a.startsWith('-') || a === '--') continue;
-      if (this._isHomeish(a)) {
-        throw new Error(`Refusing to use ${a} — home-directory paths are outside the workspace.`);
-      }
-      if (!this._looksLikePath(a)) continue;
-      const { base, target, outside } = this._resolve(a);
-      if (outside) {
-        throw new Error(`${bin}: refusing to touch ${a} — it resolves outside the workspace (${base}).`);
-      }
-    }
-  }
-
-  // Avoid treating plain words (e.g. a file NAME in `npm install foo`) as
-  // paths. Only flags, or tokens that contain a path separator or a known
-  // relative prefix, are checked.
-  _looksLikePath(a) {
-    if (a.includes('/') || a.includes('\\') || a.startsWith('.') || a === '..') return true;
-    if (/\.[A-Za-z0-9]{1,8}$/.test(a)) return true;
-    return false;
-  }
-
-  runCommand(commandLine) {
-    if (typeof commandLine !== 'string' || !commandLine.trim()) {
-      return Promise.resolve(toolResult({
-        success: false,
-        command: String(commandLine || ''),
-        stderr: 'Empty or invalid command.',
-        cwd: this.cwd,
-      }));
-    }
-    let argv;
-    try {
-      argv = this.validate(parseCommandLine(commandLine));
-    } catch (err) {
-      return Promise.resolve(toolResult({
-        success: false,
-        command: commandLine,
-        stderr: err.message,
-        cwd: this.cwd,
-      }));
-    }
-    return this.run(argv, commandLine);
-  }
-
-  run(argv, display = argv.join(' ')) {
-    return new Promise((resolvePromise) => {
-      let stdout = '';
-      let stderr = '';
-      let settled = false;
-      let timedOut = false;
-      let childExitCode = 1;
-
-      let child;
-      try {
-        child = spawn(argv[0], argv.slice(1), { cwd: this.cwd, shell: false });
-      } catch (err) {
-        return resolvePromise(toolResult({
-          success: false,
-          command: display,
-          stderr: err.message,
-          cwd: this.cwd,
-        }));
-      }
-
-      const finish = (code, dueToTimeout) => {
-        if (settled) return;
-        settled = true;
-        let out = stdout;
-        let errOut = stderr;
-        if (out.length > MAX_CAPTURE) out = out.slice(-MAX_CAPTURE) + '\n…[truncated]';
-        if (errOut.length > MAX_CAPTURE) errOut = errOut.slice(-MAX_CAPTURE) + '\n…[truncated]';
-        resolvePromise(toolResult({
-          success: code === 0 && !dueToTimeout,
-          command: display,
-          stdout: out,
-          stderr: errOut,
-          exitCode: dueToTimeout ? 124 : code,
-          cwd: this.cwd,
-          timedOut: !!dueToTimeout,
-        }));
-      };
-
-      const timer = setTimeout(() => {
-        timedOut = true;
-        try { child.kill('SIGKILL'); } catch {}
-      }, this.timeoutMs);
-
-      child.stdout.on('data', (d) => {
-        if (stdout.length < MAX_CAPTURE * 2) stdout += d.toString();
-      });
-      child.stderr.on('data', (d) => {
-        if (stderr.length < MAX_CAPTURE * 2) stderr += d.toString();
-      });
-      child.on('error', (err) => {
-        clearTimeout(timer);
-        stderr = err.message;
-        finish(127, false);
-      });
-      child.on('close', (code) => {
-        clearTimeout(timer);
-        finish(timedOut ? 124 : (code == null ? 1 : code), timedOut);
-      });
-    });
-  }
-}

package/src/cmd/todos.js

@@ -1,64 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-
-const FILE_NAME = '.todos.json';
-
-export function todosFile(cwd) {
-  return join(cwd || '.', FILE_NAME);
-}
-
-export function loadTodos(cwd) {
-  try {
-    const data = JSON.parse(readFileSync(todosFile(cwd), 'utf-8'));
-    if (!Array.isArray(data)) return [];
-    return data.map((t, i) => {
-      if (t && typeof t === 'object') {
-        return {
-          text: String(t.text ?? '').trim(),
-          done: Boolean(t.done),
-          createdAt: t.createdAt ?? null,
-          updatedAt: t.updatedAt ?? null,
-        };
-      }
-      return { text: String(t ?? '').trim(), done: false, createdAt: null, updatedAt: null };
-    }).filter((t) => t.text.length > 0);
-  } catch {
-    return [];
-  }
-}
-
-export function saveTodos(cwd, todos) {
-  writeFileSync(todosFile(cwd), JSON.stringify(todos, null, 2) + '\n', 'utf-8');
-}
-
-export function formatTodos(todos) {
-  if (!todos || !todos.length) return '(no todos yet)';
-  return todos.map((t, i) => `${i + 1}. ${t.done ? '[x]' : '[ ]'} ${t.text}`).join('\n');
-}
-
-export function addTodo(cwd, text) {
-  const clean = String(text ?? '').trim();
-  if (!clean) return { error: 'Missing todo text.' };
-  const todos = loadTodos(cwd);
-  todos.push({ text: clean, done: false, createdAt: new Date().toISOString(), updatedAt: null });
-  saveTodos(cwd, todos);
-  return { okay: true };
-}
-
-export function updateTodo(cwd, index, { done, text } = {}) {
-  const todos = loadTodos(cwd);
-  const i = Number(index) - 1;
-  if (!Number.isInteger(i) || i < 0 || i >= todos.length) {
-    return { error: `No todo #${index}.` };
-  }
-  if (typeof done === 'boolean') todos[i].done = done;
-  if (typeof text === 'string' && text.trim()) todos[i].text = text.trim();
-  todos[i].updatedAt = new Date().toISOString();
-  saveTodos(cwd, todos);
-  return { okay: true };
-}
-
-export function clearTodos(cwd) {
-  saveTodos(cwd, []);
-  return { okay: true };
-}

package/src/cmd/tools.js

@@ -1,204 +0,0 @@
-import { accessSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, X_OK } from 'fs';
-import { delimiter, join, resolve, sep } from 'path';
-import { toolResult, SafeCommandExecutor } from './executor.js';
-import { Downloader } from '../utils/downloader.js';
-import { Config } from '../config.js';
-import { loadTodos, addTodo, updateTodo, clearTodos, formatTodos } from './todos.js';
-
-// Resolve a path relative to the workspace and require it to stay inside.
-// Throws if the path escapes the workspace (or hits the workspace root for
-// destructive operations).
-export function resolveWithin(cwd, p, { allowRoot = false } = {}) {
-  const base = resolve(cwd);
-  const target = resolve(base, String(p || ''));
-  const rootOrEscape = target === base || !target.startsWith(base + sep);
-  if (target !== base && !target.startsWith(base + sep)) {
-    throw new Error(`Refusing to access a path outside the workspace: ${p}`);
-  }
-  if (!allowRoot && target === base && String(p || '') !== '.' && String(p || '') !== '') {
-    throw new Error('Refusing to use the workspace root as a file path.');
-  }
-  return target;
-}
-
-function ok({ command, stdout = '', cwd }) {
-  return toolResult({ success: true, command, stdout, stderr: '', exitCode: 0, cwd });
-}
-
-function fail({ command, stderr, exitCode = 1, cwd }) {
-  return toolResult({ success: false, command, stdout: '', stderr, exitCode, cwd });
-}
-
-export function createFile(cwd, path, content = '') {
-  if (!path || typeof path !== 'string' || path.trim() === '') {
-    return fail({ command: 'create_file', stderr: 'Missing file path.', cwd });
-  }
-  try {
-    const target = resolveWithin(cwd, path);
-    const dir = resolve(target, '..');
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(target, String(content ?? ''));
-    return ok({ command: `create_file("${path}")`, stdout: `created ${path} (${String(content ?? '').length} bytes)`, cwd });
-  } catch (err) {
-    return fail({ command: `create_file("${path}")`, stderr: err.message, cwd });
-  }
-}
-
-export function createDirectory(cwd, path) {
-  if (!path || typeof path !== 'string' || path.trim() === '') {
-    return fail({ command: 'create_directory', stderr: 'Missing directory path.', cwd });
-  }
-  try {
-    const target = resolveWithin(cwd, path, { allowRoot: true });
-    if (target === resolve(cwd)) {
-      return ok({ command: `create_directory("${path}")`, stdout: `already at workspace root`, cwd });
-    }
-    mkdirSync(target, { recursive: true });
-    return ok({ command: `create_directory("${path}")`, stdout: `created directory ${path}`, cwd });
-  } catch (err) {
-    return fail({ command: `create_directory("${path}")`, stderr: err.message, cwd });
-  }
-}
-
-export function readFile(cwd, path) {
-  if (!path || typeof path !== 'string' || path.trim() === '') {
-    return fail({ command: 'read_file', stderr: 'Missing file path.', cwd });
-  }
-  try {
-    const target = resolveWithin(cwd, path);
-    const content = readFileSync(target, 'utf-8');
-    return ok({ command: `read_file("${path}")`, stdout: content, cwd });
-  } catch (err) {
-    return fail({ command: `read_file("${path}")`, stderr: err.message, cwd });
-  }
-}
-
-export function listDirectory(cwd, path = '.') {
-  try {
-    const target = resolveWithin(cwd, path, { allowRoot: true });
-    const entries = readdirSync(target, { withFileTypes: true });
-    const list = entries
-      .map((e) => (e.isDirectory() ? `${e.name}/` : e.name))
-      .sort()
-      .join('\n');
-    return ok({ command: `list_directory("${path}")`, stdout: list || '(empty)', cwd });
-  } catch (err) {
-    return fail({ command: `list_directory("${path}")`, stderr: err.message, cwd });
-  }
-}
-
-export function deleteFile(cwd, path) {
-  if (!path || typeof path !== 'string' || path.trim() === '') {
-    return fail({ command: 'delete_file', stderr: 'Missing path.', cwd });
-  }
-  try {
-    const target = resolveWithin(cwd, path);
-    if (resolve(cwd) === target) {
-      return fail({ command: `delete_file("${path}")`, stderr: 'Refusing to delete the workspace root.', cwd });
-    }
-    if (!existsSync(target)) {
-      return fail({ command: `delete_file("${path}")`, stderr: `No such file or directory: ${path}`, exitCode: 1, cwd });
-    }
-    rmSync(target, { recursive: true, force: true });
-    return ok({ command: `delete_file("${path}")`, stdout: `removed ${path}`, cwd });
-  } catch (err) {
-    return fail({ command: `delete_file("${path}")`, stderr: err.message, cwd });
-  }
-}
-
-// Pick the package manager to use for installing system packages: pkg is the
-// Termux/Android wrapper, everywhere else apt/apt-get.
-export function pickPackageManager() {
-  const dirs = (process.env.PATH || '').split(delimiter).filter(Boolean);
-  const available = (bin) => dirs.some((dir) => {
-    try {
-      accessSync(join(dir, bin), X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  if (available('pkg')) return 'pkg';
-  if (available('apt-get')) return 'apt-get';
-  return 'apt';
-}
-
-export async function downloadUrl(cwd, url, dir) {
-  if (!url || typeof url !== 'string' || !/^https?:\/\//i.test(url.trim())) {
-    return fail({ command: 'download_url', stderr: 'Invalid URL. Provide a valid http(s) address.', cwd });
-  }
-  const targetDir = dir ? resolveWithin(cwd, dir, { allowRoot: true }) : Config.get('downloadDir');
-  try {
-    const res = await Downloader.download(url.trim(), { dir: targetDir });
-    const kind = res.kind || 'file';
-    const note = res.extracted ? '\n(contents extracted into that folder)' : '';
-    return ok({
-      command: `download_url("${url}")`,
-      stdout: `downloaded ${kind} → ${res.path}${note}`,
-      cwd,
-    });
-  } catch (err) {
-    return fail({ command: 'download_url', stderr: err.message, cwd });
-  }
-}
-
-export function todoAdd(cwd, text) {
-  const err = addTodo(cwd, text);
-  if (err && err.error) return fail({ command: `todo_add("${text}")`, stderr: err.error, cwd });
-  return ok({ command: `todo_add("${text}")`, stdout: formatTodos(loadTodos(cwd)), cwd });
-}
-
-export function todoList(cwd) {
-  try {
-    return ok({ command: 'todo_list', stdout: formatTodos(loadTodos(cwd)), cwd });
-  } catch (err) {
-    return fail({ command: 'todo_list', stderr: err.message, cwd });
-  }
-}
-
-export function todoUpdate(cwd, index, done, text) {
-  const err = updateTodo(cwd, index, { done, text });
-  if (err && err.error) return fail({ command: `todo_update(${index})`, stderr: err.error, cwd });
-  return ok({ command: `todo_update(${index})`, stdout: formatTodos(loadTodos(cwd)), cwd });
-}
-
-export function todoClear(cwd) {
-  try {
-    clearTodos(cwd);
-    return ok({ command: 'todo_clear', stdout: '(no todos yet)', cwd });
-  } catch (err) {
-    return fail({ command: 'todo_clear', stderr: err.message, cwd });
-  }
-}
-
-// Structured tool registry shared with the agent loop.
-export const TOOL_EXECUTORS = {
-  run_command: (executor, params) => executor.runCommand(params.command),
-  create_file: (executor, params) => createFile(executor.cwd, params.path, params.content),
-  create_directory: (executor, params) => createDirectory(executor.cwd, params.path),
-  read_file: (executor, params) => readFile(executor.cwd, params.path),
-  list_directory: (executor, params) => listDirectory(executor.cwd, params.path || '.'),
-  delete_file: (executor, params) => deleteFile(executor.cwd, params.path),
-  download_url: (executor, params) => downloadUrl(executor.cwd, params.url, params.dir),
-  todo_add: (executor, params) => todoAdd(executor.cwd, params ? params.text : undefined),
-  todo_list: (executor, params) => todoList(executor.cwd),
-  todo_update: (executor, params) => todoUpdate(executor.cwd, params ? params.index : undefined, params ? params.done : undefined, params ? params.text : undefined),
-  todo_clear: (executor, params) => todoClear(executor.cwd),
-};
-
-export function makeExecutor({ cwd, timeoutMs } = {}) {
-  return new SafeCommandExecutor({ cwd, timeoutMs });
-}
-
-export function dispatchTool(executor, call) {
-  const fn = TOOL_EXECUTORS[call && call.name];
-  if (!fn) {
-    return toolResult({
-      success: false,
-      command: `${call && call.name ? call.name : '(unknown tool)'}`,
-      stderr: `Unknown tool ${call && call.name}.`,
-      cwd: executor.cwd,
-    });
-  }
-  return fn(executor, call.params || {});
-}

package/src/engine.js

@@ -1,150 +0,0 @@
-import { execSync, exec } from 'child_process';
-import { existsSync } from 'fs';
-import { Catalog } from './catalog.js';
-import { Config } from './config.js';
-
-function runSilent(cmd) {
-  return new Promise((resolve) => {
-    exec(cmd, { stdio: 'ignore' }, (err) => resolve(!err));
-  });
-}
-
-function isEngineRunning(host) {
-  return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
-    .then((r) => r.ok)
-    .catch(() => false);
-}
-
-function isEngineInstalled() {
-  try {
-    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
-    return true;
-  } catch {}
-  const paths = ['/usr/local/bin/ollama', '/usr/bin/ollama'];
-  return paths.some((p) => existsSync(p));
-}
-
-async function installEngine() {
-  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
-  return isEngineInstalled();
-}
-
-async function getInstalledModels(host) {
-  try {
-    const resp = await fetch(`${host}/api/tags`);
-    if (!resp.ok) return [];
-    const data = await resp.json();
-    return (data.models || []).map((m) => m.name);
-  } catch {
-    return [];
-  }
-}
-
-async function pullModel(host, model) {
-  try {
-    const resp = await fetch(`${host}/api/pull`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: model, stream: false }),
-      signal: AbortSignal.timeout(600000),
-    });
-    return resp.ok;
-  } catch {
-    return false;
-  }
-}
-
-function familyOf(model) {
-  return model
-    .split(':')[0]
-    .toLowerCase()
-    .replace(/-(coder|instruct|reasoning|chat|base|tiny|nano)$/, '');
-}
-
-function sizeOf(model) {
-  const size = model.split(':')[1] || '';
-  const match = size.match(/(\d+(?:\.\d+)?)(m|b)/i);
-  if (!match) return Number.POSITIVE_INFINITY;
-  const value = parseFloat(match[1]);
-  return match[2].toLowerCase() === 'b' ? value * 1000 : value;
-}
-
-function chooseModel(installed, realModel) {
-  if (installed.includes(realModel)) {
-    return { model: realModel, substituted: false, reason: null };
-  }
-  const fam = familyOf(realModel);
-  let best = null;
-  let bestDist = Number.POSITIVE_INFINITY;
-  for (const m of installed) {
-    if (familyOf(m) !== fam) continue;
-    const dist = Math.abs(sizeOf(m) - sizeOf(realModel)) + 0.5;
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = m;
-    }
-  }
-  if (best) {
-    return {
-      model: best,
-      substituted: true,
-      reason: `"${realModel}" is not installed; using ${best} (same family)`,
-    };
-  }
-  return { model: null, substituted: true, reason: `"${realModel}" is not installed` };
-}
-
-async function resolveModel(host, realModel) {
-  const installed = await getInstalledModels(host);
-  return chooseModel(installed, realModel);
-}
-
-async function ensure() {
-  const host = Config.get('engineHost');
-
-  if (!isEngineInstalled()) {
-    await installEngine();
-  }
-
-  const running = await isEngineRunning(host);
-  if (!running) {
-    try {
-      const child = exec('ollama serve', {
-        stdio: 'ignore',
-        detached: true,
-      });
-      if (child.unref) child.unref();
-      for (let i = 0; i < 30; i++) {
-        await new Promise((r) => setTimeout(r, 1000));
-        if (await isEngineRunning(host)) break;
-      }
-    } catch {}
-  }
-
-  const realModel = Catalog.getRealModel(Config.get('model'));
-  const installed = await getInstalledModels(host);
-  const resolved = chooseModel(installed, realModel);
-  if (resolved.model == null) {
-    await pullModel(host, realModel);
-  }
-
-  return true;
-}
-
-async function isReady() {
-  const host = Config.get('engineHost');
-  return isEngineRunning(host);
-}
-
-export const Engine = {
-  ensure,
-  isReady,
-  pullModel,
-  getInstalledModels,
-  resolveModel,
-  chooseModel,
-  firstInstalled: async (host) => {
-    const installed = await getInstalledModels(host);
-    return installed[0] || null;
-  },
-};