@askexenow/exe-os 0.9.66 → 0.9.68

package/deploy/stack-manifests/v0.9.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "latest": "0.9.1",
+  "latest": "0.9.2",
   "stacks": {
     "0.9.0": {
       "version": "0.9.0",
@@ -29,7 +29,7 @@
         },
         "exed": {
           "env": "EXED_IMAGE_TAG",
-          "image": "ghcr.io/askexe/exed:v0.9.65",
+          "image": "ghcr.io/askexe/exed:v0.9.66",
           "healthUrl": "http://127.0.0.1:8765/health"
         },
         "gateway": {
@@ -43,7 +43,7 @@
         }
       },
       "releaseDescriptors": {
-        "exed": "AskExe/exe-os@0.9.65:stack.release.json",
+        "exed": "AskExe/exe-os@0.9.66:stack.release.json",
         "crm": "AskExe/exe-crm@0.9.0:stack.release.json",
         "wiki": "AskExe/exe-wiki@0.9.0:stack.release.json",
         "gateway": "AskExe/exe-gateway@0.9.0:stack.release.json",
@@ -78,7 +78,7 @@
         },
         "exed": {
           "env": "EXED_IMAGE_TAG",
-          "image": "ghcr.io/askexe/exed:v0.9.65",
+          "image": "ghcr.io/askexe/exed:v0.9.66",
           "healthUrl": "http://127.0.0.1:8765/health"
         },
         "gateway": {
@@ -92,13 +92,62 @@
         }
       },
       "releaseDescriptors": {
-        "exed": "AskExe/exe-os@0.9.65:stack.release.json",
+        "exed": "AskExe/exe-os@0.9.66:stack.release.json",
         "crm": "AskExe/exe-crm@0.9.1:stack.release.json",
         "wiki": "AskExe/exe-wiki@0.9.1:stack.release.json",
         "gateway": "AskExe/exe-gateway@0.9.1:stack.release.json",
         "db": "AskExe/exe-db@0.9.1:stack.release.json",
         "monitorAgent": "AskExe/exe-monitor@0.9.1:stack.release.json"
       }
+    },
+    "0.9.2": {
+      "version": "0.9.2",
+      "releasedAt": "2026-05-12T00:00:00Z",
+      "notes": "Hygo private/customer pilot stack release. Aligns all deployable service, image, and package versions on 0.9.2 after exe-db-jkt dogfood fixes.",
+      "breakingChanges": [
+        {
+          "id": "whatsapp_relink_required",
+          "title": "WhatsApp QR re-link required for Baileys v7",
+          "description": "exe-gateway uses Baileys v7. Existing WhatsApp 6.x linked-device auth state must be backed up and re-linked once with a new QR code.",
+          "requiredAction": "Open https://<gateway-domain>/pair/default?token=<admin-token> and scan from WhatsApp \u2192 Linked Devices after the update.",
+          "expectedDowntimeMinutes": "2-5",
+          "requiresConfirmation": true
+        }
+      ],
+      "services": {
+        "crm": {
+          "env": "CRM_IMAGE_TAG",
+          "image": "ghcr.io/askexe/exe-crm:v0.9.2",
+          "healthUrl": "http://127.0.0.1:3000/healthz"
+        },
+        "wiki": {
+          "env": "WIKI_IMAGE_TAG",
+          "image": "ghcr.io/askexe/exe-wiki:v0.9.2",
+          "healthUrl": "http://127.0.0.1:3001/api/ping"
+        },
+        "exed": {
+          "env": "EXED_IMAGE_TAG",
+          "image": "ghcr.io/askexe/exed:v0.9.2",
+          "healthUrl": "http://127.0.0.1:8765/health"
+        },
+        "gateway": {
+          "env": "GATEWAY_IMAGE_TAG",
+          "image": "ghcr.io/askexe/exe-gateway:v0.9.2",
+          "healthUrl": "http://127.0.0.1:3100/health"
+        },
+        "monitorAgent": {
+          "env": "MONITOR_AGENT_IMAGE_TAG",
+          "image": "ghcr.io/askexe/exe-monitor-agent:v0.9.2"
+        }
+      },
+      "releaseDescriptors": {
+        "exed": "AskExe/exe-os@0.9.2:stack.release.json",
+        "crm": "AskExe/exe-crm@0.9.2:stack.release.json",
+        "wiki": "AskExe/exe-wiki@0.9.2:stack.release.json",
+        "gateway": "AskExe/exe-gateway@0.9.2:stack.release.json",
+        "db": "AskExe/exe-db@0.9.2:stack.release.json",
+        "monitorAgent": "AskExe/exe-monitor@0.9.2:stack.release.json"
+      }
     }
   }
 }

package/dist/bin/age-ontology-load.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+
+// src/bin/age-ontology-load.ts
+import { Client } from "pg";
+
+// src/lib/background-jobs.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync, unlinkSync } from "fs";
+import { execFileSync } from "child_process";
+import os2 from "os";
+import path2 from "path";
+
+// src/lib/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
+import path from "path";
+import os from "os";
+
+// src/lib/secure-files.ts
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { chmod, mkdir } from "fs/promises";
+
+// src/lib/config.ts
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
+  const newDir = path.join(os.homedir(), ".exe-os");
+  const legacyDir = path.join(os.homedir(), ".exe-mem");
+  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+var EXE_AI_DIR = resolveDataDir();
+var DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+var MODELS_DIR = path.join(EXE_AI_DIR, "models");
+var CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
+var LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+var CURRENT_CONFIG_VERSION = 1;
+var DEFAULT_CONFIG = {
+  config_version: CURRENT_CONFIG_VERSION,
+  dbPath: DB_PATH,
+  modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+  embeddingDim: 1024,
+  batchSize: 20,
+  flushIntervalMs: 1e4,
+  autoIngestion: true,
+  autoRetrieval: true,
+  searchMode: "hybrid",
+  hookSearchMode: "hybrid",
+  fileGrepEnabled: true,
+  splashEffect: true,
+  consolidationEnabled: true,
+  consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+  consolidationModel: "claude-haiku-4-5-20251001",
+  consolidationMaxCallsPerRun: 20,
+  selfQueryRouter: true,
+  selfQueryModel: "claude-haiku-4-5-20251001",
+  rerankerEnabled: true,
+  scalingRoadmap: {
+    rerankerAutoTrigger: {
+      enabled: true,
+      broadQueryMinCardinality: 5e4,
+      fetchTopK: 200,
+      returnTopK: 20
+    }
+  },
+  graphRagEnabled: true,
+  wikiEnabled: false,
+  wikiUrl: "",
+  wikiApiKey: "",
+  wikiSyncIntervalMs: 30 * 60 * 1e3,
+  wikiWorkspaceMapping: {},
+  wikiAutoUpdate: true,
+  wikiAutoUpdateThreshold: 0.5,
+  wikiAutoUpdateCreateNew: true,
+  skillLearning: true,
+  skillThreshold: 3,
+  skillModel: "claude-haiku-4-5-20251001",
+  exeHeartbeat: {
+    enabled: true,
+    intervalSeconds: 60,
+    staleInProgressThresholdHours: 2
+  },
+  sessionLifecycle: {
+    idleKillEnabled: true,
+    idleKillTicksRequired: 3,
+    idleKillIntercomAckWindowMs: 1e4,
+    maxAutoInstances: 10
+  },
+  autoUpdate: {
+    checkOnBoot: true,
+    autoInstall: false,
+    checkIntervalMs: 24 * 60 * 60 * 1e3
+  },
+  orchestration: {
+    phase: "phase_1_coo",
+    phaseSetBy: "default"
+  }
+};
+
+// src/lib/background-jobs.ts
+var JOB_DIR = path2.join(EXE_AI_DIR, "jobs");
+var JOBS_FILE = path2.join(JOB_DIR, "jobs.json");
+var LOCK_DIR = path2.join(JOB_DIR, "locks");
+var DEFAULT_LOCK_TTL_MS = 6 * 60 * 60 * 1e3;
+var MAX_HISTORY = 200;
+function ensureDirs() {
+  mkdirSync2(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 (!existsSync3(JOBS_FILE)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync2(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);
+  writeFileSync(JOBS_FILE, JSON.stringify([...rest, ...running], null, 2) + "\n");
+}
+function lockPath(type) {
+  return path2.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 (existsSync3(file)) {
+    try {
+      const lock = JSON.parse(readFileSync2(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 {
+      unlinkSync(file);
+    } catch {
+    }
+  }
+  try {
+    writeFileSync(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 (!existsSync3(file)) return;
+    const lock = JSON.parse(readFileSync2(file, "utf8"));
+    if (lock.pid === process.pid || !lock.pid || !isAlive(lock.pid)) unlinkSync(file);
+  } catch {
+    try {
+      unlinkSync(file);
+    } catch {
+    }
+  }
+}
+function startManagedJob(options) {
+  const lowPriority = options.lowPriority ?? true;
+  if (!acquireJobLock(options.type, options.lockTtlMs)) return null;
+  if (lowPriority) {
+    try {
+      os2.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 {
+      writeFileSync(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/age-ontology-load.ts
+function q(value) {
+  return `'${String(value ?? "").replace(/\u0000/g, "").slice(0, 500).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function sqlString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+async function main() {
+  const job = startManagedJob({ type: "age-ontology-load", name: "Apache AGE ontology loader", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[age-ontology-load] Another AGE ontology load is already running.\n");
+    return;
+  }
+  const sourceUrl = process.env.DATABASE_URL || process.env.EXED_DATABASE_URL;
+  const ageUrl = process.env.AGE_DATABASE_URL;
+  if (!sourceUrl) throw new Error("DATABASE_URL or EXED_DATABASE_URL is required for canonical source");
+  if (!ageUrl) throw new Error("AGE_DATABASE_URL is required for Apache AGE target");
+  const graph = process.env.AGE_GRAPH_NAME || "exe_ontology";
+  const limit = Number(process.argv[process.argv.indexOf("--limit") + 1] || "1000");
+  const source = new Client({ connectionString: sourceUrl });
+  const age = new Client({ connectionString: ageUrl });
+  await source.connect();
+  await age.connect();
+  try {
+    await age.query(`CREATE EXTENSION IF NOT EXISTS age`);
+    await age.query(`LOAD 'age'`);
+    await age.query(`SET search_path = ag_catalog, "$user", public`);
+    if (process.argv.includes("--reset")) {
+      try {
+        await age.query(`SELECT drop_graph(${sqlString(graph)}, true)`);
+      } catch {
+      }
+    }
+    try {
+      await age.query(`SELECT create_graph(${sqlString(graph)})`);
+    } catch {
+    }
+    const entities = await source.query(`SELECT id, name, type FROM memory.entities ORDER BY last_seen DESC NULLS LAST, id LIMIT $1`, [limit]);
+    let nodeCount = 0;
+    for (const entity of entities.rows) {
+      const cypher = `CREATE (:Entity {id: ${q(entity.id)}, name: ${q(entity.name)}, type: ${q(entity.type)}})`;
+      await age.query(`SELECT * FROM cypher(${sqlString(graph)}, $$ ${cypher} $$) AS (v agtype)`);
+      nodeCount++;
+      if (nodeCount % 250 === 0) {
+        job.update({ current: nodeCount, total: limit, label: `Loaded ${nodeCount} AGE nodes` });
+        await politeBatchPause(250);
+      }
+    }
+    const relationships = await source.query(`SELECT source_entity_id, target_entity_id, type, confidence FROM memory.relationships ORDER BY id LIMIT $1`, [limit * 2]);
+    let edgeCount = 0;
+    for (const rel of relationships.rows) {
+      const cypher = `MATCH (a:Entity {id: ${q(rel.source_entity_id)}}), (b:Entity {id: ${q(rel.target_entity_id)}}) CREATE (a)-[:RELATED {type: ${q(rel.type)}}]->(b)`;
+      await age.query(`SELECT * FROM cypher(${sqlString(graph)}, $$ ${cypher} $$) AS (e agtype)`);
+      edgeCount++;
+      if (edgeCount % 500 === 0) {
+        job.update({ current: nodeCount + edgeCount, total: limit * 3, label: `Loaded ${nodeCount} nodes, ${edgeCount} edges` });
+        await politeBatchPause(250);
+      }
+    }
+    process.stderr.write(`[age-ontology-load] Loaded ${nodeCount} nodes and ${edgeCount} edges into ${graph}.
+`);
+    job.complete();
+  } finally {
+    await age.end();
+    await source.end();
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`[age-ontology-load] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});