@krmxd/onegpt 0.1.8-beta → 0.1.9-beta

package/bin/ogpt.js

@@ -99,13 +99,14 @@ async function main() {
   let sessionId = "";
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--no-stream" || args[i] === "-s") {
+    if (args[i] === "--no-stream") {
       noStream = true;
     } else if (args[i] === "--auto") {
       autoApprove = true;
     } else if (args[i] === "--continue" || args[i] === "-c") {
       continueLast = true;
-    } else if (args[i] === "--session") {
+    } else if (args[i] === "--session" || args[i] === "-s") {
+      // -s <id> = resume session, matching the Python build's argparse
       sessionId = args[++i] || "";
     } else if (args[i] === "--model" || args[i] === "-m") {
       const name = args[++i];
@@ -132,6 +133,23 @@ Options:
 
   if (noStream) cfg.set("ui.stream", false);
 
+  // Local-engine bootstrap: install/start the engine and make sure a model
+  // exists BEFORE chatting, so users never see raw ECONNREFUSED errors.
+  if ((cfg.get("active_provider", "ollama") || "ollama") === "ollama"
+      && args[0] !== "--help") {
+    const { ensureLocalEngine } = require("../src/ollama-setup");
+    const res = await ensureLocalEngine({
+      host: cfg.get("providers.ollama.host"),
+      model: cfg.activeModel ? cfg.activeModel() : cfg.get("active_model"),
+    });
+    if (res.ok && res.model && res.model !== cfg.get("active_model")) {
+      cfg.set("active_model", res.model);
+    }
+    if (!res.ok && res.reason) {
+      console.log("\n" + res.reason + "\n");
+    }
+  }
+
   const cli = new CLI({ config: cfg });
 
   if (autoApprove) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krmxd/onegpt",
-  "version": "0.1.8-beta",
+  "version": "0.1.9-beta",
   "description": "OGPT - AI coding assistant for the terminal with a built-in local engine",
   "main": "src/index.js",
   "bin": {

package/src/ollama-setup.js

@@ -0,0 +1,141 @@
+"use strict";
+
+// Local-engine bootstrap (parity with ogpt/utils/ollama_setup.py).
+// Makes `ogpt` work right after install: installs the engine if missing,
+// starts the server daemon, picks a model that fits the RAM, and pulls it -
+// all installer output hidden behind short status lines.
+
+const { spawn, spawnSync } = require("child_process");
+const os = require("os");
+
+function isInstalled() {
+  try {
+    return spawnSync("ollama", ["--version"],
+      { stdio: "ignore", timeout: 15000 }).status === 0;
+  } catch { return false; }
+}
+
+function _getJson(host, path, timeoutMs) {
+  return new Promise((resolve) => {
+    const uri = new URL(path, host);
+    const mod = uri.protocol === "https:" ? require("https") : require("http");
+    const req = mod.request(uri, { timeout: timeoutMs }, (res) => {
+      let data = "";
+      res.on("data", (c) => { data += c; });
+      res.on("end", () => {
+        try { resolve({ ok: res.statusCode === 200, json: JSON.parse(data) }); }
+        catch { resolve({ ok: false }); }
+      });
+    });
+    req.on("timeout", () => { req.destroy(); resolve({ ok: false }); });
+    req.on("error", () => resolve({ ok: false }));
+    req.end();
+  });
+}
+
+async function serverUp(host, timeoutMs = 2500) {
+  const r = await _getJson(host, "/api/tags", timeoutMs);
+  return r.ok;
+}
+
+async function startServer(host, waitSec = 20) {
+  try {
+    const child = spawn("ollama", ["serve"],
+      { stdio: "ignore", detached: true });
+    child.unref();
+  } catch { return false; }
+  const deadline = Date.now() + waitSec * 1000;
+  while (Date.now() < deadline) {
+    await sleep(500);
+    if (await serverUp(host)) return true;
+  }
+  return false;
+}
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+async function listModels(host) {
+  const r = await _getJson(host, "/api/tags", 4000);
+  if (!r.ok || !r.json || !Array.isArray(r.json.models)) return [];
+  return r.json.models.map((m) => m.name || "").filter(Boolean);
+}
+
+async function pullModel(host, model, timeoutSec = 1800) {
+  console.log("Installing packages...");
+  try {
+    spawnSync("ollama", ["pull", model],
+      { stdio: "ignore", timeout: timeoutSec * 1000 });
+  } catch {}
+  const installed = await listModels(host);
+  const base = model.split(":")[0];
+  return installed.includes(model)
+    || installed.some((m) => m.startsWith(base + ":"));
+}
+
+function ramGB() {
+  return Math.round(os.totalmem() / (1024 * 1024 * 1024));
+}
+
+async function pickModel(host, configuredModel) {
+  const installed = await listModels(host);
+  if (installed.includes(configuredModel)) return configuredModel;
+  let fit = null;
+  try {
+    const { recommendForRam } = require("./catalog");
+    fit = recommendForRam(ramGB());
+  } catch {}
+  if (fit && installed.includes(fit)) return fit;
+  if (fit && !installed.length) return fit;          // fresh machine: pull best fit
+  if (installed.length) return installed[0];          // something already there
+  return fit || configuredModel;
+}
+
+/**
+ * Ensure the local engine is installed, running and has a usable model.
+ * Returns {ok, model, reason} - never throws.
+ */
+async function ensureLocalEngine({ host, model } = {}) {
+  host = host || "http://127.0.0.1:11434";
+  model = model || "qwen2.5-coder:1.5b";
+  try {
+    if (!isInstalled()) {
+      console.log("Installing packages...");
+      const { installOllama } = require("./bootstrap");
+      if (!installOllama()) {
+        return { ok: false, reason:
+          "Local engine could not be installed automatically. "
+          + "Grab it from https://ollama.com/download, or pick another "
+          + "provider with /provider." };
+      }
+    }
+    let up = await serverUp(host);
+    if (!up) {
+      console.log("Starting local engine...");
+      up = await startServer(host);
+      if (!up) {
+        return { ok: false, reason:
+          `Local engine did not respond on ${host} within 20s. `
+          + "Try 'ollama serve' manually or check 'journalctl -u ollama'." };
+      }
+    }
+    const chosen = await pickModel(host, model);
+    const installed = await listModels(host);
+    const base = chosen.split(":")[0];
+    const have = installed.includes(chosen)
+      || installed.some((m) => m.startsWith(base + ":"));
+    if (!have) {
+      const okPull = await pullModel(host, chosen);
+      if (!okPull) {
+        return { ok: false, reason:
+          `Model ${chosen} could not be downloaded (offline?). `
+          + "Check your connection or /model to pick an installed one." };
+      }
+    }
+    return { ok: true, model: chosen };
+  } catch (e) {
+    return { ok: false, reason: e.message };
+  }
+}
+
+module.exports = { ensureLocalEngine, serverUp, startServer, listModels,
+  pullModel, pickModel, isInstalled };

package/src/ollama.js

@@ -348,7 +348,16 @@ class OllamaProvider {
           });
         }
       );
-      req.on("error", reject);
+      req.on("error", (e) => {
+        if (e && (e.code === "ECONNREFUSED" || /ECONNREFUSED/.test(e.message || ""))) {
+          reject(new Error(
+            `Local engine is not running at ${this.host}. `
+            + "Start it with 'ollama serve' (OGPT normally does this "
+            + "automatically at launch), or switch providers with /provider."));
+        } else {
+          reject(e);
+        }
+      });
       req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
       if (body) req.write(JSON.stringify(body));
       req.end();
@@ -394,7 +403,16 @@ class OllamaProvider {
           req.destroy(new Error(`No data from the local engine for ${Math.round(this.idleTimeout / 1000)}s`));
         }, this.idleTimeout);
       };
-      req.on("error", (e) => { clearIdle(); reject(e); });
+      req.on("error", (e) => {
+        clearIdle();
+        if (e && e.code === "ECONNREFUSED") {
+          reject(new Error(
+            `Local engine is not running at ${this.host}. `
+            + "Start it with 'ollama serve' or switch providers with /provider."));
+        } else {
+          reject(e);
+        }
+      });
       req.on("close", clearIdle);
       req.write(JSON.stringify(body));
       req.end();

package/src/web.js

@@ -2,6 +2,7 @@
 // Same endpoints, same single-file UI, zero npm dependencies: served with
 // the plain http module and wired into the SAME agent singleton the
 // terminal uses, so dashboard and TUI share one brain and one counter.
+const _PKG_VER = require("../package.json").version;
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
@@ -111,7 +112,7 @@ function createDashboard(cli) {
         return json(res, 200, {
           ok: true,
           app: "OGPT",
-          version: "0.1.8-beta(devices-all)",
+          version: `${_PKG_VER}(devices-all)`,
           model: name,
           provider: "Ollama",
           uptime_s: Math.round((Date.now() - STARTED_AT) / 100) / 10,
@@ -140,7 +141,7 @@ function createDashboard(cli) {
         } catch {}
         return json(res, 200, {
           ok: true,
-          version: "0.1.8-beta(devices-all)",
+          version: `${_PKG_VER}(devices-all)`,
           model: name,
           model_id: name,
           provider: "Ollama",