@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-WP3PVBBP.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/pipeline-router.ts
+import crypto from "crypto";
+async function sinkConversationStore(msg, agentResponse, agentName) {
+  try {
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const mediaJson = msg.media ? JSON.stringify(msg.media) : null;
+    await client.execute({
+      sql: `INSERT INTO conversations
+            (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
+             recipient_id, channel_id, thread_id, reply_to_id,
+             content_text, content_media, agent_response, agent_name,
+             timestamp, ingested_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        msg.platform,
+        msg.messageId,
+        msg.senderId,
+        msg.senderName ?? null,
+        msg.senderPhone ?? null,
+        msg.senderEmail ?? null,
+        msg.accountId ?? null,
+        msg.channelId,
+        msg.threadId ?? `${msg.platform}:${msg.channelId}`,
+        msg.replyTo?.messageId ?? null,
+        msg.text ?? null,
+        mediaJson,
+        agentResponse ?? null,
+        agentName ?? null,
+        msg.timestamp,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] conversation-store error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkMemory(msg, agentResponse, agentName) {
+  try {
+    const { embed } = await import("./lib/embedder.js");
+    const { writeMemory, flushBatch } = await import("./lib/store.js");
+    const direction = agentResponse ? "conversation" : "inbound";
+    const rawText = [
+      `[${msg.platform}] ${direction} from ${msg.senderName ?? msg.senderId}`,
+      msg.text ? `Message: ${msg.text}` : null,
+      agentResponse ? `Agent (${agentName ?? "unknown"}): ${agentResponse}` : null
+    ].filter(Boolean).join("\n");
+    const vector = await embed(rawText);
+    await writeMemory({
+      id: crypto.randomUUID(),
+      agent_id: agentName ?? "gateway",
+      agent_role: "gateway",
+      session_id: `gateway-${msg.platform}`,
+      timestamp: msg.timestamp,
+      tool_name: `gateway-${msg.platform}`,
+      project_name: "exe-os",
+      has_error: false,
+      raw_text: rawText,
+      vector,
+      importance: 4,
+      confidence: 0.8
+    });
+    await flushBatch();
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] memory-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkCRM(msg, agentResponse, agentName) {
+  try {
+    const { isCRMBridgeEnabled, pushConversationToCRM, pushInboundMessageToCRM } = await import("./crm-bridge-BVTB6LZK.js");
+    if (!isCRMBridgeEnabled()) return false;
+    if (agentResponse) {
+      await pushConversationToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        agentResponse,
+        agentName: agentName ?? "unknown",
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    } else {
+      await pushInboundMessageToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] crm-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkWiki(msg, agentResponse) {
+  try {
+    const { createWikiClient } = await import("./wiki-client-GBPR45BQ.js");
+    const client = await createWikiClient();
+    if (!client) return false;
+    const content = msg.text ?? "";
+    if (content.length < 50) return false;
+    const { chatInWorkspace } = await import("./wiki-client-GBPR45BQ.js");
+    const ingestText = [
+      `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
+      content,
+      agentResponse ? `
+Agent response: ${agentResponse}` : ""
+    ].join("\n");
+    await chatInWorkspace(client, "conversations", ingestText, "chat");
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] wiki-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkEntityExtraction(msg, agentResponse, agentName) {
+  try {
+    const { extractFromConversation } = await import("./conversation-entity-extractor-EYSI4DKM.js");
+    const { storeExtraction } = await import("./graph-rag-G3EG5Q6L.js");
+    if ((msg.text?.length ?? 0) < 20) return false;
+    if (msg.isHistorical) return false;
+    const extraction = await extractFromConversation(msg, agentResponse, agentName);
+    if (extraction.entities.length === 0) return false;
+    const client = getClient();
+    const memoryId = `conv:${msg.messageId}`;
+    await storeExtraction(client, extraction, memoryId, msg.timestamp);
+    import("./conversation-wiki-populator-L7O6F3BB.js").then(
+      ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
+    ).catch((err) => {
+      process.stderr.write(
+        `[pipeline] wiki-population error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] entity-extraction-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function ingest(msg, agentResponse, agentName) {
+  const errors = [];
+  const [conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted] = await Promise.all([
+    sinkConversationStore(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`conversation: ${e}`);
+      return false;
+    }),
+    sinkMemory(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`memory: ${e}`);
+      return false;
+    }),
+    sinkCRM(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`crm: ${e}`);
+      return false;
+    }),
+    sinkWiki(msg, agentResponse).catch((e) => {
+      errors.push(`wiki: ${e}`);
+      return false;
+    }),
+    sinkEntityExtraction(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`entity-extraction: ${e}`);
+      return false;
+    })
+  ]);
+  if (errors.length > 0) {
+    process.stderr.write(
+      `[pipeline] ${errors.length} sink error(s): ${errors.join("; ")}
+`
+    );
+  }
+  return { conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted, errors };
+}
+
+export {
+  ingest
+};

package/dist/chunk-WQEUY7DC.js

@@ -0,0 +1,129 @@
+import {
+  EMPLOYEES_PATH,
+  getClient,
+  isInitialized,
+  loadEmployees
+} from "./chunk-CHBHR5W6.js";
+import {
+  PLAN_LIMITS,
+  checkLicense,
+  isFeatureAllowed
+} from "./chunk-MOZ2YQ54.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-VXIMSRTO.js";
+
+// src/lib/plan-limits.ts
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+var PlanLimitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanLimitError";
+  }
+};
+var CACHE_PATH = path.join(EXE_AI_DIR, "license-cache.json");
+function getLicenseSync() {
+  try {
+    if (!existsSync(CACHE_PATH)) return freeLicense();
+    const raw = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+    if (!raw.token || typeof raw.token !== "string") return freeLicense();
+    const parts = raw.token.split(".");
+    if (parts.length !== 3) return freeLicense();
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const plan = payload.plan ?? "free";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email: payload.sub ?? "",
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return freeLicense();
+  }
+}
+function freeLicense() {
+  const limits = PLAN_LIMITS.free;
+  return {
+    valid: true,
+    plan: "free",
+    email: "",
+    expiresAt: null,
+    deviceLimit: limits.devices,
+    employeeLimit: limits.employees,
+    memoryLimit: limits.memories
+  };
+}
+async function countActiveMemories() {
+  if (!isInitialized()) return 0;
+  const client = getClient();
+  const result = await client.execute(
+    "SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL"
+  );
+  const row = result.rows[0];
+  return Number(row?.cnt ?? 0);
+}
+async function assertMemoryLimit() {
+  const license = await checkLicense();
+  if (license.memoryLimit < 0) return;
+  const count = await countActiveMemories();
+  if (count >= license.memoryLimit) {
+    throw new PlanLimitError(
+      `Memory limit reached: ${count}/${license.memoryLimit} active memories on the ${license.plan} plan. Upgrade at https://askexe.com to store more.`
+    );
+  }
+}
+async function assertEmployeeLimit(license, rosterPath) {
+  const lic = license ?? await checkLicense();
+  if (lic.employeeLimit < 0) return;
+  const employees = await loadEmployees(rosterPath ?? EMPLOYEES_PATH);
+  if (employees.length >= lic.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${employees.length}/${lic.employeeLimit} employees on the ${lic.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+function assertEmployeeLimitSync(rosterPath) {
+  const license = getLicenseSync();
+  if (license.employeeLimit < 0) return;
+  const filePath = rosterPath ?? EMPLOYEES_PATH;
+  let count = 0;
+  try {
+    if (existsSync(filePath)) {
+      const raw = readFileSync(filePath, "utf8");
+      const employees = JSON.parse(raw);
+      count = Array.isArray(employees) ? employees.length : 0;
+    }
+  } catch {
+    throw new PlanLimitError(
+      `Cannot verify employee count: roster unreadable at ${filePath}. Refusing to proceed. Check file permissions or upgrade plan.`
+    );
+  }
+  if (count >= license.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${count}/${license.employeeLimit} employees on the ${license.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+async function assertFeature(feature) {
+  const license = await checkLicense();
+  if (!isFeatureAllowed(license, feature)) {
+    throw new PlanLimitError(
+      `Feature "${feature}" requires a paid plan. Current plan: ${license.plan}. Upgrade at https://askexe.com.`
+    );
+  }
+}
+
+export {
+  PlanLimitError,
+  getLicenseSync,
+  countActiveMemories,
+  assertMemoryLimit,
+  assertEmployeeLimit,
+  assertEmployeeLimitSync,
+  assertFeature
+};

package/dist/chunk-WWPJTPPQ.js

@@ -0,0 +1,197 @@
+import {
+  initStore
+} from "./chunk-DYXJFUCI.js";
+import {
+  getClient,
+  isInitialized
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/schedules.ts
+import crypto from "crypto";
+import { execSync } from "child_process";
+var CRON_FIELD = /^[\d*/,\-]+$/;
+function isValidCron(cron) {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) return false;
+  return fields.every((f) => CRON_FIELD.test(f));
+}
+var SAFE_ID = /^[a-zA-Z0-9_\-]+$/;
+function isValidScheduleId(id) {
+  return SAFE_ID.test(id) && id.length <= 128;
+}
+async function ensureDb() {
+  if (!isInitialized()) {
+    await initStore();
+  }
+}
+function parseHumanCron(input) {
+  const s = input.toLowerCase().trim();
+  if (/^[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+\s+[\d*\/,-]+$/.test(s)) {
+    return s;
+  }
+  const dayMap = {
+    sunday: "0",
+    sun: "0",
+    monday: "1",
+    mon: "1",
+    tuesday: "2",
+    tue: "2",
+    wednesday: "3",
+    wed: "3",
+    thursday: "4",
+    thu: "4",
+    friday: "5",
+    fri: "5",
+    saturday: "6",
+    sat: "6"
+  };
+  const everyMatch = s.match(/every\s+(\d+)\s*([mh])/);
+  if (everyMatch) {
+    const n = everyMatch[1];
+    const unit = everyMatch[2];
+    if (unit === "m") return `*/${n} * * * *`;
+    if (unit === "h") return `0 */${n} * * *`;
+  }
+  let hour = -1;
+  let minute = 0;
+  if (/midnight/.test(s)) {
+    hour = 0;
+  } else if (/noon/.test(s)) {
+    hour = 12;
+  } else {
+    const timeMatch = s.match(/(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/);
+    if (timeMatch) {
+      hour = parseInt(timeMatch[1], 10);
+      minute = timeMatch[2] ? parseInt(timeMatch[2], 10) : 0;
+      if (timeMatch[3] === "pm" && hour < 12) hour += 12;
+      if (timeMatch[3] === "am" && hour === 12) hour = 0;
+    }
+  }
+  if (hour === -1) hour = 0;
+  let dow = "*";
+  if (/weekday|weekdays/.test(s)) {
+    dow = "1-5";
+  } else if (/weekend|weekends/.test(s)) {
+    dow = "0,6";
+  } else {
+    for (const [name, val] of Object.entries(dayMap)) {
+      if (s.includes(name)) {
+        dow = val;
+        break;
+      }
+    }
+  }
+  return `${minute} ${hour} * * ${dow}`;
+}
+async function createSchedule(input) {
+  if (!isValidCron(input.cron)) {
+    throw new Error(`Invalid cron expression: ${input.cron}. Must be 5 fields with only digits, *, /, -, comma.`);
+  }
+  await ensureDb();
+  const client = getClient();
+  const id = crypto.randomUUID().slice(0, 8);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const prompt = input.prompt ?? input.description;
+  await client.execute({
+    sql: `INSERT INTO schedules (id, cron, description, job_type, prompt, assigned_to, project_name, active, use_crontab, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [
+      id,
+      input.cron,
+      input.description,
+      input.jobType ?? "report",
+      prompt,
+      input.assignedTo ?? null,
+      input.projectName ?? null,
+      input.useCrontab ? 1 : 0,
+      now
+    ]
+  });
+  if (input.useCrontab) {
+    addToCrontab(id, input.cron, prompt, input.projectName);
+  }
+  return {
+    id,
+    cron: input.cron,
+    description: input.description,
+    jobType: input.jobType ?? "report",
+    prompt,
+    assignedTo: input.assignedTo,
+    projectName: input.projectName,
+    active: true,
+    useCrontab: input.useCrontab ?? false,
+    createdAt: now
+  };
+}
+async function listSchedules(activeOnly = true) {
+  await ensureDb();
+  const client = getClient();
+  const sql = activeOnly ? "SELECT * FROM schedules WHERE active = 1 ORDER BY created_at ASC" : "SELECT * FROM schedules ORDER BY created_at ASC";
+  const result = await client.execute({ sql, args: [] });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    cron: String(row.cron),
+    description: String(row.description),
+    jobType: String(row.job_type),
+    prompt: row.prompt ? String(row.prompt) : void 0,
+    assignedTo: row.assigned_to ? String(row.assigned_to) : void 0,
+    projectName: row.project_name ? String(row.project_name) : void 0,
+    active: Number(row.active) === 1,
+    useCrontab: Number(row.use_crontab) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+async function deleteSchedule(id) {
+  await ensureDb();
+  const client = getClient();
+  const existing = await client.execute({
+    sql: "SELECT use_crontab FROM schedules WHERE id = ?",
+    args: [id]
+  });
+  if (existing.rows.length === 0) return false;
+  const usesCrontab = Number(existing.rows[0].use_crontab) === 1;
+  await client.execute({
+    sql: "DELETE FROM schedules WHERE id = ?",
+    args: [id]
+  });
+  if (usesCrontab) {
+    removeFromCrontab(id);
+  }
+  return true;
+}
+function addToCrontab(id, cron, prompt, projectDir) {
+  if (!isValidCron(cron)) {
+    throw new Error(`Invalid cron expression: ${cron}`);
+  }
+  if (!isValidScheduleId(id)) {
+    throw new Error(`Invalid schedule ID: ${id}`);
+  }
+  try {
+    const cwd = projectDir ? `cd ${JSON.stringify(projectDir)} && ` : "";
+    const escapedPrompt = prompt.replace(/"/g, '\\"');
+    const entry = `${cron} ${cwd}claude -p --dangerously-skip-permissions "${escapedPrompt}" # exe-schedule:${id}`;
+    execSync(
+      `(crontab -l 2>/dev/null; echo ${JSON.stringify(entry)}) | crontab -`,
+      { timeout: 5e3, stdio: "ignore" }
+    );
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Invalid")) throw err;
+  }
+}
+function removeFromCrontab(id) {
+  if (!isValidScheduleId(id)) return;
+  try {
+    execSync(
+      `crontab -l 2>/dev/null | grep -v "exe-schedule:${id}" | crontab -`,
+      { timeout: 5e3, stdio: "ignore" }
+    );
+  } catch {
+  }
+}
+
+export {
+  parseHumanCron,
+  createSchedule,
+  listSchedules,
+  deleteSchedule
+};