myaidev-method 0.2.22 → 0.2.23

package/src/scripts/ping.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import os from "os";
+
+const execAsync = promisify(exec);
+
+/**
+ * Location to IP mapping
+ */
+export const LOCATIONS = {
+	"ashburn-va": "8.8.8.8", // Google DNS (East Coast reference)
+	"los-angeles": "1.1.1.1", // Cloudflare DNS (West Coast reference)
+	chicago: "8.8.4.4", // Google DNS secondary
+	europe: "1.0.0.1", // Cloudflare secondary
+	asia: "208.67.222.222", // OpenDNS
+	amsterdam: "213.165.253.121", // aditya's ramnode vm
+};
+
+/**
+ * Get device's local IP
+ */
+function getLocalIP() {
+	const interfaces = os.networkInterfaces();
+
+	for (const name of Object.keys(interfaces)) {
+		for (const iface of interfaces[name]) {
+			// Skip internal and non-IPv4
+			if (iface.family === "IPv4" && !iface.internal) {
+				return iface.address;
+			}
+		}
+	}
+
+	return "127.0.0.1";
+}
+
+/**
+ * Get public IP and location info
+ */
+async function getPublicIPInfo() {
+	try {
+		// Try ip-api.com first (free, no key needed)
+		const response = await fetch("http://ip-api.com/json/");
+		const data = await response.json();
+
+		// Check if we got valid data
+		if (data.status === "success" && data.query) {
+			return {
+				ip: data.query,
+				city: data.city || "Unknown City",
+				region: data.regionName || data.region,
+				country: data.country || "Unknown Country",
+				location: `${data.city}, ${data.country}`,
+			};
+		}
+
+		// Fallback if API returns error
+		throw new Error("Invalid response from IP API");
+	} catch (error) {
+		// Use local IP as fallback
+		const localIP = getLocalIP();
+		return {
+			ip: localIP,
+			location: `Local Network (${localIP})`,
+		};
+	}
+}
+
+/**
+ * Simple ping function
+ * @param {string} destination - IP address or hostname to ping
+ * @param {string} source - Source IP (defaults to device IP)
+ * @returns {Promise<object>} Ping results
+ */
+export async function ping(destination, source = null) {
+	const sourceIP = source || getLocalIP();
+
+	try {
+		const platform = process.platform;
+		const countFlag = platform === "win32" ? "-n" : "-c";
+		const command = `ping ${countFlag} 4 ${destination}`;
+
+		const { stdout } = await execAsync(command);
+
+		// Parse average latency
+		let avgLatency = null;
+
+		if (platform === "win32") {
+			const match = stdout.match(/Average = (\d+)ms/);
+			if (match) avgLatency = parseFloat(match[1]);
+		} else {
+			const match = stdout.match(/min\/avg\/max\/[^\s]+ = [\d.]+\/([\d.]+)\//);
+			if (match) avgLatency = parseFloat(match[1]);
+		}
+
+		return {
+			source: sourceIP,
+			destination,
+			latency: avgLatency,
+			unit: "ms",
+			success: true,
+		};
+	} catch (error) {
+		return {
+			source: sourceIP,
+			destination,
+			latency: null,
+			error: error.message,
+			success: false,
+		};
+	}
+}
+
+/**
+ * Ping multiple locations
+ * @param {Array<string>} locations - Array of location keys from LOCATIONS
+ * @param {string} source - Source IP (optional)
+ * @returns {Promise<Array>} Array of ping results
+ */
+export async function pingLocations(locations, source = null) {
+	const results = [];
+
+	for (const loc of locations) {
+		const ip = LOCATIONS[loc];
+		if (!ip) {
+			results.push({
+				location: loc,
+				error: "Unknown location",
+				success: false,
+			});
+			continue;
+		}
+
+		const result = await ping(ip, source);
+		results.push({
+			location: loc,
+			...result,
+		});
+	}
+
+	return results;
+}
+
+/**
+ * Format ping results as markdown
+ * @param {Array} results - Array of ping results from pingLocations
+ * @param {object} options - Formatting options
+ * @returns {string} Markdown formatted output
+ */
+export async function formatAsMarkdown(results, options = {}) {
+	const { includeMetadata = true, title = "Network Latency Test Results" } =
+		options;
+
+	let md = `## ${title}\n\n`;
+
+	if (includeMetadata && results.length > 0) {
+		const timestamp = new Date().toISOString();
+		const ipInfo = await getPublicIPInfo();
+
+		md += `**Test Date**: ${timestamp}\n`;
+		md += `**Source**: ${ipInfo.location} (${ipInfo.ip})\n\n`;
+	}
+
+	// Build table
+	md += "| Location | Destination | Latency | Status |\n";
+	md += "|----------|-------------|---------|--------|\n";
+
+	for (const result of results) {
+		const location = result.location || "N/A";
+		const destination = result.destination || "N/A";
+		const latency = result.success ? `${result.latency}ms` : "-";
+		const status = result.success
+			? "✅ Success"
+			: `❌ ${result.error || "Failed"}`;
+
+		md += `| ${location} | ${destination} | ${latency} | ${status} |\n`;
+	}
+
+	// Add summary statistics
+	const successful = results.filter((r) => r.success);
+	if (successful.length > 0) {
+		md += "\n### Summary\n\n";
+
+		const latencies = successful.map((r) => r.latency);
+		const avgLatency = (
+			latencies.reduce((a, b) => a + b, 0) / latencies.length
+		).toFixed(2);
+		const minLatency = Math.min(...latencies).toFixed(2);
+		const maxLatency = Math.max(...latencies).toFixed(2);
+
+		md += `- **Average Latency**: ${avgLatency}ms\n`;
+		md += `- **Best Latency**: ${minLatency}ms\n`;
+		md += `- **Worst Latency**: ${maxLatency}ms\n`;
+		md += `- **Success Rate**: ${successful.length}/${results.length} (${((successful.length / results.length) * 100).toFixed(0)}%)\n`;
+	}
+
+	return md;
+}
+
+// CLI interface
+if (import.meta.url === `file://${process.argv[1]}`) {
+	const args = process.argv.slice(2);
+
+	// Check for --all flag
+	if (args.includes("--all")) {
+		console.log("Testing all locations...\n");
+		const allLocations = Object.keys(LOCATIONS);
+		const results = await pingLocations(allLocations);
+		const markdown = await formatAsMarkdown(results);
+		console.log(markdown);
+		process.exit(0);
+	}
+
+	// Check for multiple locations
+	if (args.length > 1) {
+		console.log(`Testing ${args.length} locations...\n`);
+		const results = await pingLocations(args);
+		const markdown = await formatAsMarkdown(results);
+		console.log(markdown);
+		process.exit(0);
+	}
+
+	const destination = args[0];
+
+	if (!destination) {
+		console.log("Usage:");
+		console.log(
+			"  node ping.js <destination>           # Single location (markdown output)",
+		);
+		console.log(
+			"  node ping.js <loc1> <loc2> <loc3>    # Multiple locations (markdown output)",
+		);
+		console.log(
+			"  node ping.js --all                   # Test all locations (markdown output)",
+		);
+		console.log("\nAvailable locations:");
+		Object.keys(LOCATIONS).forEach((loc) => {
+			console.log(`  ${loc} -> ${LOCATIONS[loc]}`);
+		});
+		process.exit(1);
+	}
+
+	// Single location - markdown output (consistent with multiple locations)
+	console.log(`Testing ${destination}...\n`);
+	const results = await pingLocations([destination]);
+	const markdown = await formatAsMarkdown(results);
+	console.log(markdown);
+}

package/src/scripts/wordpress/publish-to-wordpress.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Publish markdown content to WordPress
+ *
+ * Usage: node publish-to-wordpress.js <file-path> [--status draft|publish]
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import matter from "gray-matter";
+import dotenv from "dotenv";
+import { marked } from "marked";
+import { GutenbergConverter } from "../../mcp/gutenberg-converter.js";
+import { WordPressMCP } from "../../mcp/wordpress-integration.js";
+
+// Load environment variables
+dotenv.config();
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const filePath = args[0];
+const statusIndex = args.indexOf("--status");
+const requestedStatus =
+	statusIndex !== -1 && args[statusIndex + 1] ? args[statusIndex + 1] : "draft";
+
+if (!filePath) {
+	console.error("Error: File path is required");
+	console.error(
+		"Usage: node publish-to-wordpress.js <file-path> [--status draft|publish]",
+	);
+	process.exit(1);
+}
+
+// Validate WordPress configuration
+if (
+	!process.env.WORDPRESS_URL ||
+	!process.env.WORDPRESS_USERNAME ||
+	!process.env.WORDPRESS_APP_PASSWORD
+) {
+	console.error("Error: WordPress configuration is incomplete");
+	console.error("Required environment variables:");
+	console.error("  - WORDPRESS_URL");
+	console.error("  - WORDPRESS_USERNAME");
+	console.error("  - WORDPRESS_APP_PASSWORD");
+	console.error(
+		"\nRun /myai-configure wordpress to set up your WordPress connection",
+	);
+	process.exit(1);
+}
+
+async function publishToWordPress() {
+	try {
+		// Read and parse markdown file
+		const absolutePath = resolve(filePath);
+		const fileContent = readFileSync(absolutePath, "utf-8");
+		const { data: frontmatter, content } = matter(fileContent);
+
+		console.log("📄 Processing file:", filePath);
+		console.log("📋 Title:", frontmatter.title || "No title");
+
+		// Extract interactive blocks before markdown conversion
+		// const { markdown: cleanMarkdown, interactiveBlocks } =
+		// 	GutenbergConverter.extractInteractiveBlocks(content);
+
+		// if (interactiveBlocks.length > 0) {
+		// 	console.log(
+		// 		`   Interactive blocks: ${interactiveBlocks.length} found`,
+		// 	);
+		// }
+
+		// Convert markdown to HTML using marked (preserves placeholders)
+		const html = marked.parse(content);
+
+		// Convert HTML to Gutenberg blocks
+		let htmlContent = GutenbergConverter.htmlToGutenberg(html);
+
+		// Restore interactive blocks as raw HTML blocks
+		// if (interactiveBlocks.length > 0) {
+		// 	htmlContent = GutenbergConverter.restoreInteractiveBlocks(
+		// 		htmlContent,
+		// 		interactiveBlocks,
+		// 	);
+		// }
+
+		// Prepare WordPress configuration
+		const config = {
+			endpoint: {
+				url: process.env.WORDPRESS_URL,
+				api_version: "wp/v2",
+				authentication: {
+					username: process.env.WORDPRESS_USERNAME,
+					password: process.env.WORDPRESS_APP_PASSWORD,
+				},
+			},
+			defaults: {
+				post_status: requestedStatus,
+				format: "standard",
+				comment_status: "open",
+				ping_status: "open",
+			},
+		};
+
+		// Initialize WordPress client
+		const wp = new WordPressMCP(config);
+
+		// Prepare post data
+		const postParams = {
+			title: frontmatter.title || "Untitled",
+			content: htmlContent,
+			status: requestedStatus,
+			excerpt: frontmatter.meta_description || "",
+			slug: frontmatter.slug || "",
+			use_gutenberg: process.env.USE_GUTENBERG === "true",
+			// Note: Tags and categories require ID mapping which will be added in future versions
+		};
+
+		console.log("🚀 Publishing to WordPress...");
+		console.log("   URL:", process.env.WORDPRESS_URL);
+		console.log("   Status:", requestedStatus);
+		console.log(
+			"   Format:",
+			postParams.use_gutenberg ? "Gutenberg" : "Classic",
+		);
+
+		// Create the post
+		const result = await wp.createPost(postParams);
+
+		// Success!
+		console.log("\n✅ Successfully published to WordPress!");
+		console.log("\n📄 Post Details:");
+		console.log("   Post ID:", result.id);
+		console.log("   Title:", result.title.rendered);
+		console.log("   Status:", result.status);
+		console.log("   Slug:", result.slug);
+
+		console.log("\n🔗 URLs:");
+		console.log("   View:", result.link);
+		console.log(
+			"   Edit:",
+			`${process.env.WORDPRESS_URL}/wp-admin/post.php?post=${result.id}&action=edit`,
+		);
+
+		return result;
+	} catch (error) {
+		console.error("\n❌ Error publishing to WordPress:");
+		console.error(error.message);
+
+		if (error.message.includes("401")) {
+			console.error("\n🔑 Authentication failed. Please check:");
+			console.error("   1. Your WordPress username is correct");
+			console.error("   2. Your Application Password is valid");
+			console.error("   3. Application Passwords are enabled on your site");
+		} else if (error.message.includes("404")) {
+			console.error("\n🌐 WordPress site not found. Please check:");
+			console.error("   1. Your WORDPRESS_URL is correct");
+			console.error("   2. The site is accessible");
+			console.error("   3. The REST API is enabled");
+		}
+
+		process.exit(1);
+	}
+}
+
+// Run the publisher
+publishToWordPress();

package/src/server/auth/services/TokenService.ts

@@ -6,7 +6,7 @@ import { AuthError, JWTPayload } from "../../../shared/types.js";
 const TOKEN_EXPIRY_DAYS = 7;
 const ALGORITHM = "RS256";
 
-let keyPair: { publicKey: jose.KeyLike; privateKey: jose.KeyLike } | null = null;
+let keyPair: { publicKey: jose.CryptoKey; privateKey: jose.CryptoKey } | null = null;
 
 export class TokenService extends Context.Tag("TokenService")<
   TokenService,