@askexenow/exe-os 0.9.67 → 0.9.69

package/dist/bin/backfill-vectors.js

@@ -3338,10 +3338,10 @@ function evictLRU() {
   }
 }
 function evictIdleShards() {
-  const now = Date.now();
+  const now2 = Date.now();
   const toEvict = [];
   for (const [name, lastAccess] of _shardLastAccess) {
-    if (now - lastAccess > SHARD_IDLE_MS) {
+    if (now2 - lastAccess > SHARD_IDLE_MS) {
       toEvict.push(name);
     }
   }
@@ -3621,22 +3621,22 @@ ${sections.join("\n\n")}
 }
 async function storeGlobalProcedure(input) {
   const id = randomUUID2();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
     sql: `INSERT INTO company_procedures (id, title, content, priority, domain, active, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
-    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now, now]
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now2, now2]
   });
   await loadGlobalProcedures();
   return id;
 }
 async function deactivateGlobalProcedure(id) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   const result = await client.execute({
     sql: "UPDATE company_procedures SET active = 0, updated_at = ? WHERE id = ?",
-    args: [now, id]
+    args: [now2, id]
   });
   await loadGlobalProcedures();
   return result.rowsAffected > 0;
@@ -3816,8 +3816,8 @@ function deriveMachineKey() {
 }
 function readMachineId() {
   try {
-    const { readFileSync: readFileSync5 } = __require("fs");
-    return readFileSync5("/etc/machine-id", "utf-8").trim();
+    const { readFileSync: readFileSync6 } = __require("fs");
+    return readFileSync6("/etc/machine-id", "utf-8").trim();
   } catch {
     return "";
   }
@@ -4125,8 +4125,8 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/backfill-vectors.ts
-import { existsSync as existsSync9, unlinkSync as unlinkSync4 } from "fs";
-import path9 from "path";
+import { existsSync as existsSync10, unlinkSync as unlinkSync5 } from "fs";
+import path10 from "path";
 
 // src/lib/worker-gate.ts
 init_config();
@@ -4179,12 +4179,169 @@ function releaseBackfillLock() {
   }
 }
 
+// src/lib/background-jobs.ts
+init_config();
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4 } from "fs";
+import { execFileSync } from "child_process";
+import os6 from "os";
+import path9 from "path";
+var JOB_DIR = path9.join(EXE_AI_DIR, "jobs");
+var JOBS_FILE = path9.join(JOB_DIR, "jobs.json");
+var LOCK_DIR = path9.join(JOB_DIR, "locks");
+var DEFAULT_LOCK_TTL_MS = 6 * 60 * 60 * 1e3;
+var MAX_HISTORY = 200;
+function ensureDirs() {
+  mkdirSync4(LOCK_DIR, { recursive: true });
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJobsRaw() {
+  ensureDirs();
+  if (!existsSync9(JOBS_FILE)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync5(JOBS_FILE, "utf8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeJobsRaw(jobs) {
+  ensureDirs();
+  const running = jobs.filter((j) => j.status === "running");
+  const rest = jobs.filter((j) => j.status !== "running").slice(-MAX_HISTORY);
+  writeFileSync4(JOBS_FILE, JSON.stringify([...rest, ...running], null, 2) + "\n");
+}
+function lockPath(type) {
+  return path9.join(LOCK_DIR, `${type.replace(/[^a-zA-Z0-9_.-]/g, "_")}.lock`);
+}
+function acquireJobLock(type, ttlMs = DEFAULT_LOCK_TTL_MS) {
+  ensureDirs();
+  const file = lockPath(type);
+  if (existsSync9(file)) {
+    try {
+      const lock = JSON.parse(readFileSync5(file, "utf8"));
+      const age = Date.now() - Date.parse(lock.updatedAt ?? "");
+      if (lock.pid && isAlive(lock.pid) && Number.isFinite(age) && age < ttlMs) return false;
+    } catch {
+    }
+    try {
+      unlinkSync4(file);
+    } catch {
+    }
+  }
+  try {
+    writeFileSync4(file, JSON.stringify({ pid: process.pid, updatedAt: now() }, null, 2) + "\n", { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseJobLock(type) {
+  const file = lockPath(type);
+  try {
+    if (!existsSync9(file)) return;
+    const lock = JSON.parse(readFileSync5(file, "utf8"));
+    if (lock.pid === process.pid || !lock.pid || !isAlive(lock.pid)) unlinkSync4(file);
+  } catch {
+    try {
+      unlinkSync4(file);
+    } catch {
+    }
+  }
+}
+function startManagedJob(options) {
+  const lowPriority = options.lowPriority ?? true;
+  if (!acquireJobLock(options.type, options.lockTtlMs)) return null;
+  if (lowPriority) {
+    try {
+      os6.setPriority(process.pid, 10);
+    } catch {
+    }
+  }
+  const id = `${options.type}-${Date.now()}-${process.pid}`.replace(/[^a-zA-Z0-9_.-]/g, "_");
+  const record = {
+    id,
+    type: options.type,
+    name: options.name,
+    pid: process.pid,
+    command: options.command ?? process.argv.join(" "),
+    cwd: process.cwd(),
+    status: "running",
+    startedAt: now(),
+    updatedAt: now(),
+    lastHeartbeatAt: now(),
+    cancelCommand: `exe-os jobs cancel ${id}`,
+    lowPriority
+  };
+  const upsert = (patch) => {
+    const jobs = readJobsRaw().filter((j) => j.id !== id);
+    Object.assign(record, patch, { updatedAt: now() });
+    writeJobsRaw([...jobs, record]);
+    const file = lockPath(options.type);
+    try {
+      writeFileSync4(file, JSON.stringify({ pid: process.pid, jobId: id, updatedAt: record.updatedAt }, null, 2) + "\n");
+    } catch {
+    }
+  };
+  upsert({});
+  const timer = setInterval(() => upsert({ lastHeartbeatAt: now() }), 3e4);
+  timer.unref?.();
+  const cleanup = (status, error) => {
+    clearInterval(timer);
+    upsert({ status, error, lastHeartbeatAt: now() });
+    releaseJobLock(options.type);
+  };
+  process.once("SIGTERM", () => {
+    cleanup("cancelled");
+    process.exit(0);
+  });
+  process.once("SIGINT", () => {
+    cleanup("cancelled");
+    process.exit(130);
+  });
+  process.once("exit", () => releaseJobLock(options.type));
+  return {
+    id,
+    update(progress) {
+      upsert({ progressCurrent: progress.current, progressTotal: progress.total, progressLabel: progress.label, lastHeartbeatAt: now() });
+    },
+    complete() {
+      cleanup("completed");
+    },
+    fail(err) {
+      cleanup("failed", err instanceof Error ? err.message : String(err));
+    },
+    cancel() {
+      cleanup("cancelled");
+    }
+  };
+}
+async function politeBatchPause(ms = 250) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/bin/backfill-vectors.ts
 var BATCH_SIZE = 100;
-var BACKFILL_FLAG = path9.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+var BACKFILL_FLAG = path10.join(EXE_AI_DIR, "session-cache", "needs-backfill");
 async function backfillVectors() {
+  const job = startManagedJob({ type: "vector-backfill", name: "Vector embedding backfill", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[backfill] Vector backfill is already running \u2014 exiting\n");
+    return { processed: 0, failed: 0, remaining: -1 };
+  }
   if (!tryAcquireBackfillLock()) {
     process.stderr.write("[backfill] Another backfill is already running \u2014 exiting\n");
+    job.cancel();
     return { processed: 0, failed: 0, remaining: -1 };
   }
   registerWorkerPid(process.pid);
@@ -4205,6 +4362,7 @@ async function backfillVectors() {
   const connected = await connectEmbedDaemon();
   if (!connected) {
     process.stderr.write("[backfill] Cannot connect to embedding daemon \u2014 aborting\n");
+    job.fail(new Error("Cannot connect to embedding daemon"));
     return { processed: 0, failed: 0, remaining: -1 };
   }
   const client = getClient();
@@ -4218,6 +4376,7 @@ async function backfillVectors() {
     if (batch.rows.length === 0) break;
     process.stderr.write(`[backfill] Processing batch of ${batch.rows.length} memories...
 `);
+    job.update({ current: totalProcessed, label: `Processing batch of ${batch.rows.length} memories` });
     for (const row of batch.rows) {
       const id = row.id;
       const rawText = row.raw_text;
@@ -4242,6 +4401,8 @@ async function backfillVectors() {
     }
     process.stderr.write(`[backfill] Batch done. Processed: ${totalProcessed}, Failed: ${totalFailed}
 `);
+    job.update({ current: totalProcessed, label: `Processed ${totalProcessed}, failed ${totalFailed}` });
+    await politeBatchPause(500);
   }
   const remaining = await client.execute({
     sql: "SELECT COUNT(*) as cnt FROM memories WHERE vector IS NULL",
@@ -4250,16 +4411,18 @@ async function backfillVectors() {
   const remainingCount = Number(remaining.rows[0]?.cnt) || 0;
   if (remainingCount === 0) {
     try {
-      unlinkSync4(BACKFILL_FLAG);
+      unlinkSync5(BACKFILL_FLAG);
     } catch {
     }
   }
   process.stderr.write(`[backfill] Complete. Processed: ${totalProcessed}, Failed: ${totalFailed}, Remaining: ${remainingCount}
 `);
+  if (totalFailed > 0) job.fail(new Error(`${totalFailed} embeddings failed`));
+  else job.complete();
   return { processed: totalProcessed, failed: totalFailed, remaining: remainingCount };
 }
 function isBackfillNeeded() {
-  return existsSync9(BACKFILL_FLAG);
+  return existsSync10(BACKFILL_FLAG);
 }
 if (isMainModule(import.meta.url)) {
   backfillVectors().then((result) => {