@hasna/skills 0.1.32 → 0.1.33

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

@@ -1,209 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-export interface Config {
-  apiKey?: string;
-  apiSecret?: string;
-  customerId?: string;
-  shopperId?: string;
-  apiUrl: string;
-  // Remote server configuration
-  useRemoteServer?: boolean;
-  remoteServerUrl: string;
-  remoteApiKey?: string;
-}
-
-const CONFIG_DIR = join(homedir(), ".config", "service-domainpurchase");
-export const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-const AWS_SECRET_NAME = process.env.AWS_SECRET_NAME || "your-org/your-tool/api/live";
-
-const DEFAULT_CONFIG: Config = {
-  apiUrl: "https://api.godaddy.com",
-  remoteServerUrl: process.env.DOMAIN_REMOTE_SERVER_URL || "https://service.example.com/domainpurchase",
-  useRemoteServer: false,
-};
-
-// Cache for AWS secrets to avoid repeated API calls
-let awsSecretsCache: Partial<Config> | null = null;
-
-async function loadAwsSecrets(): Promise<Partial<Config>> {
-  if (awsSecretsCache) {
-    return awsSecretsCache;
-  }
-
-  try {
-    const { SecretsManagerClient, GetSecretValueCommand } = await import(
-      "@aws-sdk/client-secrets-manager"
-    );
-    const client = new SecretsManagerClient({ region: "us-east-1" });
-    const response = await client.send(
-      new GetSecretValueCommand({ SecretId: AWS_SECRET_NAME })
-    );
-
-    if (response.SecretString) {
-      const secret = JSON.parse(response.SecretString);
-      awsSecretsCache = {
-        apiKey: secret.api_key,
-        apiSecret: secret.api_secret,
-        customerId: secret.customer_id,
-        shopperId: secret.shopper_id,
-      };
-      return awsSecretsCache;
-    }
-  } catch {
-    // AWS secrets not available, fall back to other sources
-  }
-
-  return {};
-}
-
-export function loadConfig(): Config {
-  // First check environment variables
-  const envConfig: Partial<Config> = {
-    apiKey: process.env.DOMAIN_API_KEY,
-    apiSecret: process.env.DOMAIN_API_SECRET,
-    customerId: process.env.DOMAIN_CUSTOMER_ID,
-    apiUrl: process.env.DOMAIN_API_URL,
-  };
-
-  // Then load from config file
-  let fileConfig: Partial<Config> = {};
-  if (existsSync(CONFIG_FILE)) {
-    try {
-      fileConfig = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Merge with defaults (env vars take priority)
-  return {
-    ...DEFAULT_CONFIG,
-    ...fileConfig,
-    ...Object.fromEntries(
-      Object.entries(envConfig).filter(([_, v]) => v !== undefined)
-    ),
-  };
-}
-
-export async function loadConfigAsync(): Promise<Config> {
-  // Load AWS secrets first (lowest priority)
-  const awsConfig = await loadAwsSecrets();
-
-  // Then check environment variables
-  const envConfig: Partial<Config> = {
-    apiKey: process.env.DOMAIN_API_KEY,
-    apiSecret: process.env.DOMAIN_API_SECRET,
-    customerId: process.env.DOMAIN_CUSTOMER_ID,
-    apiUrl: process.env.DOMAIN_API_URL,
-    useRemoteServer: process.env.DOMAIN_USE_REMOTE_SERVER === "true",
-    remoteServerUrl: process.env.DOMAIN_REMOTE_SERVER_URL,
-    remoteApiKey: process.env.DOMAIN_REMOTE_API_KEY,
-  };
-
-  // Then load from config file
-  let fileConfig: Partial<Config> = {};
-  if (existsSync(CONFIG_FILE)) {
-    try {
-      fileConfig = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Merge: AWS -> file -> env (env takes highest priority)
-  return {
-    ...DEFAULT_CONFIG,
-    ...awsConfig,
-    ...fileConfig,
-    ...Object.fromEntries(
-      Object.entries(envConfig).filter(([_, v]) => v !== undefined)
-    ),
-  };
-}
-
-export function saveConfig(config: Partial<Config>): void {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-
-  const current = loadConfig();
-  const merged = { ...current, ...config };
-  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
-}
-
-export function getApiKey(): string | undefined {
-  return loadConfig().apiKey;
-}
-
-export function getApiSecret(): string | undefined {
-  return loadConfig().apiSecret;
-}
-
-export function getCustomerId(): string | undefined {
-  return loadConfig().customerId;
-}
-
-export function getApiUrl(): string {
-  return loadConfig().apiUrl;
-}
-
-// Async versions that can load from AWS Secrets Manager
-export async function getApiKeyAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).apiKey;
-}
-
-export async function getApiSecretAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).apiSecret;
-}
-
-export async function getCustomerIdAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).customerId;
-}
-
-export async function getShopperIdAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).shopperId;
-}
-
-export async function getApiUrlAsync(): Promise<string> {
-  return (await loadConfigAsync()).apiUrl;
-}
-
-// Remote server configuration getters
-export function useRemoteServer(): boolean {
-  return loadConfig().useRemoteServer || false;
-}
-
-export function getRemoteServerUrl(): string {
-  return loadConfig().remoteServerUrl;
-}
-
-export function getRemoteApiKey(): string | undefined {
-  return loadConfig().remoteApiKey;
-}
-
-export async function getRemoteApiKeyAsync(): Promise<string | undefined> {
-  const config = await loadConfigAsync();
-  if (config.remoteApiKey) {
-    return config.remoteApiKey;
-  }
-  // Try to load from AWS Secrets Manager
-  try {
-    const { SecretsManagerClient, GetSecretValueCommand } = await import(
-      "@aws-sdk/client-secrets-manager"
-    );
-    const client = new SecretsManagerClient({ region: "us-east-1" });
-    const response = await client.send(
-      new GetSecretValueCommand({ SecretId: process.env.DOMAIN_API_KEY_SECRET_ID || "your-org/prod/your-service/api-key" })
-    );
-    return response.SecretString;
-  } catch {
-    return undefined;
-  }
-}
-
-// Initialize config from AWS on first run
-export async function initConfig(): Promise<void> {
-  await loadConfigAsync();
-}

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

@@ -1,165 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-const SERVICE_NAME = "service-domainpurchase";
-const SERVICE_DIR_NAME = `.${SERVICE_NAME}`;
-
-export interface InstallOptions {
-  force?: boolean;
-}
-
-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 isInstalled(): boolean {
-  return existsSync(getServiceDir());
-}
-
-export function ensureInstalled(): void {
-  if (!isInstalled()) {
-    install();
-  }
-}
-
-export function install(options: InstallOptions = {}): { success: boolean; path: string; message: string } {
-  const serviceDir = getServiceDir();
-
-  if (existsSync(serviceDir) && !options.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}`,
-  };
-}
-
-export function uninstall(): { success: boolean; message: string } {
-  const serviceDir = getServiceDir();
-
-  if (!existsSync(serviceDir)) {
-    return {
-      success: false,
-      message: "Not installed.",
-    };
-  }
-
-  const { rmSync } = require("fs");
-  rmSync(serviceDir, { recursive: true, force: true });
-
-  return {
-    success: true,
-    message: `Uninstalled from ${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 domain purchase service that provides:
-
-- Domain registration automation
-- Registrar integrations (GoDaddy, Namecheap, etc.)
-- DNS configuration
-- Domain transfer management
-- Renewal tracking
-
-## Usage
-
-\`\`\`bash
-# Purchase a domain
-service-domainpurchase buy --domain "example.com"
-
-# List purchased domains
-service-domainpurchase list
-
-# Check purchase status
-service-domainpurchase status --domain "example.com"
-
-# Start the server
-service-domainpurchase server
-\`\`\`
-
-## Log File
-
-The \`${SERVICE_NAME}.log\` file contains:
-- Purchase transactions
-- Registration status
-- DNS changes
-- API activity
-
-## More Information
-
-For full documentation, run:
-
-\`\`\`bash
-service-domainpurchase --help
-\`\`\`
-`;
-}
-
-export type LogLevel = "debug" | "info" | "warn" | "error";
-
-export function logToFile(message: string, level: LogLevel = "info"): void {
-  ensureInstalled();
-
-  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/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;
-}