@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/sinafinance/stock.js

@@ -0,0 +1,117 @@
+/**
+ * Sinafinance stock quote — A股 / 港股 / 美股
+ *
+ * Uses two public Sina APIs (no browser required):
+ *   suggest3.sinajs.cn  — symbol search
+ *   hq.sinajs.cn        — real-time quote
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+const MARKET_CN = '11';
+const MARKET_HK = '31';
+const MARKET_US = '41';
+async function fetchGBK(url) {
+    const res = await fetch(url, { headers: { Referer: 'https://finance.sina.com.cn' } });
+    if (!res.ok)
+        throw new CliError('FETCH_ERROR', `Sina API HTTP ${res.status}`, 'Check your network');
+    const buf = await res.arrayBuffer();
+    return new TextDecoder('gbk').decode(buf);
+}
+function parseSuggest(raw, markets) {
+    const m = raw.match(/suggestvalue="(.*)"/s);
+    if (!m)
+        return [];
+    return m[1].split(';').filter(Boolean).map(s => {
+        const p = s.split(',');
+        return { name: p[4] || p[0] || '', market: p[1] || '', symbol: p[3] || '' };
+    }).filter(e => markets.includes(e.market));
+}
+function hqSymbol(e) {
+    if (e.market === MARKET_HK)
+        return `hk${e.symbol}`;
+    if (e.market === MARKET_US)
+        return `gb_${e.symbol}`;
+    return e.symbol; // A股: already "sh600519" / "sz300XXX"
+}
+function parseHq(raw, sym) {
+    const escaped = sym.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const m = raw.match(new RegExp(`hq_str_${escaped}="([^"]*)"`));
+    return m ? m[1].split(',') : [];
+}
+function fmtMktCap(val) {
+    const n = parseFloat(val);
+    if (!n)
+        return '';
+    if (n >= 1e12)
+        return (n / 1e12).toFixed(2) + 'T';
+    if (n >= 1e9)
+        return (n / 1e9).toFixed(2) + 'B';
+    if (n >= 1e6)
+        return (n / 1e6).toFixed(2) + 'M';
+    return String(n);
+}
+cli({
+    site: 'sinafinance',
+    name: 'stock',
+    description: '新浪财经行情（A股/港股/美股）',
+    domain: 'suggest3.sinajs.cn,hq.sinajs.cn',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'key', type: 'string', required: true, positional: true, help: 'Stock name or code (e.g. 贵州茅台, 腾讯控股, AAPL)' },
+        { name: 'market', type: 'string', default: 'auto', help: 'Market: cn, hk, us, auto (default: auto searches cn → hk → us)' },
+    ],
+    columns: ['Symbol', 'Name', 'Price', 'Change', 'ChangePercent', 'Open', 'High', 'Low', 'Volume', 'MarketCap'],
+    func: async (_page, args) => {
+        const key = String(args.key);
+        const market = String(args.market);
+        const marketMap = {
+            cn: [MARKET_CN], hk: [MARKET_HK], us: [MARKET_US],
+            auto: [MARKET_CN, MARKET_HK, MARKET_US],
+        };
+        const targetMarkets = marketMap[market];
+        if (!targetMarkets) {
+            throw new CliError('INPUT_ERROR', `Invalid market: "${market}"`, 'Expected cn, hk, us, or auto');
+        }
+        // 1. Search symbol — only request the markets we care about
+        const suggestRaw = await fetchGBK(`https://suggest3.sinajs.cn/suggest/type=${targetMarkets.join(',')}&key=${encodeURIComponent(key)}`);
+        const entries = parseSuggest(suggestRaw, targetMarkets);
+        if (!entries.length) {
+            throw new CliError('NOT_FOUND', `No stock found for "${key}"`, 'Try a different name, code, or --market');
+        }
+        // Pick best match: score by name similarity, tiebreak by market priority
+        const needle = key.toLowerCase();
+        const score = (e) => {
+            const n = e.name.toLowerCase();
+            if (n === needle)
+                return 1;
+            if (n.includes(needle))
+                return needle.length / n.length;
+            return 0;
+        };
+        const best = entries.sort((a, b) => {
+            const d = score(b) - score(a);
+            return d !== 0 ? d : targetMarkets.indexOf(a.market) - targetMarkets.indexOf(b.market);
+        })[0];
+        // 2. Fetch quote
+        const sym = hqSymbol(best);
+        const hqRaw = await fetchGBK(`https://hq.sinajs.cn/list=${sym}`);
+        const f = parseHq(hqRaw, sym);
+        if (f.length < 2 || !f[0]) {
+            throw new CliError('NOT_FOUND', `No quote data for "${key}"`, 'Market may be closed or data unavailable');
+        }
+        if (best.market === MARKET_CN) {
+            const price = parseFloat(f[3]);
+            const prev = parseFloat(f[2]);
+            const chg = (price - prev).toFixed(2);
+            const chgPct = ((price - prev) / prev * 100).toFixed(2) + '%';
+            return [{ Symbol: sym.toUpperCase(), Name: f[0], Price: f[3], Change: chg, ChangePercent: chgPct, Open: f[1], High: f[4], Low: f[5], Volume: f[8], MarketCap: '' }];
+        }
+        if (best.market === MARKET_HK) {
+            // [2]=price [4]=high [5]=low [6]=open [7]=change [8]=change% [11]=volume
+            return [{ Symbol: best.symbol, Name: f[1], Price: f[2], Change: f[7], ChangePercent: f[8] + '%', Open: f[6], High: f[4], Low: f[5], Volume: f[11], MarketCap: '' }];
+        }
+        // MARKET_US: [1]=price [2]=change% [4]=change [6]=open [7]=today_low [8]=52wH [9]=52wL [10]=volume [12]=mktcap
+        return [{ Symbol: best.symbol.toUpperCase(), Name: f[0], Price: f[1], Change: f[4], ChangePercent: f[2] + '%', Open: f[6], High: f[8], Low: f[9], Volume: f[10], MarketCap: fmtMktCap(f[12]) }];
+    },
+});

package/vendor/opencli/dist/clis/smzdm/search.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/smzdm/search.js

@@ -0,0 +1,54 @@
+/**
+ * 什么值得买搜索好价 — browser cookie, DOM scraping.
+ *
+ * Fix: The old adapter used `search.smzdm.com/ajax/` which returns 404.
+ * New approach: navigate to `search.smzdm.com/?c=home&s=<keyword>&v=b`
+ * and scrape the rendered DOM directly.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'smzdm',
+    name: 'search',
+    description: '什么值得买搜索好价',
+    domain: 'www.smzdm.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Search keyword' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'price', 'mall', 'comments', 'url'],
+    func: async (page, kwargs) => {
+        const q = encodeURIComponent(kwargs.query);
+        const limit = kwargs.limit || 20;
+        // Navigate directly to search results page
+        await page.goto(`https://search.smzdm.com/?c=home&s=${q}&v=b`);
+        const data = await page.evaluate(`
+      (() => {
+        const limit = ${limit};
+        const items = document.querySelectorAll('li.feed-row-wide');
+        const results = [];
+        items.forEach((li) => {
+          if (results.length >= limit) return;
+          const titleEl = li.querySelector('h5.feed-block-title > a')
+                       || li.querySelector('h5 > a');
+          if (!titleEl) return;
+          const title = (titleEl.getAttribute('title') || titleEl.textContent || '').trim();
+          const url = titleEl.getAttribute('href') || titleEl.href || '';
+          const priceEl = li.querySelector('.z-highlight');
+          const price = priceEl ? priceEl.textContent.trim() : '';
+          let mall = '';
+          const mallEl = li.querySelector('.z-feed-foot-r .feed-block-extras span')
+                      || li.querySelector('.z-feed-foot-r span');
+          if (mallEl) mall = mallEl.textContent.trim();
+          const commentEl = li.querySelector('.feed-btn-comment');
+          const comments = commentEl ? parseInt(commentEl.textContent.trim()) || 0 : 0;
+          results.push({ rank: results.length + 1, title, price, mall, comments, url });
+        });
+        return results;
+      })()
+    `);
+        if (!Array.isArray(data))
+            return [];
+        return data;
+    },
+});

package/vendor/opencli/dist/clis/spotify/spotify.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/spotify/spotify.js

@@ -0,0 +1,316 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { createServer } from 'http';
+import { homedir } from 'os';
+import { join } from 'path';
+import { exec } from 'child_process';
+import { assertSpotifyCredentialsConfigured, getFirstSpotifyTrack, mapSpotifyTrackResults, parseDotEnv, resolveSpotifyCredentials, } from './utils.js';
+// ── Credentials ───────────────────────────────────────────────────────────────
+// Set SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET as environment variables,
+// or place them in ~/.opencli/spotify.env:
+//   SPOTIFY_CLIENT_ID=your_id
+//   SPOTIFY_CLIENT_SECRET=your_secret
+const ENV_FILE = join(homedir(), '.opencli', 'spotify.env');
+function loadEnv() {
+    if (!existsSync(ENV_FILE))
+        return {};
+    return parseDotEnv(readFileSync(ENV_FILE, 'utf-8'));
+}
+const env = loadEnv();
+const credentials = resolveSpotifyCredentials(env);
+const CLIENT_ID = credentials.clientId;
+const CLIENT_SECRET = credentials.clientSecret;
+const REDIRECT_URI = 'http://127.0.0.1:8888/callback';
+const SCOPES = [
+    'user-read-playback-state',
+    'user-modify-playback-state',
+    'user-read-currently-playing',
+    'playlist-read-private',
+].join(' ');
+// ── Token storage ─────────────────────────────────────────────────────────────
+const TOKEN_FILE = join(homedir(), '.opencli', 'spotify-tokens.json');
+function loadTokens() {
+    try {
+        return JSON.parse(readFileSync(TOKEN_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveTokens(tokens) {
+    mkdirSync(join(homedir(), '.opencli'), { recursive: true });
+    writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2));
+}
+async function refreshAccessToken(refreshToken) {
+    const res = await fetch('https://accounts.spotify.com/api/token', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: 'Basic ' + Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64'),
+        },
+        body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken }),
+    });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new CliError('REFRESH_FAILED', err?.error_description || `Token refresh failed (${res.status})`);
+    }
+    const data = await res.json();
+    const tokens = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token || refreshToken,
+        expires_at: Date.now() + data.expires_in * 1000,
+    };
+    saveTokens(tokens);
+    return tokens.access_token;
+}
+async function getToken() {
+    const tokens = loadTokens();
+    if (!tokens)
+        throw new CliError('AUTH_REQUIRED', 'Not authenticated. Run: opencli spotify auth');
+    if (!tokens.access_token || !tokens.refresh_token || !(tokens.expires_at > 0)) {
+        throw new CliError('AUTH_CORRUPTED', 'Token file is corrupted. Run: opencli spotify auth');
+    }
+    if (Date.now() > tokens.expires_at - 60_000)
+        return refreshAccessToken(tokens.refresh_token);
+    return tokens.access_token;
+}
+// ── Spotify API helper ────────────────────────────────────────────────────────
+async function api(method, path, body) {
+    const token = await getToken();
+    const res = await fetch(`https://api.spotify.com/v1${path}`, {
+        method,
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (res.status === 204 || res.status === 202)
+        return null;
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new CliError('API_ERROR', err?.error?.message || `Spotify API error ${res.status}`);
+    }
+    return res.json();
+}
+async function findTrackUri(query) {
+    const data = await api('GET', `/search?q=${encodeURIComponent(query)}&type=track&limit=1`);
+    const track = getFirstSpotifyTrack(data);
+    if (!track)
+        throw new CliError('EMPTY_RESULT', `No track found for: ${query}`);
+    return track;
+}
+function openBrowser(url) {
+    const cmd = process.platform === 'win32' ? `start "" "${url}"` : process.platform === 'darwin' ? `open "${url}"` : `xdg-open "${url}"`;
+    exec(cmd);
+}
+// ── Commands ──────────────────────────────────────────────────────────────────
+cli({
+    site: 'spotify',
+    name: 'auth',
+    description: 'Authenticate with Spotify (OAuth — run once)',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['status'],
+    func: async () => {
+        assertSpotifyCredentialsConfigured(credentials, ENV_FILE);
+        return new Promise((resolve, reject) => {
+            const server = createServer(async (req, res) => {
+                try {
+                    const url = new URL(req.url, 'http://localhost:8888');
+                    if (url.pathname !== '/callback') {
+                        res.end();
+                        return;
+                    }
+                    const code = url.searchParams.get('code');
+                    if (!code) {
+                        res.end('Missing code');
+                        return;
+                    }
+                    const tokenRes = await fetch('https://accounts.spotify.com/api/token', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/x-www-form-urlencoded',
+                            Authorization: 'Basic ' + Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64'),
+                        },
+                        body: new URLSearchParams({ grant_type: 'authorization_code', code, redirect_uri: REDIRECT_URI }),
+                    });
+                    if (!tokenRes.ok) {
+                        const err = await tokenRes.json().catch(() => ({}));
+                        server.close();
+                        reject(new CliError('AUTH_FAILED', err?.error_description || `Token exchange failed (${tokenRes.status})`));
+                        return;
+                    }
+                    const data = await tokenRes.json();
+                    saveTokens({ access_token: data.access_token, refresh_token: data.refresh_token, expires_at: Date.now() + data.expires_in * 1000 });
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end('<h2>Spotify authenticated! You can close this tab.</h2>');
+                    server.close();
+                    resolve([{ status: 'Authenticated successfully' }]);
+                }
+                catch (e) {
+                    server.close();
+                    reject(e);
+                }
+            });
+            server.on('error', (e) => {
+                if (e.code === 'EADDRINUSE')
+                    reject(new CliError('PORT_IN_USE', 'Port 8888 is already in use. Stop the other process and retry.'));
+                else
+                    reject(e);
+            });
+            const timeout = setTimeout(() => { server.close(); reject(new CliError('AUTH_TIMEOUT', 'Authentication timed out after 5 minutes')); }, 5 * 60 * 1000);
+            server.listen(8888, () => {
+                const authUrl = `https://accounts.spotify.com/authorize?${new URLSearchParams({ client_id: CLIENT_ID, response_type: 'code', redirect_uri: REDIRECT_URI, scope: SCOPES })}`;
+                console.log('Opening browser for Spotify login...');
+                console.log('If it does not open, visit:', authUrl);
+                openBrowser(authUrl);
+            });
+            server.on('close', () => clearTimeout(timeout));
+        });
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'status',
+    description: 'Show current playback status',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['track', 'artist', 'album', 'status', 'progress'],
+    func: async () => {
+        const data = await api('GET', '/me/player');
+        if (!data || !data.item)
+            return [{ track: 'Nothing playing', artist: '', album: '', status: '', progress: '' }];
+        const t = data.item;
+        if (t.type !== 'track')
+            return [{ track: t.name, artist: '', album: t.show?.name ?? '', status: data.is_playing ? 'playing' : 'paused', progress: '' }];
+        const prog = (data.progress_ms ?? 0) / 1000 | 0;
+        const dur = t.duration_ms / 1000 | 0;
+        const fmt = (s) => `${s / 60 | 0}:${String(s % 60).padStart(2, '0')}`;
+        return [{ track: t.name, artist: t.artists.map((a) => a.name).join(', '), album: t.album.name, status: data.is_playing ? 'playing' : 'paused', progress: `${fmt(prog)} / ${fmt(dur)}` }];
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'play',
+    description: 'Resume playback or search and play a track/artist',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'query', type: 'str', default: '', positional: true, help: 'Track or artist to play (optional)' }],
+    columns: ['track', 'artist', 'status'],
+    func: async (_page, kwargs) => {
+        if (kwargs.query) {
+            const { uri, name, artist } = await findTrackUri(kwargs.query);
+            await api('PUT', '/me/player/play', { uris: [uri] });
+            return [{ track: name, artist, status: 'playing' }];
+        }
+        await api('PUT', '/me/player/play');
+        return [{ track: '', artist: '', status: 'resumed' }];
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'pause',
+    description: 'Pause playback',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['status'],
+    func: async () => { await api('PUT', '/me/player/pause'); return [{ status: 'paused' }]; },
+});
+cli({
+    site: 'spotify',
+    name: 'next',
+    description: 'Skip to next track',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['status'],
+    func: async () => { await api('POST', '/me/player/next'); return [{ status: 'skipped to next' }]; },
+});
+cli({
+    site: 'spotify',
+    name: 'prev',
+    description: 'Skip to previous track',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['status'],
+    func: async () => { await api('POST', '/me/player/previous'); return [{ status: 'skipped to previous' }]; },
+});
+cli({
+    site: 'spotify',
+    name: 'volume',
+    description: 'Set playback volume (0-100)',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'level', type: 'int', default: 50, positional: true, required: true, help: 'Volume 0–100' }],
+    columns: ['volume'],
+    func: async (_page, kwargs) => {
+        const level = Math.round(kwargs.level);
+        if (level < 0 || level > 100)
+            throw new CliError('INVALID_ARGS', 'Volume must be between 0 and 100');
+        await api('PUT', `/me/player/volume?volume_percent=${level}`);
+        return [{ volume: `${level}%` }];
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'search',
+    description: 'Search for tracks',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', type: 'str', required: true, positional: true, help: 'Search query' },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of results (default: 10)' },
+    ],
+    columns: ['track', 'artist', 'album', 'uri'],
+    func: async (_page, kwargs) => {
+        const limit = Math.min(50, Math.max(1, Math.round(kwargs.limit)));
+        const data = await api('GET', `/search?q=${encodeURIComponent(kwargs.query)}&type=track&limit=${limit}`);
+        const results = mapSpotifyTrackResults(data);
+        if (!results.length)
+            throw new CliError('EMPTY_RESULT', `No results found for: ${kwargs.query}`);
+        return results;
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'queue',
+    description: 'Add a track to the playback queue',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'query', type: 'str', required: true, positional: true, help: 'Track to add to queue' }],
+    columns: ['track', 'artist', 'status'],
+    func: async (_page, kwargs) => {
+        const { uri, name, artist } = await findTrackUri(kwargs.query);
+        await api('POST', `/me/player/queue?uri=${encodeURIComponent(uri)}`);
+        return [{ track: name, artist, status: 'added to queue' }];
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'shuffle',
+    description: 'Toggle shuffle on/off',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'state', type: 'str', default: 'on', positional: true, choices: ['on', 'off'], help: 'on or off' }],
+    columns: ['shuffle'],
+    func: async (_page, kwargs) => {
+        await api('PUT', `/me/player/shuffle?state=${kwargs.state === 'on'}`);
+        return [{ shuffle: kwargs.state }];
+    },
+});
+cli({
+    site: 'spotify',
+    name: 'repeat',
+    description: 'Set repeat mode (off / track / context)',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'mode', type: 'str', default: 'context', positional: true, choices: ['off', 'track', 'context'], help: 'off / track / context' }],
+    columns: ['repeat'],
+    func: async (_page, kwargs) => {
+        await api('PUT', `/me/player/repeat?state=${kwargs.mode}`);
+        return [{ repeat: kwargs.mode }];
+    },
+});

package/vendor/opencli/dist/clis/spotify/utils.d.ts

@@ -0,0 +1,21 @@
+export interface SpotifyCredentials {
+    clientId: string;
+    clientSecret: string;
+}
+export interface SpotifyTrackSummary {
+    track: string;
+    artist: string;
+    album: string;
+    uri: string;
+}
+export declare function parseDotEnv(content: string): Record<string, string>;
+export declare function resolveSpotifyCredentials(fileEnv: Record<string, string>, processEnv?: NodeJS.ProcessEnv): SpotifyCredentials;
+export declare function isPlaceholderCredential(value: string | null | undefined): boolean;
+export declare function hasConfiguredSpotifyCredentials(credentials: SpotifyCredentials): boolean;
+export declare function assertSpotifyCredentialsConfigured(credentials: SpotifyCredentials, envFile: string): void;
+export declare function mapSpotifyTrackResults(data: any): SpotifyTrackSummary[];
+export declare function getFirstSpotifyTrack(data: any): {
+    uri: string;
+    name: string;
+    artist: string;
+} | null;

package/vendor/opencli/dist/clis/spotify/utils.js

@@ -0,0 +1,66 @@
+import { CliError } from '../../errors.js';
+const SPOTIFY_PLACEHOLDER_PATTERNS = [
+    /^your_spotify_client_id_here$/i,
+    /^your_spotify_client_secret_here$/i,
+    /^your_.+_here$/i,
+];
+export function parseDotEnv(content) {
+    return Object.fromEntries(content
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#') && line.includes('='))
+        .map(line => {
+        const index = line.indexOf('=');
+        return [line.slice(0, index).trim(), line.slice(index + 1).trim()];
+    }));
+}
+export function resolveSpotifyCredentials(fileEnv, processEnv = process.env) {
+    return {
+        clientId: processEnv.SPOTIFY_CLIENT_ID || fileEnv.SPOTIFY_CLIENT_ID || '',
+        clientSecret: processEnv.SPOTIFY_CLIENT_SECRET || fileEnv.SPOTIFY_CLIENT_SECRET || '',
+    };
+}
+export function isPlaceholderCredential(value) {
+    const normalized = value?.trim() || '';
+    if (!normalized)
+        return false;
+    return SPOTIFY_PLACEHOLDER_PATTERNS.some(pattern => pattern.test(normalized));
+}
+export function hasConfiguredSpotifyCredentials(credentials) {
+    return Boolean(credentials.clientId.trim()) &&
+        Boolean(credentials.clientSecret.trim()) &&
+        !isPlaceholderCredential(credentials.clientId) &&
+        !isPlaceholderCredential(credentials.clientSecret);
+}
+export function assertSpotifyCredentialsConfigured(credentials, envFile) {
+    if (hasConfiguredSpotifyCredentials(credentials))
+        return;
+    throw new CliError('CONFIG', `Missing Spotify credentials.\n\n` +
+        `1. Go to https://developer.spotify.com/dashboard and create an app\n` +
+        `2. Add ${'http://127.0.0.1:8888/callback'} as a Redirect URI\n` +
+        `3. Copy your Client ID and Client Secret\n` +
+        `4. Open the file: ${envFile}\n` +
+        `5. Fill in SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET, then save\n` +
+        `6. Run: opencli spotify auth`);
+}
+export function mapSpotifyTrackResults(data) {
+    const items = data?.tracks?.items;
+    if (!Array.isArray(items))
+        return [];
+    return items.map((track) => ({
+        track: track?.name || '',
+        artist: Array.isArray(track?.artists) ? track.artists.map((artist) => artist.name).join(', ') : '',
+        album: track?.album?.name || '',
+        uri: track?.uri || '',
+    }));
+}
+export function getFirstSpotifyTrack(data) {
+    const track = mapSpotifyTrackResults(data)[0];
+    if (!track)
+        return null;
+    return {
+        uri: track.uri,
+        name: track.track,
+        artist: track.artist,
+    };
+}

package/vendor/opencli/dist/clis/spotify/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/spotify/utils.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { assertSpotifyCredentialsConfigured, getFirstSpotifyTrack, hasConfiguredSpotifyCredentials, mapSpotifyTrackResults, parseDotEnv, resolveSpotifyCredentials, } from './utils.js';
+describe('spotify utils', () => {
+    it('parses dotenv-style credential files', () => {
+        const env = parseDotEnv(`
+      # Spotify credentials
+      SPOTIFY_CLIENT_ID=abc123
+      SPOTIFY_CLIENT_SECRET=def456
+    `);
+        expect(env).toEqual({
+            SPOTIFY_CLIENT_ID: 'abc123',
+            SPOTIFY_CLIENT_SECRET: 'def456',
+        });
+    });
+    it('prefers explicit process env over file values', () => {
+        const credentials = resolveSpotifyCredentials({
+            SPOTIFY_CLIENT_ID: 'file-id',
+            SPOTIFY_CLIENT_SECRET: 'file-secret',
+        }, {
+            SPOTIFY_CLIENT_ID: 'env-id',
+            SPOTIFY_CLIENT_SECRET: 'env-secret',
+        });
+        expect(credentials).toEqual({
+            clientId: 'env-id',
+            clientSecret: 'env-secret',
+        });
+    });
+    it('treats placeholder values as unconfigured credentials', () => {
+        expect(hasConfiguredSpotifyCredentials({
+            clientId: 'your_spotify_client_id_here',
+            clientSecret: 'your_spotify_client_secret_here',
+        })).toBe(false);
+    });
+    it('throws a helpful CONFIG error for empty or placeholder credentials', () => {
+        expect(() => assertSpotifyCredentialsConfigured({
+            clientId: '',
+            clientSecret: '',
+        }, '/tmp/spotify.env')).toThrow(/Missing Spotify credentials/);
+        expect(() => assertSpotifyCredentialsConfigured({
+            clientId: 'your_spotify_client_id_here',
+            clientSecret: 'real-secret',
+        }, '/tmp/spotify.env')).toThrow(/Fill in SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET/);
+    });
+    it('maps search payloads into stable track summaries', () => {
+        const results = mapSpotifyTrackResults({
+            tracks: {
+                items: [
+                    {
+                        name: 'Numb',
+                        artists: [{ name: 'Linkin Park' }, { name: 'Jay-Z' }],
+                        album: { name: 'Encore' },
+                        uri: 'spotify:track:123',
+                    },
+                ],
+            },
+        });
+        expect(results).toEqual([
+            {
+                track: 'Numb',
+                artist: 'Linkin Park, Jay-Z',
+                album: 'Encore',
+                uri: 'spotify:track:123',
+            },
+        ]);
+        expect(getFirstSpotifyTrack({ tracks: { items: [] } })).toBeNull();
+    });
+});