@hasna/skills 0.0.2

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

@@ -0,0 +1,209 @@
+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/tool/brandsight/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/service/domainpurchase/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/skill-domainpurchase/src/lib/installer.ts

@@ -0,0 +1,165 @@
+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/skill-domainpurchase/src/server/index.ts

@@ -0,0 +1,332 @@
+/**
+ * HTTP Server for service-domainpurchase
+ * Exposes domain purchase functionality as REST API
+ */
+
+import { purchaseApi, formatPrice, type Contact } from "../lib/api-client";
+import { loadConfig, saveConfig } from "../lib/config";
+
+const PORT = parseInt(process.env.PORT || "3000");
+const API_KEY = process.env.API_KEY || "";
+const PATH_PREFIX = "/domainpurchase";
+
+// API Key validation
+function validateApiKey(req: Request): boolean {
+  if (!API_KEY) { console.warn("WARNING: API_KEY not set - all requests rejected"); return false; }
+
+  const authHeader = req.headers.get("Authorization");
+  if (!authHeader?.startsWith("Bearer ")) return false;
+
+  return authHeader.slice(7) === API_KEY;
+}
+
+// CORS headers
+function corsHeaders(): HeadersInit {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, PUT, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  };
+}
+
+async function handleRequest(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const { searchParams } = url;
+  const method = req.method;
+
+  // Strip path prefix if present (for ALB routing)
+  let pathname = url.pathname;
+  if (pathname.startsWith(PATH_PREFIX)) {
+    pathname = pathname.slice(PATH_PREFIX.length) || "/";
+  }
+
+  // Handle CORS preflight
+  if (method === "OPTIONS") {
+    return new Response(null, { headers: corsHeaders() });
+  }
+
+  try {
+    // Health check (no auth required)
+    if (pathname === "/health" && method === "GET") {
+      return Response.json(
+        {
+          status: "ok",
+          service: "service-domainpurchase",
+          timestamp: new Date().toISOString(),
+        },
+        { headers: corsHeaders() }
+      );
+    }
+
+    // All routes below require authentication
+    if (!validateApiKey(req)) {
+      return Response.json(
+        { error: "Unauthorized" },
+        { status: 401, headers: corsHeaders() }
+      );
+    }
+
+    // Check domain availability
+    // GET /check?domain=example.com&transfer=false
+    if (pathname === "/check" && method === "GET") {
+      const domain = searchParams.get("domain");
+      if (!domain) {
+        return Response.json(
+          { error: "domain parameter is required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      const transfer = searchParams.get("transfer") === "true";
+      const result = await purchaseApi.checkAvailability(domain, transfer);
+      return Response.json(
+        {
+          ...result,
+          priceFormatted: result.price ? formatPrice(result.price, result.currency) : null,
+        },
+        { headers: corsHeaders() }
+      );
+    }
+
+    // Get legal agreements for TLDs
+    // GET /agreements?tlds=com,net&privacy=true
+    if (pathname === "/agreements" && method === "GET") {
+      const tldsParam = searchParams.get("tlds");
+      if (!tldsParam) {
+        return Response.json(
+          { error: "tlds parameter is required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      const tlds = tldsParam.split(",").map((t) => t.trim());
+      const privacy = searchParams.get("privacy") === "true";
+      const agreements = await purchaseApi.getAgreements(tlds, privacy);
+      return Response.json({ agreements }, { headers: corsHeaders() });
+    }
+
+    // Validate purchase request (dry run)
+    // POST /validate { domain, contact, period, privacy, autoRenew }
+    if (pathname === "/validate" && method === "POST") {
+      const body = await req.json();
+      if (!body.domain) {
+        return Response.json(
+          { error: "domain is required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      // Get TLD from domain
+      const tld = body.domain.split(".").slice(1).join(".");
+      const agreements = await purchaseApi.getAgreements([tld], body.privacy);
+      const agreementKeys = agreements.map((a: any) => a.agreementKey);
+
+      // Get public IP for consent
+      const ipResponse = await fetch("https://api.ipify.org?format=json");
+      const ipData = (await ipResponse.json()) as { ip: string };
+
+      const request = {
+        domain: body.domain,
+        consent: {
+          agreedAt: new Date().toISOString(),
+          agreedBy: ipData.ip,
+          agreementKeys,
+        },
+        contactRegistrant: body.contact || getDefaultContact(),
+        period: body.period || 1,
+        privacy: body.privacy || false,
+        renewAuto: body.autoRenew || false,
+      };
+
+      const result = await purchaseApi.validatePurchase(request);
+      return Response.json(result, { headers: corsHeaders() });
+    }
+
+    // Purchase domain (CAUTION: This actually purchases!)
+    // POST /purchase { domain, contact, period, privacy, autoRenew, nameservers }
+    if (pathname === "/purchase" && method === "POST") {
+      const body = await req.json();
+      if (!body.domain || !body.contact) {
+        return Response.json(
+          { error: "domain and contact are required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      // Check availability first
+      const availability = await purchaseApi.checkAvailability(body.domain);
+      if (!availability.available) {
+        return Response.json(
+          { error: `${body.domain} is not available for registration` },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      // Get TLD from domain
+      const tld = body.domain.split(".").slice(1).join(".");
+      const agreements = await purchaseApi.getAgreements([tld], body.privacy);
+      const agreementKeys = agreements.map((a: any) => a.agreementKey);
+
+      // Get public IP for consent
+      const ipResponse = await fetch("https://api.ipify.org?format=json");
+      const ipData = (await ipResponse.json()) as { ip: string };
+
+      const request = {
+        domain: body.domain,
+        consent: {
+          agreedAt: new Date().toISOString(),
+          agreedBy: ipData.ip,
+          agreementKeys,
+        },
+        contactRegistrant: body.contact,
+        contactAdmin: body.contact,
+        contactBilling: body.contact,
+        contactTech: body.contact,
+        period: body.period || 1,
+        privacy: body.privacy || false,
+        renewAuto: body.autoRenew || false,
+        ...(body.nameservers && { nameServers: body.nameservers }),
+      };
+
+      const result = await purchaseApi.purchaseDomain(request);
+      return Response.json(result, { status: 201, headers: corsHeaders() });
+    }
+
+    // List owned domains
+    // GET /list?limit=100
+    if (pathname === "/list" && method === "GET") {
+      const limit = parseInt(searchParams.get("limit") || "100");
+      const domains = await purchaseApi.listOwnedDomains(limit);
+      return Response.json({ domains, count: domains.length }, { headers: corsHeaders() });
+    }
+
+    // Get domain details
+    // GET /info?domain=example.com
+    if (pathname === "/info" && method === "GET") {
+      const domain = searchParams.get("domain");
+      if (!domain) {
+        return Response.json(
+          { error: "domain parameter is required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      const details = await purchaseApi.getDomainDetails(domain);
+      return Response.json(details, { headers: corsHeaders() });
+    }
+
+    // Update domain settings
+    // PUT /update?domain=example.com { autoRenew, privacy, nameservers }
+    if (pathname === "/update" && method === "PUT") {
+      const domain = searchParams.get("domain");
+      if (!domain) {
+        return Response.json(
+          { error: "domain parameter is required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      const body = await req.json();
+      const updates: any = {};
+
+      if (body.autoRenew !== undefined) {
+        updates.renewAuto = body.autoRenew;
+      }
+      if (body.privacy !== undefined) {
+        updates.privacy = body.privacy;
+      }
+      if (body.nameservers) {
+        updates.nameServers = body.nameservers;
+      }
+
+      const result = await purchaseApi.updateDomain(domain, updates);
+      return Response.json(result, { headers: corsHeaders() });
+    }
+
+    // Renew domain
+    // POST /renew { domain, period }
+    if (pathname === "/renew" && method === "POST") {
+      const body = await req.json();
+      if (!body.domain) {
+        return Response.json(
+          { error: "domain is required" },
+          { status: 400, headers: corsHeaders() }
+        );
+      }
+
+      const result = await purchaseApi.renewDomain(body.domain, body.period || 1);
+      return Response.json(result, { headers: corsHeaders() });
+    }
+
+    // Get contact template
+    // GET /contact-template
+    if (pathname === "/contact-template" && method === "GET") {
+      return Response.json(
+        {
+          template: {
+            nameFirst: "John",
+            nameLast: "Doe",
+            email: "john.doe@example.com",
+            phone: "+1.5551234567",
+            organization: "Example Corp",
+            addressMailing: {
+              address1: "123 Main Street",
+              address2: "Suite 100",
+              city: "San Francisco",
+              state: "CA",
+              postalCode: "94102",
+              country: "US",
+            },
+            encoding: "UTF-8",
+          },
+        },
+        { headers: corsHeaders() }
+      );
+    }
+
+    return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders() });
+  } catch (error) {
+    console.error("Request error:", error);
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Internal server error" },
+      { status: 500, headers: corsHeaders() }
+    );
+  }
+}
+
+function getDefaultContact(): Contact {
+  return {
+    nameFirst: "Test",
+    nameLast: "User",
+    email: "test@example.com",
+    phone: "+1.5555555555",
+    addressMailing: {
+      address1: "123 Test St",
+      city: "Test City",
+      state: "CA",
+      postalCode: "90210",
+      country: "US",
+    },
+    encoding: "UTF-8",
+  };
+}
+
+const server = Bun.serve({
+  port: PORT,
+  fetch: handleRequest,
+});
+
+console.log(`Service-Domainpurchase server running at http://localhost:${PORT}`);
+
+// Graceful shutdown
+process.on("SIGINT", () => {
+  console.log("\nShutting down gracefully...");
+  server.stop();
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  console.log("\nShutting down gracefully...");
+  server.stop();
+  process.exit(0);
+});