@adaptic/maestro 1.0.0

package/scripts/poller/trigger.mjs

@@ -0,0 +1,47 @@
+// Priority Trigger — writes a priority task file when urgent items detected
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { SOPHIE_AI_DIR } from "./utils.mjs";
+
+const COOLDOWN_MS = 30_000;
+let lastTrigger = 0;
+
+export function triggerSophie(item) {
+  const now = Date.now();
+  if (now - lastTrigger < COOLDOWN_MS) {
+    console.log(
+      `[trigger] Cooldown active, skipping trigger for: ${item.subject}`,
+    );
+    return false;
+  }
+  lastTrigger = now;
+
+  const reasons = [];
+  if (item.priority_signals?.from_ceo) reasons.push("Message from CEO");
+  if (item.priority_signals?.tagged_urgent) reasons.push("Tagged urgent");
+  if (item.priority_signals?.mentions_sophie) reasons.push("Mentions Sophie");
+  const reason = reasons.join(", ") || "Priority item";
+
+  console.log(`[trigger] Priority event detected: ${reason}`);
+
+  try {
+    const dir = join(SOPHIE_AI_DIR, "state", "inbox", "internal");
+    mkdirSync(dir, { recursive: true });
+    const taskFile = join(dir, `priority-${Date.now()}.yaml`);
+    const content = `type: priority_trigger
+reason: "${reason}"
+source_item: "${item.raw_ref}"
+timestamp: "${new Date().toISOString()}"
+sender: "${item.sender}"
+channel: "${item.channel}"
+content: |
+  ${(item.content || "").replace(/\n/g, "\n  ")}
+`;
+    writeFileSync(taskFile, content);
+    console.log(`[trigger] Priority task written to ${taskFile}`);
+    return true;
+  } catch (err) {
+    console.error(`[trigger] Failed to trigger: ${err.message}`);
+    return false;
+  }
+}

package/scripts/poller/utils.mjs

@@ -0,0 +1,253 @@
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname, extname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const SOPHIE_AI_DIR = join(__dirname, "../..");
+export const ATTACHMENTS_DIR = join(SOPHIE_AI_DIR, "state", "inbox", "attachments");
+
+export function writeInboxItem(service, item) {
+  const dir = join(SOPHIE_AI_DIR, "state", "inbox", service);
+  mkdirSync(dir, { recursive: true });
+  const ts = item.timestamp.replace(/[:.]/g, "-");
+  const filename = `${ts}-${item.id}.yaml`;
+  const filePath = join(dir, filename);
+
+  // Skip if this item was already written or already processed.
+  // The daemon renames files to .processed after handling them;
+  // without this check the 30-min thread lookback re-creates the
+  // file every poll cycle, causing duplicate responses.
+  if (existsSync(filePath) || existsSync(filePath + ".processed")) {
+    return;
+  }
+
+  writeFileSync(filePath, inboxItemToYaml(item));
+}
+
+function inboxItemToYaml(item) {
+  const content = (item.content || "").replace(/\n/g, "\n  ");
+  let yaml = `id: "${item.id}"
+service: "${item.service}"
+channel: "${item.channel}"
+sender: "${item.sender}"
+sender_privilege: "${item.sender_privilege}"
+timestamp: "${item.timestamp}"
+subject: "${item.subject || ""}"
+content: |
+  ${content}
+thread_id: "${item.thread_id || ""}"
+is_reply: ${item.is_reply || false}
+is_voice_transcript: ${item.is_voice_transcript || false}
+priority_signals:
+  from_ceo: ${item.priority_signals?.from_ceo || false}
+  tagged_urgent: ${item.priority_signals?.tagged_urgent || false}
+  contains_deadline: ${item.priority_signals?.contains_deadline || false}
+  mentions_sophie: ${item.priority_signals?.mentions_sophie || false}
+raw_ref: "${item.raw_ref || ""}"
+`;
+
+  // Add thread context if present (conversation history before this message)
+  if (item.thread_context) {
+    const tc = item.thread_context.replace(/\n/g, "\n  ");
+    yaml += `thread_context: |\n  ${tc}\n`;
+  }
+
+  // Add channel_id if present
+  if (item.channel_id) {
+    yaml += `channel_id: "${item.channel_id}"\n`;
+  }
+
+  // Add event_type if present (e.g., message_changed, reaction)
+  if (item.event_type) {
+    yaml += `event_type: "${item.event_type}"\n`;
+  }
+
+  // Add attachments if present
+  if (item.attachments && item.attachments.length > 0) {
+    yaml += `attachments:\n`;
+    for (const att of item.attachments) {
+      yaml += `  - id: "${att.id}"\n`;
+      yaml += `    name: "${att.name}"\n`;
+      yaml += `    mimetype: "${att.mimetype}"\n`;
+      yaml += `    size: ${att.size}\n`;
+      if (att.local_path) {
+        yaml += `    local_path: "${att.local_path}"\n`;
+      }
+      if (att.url_private) {
+        yaml += `    url_private: "${att.url_private}"\n`;
+      }
+    }
+  }
+
+  // Add voice metadata if present
+  if (item.is_voice_transcript && item.voice_meta) {
+    yaml += `voice_meta:
+  caller_phone: "${item.voice_meta.caller_phone || ""}"
+  duration_seconds: ${item.voice_meta.duration_seconds || 0}
+  turns: ${item.voice_meta.turns || 0}
+  topics: [${(item.voice_meta.topics || []).map((t) => `"${t}"`).join(", ")}]
+  action_priority: "${item.voice_meta.action_priority || ""}"
+`;
+  }
+
+  return yaml;
+}
+
+// ── Attachment Handling ──────────────────────────────────────────────────────
+
+/**
+ * Download a Slack file attachment to local storage.
+ * Slack file URLs require the bot token for authentication.
+ * Returns the local file path on success, null on failure.
+ */
+export async function downloadSlackAttachment(file, token) {
+  if (!file || !token) return null;
+
+  const downloadUrl = file.url_private_download || file.url_private;
+  if (!downloadUrl) return null;
+
+  const ext = extname(file.name || "") || "";
+  const safeId = (file.id || "unknown").replace(/[^a-zA-Z0-9_-]/g, "");
+  const safeName = (file.name || "file").replace(/[^a-zA-Z0-9._-]/g, "_");
+  const localName = `${safeId}-${safeName}`;
+  const localPath = join(ATTACHMENTS_DIR, localName);
+
+  // Skip if already downloaded
+  if (existsSync(localPath)) return localPath;
+
+  try {
+    mkdirSync(ATTACHMENTS_DIR, { recursive: true });
+    const res = await fetch(downloadUrl, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+      console.error(`[attachment] Failed to download ${file.name}: HTTP ${res.status}`);
+      return null;
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    writeFileSync(localPath, buffer);
+    return localPath;
+  } catch (err) {
+    console.error(`[attachment] Download error for ${file.name}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Extract attachment metadata from a Slack message's files array.
+ * Returns a structured array suitable for inbox YAML serialization.
+ */
+export function extractSlackAttachments(files) {
+  if (!files || !Array.isArray(files) || files.length === 0) return [];
+  return files.map((f) => ({
+    id: f.id || "",
+    name: f.name || "unnamed",
+    mimetype: f.mimetype || f.filetype || "unknown",
+    size: f.size || 0,
+    url_private: f.url_private || "",
+    url_private_download: f.url_private_download || "",
+    local_path: null, // Populated after download
+  }));
+}
+
+// ── Slack Reactions ─────────────────────────────────────────────────────────
+
+/**
+ * Add an emoji reaction to a Slack message.
+ * Used by Sophie to acknowledge, approve, or signal status on messages.
+ *
+ * @param {string} channel - Slack channel ID
+ * @param {string} timestamp - Message timestamp (ts)
+ * @param {string} emoji - Emoji name without colons (e.g., "eyes", "white_check_mark")
+ * @param {string} token - Slack bot token
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+export async function addSlackReaction(channel, timestamp, emoji, token) {
+  if (!token || !channel || !timestamp || !emoji) {
+    return { ok: false, error: "missing_parameters" };
+  }
+
+  try {
+    const res = await fetch("https://slack.com/api/reactions.add", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        channel,
+        timestamp,
+        name: emoji,
+      }),
+    });
+    return await res.json();
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export function readCursor(service) {
+  const path = join(
+    SOPHIE_AI_DIR,
+    "state",
+    "polling",
+    `${service}-cursor.yaml`,
+  );
+  try {
+    const content = readFileSync(path, "utf-8");
+    const match = content.match(/last_checked:\s*"?([^"\n]*)"?/);
+    const val = match ? match[1] : null;
+    return val === "null" ? null : val;
+  } catch {
+    return null;
+  }
+}
+
+export function writeCursor(service, timestamp) {
+  const path = join(
+    SOPHIE_AI_DIR,
+    "state",
+    "polling",
+    `${service}-cursor.yaml`,
+  );
+  const content = `service: ${service}
+last_checked: "${timestamp}"
+cursors: {}
+stats:
+  total_polls_today: 0
+  items_found_today: 0
+  errors_today: 0
+`;
+  writeFileSync(path, content);
+}
+
+export function appendLog(service, entry) {
+  const dir = join(SOPHIE_AI_DIR, "logs", "polling");
+  mkdirSync(dir, { recursive: true });
+  const today = new Date().toISOString().split("T")[0];
+  const path = join(dir, `${today}-${service}.jsonl`);
+  appendFileSync(path, JSON.stringify(entry) + "\n");
+}
+
+export function isPriorityItem(item) {
+  if (!item) return false;
+  return (
+    item.priority_signals?.from_ceo ||
+    item.priority_signals?.tagged_urgent ||
+    item.priority_signals?.mentions_sophie
+  );
+}
+
+// Known user IDs for privilege resolution
+const KNOWN_USERS = {
+  U097N5R0M7U: { name: "mehran-granfar", privilege: "ceo" },
+  U099N1JFPRQ: { name: "sophie-nguyen", privilege: "system" },
+};
+
+export function resolvePrivilege(userId) {
+  return KNOWN_USERS[userId]?.privilege || "unknown";
+}
+
+export function resolveName(userId) {
+  return KNOWN_USERS[userId]?.name || userId;
+}

package/scripts/poller-launchd/ai.adaptic.sophie-poller.plist

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.adaptic.sophie-poller</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/local/bin/node</string>
+        <string>/Users/sophie/sophie-ai/scripts/poller/index.mjs</string>
+    </array>
+
+    <key>StartInterval</key>
+    <integer>60</integer>
+
+    <key>WorkingDirectory</key>
+    <string>/Users/sophie/sophie-ai</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin</string>
+        <key>NODE_ENV</key>
+        <string>production</string>
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>/Users/sophie/sophie-ai/logs/polling/launchd-stdout.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/Users/sophie/sophie-ai/logs/polling/launchd-stderr.log</string>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <false/>
+</dict>
+</plist>

package/scripts/poller-launchd/ai.adaptic.sophie-whatsapp-handler.plist

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.adaptic.sophie-whatsapp-handler</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/opt/homebrew/bin/node</string>
+        <string>/Users/sophie/sophie-ai/scripts/whatsapp-handler.mjs</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>/Users/sophie/sophie-ai</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+        <key>NODE_ENV</key>
+        <string>production</string>
+        <key>WHATSAPP_PORT</key>
+        <string>3002</string>
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>/Users/sophie/sophie-ai/logs/whatsapp/launchd-stdout.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/Users/sophie/sophie-ai/logs/whatsapp/launchd-stderr.log</string>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+</dict>
+</plist>

package/scripts/poller-launchd/install.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Install the Sophie poller as a macOS launchd daemon
+# Usage: ./scripts/poller-launchd/install.sh
+
+set -e
+
+PLIST_NAME="ai.adaptic.sophie-poller"
+PLIST_SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$PLIST_NAME.plist"
+PLIST_DST="$HOME/Library/LaunchAgents/$PLIST_NAME.plist"
+
+echo "Installing Sophie poller daemon..."
+
+# Copy plist to LaunchAgents
+cp "$PLIST_SRC" "$PLIST_DST"
+
+# Update node path to actual location
+NODE_PATH=$(which node)
+sed -i '' "s|/usr/local/bin/node|$NODE_PATH|g" "$PLIST_DST"
+
+# Inject environment variables from .env if it exists
+SOPHIE_AI_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+ENV_FILE="$SOPHIE_AI_DIR/.env"
+if [ -f "$ENV_FILE" ]; then
+    # Read SLACK_USER_TOKEN from .env and inject into plist
+    SLACK_TOKEN=$(grep '^SLACK_USER_TOKEN=' "$ENV_FILE" | cut -d= -f2-)
+    if [ -n "$SLACK_TOKEN" ]; then
+        sed -i '' "s|<string>production</string>|<string>production</string>\n        <key>SLACK_USER_TOKEN</key>\n        <string>$SLACK_TOKEN</string>|g" "$PLIST_DST"
+        echo "Injected SLACK_USER_TOKEN from .env"
+    fi
+fi
+
+# Load the daemon
+launchctl unload "$PLIST_DST" 2>/dev/null || true
+launchctl load "$PLIST_DST"
+
+echo "Sophie poller daemon installed and running."
+echo "Check status: launchctl list | grep sophie"
+echo "Uninstall: launchctl unload $PLIST_DST && rm $PLIST_DST"