zevairouter 1.0.152 → 1.0.154

package/cli/app/src/lib/db/adapters/bunSqliteAdapter.js

@@ -25,15 +25,16 @@ export async function createBunSqliteAdapter(filePath) {
   }, CHECKPOINT_INTERVAL_MS);
   if (typeof checkpointTimer.unref === "function") checkpointTimer.unref();
 
+  let closed = false;
   function gracefulClose() {
+    if (closed) return;
+    closed = true;
     try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {}
     try { stmtCache.clear(); } catch {}
     try { db.close(); } catch {}
   }
   const onShutdown = () => gracefulClose();
   process.once("beforeExit", onShutdown);
-  process.once("SIGINT", () => { onShutdown(); process.exit(0); });
-  process.once("SIGTERM", () => { onShutdown(); process.exit(0); });
 
   return {
     driver: "bun:sqlite",
@@ -56,6 +57,7 @@ export async function createBunSqliteAdapter(filePath) {
     checkpoint() { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); },
     close() {
       clearInterval(checkpointTimer);
+      process.removeListener("beforeExit", onShutdown);
       gracefulClose();
     },
     raw: db,

package/cli/app/src/lib/db/adapters/nodeSqliteAdapter.js

@@ -38,15 +38,16 @@ export async function createNodeSqliteAdapter(filePath) {
   }, CHECKPOINT_INTERVAL_MS);
   if (typeof checkpointTimer.unref === "function") checkpointTimer.unref();
 
+  let closed = false;
   function gracefulClose() {
+    if (closed) return;
+    closed = true;
     try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {}
     try { stmtCache.clear(); } catch {}
     try { db.close(); } catch {}
   }
   const onShutdown = () => gracefulClose();
   process.once("beforeExit", onShutdown);
-  process.once("SIGINT", () => { onShutdown(); process.exit(0); });
-  process.once("SIGTERM", () => { onShutdown(); process.exit(0); });
 
   return {
     driver: "node:sqlite",
@@ -77,6 +78,7 @@ export async function createNodeSqliteAdapter(filePath) {
     checkpoint() { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); },
     close() {
       clearInterval(checkpointTimer);
+      process.removeListener("beforeExit", onShutdown);
       gracefulClose();
     },
     raw: db,

package/cli/app/src/lib/db/adapters/sqljsAdapter.js

@@ -10,7 +10,7 @@ async function loadSql() {
   return SQL;
 }
 
-export async function createSqlJsAdapter(filePath) {
+export async function createSqlJsAdapter(filePath, options = {}) {
   const lockPath = `${filePath}.sqljs.lock`;
   let lockFd;
   try {
@@ -42,9 +42,17 @@ export async function createSqlJsAdapter(filePath) {
     releaseLock();
     throw error;
   }
-  const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
-  let db = new SQLLib.Database(buf);
-  db.exec(PRAGMA_SQL);
+  let db;
+  try {
+    options.beforeOpen?.({ filePath });
+    const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
+    db = new SQLLib.Database(buf);
+    db.exec(PRAGMA_SQL);
+  } catch (error) {
+    try { db?.close(); } catch {}
+    releaseLock();
+    throw error;
+  }
   // Schema is created/synced by migrate.js after adapter init
 
   let dirty = false;
@@ -55,6 +63,7 @@ export async function createSqlJsAdapter(filePath) {
     const tempPath = `${filePath}.tmp-${process.pid}`;
     dirty = true;
     try {
+      options.beforePersist?.({ filePath, tempPath });
       fs.writeFileSync(tempPath, Buffer.from(data));
       fs.renameSync(tempPath, filePath);
       dirty = false;
@@ -64,23 +73,54 @@ export async function createSqlJsAdapter(filePath) {
     }
   }
 
+  function restoreSnapshot(snapshot) {
+    let restored;
+    try {
+      restored = new SQLLib.Database(snapshot);
+      restored.exec(PRAGMA_SQL);
+    } catch (error) {
+      try { restored?.close(); } catch {}
+      throw error;
+    }
+
+    const previous = db;
+    db = restored;
+    dirty = false;
+    try { previous.close(); } catch {}
+  }
+
+  function runWithPersistence(operation) {
+    if (transactionDepth > 0) return operation();
+
+    const snapshot = db.export();
+    try {
+      const result = operation();
+      persist();
+      return result;
+    } catch (error) {
+      restoreSnapshot(snapshot);
+      throw error;
+    }
+  }
+
   function paramsObj(params) {
     if (!params || (Array.isArray(params) && params.length === 0)) return undefined;
     return params;
   }
 
   function run(sql, params = []) {
-    const stmt = db.prepare(sql);
-    try {
-      stmt.bind(paramsObj(params));
-      stmt.step();
-      const changes = db.getRowsModified();
-      const lastInsertRowid = db.exec("SELECT last_insert_rowid() as id")[0]?.values?.[0]?.[0] ?? null;
-      if (transactionDepth === 0) persist();
-      return { changes, lastInsertRowid };
-    } finally {
-      stmt.free();
-    }
+    return runWithPersistence(() => {
+      const stmt = db.prepare(sql);
+      try {
+        stmt.bind(paramsObj(params));
+        stmt.step();
+        const changes = db.getRowsModified();
+        const lastInsertRowid = db.exec("SELECT last_insert_rowid() as id")[0]?.values?.[0]?.[0] ?? null;
+        return { changes, lastInsertRowid };
+      } finally {
+        stmt.free();
+      }
+    });
   }
 
   function get(sql, params = []) {
@@ -107,28 +147,32 @@ export async function createSqlJsAdapter(filePath) {
   }
 
   function exec(sql) {
-    db.exec(sql);
-    if (transactionDepth === 0) persist();
+    return runWithPersistence(() => db.exec(sql));
   }
 
   function transaction(fn) {
     const sp = `sp_${Math.random().toString(36).slice(2)}`;
-    const snapshot = transactionDepth === 0 ? db.export() : null;
+    const outermost = transactionDepth === 0;
+    const snapshot = outermost ? db.export() : null;
     db.exec(`SAVEPOINT ${sp}`);
     transactionDepth++;
+    let released = false;
     try {
       const result = fn();
       db.exec(`RELEASE ${sp}`);
+      released = true;
       transactionDepth--;
-      if (transactionDepth === 0) persist();
+      if (outermost) persist();
       return result;
     } catch (e) {
-      transactionDepth--;
-      try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+      // A persist failure happens after RELEASE and after depth was restored.
+      // Only unwind here when the savepoint itself is still active.
+      if (!released) {
+        transactionDepth--;
+        try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+      }
       if (snapshot) {
-        db.close();
-        db = new SQL.Database(snapshot);
-        dirty = false;
+        restoreSnapshot(snapshot);
       }
       throw e;
     }
@@ -138,13 +182,26 @@ export async function createSqlJsAdapter(filePath) {
   function close() {
     if (closed) return;
     closed = true;
+    let closeError = null;
     try {
       if (dirty) persist();
-      db.close();
+    } catch (error) {
+      closeError = error;
     } finally {
-      releaseLock();
+      try { db.close(); } catch (error) { closeError ||= error; }
+      finally { releaseLock(); }
     }
+    if (closeError) throw closeError;
   }
 
-  return { driver: "sql.js", run, get, all, exec, transaction, close, raw: db };
+  return {
+    driver: "sql.js",
+    run,
+    get,
+    all,
+    exec,
+    transaction,
+    close,
+    get raw() { return db; },
+  };
 }

package/cli/app/src/lib/db/maintenance.js

@@ -70,3 +70,9 @@ export function runStartupMaintenanceOnce(adapter) {
     } catch {}
   }
 }
+
+export function stopStartupMaintenance() {
+  if (!global._usageHistoryPruneTimer) return;
+  clearInterval(global._usageHistoryPruneTimer);
+  global._usageHistoryPruneTimer = null;
+}

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.152",
+  "version": "1.0.154",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/cli/src/cli/api/client.js

@@ -287,7 +287,9 @@ async function updateConnection(id, data) {
  * @returns {Promise<Object>} { success, data: { keys } }
  */
 async function getApiKeys() {
-  return makeRequest("GET", "/api/keys");
+  // The public dashboard collection is deliberately masked. CLI setup and key
+  // management run with the local CLI token, so use the narrowly scoped reveal route.
+  return makeRequest("GET", "/api/dashboard/cli-tools/keys");
 }
 
 /**

package/open-sse/executors/github.js

@@ -206,9 +206,13 @@ export class GithubExecutor extends BaseExecutor {
 
   async executeWithResponsesEndpoint({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
     const url = this.config.responsesUrl;
-    const headers = this.buildHeaders(credentials, stream);
+    // This executor's response bridge consumes Responses SSE and emits Chat SSE.
+    // Keep the upstream streaming even when chatCore will aggregate it for a
+    // non-streaming client.
+    const upstreamStream = true;
+    const headers = this.buildHeaders(credentials, upstreamStream);
 
-    const transformedBody = openaiToOpenAIResponsesRequest(model, body, stream, credentials);
+    const transformedBody = openaiToOpenAIResponsesRequest(model, body, upstreamStream, credentials);
 
     log?.debug("GITHUB", "Sending translated request to /responses");
 
@@ -243,7 +247,7 @@ export class GithubExecutor extends BaseExecutor {
           const parsed = parseSSELine(trimmed);
           if (!parsed) continue;
 
-          if (parsed.done && stream === true) {
+          if (parsed.done && upstreamStream) {
             controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
             continue;
           }

package/open-sse/executors/kiro.js

@@ -4,6 +4,7 @@ import { v4 as uuidv4 } from "uuid";
 import { refreshKiroToken } from "../services/tokenRefresh.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { HTTP_STATUS, RETRY_CONFIG, DEFAULT_RETRY_CONFIG, resolveRetryEntry } from "../config/runtimeConfig.js";
+import { fetchImageAsBase64 } from "../translator/helpers/imageHelper.js";
 
 /**
  * KiroExecutor - Executor for Kiro AI (AWS CodeWhisperer)
@@ -32,11 +33,39 @@ export class KiroExecutor extends BaseExecutor {
     return body;
   }
 
+  async prefetchImages(body, signal) {
+    const state = body?.conversationState;
+    const carriers = [state?.currentMessage, ...(state?.history || [])];
+
+    for (const carrier of carriers) {
+      const message = carrier?.userInputMessage;
+      if (!Array.isArray(message?.images)) continue;
+
+      const resolved = await Promise.all(message.images.map(async image => {
+        const url = image?.source?.url;
+        if (!url) return image;
+        const fetched = await fetchImageAsBase64(url, { signal, timeoutMs: 15000 });
+        if (!fetched?.url) {
+          const marker = `[Image unavailable: ${url}]`;
+          message.content = message.content ? `${message.content}\n\n${marker}` : marker;
+          return null;
+        }
+        const match = fetched.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (!match) return null;
+        const subtype = match[1].split("/")[1] || image.format || "jpeg";
+        return { format: subtype === "jpg" ? "jpeg" : subtype, source: { bytes: match[2] } };
+      }));
+      message.images = resolved.filter(Boolean);
+      if (message.images.length === 0) delete message.images;
+    }
+  }
+
   /**
    * Custom execute for Kiro - handles AWS EventStream binary response with retry support
    */
   async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
     const url = this.buildUrl(model, stream, 0);
+    await this.prefetchImages(body, signal);
     const transformedBody = this.transformRequest(model, body, stream, credentials);
     
     // Merge default retry config with provider-specific config

package/open-sse/handlers/chatCore/nonStreamingHandler.js

@@ -4,7 +4,12 @@ import { ollamaBodyToOpenAI } from "../../translator/response/ollama-to-openai.j
 import { addBufferToUsage, filterUsageForFormat } from "../../utils/usageTracking.js";
 import { createErrorResult } from "../../utils/error.js";
 import { HTTP_STATUS } from "../../config/runtimeConfig.js";
-import { parseSSEToOpenAIResponse } from "./sseToJsonHandler.js";
+import {
+  chatCompletionToClientJson,
+  notifyRequestSuccess,
+  parseSSEToOpenAIResponse,
+  responsesJsonToChatCompletion,
+} from "./sseToJsonHandler.js";
 import { buildRequestDetail, extractRequestConfig, extractUsageFromResponse, saveUsageStats } from "./requestDetail.js";
 import { appendRequestLog, saveRequestDetail } from "@/lib/usageDb.js";
 import { decloakToolNames } from "../../utils/claudeCloaking.js";
@@ -140,9 +145,12 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
   if (contentType.includes("text/event-stream")) {
     const sseText = await providerResponse.text();
     const parsed = parseSSEToOpenAIResponse(sseText, model);
-    if (!parsed) {
+    if (!parsed || parsed.error) {
       appendLog({ status: `FAILED ${HTTP_STATUS.BAD_GATEWAY}` });
-      return createErrorResult(HTTP_STATUS.BAD_GATEWAY, "Invalid SSE response for non-streaming request");
+      return createErrorResult(
+        HTTP_STATUS.BAD_GATEWAY,
+        parsed?.error?.message || "Invalid SSE response for non-streaming request"
+      );
     }
     responseBody = parsed;
   } else {
@@ -155,8 +163,22 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
     }
   }
 
+  if (!responseBody || typeof responseBody !== "object" || Array.isArray(responseBody)) {
+    appendLog({ status: `FAILED ${HTTP_STATUS.BAD_GATEWAY}` });
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, `Invalid response payload from ${provider}`);
+  }
+
+  const responseError = responseBody.error || (responseBody.status === "failed" ? responseBody : null);
+  if (responseError) {
+    const message = typeof responseError === "string"
+      ? responseError
+      : responseError.message || responseError.error?.message || "Provider returned a failed response";
+    appendLog({ status: `FAILED ${HTTP_STATUS.BAD_GATEWAY}` });
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, message);
+  }
+
   reqLogger.logProviderResponse(providerResponse.status, providerResponse.statusText, providerResponse.headers, responseBody);
-  if (onRequestSuccess) await onRequestSuccess();
+  await notifyRequestSuccess(onRequestSuccess);
 
   // Decloak tool_use names once on raw Claude body, before any translation (INPUT side)
   responseBody = decloakToolNames(responseBody, toolNameMap);
@@ -168,9 +190,13 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
     latency: { ttft: 0, total: Date.now() - requestStartTime },
   });
 
-  const translatedResponse = needsTranslation(targetFormat, sourceFormat)
-    ? translateNonStreamingResponse(responseBody, targetFormat, sourceFormat)
-    : responseBody;
+  let translatedResponse = responseBody;
+  if (needsTranslation(targetFormat, sourceFormat)) {
+    const openAIResponse = targetFormat === FORMATS.OPENAI_RESPONSES
+      ? responsesJsonToChatCompletion(responseBody, model)
+      : translateNonStreamingResponse(responseBody, targetFormat, FORMATS.OPENAI);
+    translatedResponse = chatCompletionToClientJson(openAIResponse, sourceFormat, model);
+  }
 
   // Fix finish_reason for tool_calls: some providers return non-standard values (e.g. "other")
   if (translatedResponse?.choices?.[0]) {
@@ -182,13 +208,15 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
     }
   }
 
-  // Ensure OpenAI-required fields
-  if (!translatedResponse.object) translatedResponse.object = "chat.completion";
-  if (!translatedResponse.created) translatedResponse.created = Math.floor(Date.now() / 1000);
+  // Ensure OpenAI-required fields without polluting Claude/Responses envelopes.
+  if (sourceFormat === FORMATS.OPENAI) {
+    if (!translatedResponse.object) translatedResponse.object = "chat.completion";
+    if (!translatedResponse.created) translatedResponse.created = Math.floor(Date.now() / 1000);
+  }
 
   // Strip Azure-specific fields
   delete translatedResponse.prompt_filter_results;
-  if (translatedResponse?.choices) {
+  if (sourceFormat === FORMATS.OPENAI && translatedResponse?.choices) {
     for (const choice of translatedResponse.choices) delete choice.content_filter_results;
   }
 
@@ -198,7 +226,7 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
 
   // Strip reasoning_content — some clients (e.g. Firecrawl AI SDK) have JSON parsers that
   // break on this non-standard field, even though OpenAI allows it in extensions.
-  if (translatedResponse?.choices) {
+  if (sourceFormat === FORMATS.OPENAI && translatedResponse?.choices) {
     for (const choice of translatedResponse.choices) {
       if (choice?.message) delete choice.message.reasoning_content;
     }