@synapta/skills 0.1.0 → 0.1.2

package/skills/telegram-control/scripts/schedule_message.ts

@@ -0,0 +1,216 @@
+#!/usr/bin/env tsx
+
+import { ConvexHttpClient } from 'convex/browser';
+import { readFileSync, existsSync } from 'fs';
+import { api } from '../convex/_generated/api.js';
+import * as chrono from 'chrono-node';
+import { Config, CONFIG_PATH, ParsedTime, getConvexUrl } from './types.js';
+import { setupProxy } from './proxy-util.js';
+import {
+  logError,
+  logSuccess,
+  logInfo,
+  logDetail,
+  logUsage,
+  logNotConfigured,
+} from './logger.js';
+
+// Blob is available globally in Node.js 18+
+declare const Blob: typeof globalThis extends { Blob: infer B } ? B : any;
+
+setupProxy();
+
+async function scheduleMessage(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length < 2) {
+    logUsage(
+      'Usage: tsx schedule_message.ts <time_expression> <title> [message_text] [file_path]',
+      [
+        'tsx schedule_message.ts "tomorrow 10am" "Meeting" "Team standup"',
+        'tsx schedule_message.ts "in 5 minutes" "Quick reminder" "Check email"',
+        'tsx schedule_message.ts "next Monday 9am" "Report" "Weekly report" /path/to/file.pdf',
+        'tsx schedule_message.ts "every day at 9am" "Daily" "Good morning!"',
+        'tsx schedule_message.ts "every 2 hours" "Hydration" "Drink water!"',
+      ]
+    );
+    process.exit(1);
+  }
+
+  const [timeExpression, title, messageText, filePath] = args;
+
+  // Load config
+  if (!existsSync(CONFIG_PATH)) {
+    logNotConfigured();
+  }
+
+  const config: Config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+
+  // Parse time
+  const { scheduledTime, recurring } = parseTime(timeExpression);
+
+  logInfo('📅', 'Scheduling message...');
+  logDetail(`Title: ${title}`);
+  logDetail(`Time: ${new Date(scheduledTime).toLocaleString()}`);
+  if (recurring) {
+    logDetail(`Recurring: ${recurring}`);
+  }
+
+  // Get Convex URL
+  const deploymentUrl = getConvexUrl(config.deployKey);
+  const client = new ConvexHttpClient(deploymentUrl);
+
+  // Verify file exists if provided
+  if (filePath && !existsSync(filePath)) {
+    logError(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  try {
+    // Build args, only including optional fields if they have values
+    const scheduleArgs: any = {
+      title,
+      message_text: messageText,
+      scheduled_time: scheduledTime,
+    };
+
+    // Only add recurring if it exists
+    if (recurring) {
+      scheduleArgs.recurring = recurring;
+    }
+
+    // Handle file upload if provided
+    if (filePath) {
+      logInfo('📁', 'Uploading file to Convex Storage...');
+
+      // Get upload URL from Convex
+      const uploadUrl = await client.mutation(api.messages.generateUploadUrl);
+
+      // Read file
+      const fileBuffer = readFileSync(filePath);
+      const fileName = filePath.split('/').pop() || 'file';
+
+      // Convert buffer to Blob for fetch compatibility
+      const fileBlob = new Blob([fileBuffer], { type: 'application/octet-stream' });
+
+      // Upload file to Convex Storage (proxy is set globally via setGlobalDispatcher)
+      const uploadResponse = await fetch(uploadUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/octet-stream' },
+        body: fileBlob,
+      });
+
+      if (!uploadResponse.ok) {
+        throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+      }
+
+      const { storageId } = (await uploadResponse.json()) as {
+        storageId: string;
+      };
+
+      scheduleArgs.storage_id = storageId;
+      scheduleArgs.file_name = fileName;
+
+      logDetail(`✓ File uploaded: ${fileName}`);
+    }
+
+    const messageId = await client.mutation(
+      api.messages.scheduleMessage,
+      scheduleArgs
+    );
+
+    logSuccess('Message scheduled successfully!');
+    logDetail(`ID: ${messageId}`);
+    if (filePath) {
+      logDetail(
+        `→ File will be sent and deleted from storage when message is delivered`
+      );
+    }
+  } catch (error: any) {
+    logError(`Failed to schedule: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function parseTime(expression: string): ParsedTime {
+  const lowerExpr = expression.toLowerCase();
+
+  // Check for recurring patterns
+  const recurringPatterns = [
+    { pattern: /every (\d+) minutes?/, type: 'interval' as const },
+    { pattern: /every (\d+) hours?/, type: 'interval' as const },
+    {
+      pattern: /every day at (\d+(?::\d+)?(?:am|pm)?)/i,
+      type: 'daily' as const,
+    },
+    {
+      pattern:
+        /every (monday|tuesday|wednesday|thursday|friday|saturday|sunday) at (\d+(?::\d+)?(?:am|pm)?)/i,
+      type: 'weekly' as const,
+    },
+    {
+      pattern: /every (weekday|weekend) at (\d+(?::\d+)?(?:am|pm)?)/i,
+      type: 'weekday' as const,
+    },
+  ];
+
+  for (const { pattern, type } of recurringPatterns) {
+    const match = lowerExpr.match(pattern);
+    if (match) {
+      return parseRecurring(expression, type, match);
+    }
+  }
+
+  // Parse one-time scheduled time
+  const parsedDate = chrono.parseDate(expression, new Date(), {
+    forwardDate: true,
+  });
+
+  if (!parsedDate) {
+    throw new Error(`Could not parse time expression: ${expression}`);
+  }
+
+  return {
+    scheduledTime: parsedDate.getTime(),
+    recurring: undefined,
+  };
+}
+
+function parseRecurring(
+  expression: string,
+  type: 'interval' | 'daily' | 'weekly' | 'weekday',
+  match: RegExpMatchArray
+): ParsedTime {
+  const now = Date.now();
+
+  if (type === 'interval') {
+    const amount = parseInt(match[1]);
+    const unit = expression.includes('hour') ? 'hours' : 'minutes';
+    const ms = unit === 'hours' ? amount * 60 * 60 * 1000 : amount * 60 * 1000;
+
+    return {
+      scheduledTime: now + ms,
+      recurring: `every ${amount} ${unit}`,
+    };
+  }
+
+  // For daily, weekly, weekday patterns - use chrono to parse the time part
+  const timeStr = match[match.length - 1];
+  const parsedDate = chrono.parseDate(timeStr, new Date(), {
+    forwardDate: true,
+  });
+
+  if (!parsedDate) {
+    throw new Error(`Could not parse time: ${timeStr}`);
+  }
+
+  return {
+    scheduledTime: parsedDate.getTime(),
+    recurring: expression,
+  };
+}
+
+scheduleMessage().catch((error: Error) => {
+  logError(error.message);
+  process.exit(1);
+});

package/skills/telegram-control/scripts/send_message.ts

@@ -0,0 +1,115 @@
+#!/usr/bin/env tsx
+
+import { ConvexHttpClient } from 'convex/browser';
+import { readFileSync, existsSync } from 'fs';
+import { api } from '../convex/_generated/api.js';
+import { Config, CONFIG_PATH, getConvexUrl } from './types.js';
+import { setupProxy } from './proxy-util.js';
+import {
+  logError,
+  logSuccess,
+  logInfo,
+  logDetail,
+  logUsage,
+  logNotConfigured,
+} from './logger.js';
+
+setupProxy();
+
+async function sendMessage(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length < 1) {
+    logUsage('Usage: tsx send_message.ts <message_text> [file_path]', [
+      'tsx send_message.ts "Hello from Claude!"',
+      'tsx send_message.ts "Meeting notes" /home/claude/notes.md',
+      'tsx send_message.ts "Report" /home/claude/report.pdf',
+    ]);
+    process.exit(1);
+  }
+
+  const [messageText, filePath] = args;
+
+  // Load config
+  if (!existsSync(CONFIG_PATH)) {
+    logNotConfigured();
+  }
+
+  const config: Config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+
+  // Get Convex URL from deployment
+  logInfo('📡', 'Connecting to Convex...');
+  const deploymentUrl = getConvexUrl(config.deployKey);
+
+  const client = new ConvexHttpClient(deploymentUrl);
+
+  // Verify file exists if provided
+  if (filePath && !existsSync(filePath)) {
+    logError(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  logInfo('📤', 'Sending message...');
+
+  try {
+    // Build args
+    const sendArgs: any = {
+      message_text: messageText,
+    };
+
+    if (filePath) {
+      logInfo('📁', 'Uploading file to Convex Storage...');
+
+      // Get upload URL from Convex
+      const uploadUrl = await client.mutation(api.messages.generateUploadUrl);
+
+      // Read file
+      const fileBuffer = readFileSync(filePath);
+      const fileName = filePath.split('/').pop() || 'file';
+
+      // Convert buffer to Blob for fetch compatibility
+      const fileBlob = new Blob([fileBuffer], {
+        type: 'application/octet-stream',
+      });
+
+      // Upload file to Convex Storage (proxy is set globally via setGlobalDispatcher)
+      const uploadResponse = await fetch(uploadUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/octet-stream' },
+        body: fileBlob,
+      });
+
+      if (!uploadResponse.ok) {
+        throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+      }
+
+      const { storageId } = (await uploadResponse.json()) as {
+        storageId: string;
+      };
+
+      sendArgs.storage_id = storageId;
+      sendArgs.file_name = fileName;
+
+      logDetail(`✓ File uploaded: ${fileName}`);
+    }
+
+    await client.action(api.telegram.sendMessage, sendArgs);
+
+    logSuccess('Message sent successfully!');
+    if (filePath) {
+      logDetail(`→ Text: ${messageText}`);
+      logDetail(`→ File: ${filePath.split('/').pop()}`);
+      logDetail(
+        `→ File will be automatically deleted from storage after sending`
+      );
+    }
+  } catch (error: any) {
+    logError(`Failed to send: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+sendMessage().catch((error: Error) => {
+  logError(error.message);
+  process.exit(1);
+});

package/skills/telegram-control/scripts/setup.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env tsx
+
+import { writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { Config, CONFIG_PATH, BotInfo } from './types.js';
+import { logError, logSuccess, logInfo, logDetail, log } from './logger.js';
+import { setupProxy } from './proxy-util.js';
+
+setupProxy();
+
+async function setup(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length < 3) {
+    console.error(
+      'Usage: tsx setup.ts <bot_token> <user_id> <convex_deploy_key>'
+    );
+    console.error('');
+    console.error('Steps to get credentials:');
+    console.error('1. Bot Token: Message @BotFather on Telegram, create a bot');
+    console.error('2. User ID: Message @userinfobot on Telegram');
+    console.error(
+      '3. Deploy Key: Get from Convex dashboard (Settings > Deploy Keys)'
+    );
+    logDetail('- Login at https://dashboard.convex.dev', '   ');
+    logDetail('- Create a new project', '   ');
+    logDetail('- Go to Settings > Deploy Keys', '   ');
+    logDetail("- Create a 'Production' deploy key", '   ');
+    process.exit(1);
+  }
+
+  const [botToken, userId, deployKey] = args;
+
+  logInfo('🔧', 'Setting up Telegram Reminders with Convex...\n');
+
+  // Step 1: Verify Telegram credentials (skip in sandboxed environments)
+  logInfo('1️⃣', 'Verifying Telegram bot...');
+  try {
+    const botInfo = await verifyTelegramBot(botToken);
+    logDetail(`✓ Bot verified: @${botInfo.username}`);
+  } catch (error: any) {
+    console.warn(
+      `   ⚠ Could not verify bot (fetch may be unavailable): ${error.message}`
+    );
+    logDetail('→ Proceeding with setup anyway...');
+  }
+
+  // Step 2: Save configuration FIRST (so other tools can work)
+  logInfo('\n2️⃣', 'Saving configuration...');
+  const config: Config = {
+    botToken,
+    userId,
+    deployKey,
+    setupDate: new Date().toISOString(),
+  };
+
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  logDetail(`✓ Config saved to ${CONFIG_PATH}`);
+
+  // Step 3: Install dependencies
+  logInfo('\n3️⃣', 'Installing dependencies...');
+  try {
+    execSync('npm install', { stdio: 'inherit' });
+    logDetail('✓ Dependencies installed');
+  } catch (error) {
+    logDetail('✗ Failed to install dependencies');
+    process.exit(1);
+  }
+
+  // Step 4: Deploy to Convex
+  logInfo('\n4️⃣', 'Deploying to Convex...');
+  try {
+    // Set deploy key as environment variable
+    process.env.CONVEX_DEPLOY_KEY = deployKey;
+
+    // Create .env.local for local development
+    writeFileSync('.env.local', `CONVEX_DEPLOY_KEY=${deployKey}\n`);
+
+    // Deploy
+    execSync('npx convex deploy', { stdio: 'inherit' });
+    logDetail('✓ Deployed to Convex');
+
+    // Set environment variables in Convex
+    logInfo('\n5️⃣', 'Setting Telegram credentials in Convex...');
+    execSync(`npx convex env set TELEGRAM_BOT_TOKEN "${botToken}"`, {
+      stdio: 'inherit',
+    });
+    execSync(`npx convex env set TELEGRAM_USER_ID "${userId}"`, {
+      stdio: 'inherit',
+    });
+    logDetail('✓ Environment variables set');
+  } catch (error) {
+    logDetail('✗ Deployment failed');
+    logDetail('→ Make sure your deploy key is valid');
+    logDetail('→ Check https://dashboard.convex.dev for errors');
+    process.exit(1);
+  }
+
+  // Step 6: Test sending a message via Convex
+  logInfo('\n6️⃣', 'Testing message send...');
+  try {
+    await sendTestMessageViaConvex(deployKey);
+    logDetail('✓ Test message sent successfully!');
+    logDetail('→ Check your Telegram for the test message');
+    logDetail(
+      "→ If you don't see it, make sure you've started a chat with your bot"
+    );
+  } catch (error: any) {
+    console.warn(`   ⚠ Could not send test message: ${error.message}`);
+    logDetail(
+      '→ You can test manually with: npx convex run telegram:sendMessage \'{"message_text":"Test"}\''
+    );
+  }
+
+  logSuccess('\nSetup complete!');
+  log('\nYour Telegram reminder system is now running 24/7 in Convex Cloud!');
+  log("\n⚠️  IMPORTANT: Make sure you've started a chat with your bot!");
+  logDetail('→ Search for your bot on Telegram');
+  logDetail("→ Press 'Start' to enable messages");
+  log(
+    '\nTo send messages (use Convex CLI instead of npm scripts in sandboxed environments):'
+  );
+  log(
+    '  • Send: npx convex run telegram:sendMessage \'{"message_text":"Your message"}\''
+  );
+  log(
+    '  • Schedule: npx convex run messages:schedule \'{"scheduled_time":1234567890,"title":"Title","message":"Text"}\''
+  );
+  log('\nMonitor your deployment:');
+  log('  → https://dashboard.convex.dev');
+}
+
+interface TelegramResponse<T = unknown> {
+  ok: boolean;
+  description?: string;
+  result?: T;
+}
+
+async function verifyTelegramBot(botToken: string): Promise<BotInfo> {
+  const url = `https://api.telegram.org/bot${botToken}/getMe`;
+  const response = await fetch(url);
+  const result = (await response.json()) as TelegramResponse<BotInfo>;
+
+  if (!result.ok) {
+    throw new Error(result.description || 'Invalid bot token');
+  }
+
+  return result.result!;
+}
+
+async function sendTestMessage(
+  botToken: string,
+  userId: string
+): Promise<void> {
+  const url = `https://api.telegram.org/bot${botToken}/sendMessage`;
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      chat_id: userId,
+      text: '✅ Telegram Reminders setup successful! Your bot is ready to send messages.',
+    }),
+  });
+
+  const result = (await response.json()) as TelegramResponse;
+  if (!result.ok) {
+    throw new Error(result.description || 'Failed to send test message');
+  }
+}
+
+async function sendTestMessageViaConvex(deployKey: string): Promise<void> {
+  try {
+    execSync(
+      `npx convex run telegram:sendMessage '{"message_text":"✅ Telegram Reminders setup successful! Your bot is ready to send messages."}'`,
+      { stdio: 'inherit' }
+    );
+  } catch (error: any) {
+    throw new Error('Convex test message failed');
+  }
+}
+
+setup().catch((error: Error) => {
+  logError(`\nSetup failed: ${error.message}`);
+  process.exit(1);
+});

package/skills/telegram-control/scripts/types.ts

@@ -0,0 +1,75 @@
+import { Id } from "../convex/_generated/dataModel.js";
+
+/**
+ * Configuration stored in /mnt/user-data/outputs/telegram_config.json
+ */
+export interface Config {
+  botToken: string;
+  userId: string;
+  deployKey: string;
+  setupDate: string;
+}
+
+/**
+ * Scheduled message record from database
+ */
+export interface ScheduledMessage {
+  _id: Id<"scheduled_messages">;
+  title: string;
+  message_text?: string;
+  storage_id?: Id<"_storage">;
+  file_name?: string;
+  scheduled_time: number;
+  recurring?: string;
+  status: string;
+  created_at: number;
+  last_sent_at?: number;
+  error_message?: string;
+}
+
+/**
+ * Message history record from database
+ */
+export interface MessageHistory {
+  _id: Id<"message_history">;
+  title: string;
+  message_text?: string;
+  sent_at: number;
+  status: string;
+  error_message?: string;
+  scheduled_message_id?: Id<"scheduled_messages">;
+}
+
+/**
+ * Telegram bot info from getMe API
+ */
+export interface BotInfo {
+  username: string;
+}
+
+/**
+ * Parsed time result from natural language processing
+ */
+export interface ParsedTime {
+  scheduledTime: number;
+  recurring?: string;
+}
+
+/**
+ * Configuration file path
+ */
+export const CONFIG_PATH = "/mnt/user-data/outputs/telegram_config.json";
+
+/**
+ * Extract Convex deployment URL from deploy key
+ * @param deployKey - Convex deploy key in format "prod:deployment-name|key"
+ * @returns Convex deployment URL
+ */
+export function getConvexUrl(deployKey: string): string {
+  const parts = deployKey.split("|")[0].split(":");
+  if (parts.length < 2) {
+    throw new Error("Invalid deploy key format");
+  }
+  const deploymentName = parts[1];
+  return `https://${deploymentName}.convex.cloud`;
+}

package/skills/telegram-control/scripts/view_history.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env tsx
+
+import { ConvexHttpClient } from "convex/browser";
+import { readFileSync, existsSync } from "fs";
+import { api } from "../convex/_generated/api.js";
+import { Config, CONFIG_PATH, MessageHistory, getConvexUrl } from "./types.js";
+import { setupProxy } from "./proxy-util.js";
+import {
+  logError,
+  logInfo,
+  log,
+  logSeparator,
+  logNotConfigured,
+  logMessageEntry,
+} from "./logger.js";
+
+setupProxy();
+
+async function viewHistory(): Promise<void> {
+  const args = process.argv.slice(2);
+  const limit = args[0] ? parseInt(args[0]) : 50;
+
+  // Load config
+  if (!existsSync(CONFIG_PATH)) {
+    logNotConfigured();
+  }
+
+  const config: Config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+  // Get Convex URL
+  const deploymentUrl = getConvexUrl(config.deployKey);
+  const client = new ConvexHttpClient(deploymentUrl);
+
+  logInfo("📜", `Fetching last ${limit} messages...\n`);
+
+  try {
+    const history = await client.query(api.messages.viewHistory, { limit }) as MessageHistory[];
+
+    if (history.length === 0) {
+      log("No message history found.");
+      return;
+    }
+
+    log("MESSAGE HISTORY:");
+    logSeparator();
+
+    history.forEach((msg, index) => {
+      const time = new Date(msg.sent_at).toLocaleString();
+      const preview = msg.message_text
+        ? msg.message_text.substring(0, 50) + (msg.message_text.length > 50 ? "..." : "")
+        : undefined;
+
+      logMessageEntry({
+        index: index + 1,
+        status: msg.status,
+        title: msg.title,
+        time,
+        message: preview,
+        error: msg.status === "failed" ? msg.error_message : undefined,
+      });
+    });
+
+    log("\n" + "─".repeat(60));
+    log(`Total: ${history.length} messages`);
+  } catch (error: any) {
+    logError(`Failed to view history: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+viewHistory().catch((error: Error) => {
+  logError(error.message);
+  process.exit(1);
+});