@hasna/skills 0.1.32 → 0.1.34

package/skills/managemcp/.env.example

@@ -1,16 +0,0 @@
-# Database (individual connection params)
-DB_HOST=localhost
-DB_PORT=5432
-DB_NAME=managemcp_db
-DB_USER=postgres
-DB_PASSWORD=your-password-here
-
-# Or use a full connection string
-# DATABASE_URL=postgres://user:password@host:port/dbname
-
-# Server
-PORT=3000
-
-# API (for CLI usage)
-API_URL=https://api.example.com
-API_KEY=your-api-key-here

package/skills/managemcp/scripts/migrate.ts

@@ -1,57 +0,0 @@
-#!/usr/bin/env bun
-
-import { sql, testConnection, closeConnection } from '../src/db';
-
-console.log('Running database migrations...');
-
-const connected = await testConnection();
-if (!connected) {
-  console.error('Failed to connect to database');
-  process.exit(1);
-}
-
-console.log('Database connected\n');
-
-try {
-  console.log('Creating tables...');
-  await sql`
-    CREATE TABLE IF NOT EXISTS items (
-      id SERIAL PRIMARY KEY,
-      name VARCHAR(255) NOT NULL,
-      description TEXT,
-      metadata JSONB DEFAULT '{}',
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-
-  console.log('Creating indexes...');
-  await sql`CREATE INDEX IF NOT EXISTS idx_items_name ON items(name)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_items_created_at ON items(created_at DESC)`;
-
-  console.log('Creating triggers...');
-  await sql`
-    CREATE OR REPLACE FUNCTION update_updated_at_column()
-    RETURNS TRIGGER AS $$
-    BEGIN
-      NEW.updated_at = CURRENT_TIMESTAMP;
-      RETURN NEW;
-    END;
-    $$ language 'plpgsql'
-  `;
-
-  await sql`DROP TRIGGER IF EXISTS update_items_updated_at ON items`;
-  await sql`
-    CREATE TRIGGER update_items_updated_at
-    BEFORE UPDATE ON items
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column()
-  `;
-
-  console.log('\nMigrations completed successfully');
-} catch (error) {
-  console.error('\nMigration failed:', error);
-  process.exit(1);
-} finally {
-  await closeConnection();
-}

package/skills/managemcp/scripts/seed.ts

@@ -1,58 +0,0 @@
-#!/usr/bin/env bun
-
-import { sql, testConnection, closeConnection } from '../src/db';
-
-console.log('Seeding database...');
-
-const connected = await testConnection();
-if (!connected) {
-  console.error('Failed to connect to database');
-  process.exit(1);
-}
-
-console.log('Database connected\n');
-
-try {
-  const [{ count }] = await sql`SELECT COUNT(*) as count FROM items`;
-
-  if (parseInt(count) > 0) {
-    console.log(`Database already has ${count} items - skipping seed`);
-    console.log('To re-seed, truncate the items table first\n');
-    process.exit(0);
-  }
-
-  console.log('Inserting seed data...');
-
-  const seedItems = [
-    {
-      name: 'Example Item 1',
-      description: 'This is the first example item',
-      metadata: { category: 'example', priority: 'high' },
-    },
-    {
-      name: 'Example Item 2',
-      description: 'This is the second example item',
-      metadata: { category: 'sample', priority: 'medium' },
-    },
-    {
-      name: 'Example Item 3',
-      description: 'This is the third example item',
-      metadata: { category: 'demo', priority: 'low' },
-    },
-  ];
-
-  for (const item of seedItems) {
-    await sql`
-      INSERT INTO items (name, description, metadata)
-      VALUES (${item.name}, ${item.description}, ${JSON.stringify(item.metadata)})
-    `;
-    console.log(`  Created: ${item.name}`);
-  }
-
-  console.log(`\nSeeded ${seedItems.length} items successfully`);
-} catch (error) {
-  console.error('\nSeeding failed:', error);
-  process.exit(1);
-} finally {
-  await closeConnection();
-}

package/skills/managemcp/src/db/index.ts

@@ -1,37 +0,0 @@
-import postgres from 'postgres';
-
-function getConnectionString(): string {
-  if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
-
-  const {
-    DB_USER = 'postgres',
-    DB_PASSWORD = '',
-    DB_HOST = 'localhost',
-    DB_PORT = '5432',
-    DB_NAME = 'managemcp_db',
-  } = process.env;
-
-  return `postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}`;
-}
-
-export const sql = postgres(getConnectionString(), {
-  max: 10,
-  idle_timeout: 20,
-  connect_timeout: 10,
-});
-
-export async function testConnection(): Promise<boolean> {
-  try {
-    await sql`SELECT 1`;
-    return true;
-  } catch (error) {
-    console.error('Database connection failed:', error instanceof Error ? error.message : 'Unknown error');
-    return false;
-  }
-}
-
-export async function closeConnection(): Promise<void> {
-  await sql.end({ timeout: 5 });
-}
-
-export type Sql = typeof sql;

package/skills/managemcp/src/lib/api-client.ts

@@ -1,108 +0,0 @@
-import { getApiKey, getApiUrl } from './config';
-
-export interface ApiItem {
-  id: string;
-  name: string;
-  description?: string;
-  metadata?: Record<string, unknown>;
-  createdAt?: string;
-  updatedAt?: string;
-}
-
-export interface ListOptions {
-  filter?: string;
-  limit?: number;
-  offset?: number;
-}
-
-export interface CreateItemData {
-  name: string;
-  description?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export class ApiError extends Error {
-  constructor(
-    message: string,
-    public statusCode?: number,
-    public response?: unknown
-  ) {
-    super(message);
-    this.name = 'ApiError';
-  }
-}
-
-async function makeRequest<T>(
-  endpoint: string,
-  options: RequestInit = {}
-): Promise<T> {
-  const apiUrl = await getApiUrl();
-  const apiKey = await getApiKey();
-
-  if (!apiUrl) {
-    throw new ApiError('API URL not configured. Run: managemcp config --set-api-url <url>');
-  }
-
-  if (!apiKey) {
-    throw new ApiError('API key not configured. Run: managemcp config --set-api-key <key>');
-  }
-
-  const url = `${apiUrl}${endpoint}`;
-  const headers = {
-    'Authorization': `Bearer ${apiKey}`,
-    'Content-Type': 'application/json',
-    ...options.headers,
-  };
-
-  try {
-    const response = await fetch(url, {
-      ...options,
-      headers,
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => null);
-      const message = errorData?.error || response.statusText;
-      throw new ApiError(`API request failed: ${message}`, response.status, errorData);
-    }
-
-    return await response.json();
-  } catch (error) {
-    if (error instanceof ApiError) throw error;
-    throw new ApiError(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-  }
-}
-
-export async function listItems(options: ListOptions = {}): Promise<ApiItem[]> {
-  const params = new URLSearchParams();
-  if (options.filter) params.set('filter', options.filter);
-  if (options.limit) params.set('limit', options.limit.toString());
-  if (options.offset) params.set('offset', options.offset.toString());
-
-  const query = params.toString();
-  const endpoint = `/items${query ? `?${query}` : ''}`;
-
-  const response = await makeRequest<{ items: ApiItem[] }>(endpoint);
-  return response.items;
-}
-
-export async function getItem(id: string): Promise<ApiItem> {
-  return await makeRequest<ApiItem>(`/items/${id}`);
-}
-
-export async function searchItems(query: string, limit = 10): Promise<ApiItem[]> {
-  const params = new URLSearchParams({
-    q: query,
-    limit: limit.toString(),
-  });
-
-  const response = await makeRequest<{ items: ApiItem[] }>(`/items/search?${params}`);
-  return response.items;
-}
-
-export async function createItem(data: CreateItemData): Promise<ApiItem> {
-  return await makeRequest<ApiItem>('/items', {
-    method: 'POST',
-    body: JSON.stringify(data),
-  });
-}

package/skills/managemcp/src/lib/config.ts

@@ -1,34 +0,0 @@
-import { readFile, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-
-export interface Config {
-  apiUrl?: string;
-  apiKey?: string;
-}
-
-export const CONFIG_FILE = join(homedir(), '.managemcp.json');
-
-export async function loadConfig(): Promise<Config> {
-  try {
-    const data = await readFile(CONFIG_FILE, 'utf-8');
-    return JSON.parse(data);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
-    throw error;
-  }
-}
-
-export async function saveConfig(config: Config): Promise<void> {
-  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
-}
-
-export async function getApiKey(): Promise<string | undefined> {
-  const config = await loadConfig();
-  return config.apiKey || process.env.API_KEY;
-}
-
-export async function getApiUrl(): Promise<string | undefined> {
-  const config = await loadConfig();
-  return config.apiUrl || process.env.API_URL;
-}

package/skills/managemcp/src/lib/installer.ts

@@ -1,140 +0,0 @@
-import { readFile, writeFile, readdir, unlink, mkdir } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-import { getItem } from './api-client';
-
-export type Target = 'claude' | 'codex';
-export type ConflictStrategy = 'skip' | 'overwrite';
-
-export interface InstallResult {
-  success: boolean;
-  message: string;
-  itemId: string;
-}
-
-export interface InstalledItem {
-  id: string;
-  name: string;
-  target: Target;
-  installedAt: string;
-}
-
-const CLAUDE_DIR = join(homedir(), '.claude', 'skills');
-const CODEX_DIR = join(homedir(), '.codex', 'skills');
-
-function getTargetDir(target: Target): string {
-  return target === 'claude' ? CLAUDE_DIR : CODEX_DIR;
-}
-
-async function ensureDir(dir: string): Promise<void> {
-  await mkdir(dir, { recursive: true });
-}
-
-async function writeItemFile(
-  target: Target,
-  itemId: string,
-  content: string,
-  strategy: ConflictStrategy
-): Promise<boolean> {
-  const dir = getTargetDir(target);
-  await ensureDir(dir);
-
-  const filePath = join(dir, `${itemId}.json`);
-
-  try {
-    await readFile(filePath);
-    if (strategy === 'skip') return false;
-  } catch {
-    // File doesn't exist, proceed
-  }
-
-  await writeFile(filePath, content, 'utf-8');
-  return true;
-}
-
-async function installToTarget(
-  target: Target,
-  itemId: string,
-  strategy: ConflictStrategy = 'skip'
-): Promise<InstallResult> {
-  try {
-    const item = await getItem(itemId);
-    const content = JSON.stringify(item, null, 2);
-    const written = await writeItemFile(target, itemId, content, strategy);
-
-    const targetName = target.charAt(0).toUpperCase() + target.slice(1);
-    return {
-      success: true,
-      message: written
-        ? `Installed to ${targetName}: ${item.name}`
-        : `Skipped (already exists): ${item.name}`,
-      itemId,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to install to ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      itemId,
-    };
-  }
-}
-
-export async function install(
-  itemId: string,
-  target: Target | 'both' = 'both',
-  strategy: ConflictStrategy = 'skip'
-): Promise<InstallResult> {
-  if (target === 'both') {
-    const claudeResult = await installToTarget('claude', itemId, strategy);
-    const codexResult = await installToTarget('codex', itemId, strategy);
-
-    return {
-      success: claudeResult.success && codexResult.success,
-      message: `${claudeResult.message}\n${codexResult.message}`,
-      itemId,
-    };
-  }
-
-  return await installToTarget(target, itemId, strategy);
-}
-
-export async function clearTarget(target?: Target | 'both'): Promise<void> {
-  const targets: Target[] = target === 'both' || !target ? ['claude', 'codex'] : [target];
-
-  for (const t of targets) {
-    const dir = getTargetDir(t);
-    try {
-      const files = await readdir(dir);
-      const jsonFiles = files.filter((f) => f.endsWith('.json')).map((f) => unlink(join(dir, f)));
-      await Promise.all(jsonFiles);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-    }
-  }
-}
-
-export async function listInstalled(target?: Target | 'both'): Promise<InstalledItem[]> {
-  const targets: Target[] = target === 'both' || !target ? ['claude', 'codex'] : [target];
-  const items: InstalledItem[] = [];
-
-  for (const t of targets) {
-    const dir = getTargetDir(t);
-    try {
-      const files = await readdir(dir);
-      for (const file of files.filter((f) => f.endsWith('.json'))) {
-        const content = await readFile(join(dir, file), 'utf-8');
-        const item = JSON.parse(content);
-        items.push({
-          id: item.id,
-          name: item.name,
-          target: t,
-          installedAt: file,
-        });
-      }
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-    }
-  }
-
-  return items;
-}

package/skills/managemcp/src/lib/service-dir.ts

@@ -1,119 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-const SERVICE_NAME = "managemcp";
-const SERVICE_DIR_NAME = `.${SERVICE_NAME}`;
-
-export function getServiceDir(): string {
-  return join(homedir(), SERVICE_DIR_NAME);
-}
-
-export function getLogFilePath(): string {
-  return join(getServiceDir(), `${SERVICE_NAME}.log`);
-}
-
-export function getReadmePath(): string {
-  return join(getServiceDir(), "README.md");
-}
-
-export function isServiceDirInstalled(): boolean {
-  return existsSync(getServiceDir());
-}
-
-export function ensureServiceDir(): void {
-  if (!isServiceDirInstalled()) {
-    initServiceDir();
-  }
-}
-
-export function initServiceDir(force = false): { success: boolean; path: string; message: string } {
-  const serviceDir = getServiceDir();
-
-  if (existsSync(serviceDir) && !force) {
-    return {
-      success: false,
-      path: serviceDir,
-      message: "Already installed. Use --force to reinstall.",
-    };
-  }
-
-  mkdirSync(serviceDir, { recursive: true });
-
-  const readmeContent = generateReadme();
-  writeFileSync(getReadmePath(), readmeContent);
-
-  const logHeader = `# ${SERVICE_NAME} log file
-# Created: ${new Date().toISOString()}
-# This file contains activity history and logs.
-# -------------------------------------------------------
-
-`;
-  writeFileSync(getLogFilePath(), logHeader);
-
-  return {
-    success: true,
-    path: serviceDir,
-    message: `Installed at ${serviceDir}`,
-  };
-}
-
-function generateReadme(): string {
-  return `# .${SERVICE_NAME}
-
-This directory contains local configuration and logs for \`${SERVICE_NAME}\`.
-
-## Files
-
-| Path | Description |
-|------|-------------|
-| \`${SERVICE_NAME}.log\` | Activity log |
-| \`README.md\` | This file |
-
-## What is ${SERVICE_NAME}?
-
-\`${SERVICE_NAME}\` is a tool for managing MCP server connections.
-
-## Log File
-
-The \`${SERVICE_NAME}.log\` file contains:
-- Activity logs
-- Error logs
-- API activity
-
-## More Information
-
-For full documentation, run:
-
-\`\`\`bash
-${SERVICE_NAME} --help
-\`\`\`
-`;
-}
-
-export type LogLevel = "debug" | "info" | "warn" | "error";
-
-export function logToFile(message: string, level: LogLevel = "info"): void {
-  ensureServiceDir();
-
-  const timestamp = new Date().toISOString();
-  const logLine = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-
-  try {
-    appendFileSync(getLogFilePath(), logLine);
-  } catch {
-    // Silently fail
-  }
-}
-
-export function logInfo(message: string): void {
-  logToFile(message, "info");
-}
-
-export function logError(message: string): void {
-  logToFile(message, "error");
-}
-
-export function logWarn(message: string): void {
-  logToFile(message, "warn");
-}

package/skills/sms/scripts/buy-number.ts

@@ -1,63 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Script to buy a Twilio phone number for an agent
- * Usage: bun run scripts/buy-number.ts [agent_name] [area_code]
- */
-
-import twilio from "twilio";
-
-const CONFIG = {
-  accountSid: process.env.TWILIO_ACCOUNT_SID || "",
-  authToken: process.env.TWILIO_AUTH_TOKEN || "",
-};
-
-const twilioClient = twilio(CONFIG.accountSid, CONFIG.authToken);
-
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}
-
-async function buyPhoneNumber() {
-  const agentName = process.argv[2] || "claude";
-  const areaCode = process.argv[3] || "302"; // Default to Delaware
-
-  const friendlyName = `${capitalize(agentName)} (AI Agent)`;
-
-  console.log(`Searching for available numbers with area code ${areaCode}...`);
-
-  try {
-    // Search for available numbers
-    const availableNumbers = await twilioClient
-      .availablePhoneNumbers("US")
-      .local.list({ areaCode: parseInt(areaCode), limit: 5 });
-
-    if (availableNumbers.length === 0) {
-      console.error(`No available phone numbers found with area code ${areaCode}`);
-      process.exit(1);
-    }
-
-    console.log(`Found ${availableNumbers.length} available numbers:`);
-    availableNumbers.forEach((n, i) => {
-      console.log(`  ${i + 1}. ${n.phoneNumber}`);
-    });
-
-    // Purchase the first available number
-    const phoneNumber = availableNumbers[0].phoneNumber;
-    console.log(`\nPurchasing ${phoneNumber} for ${friendlyName}...`);
-
-    const purchased = await twilioClient.incomingPhoneNumbers.create({
-      phoneNumber,
-      friendlyName,
-    });
-
-    console.log("\nPhone number purchased successfully!");
-    console.log(`  SID: ${purchased.sid}`);
-    console.log(`  Phone Number: ${purchased.phoneNumber}`);
-    console.log(`  Friendly Name: ${purchased.friendlyName}`);
-  } catch (error: any) {
-    console.error("Failed to buy phone number:", error.message);
-    process.exit(1);
-  }
-}
-
-buyPhoneNumber();

package/skills/sms/scripts/test-send.ts

@@ -1,67 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Test script to send SMS via Twilio
- * Usage: bun run scripts/test-send.ts [from_number] [to_number] [message]
- */
-
-import twilio from "twilio";
-
-const CONFIG = {
-  accountSid: process.env.TWILIO_ACCOUNT_SID || "",
-  authToken: process.env.TWILIO_AUTH_TOKEN || "",
-};
-
-const twilioClient = twilio(CONFIG.accountSid, CONFIG.authToken);
-
-function formatPhoneNumber(phone: string): string {
-  const digits = phone.replace(/\D/g, "");
-  if (digits.length === 10) {
-    return `+1${digits}`;
-  }
-  if (digits.length === 11 && digits.startsWith("1")) {
-    return `+${digits}`;
-  }
-  if (!phone.startsWith("+")) {
-    return `+${digits}`;
-  }
-  return phone;
-}
-
-async function sendTestSms() {
-  const fromNumber = process.argv[2];
-  const toNumber = process.argv[3];
-  const messageBody =
-    process.argv[4] ||
-    `Hello from the SMS agent!\n\nThis is a test SMS sent at ${new Date().toISOString()}.`;
-
-  if (!fromNumber || !toNumber) {
-    console.error("Usage: bun run scripts/test-send.ts <from_number> <to_number> [message]");
-    console.error("\nAvailable numbers:");
-    const numbers = await twilioClient.incomingPhoneNumbers.list();
-    numbers.forEach((n) => {
-      console.log(`  ${n.phoneNumber} - ${n.friendlyName}`);
-    });
-    process.exit(1);
-  }
-
-  console.log(`Sending test SMS from ${formatPhoneNumber(fromNumber)} to ${formatPhoneNumber(toNumber)}...`);
-
-  try {
-    const message = await twilioClient.messages.create({
-      body: messageBody,
-      from: formatPhoneNumber(fromNumber),
-      to: formatPhoneNumber(toNumber),
-    });
-
-    console.log("SMS sent successfully!");
-    console.log(`  Message SID: ${message.sid}`);
-    console.log(`  Status: ${message.status}`);
-    console.log(`  From: ${message.from}`);
-    console.log(`  To: ${message.to}`);
-  } catch (error: any) {
-    console.error("Failed to send SMS:", error.message);
-    process.exit(1);
-  }
-}
-
-sendTestSms();