npm - @crafter/spoti-cli - Versions diffs - 0.1.0 - Mend

@crafter/spoti-cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.d.ts ADDED Viewed

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

package/dist/index.js ADDED Viewed

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command } from "commander";
+// src/lib/auth-server.ts
+import { createServer } from "http";
+var PORT = 8888;
+function startAuthServer() {
+  return new Promise((resolve, reject) => {
+    const connections = /* @__PURE__ */ new Set();
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1:${PORT}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(authPage("Authentication failed. You can close this tab.", true));
+          reject(new Error(`Auth failed: ${error}`));
+          setTimeout(forceClose, 100);
+          return;
+        }
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(authPage("Authentication successful! Return to your terminal."));
+          resolve(code);
+          setTimeout(forceClose, 100);
+          return;
+        }
+        res.writeHead(400);
+        res.end("Missing code");
+        return;
+      }
+      res.writeHead(404);
+      res.end("Not found");
+    });
+    server.on("connection", (conn) => {
+      connections.add(conn);
+      conn.on("close", () => connections.delete(conn));
+    });
+    const forceClose = () => {
+      clearTimeout(timeout);
+      for (const conn of connections) conn.destroy();
+      server.close();
+      server.unref();
+    };
+    server.listen(PORT, "127.0.0.1");
+    const timeout = setTimeout(() => {
+      forceClose();
+      reject(new Error("Auth timeout after 120s"));
+    }, 12e4);
+    timeout.unref();
+  });
+}
+function authPage(message, isError = false) {
+  const color = isError ? "#ef4444" : "#22c55e";
+  return `<!DOCTYPE html>
+<html>
+<head><title>spoti-cli</title></head>
+<body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#0a0a0a;color:#fafafa">
+<div style="text-align:center">
+<h1 style="color:${color}">${message}</h1>
+<p style="color:#888">spoti-cli</p>
+</div>
+</body>
+</html>`;
+}
+var REDIRECT_URI = `http://127.0.0.1:${PORT}/callback`;
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".spoti-cli");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readConfig() {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) return {};
+  return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function updateConfig(partial) {
+  const current = readConfig();
+  writeConfig({ ...current, ...partial });
+}
+// src/commands/auth.ts
+var SCOPES = [
+  "playlist-modify-private",
+  "playlist-modify-public",
+  "user-read-private",
+  "user-read-email"
+];
+function generateCodeVerifier() {
+  const array = new Uint8Array(64);
+  crypto.getRandomValues(array);
+  return btoa(String.fromCharCode(...array)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_").slice(0, 128);
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return btoa(String.fromCharCode(...new Uint8Array(digest))).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+async function authCommand(clientId) {
+  const config = readConfig();
+  const id = clientId ?? config.client_id;
+  if (!id) {
+    console.error("Client ID required. Run: spoti-cli auth --client-id <ID>");
+    console.error("Get one at: https://developer.spotify.com/dashboard/create");
+    process.exit(1);
+  }
+  updateConfig({ client_id: id });
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = await generateCodeChallenge(codeVerifier);
+  const authUrl = new URL("https://accounts.spotify.com/authorize");
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", id);
+  authUrl.searchParams.set("scope", SCOPES.join(" "));
+  authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  console.log("Opening browser for Spotify login...");
+  console.log(`If it doesn't open, visit: ${authUrl.toString()}`);
+  const open = (await import("open")).default;
+  await open(authUrl.toString());
+  const code = await startAuthServer();
+  console.log("Exchanging code for tokens...");
+  const res = await fetch("https://accounts.spotify.com/api/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: REDIRECT_URI,
+      client_id: id,
+      code_verifier: codeVerifier
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    console.error(`Token exchange failed: ${err}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  updateConfig({
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Date.now() + data.expires_in * 1e3
+  });
+  console.log("Authenticated successfully!");
+  console.log("");
+  console.log("Install the Claude skill for AI-powered playlists:");
+  console.log("  npx skills add crafter-station/skills --skill spoti-cli");
+}
+// src/lib/output.ts
+function output(data, json) {
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (Array.isArray(data)) {
+    for (const item of data) {
+      printItem(item);
+    }
+  } else {
+    printItem(data);
+  }
+}
+function printItem(item) {
+  const parts = [];
+  for (const [key, value] of Object.entries(item)) {
+    if (value !== void 0 && value !== null) {
+      parts.push(`${key}: ${value}`);
+    }
+  }
+  console.log(parts.join(" | "));
+}
+// src/lib/spotify.ts
+var BASE_URL = "https://api.spotify.com/v1";
+var TOKEN_URL = "https://accounts.spotify.com/api/token";
+async function refreshAccessToken() {
+  const config = readConfig();
+  if (!config.client_id || !config.refresh_token) {
+    throw new Error("Not authenticated. Run: spoti-cli auth --client-id <ID>");
+  }
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: config.refresh_token,
+      client_id: config.client_id
+    })
+  });
+  if (!res.ok) throw new Error(`Token refresh failed: ${res.status}`);
+  const data = await res.json();
+  updateConfig({
+    access_token: data.access_token,
+    refresh_token: data.refresh_token ?? config.refresh_token,
+    expires_at: Date.now() + data.expires_in * 1e3
+  });
+  return data.access_token;
+}
+async function getToken() {
+  const config = readConfig();
+  if (!config.access_token) {
+    throw new Error("Not authenticated. Run: spoti-cli auth --client-id <ID>");
+  }
+  if (config.expires_at && Date.now() > config.expires_at - 6e4) {
+    return refreshAccessToken();
+  }
+  return config.access_token;
+}
+async function spotify(path, options = {}) {
+  const token = await getToken();
+  const res = await fetch(`${BASE_URL}${path}`, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  if (res.status === 401) {
+    const newToken = await refreshAccessToken();
+    const retry = await fetch(`${BASE_URL}${path}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${newToken}`,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!retry.ok) throw new Error(`Spotify API error: ${retry.status}`);
+    return retry.json();
+  }
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Spotify API error ${res.status}: ${body}`);
+  }
+  if (res.status === 204) return {};
+  return res.json();
+}
+// src/commands/create.ts
+async function createCommand(name, opts) {
+  const user = await spotify("/me");
+  const playlist2 = await spotify(
+    `/users/${user.id}/playlists`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        description: opts.description ?? "",
+        public: opts.public
+      })
+    }
+  );
+  if (opts.tracks) {
+    const uris = opts.tracks.split(",").map((t) => t.startsWith("spotify:") ? t : `spotify:track:${t}`);
+    await spotify(`/playlists/${playlist2.id}/tracks`, {
+      method: "POST",
+      body: JSON.stringify({ uris })
+    });
+    console.log(`Added ${uris.length} tracks`);
+  }
+  const result = {
+    id: playlist2.id,
+    name: playlist2.name,
+    url: playlist2.external_urls.spotify,
+    uri: playlist2.uri
+  };
+  if (opts.json) {
+    output(result, true);
+  } else {
+    console.log(`Playlist created: ${result.url}`);
+  }
+  if (opts.open) {
+    const { exec } = await import("child_process");
+    exec(`open ${playlist2.uri}`);
+  }
+}
+// src/commands/me.ts
+async function meCommand(opts) {
+  const user = await spotify("/me");
+  const result = {
+    id: user.id,
+    name: user.display_name,
+    email: user.email,
+    plan: user.product,
+    country: user.country,
+    url: user.external_urls.spotify
+  };
+  output(result, opts.json);
+}
+// src/commands/playlist.ts
+async function playlistListCommand(opts) {
+  const data = await spotify(
+    `/me/playlists?limit=${opts.limit || "20"}`
+  );
+  const items = data.items.map((p) => ({
+    id: p.id,
+    name: p.name,
+    tracks: p.tracks.total,
+    public: p.public,
+    url: p.external_urls.spotify
+  }));
+  output(items, opts.json);
+}
+async function playlistGetCommand(id, opts) {
+  const data = await spotify(`/playlists/${id}`);
+  const result = {
+    id: data.id,
+    name: data.name,
+    description: data.description,
+    url: data.external_urls.spotify,
+    tracks: data.tracks.items.map((i) => ({
+      id: i.track.id,
+      name: i.track.name,
+      artist: i.track.artists.map((a) => a.name).join(", "),
+      uri: i.track.uri
+    }))
+  };
+  output(result, opts.json);
+}
+async function playlistAddCommand(id, opts) {
+  const uris = opts.tracks.split(",").map((t) => t.startsWith("spotify:") ? t : `spotify:track:${t}`);
+  await spotify(`/playlists/${id}/tracks`, {
+    method: "POST",
+    body: JSON.stringify({ uris })
+  });
+  console.log(`Added ${uris.length} tracks to playlist ${id}`);
+}
+// src/commands/recommend.ts
+async function recommendCommand(opts) {
+  const limit = Number.parseInt(opts.limit || "20");
+  const queries = [];
+  if (opts.seedGenres) {
+    for (const genre of opts.seedGenres.split(",")) {
+      queries.push(`genre:${genre.trim()}`);
+    }
+  }
+  if (opts.seedArtists) {
+    for (const artistId of opts.seedArtists.split(",")) {
+      const artist = await spotify(
+        `/artists/${artistId.trim()}`
+      );
+      queries.push(`artist:${artist.name}`);
+    }
+  }
+  if (opts.seedTracks) {
+    for (const trackId of opts.seedTracks.split(",")) {
+      const track = await spotify(
+        `/tracks/${trackId.trim()}`
+      );
+      queries.push(`artist:${track.artists[0].name}`);
+    }
+  }
+  if (queries.length === 0) {
+    console.error(
+      "At least one seed required: --seed-tracks, --seed-artists, or --seed-genres"
+    );
+    process.exit(1);
+  }
+  const query = queries.join(" ");
+  const params = new URLSearchParams({
+    q: query,
+    type: "track",
+    limit: String(Math.min(limit, 50))
+  });
+  const data = await spotify(`/search?${params}`);
+  if (!data.tracks) {
+    console.error("No tracks found");
+    process.exit(1);
+  }
+  const items = data.tracks.items.map((t) => ({
+    id: t.id,
+    name: t.name,
+    artist: t.artists.map((a) => a.name).join(", "),
+    album: t.album.name,
+    uri: t.uri,
+    popularity: t.popularity
+  }));
+  output(items, opts.json);
+}
+// src/commands/search.ts
+async function searchCommand(query, opts) {
+  const type = opts.type || "track";
+  const limit = opts.limit || "10";
+  const params = new URLSearchParams({ q: query, type, limit });
+  const data = await spotify(`/search?${params}`);
+  if (type === "track" && data.tracks) {
+    const items = data.tracks.items.map((t) => ({
+      id: t.id,
+      name: t.name,
+      artist: t.artists.map((a) => a.name).join(", "),
+      album: t.album.name,
+      uri: t.uri,
+      popularity: t.popularity
+    }));
+    output(items, opts.json);
+  } else if (type === "artist" && data.artists) {
+    const items = data.artists.items.map((a) => ({
+      id: a.id,
+      name: a.name,
+      genres: a.genres.join(", "),
+      uri: a.uri,
+      popularity: a.popularity
+    }));
+    output(items, opts.json);
+  } else if (type === "album" && data.albums) {
+    const items = data.albums.items.map((a) => ({
+      id: a.id,
+      name: a.name,
+      artist: a.artists.map((ar) => ar.name).join(", "),
+      released: a.release_date,
+      uri: a.uri
+    }));
+    output(items, opts.json);
+  }
+}
+// src/index.ts
+var program = new Command();
+program.name("spoti-cli").description("Spotify Web API from your terminal").version("0.1.0");
+program.command("auth").description("Authenticate with Spotify (OAuth2 PKCE)").option("-c, --client-id <id>", "Spotify app client ID").action((opts) => authCommand(opts.clientId));
+program.command("search <query>").description("Search for tracks, artists, or albums").option("-t, --type <type>", "Search type: track, artist, album", "track").option("-l, --limit <n>", "Number of results", "10").option("--json", "Output as JSON", false).action((query, opts) => searchCommand(query, opts));
+program.command("recommend").description("Get track recommendations based on seeds").option("--seed-tracks <ids>", "Comma-separated track IDs").option("--seed-artists <ids>", "Comma-separated artist IDs").option("--seed-genres <genres>", "Comma-separated genres").option("-l, --limit <n>", "Number of recommendations", "20").option("--energy <n>", "Target energy (0.0-1.0)").option("--danceability <n>", "Target danceability (0.0-1.0)").option("--valence <n>", "Target valence/positiveness (0.0-1.0)").option("--tempo <n>", "Target tempo in BPM").option("--popularity <n>", "Target popularity (0-100)").option("--acousticness <n>", "Target acousticness (0.0-1.0)").option("--instrumentalness <n>", "Target instrumentalness (0.0-1.0)").option("--json", "Output as JSON", false).action((opts) => recommendCommand(opts));
+program.command("create <name>").description("Create a new playlist").option("-d, --description <text>", "Playlist description").option("--public", "Make playlist public", false).option("--tracks <uris>", "Comma-separated track URIs or IDs to add").option("-o, --open", "Open playlist in Spotify app after creation", false).option("--json", "Output as JSON", false).action((name, opts) => createCommand(name, opts));
+program.command("me").description("Show current user profile").option("--json", "Output as JSON", false).action((opts) => meCommand(opts));
+var playlist = program.command("playlist").description("Manage playlists");
+playlist.command("list").description("List your playlists").option("-l, --limit <n>", "Number of playlists", "20").option("--json", "Output as JSON", false).action((opts) => playlistListCommand(opts));
+playlist.command("get <id>").description("Get playlist details and tracks").option("--json", "Output as JSON", false).action((id, opts) => playlistGetCommand(id, opts));
+playlist.command("add <id>").description("Add tracks to a playlist").requiredOption("--tracks <uris>", "Comma-separated track URIs or IDs").action((id, opts) => playlistAddCommand(id, opts));
+program.parse();

package/package.json ADDED Viewed

@@ -0,0 +1,39 @@
+{
+	"name": "@crafter/spoti-cli",
+	"version": "0.1.0",
+	"description": "Spotify Web API from your terminal. Search, recommend, and create playlists.",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"spoti-cli": "dist/index.js"
+	},
+	"scripts": {
+		"dev": "tsx src/index.ts",
+		"build": "tsup"
+	},
+	"dependencies": {
+		"commander": "^13.1.0",
+		"open": "^11.0.0"
+	},
+	"devDependencies": {
+		"tsup": "^8.4.0",
+		"tsx": "^4.19.0",
+		"typescript": "^5.8.0",
+		"@types/bun": "^1.2.0"
+	},
+	"files": [
+		"dist"
+	],
+	"keywords": [
+		"spotify",
+		"cli",
+		"playlist",
+		"music",
+		"terminal"
+	],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/crafter-station/spoti-cli"
+	}
+}