@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/cto-delegation-gate-XWHZCUJH.js

@@ -0,0 +1,208 @@
+import {
+  init_task_scope,
+  sessionScopeFilter
+} from "./chunk-N7L33TED.js";
+import "./chunk-NEAHEC5G.js";
+import "./chunk-KRLOFIPI.js";
+import "./chunk-R4M6XCMU.js";
+import "./chunk-TYLF4LSW.js";
+import "./chunk-PJHHFJAN.js";
+import "./chunk-YOQKMB6N.js";
+import "./chunk-JT76KRZQ.js";
+import "./chunk-6M5II4EV.js";
+import "./chunk-HP43GLZ6.js";
+import "./chunk-ELE2C7L4.js";
+import "./chunk-WZQ4CPRG.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+import "./chunk-4NYQAS33.js";
+import "./chunk-OFK72LTZ.js";
+import "./chunk-6BFIFI5F.js";
+import {
+  getEmployeeByRole,
+  init_employees,
+  loadEmployeesSync
+} from "./chunk-RUG3N6P4.js";
+import "./chunk-IRQTM7DY.js";
+import "./chunk-KVPG5UT6.js";
+import "./chunk-X2IMCCM5.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/lib/cto-delegation-gate.ts
+init_database();
+init_task_scope();
+init_employees();
+import os from "os";
+import path from "path";
+import { existsSync, readFileSync, statSync } from "fs";
+var GATED_ROLE = "CTO";
+function resolveGatedAgent() {
+  try {
+    const employees = loadEmployeesSync();
+    const cto = getEmployeeByRole(employees, GATED_ROLE);
+    return cto?.name ?? "";
+  } catch {
+    return "";
+  }
+}
+var GATED_AGENT = resolveGatedAgent();
+function getGatedAgent() {
+  return resolveGatedAgent() || GATED_AGENT;
+}
+var BLOCKED_PATH_PREFIXES = [
+  "src/",
+  "tests/",
+  "scripts/",
+  "bin/",
+  ".github/workflows/",
+  ".claude/skills/"
+];
+var BLOCKED_FILENAMES = [
+  "package.json",
+  "tsconfig.json",
+  "docker-compose.yml"
+];
+var BLOCKED_DOCKERFILE_PREFIX = "Dockerfile";
+var BLOCKED_EXTENSIONS = [
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".rs",
+  ".py",
+  ".go",
+  ".sh",
+  ".yaml",
+  ".yml",
+  ".prisma",
+  ".sql"
+];
+var EXEMPT_MD_DIR_PREFIXES = [
+  ".planning/",
+  "exe/output/",
+  "exe/",
+  "docs/"
+];
+var RECENT_DISPATCH_WINDOW_MS = 5 * 60 * 1e3;
+var SCRATCHPAD_MAX_AGE_MS = 10 * 60 * 1e3;
+var SCRATCHPAD_ESCAPE_PATTERN = /^(?:ENGINEER|TOM)-CAPABLE:\s*NO\s*—\s*reason:\s*\S+/m;
+function toWorkspaceRelative(filePath, cwd = process.cwd()) {
+  const normalized = path.normalize(filePath);
+  if (normalized.startsWith(cwd + path.sep)) {
+    return normalized.slice(cwd.length + 1);
+  }
+  if (path.isAbsolute(normalized)) {
+    return path.basename(normalized);
+  }
+  return normalized;
+}
+function isDockerfile(basename) {
+  return basename === BLOCKED_DOCKERFILE_PREFIX || basename.startsWith(`${BLOCKED_DOCKERFILE_PREFIX}.`);
+}
+function classifyPath(filePath, cwd) {
+  const rel = toWorkspaceRelative(filePath, cwd);
+  const basename = path.basename(rel);
+  const ext = path.extname(rel).toLowerCase();
+  if (ext === ".md") {
+    for (const prefix of EXEMPT_MD_DIR_PREFIXES) {
+      if (rel.startsWith(prefix)) return "exempt";
+    }
+    if (!BLOCKED_PATH_PREFIXES.some((p) => rel.startsWith(p))) {
+      return "exempt";
+    }
+  }
+  if (BLOCKED_FILENAMES.includes(basename)) return "code";
+  if (isDockerfile(basename)) return "code";
+  if (BLOCKED_EXTENSIONS.includes(ext)) return "code";
+  if (BLOCKED_PATH_PREFIXES.some((p) => rel.startsWith(p))) return "code";
+  return "exempt";
+}
+async function hasRecentEngineerDispatch(now = Date.now()) {
+  try {
+    const client = getClient();
+    const engineers = loadEmployeesSync().filter(
+      (e) => e.role.toLowerCase() === "principal engineer"
+    );
+    const engineerNames = engineers.map((e) => e.name);
+    const gatedAgent = getGatedAgent();
+    if (!gatedAgent) return false;
+    if (engineerNames.length === 0) return false;
+    const placeholders = engineerNames.map(() => "?").join(",");
+    const ydScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT MAX(created_at) AS last_dispatch
+            FROM tasks
+            WHERE assigned_by = ? AND assigned_to IN (${placeholders})${ydScope.sql}`,
+      args: [gatedAgent, ...engineerNames, ...ydScope.args]
+    });
+    const raw = result.rows[0]?.last_dispatch;
+    if (raw === null || raw === void 0) return false;
+    const parsed = Date.parse(String(raw));
+    if (Number.isNaN(parsed)) return false;
+    return now - parsed <= RECENT_DISPATCH_WINDOW_MS;
+  } catch {
+    return false;
+  }
+}
+function scratchpadPath(sessionId, homeDir = os.homedir()) {
+  return path.join(
+    homeDir,
+    ".exe-os",
+    "session-cache",
+    `cto-scratchpad-${sessionId}.txt`
+  );
+}
+function hasValidScratchpadEscape(sessionId, now = Date.now(), homeDir = os.homedir()) {
+  const paths = [scratchpadPath(sessionId, homeDir)];
+  for (const filePath of paths) {
+    if (!existsSync(filePath)) continue;
+    try {
+      const stat = statSync(filePath);
+      if (now - stat.mtimeMs > SCRATCHPAD_MAX_AGE_MS) continue;
+      const body = readFileSync(filePath, "utf-8");
+      if (SCRATCHPAD_ESCAPE_PATTERN.test(body)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var GATE_BLOCK_MESSAGE = [
+  "ACTION BLOCKED by CTO delegation gate. Your Write/Edit was DENIED \u2014 it did NOT execute.",
+  "This edit looks implementable by an engineer. You MUST either:",
+  "  1. Dispatch create_task to an engineer, OR",
+  "  2. Add ENGINEER-CAPABLE: NO with explicit reason to proceed yourself.",
+  "Do NOT report this action as successful. It was blocked. No file was changed.",
+  "If you are a sub-agent, report this FAILURE to your parent agent."
+].join("\n");
+async function evaluateDelegationGate(opts) {
+  const gatedAgent = getGatedAgent();
+  if (!gatedAgent || opts.agentId !== gatedAgent) {
+    return { outcome: "allow", reason: "agent_not_gated" };
+  }
+  if (!/^(Write|Edit)$/.test(opts.toolName)) {
+    return { outcome: "allow", reason: "tool_not_gated" };
+  }
+  if (classifyPath(opts.filePath, opts.cwd) === "exempt") {
+    return { outcome: "allow", reason: "exempt_path" };
+  }
+  if (await hasRecentEngineerDispatch(opts.now)) {
+    return { outcome: "allow", reason: "recent_engineer_dispatch" };
+  }
+  if (hasValidScratchpadEscape(opts.sessionId, opts.now, opts.homeDir)) {
+    return { outcome: "allow", reason: "scratchpad_escape" };
+  }
+  return { outcome: "block", reason: "no_delegation_no_escape" };
+}
+export {
+  GATED_AGENT,
+  GATED_ROLE,
+  GATE_BLOCK_MESSAGE,
+  classifyPath,
+  evaluateDelegationGate,
+  getGatedAgent,
+  hasRecentEngineerDispatch,
+  hasValidScratchpadEscape,
+  scratchpadPath
+};

package/dist/daemon-auth-GWUXTUYO.js

@@ -0,0 +1,15 @@
+import {
+  DAEMON_TOKEN_PATH,
+  ensureDaemonToken,
+  init_daemon_auth,
+  readDaemonToken
+} from "./chunk-NXFJHTED.js";
+import "./chunk-KVPG5UT6.js";
+import "./chunk-X2IMCCM5.js";
+import "./chunk-KFQGP6VL.js";
+init_daemon_auth();
+export {
+  DAEMON_TOKEN_PATH,
+  ensureDaemonToken,
+  readDaemonToken
+};

package/dist/daemon-orchestration-2C3TVOHO.js

@@ -0,0 +1,91 @@
+import {
+  AUTO_WAKE_COOLDOWN_MS,
+  AUTO_WAKE_MAX_RETRIES,
+  IDLE_KILL_INTERCOM_ACK_WINDOW_MS,
+  IDLE_NUDGE_DEDUP_MS,
+  ORPHAN_PATTERNS,
+  ORPHAN_SIGKILL_DELAY_MS,
+  REVIEW_NUDGE_COOLDOWN_MS,
+  SESSION_CONTEXT_THRESHOLD_PCT,
+  SESSION_TTL_HOURS,
+  STUCK_TASK_GRACE_MS,
+  _resetAutoWakeState,
+  checkSessionTTL,
+  classifyTtlKillReason,
+  createAutoWakeRealDeps,
+  createIdleKillRealDeps,
+  createIdleNudgeRealDeps,
+  createOrphanReaperRealDeps,
+  createReviewNudgeRealDeps,
+  createSessionTTLRealDeps,
+  createStuckTaskRealDeps,
+  loadNudgeState,
+  pollIdleEmployees,
+  pollIdleKill,
+  pollOrphanedTasks,
+  pollReviewNudge,
+  reapOrphanedMcpProcesses,
+  releaseStuckTasks,
+  saveNudgeState,
+  shouldAutoWake,
+  shouldKillIdleSession,
+  shouldKillSession,
+  shouldNudgeEmployee
+} from "./chunk-CFIM43JH.js";
+import "./chunk-IHDHL5ML.js";
+import "./chunk-DC4ZD76Y.js";
+import "./chunk-N7L33TED.js";
+import "./chunk-NEAHEC5G.js";
+import "./chunk-KRLOFIPI.js";
+import "./chunk-R4M6XCMU.js";
+import "./chunk-TYLF4LSW.js";
+import "./chunk-PJHHFJAN.js";
+import "./chunk-YOQKMB6N.js";
+import "./chunk-JT76KRZQ.js";
+import "./chunk-6M5II4EV.js";
+import "./chunk-HP43GLZ6.js";
+import "./chunk-ELE2C7L4.js";
+import "./chunk-WZQ4CPRG.js";
+import "./chunk-A2NZP64U.js";
+import "./chunk-4NYQAS33.js";
+import "./chunk-OFK72LTZ.js";
+import "./chunk-6BFIFI5F.js";
+import "./chunk-RUG3N6P4.js";
+import "./chunk-IRQTM7DY.js";
+import "./chunk-KVPG5UT6.js";
+import "./chunk-X2IMCCM5.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AUTO_WAKE_COOLDOWN_MS,
+  AUTO_WAKE_MAX_RETRIES,
+  IDLE_KILL_INTERCOM_ACK_WINDOW_MS,
+  IDLE_NUDGE_DEDUP_MS,
+  ORPHAN_PATTERNS,
+  ORPHAN_SIGKILL_DELAY_MS,
+  REVIEW_NUDGE_COOLDOWN_MS,
+  SESSION_CONTEXT_THRESHOLD_PCT,
+  SESSION_TTL_HOURS,
+  STUCK_TASK_GRACE_MS,
+  _resetAutoWakeState,
+  checkSessionTTL,
+  classifyTtlKillReason,
+  createAutoWakeRealDeps,
+  createIdleKillRealDeps,
+  createIdleNudgeRealDeps,
+  createOrphanReaperRealDeps,
+  createReviewNudgeRealDeps,
+  createSessionTTLRealDeps,
+  createStuckTaskRealDeps,
+  loadNudgeState,
+  pollIdleEmployees,
+  pollIdleKill,
+  pollOrphanedTasks,
+  pollReviewNudge,
+  reapOrphanedMcpProcesses,
+  releaseStuckTasks,
+  saveNudgeState,
+  shouldAutoWake,
+  shouldKillIdleSession,
+  shouldKillSession,
+  shouldNudgeEmployee
+};

package/dist/daemon-protocol-RLH2XM2K.js

@@ -0,0 +1,19 @@
+import {
+  deserializeArgs,
+  deserializeResultSet,
+  deserializeValue,
+  init_daemon_protocol,
+  serializeArgs,
+  serializeResultSet,
+  serializeValue
+} from "./chunk-MFO7MNSD.js";
+import "./chunk-KFQGP6VL.js";
+init_daemon_protocol();
+export {
+  deserializeArgs,
+  deserializeResultSet,
+  deserializeValue,
+  serializeArgs,
+  serializeResultSet,
+  serializeValue
+};

package/dist/db-backup-CH2KG3JY.js

@@ -0,0 +1,23 @@
+import {
+  createBackup,
+  findActiveDb,
+  getBackupDir,
+  getLatestBackup,
+  hasBackupToday,
+  init_db_backup,
+  listBackups,
+  rotateBackups
+} from "./chunk-NDYSNVI5.js";
+import "./chunk-KVPG5UT6.js";
+import "./chunk-X2IMCCM5.js";
+import "./chunk-KFQGP6VL.js";
+init_db_backup();
+export {
+  createBackup,
+  findActiveDb,
+  getBackupDir,
+  getLatestBackup,
+  hasBackupToday,
+  listBackups,
+  rotateBackups
+};

package/dist/devtools-PLJCAU53.js

@@ -0,0 +1,8 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/tui/ink/devtools.js
+function connectDevtools() {
+}
+export {
+  connectDevtools as default
+};

package/dist/discord-G4BQJ2VX.js

@@ -0,0 +1,7 @@
+import {
+  DiscordAdapter
+} from "./chunk-N5RRQOAC.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  DiscordAdapter
+};

package/dist/email-XMRNMFXR.js

@@ -0,0 +1,137 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/gateway/adapters/email.ts
+import { randomUUID } from "crypto";
+import { createTransport } from "nodemailer";
+var SMTP_VERIFY_TIMEOUT_MS = 1e4;
+function extractEmailAddress(from) {
+  const match = from.match(/<([^>]+)>/);
+  return match?.[1] ?? from.trim();
+}
+function extractSenderName(from) {
+  const match = from.match(/^([^<]+)</);
+  const name = match?.[1]?.trim();
+  return name || void 0;
+}
+function mapContentType(contentType) {
+  if (contentType.startsWith("image/")) return "image";
+  if (contentType.startsWith("video/")) return "video";
+  if (contentType.startsWith("audio/")) return "audio";
+  return "document";
+}
+var EmailAdapter = class {
+  platform = "email";
+  transporter = null;
+  fromAddress = "";
+  messageHandler = null;
+  connected = false;
+  async connect(config) {
+    const {
+      smtp_host,
+      smtp_port,
+      smtp_user,
+      smtp_pass,
+      smtp_tls,
+      from_address
+    } = config.credentials;
+    if (!smtp_host || !smtp_user || !smtp_pass || !from_address) {
+      throw new Error(
+        "Email adapter requires smtp_host, smtp_user, smtp_pass, and from_address in credentials"
+      );
+    }
+    this.fromAddress = from_address;
+    this.transporter = createTransport({
+      host: smtp_host,
+      port: smtp_port ? parseInt(smtp_port, 10) : 587,
+      secure: smtp_tls === "true",
+      auth: {
+        user: smtp_user,
+        pass: smtp_pass
+      }
+    });
+    const check = await this.healthCheck();
+    if (!check.connected) {
+      throw new Error(`SMTP connection failed to ${smtp_host}`);
+    }
+    this.connected = true;
+    console.log(`[email] Connected to SMTP ${smtp_host}`);
+  }
+  async disconnect() {
+    if (this.transporter) {
+      this.transporter.close();
+      this.transporter = null;
+    }
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  /**
+   * Inject a raw inbound email payload from the WebhookServer.
+   * Parses the email fields and calls the registered message handler.
+   */
+  async injectMessage(rawPayload) {
+    if (!this.messageHandler) return;
+    const payload = rawPayload;
+    const from = payload.from ?? payload.envelope?.from ?? "";
+    const text = payload.text ?? "";
+    if (!from || !text) return;
+    const senderEmail = extractEmailAddress(from);
+    const media = this.extractMedia(payload);
+    const normalized = {
+      messageId: payload.message_id ?? randomUUID(),
+      platform: "email",
+      senderId: senderEmail,
+      senderName: extractSenderName(from),
+      channelId: senderEmail,
+      chatType: "direct",
+      text: payload.subject ? `[${payload.subject}] ${text}` : text,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      media,
+      raw: rawPayload
+    };
+    try {
+      await this.messageHandler(normalized);
+    } catch (err) {
+      console.error("[email] Message handler error:", err);
+    }
+  }
+  async sendText(channelId, text, options) {
+    if (!this.transporter) throw new Error("Email not connected");
+    await this.transporter.sendMail({
+      from: this.fromAddress,
+      to: channelId,
+      subject: options?.subject?.trim() || "Reply",
+      text
+    });
+  }
+  async sendTyping(_channelId) {
+  }
+  async healthCheck() {
+    if (!this.transporter) return { connected: this.connected };
+    const start = Date.now();
+    try {
+      await Promise.race([
+        this.transporter.verify(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("SMTP verify timeout")), SMTP_VERIFY_TIMEOUT_MS)
+        )
+      ]);
+      this.connected = true;
+      return { connected: true, latencyMs: Date.now() - start };
+    } catch {
+      this.connected = false;
+      return { connected: false };
+    }
+  }
+  extractMedia(payload) {
+    if (!payload.attachments?.length) return void 0;
+    return payload.attachments.map((att) => ({
+      type: mapContentType(att.content_type ?? "application/octet-stream"),
+      fileName: att.filename ?? void 0
+    }));
+  }
+};
+export {
+  EmailAdapter
+};