sdkwork-browser-agent 1.0.0

package/dist/node/skills/index.d.ts

@@ -0,0 +1,401 @@
+import { S as Skill, E as ExecutionContext, a as SkillResult } from '../agent-Bpxmkz8W.js';
+import { S as StorageAdapter } from '../types-CG5I-byI.js';
+import '../provider-Dna36xA-.js';
+
+/**
+ * Enhanced Skill Registry
+ * Advanced caching, indexing, and skill management
+ */
+
+interface RegistryConfig {
+    storage?: StorageAdapter | null;
+    enableCache?: boolean;
+    enableIndexing?: boolean;
+    maxCacheSize?: number;
+    cacheTTL?: number;
+    hotReload?: boolean;
+}
+declare class SkillRegistry {
+    private skills;
+    private index;
+    private config;
+    private storage;
+    private watchers;
+    constructor(config?: RegistryConfig);
+    /**
+     * Register a skill in the registry
+     */
+    register(skill: Skill): void;
+    /**
+     * Unregister a skill
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a skill by name
+     */
+    get(name: string): Skill | undefined;
+    /**
+     * Check if skill exists
+     */
+    has(name: string): boolean;
+    /**
+     * Find skills by category
+     */
+    findByCategory(category: string): Skill[];
+    /**
+     * Find skills by tag
+     */
+    findByTag(tag: string): Skill[];
+    /**
+     * Search skills by keyword
+     */
+    search(keyword: string): Skill[];
+    /**
+     * Get all registered skills
+     */
+    getAll(): Skill[];
+    /**
+     * Get all skill names
+     */
+    getNames(): string[];
+    /**
+     * Get skills by names
+     */
+    getMany(names: string[]): Skill[];
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        totalSkills: number;
+        totalSize: number;
+        averageAccessCount: number;
+        cacheHitRate: number;
+        categories: string[];
+        tags: string[];
+    };
+    /**
+     * Clear all skills
+     */
+    clear(): void;
+    /**
+     * Clear expired cache entries
+     */
+    clearExpired(): number;
+    /**
+     * Optimize cache by removing least recently used entries
+     */
+    optimizeCache(): void;
+    private indexSkill;
+    private removeFromIndex;
+    private clearIndex;
+    private calculateSkillSize;
+    private calculateCacheHitRate;
+    private watchSkill;
+}
+
+/**
+ * Built-in Skills - TypeScript Implementations
+ *
+ * Each skill follows the Agent Skills Specification:
+ * - SKILL.md with YAML frontmatter
+ * - Progressive disclosure pattern
+ * - Standardized parameters and responses
+ */
+
+declare const echoSkill: Skill;
+declare const mathSkill: Skill;
+declare const listSkillsSkill: Skill;
+declare const builtInSkills: Skill[];
+declare const builtInSkillsMap: Map<string, Skill>;
+
+/**
+ * Agent Skills Specification Loader
+ *
+ * Loads skills following the Agent Skills Specification:
+ * - skill-name/
+ *   └── SKILL.md (with YAML frontmatter)
+ *   └── scripts/ (optional)
+ *   └── references/ (optional)
+ *   └── assets/ (optional)
+ */
+
+interface SkillManifest {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+}
+interface ParsedSkill {
+    manifest: SkillManifest;
+    instructions: string;
+    skill: Skill;
+}
+/**
+ * Parse SKILL.md content
+ * Extracts YAML frontmatter and markdown body
+ */
+declare function parseSkillMd(content: string): {
+    manifest: SkillManifest;
+    instructions: string;
+};
+/**
+ * Convert manifest and instructions to Skill object
+ * Note: This creates a placeholder skill. Real implementation
+ * would need to load actual handler from scripts/ directory
+ */
+declare function createSkillFromManifest(manifest: SkillManifest, _instructions: string): Skill;
+/**
+ * Load skill from directory
+ */
+declare function loadSkillFromDirectory(skillPath: string): Promise<ParsedSkill>;
+/**
+ * Validate skill manifest
+ */
+declare function validateManifest(manifest: SkillManifest): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * Skill Resource Manager
+ *
+ * Manages loading and execution of skills following Agent Skills Specification
+ * Implements progressive disclosure: metadata → instructions → resources
+ */
+
+interface ScriptFile {
+    name: string;
+    path: string;
+    language: 'javascript' | 'typescript' | 'python' | 'bash';
+    content: string;
+}
+interface ReferenceFile {
+    name: string;
+    path: string;
+    content: string;
+}
+interface AssetFile {
+    name: string;
+    path: string;
+    type: 'template' | 'image' | 'data' | 'other';
+    content: string;
+}
+type DisclosureLevel = 'metadata' | 'instructions' | 'resources';
+interface LoadedSkill {
+    name: string;
+    path: string;
+    manifest: SkillManifest;
+    instructions?: string;
+    scripts: Map<string, ScriptFile>;
+    references: Map<string, ReferenceFile>;
+    assets: Map<string, AssetFile>;
+    currentLevel: DisclosureLevel;
+    loadedAt: Date;
+}
+interface SkillManagerConfig {
+    basePath?: string;
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+}
+/**
+ * Skill Resource Manager
+ * Manages loading and execution of skills following Agent Skills Specification
+ */
+declare class SkillResourceManager {
+    private config;
+    private cache;
+    private metadataCache;
+    constructor(config?: SkillManagerConfig);
+    /**
+     * Level 1: Load metadata only (~100 tokens)
+     * Loaded at startup for all skills
+     */
+    loadMetadata(skillPath: string): Promise<SkillManifest>;
+    /**
+     * Level 2: Load instructions (< 5000 tokens)
+     * Loaded when skill is activated
+     */
+    loadInstructions(skillPath: string): Promise<string>;
+    /**
+     * Level 3: Load complete skill with resources
+     * Resources loaded as needed
+     */
+    loadFullSkill(skillPath: string): Promise<LoadedSkill>;
+    /**
+     * Progressive loading - load up to specified level
+     */
+    loadProgressive(skillPath: string, level?: DisclosureLevel): Promise<LoadedSkill>;
+    /**
+     * Load a specific resource on demand
+     */
+    loadResource(skillPath: string, type: 'script' | 'reference' | 'asset', name: string): Promise<ScriptFile | ReferenceFile | AssetFile | null>;
+    /**
+     * Get reference content
+     */
+    getReference(skillPath: string, referenceName: string): Promise<string | null>;
+    /**
+     * Get asset content
+     */
+    getAsset(skillPath: string, assetName: string): Promise<string | null>;
+    private loadScripts;
+    private loadReferences;
+    private loadAssets;
+    private loadScript;
+    private loadReference;
+    private loadAsset;
+    private parseSkillMd;
+    private parseYaml;
+    private parseYamlValue;
+    /**
+     * Validate manifest according to Agent Skills Specification
+     */
+    private validateManifest;
+    private detectLanguage;
+    private detectAssetType;
+    private enforceCacheLimit;
+    private readFile;
+    private listDirectory;
+}
+
+/**
+ * Enhanced Skill Script Executor
+ *
+ * Executes scripts from Skill scripts/ directory with comprehensive sandboxing
+ * Supports JavaScript, TypeScript, Python, and Bash with security controls
+ */
+
+interface ScriptExecutionResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    executionTime: number;
+    memoryUsage?: number;
+}
+interface ScriptExecutorConfig {
+    timeout?: number;
+    allowedGlobals?: string[];
+    restrictedGlobals?: string[];
+    maxMemoryMB?: number;
+    allowedTools?: string[];
+    enableLogging?: boolean;
+}
+/**
+ * Enhanced Skill Script Executor with comprehensive sandboxing
+ */
+declare class SkillScriptExecutor {
+    private config;
+    private executionCount;
+    constructor(config?: ScriptExecutorConfig);
+    /**
+     * Execute a script with given operation and parameters
+     */
+    execute(script: ScriptFile, operation: string, params: Record<string, unknown>, context: ExecutionContext): Promise<ScriptExecutionResult>;
+    /**
+     * Check if script is allowed to execute based on allowed-tools configuration
+     */
+    private isScriptAllowed;
+    /**
+     * Execute JavaScript/TypeScript in secure sandbox
+     */
+    private executeJavaScript;
+    /**
+     * Sanitize JavaScript code to remove dangerous patterns
+     */
+    private sanitizeJavaScript;
+    /**
+     * Create sandbox context with allowed globals
+     */
+    private createSandbox;
+    /**
+     * Execute JavaScript in browser using Web Worker
+     */
+    private executeInBrowserWorker;
+    /**
+     * Execute JavaScript in Node.js using VM module
+     */
+    private executeInNodeVM;
+    /**
+     * Execute Python code (requires Python runtime)
+     */
+    private executePython;
+    /**
+     * Execute Bash script (Node.js only)
+     */
+    private executeBash;
+    /**
+     * Get executor statistics
+     */
+    getStats(): {
+        totalExecutions: number;
+        config: ScriptExecutorConfig;
+    };
+}
+
+/**
+ * Enhanced Skill Executor
+ *
+ * Integrates SkillResourceManager and SkillScriptExecutor
+ * Provides complete Skill execution with resource loading
+ */
+
+interface EnhancedSkillExecutorConfig {
+    resourceManager?: SkillResourceManager;
+    scriptExecutor?: SkillScriptExecutor;
+    defaultScriptName?: string;
+}
+/**
+ * Enhanced Skill Executor with full resource support
+ */
+declare class EnhancedSkillExecutor {
+    private resourceManager;
+    private scriptExecutor;
+    private defaultScriptName;
+    constructor(config?: EnhancedSkillExecutorConfig);
+    /**
+     * Execute a skill with full resource loading
+     *
+     * This method:
+     * 1. Loads the skill with all resources (if not cached)
+     * 2. Finds the appropriate script
+     * 3. Executes the script with the operation and parameters
+     * 4. Returns the result
+     */
+    execute(skillPath: string, operation: string, params: Record<string, unknown> | undefined, context: ExecutionContext): Promise<SkillResult>;
+    /**
+     * Execute skill with progressive loading
+     * Loads only metadata first, then instructions if needed, then resources
+     */
+    executeProgressive(skillPath: string, operation: string, params: Record<string, unknown> | undefined, context: ExecutionContext): Promise<SkillResult>;
+    /**
+     * Get skill information without loading resources
+     */
+    getSkillInfo(skillPath: string): Promise<{
+        name: string;
+        description: string;
+        hasScripts: boolean;
+        hasReferences: boolean;
+        hasAssets: boolean;
+    }>;
+    /**
+     * Get reference documentation
+     */
+    getReference(skillPath: string, referenceName: string): Promise<string | null>;
+    /**
+     * Get asset content
+     */
+    getAsset(skillPath: string, assetName: string): Promise<string | null>;
+    /**
+     * List all available skills in a directory
+     */
+    listSkills(directoryPath: string): Promise<Array<{
+        path: string;
+        name: string;
+        description: string;
+    }>>;
+    private findScript;
+    private operationSupported;
+}
+
+export { type AssetFile, type DisclosureLevel, EnhancedSkillExecutor, type EnhancedSkillExecutorConfig, type LoadedSkill, type ParsedSkill, type ReferenceFile, type RegistryConfig, type LoadedSkill as ResourceLoadedSkill, type ScriptExecutionResult, type ScriptExecutorConfig, type ScriptFile, type SkillManagerConfig, type SkillManifest, SkillRegistry, SkillResourceManager, SkillScriptExecutor, builtInSkills, builtInSkillsMap, createSkillFromManifest, echoSkill, listSkillsSkill, loadSkillFromDirectory, mathSkill, parseSkillMd, validateManifest };

package/dist/node/skills/index.js

@@ -0,0 +1,31 @@
+import {
+  EnhancedSkillExecutor,
+  SkillRegistry,
+  SkillResourceManager,
+  SkillScriptExecutor,
+  builtInSkills,
+  builtInSkillsMap,
+  createSkillFromManifest,
+  echoSkill,
+  listSkillsSkill,
+  loadSkillFromDirectory,
+  mathSkill,
+  parseSkillMd,
+  validateManifest
+} from "../chunk-HXLRBB7S.js";
+export {
+  EnhancedSkillExecutor,
+  SkillRegistry,
+  SkillResourceManager,
+  SkillScriptExecutor,
+  builtInSkills,
+  builtInSkillsMap,
+  createSkillFromManifest,
+  echoSkill,
+  listSkillsSkill,
+  loadSkillFromDirectory,
+  mathSkill,
+  parseSkillMd,
+  validateManifest
+};
+//# sourceMappingURL=index.js.map

package/dist/node/skills/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/node/storage/index.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkJF33ZOMBcjs = require('../chunk-JF33ZOMB.cjs');
+
+
+
+
+
+
+exports.BrowserStorageAdapter = _chunkJF33ZOMBcjs.BrowserStorageAdapter; exports.NodeStorageAdapter = _chunkJF33ZOMBcjs.NodeStorageAdapter; exports.createStorage = _chunkJF33ZOMBcjs.createStorage; exports.getDefaultStorage = _chunkJF33ZOMBcjs.getDefaultStorage; exports.resetDefaultStorage = _chunkJF33ZOMBcjs.resetDefaultStorage;
+//# sourceMappingURL=index.cjs.map

package/dist/node/storage/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["d:\\sdkwork-opensource\\sdkwork-browser-agent\\dist\\node\\storage\\index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACF,0UAAC","file":"D:\\sdkwork-opensource\\sdkwork-browser-agent\\dist\\node\\storage\\index.cjs"}

package/dist/node/storage/index.d.cts

@@ -0,0 +1,64 @@
+import { S as StorageAdapter, a as StorageConfig, F as FileMetadata } from '../types-CG5I-byI.cjs';
+export { b as StorageAdapterFactory } from '../types-CG5I-byI.cjs';
+
+/**
+ * Browser Storage Adapter
+ * Uses IndexedDB for file-like storage and fetch for remote resources
+ */
+
+declare class BrowserStorageAdapter implements StorageAdapter {
+    readonly name = "browser";
+    readonly isAvailable: boolean;
+    private dbName;
+    private dbVersion;
+    private storeName;
+    private db;
+    constructor(config?: StorageConfig);
+    private getDB;
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    listDirectory(path: string): Promise<string[]>;
+    createDirectory(path: string): Promise<void>;
+    deleteDirectory(path: string): Promise<void>;
+    getMetadata(path: string): Promise<FileMetadata | null>;
+}
+
+/**
+ * Node.js Storage Adapter
+ * Uses native fs module for file operations
+ */
+
+declare class NodeStorageAdapter implements StorageAdapter {
+    private config;
+    readonly name = "node";
+    readonly isAvailable: boolean;
+    constructor(config?: StorageConfig);
+    private resolvePath;
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    listDirectory(path: string): Promise<string[]>;
+    createDirectory(path: string): Promise<void>;
+    deleteDirectory(path: string): Promise<void>;
+    getMetadata(path: string): Promise<FileMetadata | null>;
+}
+
+/**
+ * Storage Module
+ * Unified storage interface for browser and Node.js environments
+ */
+
+/**
+ * Create the appropriate storage adapter for the current environment
+ */
+declare function createStorage(config?: StorageConfig): StorageAdapter;
+declare function getDefaultStorage(config?: StorageConfig): StorageAdapter;
+/**
+ * Reset the default storage adapter (useful for testing)
+ */
+declare function resetDefaultStorage(): void;
+
+export { BrowserStorageAdapter, FileMetadata, NodeStorageAdapter, StorageAdapter, StorageConfig, createStorage, getDefaultStorage, resetDefaultStorage };

package/dist/node/storage/index.d.ts

@@ -0,0 +1,64 @@
+import { S as StorageAdapter, a as StorageConfig, F as FileMetadata } from '../types-CG5I-byI.js';
+export { b as StorageAdapterFactory } from '../types-CG5I-byI.js';
+
+/**
+ * Browser Storage Adapter
+ * Uses IndexedDB for file-like storage and fetch for remote resources
+ */
+
+declare class BrowserStorageAdapter implements StorageAdapter {
+    readonly name = "browser";
+    readonly isAvailable: boolean;
+    private dbName;
+    private dbVersion;
+    private storeName;
+    private db;
+    constructor(config?: StorageConfig);
+    private getDB;
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    listDirectory(path: string): Promise<string[]>;
+    createDirectory(path: string): Promise<void>;
+    deleteDirectory(path: string): Promise<void>;
+    getMetadata(path: string): Promise<FileMetadata | null>;
+}
+
+/**
+ * Node.js Storage Adapter
+ * Uses native fs module for file operations
+ */
+
+declare class NodeStorageAdapter implements StorageAdapter {
+    private config;
+    readonly name = "node";
+    readonly isAvailable: boolean;
+    constructor(config?: StorageConfig);
+    private resolvePath;
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    listDirectory(path: string): Promise<string[]>;
+    createDirectory(path: string): Promise<void>;
+    deleteDirectory(path: string): Promise<void>;
+    getMetadata(path: string): Promise<FileMetadata | null>;
+}
+
+/**
+ * Storage Module
+ * Unified storage interface for browser and Node.js environments
+ */
+
+/**
+ * Create the appropriate storage adapter for the current environment
+ */
+declare function createStorage(config?: StorageConfig): StorageAdapter;
+declare function getDefaultStorage(config?: StorageConfig): StorageAdapter;
+/**
+ * Reset the default storage adapter (useful for testing)
+ */
+declare function resetDefaultStorage(): void;
+
+export { BrowserStorageAdapter, FileMetadata, NodeStorageAdapter, StorageAdapter, StorageConfig, createStorage, getDefaultStorage, resetDefaultStorage };

package/dist/node/storage/index.js

@@ -0,0 +1,15 @@
+import {
+  BrowserStorageAdapter,
+  NodeStorageAdapter,
+  createStorage,
+  getDefaultStorage,
+  resetDefaultStorage
+} from "../chunk-CLP6UNSV.js";
+export {
+  BrowserStorageAdapter,
+  NodeStorageAdapter,
+  createStorage,
+  getDefaultStorage,
+  resetDefaultStorage
+};
+//# sourceMappingURL=index.js.map

package/dist/node/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/node/tools/index.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkKXXS33G3cjs = require('../chunk-KXXS33G3.cjs');
+
+
+
+
+
+
+exports.ToolRegistry = _chunkKXXS33G3cjs.ToolRegistry; exports.builtInTools = _chunkKXXS33G3cjs.builtInTools; exports.fileReadTool = _chunkKXXS33G3cjs.fileReadTool; exports.fileWriteTool = _chunkKXXS33G3cjs.fileWriteTool; exports.httpRequestTool = _chunkKXXS33G3cjs.httpRequestTool;
+//# sourceMappingURL=index.cjs.map

package/dist/node/tools/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["d:\\sdkwork-opensource\\sdkwork-browser-agent\\dist\\node\\tools\\index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACF,0RAAC","file":"D:\\sdkwork-opensource\\sdkwork-browser-agent\\dist\\node\\tools\\index.cjs"}

package/dist/node/tools/index.d.cts

@@ -0,0 +1,45 @@
+import { T as Tool, E as ExecutionContext, q as ToolOutput } from '../agent-kexkkI13.cjs';
+import '../provider-Dna36xA-.cjs';
+
+/**
+ * Tool Registry for managing and discovering tools
+ */
+
+interface ToolRegistryConfig {
+    autoDiscover?: boolean;
+    toolDirectory?: string;
+}
+declare class ToolRegistry {
+    private tools;
+    private categories;
+    constructor(_config?: ToolRegistryConfig);
+    register(tool: Tool): void;
+    unregister(name: string): boolean;
+    get(name: string): Tool | undefined;
+    has(name: string): boolean;
+    list(): Tool[];
+    listNames(): string[];
+    findByCategory(category: string): Tool[];
+    findByTag(tag: string): Tool[];
+    findByConfirmation(needsConfirmation: boolean): Tool[];
+    search(query: string): Tool[];
+    execute(name: string, input: unknown, context: ExecutionContext): Promise<ToolOutput>;
+    clear(): void;
+    getCategories(): string[];
+    getStats(): {
+        total: number;
+        categories: number;
+        requireConfirmation: number;
+    };
+}
+
+/**
+ * Built-in Tools
+ */
+
+declare const fileReadTool: Tool;
+declare const fileWriteTool: Tool;
+declare const httpRequestTool: Tool;
+declare const builtInTools: Tool[];
+
+export { ToolRegistry, type ToolRegistryConfig, builtInTools, fileReadTool, fileWriteTool, httpRequestTool };