apexbot 1.0.4 → 1.0.5

package/dist/cli/index.js

@@ -864,12 +864,15 @@ program
                 }
             }
             catch (e) {
-                console.log(chalk.yellow('Gateway not running. Available skills:'));
+                console.log(chalk.yellow('Gateway not running or error connecting.'));
+                console.log(chalk.gray(`(${e.message || 'Connection refused'})\n`));
+                console.log('Available skills:');
                 console.log('');
                 console.log('  - obsidian   Obsidian note-taking integration');
                 console.log('  - weather    Weather forecasts');
                 console.log('  - reminder   Reminders and timers');
                 console.log('  - system     System info and process management');
+                console.log('  - spotify    Spotify music playback control');
                 console.log('');
             }
             break;
@@ -925,13 +928,16 @@ program
         }
     }
     catch (e) {
-        console.log(chalk.yellow('Gateway not running. Built-in tools:'));
+        console.log(chalk.yellow('Gateway not running or error connecting.'));
+        console.log(chalk.gray(`(${e.message || 'Connection refused'})\n`));
+        console.log('Built-in tools:');
         console.log('');
         console.log('  CORE');
         console.log('    shell         Execute shell commands');
         console.log('    read_file     Read file contents');
         console.log('    write_file    Write to files');
         console.log('    list_dir      List directory contents');
+        console.log('    delete_file   Delete files/directories');
         console.log('    edit_file     Edit files (search/replace)');
         console.log('    fetch_url     Fetch web pages');
         console.log('    web_search    Search the web');
@@ -939,6 +945,13 @@ program
         console.log('    math          Mathematical calculations');
         console.log('    convert       Unit conversions');
         console.log('');
+        console.log('  SKILLS (when enabled)');
+        console.log('    obsidian_*    Obsidian notes');
+        console.log('    weather       Weather forecasts');
+        console.log('    reminder_*    Reminders & timers');
+        console.log('    system_*      System info');
+        console.log('    spotify_*     Spotify control');
+        console.log('');
     }
 });
 // ─────────────────────────────────────────────────────────────────

package/dist/skills/spotify.js

@@ -0,0 +1,611 @@
+"use strict";
+/**
+ * Spotify Skill
+ *
+ * Integration with Spotify for music playback control.
+ * Uses Spotify Web API - requires user authentication via OAuth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// Spotify API state
+let accessToken = '';
+let refreshToken = '';
+let clientId = '';
+let clientSecret = '';
+let tokenExpiry = 0;
+const SPOTIFY_API = 'https://api.spotify.com/v1';
+const SPOTIFY_ACCOUNTS = 'https://accounts.spotify.com';
+async function refreshAccessToken() {
+    if (!refreshToken || !clientId || !clientSecret) {
+        return false;
+    }
+    try {
+        const res = await fetch(`${SPOTIFY_ACCOUNTS}/api/token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Authorization': 'Basic ' + Buffer.from(`${clientId}:${clientSecret}`).toString('base64'),
+            },
+            body: `grant_type=refresh_token&refresh_token=${refreshToken}`,
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        accessToken = data.access_token;
+        tokenExpiry = Date.now() + (data.expires_in * 1000);
+        if (data.refresh_token) {
+            refreshToken = data.refresh_token;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function spotifyFetch(endpoint, options = {}) {
+    // Check if token needs refresh
+    if (Date.now() >= tokenExpiry - 60000) {
+        await refreshAccessToken();
+    }
+    if (!accessToken) {
+        throw new Error('Spotify not authenticated. Please configure your Spotify credentials.');
+    }
+    const res = await fetch(`${SPOTIFY_API}${endpoint}`, {
+        ...options,
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+    });
+    if (res.status === 401) {
+        // Try refresh
+        if (await refreshAccessToken()) {
+            return spotifyFetch(endpoint, options);
+        }
+        throw new Error('Spotify authentication expired. Please re-authenticate.');
+    }
+    if (!res.ok) {
+        const error = await res.json().catch(() => ({}));
+        throw new Error(error.error?.message || `Spotify API error: ${res.status}`);
+    }
+    // Handle empty responses
+    if (res.status === 204) {
+        return { success: true };
+    }
+    return res.json();
+}
+// ─────────────────────────────────────────────────────────────────
+// Spotify Tools
+// ─────────────────────────────────────────────────────────────────
+const spotifyNowPlayingTool = {
+    definition: {
+        name: 'spotify_now_playing',
+        description: 'Get the currently playing track on Spotify.',
+        category: 'media',
+        parameters: [],
+        returns: 'Current track info',
+    },
+    async execute(params, context) {
+        try {
+            const data = await spotifyFetch('/me/player/currently-playing');
+            if (!data || !data.item) {
+                return {
+                    success: true,
+                    data: { playing: false, message: 'Nothing is currently playing' },
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    playing: data.is_playing,
+                    track: data.item.name,
+                    artist: data.item.artists.map((a) => a.name).join(', '),
+                    album: data.item.album.name,
+                    duration: Math.floor(data.item.duration_ms / 1000),
+                    progress: Math.floor(data.progress_ms / 1000),
+                    url: data.item.external_urls.spotify,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPlayTool = {
+    definition: {
+        name: 'spotify_play',
+        description: 'Play music on Spotify. Can play a specific track, album, playlist, or resume playback.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                description: 'Search query for track, album, or playlist (optional - omit to resume)',
+                required: false,
+            },
+            {
+                name: 'type',
+                type: 'string',
+                description: 'Type to search: track, album, playlist, artist',
+                required: false,
+                default: 'track',
+                enum: ['track', 'album', 'playlist', 'artist'],
+            },
+        ],
+        returns: 'Playback status',
+        examples: [
+            'spotify_play() - Resume playback',
+            'spotify_play({ query: "Bohemian Rhapsody" })',
+            'spotify_play({ query: "Chill Vibes", type: "playlist" })',
+        ],
+    },
+    async execute(params, context) {
+        try {
+            const { query, type = 'track' } = params;
+            if (!query) {
+                // Resume playback
+                await spotifyFetch('/me/player/play', { method: 'PUT' });
+                return {
+                    success: true,
+                    data: { action: 'resumed', message: 'Playback resumed' },
+                };
+            }
+            // Search for content
+            const searchResult = await spotifyFetch(`/search?q=${encodeURIComponent(query)}&type=${type}&limit=1`);
+            const items = searchResult[`${type}s`]?.items;
+            if (!items || items.length === 0) {
+                return { success: false, error: `No ${type} found for: ${query}` };
+            }
+            const item = items[0];
+            let body = {};
+            if (type === 'track') {
+                body = { uris: [item.uri] };
+            }
+            else {
+                body = { context_uri: item.uri };
+            }
+            await spotifyFetch('/me/player/play', {
+                method: 'PUT',
+                body: JSON.stringify(body),
+            });
+            return {
+                success: true,
+                data: {
+                    action: 'playing',
+                    type,
+                    name: item.name,
+                    artist: item.artists?.[0]?.name || item.owner?.display_name,
+                    url: item.external_urls.spotify,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPauseTool = {
+    definition: {
+        name: 'spotify_pause',
+        description: 'Pause Spotify playback.',
+        category: 'media',
+        parameters: [],
+        returns: 'Pause confirmation',
+    },
+    async execute(params, context) {
+        try {
+            await spotifyFetch('/me/player/pause', { method: 'PUT' });
+            return {
+                success: true,
+                data: { action: 'paused', message: 'Playback paused' },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyNextTool = {
+    definition: {
+        name: 'spotify_next',
+        description: 'Skip to the next track.',
+        category: 'media',
+        parameters: [],
+        returns: 'Skip confirmation',
+    },
+    async execute(params, context) {
+        try {
+            await spotifyFetch('/me/player/next', { method: 'POST' });
+            return {
+                success: true,
+                data: { action: 'skipped', message: 'Skipped to next track' },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPreviousTool = {
+    definition: {
+        name: 'spotify_previous',
+        description: 'Go back to the previous track.',
+        category: 'media',
+        parameters: [],
+        returns: 'Previous confirmation',
+    },
+    async execute(params, context) {
+        try {
+            await spotifyFetch('/me/player/previous', { method: 'POST' });
+            return {
+                success: true,
+                data: { action: 'previous', message: 'Playing previous track' },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyVolumeTool = {
+    definition: {
+        name: 'spotify_volume',
+        description: 'Set Spotify playback volume.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'volume',
+                type: 'number',
+                description: 'Volume level (0-100)',
+                required: true,
+            },
+        ],
+        returns: 'Volume confirmation',
+    },
+    async execute(params, context) {
+        try {
+            const { volume } = params;
+            const level = Math.max(0, Math.min(100, volume));
+            await spotifyFetch(`/me/player/volume?volume_percent=${level}`, { method: 'PUT' });
+            return {
+                success: true,
+                data: { action: 'volume', level, message: `Volume set to ${level}%` },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifySearchTool = {
+    definition: {
+        name: 'spotify_search',
+        description: 'Search Spotify for tracks, albums, artists, or playlists.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                description: 'Search query',
+                required: true,
+            },
+            {
+                name: 'type',
+                type: 'string',
+                description: 'Type to search: track, album, artist, playlist',
+                required: false,
+                default: 'track',
+                enum: ['track', 'album', 'artist', 'playlist'],
+            },
+            {
+                name: 'limit',
+                type: 'number',
+                description: 'Number of results (default: 5)',
+                required: false,
+                default: 5,
+            },
+        ],
+        returns: 'Search results',
+    },
+    async execute(params, context) {
+        try {
+            const { query, type = 'track', limit = 5 } = params;
+            const data = await spotifyFetch(`/search?q=${encodeURIComponent(query)}&type=${type}&limit=${limit}`);
+            const items = data[`${type}s`]?.items || [];
+            const results = items.map((item) => ({
+                name: item.name,
+                artist: item.artists?.[0]?.name || item.owner?.display_name,
+                album: item.album?.name,
+                url: item.external_urls.spotify,
+                uri: item.uri,
+            }));
+            return {
+                success: true,
+                data: {
+                    query,
+                    type,
+                    results,
+                    count: results.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPlaylistsTool = {
+    definition: {
+        name: 'spotify_playlists',
+        description: 'Get your Spotify playlists.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'limit',
+                type: 'number',
+                description: 'Number of playlists (default: 20)',
+                required: false,
+                default: 20,
+            },
+        ],
+        returns: 'List of playlists',
+    },
+    async execute(params, context) {
+        try {
+            const { limit = 20 } = params;
+            const data = await spotifyFetch(`/me/playlists?limit=${limit}`);
+            const playlists = data.items.map((p) => ({
+                name: p.name,
+                tracks: p.tracks.total,
+                owner: p.owner.display_name,
+                public: p.public,
+                url: p.external_urls.spotify,
+                uri: p.uri,
+            }));
+            return {
+                success: true,
+                data: {
+                    playlists,
+                    count: playlists.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyCreatePlaylistTool = {
+    definition: {
+        name: 'spotify_create_playlist',
+        description: 'Create a new Spotify playlist.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'name',
+                type: 'string',
+                description: 'Playlist name',
+                required: true,
+            },
+            {
+                name: 'description',
+                type: 'string',
+                description: 'Playlist description',
+                required: false,
+            },
+            {
+                name: 'public',
+                type: 'boolean',
+                description: 'Make playlist public',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Created playlist info',
+    },
+    async execute(params, context) {
+        try {
+            const { name, description, public: isPublic = false } = params;
+            // Get user ID first
+            const user = await spotifyFetch('/me');
+            const playlist = await spotifyFetch(`/users/${user.id}/playlists`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    name,
+                    description: description || '',
+                    public: isPublic,
+                }),
+            });
+            return {
+                success: true,
+                data: {
+                    action: 'created',
+                    name: playlist.name,
+                    id: playlist.id,
+                    url: playlist.external_urls.spotify,
+                    uri: playlist.uri,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyAddToPlaylistTool = {
+    definition: {
+        name: 'spotify_add_to_playlist',
+        description: 'Add tracks to a playlist.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'playlist',
+                type: 'string',
+                description: 'Playlist name or ID',
+                required: true,
+            },
+            {
+                name: 'tracks',
+                type: 'string',
+                description: 'Track name to search and add, or track URI',
+                required: true,
+            },
+        ],
+        returns: 'Add confirmation',
+    },
+    async execute(params, context) {
+        try {
+            const { playlist, tracks } = params;
+            // Find playlist
+            let playlistId = playlist;
+            if (!playlist.startsWith('spotify:playlist:')) {
+                const playlists = await spotifyFetch('/me/playlists?limit=50');
+                const found = playlists.items.find((p) => p.name.toLowerCase() === playlist.toLowerCase() || p.id === playlist);
+                if (!found) {
+                    return { success: false, error: `Playlist not found: ${playlist}` };
+                }
+                playlistId = found.id;
+            }
+            else {
+                playlistId = playlist.replace('spotify:playlist:', '');
+            }
+            // Find track if not URI
+            let trackUri = tracks;
+            if (!tracks.startsWith('spotify:track:')) {
+                const search = await spotifyFetch(`/search?q=${encodeURIComponent(tracks)}&type=track&limit=1`);
+                const track = search.tracks?.items?.[0];
+                if (!track) {
+                    return { success: false, error: `Track not found: ${tracks}` };
+                }
+                trackUri = track.uri;
+            }
+            await spotifyFetch(`/playlists/${playlistId}/tracks`, {
+                method: 'POST',
+                body: JSON.stringify({ uris: [trackUri] }),
+            });
+            return {
+                success: true,
+                data: {
+                    action: 'added',
+                    playlist: playlistId,
+                    track: trackUri,
+                    message: 'Track added to playlist',
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyDevicesTool = {
+    definition: {
+        name: 'spotify_devices',
+        description: 'List available Spotify playback devices.',
+        category: 'media',
+        parameters: [],
+        returns: 'List of devices',
+    },
+    async execute(params, context) {
+        try {
+            const data = await spotifyFetch('/me/player/devices');
+            const devices = data.devices.map((d) => ({
+                name: d.name,
+                type: d.type,
+                active: d.is_active,
+                volume: d.volume_percent,
+                id: d.id,
+            }));
+            return {
+                success: true,
+                data: {
+                    devices,
+                    count: devices.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+// ─────────────────────────────────────────────────────────────────
+// Skill Definition
+// ─────────────────────────────────────────────────────────────────
+const manifest = {
+    name: 'spotify',
+    version: '1.0.0',
+    description: 'Spotify music playback control and playlist management',
+    category: 'media',
+    icon: 'music',
+    homepage: 'https://developer.spotify.com/documentation/web-api',
+    tools: [
+        'spotify_now_playing',
+        'spotify_play',
+        'spotify_pause',
+        'spotify_next',
+        'spotify_previous',
+        'spotify_volume',
+        'spotify_search',
+        'spotify_playlists',
+        'spotify_create_playlist',
+        'spotify_add_to_playlist',
+        'spotify_devices',
+    ],
+    config: [
+        {
+            name: 'clientId',
+            type: 'string',
+            description: 'Spotify App Client ID (from developer.spotify.com)',
+            required: true,
+        },
+        {
+            name: 'clientSecret',
+            type: 'secret',
+            description: 'Spotify App Client Secret',
+            required: true,
+        },
+        {
+            name: 'refreshToken',
+            type: 'secret',
+            description: 'Spotify OAuth Refresh Token',
+            required: true,
+        },
+    ],
+    permissions: ['user-read-playback-state', 'user-modify-playback-state', 'playlist-read-private', 'playlist-modify-public', 'playlist-modify-private'],
+};
+const spotifySkill = {
+    manifest,
+    tools: [
+        spotifyNowPlayingTool,
+        spotifyPlayTool,
+        spotifyPauseTool,
+        spotifyNextTool,
+        spotifyPreviousTool,
+        spotifyVolumeTool,
+        spotifySearchTool,
+        spotifyPlaylistsTool,
+        spotifyCreatePlaylistTool,
+        spotifyAddToPlaylistTool,
+        spotifyDevicesTool,
+    ],
+    async initialize(config) {
+        clientId = config.clientId || process.env.SPOTIFY_CLIENT_ID || '';
+        clientSecret = config.clientSecret || process.env.SPOTIFY_CLIENT_SECRET || '';
+        refreshToken = config.refreshToken || process.env.SPOTIFY_REFRESH_TOKEN || '';
+        if (clientId && clientSecret && refreshToken) {
+            await refreshAccessToken();
+            console.log('[Spotify] Initialized and authenticated');
+        }
+        else {
+            console.log('[Spotify] Initialized (credentials not configured)');
+        }
+    },
+    async shutdown() {
+        accessToken = '';
+        refreshToken = '';
+        console.log('[Spotify] Shutdown');
+    },
+};
+exports.default = spotifySkill;

package/dist/tools/loader.js

@@ -24,6 +24,7 @@ const obsidian_1 = __importDefault(require("../skills/obsidian"));
 const weather_1 = __importDefault(require("../skills/weather"));
 const reminder_1 = __importDefault(require("../skills/reminder"));
 const system_1 = __importDefault(require("../skills/system"));
+const spotify_1 = __importDefault(require("../skills/spotify"));
 /**
  * Register all built-in tools
  */
@@ -49,6 +50,7 @@ async function registerSkills(configDir) {
     skillManager.register(weather_1.default);
     skillManager.register(reminder_1.default);
     skillManager.register(system_1.default);
+    skillManager.register(spotify_1.default);
     // Initialize enabled skills
     await skillManager.initializeEnabled();
     console.log(`[Loader] Registered ${skillManager.list().length} skills`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apexbot",
-  "version": "1.0.4",
-  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Tools & Skills system like Clawdbot!",
+  "version": "1.0.5",
+  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Tools & Skills system with Spotify, Obsidian, and more!",
   "main": "dist/index.js",
   "bin": {
     "apexbot": "./dist/cli/index.js"