@adaptic/maestro 1.0.0

package/scripts/slack-upload-v2.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Upload a file to Slack using the v2 upload API (getUploadURLExternal + completeUploadExternal)."""
+import sys
+import os
+import json
+import urllib.request
+import urllib.parse
+import uuid
+
+def upload_file(token, file_path, title, channel_id, thread_ts=None, initial_comment=None):
+    filename = os.path.basename(file_path)
+    filesize = os.path.getsize(file_path)
+
+    # Step 1: Get upload URL
+    data1_body = urllib.parse.urlencode({"filename": filename, "length": filesize}).encode()
+    req1 = urllib.request.Request(
+        "https://slack.com/api/files.getUploadURLExternal",
+        data=data1_body,
+        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/x-www-form-urlencoded"}
+    )
+    with urllib.request.urlopen(req1) as resp1:
+        data1 = json.loads(resp1.read())
+
+    if not data1.get("ok"):
+        print(f"ERROR step1: {data1.get('error', data1)}", file=sys.stderr)
+        return False
+
+    upload_url = data1["upload_url"]
+    file_id = data1["file_id"]
+
+    # Step 2: Upload file content via multipart form
+    boundary = uuid.uuid4().hex
+    with open(file_path, "rb") as f:
+        file_data = f.read()
+
+    body = (
+        f"--{boundary}\r\n"
+        f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'
+        f"Content-Type: application/pdf\r\n\r\n"
+    ).encode() + file_data + f"\r\n--{boundary}--\r\n".encode()
+
+    req2 = urllib.request.Request(
+        upload_url,
+        data=body,
+        headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
+        method="POST"
+    )
+    with urllib.request.urlopen(req2) as resp2:
+        pass  # Just need success status
+
+    # Step 3: Complete the upload
+    payload = {
+        "files": [{"id": file_id, "title": title}],
+        "channel_id": channel_id,
+    }
+    if thread_ts:
+        payload["thread_ts"] = thread_ts
+    if initial_comment:
+        payload["initial_comment"] = initial_comment
+
+    req3 = urllib.request.Request(
+        "https://slack.com/api/files.completeUploadExternal",
+        data=json.dumps(payload).encode(),
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+    )
+    with urllib.request.urlopen(req3) as resp3:
+        data3 = json.loads(resp3.read())
+
+    if data3.get("ok"):
+        print("OK")
+        return True
+    else:
+        print(f"ERROR step3: {data3.get('error', data3)}", file=sys.stderr)
+        return False
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--file", required=True)
+    parser.add_argument("--title", required=True)
+    parser.add_argument("--channel", required=True)
+    parser.add_argument("--thread-ts", default=None)
+    parser.add_argument("--comment", default=None)
+    args = parser.parse_args()
+
+    token = os.environ.get("SLACK_USER_TOKEN", "")
+    if not token:
+        print("ERROR: SLACK_USER_TOKEN not set", file=sys.stderr)
+        sys.exit(1)
+
+    success = upload_file(token, args.file, args.title, args.channel, args.thread_ts, args.comment)
+    sys.exit(0 if success else 1)

package/scripts/sms-handler.mjs

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+/**
+ * Sophie SMS Handler — Twilio Inbound SMS Webhook
+ *
+ * Receives inbound SMS/MMS via Twilio webhook, maps senders to known contacts,
+ * writes messages to the inbox for the inbox processor, and logs everything.
+ *
+ * Endpoints:
+ *   POST /sms       — Twilio SMS webhook (returns TwiML)
+ *   GET  /health    — Health check
+ *
+ * Environment:
+ *   TWILIO_ACCOUNT_SID   — For request validation (optional but recommended)
+ *   TWILIO_AUTH_TOKEN     — For request validation (optional but recommended)
+ *   SMS_PORT             — Port to listen on (default: 3001)
+ *
+ * Usage:
+ *   node scripts/sms-handler.mjs
+ *
+ * Configure in Twilio Console:
+ *   Phone Number → Messaging → "A message comes in" → Webhook → POST → <url>/sms
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import http from "node:http";
+import { URL } from "node:url";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const PORT = parseInt(process.env.SMS_PORT || "3001", 10);
+const SOPHIE_AI =
+  process.env.SOPHIE_AI_PATH ||
+  path.join(process.env.HOME || "/Users/sophie", "sophie-ai");
+const INBOX_DIR = path.join(SOPHIE_AI, "state", "inbox", "sms");
+const LOG_DIR = path.join(SOPHIE_AI, "logs", "sms");
+const CALLER_ID_MAP_PATH = path.join(SOPHIE_AI, "config", "caller-id-map.yaml");
+const SOPHIE_NUMBER = "+16282656712";
+
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+
+function ensureDir(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+    // Already exists or inaccessible
+  }
+}
+
+function today() {
+  return new Date().toISOString().split("T")[0];
+}
+
+function timestamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+/**
+ * Load caller-id-map.yaml and build a phone-to-user lookup.
+ * Simple YAML parsing — avoids external dependency.
+ */
+function loadCallerIdMap() {
+  const map = new Map();
+  try {
+    const content = fs.readFileSync(CALLER_ID_MAP_PATH, "utf-8");
+    // Parse each user block: look for phone numbers and associated names
+    const userBlocks = content.split(/^\s{2}\w+:/gm);
+    const userKeys = content.match(/^\s{2}(\w+):/gm) || [];
+
+    for (let i = 0; i < userKeys.length; i++) {
+      const key = userKeys[i].trim().replace(":", "");
+      const block = userBlocks[i + 1] || "";
+
+      // Extract name
+      const nameMatch = block.match(/name:\s*"([^"]+)"/);
+      const name = nameMatch ? nameMatch[1] : key;
+
+      // Extract access level
+      const accessMatch = block.match(/access_level:\s*(\w+)/);
+      const accessLevel = accessMatch ? accessMatch[1] : "default";
+
+      // Extract email
+      const emailMatch = block.match(/email:\s*"([^"]+)"/);
+      const email = emailMatch ? emailMatch[1] : "";
+
+      // Extract phone numbers — handles both single and array format
+      const phoneMatch = block.match(/phone:\s*\[([^\]]*)\]/);
+      if (phoneMatch) {
+        const phones = phoneMatch[1].match(/"([^"]+)"/g) || [];
+        for (const phoneStr of phones) {
+          const phone = phoneStr.replace(/"/g, "");
+          map.set(phone, { id: key, name, accessLevel, email });
+        }
+      }
+    }
+  } catch (err) {
+    console.error(`[CALLER-MAP] Failed to load: ${err.message}`);
+  }
+  return map;
+}
+
+// Load on startup; reload periodically
+let callerMap = loadCallerIdMap();
+setInterval(() => {
+  callerMap = loadCallerIdMap();
+}, 60_000); // Reload every 60s
+
+/**
+ * Look up a phone number in the caller ID map.
+ */
+function lookupSender(phoneNumber) {
+  // Try exact match first
+  if (callerMap.has(phoneNumber)) {
+    return callerMap.get(phoneNumber);
+  }
+  // Try without + prefix
+  const stripped = phoneNumber.replace(/^\+/, "");
+  for (const [key, value] of callerMap) {
+    if (key.replace(/^\+/, "") === stripped) {
+      return value;
+    }
+  }
+  return null;
+}
+
+/**
+ * Parse URL-encoded form body (application/x-www-form-urlencoded).
+ */
+function parseFormBody(body) {
+  const params = new URLSearchParams(body);
+  const result = {};
+  for (const [key, value] of params) {
+    result[key] = value;
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+
+function logSms(entry) {
+  const dir = path.join(LOG_DIR, today());
+  ensureDir(dir);
+
+  const logFile = path.join(dir, `${today()}-sms.jsonl`);
+  const line = JSON.stringify({
+    ...entry,
+    logged_at: new Date().toISOString(),
+  });
+
+  try {
+    fs.appendFileSync(logFile, line + "\n");
+  } catch (err) {
+    console.error(`[LOG] Failed to write: ${err.message}`);
+  }
+
+  // Also log to stdout
+  console.log(
+    `[SMS] ${entry.direction || "inbound"} ${entry.from} -> ${entry.to}: ${(entry.body || "").substring(0, 100)}`,
+  );
+}
+
+/**
+ * Log to the main audit trail (sophie-ai/logs/audit/).
+ */
+function logAudit(action, details) {
+  const auditDir = path.join(SOPHIE_AI, "logs", "audit");
+  ensureDir(auditDir);
+
+  const auditFile = path.join(auditDir, `${today()}-actions.jsonl`);
+  const entry = {
+    timestamp: new Date().toISOString(),
+    agent: "sms-handler",
+    action,
+    ...details,
+  };
+
+  try {
+    fs.appendFileSync(auditFile, JSON.stringify(entry) + "\n");
+  } catch (err) {
+    console.error(`[AUDIT] Failed to write: ${err.message}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Inbox Writer
+// ---------------------------------------------------------------------------
+
+/**
+ * Write an inbound SMS to the inbox as a YAML file for the inbox processor.
+ * Follows the same schema as Slack/Gmail inbox items.
+ */
+function writeToInbox(smsData) {
+  ensureDir(INBOX_DIR);
+
+  const ts = timestamp();
+  const filename = `${ts}-${smsData.MessageSid || "unknown"}.yaml`;
+  const filePath = path.join(INBOX_DIR, filename);
+
+  const sender = lookupSender(smsData.From || "");
+  const senderName = sender ? sender.name : smsData.From || "unknown";
+  const senderId = sender ? sender.id : "unknown";
+  const senderPrivilege = sender ? sender.accessLevel : "unknown";
+
+  // Check for media (MMS)
+  const numMedia = parseInt(smsData.NumMedia || "0", 10);
+  const mediaUrls = [];
+  for (let i = 0; i < numMedia; i++) {
+    const url = smsData[`MediaUrl${i}`];
+    const contentType = smsData[`MediaContentType${i}`];
+    if (url) {
+      mediaUrls.push({ url, content_type: contentType || "unknown" });
+    }
+  }
+
+  const yaml = [
+    `id: "${smsData.MessageSid || ts}"`,
+    `service: "sms"`,
+    `channel: "sms/${senderId}"`,
+    `sender: "${senderName}"`,
+    `sender_phone: "${smsData.From || ""}"`,
+    `sender_privilege: "${senderPrivilege}"`,
+    `timestamp: "${new Date().toISOString()}"`,
+    `subject: "SMS from ${senderName}"`,
+    `content: |`,
+    `  ${(smsData.Body || "").replace(/\n/g, "\n  ")}`,
+    `to: "${smsData.To || SOPHIE_NUMBER}"`,
+    `is_reply: false`,
+    `priority_signals:`,
+    `  from_ceo: ${senderPrivilege === "ceo"}`,
+    `  tagged_urgent: false`,
+    `  contains_deadline: false`,
+    `  mentions_sophie: false`,
+  ];
+
+  if (mediaUrls.length > 0) {
+    yaml.push(`media:`);
+    for (const m of mediaUrls) {
+      yaml.push(`  - url: "${m.url}"`);
+      yaml.push(`    content_type: "${m.content_type}"`);
+    }
+  }
+
+  yaml.push(`raw_ref: "sms:${smsData.MessageSid || "unknown"}"`);
+
+  try {
+    fs.writeFileSync(filePath, yaml.join("\n") + "\n");
+    console.log(`[INBOX] Written: ${filename}`);
+    return filePath;
+  } catch (err) {
+    console.error(`[INBOX] Failed to write: ${err.message}`);
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// TwiML Response
+// ---------------------------------------------------------------------------
+
+/**
+ * Return a minimal TwiML response.
+ * Empty <Response/> acknowledges receipt without sending a reply SMS.
+ */
+function twimlAck() {
+  return '<?xml version="1.0" encoding="UTF-8"?>\n<Response></Response>';
+}
+
+// ---------------------------------------------------------------------------
+// HTTP Server
+// ---------------------------------------------------------------------------
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, `http://localhost:${PORT}`);
+
+  // Health check
+  if (req.method === "GET" && url.pathname === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        status: "ok",
+        service: "sophie-sms-handler",
+        uptime: process.uptime(),
+        timestamp: new Date().toISOString(),
+        knownContacts: callerMap.size,
+      }),
+    );
+    return;
+  }
+
+  // Root info
+  if (req.method === "GET" && url.pathname === "/") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        service: "Sophie SMS Handler",
+        description: "Twilio inbound SMS webhook for sophie-ai inbox",
+        endpoints: {
+          health: "/health",
+          sms: "/sms (POST)",
+        },
+      }),
+    );
+    return;
+  }
+
+  // SMS webhook
+  if (req.method === "POST" && url.pathname === "/sms") {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const smsData = parseFormBody(body);
+
+        const from = smsData.From || "unknown";
+        const to = smsData.To || SOPHIE_NUMBER;
+        const messageBody = smsData.Body || "";
+        const messageSid = smsData.MessageSid || "unknown";
+        const numMedia = parseInt(smsData.NumMedia || "0", 10);
+
+        // Log the inbound SMS
+        logSms({
+          direction: "inbound",
+          messageSid,
+          from,
+          to,
+          body: messageBody,
+          numMedia,
+          timestamp: new Date().toISOString(),
+        });
+
+        // Write to inbox for processing
+        const inboxPath = writeToInbox(smsData);
+
+        // Log to audit trail
+        logAudit("sms_received", {
+          from,
+          to,
+          messageSid,
+          body_preview: messageBody.substring(0, 100),
+          inbox_path: inboxPath,
+          sender_identified: !!lookupSender(from),
+        });
+
+        // Check if from CEO — log as priority
+        const sender = lookupSender(from);
+        if (sender && sender.accessLevel === "ceo") {
+          console.log(
+            `[PRIORITY] SMS from CEO (${sender.name}): ${messageBody.substring(0, 100)}`,
+          );
+
+          // Write priority trigger
+          const priorityDir = path.join(
+            SOPHIE_AI,
+            "state",
+            "inbox",
+            "processed",
+          );
+          ensureDir(priorityDir);
+          // Actually write to main inbox dir for the inbox processor to catch
+          const priorityFile = path.join(
+            INBOX_DIR,
+            `priority-${Date.now()}.yaml`,
+          );
+          const priorityYaml =
+            [
+              `type: priority_trigger`,
+              `reason: "SMS from CEO"`,
+              `source_item: "sms:${messageSid}"`,
+              `timestamp: "${new Date().toISOString()}"`,
+              `sender: "${sender.name}"`,
+              `channel: "sms/${sender.id}"`,
+              `content: |`,
+              `  ${messageBody.replace(/\n/g, "\n  ")}`,
+            ].join("\n") + "\n";
+
+          try {
+            fs.writeFileSync(priorityFile, priorityYaml);
+            console.log(`[PRIORITY] Priority trigger written`);
+          } catch (err) {
+            console.error(`[PRIORITY] Failed: ${err.message}`);
+          }
+        }
+
+        // Return TwiML acknowledgement (no auto-reply)
+        res.writeHead(200, { "Content-Type": "text/xml" });
+        res.end(twimlAck());
+      } catch (err) {
+        console.error(`[SMS] Error processing webhook: ${err.message}`);
+        // Still return valid TwiML to avoid Twilio retries
+        res.writeHead(200, { "Content-Type": "text/xml" });
+        res.end(twimlAck());
+      }
+    });
+    return;
+  }
+
+  // 404 for everything else
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "Not found" }));
+});
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+ensureDir(INBOX_DIR);
+ensureDir(LOG_DIR);
+
+server.listen(PORT, "0.0.0.0", () => {
+  console.log(`\n========================================`);
+  console.log(`  Sophie SMS Handler`);
+  console.log(`  Port: ${PORT}`);
+  console.log(`  Health: http://0.0.0.0:${PORT}/health`);
+  console.log(`  Webhook: POST /sms`);
+  console.log(`  Known contacts: ${callerMap.size}`);
+  console.log(`  Inbox: ${INBOX_DIR}`);
+  console.log(`  Logs: ${LOG_DIR}`);
+  console.log(`========================================\n`);
+});
+
+// Graceful shutdown
+process.on("SIGTERM", () => {
+  console.log("[SMS] Shutting down...");
+  server.close(() => process.exit(0));
+});
+process.on("SIGINT", () => {
+  console.log("[SMS] Shutting down...");
+  server.close(() => process.exit(0));
+});