@askexenow/exe-os 0.9.273 → 0.9.274

package/dist/chunk-BSWNP5GP.js

@@ -0,0 +1,197 @@
+import {
+  initStore
+} from "./chunk-ZPBCPDB3.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
+};

package/dist/chunk-EWQLQZNS.js

@@ -0,0 +1,345 @@
+import {
+  employeeSessionName,
+  isEmployeeAlive,
+  resolveExeSession,
+  sendIntercom,
+  strictSessionScopeFilter
+} from "./chunk-3FZQAO7A.js";
+import {
+  parseMessage,
+  serializeMessage
+} from "./chunk-4JERP7NT.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-2NQQP3FF.js";
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/messaging.ts
+import crypto from "crypto";
+function generateUlid() {
+  const timestamp = Date.now().toString(36).padStart(10, "0");
+  const random = crypto.randomBytes(10).toString("hex").slice(0, 16);
+  return (timestamp + random).toUpperCase();
+}
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    fromAgent: row.from_agent,
+    fromDevice: row.from_device,
+    targetAgent: row.target_agent,
+    targetProject: row.target_project ?? null,
+    targetDevice: row.target_device,
+    sessionScope: row.session_scope ?? null,
+    content: row.content,
+    priority: row.priority ?? "normal",
+    status: row.status ?? "pending",
+    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
+    retryCount: Number(row.retry_count ?? 0),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at ?? null,
+    processedAt: row.processed_at ?? null,
+    failedAt: row.failed_at ?? null,
+    failureReason: row.failure_reason ?? null
+  };
+}
+var MAX_RETRIES = 10;
+async function countUnreadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) AS count FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [targetAgent, ...scope.args]
+  });
+  return Number(result.rows[0]?.count ?? 0);
+}
+async function sendMessage(input) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input.targetDevice ?? "local";
+  const sessionScope = input.sessionScope === void 0 ? resolveExeSession() : input.sessionScope;
+  await client.execute({
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, session_scope, content, priority, status, founder_id, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`,
+    args: [
+      id,
+      input.fromAgent,
+      input.targetAgent,
+      input.targetProject ?? null,
+      targetDevice,
+      sessionScope,
+      input.content,
+      input.priority ?? "normal",
+      input.founderId ?? null,
+      now
+    ]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.sent",
+    source: "messaging.sendMessage",
+    agentId: input.fromAgent,
+    payload: { targetAgent: input.targetAgent, priority: input.priority ?? "normal", targetDevice },
+    sessionScope: sessionScope ?? null
+  });
+  try {
+    if (targetDevice !== "local") {
+      await deliverCrossMachineMessage(id, targetDevice);
+    } else {
+      await deliverLocalMessage(id);
+    }
+  } catch {
+  }
+  const sentScope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
+    args: [id, ...sentScope.args]
+  });
+  return rowToMessage(result.rows[0]);
+}
+var _wsClientSend = null;
+function setWsClientSend(fn) {
+  _wsClientSend = fn;
+}
+async function deliverCrossMachineMessage(messageId, targetDevice) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  if (!_wsClientSend) {
+    return false;
+  }
+  const payload = JSON.stringify({
+    id: msg.id,
+    fromAgent: msg.fromAgent,
+    targetAgent: msg.targetAgent,
+    targetProject: msg.targetProject,
+    sessionScope: msg.sessionScope,
+    content: msg.content,
+    priority: msg.priority,
+    createdAt: msg.createdAt
+  });
+  const sent = _wsClientSend(targetDevice, payload);
+  if (sent) {
+    await client.execute({
+      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
+      args: [messageId]
+    });
+    return true;
+  }
+  return false;
+}
+async function deliverLocalMessage(messageId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  const targetAgent = msg.targetAgent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      throw new Error("No coordinator session found");
+    }
+    process.stderr.write(`[messaging] ENTER deliverLocal: target=${targetAgent} exeSession=${exeSession}
+`);
+    const { isCoordinatorName: isCoord } = await import("./lib/employees.js");
+    const isCOO = isCoord(targetAgent);
+    process.stderr.write(`[messaging] COO check: targetAgent="${targetAgent}" isCOO=${isCOO}
+`);
+    const sessionName = isCOO ? exeSession : employeeSessionName(targetAgent, exeSession);
+    process.stderr.write(`[messaging] delivery attempt: target=${targetAgent} session=${sessionName} isCOO=${isCOO}
+`);
+    if (!isCOO && !isEmployeeAlive(sessionName)) {
+      throw new Error("Session not running \u2014 message stays queued");
+    }
+    const unreadCount = await countUnreadMessages(targetAgent, msg.sessionScope);
+    if (unreadCount <= 0) {
+      return false;
+    }
+    const intercomResult = sendIntercom(sessionName, { force: true, reason: "message" });
+    process.stderr.write(`[messaging] intercom result for ${sessionName}: ${intercomResult}
+`);
+    await client.execute({
+      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
+      args: [now, messageId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "message.delivered",
+      source: "messaging.deliverLocalMessage",
+      agentId: msg.targetAgent,
+      payload: { fromAgent: msg.fromAgent, priority: msg.priority }
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[messaging] delivery failed for message ${messageId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES) {
+      await markFailed(messageId, "session unavailable after 10 retries", msg.sessionScope);
+    } else {
+      await client.execute({
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
+      });
+    }
+    return false;
+  }
+}
+async function getPendingMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markRead(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'read'
+          WHERE id = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.read",
+    source: "messaging.markRead",
+    payload: { messageId }
+  });
+}
+async function markAcknowledged(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'acknowledged', processed_at = ?
+          WHERE id = ? AND status = 'read'${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function markProcessed(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'processed', processed_at = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function getMessageStatus(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT status FROM messages WHERE id = ?${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  return result.rows[0]?.status ?? null;
+}
+async function getUnacknowledgedMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function getReadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status = 'read'${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markFailed(messageId, reason, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId, ...scope.args]
+  });
+}
+async function getFailedMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE status = 'failed'${scope.sql} ORDER BY created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function retryPendingMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE status = 'pending' AND retry_count < ?${scope.sql}
+          ORDER BY id`,
+    args: [MAX_RETRIES, ...scope.args]
+  });
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
+    try {
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
+    } catch {
+    }
+  }
+  return delivered;
+}
+async function sendTypedMessage(envelope, targetAgent, opts) {
+  return sendMessage({
+    fromAgent: envelope.from,
+    targetAgent,
+    targetProject: opts?.targetProject,
+    targetDevice: opts?.targetDevice,
+    content: serializeMessage(envelope),
+    priority: opts?.priority,
+    sessionScope: opts?.sessionScope
+  });
+}
+function parseIncomingMessage(content) {
+  return parseMessage(content);
+}
+
+export {
+  countUnreadMessages,
+  sendMessage,
+  setWsClientSend,
+  deliverLocalMessage,
+  getPendingMessages,
+  markRead,
+  markAcknowledged,
+  markProcessed,
+  getMessageStatus,
+  getUnacknowledgedMessages,
+  getReadMessages,
+  markFailed,
+  getFailedMessages,
+  retryPendingMessages,
+  sendTypedMessage,
+  parseIncomingMessage
+};

package/dist/chunk-FC5WORMP.js

@@ -0,0 +1,81 @@
+// src/bin/fast-db-init.ts
+async function fastDbInit() {
+  const { isInitialized, getClient, setExternalClient } = await import("./lib/database.js");
+  if (isInitialized()) {
+    return getClient();
+  }
+  const forceDirect = process.env.EXE_DB_DIRECT === "1" || process.env.EXE_DB_READONLY === "1" || process.env.EXE_SKIP_DAEMON === "1";
+  if (!forceDirect) {
+    try {
+      const { connectEmbedDaemon, sendDaemonRequest, isClientConnected, disconnectClient } = await import("./lib/exe-daemon-client.js");
+      const { deserializeResultSet } = await import("./daemon-protocol-XW2OLNBS.js");
+      await Promise.race([
+        connectEmbedDaemon(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Daemon socket timeout (2s)")), 2e3))
+      ]);
+      if (isClientConnected()) {
+        const daemonClient = {
+          async execute(stmt) {
+            const sql = typeof stmt === "string" ? stmt : stmt.sql;
+            const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+            const resp = await sendDaemonRequest({ type: "db-execute", sql, args });
+            if (resp.error) throw new Error(String(resp.error));
+            if (resp.db) return deserializeResultSet(resp.db);
+            throw new Error("Unexpected daemon response");
+          },
+          async batch(stmts, mode) {
+            const statements = stmts.map((s) => {
+              const sql = typeof s === "string" ? s : s.sql;
+              const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+              return { sql, args };
+            });
+            const resp = await sendDaemonRequest({ type: "db-batch", statements, mode: mode ?? "deferred" });
+            if (resp.error) throw new Error(String(resp.error));
+            const batchResults = resp["db-batch"];
+            if (batchResults) return batchResults.map(deserializeResultSet);
+            throw new Error("Unexpected daemon batch response");
+          },
+          async transaction(_mode) {
+            throw new Error("Transactions not supported via daemon socket");
+          },
+          async executeMultiple(_sql) {
+            throw new Error("executeMultiple not supported via daemon socket");
+          },
+          async migrate(_stmts) {
+            throw new Error("migrate not supported via daemon socket");
+          },
+          sync() {
+            return Promise.resolve(void 0);
+          },
+          close() {
+          },
+          get closed() {
+            return false;
+          },
+          get protocol() {
+            return "file";
+          }
+        };
+        try {
+          await daemonClient.execute("SELECT 1");
+        } catch {
+          try {
+            disconnectClient();
+          } catch {
+          }
+          throw new Error("Daemon socket validation failed");
+        }
+        setExternalClient(daemonClient);
+        return daemonClient;
+      }
+    } catch {
+    }
+  }
+  const { initStore } = await import("./lib/store.js");
+  await initStore({ lightweight: true });
+  return getClient();
+}
+
+export {
+  fastDbInit
+};