@askexenow/exe-os 0.8.37 → 0.8.39

package/dist/bin/exe-agent.js

@@ -1094,7 +1094,8 @@ var OllamaProvider = class {
     const res = await fetch(`${this.host}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
     });
     if (!res.ok) {
       throw new Error(`Ollama API error: ${res.status} ${await res.text()}`);
@@ -1425,10 +1426,19 @@ var BashTool = {
         stdio: ["ignore", "pipe", "pipe"],
         env: { ...process.env }
       });
+      const MAX_OUTPUT_SIZE = 5242880;
       const stdoutChunks = [];
       const stderrChunks = [];
-      child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+      let stdoutSize = 0;
+      let stderrSize = 0;
+      child.stdout.on("data", (chunk) => {
+        if (stdoutSize < MAX_OUTPUT_SIZE) stdoutChunks.push(chunk);
+        stdoutSize += chunk.length;
+      });
+      child.stderr.on("data", (chunk) => {
+        if (stderrSize < MAX_OUTPUT_SIZE) stderrChunks.push(chunk);
+        stderrSize += chunk.length;
+      });
       const onAbort = () => {
         child.kill("SIGTERM");
         setTimeout(() => {
@@ -1829,8 +1839,13 @@ function runRipgrep(input, searchPath, context) {
       timeout: 3e4,
       stdio: ["ignore", "pipe", "pipe"]
     });
+    const MAX_OUTPUT = 1e7;
     const chunks = [];
-    child.stdout.on("data", (chunk) => chunks.push(chunk));
+    let totalSize = 0;
+    child.stdout.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize <= MAX_OUTPUT) chunks.push(chunk);
+    });
     const onAbort = () => child.kill("SIGTERM");
     context.abortSignal.addEventListener("abort", onAbort, { once: true });
     child.on("close", (code) => {

package/dist/bin/exe-assign.js

@@ -1,12 +1,6 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -16,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // src/lib/config.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
 import { readFileSync, existsSync, renameSync } from "fs";
 import path from "path";
 import os from "os";
@@ -218,7 +212,7 @@ __export(shard_manager_exports, {
   shardExists: () => shardExists
 });
 import path5 from "path";
-import { existsSync as existsSync5, mkdirSync } from "fs";
+import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
@@ -257,7 +251,6 @@ function shardExists(projectName) {
 }
 function listShards() {
   if (!existsSync5(SHARDS_DIR)) return [];
-  const { readdirSync } = __require("fs");
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -614,8 +607,13 @@ var _buffer = "";
 var _requestCount = 0;
 var HEALTH_CHECK_INTERVAL = 100;
 var _pending = /* @__PURE__ */ new Map();
+var MAX_BUFFER = 1e7;
 function handleData(chunk) {
   _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
   let newlineIdx;
   while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
     const line = _buffer.slice(0, newlineIdx).trim();
@@ -1015,6 +1013,7 @@ async function ensureSchema() {
   const client = getRawClient();
   await client.execute("PRAGMA journal_mode = WAL");
   await client.execute("PRAGMA busy_timeout = 30000");
+  await client.execute("PRAGMA wal_autocheckpoint = 1000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -1805,14 +1804,15 @@ async function ensureSchema() {
 }
 
 // src/lib/keychain.ts
-import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import path4 from "path";
+import os2 from "os";
 import crypto from "crypto";
 var SERVICE = "exe-mem";
 var ACCOUNT = "master-key";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(process.env.HOME ?? "/tmp", ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(os2.homedir(), ".exe-os");
 }
 function getKeyPath() {
   return path4.join(getKeyDir(), "master.key");
@@ -1849,6 +1849,30 @@ async function getMasterKey() {
 
 // src/lib/store.ts
 init_config();
+var INIT_MAX_RETRIES = 3;
+var INIT_RETRY_DELAY_MS = 1e3;
+function isBusyError2(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+async function retryOnBusy2(fn, label) {
+  for (let attempt = 0; attempt <= INIT_MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!isBusyError2(err) || attempt === INIT_MAX_RETRIES) throw err;
+      process.stderr.write(
+        `[store] SQLITE_BUSY during ${label}, retry ${attempt + 1}/${INIT_MAX_RETRIES}
+`
+      );
+      await new Promise((r) => setTimeout(r, INIT_RETRY_DELAY_MS * (attempt + 1)));
+    }
+  }
+  throw new Error("unreachable");
+}
 var _pendingRecords = [];
 var _batchSize = 20;
 var _flushIntervalMs = 1e4;
@@ -1883,14 +1907,17 @@ async function initStore(options) {
     dbPath,
     encryptionKey: hexKey
   });
-  await ensureSchema();
+  await retryOnBusy2(() => ensureSchema(), "ensureSchema");
   try {
     const { initShardManager: initShardManager2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
     initShardManager2(hexKey);
   } catch {
   }
   const client = getClient();
-  const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
+  const vResult = await retryOnBusy2(
+    () => client.execute("SELECT MAX(version) as max_v FROM memories"),
+    "version-query"
+  );
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
 }
 function classifyTier(record) {
@@ -1933,6 +1960,12 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
+  const MAX_PENDING = 1e3;
+  if (_pendingRecords.length > MAX_PENDING) {
+    const dropped = _pendingRecords.length - MAX_PENDING;
+    _pendingRecords = _pendingRecords.slice(-MAX_PENDING);
+    console.warn(`[store] Dropped ${dropped} oldest pending records (overflow)`);
+  }
   if (_flushTimer === null) {
     _flushTimer = setInterval(() => {
       void flushBatch();