skillpkg-core 0.1.0

package/dist/parser/schema.d.ts

@@ -0,0 +1,155 @@
+/**
+ * JSON Schema for skill.yaml validation
+ */
+/**
+ * JSON Schema for skill.yaml
+ * Using plain object instead of JSONSchemaType for flexibility
+ */
+export declare const skillSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly schema: {
+            readonly type: "string";
+            readonly pattern: "^\\d+\\.\\d+$";
+            readonly description: "Schema version (e.g., \"1.0\")";
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly pattern: "^[a-z][a-z0-9-]*[a-z0-9]$";
+            readonly minLength: 2;
+            readonly maxLength: 100;
+            readonly description: "Unique skill identifier in kebab-case";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly pattern: "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$";
+            readonly description: "Semantic version (e.g., \"1.0.0\")";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 500;
+            readonly description: "Short description of the skill";
+        };
+        readonly instructions: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Markdown instructions for the AI agent";
+        };
+        readonly author: {
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                    };
+                    readonly email: {
+                        readonly type: "string";
+                        readonly format: "email";
+                    };
+                    readonly url: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                    };
+                };
+                readonly required: readonly ["name"];
+                readonly additionalProperties: false;
+            }];
+            readonly description: "Author name or object with name, email, url";
+        };
+        readonly license: {
+            readonly type: "string";
+            readonly description: "License identifier (e.g., \"MIT\")";
+        };
+        readonly repository: {
+            readonly type: "string";
+            readonly format: "uri";
+            readonly description: "Repository URL";
+        };
+        readonly keywords: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Keywords for search";
+        };
+        readonly triggers: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Trigger words to activate the skill";
+        };
+        readonly capabilities: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly enum: readonly ["file:read", "file:write", "shell:execute", "web:search", "web:fetch", "mcp:*"];
+            };
+            readonly description: "Required capabilities";
+        };
+        readonly platforms: {
+            readonly type: "object";
+            readonly properties: {
+                readonly 'claude-code': {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly 'allowed-tools': {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+                readonly codex: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly sandbox: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+                readonly copilot: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly mode: {
+                            readonly type: "string";
+                            readonly enum: readonly ["edit", "chat"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+                readonly cline: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly customRules: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Platform-specific configurations";
+        };
+        readonly dependencies: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+            readonly description: "Skill dependencies with version ranges";
+        };
+    };
+    readonly required: readonly ["schema", "name", "version", "description", "instructions"];
+    readonly additionalProperties: false;
+};
+/**
+ * Human-readable field descriptions for error messages
+ */
+export declare const fieldDescriptions: Record<string, string>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/parser/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/parser/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwHd,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAcpD,CAAC"}

package/dist/parser/schema.js

@@ -0,0 +1,147 @@
+/**
+ * JSON Schema for skill.yaml validation
+ */
+/**
+ * JSON Schema for skill.yaml
+ * Using plain object instead of JSONSchemaType for flexibility
+ */
+export const skillSchema = {
+    type: 'object',
+    properties: {
+        schema: {
+            type: 'string',
+            pattern: '^\\d+\\.\\d+$',
+            description: 'Schema version (e.g., "1.0")',
+        },
+        name: {
+            type: 'string',
+            pattern: '^[a-z][a-z0-9-]*[a-z0-9]$',
+            minLength: 2,
+            maxLength: 100,
+            description: 'Unique skill identifier in kebab-case',
+        },
+        version: {
+            type: 'string',
+            pattern: '^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$',
+            description: 'Semantic version (e.g., "1.0.0")',
+        },
+        description: {
+            type: 'string',
+            minLength: 1,
+            maxLength: 500,
+            description: 'Short description of the skill',
+        },
+        instructions: {
+            type: 'string',
+            minLength: 1,
+            description: 'Markdown instructions for the AI agent',
+        },
+        author: {
+            oneOf: [
+                { type: 'string' },
+                {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        email: { type: 'string', format: 'email' },
+                        url: { type: 'string', format: 'uri' },
+                    },
+                    required: ['name'],
+                    additionalProperties: false,
+                },
+            ],
+            description: 'Author name or object with name, email, url',
+        },
+        license: {
+            type: 'string',
+            description: 'License identifier (e.g., "MIT")',
+        },
+        repository: {
+            type: 'string',
+            format: 'uri',
+            description: 'Repository URL',
+        },
+        keywords: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Keywords for search',
+        },
+        triggers: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Trigger words to activate the skill',
+        },
+        capabilities: {
+            type: 'array',
+            items: {
+                type: 'string',
+                enum: ['file:read', 'file:write', 'shell:execute', 'web:search', 'web:fetch', 'mcp:*'],
+            },
+            description: 'Required capabilities',
+        },
+        platforms: {
+            type: 'object',
+            properties: {
+                'claude-code': {
+                    type: 'object',
+                    properties: {
+                        'allowed-tools': {
+                            type: 'array',
+                            items: { type: 'string' },
+                        },
+                    },
+                    additionalProperties: false,
+                },
+                codex: {
+                    type: 'object',
+                    properties: {
+                        sandbox: { type: 'boolean' },
+                    },
+                    additionalProperties: false,
+                },
+                copilot: {
+                    type: 'object',
+                    properties: {
+                        mode: { type: 'string', enum: ['edit', 'chat'] },
+                    },
+                    additionalProperties: false,
+                },
+                cline: {
+                    type: 'object',
+                    properties: {
+                        customRules: { type: 'string' },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            additionalProperties: false,
+            description: 'Platform-specific configurations',
+        },
+        dependencies: {
+            type: 'object',
+            additionalProperties: { type: 'string' },
+            description: 'Skill dependencies with version ranges',
+        },
+    },
+    required: ['schema', 'name', 'version', 'description', 'instructions'],
+    additionalProperties: false,
+};
+/**
+ * Human-readable field descriptions for error messages
+ */
+export const fieldDescriptions = {
+    schema: 'Schema version (e.g., "1.0")',
+    name: 'Unique skill identifier in kebab-case (e.g., "my-skill")',
+    version: 'Semantic version (e.g., "1.0.0")',
+    description: 'Short description of the skill (max 500 chars)',
+    instructions: 'Markdown instructions for the AI agent',
+    author: 'Author name or object with name, email, url',
+    license: 'License identifier (e.g., "MIT")',
+    repository: 'Repository URL',
+    keywords: 'Keywords for search',
+    triggers: 'Trigger words to activate the skill',
+    capabilities: 'Required capabilities (file:read, shell:execute, etc.)',
+    platforms: 'Platform-specific configurations',
+    dependencies: 'Skill dependencies with version ranges',
+};
+//# sourceMappingURL=schema.js.map

package/dist/parser/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/parser/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,eAAe;YACxB,WAAW,EAAE,8BAA8B;SAC5C;QACD,IAAI,EAAE;YACJ,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,2BAA2B;YACpC,SAAS,EAAE,CAAC;YACZ,SAAS,EAAE,GAAG;YACd,WAAW,EAAE,uCAAuC;SACrD;QACD,OAAO,EAAE;YACP,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,4DAA4D;YACrE,WAAW,EAAE,kCAAkC;SAChD;QACD,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,CAAC;YACZ,SAAS,EAAE,GAAG;YACd,WAAW,EAAE,gCAAgC;SAC9C;QACD,YAAY,EAAE;YACZ,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,CAAC;YACZ,WAAW,EAAE,wCAAwC;SACtD;QACD,MAAM,EAAE;YACN,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAClB;oBACE,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wBACxB,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;wBAC1C,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE;qBACvC;oBACD,QAAQ,EAAE,CAAC,MAAM,CAAC;oBAClB,oBAAoB,EAAE,KAAK;iBAC5B;aACF;YACD,WAAW,EAAE,6CAA6C;SAC3D;QACD,OAAO,EAAE;YACP,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,kCAAkC;SAChD;QACD,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,gBAAgB;SAC9B;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACzB,WAAW,EAAE,qBAAqB;SACnC;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACzB,WAAW,EAAE,qCAAqC;SACnD;QACD,YAAY,EAAE;YACZ,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,CAAC;aACvF;YACD,WAAW,EAAE,uBAAuB;SACrC;QACD,SAAS,EAAE;YACT,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,aAAa,EAAE;oBACb,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,eAAe,EAAE;4BACf,IAAI,EAAE,OAAO;4BACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;yBAC1B;qBACF;oBACD,oBAAoB,EAAE,KAAK;iBAC5B;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;qBAC7B;oBACD,oBAAoB,EAAE,KAAK;iBAC5B;gBACD,OAAO,EAAE;oBACP,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;qBACjD;oBACD,oBAAoB,EAAE,KAAK;iBAC5B;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;qBAChC;oBACD,oBAAoB,EAAE,KAAK;iBAC5B;aACF;YACD,oBAAoB,EAAE,KAAK;YAC3B,WAAW,EAAE,kCAAkC;SAChD;QACD,YAAY,EAAE;YACZ,IAAI,EAAE,QAAQ;YACd,oBAAoB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACxC,WAAW,EAAE,wCAAwC;SACtD;KACF;IACD,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,CAAC;IACtE,oBAAoB,EAAE,KAAK;CACnB,CAAC;AAEX;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA2B;IACvD,MAAM,EAAE,8BAA8B;IACtC,IAAI,EAAE,0DAA0D;IAChE,OAAO,EAAE,kCAAkC;IAC3C,WAAW,EAAE,gDAAgD;IAC7D,YAAY,EAAE,wCAAwC;IACtD,MAAM,EAAE,6CAA6C;IACrD,OAAO,EAAE,kCAAkC;IAC3C,UAAU,EAAE,gBAAgB;IAC5B,QAAQ,EAAE,qBAAqB;IAC/B,QAAQ,EAAE,qCAAqC;IAC/C,YAAY,EAAE,wDAAwD;IACtE,SAAS,EAAE,kCAAkC;IAC7C,YAAY,EAAE,wCAAwC;CACvD,CAAC"}

package/dist/parser/validator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Validation error with detailed information
+ */
+export interface ValidationError {
+    /** JSON path to the error (e.g., "/name") */
+    path: string;
+    /** Human-readable error message */
+    message: string;
+    /** Expected value/type */
+    expected?: string;
+    /** Actual value received */
+    actual?: unknown;
+}
+/**
+ * Validation warning (non-critical issues)
+ */
+export interface ValidationWarning {
+    /** JSON path to the warning */
+    path: string;
+    /** Warning message */
+    message: string;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    /** Whether the skill is valid */
+    valid: boolean;
+    /** Validation errors (if any) */
+    errors: ValidationError[];
+    /** Validation warnings (non-critical) */
+    warnings: ValidationWarning[];
+}
+/**
+ * Validate a skill object against the schema
+ */
+export declare function validate(skill: unknown): ValidationResult;
+//# sourceMappingURL=validator.d.ts.map

package/dist/parser/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/parser/validator.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,iCAAiC;IACjC,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,yCAAyC;IACzC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAaD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAqGzD"}

package/dist/parser/validator.js

@@ -0,0 +1,125 @@
+/**
+ * Skill validation using JSON Schema
+ */
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { skillSchema, fieldDescriptions } from './schema.js';
+// Create Ajv instance with formats
+const ajv = new Ajv({
+    allErrors: true,
+    verbose: true,
+    strict: false,
+});
+addFormats(ajv);
+// Compile the schema
+const validateSkill = ajv.compile(skillSchema);
+/**
+ * Validate a skill object against the schema
+ */
+export function validate(skill) {
+    const errors = [];
+    const warnings = [];
+    // Run JSON Schema validation
+    const isValid = validateSkill(skill);
+    if (!isValid && validateSkill.errors) {
+        for (const error of validateSkill.errors) {
+            const path = error.instancePath || '/';
+            const fieldName = path.split('/').pop() || 'root';
+            const description = fieldDescriptions[fieldName] || '';
+            let message = error.message || 'Validation error';
+            let expected;
+            // Enhance error messages
+            switch (error.keyword) {
+                case 'required':
+                    message = `Missing required field: ${error.params.missingProperty}`;
+                    expected = description || undefined;
+                    break;
+                case 'pattern':
+                    message = `Invalid format for "${fieldName}"`;
+                    expected = getPatternDescription(fieldName);
+                    break;
+                case 'enum':
+                    message = `Invalid value for "${fieldName}"`;
+                    expected = `One of: ${error.params.allowedValues.join(', ')}`;
+                    break;
+                case 'type':
+                    message = `Invalid type for "${fieldName}"`;
+                    expected = error.params.type;
+                    break;
+                case 'minLength':
+                    message = `"${fieldName}" is too short`;
+                    expected = `At least ${error.params.limit} characters`;
+                    break;
+                case 'maxLength':
+                    message = `"${fieldName}" is too long`;
+                    expected = `At most ${error.params.limit} characters`;
+                    break;
+                case 'format':
+                    message = `Invalid ${error.params.format} format for "${fieldName}"`;
+                    break;
+                case 'additionalProperties':
+                    message = `Unknown field: ${error.params.additionalProperty}`;
+                    break;
+            }
+            errors.push({
+                path,
+                message,
+                expected,
+                actual: error.data,
+            });
+        }
+    }
+    // Add warnings for best practices (even if valid)
+    if (typeof skill === 'object' && skill !== null) {
+        const s = skill;
+        // Warn if no triggers defined
+        if (!s.triggers || s.triggers.length === 0) {
+            warnings.push({
+                path: '/triggers',
+                message: 'No trigger words defined. Consider adding triggers for easier activation.',
+            });
+        }
+        // Warn if no capabilities defined
+        if (!s.capabilities || s.capabilities.length === 0) {
+            warnings.push({
+                path: '/capabilities',
+                message: 'No capabilities declared. Consider declaring required capabilities.',
+            });
+        }
+        // Warn if description is too short
+        if (s.description && s.description.length < 20) {
+            warnings.push({
+                path: '/description',
+                message: 'Description is very short. Consider adding more detail.',
+            });
+        }
+        // Warn if no author
+        if (!s.author) {
+            warnings.push({
+                path: '/author',
+                message: 'No author specified. Consider adding author information.',
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Get human-readable pattern description
+ */
+function getPatternDescription(fieldName) {
+    switch (fieldName) {
+        case 'name':
+            return 'kebab-case (e.g., "my-skill-name")';
+        case 'version':
+            return 'Semantic version (e.g., "1.0.0")';
+        case 'schema':
+            return 'Version number (e.g., "1.0")';
+        default:
+            return '';
+    }
+}
+//# sourceMappingURL=validator.js.map

package/dist/parser/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/parser/validator.ts"],"names":[],"mappings":"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"}

package/dist/registry/auth.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Auth token data
+ */
+export interface AuthToken {
+    token: string;
+    registry: string;
+    createdAt: string;
+    expiresAt?: string;
+    username?: string;
+}
+/**
+ * Get token for a registry URL
+ */
+export declare function getToken(registryUrl: string): Promise<string | null>;
+/**
+ * Save token for a registry URL
+ */
+export declare function setToken(registryUrl: string, token: string, options?: {
+    expiresIn?: number;
+    username?: string;
+}): Promise<void>;
+/**
+ * Remove token for a registry URL
+ */
+export declare function removeToken(registryUrl: string): Promise<boolean>;
+/**
+ * Get all saved tokens
+ */
+export declare function listTokens(): Promise<AuthToken[]>;
+/**
+ * Check if authenticated for a registry
+ */
+export declare function isAuthenticated(registryUrl: string): Promise<boolean>;
+/**
+ * Get username for a registry
+ */
+export declare function getUsername(registryUrl: string): Promise<string | null>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/registry/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/registry/auth.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAyDD;;GAEG;AACH,wBAAsB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAqB1E;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAWvE;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAGvD;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG3E;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAI7E"}

package/dist/registry/auth.js

@@ -0,0 +1,142 @@
+/**
+ * Registry authentication module
+ */
+import { readFile, writeFile, chmod, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+/**
+ * Get auth file path
+ */
+function getAuthPath() {
+    return join(homedir(), '.skillpkg', 'auth.json');
+}
+/**
+ * Load auth file
+ */
+async function loadAuthFile() {
+    const authPath = getAuthPath();
+    if (!existsSync(authPath)) {
+        return { tokens: {} };
+    }
+    try {
+        const content = await readFile(authPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { tokens: {} };
+    }
+}
+/**
+ * Save auth file with secure permissions (600)
+ */
+async function saveAuthFile(auth) {
+    const authPath = getAuthPath();
+    const dir = dirname(authPath);
+    // Ensure directory exists
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    // Write file
+    await writeFile(authPath, JSON.stringify(auth, null, 2), 'utf-8');
+    // Set secure permissions (readable/writable only by owner)
+    try {
+        await chmod(authPath, 0o600);
+    }
+    catch {
+        // Ignore permission errors on Windows
+    }
+}
+/**
+ * Get token for a registry URL
+ */
+export async function getToken(registryUrl) {
+    const auth = await loadAuthFile();
+    const normalizedUrl = normalizeRegistryUrl(registryUrl);
+    const tokenData = auth.tokens[normalizedUrl];
+    if (!tokenData) {
+        return null;
+    }
+    // Check if token is expired
+    if (tokenData.expiresAt) {
+        const expiresAt = new Date(tokenData.expiresAt);
+        if (expiresAt < new Date()) {
+            // Token expired, remove it
+            delete auth.tokens[normalizedUrl];
+            await saveAuthFile(auth);
+            return null;
+        }
+    }
+    return tokenData.token;
+}
+/**
+ * Save token for a registry URL
+ */
+export async function setToken(registryUrl, token, options) {
+    const auth = await loadAuthFile();
+    const normalizedUrl = normalizeRegistryUrl(registryUrl);
+    const tokenData = {
+        token,
+        registry: normalizedUrl,
+        createdAt: new Date().toISOString(),
+        username: options?.username,
+    };
+    if (options?.expiresIn) {
+        const expiresAt = new Date();
+        expiresAt.setSeconds(expiresAt.getSeconds() + options.expiresIn);
+        tokenData.expiresAt = expiresAt.toISOString();
+    }
+    auth.tokens[normalizedUrl] = tokenData;
+    await saveAuthFile(auth);
+}
+/**
+ * Remove token for a registry URL
+ */
+export async function removeToken(registryUrl) {
+    const auth = await loadAuthFile();
+    const normalizedUrl = normalizeRegistryUrl(registryUrl);
+    if (!auth.tokens[normalizedUrl]) {
+        return false;
+    }
+    delete auth.tokens[normalizedUrl];
+    await saveAuthFile(auth);
+    return true;
+}
+/**
+ * Get all saved tokens
+ */
+export async function listTokens() {
+    const auth = await loadAuthFile();
+    return Object.values(auth.tokens);
+}
+/**
+ * Check if authenticated for a registry
+ */
+export async function isAuthenticated(registryUrl) {
+    const token = await getToken(registryUrl);
+    return token !== null;
+}
+/**
+ * Get username for a registry
+ */
+export async function getUsername(registryUrl) {
+    const auth = await loadAuthFile();
+    const normalizedUrl = normalizeRegistryUrl(registryUrl);
+    return auth.tokens[normalizedUrl]?.username ?? null;
+}
+/**
+ * Normalize registry URL (remove trailing slash, ensure https)
+ */
+function normalizeRegistryUrl(url) {
+    let normalized = url.trim();
+    // Add https if no protocol
+    if (!normalized.startsWith('http://') && !normalized.startsWith('https://')) {
+        normalized = `https://${normalized}`;
+    }
+    // Remove trailing slash
+    if (normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+//# sourceMappingURL=auth.js.map