mop-agent 0.1.14 → 0.1.16

package/apps/web/lib/channels/config.ts

@@ -0,0 +1,48 @@
+import { decryptSecret, encryptSecret, keyHint } from "../crypto";
+import { getSqlite } from "../db/client";
+
+export type AppId = "telegram" | "discord" | "whatsapp" | "slack" | "webhook";
+export type AppPayload = { secret: string; fields: Record<string, string> };
+type AppRow = { owner_id: string; app_id: AppId; config_enc: string; enabled: number; updated_at: number };
+
+export function listAppConfigs(ownerId: string) {
+  const rows = getSqlite().prepare("SELECT * FROM app_config WHERE owner_id = ? ORDER BY app_id").all(ownerId) as AppRow[];
+  return rows.map((row) => {
+    let hint = "••••";
+    try { hint = keyHint((JSON.parse(decryptSecret(row.config_enc)) as AppPayload).secret); } catch { /* masked */ }
+    return { appId: row.app_id, configured: true, enabled: !!row.enabled, keyHint: hint, updatedAt: row.updated_at };
+  });
+}
+
+export function saveAppConfig(ownerId: string, input: { appId: AppId; secret?: string; fields?: Record<string, string>; enabled: boolean }) {
+  const existing = getSqlite().prepare("SELECT * FROM app_config WHERE owner_id = ? AND app_id = ?").get(ownerId, input.appId) as AppRow | undefined;
+  let previous: AppPayload | undefined;
+  if (existing) {
+    try { previous = JSON.parse(decryptSecret(existing.config_enc)) as AppPayload; } catch { /* replace invalid config */ }
+  }
+  const secret = input.secret?.trim() || previous?.secret;
+  if (!secret) throw new Error("missing_secret");
+  const payload: AppPayload = { secret, fields: { ...(previous?.fields ?? {}), ...(input.fields ?? {}) } };
+  getSqlite().prepare(`
+    INSERT INTO app_config(owner_id, app_id, config_enc, enabled, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(owner_id, app_id) DO UPDATE SET
+      config_enc = excluded.config_enc,
+      enabled = excluded.enabled,
+      updated_at = excluded.updated_at
+  `).run(ownerId, input.appId, encryptSecret(JSON.stringify(payload)), input.enabled ? 1 : 0, Date.now());
+}
+
+export function listEnabledAppConfigs(): Array<{ appId: AppId; payload: AppPayload }> {
+  const rows = getSqlite().prepare("SELECT * FROM app_config WHERE enabled = 1 ORDER BY updated_at DESC").all() as AppRow[];
+  const seen = new Set<AppId>();
+  const configs: Array<{ appId: AppId; payload: AppPayload }> = [];
+  for (const row of rows) {
+    if (seen.has(row.app_id)) continue;
+    try {
+      configs.push({ appId: row.app_id, payload: JSON.parse(decryptSecret(row.config_enc)) as AppPayload });
+      seen.add(row.app_id);
+    } catch { /* skip unreadable secrets */ }
+  }
+  return configs;
+}

package/apps/web/lib/channels/index.ts

@@ -4,14 +4,18 @@
  */
 export async function startChannels(): Promise<string[]> {
   const started: string[] = [];
-  if (process.env.TELEGRAM_BOT_TOKEN) {
+  const { listEnabledAppConfigs } = await import("./config");
+  const configs = listEnabledAppConfigs();
+  const telegramToken = process.env.TELEGRAM_BOT_TOKEN ?? configs.find((config) => config.appId === "telegram")?.payload.secret;
+  const discordToken = process.env.DISCORD_BOT_TOKEN ?? configs.find((config) => config.appId === "discord")?.payload.secret;
+  if (telegramToken) {
     const { startTelegram } = await import("./telegram");
-    startTelegram(process.env.TELEGRAM_BOT_TOKEN);
+    startTelegram(telegramToken);
     started.push("telegram");
   }
-  if (process.env.DISCORD_BOT_TOKEN) {
+  if (discordToken) {
     const { startDiscord } = await import("./discord");
-    startDiscord(process.env.DISCORD_BOT_TOKEN);
+    startDiscord(discordToken);
     started.push("discord");
   }
   return started;

package/apps/web/lib/db/migrate.ts

@@ -80,6 +80,15 @@ CREATE TABLE IF NOT EXISTS provider_config (
   updated_at INTEGER NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS app_config (
+  owner_id TEXT NOT NULL,
+  app_id TEXT NOT NULL,
+  config_enc TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 0,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (owner_id, app_id)
+);
+
 CREATE TABLE IF NOT EXISTS skill (
   id TEXT PRIMARY KEY,
   name TEXT NOT NULL,

package/apps/web/lib/providers/anthropic.ts

@@ -7,11 +7,30 @@ export function anthropicProvider(apiKey: string, model = "claude-sonnet-4-6"):
     id: "anthropic",
     model,
     async *chat({ system, messages }: ChatOptions) {
+      const anthropicMessages: Anthropic.MessageParam[] = messages.map((message) => {
+        if (!message.image || message.role !== "user") return { role: message.role, content: message.content };
+        const match = message.image.dataUrl.match(/^data:(image\/(?:jpeg|png|gif|webp));base64,(.+)$/s);
+        if (!match) return { role: message.role, content: message.content };
+        return {
+          role: message.role,
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: match[1] as "image/jpeg" | "image/png" | "image/gif" | "image/webp",
+                data: match[2]!,
+              },
+            },
+            { type: "text", text: message.content || "Describe and help with this image." },
+          ],
+        };
+      });
       const stream = client.messages.stream({
         model,
         max_tokens: 4096,
         system,
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        messages: anthropicMessages,
       });
       for await (const ev of stream) {
         if (ev.type === "content_block_delta" && ev.delta.type === "text_delta") {

package/apps/web/lib/providers/openrouter.ts

@@ -8,12 +8,22 @@ export function openRouterProvider(apiKey: string, model = "anthropic/claude-son
     id: "openrouter",
     model,
     async *chat({ system, messages }: ChatOptions) {
+      const openRouterMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = messages.map((message) => {
+        if (!message.image || message.role !== "user") return { role: message.role, content: message.content };
+        return {
+          role: "user",
+          content: [
+            { type: "text", text: message.content || "Describe and help with this image." },
+            { type: "image_url", image_url: { url: message.image.dataUrl } },
+          ],
+        };
+      });
       const stream = await client.chat.completions.create({
         model,
         stream: true,
         messages: [
           ...(system ? ([{ role: "system" as const, content: system }]) : []),
-          ...messages.map((m) => ({ role: m.role, content: m.content })),
+          ...openRouterMessages,
         ],
       });
       for await (const chunk of stream) {

package/apps/web/lib/providers/types.ts

@@ -1,5 +1,6 @@
 /** Provider-neutral chat interface. Adapters stream text deltas. */
-export type Msg = { role: "user" | "assistant"; content: string };
+export type ChatImage = { name: string; mimeType: string; dataUrl: string };
+export type Msg = { role: "user" | "assistant"; content: string; image?: ChatImage };
 
 export type ChatOptions = {
   system?: string;

package/apps/web/package.json

@@ -15,6 +15,9 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.105.0",
     "@mop/link-protocol": "*",
+    "@radix-ui/react-dialog": "^1.1.17",
+    "@radix-ui/react-popover": "^1.1.17",
+    "@radix-ui/react-tooltip": "^1.2.10",
     "@xenova/transformers": "^2.17.2",
     "better-auth": "^1.6.20",
     "better-sqlite3": "^12.11.1",
@@ -31,6 +34,7 @@
     "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@tailwindcss/postcss": "^4.3.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
@@ -38,7 +42,9 @@
     "@types/ws": "^8.5.12",
     "cross-env": "^7.0.3",
     "drizzle-kit": "^0.31.10",
+    "tailwindcss": "^4.3.1",
     "tsx": "^4.19.0",
+    "tw-animate-css": "^1.4.0",
     "typescript": "^5.5.0"
   }
 }

package/apps/web/postcss.config.mjs

@@ -0,0 +1,5 @@
+export default {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};