@pulso/companion 0.1.5 → 0.1.6

package/dist/index.js

@@ -55,54 +55,101 @@ function runSwift(code, timeout = 1e4) {
     child.stdin?.end();
   });
 }
-var spotifyToken = null;
-var spotifyTokenExpiry = 0;
-async function getSpotifyToken() {
-  if (spotifyToken && Date.now() < spotifyTokenExpiry) return spotifyToken;
+var UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+var searchCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 7 * 24 * 3600 * 1e3;
+async function spotifySearch(query) {
+  const key = query.toLowerCase().trim();
+  const cached = searchCache.get(key);
+  if (cached && Date.now() - cached.ts < CACHE_TTL) {
+    return cached;
+  }
+  try {
+    const res = await fetch(
+      `${API_URL}/tools/spotify/search?q=${encodeURIComponent(query)}`,
+      { headers: { Authorization: `Bearer ${TOKEN}` } }
+    );
+    if (res.ok) {
+      const data = await res.json();
+      if (data.uri) {
+        searchCache.set(key, { ...data, ts: Date.now() });
+        return data;
+      }
+    }
+  } catch {
+  }
+  const trackIds = await searchBraveForSpotifyTracks(query);
+  if (trackIds.length === 0) return null;
+  const meta = await getTrackMetadata(trackIds[0]);
+  const result = {
+    uri: `spotify:track:${trackIds[0]}`,
+    name: meta?.name ?? query,
+    artist: meta?.artist ?? "Unknown"
+  };
+  searchCache.set(key, { ...result, ts: Date.now() });
+  pushToServerCache(query, result).catch(() => {
+  });
+  return result;
+}
+async function searchBraveForSpotifyTracks(query) {
   try {
-    const res = await fetch("https://open.spotify.com/embed/track/4u7EnebtmKWzUH433cf5Qv", {
-      headers: { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36" }
+    const searchQuery = `spotify track ${query} site:open.spotify.com`;
+    const url = `https://search.brave.com/search?q=${encodeURIComponent(searchQuery)}&source=web`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 8e3);
+    const res = await fetch(url, {
+      headers: { "User-Agent": UA, Accept: "text/html" },
+      signal: controller.signal
     });
+    clearTimeout(timeout);
+    if (!res.ok) return [];
     const html = await res.text();
-    const match = html.match(/"accessToken":"([^"]+)"/);
-    if (!match) return null;
-    spotifyToken = match[1];
-    spotifyTokenExpiry = Date.now() + 55 * 60 * 1e3;
-    return spotifyToken;
+    const trackIds = /* @__PURE__ */ new Set();
+    for (const m of html.matchAll(/https?:\/\/open\.spotify\.com\/track\/([a-zA-Z0-9]{22})/g)) {
+      trackIds.add(m[1]);
+    }
+    return [...trackIds];
   } catch {
-    return null;
+    return [];
   }
 }
-async function spotifySearch(query) {
-  const token = await getSpotifyToken();
-  if (!token) return null;
+async function getTrackMetadata(trackId) {
   try {
-    const res = await fetch(
-      `https://api.spotify.com/v1/search?q=${encodeURIComponent(query)}&type=track&limit=1`,
-      { headers: { Authorization: `Bearer ${token}` } }
-    );
-    if (!res.ok) {
-      if (res.status === 401) {
-        spotifyToken = null;
-        spotifyTokenExpiry = 0;
-        const newToken = await getSpotifyToken();
-        if (!newToken) return null;
-        const retry = await fetch(
-          `https://api.spotify.com/v1/search?q=${encodeURIComponent(query)}&type=track&limit=1`,
-          { headers: { Authorization: `Bearer ${newToken}` } }
-        );
-        if (!retry.ok) return null;
-        const retryData = await retry.json();
-        return retryData.tracks?.items?.[0]?.uri ?? null;
-      }
-      return null;
-    }
-    const data = await res.json();
-    return data.tracks?.items?.[0]?.uri ?? null;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`https://open.spotify.com/embed/track/${trackId}`, {
+      headers: { "User-Agent": UA, Accept: "text/html" },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const html = await res.text();
+    const scriptMatch = html.match(/<script[^>]*>(\{"props":\{"pageProps".*?\})<\/script>/s);
+    if (!scriptMatch) return null;
+    const data = JSON.parse(scriptMatch[1]);
+    const entity = data?.props?.pageProps?.state?.data?.entity;
+    if (!entity?.name) return null;
+    return {
+      name: entity.name,
+      artist: entity.artists?.map((a) => a.name).join(", ") ?? "Unknown"
+    };
   } catch {
     return null;
   }
 }
+async function pushToServerCache(query, result) {
+  try {
+    await fetch(`${API_URL}/tools/spotify/cache`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TOKEN}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query, ...result })
+    });
+  } catch {
+  }
+}
 async function handleCommand(command, params) {
   try {
     switch (command) {
@@ -170,20 +217,36 @@ async function handleCommand(command, params) {
           case "search_play": {
             const query = params.query;
             if (!query) return { success: false, error: "Missing search query" };
-            const trackUri = await spotifySearch(query);
-            if (trackUri) {
-              await runAppleScript(`tell application "Spotify" to play track "${trackUri}"`);
+            const result = await spotifySearch(query);
+            if (result) {
+              await runAppleScript(`tell application "Spotify" to play track "${result.uri}"`);
               await new Promise((r) => setTimeout(r, 1500));
               try {
                 const track = await runAppleScript('tell application "Spotify" to name of current track');
                 const artist = await runAppleScript('tell application "Spotify" to artist of current track');
-                return { success: true, data: { searched: query, nowPlaying: `${track} - ${artist}`, state: "playing" } };
+                const state = await runAppleScript('tell application "Spotify" to player state as string');
+                return {
+                  success: true,
+                  data: {
+                    searched: query,
+                    resolved: `${result.name} - ${result.artist}`,
+                    nowPlaying: `${track} - ${artist}`,
+                    state
+                  }
+                };
               } catch {
-                return { success: true, data: { searched: query, note: "Playing track" } };
+                return { success: true, data: { searched: query, resolved: `${result.name} - ${result.artist}`, note: "Playing track" } };
               }
             }
             await runShell(`open "spotify:search:${encodeURIComponent(query)}"`);
-            return { success: true, data: { searched: query, note: "Opened Spotify search (API unavailable). Select a song to play." } };
+            return {
+              success: true,
+              data: {
+                searched: query,
+                note: "Search engine unavailable. Opened Spotify search \u2014 use computer-use (screenshot + click) to select the correct song.",
+                requiresComputerUse: true
+              }
+            };
           }
           case "volume": {
             const level = params.level;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulso/companion",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "description": "Pulso Companion — gives your AI agent real control over your computer",
   "bin": {