@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-RJT7H2KR.js

@@ -0,0 +1,349 @@
+// src/gateway/adapters/signal.ts
+import { randomUUID } from "crypto";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var POLL_INTERVAL_MS = 2e3;
+var SignalAdapter = class {
+  platform = "signal";
+  baseUrl = "";
+  account = "";
+  abortController = null;
+  messageHandler = null;
+  _connected = false;
+  pollTimer = null;
+  normalizeBaseUrl(url) {
+    const trimmed = url.trim();
+    if (/^https?:\/\//i.test(trimmed)) {
+      return trimmed.replace(/\/+$/, "");
+    }
+    return `http://${trimmed}`.replace(/\/+$/, "");
+  }
+  async connect(config) {
+    this.baseUrl = this.normalizeBaseUrl(
+      config.credentials.baseUrl ?? "localhost:8080"
+    );
+    this.account = config.credentials.account ?? "";
+    const check = await this.healthCheck();
+    if (!check.connected) {
+      throw new Error(
+        `signal-cli REST API not reachable at ${this.baseUrl}. Ensure bbernhard/signal-cli-rest-api container is running.`
+      );
+    }
+    this._connected = true;
+    this.abortController = new AbortController();
+    void this.startPolling();
+    void this.syncContacts().catch((err) => {
+      console.error("[signal] Contact sync failed:", err);
+    });
+    void this.syncGroups().catch((err) => {
+      console.error("[signal] Group sync failed:", err);
+    });
+  }
+  async disconnect() {
+    this.abortController?.abort();
+    this.abortController = null;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this._connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async sendText(channelId, text, _options) {
+    const isGroup = channelId.startsWith("group:");
+    const body = {
+      message: text,
+      number: this.account,
+      ...isGroup ? { recipients: [], group_id: channelId.slice("group:".length) } : { recipients: [channelId] }
+    };
+    const res = await fetch(`${this.baseUrl}/v2/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`Signal send failed (${res.status}): ${errText}`);
+    }
+  }
+  async sendTyping(channelId) {
+    try {
+      const isGroup = channelId.startsWith("group:");
+      const endpoint = isGroup ? `${this.baseUrl}/v1/typing-indicator/${this.account}` : `${this.baseUrl}/v1/typing-indicator/${this.account}`;
+      await fetch(endpoint, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          recipient: isGroup ? void 0 : channelId,
+          group_id: isGroup ? channelId.slice("group:".length) : void 0
+        }),
+        signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+      });
+    } catch {
+    }
+  }
+  async healthCheck() {
+    if (!this.baseUrl) return { connected: this._connected };
+    const start = Date.now();
+    try {
+      const res = await fetch(`${this.baseUrl}/v1/about`, {
+        method: "GET",
+        signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+      });
+      this._connected = res.ok;
+      return {
+        connected: this._connected,
+        latencyMs: Date.now() - start
+      };
+    } catch {
+      this._connected = false;
+      return { connected: false };
+    }
+  }
+  async startPolling() {
+    while (this.abortController && !this.abortController.signal.aborted) {
+      try {
+        await this.pollMessages();
+      } catch (err) {
+        if (this.abortController?.signal.aborted) return;
+        console.error("[signal] Poll error:", err);
+      }
+      await new Promise((resolve) => {
+        this.pollTimer = setTimeout(resolve, POLL_INTERVAL_MS);
+      });
+    }
+  }
+  async pollMessages() {
+    if (!this.account || !this.messageHandler) return;
+    const res = await fetch(
+      `${this.baseUrl}/v1/receive/${encodeURIComponent(this.account)}`,
+      {
+        method: "GET",
+        signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+      }
+    );
+    if (!res.ok) {
+      if (res.status === 400) {
+        return;
+      }
+      throw new Error(`Signal receive failed (${res.status})`);
+    }
+    const entries = await res.json();
+    if (!Array.isArray(entries) || entries.length === 0) return;
+    for (const entry of entries) {
+      await this.handleEntry(entry);
+    }
+  }
+  async handleEntry(entry) {
+    if (!this.messageHandler) return;
+    const envelope = entry.envelope;
+    if (!envelope) return;
+    const senderId = envelope.sourceNumber ?? envelope.source ?? envelope.sourceUuid ?? "";
+    if (envelope.dataMessage?.reaction) {
+      const rm = envelope.dataMessage.reaction;
+      if (rm.isRemove) return;
+      const normalized2 = {
+        messageId: randomUUID(),
+        platform: "signal",
+        senderId,
+        senderName: envelope.sourceName ?? void 0,
+        channelId: senderId,
+        chatType: "direct",
+        text: "",
+        timestamp: new Date(
+          envelope.timestamp ?? Date.now()
+        ).toISOString(),
+        raw: entry,
+        dataCategory: "reaction",
+        reaction: {
+          emoji: rm.emoji ?? "",
+          targetMessageId: String(rm.targetSentTimestamp ?? ""),
+          reactedBy: senderId,
+          timestamp: new Date(
+            envelope.timestamp ?? Date.now()
+          ).toISOString()
+        }
+      };
+      await this.emitMessage(normalized2);
+      return;
+    }
+    if (envelope.receiptMessage) {
+      const rcpt = envelope.receiptMessage;
+      for (const ts of rcpt.timestamps ?? []) {
+        const normalized2 = {
+          messageId: randomUUID(),
+          platform: "signal",
+          senderId,
+          senderName: envelope.sourceName ?? void 0,
+          channelId: senderId,
+          chatType: "direct",
+          text: "",
+          timestamp: new Date(
+            envelope.timestamp ?? Date.now()
+          ).toISOString(),
+          raw: entry,
+          dataCategory: "read_receipt",
+          readReceipt: {
+            messageId: String(ts),
+            status: rcpt.type === "READ" ? "read" : "delivered",
+            timestamp: new Date(
+              envelope.timestamp ?? Date.now()
+            ).toISOString(),
+            readBy: senderId
+          }
+        };
+        await this.emitMessage(normalized2);
+      }
+      return;
+    }
+    if (envelope.editMessage) {
+      const em = envelope.editMessage;
+      const dm2 = em.dataMessage;
+      if (!dm2) return;
+      const isGroup2 = !!dm2.groupInfo?.groupId;
+      const normalized2 = {
+        messageId: String(dm2.timestamp ?? randomUUID()),
+        platform: "signal",
+        senderId,
+        senderName: envelope.sourceName ?? void 0,
+        channelId: isGroup2 ? `group:${dm2.groupInfo.groupId ?? ""}` : senderId,
+        chatType: isGroup2 ? "group" : "direct",
+        text: dm2.message ?? "",
+        timestamp: new Date(
+          envelope.timestamp ?? Date.now()
+        ).toISOString(),
+        media: this.extractMedia(dm2.attachments),
+        raw: entry,
+        dataCategory: "edit",
+        replyTo: {
+          messageId: String(em.targetSentTimestamp ?? ""),
+          text: "",
+          senderId
+        }
+      };
+      await this.emitMessage(normalized2);
+      return;
+    }
+    if (!envelope.dataMessage?.message) return;
+    const dm = envelope.dataMessage;
+    const isGroup = !!dm.groupInfo?.groupId;
+    const normalized = {
+      messageId: String(dm.timestamp ?? randomUUID()),
+      platform: "signal",
+      senderId,
+      senderName: envelope.sourceName ?? void 0,
+      channelId: isGroup ? `group:${dm.groupInfo.groupId ?? ""}` : senderId,
+      chatType: isGroup ? "group" : "direct",
+      text: dm.message,
+      timestamp: new Date(
+        envelope.timestamp ?? Date.now()
+      ).toISOString(),
+      media: this.extractMedia(dm.attachments),
+      replyTo: dm.quote ? {
+        messageId: String(dm.quote.id ?? ""),
+        text: dm.quote.text ?? "",
+        senderId: dm.quote.author ?? ""
+      } : void 0,
+      raw: entry,
+      dataCategory: "message"
+    };
+    await this.emitMessage(normalized);
+  }
+  async emitMessage(msg) {
+    if (!this.messageHandler) return;
+    try {
+      await this.messageHandler(msg);
+    } catch (err) {
+      console.error("[signal] Message handler error:", err);
+    }
+  }
+  /** Import all Signal contacts */
+  async syncContacts() {
+    if (!this.messageHandler || !this.account) return;
+    const res = await fetch(
+      `${this.baseUrl}/v1/contacts/${encodeURIComponent(this.account)}`,
+      { signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS) }
+    );
+    if (!res.ok) return;
+    const contacts = await res.json();
+    if (!Array.isArray(contacts)) return;
+    for (const contact of contacts) {
+      const phone = contact.number ?? "";
+      if (!phone) continue;
+      const name = contact.name ?? contact.profileName ?? phone;
+      const normalized = {
+        messageId: randomUUID(),
+        platform: "signal",
+        senderId: phone,
+        senderName: name,
+        channelId: phone,
+        chatType: "direct",
+        text: "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: contact,
+        dataCategory: "contact_sync",
+        contactSync: {
+          name,
+          phone,
+          pushName: contact.profileName ?? void 0
+        }
+      };
+      await this.emitMessage(normalized);
+    }
+    console.log(`[signal] Synced ${contacts.length} contacts`);
+  }
+  /** Import all Signal groups */
+  async syncGroups() {
+    if (!this.messageHandler || !this.account) return;
+    const res = await fetch(
+      `${this.baseUrl}/v1/groups/${encodeURIComponent(this.account)}`,
+      { signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS) }
+    );
+    if (!res.ok) return;
+    const groups = await res.json();
+    if (!Array.isArray(groups)) return;
+    for (const group of groups) {
+      const normalized = {
+        messageId: randomUUID(),
+        platform: "signal",
+        senderId: `group:${group.id}`,
+        channelId: `group:${group.id}`,
+        chatType: "group",
+        text: "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: group,
+        dataCategory: "group",
+        groupInfo: {
+          groupId: group.id,
+          groupName: group.name ?? "",
+          participants: group.members ?? [],
+          admins: group.admins ?? [],
+          description: group.description ?? void 0
+        }
+      };
+      await this.emitMessage(normalized);
+    }
+    console.log(`[signal] Synced ${groups.length} groups`);
+  }
+  extractMedia(attachments) {
+    if (!attachments?.length) return void 0;
+    return attachments.map((att) => {
+      const ct = att.contentType ?? "";
+      let type = "document";
+      if (ct.startsWith("image/")) type = "image";
+      else if (ct.startsWith("video/")) type = "video";
+      else if (ct.startsWith("audio/")) type = "audio";
+      return {
+        type,
+        fileName: att.filename ?? void 0,
+        url: att.id ? `${this.baseUrl}/v1/attachments/${att.id}` : void 0
+      };
+    });
+  }
+};
+
+export {
+  SignalAdapter
+};

package/dist/chunk-RMPAMMYW.js

@@ -0,0 +1,70 @@
+import {
+  loadEmployees
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/agent-symlinks.ts
+import os from "os";
+import path from "path";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  symlinkSync
+} from "fs";
+function claudeAgentsDir(homeDir) {
+  return path.join(homeDir, ".claude", "agents");
+}
+function identitySourcePath(homeDir, agentId) {
+  return path.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+}
+function claudeAgentLinkPath(homeDir, agentId) {
+  return path.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+}
+function ensureAgentSymlink(agentId, homeDir = os.homedir()) {
+  const target = identitySourcePath(homeDir, agentId);
+  const link = claudeAgentLinkPath(homeDir, agentId);
+  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync(link)) {
+    let stat;
+    try {
+      stat = lstatSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "stat_failed" };
+    }
+    if (!stat.isSymbolicLink()) {
+      return { agentId, action: "conflict", target, link, conflict: "regular_file" };
+    }
+    let currentTarget;
+    try {
+      currentTarget = readlinkSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "readlink_failed" };
+    }
+    if (currentTarget === target) {
+      return { agentId, action: "already_correct", target, link };
+    }
+    return { agentId, action: "conflict", target, link, conflict: `points_to:${currentTarget}` };
+  }
+  try {
+    symlinkSync(target, link);
+  } catch (err) {
+    return {
+      agentId,
+      action: "conflict",
+      target,
+      link,
+      conflict: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { agentId, action: "created", target, link };
+}
+async function ensureAllAgentSymlinks(homeDir = os.homedir()) {
+  const employees = await loadEmployees();
+  return employees.map((emp) => ensureAgentSymlink(emp.name, homeDir));
+}
+
+export {
+  ensureAgentSymlink,
+  ensureAllAgentSymlinks
+};