myaiforone 1.0.0

package/src/whatsapp-chats.ts

@@ -0,0 +1,91 @@
+import {
+  makeWASocket,
+  useMultiFileAuthState,
+  fetchLatestBaileysVersion,
+  makeCacheableSignalKeyStore,
+} from "@whiskeysockets/baileys";
+import qrcode from "qrcode-terminal";
+import { mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const authDir = resolve(__dirname, "..", "data", "whatsapp-auth");
+mkdirSync(authDir, { recursive: true });
+
+const silentLogger = {
+  level: "silent" as const,
+  child: () => silentLogger,
+  trace: () => {},
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  fatal: () => {},
+};
+
+async function discover(): Promise<void> {
+  const { state, saveCreds } = await useMultiFileAuthState(authDir);
+  const { version } = await fetchLatestBaileysVersion();
+
+  const sock = makeWASocket({
+    auth: {
+      creds: state.creds,
+      keys: makeCacheableSignalKeyStore(state.keys, silentLogger as any),
+    },
+    version,
+    logger: silentLogger as any,
+    printQRInTerminal: false,
+    browser: ["channelToAgentToClaude", "Desktop", "1.0.0"],
+    syncFullHistory: false,
+    markOnlineOnConnect: false,
+  });
+
+  sock.ev.on("creds.update", saveCreds);
+
+  sock.ev.on("connection.update", (update) => {
+    if (update.qr) {
+      console.log("\nScan this QR code with WhatsApp:\n");
+      qrcode.generate(update.qr, { small: true });
+    }
+    if (update.connection === "open") {
+      console.log("\nConnected! Now send a message in the WhatsApp chat you want to use.");
+      console.log("(Send from your phone — any message will do)\n");
+    }
+    if (update.connection === "close") {
+      // Don't exit on close during reconnect
+    }
+  });
+
+  sock.ev.on("messages.upsert", (upsert) => {
+    for (const msg of upsert.messages) {
+      if (msg.key.remoteJid === "status@broadcast") continue;
+      if (!msg.key.remoteJid) continue;
+
+      const text =
+        msg.message?.conversation ||
+        msg.message?.extendedTextMessage?.text ||
+        msg.message?.imageMessage?.caption ||
+        "(media/no text)";
+
+      const isGroup = msg.key.remoteJid.endsWith("@g.us");
+
+      console.log("=== MESSAGE FOUND ===");
+      console.log(`  JID:     ${msg.key.remoteJid}`);
+      console.log(`  Type:    ${isGroup ? "GROUP" : "DM"}`);
+      console.log(`  From:    ${msg.key.fromMe ? "you" : (msg.key.participant || msg.key.remoteJid)}`);
+      console.log(`  Name:    ${msg.pushName || "(unknown)"}`);
+      console.log(`  Text:    ${String(text).slice(0, 100)}`);
+      console.log("=====================\n");
+    }
+  });
+}
+
+console.log("WhatsApp Chat Discovery");
+console.log("If already linked, will connect automatically.");
+console.log("If not linked, scan the QR code.\n");
+
+discover().catch((err) => {
+  console.error("Error:", err);
+  process.exit(1);
+});

package/src/whatsapp-login.ts

@@ -0,0 +1,110 @@
+import {
+  makeWASocket,
+  useMultiFileAuthState,
+  fetchLatestBaileysVersion,
+  makeCacheableSignalKeyStore,
+  DisconnectReason,
+} from "@whiskeysockets/baileys";
+import { Boom } from "@hapi/boom";
+import qrcode from "qrcode-terminal";
+import { mkdirSync, rmSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const authDir = resolve(__dirname, "..", "data", "whatsapp-auth");
+
+let qrCount = 0;
+
+function connectSocket(): Promise<"restart" | "done"> {
+  return new Promise(async (res) => {
+    mkdirSync(authDir, { recursive: true });
+    const { state, saveCreds } = await useMultiFileAuthState(authDir);
+    const { version } = await fetchLatestBaileysVersion();
+
+    console.log(`Connecting... (Baileys ${version.join(".")})`);
+
+    const sock = makeWASocket({
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, silentLogger as any),
+      },
+      version,
+      logger: silentLogger as any,
+      printQRInTerminal: false,
+      browser: ["channelToAgentToClaude", "Desktop", "1.0.0"],
+      syncFullHistory: false,
+      markOnlineOnConnect: false,
+    });
+
+    sock.ev.on("creds.update", saveCreds);
+
+    sock.ev.on("connection.update", (update) => {
+      const { connection, lastDisconnect, qr } = update;
+
+      if (qr) {
+        qrCount++;
+        console.log(`\n--- QR Code #${qrCount} (scan quickly!) ---\n`);
+        qrcode.generate(qr, { small: true });
+        console.log("\nWaiting for scan...");
+      }
+
+      if (connection === "open") {
+        console.log(`\n✓ Connected as ${sock.user?.name ?? sock.user?.id}`);
+        console.log(`Credentials saved to: ${authDir}`);
+        console.log("\nWhatsApp is linked! You can now restart the service.");
+        setTimeout(() => res("done"), 3000);
+      }
+
+      if (connection === "close") {
+        const reason = (lastDisconnect?.error as Boom)?.output?.statusCode;
+        console.log(`Connection closed (reason: ${reason})`);
+
+        if (reason === DisconnectReason.loggedOut) {
+          console.log("Logged out — clearing creds and retrying...");
+          rmSync(authDir, { recursive: true, force: true });
+          res("restart");
+        } else if (reason === DisconnectReason.restartRequired || reason === 515) {
+          console.log("WhatsApp requested restart — reconnecting...\n");
+          res("restart");
+        } else {
+          console.error(`Unexpected disconnect (${reason}). Retrying...\n`);
+          res("restart");
+        }
+      }
+    });
+  });
+}
+
+const silentLogger = {
+  level: "silent" as const,
+  child: () => silentLogger,
+  trace: () => {},
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  fatal: () => {},
+};
+
+async function login(): Promise<void> {
+  console.log("WhatsApp Login — Scan the QR code with your phone");
+  console.log("WhatsApp > Settings > Linked Devices > Link a Device\n");
+
+  const maxAttempts = 5;
+  for (let i = 0; i < maxAttempts; i++) {
+    const result = await connectSocket();
+    if (result === "done") {
+      process.exit(0);
+    }
+    console.log(`Attempt ${i + 2} of ${maxAttempts}...`);
+  }
+
+  console.error("Max reconnection attempts reached. Please try again.");
+  process.exit(1);
+}
+
+login().catch((err) => {
+  console.error("Login failed:", err);
+  process.exit(1);
+});

package/src/wiki-sync.ts

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync, appendFileSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import * as cron from "node-cron";
+import type { AppConfig, McpServerConfig } from "./config.js";
+import type { InboundMessage } from "./channels/types.js";
+import type { ResolvedRoute } from "./router.js";
+import { executeAgent } from "./executor.js";
+import { log } from "./logger.js";
+
+// ─── Wiki Sync Result ───────────────────────────────────────────────
+
+export interface WikiSyncResult {
+  id: string;
+  agentId: string;
+  triggeredBy: string;  // "manual" | "cron"
+  triggeredAt: string;
+  completedAt: string;
+  durationMs: number;
+  summary: string;
+  status: "success" | "error";
+}
+
+// ─── Scheduled Tasks ────────────────────────────────────────────────
+
+const scheduledTasks: cron.ScheduledTask[] = [];
+
+// ─── Build the sync prompt ──────────────────────────────────────────
+
+function buildWikiSyncPrompt(memoryDir: string): string {
+  const contextPath = join(memoryDir, "context.md");
+  const learnedPath = join(memoryDir, "learned.md");
+
+  const hasLearned = existsSync(learnedPath);
+  const hasContext = existsSync(contextPath);
+
+  if (!hasLearned) {
+    return `[WIKI SYNC]\nNo learned.md file found — nothing to sync. Wiki sync complete.\n[END WIKI SYNC]`;
+  }
+
+  return `[WIKI SYNC]
+You are performing a scheduled wiki sync. Your job:
+
+1. Read \`${learnedPath}\` — this contains facts the agent learned from conversations
+2. Read \`${contextPath}\` — this is the curated knowledge base
+3. For each entry in learned.md:
+   - If it's a NEW fact not in context.md → add it to the appropriate section in context.md
+   - If it CONTRADICTS something in context.md → update context.md with the correction, adding a note like "(Updated [date] — corrected per [source])"
+   - If it's ALREADY in context.md → skip it
+4. After merging, clear the processed entries from learned.md (leave any that you couldn't verify or that need human review, with a note explaining why)
+5. Summarize what you merged, what you skipped, and what needs human review
+
+Be conservative — only merge facts you're confident about. Flag anything uncertain for human review.
+[END WIKI SYNC]`;
+}
+
+// ─── Execute Wiki Sync ──────────────────────────────────────────────
+
+export async function executeWikiSync(
+  agentId: string,
+  agent: AppConfig["agents"][string],
+  baseDir: string,
+  mcpRegistry?: Record<string, McpServerConfig>,
+  claudeAccounts?: Record<string, string>,
+  globalDefaults?: { skills?: string[]; mcps?: string[]; prompts?: string[]; promptTrigger?: string },
+  triggeredBy: string = "manual",
+): Promise<WikiSyncResult> {
+  const memoryDir = resolve(baseDir, agent.memoryDir.replace(/^~/, process.env.HOME || ""));
+
+  const prompt = buildWikiSyncPrompt(memoryDir);
+
+  const syntheticMsg: InboundMessage = {
+    id: `wiki-sync-${agentId}-${Date.now()}`,
+    channel: "wiki-sync",
+    chatId: `wiki-sync-${agentId}`,
+    chatType: "group",
+    sender: "wiki-sync-runner",
+    senderName: "WikiSync",
+    text: prompt,
+    timestamp: Date.now(),
+    isFromMe: false,
+    isGroup: true,
+    raw: { type: "wiki-sync", agentId },
+  };
+
+  const route: ResolvedRoute = {
+    agentId,
+    agentConfig: agent,
+    route: agent.routes[0],
+  };
+
+  const startTime = Date.now();
+  const triggeredAt = new Date(startTime).toISOString();
+  let status: WikiSyncResult["status"] = "success";
+  let summary = "";
+
+  try {
+    const response = await executeAgent(route, syntheticMsg, baseDir, mcpRegistry, claudeAccounts, globalDefaults);
+    summary = response;
+  } catch (err) {
+    status = "error";
+    summary = String(err);
+    log.error(`Wiki sync failed for ${agentId}: ${err}`);
+  }
+
+  const endTime = Date.now();
+  const result: WikiSyncResult = {
+    id: `ws-${agentId}-${startTime}`,
+    agentId,
+    triggeredBy,
+    triggeredAt,
+    completedAt: new Date(endTime).toISOString(),
+    durationMs: endTime - startTime,
+    summary,
+    status,
+  };
+
+  // Persist result
+  saveWikiSyncResult(agent, baseDir, result);
+
+  log.info(`Wiki sync completed: ${agentId} (${result.durationMs}ms, ${status})`);
+  return result;
+}
+
+// ─── Persistence ────────────────────────────────────────────────────
+
+function saveWikiSyncResult(agent: AppConfig["agents"][string], baseDir: string, result: WikiSyncResult): void {
+  const agentHome = agent.agentHome || resolve(baseDir, agent.memoryDir, "..");
+  const dir = join(agentHome.replace(/^~/, process.env.HOME || ""), "wiki-sync");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const today = new Date().toISOString().split("T")[0];
+  const logFile = join(dir, `log-${today}.jsonl`);
+  appendFileSync(logFile, JSON.stringify(result) + "\n");
+}
+
+export function getWikiSyncHistory(agentHome: string, limit: number = 20): WikiSyncResult[] {
+  const dir = join(agentHome.replace(/^~/, process.env.HOME || ""), "wiki-sync");
+  if (!existsSync(dir)) return [];
+
+  const results: WikiSyncResult[] = [];
+  try {
+    const files = require("fs").readdirSync(dir)
+      .filter((f: string) => f.startsWith("log-") && f.endsWith(".jsonl"))
+      .sort()
+      .reverse();
+
+    for (const file of files) {
+      const lines = readFileSync(join(dir, file), "utf-8").split("\n").filter(Boolean);
+      for (const line of lines.reverse()) {
+        try { results.push(JSON.parse(line)); } catch { /* skip */ }
+        if (results.length >= limit) return results;
+      }
+    }
+  } catch { /* ignore */ }
+  return results;
+}
+
+// ─── Startup / Shutdown ─────────────────────────────────────────────
+
+export function startWikiSync(
+  config: AppConfig,
+  baseDir: string,
+  mcpRegistry?: Record<string, McpServerConfig>,
+): void {
+  for (const [agentId, agent] of Object.entries(config.agents)) {
+    if (!agent.wiki || !agent.wikiSync?.enabled) continue;
+
+    const schedule = agent.wikiSync.schedule;
+    if (!cron.validate(schedule)) {
+      log.warn(`Invalid wikiSync cron for ${agentId}: "${schedule}"`);
+      continue;
+    }
+
+    const task = cron.schedule(schedule, async () => {
+      log.info(`Wiki sync triggered: ${agentId}`);
+      try {
+        await executeWikiSync(
+          agentId, agent, baseDir,
+          mcpRegistry,
+          config.service?.claudeAccounts,
+          { skills: config.defaultSkills, mcps: config.defaultMcps, prompts: config.defaultPrompts, promptTrigger: config.promptTrigger },
+          "cron",
+        );
+      } catch (err) {
+        log.error(`Wiki sync cron error for ${agentId}: ${err}`);
+      }
+    });
+
+    scheduledTasks.push(task);
+    log.info(`Wiki sync scheduled: ${agentId} → "${schedule}"`);
+  }
+}
+
+export function stopWikiSync(): void {
+  for (const task of scheduledTasks) {
+    task.stop();
+  }
+  scheduledTasks.length = 0;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}