@rnsk/toolkits 0.0.9 → 0.0.11

package/dist/toolkits/hacker-news/tools/items.js

@@ -0,0 +1,126 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hnFirebase } from './client.js';
+export const hackerNewsGetItem = tool({
+    description: 'Get a Hacker News item (story, comment, job, poll, or pollopt) by its numeric ID. Returns author, score, title, text, timestamps, and comment IDs.',
+    inputSchema: z.object({
+        id: z.number().int().positive().describe('Unique numeric ID of the item to retrieve'),
+    }),
+    execute: async ({ id }) => {
+        const item = await hnFirebase(`/item/${id}.json`);
+        if (item && typeof item === 'object' && 'error' in item)
+            return item;
+        if (item === null)
+            return { error: `Hacker News item ${id} not found` };
+        return item;
+    },
+});
+function truncate(text, enabled) {
+    if (!enabled || typeof text !== 'string' || text.length <= 500)
+        return text;
+    return text.slice(0, 500);
+}
+async function resolveChildren(kids, depth, maxDepth, maxChildren, truncateText) {
+    if (depth > maxDepth || !kids || kids.length === 0 || maxChildren === 0) {
+        return { children: [], truncated: (kids?.length ?? 0) > 0 && depth <= maxDepth && maxChildren === 0, depthReached: depth > maxDepth };
+    }
+    const shown = kids.slice(0, maxChildren);
+    const children = [];
+    for (const kidId of shown) {
+        const raw = await hnFirebase(`/item/${kidId}.json`);
+        if (!raw || typeof raw !== 'object' || 'error' in raw || raw === null)
+            continue;
+        const item = raw;
+        const nested = await resolveChildren(item.kids, depth + 1, maxDepth, maxChildren, truncateText);
+        children.push({
+            id: item.id,
+            type: item.type,
+            author: item.by ?? null,
+            text: truncate(item.text ?? null, truncateText),
+            createdAt: typeof item.time === 'number' ? new Date(item.time * 1000).toISOString() : null,
+            createdAtI: item.time ?? null,
+            parentId: item.parent ?? null,
+            children: nested.children,
+            childrenTruncated: nested.truncated,
+            maxDepthReached: nested.depthReached,
+        });
+    }
+    return { children, truncated: kids.length > shown.length, depthReached: false };
+}
+export const hackerNewsGetItemWithId = tool({
+    description: 'Get a Hacker News item with nested comment replies. Limits depth, child count, and text length to prevent context overflow. Use for reading stories with their discussion.',
+    inputSchema: z.object({
+        itemId: z.string().describe('Numeric ID of the item (story, comment, job, poll, or pollopt)'),
+        maxDepth: z.number().int().min(0).max(10).optional().describe('Nested reply depth to include (0 = no children). Defaults to 2.'),
+        maxChildren: z.number().int().min(0).max(100).optional().describe('Direct child comments per item. Defaults to 10.'),
+        truncateText: z.boolean().optional().describe('Truncate long text to 500 characters. Defaults to true.'),
+    }),
+    execute: async ({ itemId, maxDepth = 2, maxChildren = 10, truncateText = true, }) => {
+        const id = Number(itemId);
+        if (!Number.isInteger(id) || id <= 0) {
+            return { found: false, item: null, errorMessage: `Invalid item ID: ${itemId}` };
+        }
+        const raw = await hnFirebase(`/item/${id}.json`);
+        if (raw && typeof raw === 'object' && 'error' in raw) {
+            return { found: false, item: null, errorMessage: raw.error };
+        }
+        if (raw === null) {
+            return { found: false, item: null, errorMessage: `Item ${id} not found` };
+        }
+        const item = raw;
+        const nested = await resolveChildren(item.kids, 1, maxDepth, maxChildren, truncateText);
+        return {
+            found: true,
+            item: {
+                id: item.id,
+                type: item.type,
+                author: item.by ?? null,
+                title: truncate(item.title ?? null, truncateText),
+                url: item.url ?? null,
+                text: truncate(item.text ?? null, truncateText),
+                points: item.score ?? null,
+                parentId: item.parent ?? null,
+                storyId: null,
+                createdAt: typeof item.time === 'number' ? new Date(item.time * 1000).toISOString() : null,
+                createdAtI: item.time ?? null,
+                options: item.parts ?? null,
+                children: nested.children,
+                childrenShown: nested.children.length,
+                totalChildrenCount: Array.isArray(item.kids) ? item.kids.length : 0,
+                childrenTruncated: nested.truncated,
+                maxDepthReached: nested.depthReached,
+            },
+        };
+    },
+});
+export const hackerNewsGetUser = tool({
+    description: 'Get a Hacker News user public profile by username. Returns username, karma, and bio. Use to look up HN community members.',
+    inputSchema: z.object({
+        username: z.string().describe('Case-sensitive HN username, e.g. "pg"'),
+    }),
+    execute: async ({ username }) => {
+        const user = await hnFirebase(`/user/${username}.json`);
+        if (user && typeof user === 'object' && 'error' in user)
+            return user;
+        if (user === null)
+            return { error: `Hacker News user "${username}" not found` };
+        const u = user;
+        return { username: u.id, karma: u.karma, about: u.about ?? null };
+    },
+});
+export const hackerNewsGetUserByUsername = tool({
+    description: 'Get detailed Hacker News user info by username, including creation date, karma, bio, and submission history.',
+    inputSchema: z.object({
+        username: z.string().describe('Case-sensitive HN username, e.g. "pg"'),
+    }),
+    execute: async ({ username }) => {
+        const user = await hnFirebase(`/user/${username}.json`);
+        if (user && typeof user === 'object' && 'error' in user)
+            return user;
+        if (user === null)
+            return { error: `Hacker News user "${username}" not found` };
+        return user;
+    },
+});
+//# sourceMappingURL=items.js.map

package/dist/toolkits/hacker-news/tools/search.d.ts

@@ -0,0 +1,12 @@
+export declare const hackerNewsGetLatestPosts: import("ai").Tool<{
+    size?: number | undefined;
+    page?: number | undefined;
+    tags?: string[] | undefined;
+}, any>;
+export declare const hackerNewsSearchPosts: import("ai").Tool<{
+    query: string;
+    size?: number | undefined;
+    page?: number | undefined;
+    tags?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=search.d.ts.map

package/dist/toolkits/hacker-news/tools/search.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hnSearch } from './client.js';
+const tagsField = z
+    .array(z.string())
+    .optional()
+    .describe('Filter tags (ANDed). Available: story, comment, poll, pollopt, show_hn, ask_hn, front_page, author_<USERNAME>, story_<ID>.');
+export const hackerNewsGetLatestPosts = tool({
+    description: 'Get latest Hacker News posts with optional tag filters. Use to browse recent stories or comments, optionally filtered by type or author.',
+    inputSchema: z.object({
+        page: z.number().int().min(0).optional().describe('Page number, 0-indexed. Defaults to 0.'),
+        size: z.number().int().min(0).optional().describe('Max results to return. Defaults to 5. Set to 0 for the full page (up to 20).'),
+        tags: tagsField,
+    }),
+    execute: async ({ page = 0, size = 5, tags }) => {
+        const result = await hnSearch({ page, hitsPerPage: size && size > 0 ? size : 20, tags });
+        if (result && typeof result === 'object' && 'error' in result)
+            return result;
+        const hits = Array.isArray(result.hits) ? result.hits : [];
+        return { ...result, hits: size && size > 0 ? hits.slice(0, size) : hits };
+    },
+});
+export const hackerNewsSearchPosts = tool({
+    description: 'Full-text search of Hacker News stories and comments via Algolia. Supports AND/OR/NOT operators plus tag and author filters.',
+    inputSchema: z.object({
+        query: z.string().describe('Full-text search query'),
+        page: z.number().int().min(0).optional().describe('Page number, 0-indexed. Defaults to 0.'),
+        size: z.number().int().min(0).optional().describe('Max results to return. Defaults to 5. Set to 0 for the full page (up to 20).'),
+        tags: tagsField,
+    }),
+    execute: async ({ query, page = 0, size = 5, tags, }) => {
+        const result = await hnSearch({ query, page, hitsPerPage: size && size > 0 ? size : 20, tags });
+        if (result && typeof result === 'object' && 'error' in result)
+            return result;
+        const hits = Array.isArray(result.hits) ? result.hits : [];
+        return { ...result, hits: size && size > 0 ? hits.slice(0, size) : hits };
+    },
+});
+//# sourceMappingURL=search.js.map

package/dist/toolkits/hacker-news/tools/stories.d.ts

@@ -0,0 +1,25 @@
+export declare const hackerNewsGetAskStories: import("ai").Tool<{
+    print?: string | undefined;
+}, any>;
+export declare const hackerNewsGetBestStories: import("ai").Tool<{
+    print?: string | undefined;
+}, any>;
+export declare const hackerNewsGetJobStories: import("ai").Tool<{
+    printFormat?: string | undefined;
+}, any>;
+export declare const hackerNewsGetNewStories: import("ai").Tool<{
+    printFormat?: string | undefined;
+}, any>;
+export declare const hackerNewsGetShowStories: import("ai").Tool<{
+    printFormat?: string | undefined;
+}, any>;
+export declare const hackerNewsGetTopStories: import("ai").Tool<{
+    print?: string | undefined;
+}, any>;
+export declare const hackerNewsGetMaxItemId: import("ai").Tool<{
+    print?: string | undefined;
+}, any>;
+export declare const hackerNewsGetUpdates: import("ai").Tool<{
+    print?: string | undefined;
+}, any>;
+//# sourceMappingURL=stories.d.ts.map

package/dist/toolkits/hacker-news/tools/stories.js

@@ -0,0 +1,98 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hnFirebase } from './client.js';
+const prettyField = z
+    .string()
+    .optional()
+    .describe("Set to 'pretty' for formatted JSON output. Leave unset for compact JSON.");
+function feedTool(name, description, endpoint, resultKey) {
+    return tool({
+        description,
+        inputSchema: z.object({
+            print: prettyField,
+        }),
+        execute: async ({ print }) => {
+            const ids = await hnFirebase(`/${endpoint}.json`, print ? { print } : {});
+            if (ids && typeof ids === 'object' && 'error' in ids)
+                return ids;
+            return { [resultKey]: ids, count: Array.isArray(ids) ? ids.length : 0 };
+        },
+    });
+}
+export const hackerNewsGetAskStories = feedTool('ask', 'Get up to 200 latest Ask HN story IDs in ranked order. Use the IDs with HackerNewsGetItem to fetch full story details.', 'askstories', 'storyIds');
+export const hackerNewsGetBestStories = feedTool('best', 'Get up to 500 best Hacker News story IDs ranked by score. Use the IDs with HackerNewsGetItem to fetch full story details.', 'beststories', 'storyIds');
+export const hackerNewsGetJobStories = tool({
+    description: 'Get up to 200 latest Hacker News job story IDs. Use the IDs with HackerNewsGetItem to fetch full job details.',
+    inputSchema: z.object({
+        printFormat: z
+            .string()
+            .optional()
+            .describe("Set to 'pretty' for formatted JSON output. Leave unset for compact JSON."),
+    }),
+    execute: async ({ printFormat }) => {
+        const ids = await hnFirebase('/jobstories.json', printFormat ? { print: printFormat } : {});
+        if (ids && typeof ids === 'object' && 'error' in ids)
+            return ids;
+        return { jobStoryIds: ids, count: Array.isArray(ids) ? ids.length : 0 };
+    },
+});
+export const hackerNewsGetNewStories = tool({
+    description: 'Get up to 500 newest Hacker News story IDs, most recent first. Use the IDs with HackerNewsGetItem to fetch full story details.',
+    inputSchema: z.object({
+        printFormat: z
+            .string()
+            .optional()
+            .describe("Set to 'pretty' for formatted JSON output. Leave unset for compact JSON."),
+    }),
+    execute: async ({ printFormat }) => {
+        const ids = await hnFirebase('/newstories.json', printFormat ? { print: printFormat } : {});
+        if (ids && typeof ids === 'object' && 'error' in ids)
+            return ids;
+        return { storyIds: ids, count: Array.isArray(ids) ? ids.length : 0 };
+    },
+});
+export const hackerNewsGetShowStories = tool({
+    description: 'Get up to 200 latest Show HN story IDs where people share projects and products. Use the IDs with HackerNewsGetItem to fetch full details.',
+    inputSchema: z.object({
+        printFormat: z
+            .string()
+            .optional()
+            .describe("Set to 'pretty' for formatted JSON output. Leave unset for compact JSON."),
+    }),
+    execute: async ({ printFormat }) => {
+        const ids = await hnFirebase('/showstories.json', printFormat ? { print: printFormat } : {});
+        if (ids && typeof ids === 'object' && 'error' in ids)
+            return ids;
+        return { storyIds: ids, count: Array.isArray(ids) ? ids.length : 0 };
+    },
+});
+export const hackerNewsGetTopStories = feedTool('top', 'Get up to 500 top Hacker News story IDs in front-page order. Use the IDs with HackerNewsGetItem to fetch full story details.', 'topstories', 'storyIds');
+export const hackerNewsGetMaxItemId = tool({
+    description: 'Get the current largest Hacker News item ID. Use to discover the most recent items or walk backward through all items.',
+    inputSchema: z.object({
+        print: z
+            .string()
+            .optional()
+            .describe("Set to 'pretty' for formatted JSON output. Leave unset for compact JSON."),
+    }),
+    execute: async ({ print }) => {
+        const maxId = await hnFirebase('/maxitem.json', print ? { print } : {});
+        if (maxId && typeof maxId === 'object' && 'error' in maxId)
+            return maxId;
+        return { maxItemId: maxId };
+    },
+});
+export const hackerNewsGetUpdates = tool({
+    description: 'Get recently changed Hacker News item IDs and user profiles. Use to monitor recent activity on the platform.',
+    inputSchema: z.object({
+        print: z
+            .string()
+            .optional()
+            .describe("Set to 'pretty' for formatted JSON output. Leave unset for compact JSON."),
+    }),
+    execute: async ({ print }) => {
+        return hnFirebase('/updates.json', print ? { print } : {});
+    },
+});
+//# sourceMappingURL=stories.js.map

package/dist/toolkits/hostinger/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const HOSTINGER_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/hostinger/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" clip-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2"><path d="M347.979 6v149.166l120.52 70.5V67.437L347.98 6zM43.499 6v234.104h391.98L316.207 174.54l-155.354-.062V68.999L43.5 6zm304.48 435.291V336.729l-156.542-.105c.146.688-121.25-66.604-121.25-66.604l398.312 1.896V506l-120.52-64.708zM43.499 288.312v152.979l117.355 61.437V357.145L43.5 288.312z" fill="#673de6" fill-rule="nonzero"/></svg>`;
+export const HOSTINGER_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/hostinger/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/hostinger/manifest.js

@@ -0,0 +1,36 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { HOSTINGER_ICON } from './icon.js';
+import { hostingerTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'hostinger',
+    displayName: 'Hostinger',
+    shortDescription: 'Domains, DNS, WHOIS, VPS, hosting, websites, and billing.',
+    category: 'Developer Tools & DevOps',
+    icon: HOSTINGER_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'hostingerApiKey',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            prefix: 'Bearer',
+            connectDescription: 'Connect Hostinger with an API token. Generate one from your Hostinger dashboard under the API section. All requests send it as Authorization: Bearer <token>.',
+        },
+    },
+    allowedHosts: ['developers.hostinger.com'],
+    tools: hostingerTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://www.hostinger.com',
+        docsUrl: 'https://developers.hostinger.com/',
+        apiDocsUrl: 'https://docs.hostinger.com/api-reference/overview',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/hostinger/tools/billing.d.ts

@@ -0,0 +1,12 @@
+export declare const hostingerListCatalogItems: import("ai").Tool<{
+    name?: string | undefined;
+    hostingerApiKey?: string | undefined;
+    category?: "DOMAIN" | "VPS" | undefined;
+}, any>;
+export declare const hostingerListPaymentMethods: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListSubscriptions: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=billing.d.ts.map

package/dist/toolkits/hostinger/tools/billing.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerListCatalogItems = tool({
+    description: 'List catalog items available for order (domains, VPS plans) with pricing in cents. Use to check services and prices before ordering.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        name: z.string().optional().describe('Filter by name, use * as wildcard, e.g. ".COM*"'),
+        category: z.enum(['DOMAIN', 'VPS']).optional().describe('Filter by category'),
+    }),
+    execute: async ({ hostingerApiKey, name, category }) => {
+        return hostingerRequest(hostingerApiKey, '/api/billing/v1/catalog', { query: { name, category } });
+    },
+});
+export const hostingerListPaymentMethods = tool({
+    description: 'List payment methods available for placing orders. Use to view payment options before creating an order.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/billing/v1/payment-methods');
+    },
+});
+export const hostingerListSubscriptions = tool({
+    description: 'List all subscriptions on the account. Use to monitor active services and billing status.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/billing/v1/subscriptions');
+    },
+});
+//# sourceMappingURL=billing.js.map

package/dist/toolkits/hostinger/tools/client.d.ts

@@ -0,0 +1,6 @@
+export declare function hostingerRequest(hostingerApiKey: string | undefined, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<any>;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/hostinger/tools/client.js

@@ -0,0 +1,57 @@
+// @ts-nocheck
+const HOSTINGER_API_BASE = 'https://developers.hostinger.com';
+export async function hostingerRequest(hostingerApiKey, path, options = {}) {
+    if (!hostingerApiKey) {
+        return { error: 'Hostinger API key is required. Connect Hostinger first.' };
+    }
+    const params = new URLSearchParams();
+    if (options.query) {
+        for (const [key, value] of Object.entries(options.query)) {
+            if (value !== undefined && value !== null && value !== '') {
+                if (Array.isArray(value)) {
+                    for (const item of value)
+                        params.append(key, String(item));
+                }
+                else {
+                    params.append(key, String(value));
+                }
+            }
+        }
+    }
+    const queryString = params.toString();
+    const url = `${HOSTINGER_API_BASE}${path}${queryString ? `?${queryString}` : ''}`;
+    try {
+        const response = await fetch(url, {
+            method: options.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${hostingerApiKey}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const details = await response.json().catch(() => ({}));
+            return { error: `Hostinger API request failed with status ${response.status}`, details };
+        }
+        if (response.status === 204) {
+            return { success: true };
+        }
+        const text = await response.text();
+        if (!text)
+            return { success: true };
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return { raw: text };
+        }
+    }
+    catch (error) {
+        return {
+            error: 'Error calling Hostinger API',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/hostinger/tools/dns.d.ts

@@ -0,0 +1,22 @@
+export declare const hostingerGetDnsRecords: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerValidateDnsRecords: import("ai").Tool<{
+    domain: string;
+    zone: {
+        type: string;
+        name: string;
+        records: {
+            content: string;
+        }[];
+        ttl?: number | undefined;
+    }[];
+    overwrite?: boolean | undefined;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListDnsSnapshots: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=dns.d.ts.map

package/dist/toolkits/hostinger/tools/dns.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerGetDnsRecords = tool({
+    description: 'Get DNS zone records for a domain. Use to review current DNS configuration, check propagation after updates, or audit DNS settings.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "mydomain.tld"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, `/api/dns/v1/zones/${encodeURIComponent(domain)}`);
+    },
+});
+const zoneEntry = z.object({
+    name: z.string().describe('Subdomain or hostname, e.g. "www"'),
+    type: z.string().describe('Record type, e.g. "A", "AAAA", "CNAME", "MX", "TXT", "NS"'),
+    ttl: z.number().int().min(0).optional().describe('Time to live in seconds'),
+    records: z.array(z.object({ content: z.string().describe('Record content, e.g. IP address or hostname') })).min(1).describe('DNS records for this entry'),
+});
+export const hostingerValidateDnsRecords = tool({
+    description: 'Validate DNS zone records for a domain before applying an update. Use to verify record validity; success returns 200, invalid records fail with 422.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "example.com"'),
+        zone: z.array(zoneEntry).min(1).describe('DNS zone entries to validate'),
+        overwrite: z.boolean().optional().describe('When true, matching records are replaced; otherwise TTLs are updated and records appended'),
+    }),
+    execute: async ({ hostingerApiKey, domain, zone, overwrite }) => {
+        return hostingerRequest(hostingerApiKey, `/api/dns/v1/zones/${encodeURIComponent(domain)}/validate`, {
+            method: 'POST',
+            body: { zone, overwrite },
+        });
+    },
+});
+export const hostingerListDnsSnapshots = tool({
+    description: 'List DNS snapshots (backup points) for a domain. Use to find restore points for DNS recovery or audit history.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "mydomain.tld"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, `/api/dns/v1/snapshots/${encodeURIComponent(domain)}`);
+    },
+});
+//# sourceMappingURL=dns.js.map

package/dist/toolkits/hostinger/tools/domains.d.ts

@@ -0,0 +1,21 @@
+export declare const hostingerCheckDomainAvailability: import("ai").Tool<{
+    domain: string;
+    tlds: string[];
+    hostingerApiKey?: string | undefined;
+    withAlternatives?: boolean | undefined;
+}, any>;
+export declare const hostingerListDomains: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerGetDomainForwarding: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerGenerateFreeSubdomain: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerVerifyDomainOwnership: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=domains.d.ts.map

package/dist/toolkits/hostinger/tools/domains.js

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerCheckDomainAvailability = tool({
+    description: 'Check if domain names are available for registration across multiple TLDs. Use before purchasing a domain. Provide TLDs without a leading dot. Rate limited to 10 requests per minute.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name without TLD, e.g. "mydomain"'),
+        tlds: z.array(z.string()).min(1).describe('TLDs to check without leading dot, e.g. ["com", "net"]'),
+        withAlternatives: z.boolean().optional().describe('Include alternative domain suggestions (provide only one TLD when true)'),
+    }),
+    execute: async ({ hostingerApiKey, domain, tlds, withAlternatives }) => {
+        return hostingerRequest(hostingerApiKey, '/api/domains/v1/availability', {
+            method: 'POST',
+            body: { domain, tlds, with_alternatives: withAlternatives },
+        });
+    },
+});
+export const hostingerListDomains = tool({
+    description: 'List all domains in the Hostinger account portfolio. Use when the user asks to see their domains or domain portfolio.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/domains/v1/portfolio');
+    },
+});
+export const hostingerGetDomainForwarding = tool({
+    description: 'Get the forwarding (redirect) configuration for a domain, including target URL and redirect type (301/302).',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "mydomain.tld"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, `/api/domains/v1/forwarding/${encodeURIComponent(domain)}`);
+    },
+});
+export const hostingerGenerateFreeSubdomain = tool({
+    description: 'Generate a free *.hostingersite.com subdomain for hosting without buying a custom domain. Use when the user wants a quick free subdomain.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/hosting/v1/domains/free-subdomains', { method: 'POST' });
+    },
+});
+export const hostingerVerifyDomainOwnership = tool({
+    description: 'Verify ownership of a domain and check if it is accessible for new websites. If not accessible, the response includes a TXT record to add to DNS. Skip for *.hostingersite.com subdomains.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name to verify, e.g. "example.com"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, '/api/hosting/v1/domains/verify-ownership', {
+            method: 'POST',
+            body: { domain },
+        });
+    },
+});
+//# sourceMappingURL=domains.js.map

package/dist/toolkits/hostinger/tools/hosting.d.ts

@@ -0,0 +1,17 @@
+export declare const hostingerListOrders: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    statuses?: string[] | undefined;
+    hostingerApiKey?: string | undefined;
+    orderIds?: number[] | undefined;
+}, any>;
+export declare const hostingerListWebsites: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    username?: string | undefined;
+    domain?: string | undefined;
+    hostingerApiKey?: string | undefined;
+    orderId?: number | undefined;
+    isEnabled?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=hosting.d.ts.map