@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/notebook-lm/tools/share-notebook.d.ts

@@ -0,0 +1,48 @@
+export declare const shareNotebook: import("ai").Tool<{
+    notebookLmToken: string;
+    notebookId: string;
+    shares: {
+        email: string;
+        role: "owner" | "writer" | "reader" | "not_shared";
+    }[];
+    location?: string | undefined;
+    endpointLocation?: string | undefined;
+    projectNumber?: string | undefined;
+    notifyViaEmail?: boolean | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    notebookId?: undefined;
+    affectedAccounts?: undefined;
+    notifyViaEmail?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: unknown;
+    notebookId?: undefined;
+    affectedAccounts?: undefined;
+    notifyViaEmail?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    notebookId: string;
+    affectedAccounts: {
+        email: string;
+        role: "owner" | "writer" | "reader" | "not_shared";
+    }[];
+    notifyViaEmail: boolean;
+    raw: unknown;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    notebookId?: undefined;
+    affectedAccounts?: undefined;
+    notifyViaEmail?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=share-notebook.d.ts.map

package/dist/toolkits/notebook-lm/tools/share-notebook.js

@@ -0,0 +1,57 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildNotebookName, getEndpoint, parseResponseError } from './utils.js';
+export const shareNotebook = tool({
+    description: 'Grant, change, or remove account access to a NotebookLM Enterprise notebook. Notification emails are disabled by default; notifyViaEmail=true sends email and cannot be undone.',
+    inputSchema: z.object({
+        notebookLmToken: z.string().describe('NotebookLM OAuth access token.'),
+        notebookId: z.string().min(1).describe('Notebook UUID or full resource name.'),
+        shares: z.array(z.object({
+            email: z.string().email().describe('Google account email address whose access will be changed.'),
+            role: z.enum(['owner', 'writer', 'reader', 'not_shared']).describe('Access to set: owner, writer, reader, or not_shared to remove access.'),
+        })).min(1).describe('Accounts and exact access roles to apply.'),
+        notifyViaEmail: z.boolean().optional().describe('Whether Google sends notification emails. Defaults to false. WARNING: true cannot be undone.'),
+        location: z.string().optional().describe('Location override, defaults to global.'),
+        endpointLocation: z.string().optional().describe('Endpoint multi-region, defaults to global.'),
+        projectNumber: z.string().optional().describe('Project number, defaults to -.'),
+    }),
+    execute: async ({ notebookLmToken, notebookId, shares, notifyViaEmail, location, endpointLocation, projectNumber }) => {
+        if (!notebookLmToken)
+            return { error: 'NotebookLM token is required. Connect NotebookLM first.' };
+        try {
+            const endpoint = getEndpoint(endpointLocation || location);
+            const name = buildNotebookName(notebookId, projectNumber, location);
+            const url = `${endpoint}/${name}:share`;
+            const roleMap = {
+                owner: 'PROJECT_ROLE_OWNER',
+                writer: 'PROJECT_ROLE_WRITER',
+                reader: 'PROJECT_ROLE_READER',
+                not_shared: 'PROJECT_ROLE_NOT_SHARED',
+            };
+            const accountAndRoles = shares.map((s) => ({ email: s.email, role: roleMap[s.role] || s.role }));
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${notebookLmToken}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ accountAndRoles }),
+            });
+            if (!response.ok) {
+                const err = await parseResponseError(response);
+                return { error: 'Failed to share notebook', details: err.details };
+            }
+            const text = await response.text();
+            let data = {};
+            try {
+                data = text ? JSON.parse(text) : {};
+            }
+            catch {
+                data = text;
+            }
+            return { notebookId, affectedAccounts: shares, notifyViaEmail: notifyViaEmail ?? false, raw: data };
+        }
+        catch (error) {
+            return { error: 'Error sharing notebook', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=share-notebook.js.map

package/dist/toolkits/notebook-lm/tools/upload-source-file.d.ts

@@ -0,0 +1,40 @@
+export declare const uploadSourceFile: import("ai").Tool<{
+    fileName: string;
+    notebookLmToken: string;
+    notebookId: string;
+    mimeType?: string | undefined;
+    location?: string | undefined;
+    file?: {
+        name: string;
+        mimetype: string;
+        s3key: string;
+    } | undefined;
+    fileContent?: string | undefined;
+    endpointLocation?: string | undefined;
+    projectNumber?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    sourceId?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: unknown;
+    sourceId?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    sourceId: any;
+    raw: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    sourceId?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=upload-source-file.d.ts.map

package/dist/toolkits/notebook-lm/tools/upload-source-file.js

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildNotebookName, getEndpoint, parseResponseError } from './utils.js';
+export const uploadSourceFile = tool({
+    description: 'Upload a plain-text file as a source in a NotebookLM Enterprise notebook via the raw upload endpoint. Supports S3-key style file store object or direct content.',
+    inputSchema: z.object({
+        notebookLmToken: z.string().describe('NotebookLM OAuth access token.'),
+        notebookId: z.string().min(1).describe('Notebook UUID or full resource name to receive the uploaded source.'),
+        fileName: z.string().min(1).describe('Filename NotebookLM should use for the source, including extension.'),
+        file: z.object({
+            name: z.string().describe('Original filename supplied by file store.'),
+            mimetype: z.string().describe('MIME type detected for the uploaded file.'),
+            s3key: z.string().describe('Opaque file-store reference used to read the file bytes.'),
+        }).optional().describe('Optional file-store object with s3key. When provided, content is resolved from store; otherwise use fileContent.'),
+        fileContent: z.string().optional().describe('Raw file content as text. Used when file.s3key is not provided. Provide as plain text or base64 if binary.'),
+        mimeType: z.string().optional().describe('MIME type sent with the raw upload. Defaults to text/plain. Only text/plain is currently verified.'),
+        location: z.string().optional().describe('Location override, defaults to global.'),
+        endpointLocation: z.string().optional().describe('Endpoint multi-region, defaults to global.'),
+        projectNumber: z.string().optional().describe('Project number, defaults to -.'),
+    }),
+    execute: async ({ notebookLmToken, notebookId, fileName, file, fileContent, mimeType, location, endpointLocation, projectNumber }) => {
+        if (!notebookLmToken)
+            return { error: 'NotebookLM token is required. Connect NotebookLM first.' };
+        try {
+            const notebookName = buildNotebookName(notebookId, projectNumber, location);
+            const displayName = fileName || file?.name || 'upload.txt';
+            const contentType = mimeType || file?.mimetype || 'text/plain';
+            // If file store reference is given but no direct content, we cannot resolve S3 without a fetcher — return hint.
+            let body;
+            if (file?.s3key && !fileContent) {
+                return {
+                    error: 'File store s3key provided but direct fileContent is missing. Provide fileContent for upload.',
+                    details: { file, fileName: displayName },
+                };
+            }
+            body = fileContent ?? '';
+            const base = getEndpoint(endpointLocation || location).replace('/v1alpha', '');
+            const finalUrl = `${base}/upload/v1alpha/${notebookName}/sources:uploadFile`;
+            const response = await fetch(finalUrl, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${notebookLmToken}`,
+                    'Content-Type': contentType,
+                    'X-Goog-Upload-Protocol': 'raw',
+                    'X-Goog-Upload-File-Name': displayName,
+                },
+                body: body,
+            });
+            if (!response.ok) {
+                const err = await parseResponseError(response);
+                return { error: 'Failed to upload source file', details: err.details };
+            }
+            const data = await response.json();
+            return { sourceId: data.sourceId?.id || data.sourceId, raw: data };
+        }
+        catch (error) {
+            return { error: 'Error uploading source file', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=upload-source-file.js.map

package/dist/toolkits/notebook-lm/tools/utils.d.ts

@@ -0,0 +1,15 @@
+export declare const NOTEBOOK_LM_API_VERSION = "v1alpha";
+export declare const DEFAULT_LOCATION = "global";
+export declare const DEFAULT_ENDPOINT_LOCATION = "global";
+export declare function getEndpoint(endpointLocation?: string): string;
+export declare function buildNotebookName(notebookId: string, projectNumber?: string, location?: string): string;
+export declare function buildParent(projectNumber?: string, location?: string): string;
+export declare function buildSourceName(notebookId: string, sourceId: string, projectNumber?: string, location?: string): string;
+export declare function parseResponseError(response: Response): Promise<{
+    error: string;
+    details: unknown;
+}>;
+export declare function requireToken(token: unknown, field: string): {
+    error: string;
+} | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/notebook-lm/tools/utils.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+export const NOTEBOOK_LM_API_VERSION = 'v1alpha';
+export const DEFAULT_LOCATION = 'global';
+export const DEFAULT_ENDPOINT_LOCATION = 'global';
+export function getEndpoint(endpointLocation) {
+    const loc = (endpointLocation || DEFAULT_ENDPOINT_LOCATION).toLowerCase();
+    if (loc === 'global')
+        return `https://discoveryengine.googleapis.com/${NOTEBOOK_LM_API_VERSION}`;
+    return `https://${loc}-discoveryengine.googleapis.com/${NOTEBOOK_LM_API_VERSION}`;
+}
+export function buildNotebookName(notebookId, projectNumber, location) {
+    if (notebookId.includes('/'))
+        return notebookId;
+    const proj = projectNumber || '-';
+    const loc = location || DEFAULT_LOCATION;
+    return `projects/${proj}/locations/${loc}/notebooks/${notebookId}`;
+}
+export function buildParent(projectNumber, location) {
+    const proj = projectNumber || '-';
+    const loc = location || DEFAULT_LOCATION;
+    return `projects/${proj}/locations/${loc}`;
+}
+export function buildSourceName(notebookId, sourceId, projectNumber, location) {
+    if (sourceId.includes('/'))
+        return sourceId;
+    const notebookName = buildNotebookName(notebookId, projectNumber, location);
+    return `${notebookName}/sources/${sourceId}`;
+}
+export async function parseResponseError(response) {
+    const text = await response.text().catch(() => '');
+    let details = text;
+    try {
+        details = text ? JSON.parse(text) : {};
+    }
+    catch {
+        details = text;
+    }
+    return { error: `Request failed with ${response.status} ${response.statusText}`, details };
+}
+export function requireToken(token, field) {
+    if (!token || typeof token !== 'string' || token.trim() === '') {
+        return { error: `${field} is required. Connect NotebookLM first.` };
+    }
+    return null;
+}
+//# sourceMappingURL=utils.js.map

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

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

package/dist/toolkits/npm/icon.js

@@ -0,0 +1,11 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+  <g fill="none" fill-rule="evenodd">
+    <rect width="24" height="24" fill="#D40001"/>
+    <path fill="#FFF" d="M16.7179487,7.92840493 L12.2051282,7.92840493 L12.2051282,20.2494172 L4,20.2494172 L4,3 L12.2051282,3 L20,3 L20,7.92840493 L20,20.2494172 L16.7179487,20.2494172 L16.7179487,7.92840493 Z"/>
+  </g>
+</svg>`;
+export const NPM_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/npm/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/npm/manifest.js

@@ -0,0 +1,35 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { NPM_ICON } from './icon.js';
+import { npmTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'npm',
+    displayName: 'npm',
+    shortDescription: 'Search packages, check downloads and advisories, and manage registry tokens.',
+    category: 'Developer Tools & DevOps',
+    icon: NPM_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'npmApiKey',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            prefix: 'Bearer',
+            connectDescription: 'Connect npm with an access token (classic or granular). Create one at npmjs.com > Access Tokens. Sent as Authorization: Bearer <token> to registry.npmjs.org. Download stats, search, metadata, advisories, and ping are public and work without a key; whoami and token deletion require it.',
+        },
+    },
+    allowedHosts: ['registry.npmjs.org', 'api.npmjs.org', 'replicate.npmjs.com'],
+    tools: npmTools.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.10',
+        homepage: 'https://www.npmjs.com',
+        docsUrl: 'https://api-docs.npmjs.com',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const REGISTRY_BASE = "https://registry.npmjs.org";
+export declare const DOWNLOADS_BASE = "https://api.npmjs.org";
+export declare const REPLICATE_BASE = "https://replicate.npmjs.com";
+export declare const npmApiKeyField: z.ZodOptional<z.ZodString>;
+export declare function missingKey(): {
+    error: string;
+};
+export interface NpmRequestOptions {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    apiKey?: string;
+    npmOtp?: string;
+}
+export declare function npmRequest(base: string, path: string, options?: NpmRequestOptions): Promise<any>;
+/** Escape a package name for URL paths (scoped packages need %2F). */
+export declare function escapePackage(name: string): string;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,64 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const REGISTRY_BASE = 'https://registry.npmjs.org';
+export const DOWNLOADS_BASE = 'https://api.npmjs.org';
+export const REPLICATE_BASE = 'https://replicate.npmjs.com';
+export const npmApiKeyField = z
+    .string()
+    .optional()
+    .describe('npm access token (Bearer). Injected at runtime — create at npmjs.com > Access Tokens.');
+export function missingKey() {
+    return { error: 'npm API key is required. Connect npm first.' };
+}
+function authHeaders(apiKey, npmOtp) {
+    const headers = { Accept: 'application/json' };
+    if (apiKey)
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    if (npmOtp)
+        headers['npm-otp'] = npmOtp;
+    return headers;
+}
+export async function npmRequest(base, path, options) {
+    let url = `${base}${path}`;
+    if (options?.query) {
+        const search = new URLSearchParams();
+        for (const [k, v] of Object.entries(options.query)) {
+            if (v !== undefined)
+                search.set(k, String(v));
+        }
+        const qs = search.toString();
+        if (qs)
+            url += `?${qs}`;
+    }
+    const headers = authHeaders(options?.apiKey, options?.npmOtp);
+    if (options?.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    try {
+        const response = await fetch(url, {
+            method: options?.method ?? 'GET',
+            headers,
+            body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        const text = await response.text();
+        let data = {};
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = { raw: text };
+            }
+        }
+        if (!response.ok)
+            return { error: 'npm API request failed', status: response.status, details: data };
+        return data;
+    }
+    catch (error) {
+        return { error: 'Error calling npm API', message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+/** Escape a package name for URL paths (scoped packages need %2F). */
+export function escapePackage(name) {
+    return name.replace('/', '%2F');
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/npm/tools/downloads.d.ts

@@ -0,0 +1,19 @@
+export declare const getDownloadCountsPoint: import("ai").Tool<{
+    package: string;
+    period: string;
+}, any>;
+export declare const getAllPackagesDownloadPoint: import("ai").Tool<{
+    period: string;
+}, any>;
+export declare const getDownloadCountsRangePackage: import("ai").Tool<{
+    package: string;
+    start: string;
+    end: string;
+}, any>;
+export declare const getDownloadRangeAll: import("ai").Tool<{
+    period: string;
+}, any>;
+export declare const getVersionDownloads: import("ai").Tool<{
+    package: string;
+}, any>;
+//# sourceMappingURL=downloads.d.ts.map

package/dist/toolkits/npm/tools/downloads.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { DOWNLOADS_BASE, escapePackage, npmRequest } from './client.js';
+const periodField = z.string().describe("Period: 'last-day', 'last-week', 'last-month', 'last-year', or 'YYYY-MM-DD:YYYY-MM-DD' (data since 2015-01-10)");
+const packageField = z.string().describe("Package name, e.g. 'express' or '@babel/core' ('/' is encoded automatically)");
+export const getDownloadCountsPoint = tool({
+    description: 'Gets total download counts for one package over a period (preset or custom range up to 18 months). Query packages individually — bulk format differs.',
+    inputSchema: z.object({
+        period: periodField,
+        package: packageField,
+    }),
+    execute: async ({ period, package: pkg }) => npmRequest(DOWNLOADS_BASE, `/downloads/point/${period}/${escapePackage(pkg)}`),
+});
+export const getAllPackagesDownloadPoint = tool({
+    description: 'Gets aggregate download counts across the entire registry for a period (preset or custom range up to 365 days).',
+    inputSchema: z.object({ period: periodField }),
+    execute: async ({ period }) => npmRequest(DOWNLOADS_BASE, `/downloads/point/${period}`),
+});
+export const getDownloadCountsRangePackage = tool({
+    description: 'Gets daily download counts for one package between two YYYY-MM-DD dates (inclusive). Use for historical trends.',
+    inputSchema: z.object({
+        package: packageField,
+        start: z.string().describe("Start date YYYY-MM-DD, e.g. '2023-01-01'"),
+        end: z.string().describe("End date YYYY-MM-DD (>= start), e.g. '2023-01-31'"),
+    }),
+    execute: async ({ package: pkg, start, end }) => npmRequest(DOWNLOADS_BASE, `/downloads/range/${start}:${end}/${escapePackage(pkg)}`),
+});
+export const getDownloadRangeAll = tool({
+    description: 'Gets daily aggregate download counts for all packages over a period. Use for registry-wide statistics.',
+    inputSchema: z.object({ period: periodField }),
+    execute: async ({ period }) => npmRequest(DOWNLOADS_BASE, `/downloads/range/${period}`),
+});
+export const getVersionDownloads = tool({
+    description: 'Gets per-version download counts for a package over the last 7 days. Use to see which versions are most popular.',
+    inputSchema: z.object({ package: packageField }),
+    execute: async ({ package: pkg }) => npmRequest(DOWNLOADS_BASE, `/versions/${escapePackage(pkg)}/last-week`),
+});
+//# sourceMappingURL=downloads.js.map

package/dist/toolkits/npm/tools/index.d.ts

@@ -0,0 +1,14 @@
+import { getAllPackagesDownloadPoint, getDownloadCountsPoint, getDownloadCountsRangePackage, getDownloadRangeAll, getVersionDownloads } from './downloads.js';
+import { getPackageMetadata, getRegistryChanges, getRegistryMeta, getRegistryRoot, searchPackages } from './registry.js';
+import { deleteUserTokenLegacy, queryBulkSecurityAdvisories } from './security.js';
+export { getDownloadCountsPoint, getAllPackagesDownloadPoint, getDownloadCountsRangePackage, getDownloadRangeAll, getVersionDownloads, getPackageMetadata, searchPackages, getRegistryRoot, getRegistryChanges, getRegistryMeta, queryBulkSecurityAdvisories, deleteUserTokenLegacy, };
+declare const auth: "npmApiKey";
+type Scope = 'read' | 'write' | 'delete';
+export declare const npmTools: {
+    name: string;
+    description: string;
+    tool: any;
+    requiredAuth?: typeof auth;
+    scope: Scope;
+}[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/npm/tools/index.js

@@ -0,0 +1,24 @@
+// @ts-nocheck
+import { getAllPackagesDownloadPoint, getDownloadCountsPoint, getDownloadCountsRangePackage, getDownloadRangeAll, getVersionDownloads, } from './downloads.js';
+import { getPackageMetadata, getRegistryChanges, getRegistryMeta, getRegistryRoot, searchPackages, } from './registry.js';
+import { deleteUserTokenLegacy, queryBulkSecurityAdvisories } from './security.js';
+export { getDownloadCountsPoint, getAllPackagesDownloadPoint, getDownloadCountsRangePackage, getDownloadRangeAll, getVersionDownloads, getPackageMetadata, searchPackages, getRegistryRoot, getRegistryChanges, getRegistryMeta, queryBulkSecurityAdvisories, deleteUserTokenLegacy, };
+const auth = 'npmApiKey';
+function entry(name, description, toolRef, scope, noAuth = false) {
+    return noAuth ? { name, description, tool: toolRef, scope } : { name, description, tool: toolRef, requiredAuth: auth, scope };
+}
+export const npmTools = [
+    entry('npmGetDownloadCountsPoint', 'Gets total download counts for one package over a period.', getDownloadCountsPoint, 'read', true),
+    entry('npmGetAllPackagesDownloadPoint', 'Gets aggregate registry-wide download counts for a period.', getAllPackagesDownloadPoint, 'read', true),
+    entry('npmGetDownloadCountsRangePackage', 'Gets daily download counts for a package between two dates.', getDownloadCountsRangePackage, 'read', true),
+    entry('npmGetDownloadRangeAll', 'Gets daily registry-wide download counts for a period.', getDownloadRangeAll, 'read', true),
+    entry('npmGetVersionDownloads', 'Gets per-version download counts for the last 7 days.', getVersionDownloads, 'read', true),
+    entry('npmRegistryGetPackage', 'Fetches package metadata (dist-tags, license, maintainers).', getPackageMetadata, 'read', true),
+    entry('npmRegistrySearchPackages', 'Searches packages by name/keywords/description.', searchPackages, 'read', true),
+    entry('npmRegistryGetRoot', 'Fetches registry database statistics (package count, update_seq).', getRegistryRoot, 'read', true),
+    entry('npmGetRegistryChanges', 'Streams the registry change feed for replication.', getRegistryChanges, 'read', true),
+    entry('npmGetRegistryMeta', "Calls registry meta endpoints 'ping' (public) or 'whoami' (authed).", getRegistryMeta, 'read'),
+    entry('npmQueryBulkSecurityAdvisories', 'Bulk-checks vulnerabilities for multiple packages.', queryBulkSecurityAdvisories, 'read', true),
+    entry('npmDeleteUserTokenLegacy', 'Revokes a user auth token via the legacy endpoint.', deleteUserTokenLegacy, 'delete'),
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/npm/tools/registry.d.ts

@@ -0,0 +1,24 @@
+export declare const getPackageMetadata: import("ai").Tool<{
+    package: string;
+    version?: string | undefined;
+}, any>;
+export declare const searchPackages: import("ai").Tool<{
+    text: string;
+    size?: number | undefined;
+    offset?: number | undefined;
+    quality?: number | undefined;
+    popularity?: number | undefined;
+    maintenance?: number | undefined;
+}, any>;
+export declare const getRegistryRoot: import("ai").Tool<{
+    npmApiKey?: string | undefined;
+}, any>;
+export declare const getRegistryChanges: import("ai").Tool<{
+    since?: number | undefined;
+    limit?: number | undefined;
+}, any>;
+export declare const getRegistryMeta: import("ai").Tool<{
+    endpoint: "ping" | "whoami";
+    npmApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/toolkits/npm/tools/registry.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { REGISTRY_BASE, REPLICATE_BASE, escapePackage, missingKey, npmApiKeyField, npmRequest } from './client.js';
+export const getPackageMetadata = tool({
+    description: "Fetches package metadata (dist-tags, description, license, maintainers). Without version returns abbreviated metadata for all versions; with version returns that version's manifest. Use 'dist-tags.latest' as the stable version.",
+    inputSchema: z.object({
+        package: z.string().describe("Package name with scope, e.g. 'react', '@babel/core'"),
+        version: z.string().optional().describe("Version or dist-tag, e.g. 'latest', '1.2.3', 'next' (omit for all versions)"),
+    }),
+    execute: async ({ package: pkg, version }) => {
+        const path = version ? `/${escapePackage(pkg)}/${encodeURIComponent(version)}` : `/${escapePackage(pkg)}`;
+        return npmRequest(REGISTRY_BASE, path);
+    },
+});
+export const searchPackages = tool({
+    description: "Searches packages by name/keywords/description. Results in 'objects' array with metadata under 'package' and weekly downloads under 'downloads.weekly'. Combine keywords for precision.",
+    inputSchema: z.object({
+        text: z.string().describe("Query, e.g. 'react', 'testing framework'"),
+        size: z.number().int().min(1).max(250).optional().describe('Results to return (1-250, default 20)'),
+        offset: z.number().int().min(0).optional().describe('Pagination offset (default 0)'),
+        quality: z.number().min(0).max(1).optional().describe('Quality weight 0-1 (default 1)'),
+        popularity: z.number().min(0).max(1).optional().describe('Popularity weight 0-1 (default 1)'),
+        maintenance: z.number().min(0).max(1).optional().describe('Maintenance weight 0-1 (default 1)'),
+    }),
+    execute: async ({ text, size, offset, quality, popularity, maintenance }) => npmRequest(REGISTRY_BASE, '/-/v1/search', { query: { text, size, from: offset, quality, popularity, maintenance } }),
+});
+export const getRegistryRoot = tool({
+    description: 'Fetches registry database statistics (total package count doc_count, update_seq) from the replication service. No inputs needed.',
+    inputSchema: z.object({
+        npmApiKey: npmApiKeyField.describe('Optional Bearer token (only needed for private registry mirrors)'),
+    }),
+    execute: async ({ npmApiKey }) => npmRequest(REPLICATE_BASE, '/', { apiKey: npmApiKey }),
+});
+export const getRegistryChanges = tool({
+    description: 'Streams the CouchDB-style registry change feed for replication. Pass back last_seq as since to continue polling.',
+    inputSchema: z.object({
+        since: z.number().int().min(0).optional().describe('Sequence number to start from (use last_seq to continue)'),
+        limit: z.number().int().min(1).max(10000).optional().describe('Max changes (default 1000, max 10000)'),
+    }),
+    execute: async ({ since, limit }) => npmRequest(REPLICATE_BASE, '/registry/_changes', { query: { since, limit } }),
+});
+export const getRegistryMeta = tool({
+    description: "Calls a registry meta endpoint: 'ping' checks connectivity (public, returns {}), 'whoami' returns the token's username (needs API key).",
+    inputSchema: z.object({
+        npmApiKey: npmApiKeyField,
+        endpoint: z.enum(['ping', 'whoami']).describe("'ping' for connectivity, 'whoami' for authenticated username"),
+    }),
+    execute: async ({ npmApiKey, endpoint }) => {
+        if (endpoint === 'whoami' && !npmApiKey)
+            return missingKey();
+        const data = await npmRequest(REGISTRY_BASE, `/-/${endpoint}`, { apiKey: npmApiKey });
+        if (endpoint === 'ping')
+            return { ping: JSON.stringify(data) };
+        return data;
+    },
+});
+//# sourceMappingURL=registry.js.map

package/dist/toolkits/npm/tools/security.d.ts

@@ -0,0 +1,9 @@
+export declare const queryBulkSecurityAdvisories: import("ai").Tool<{
+    packages: Record<string, string[]>;
+}, any>;
+export declare const deleteUserTokenLegacy: import("ai").Tool<{
+    token: string;
+    npmApiKey?: string | undefined;
+    npmOtp?: string | undefined;
+}, any>;
+//# sourceMappingURL=security.d.ts.map

package/dist/toolkits/npm/tools/security.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { REGISTRY_BASE, missingKey, npmApiKeyField, npmRequest } from './client.js';
+export const queryBulkSecurityAdvisories = tool({
+    description: 'Bulk-checks vulnerabilities for multiple packages at once. Maps package names to version arrays; packages without issues return empty arrays.',
+    inputSchema: z.object({
+        packages: z.record(z.array(z.string())).describe("Package-to-versions map, e.g. {express:['4.17.1'],lodash:['4.17.20']}"),
+    }),
+    execute: async ({ packages }) => npmRequest(REGISTRY_BASE, '/-/npm/v1/security/advisories/bulk', { method: 'POST', body: packages }),
+});
+export const deleteUserTokenLegacy = tool({
+    description: 'Revokes a user auth token via the legacy endpoint using its key from the token list. Provide npm OTP for 2FA accounts.',
+    inputSchema: z.object({
+        npmApiKey: npmApiKeyField,
+        token: z.string().describe("Token key/UUID to delete, e.g. 'a1df1599-b022-4f1b-86c5-ee7a1df48f48'"),
+        npmOtp: z.string().optional().describe('One-time password for 2FA accounts'),
+    }),
+    execute: async ({ npmApiKey, token, npmOtp }) => {
+        if (!npmApiKey)
+            return missingKey();
+        return npmRequest(REGISTRY_BASE, `/-/user/token/${encodeURIComponent(token)}`, {
+            method: 'DELETE',
+            apiKey: npmApiKey,
+            npmOtp,
+        });
+    },
+});
+//# sourceMappingURL=security.js.map