@mulmoclaude/spotify-plugin 0.1.0

package/dist/profile.d.ts

@@ -0,0 +1,32 @@
+import { FileOps, PluginRuntime } from 'gui-chat-protocol';
+import { SpotifyClientError } from './client';
+import { SpotifyProfile, SpotifyTokens } from './types';
+export interface ProfileDeps {
+    runtime: PluginRuntime;
+    clientId: string;
+    tokens: SpotifyTokens;
+    now?: () => Date;
+}
+export declare function readProfile(files: FileOps): Promise<SpotifyProfile | null>;
+export declare function writeProfile(files: FileOps, profile: SpotifyProfile): Promise<void>;
+/** Get the cached profile if fresh; otherwise fetch + persist a
+ *  new snapshot. On API failure with a stale cache we keep the
+ *  stale value (better than locking the user out — a network blip
+ *  shouldn't break playback).
+ *
+ *  Account scoping: cache is invalidated by `clearProfileCache`
+ *  whenever new tokens are written (i.e. after `oauthCallback`),
+ *  so reconnecting with a different Spotify account starts with a
+ *  fresh fetch and never serves the previous account's `product`
+ *  (Codex review on PR #1171). */
+export declare function getProfile(deps: ProfileDeps): Promise<{
+    ok: true;
+    profile: SpotifyProfile;
+} | {
+    ok: false;
+    error: SpotifyClientError;
+}>;
+export declare function isPremium(profile: SpotifyProfile): boolean;
+/** Test-only: clear the cache. Production callers should not need
+ *  this — the TTL handles it. */
+export declare function clearProfileCache(files: FileOps): Promise<void>;

package/dist/schemas.d.ts

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+/** Single source of truth for `manageSpotify`'s `kind` discriminator.
+ *  `definition.ts` derives the LLM-facing enum from `LLM_CALLABLE_KINDS`,
+ *  the Zod union below uses these same literals — the previous setup
+ *  duplicated the strings across both surfaces and risked drift
+ *  (CodeRabbit review on PR #1166). */
+export declare const SPOTIFY_KINDS: {
+    readonly connect: "connect";
+    readonly oauthCallback: "oauthCallback";
+    readonly status: "status";
+    readonly diagnose: "diagnose";
+    readonly configure: "configure";
+    readonly liked: "liked";
+    readonly playlists: "playlists";
+    readonly playlistTracks: "playlistTracks";
+    readonly recent: "recent";
+    readonly nowPlaying: "nowPlaying";
+    readonly search: "search";
+    readonly play: "play";
+    readonly pause: "pause";
+    readonly next: "next";
+    readonly previous: "previous";
+    readonly seek: "seek";
+    readonly setVolume: "setVolume";
+    readonly transferPlayback: "transferPlayback";
+    readonly getDevices: "getDevices";
+};
+/** Categories the `search` kind may include. Spotify's `/v1/search`
+ *  accepts these four; centralising the list lets `definition.ts`
+ *  reuse the same source for the JSON-schema enum (no drift between
+ *  Zod and the LLM-facing schema). */
+export declare const SEARCH_TYPES: readonly ["track", "artist", "album", "playlist"];
+/** Kinds the LLM is allowed to invoke directly (= advertised in
+ *  `TOOL_DEFINITION.parameters.kind.enum`). `configure` is omitted
+ *  intentionally — it's a View-only action that writes the user's
+ *  Client ID; exposing it to the LLM would invite the model to
+ *  mutate user secrets. */
+export declare const LLM_CALLABLE_KINDS: readonly ["connect", "oauthCallback", "status", "diagnose", "liked", "playlists", "playlistTracks", "recent", "nowPlaying", "search", "play", "pause", "next", "previous", "seek", "setVolume", "transferPlayback", "getDevices"];
+/** Persisted at `runtime.files.config/tokens.json`. Per-machine
+ *  secret — not synced via mulmoclaude's backup story. */
+export declare const TokensSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    expiresAt: z.ZodString;
+    scopes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** Persisted at `runtime.files.config/client.json`. The user
+ *  registers their own Spotify Developer Dashboard app and writes
+ *  the Client ID here (PKCE flow doesn't need a secret). */
+export declare const ClientConfigSchema: z.ZodObject<{
+    clientId: z.ZodString;
+}, z.core.$strip>;
+/** In-memory record kept between `connect` and `oauthCallback`. */
+export declare const PendingAuthSchema: z.ZodObject<{
+    codeVerifier: z.ZodString;
+    redirectUri: z.ZodString;
+    createdAtMs: z.ZodNumber;
+}, z.core.$strip>;
+/** Dispatch argument shape — discriminated by `kind`. PR 1 covered
+ *  only the OAuth-flavored kinds; PR 2 adds the listening-data
+ *  kinds plus a View-only `configure` action.
+ *
+ *  `configure` is excluded from `TOOL_DEFINITION.parameters.kind`
+ *  enum because it's intended for the View's "Configure" form, not
+ *  for the LLM. It still rides the same dispatch surface so the
+ *  View doesn't need a separate endpoint. */
+export declare const DispatchArgsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"connect">;
+    redirectUri: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"oauthCallback">;
+    code: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"status">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"diagnose">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"configure">;
+    clientId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"liked">;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"playlists">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"playlistTracks">;
+    playlistId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"recent">;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"nowPlaying">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"search">;
+    query: z.ZodString;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        track: "track";
+        artist: "artist";
+        album: "album";
+        playlist: "playlist";
+    }>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"play">;
+    deviceId: z.ZodOptional<z.ZodString>;
+    contextUri: z.ZodOptional<z.ZodString>;
+    trackUris: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pause">;
+    deviceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"next">;
+    deviceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"previous">;
+    deviceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"seek">;
+    positionMs: z.ZodNumber;
+    deviceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"setVolume">;
+    volumePercent: z.ZodNumber;
+    deviceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"transferPlayback">;
+    deviceId: z.ZodString;
+    play: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"getDevices">;
+}, z.core.$strip>], "kind">;
+export type DispatchArgs = z.infer<typeof DispatchArgsSchema>;

package/dist/search.d.ts

@@ -0,0 +1,19 @@
+import { PluginRuntime } from 'gui-chat-protocol';
+import { SpotifyClientError } from './client';
+import { SearchResult, SpotifyTokens } from './types';
+export type SearchType = "track" | "artist" | "album" | "playlist";
+export interface SearchDeps {
+    runtime: PluginRuntime;
+    clientId: string;
+    tokens: SpotifyTokens;
+    now?: () => Date;
+}
+type Result<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: SpotifyClientError;
+};
+export declare function searchSpotify(deps: SearchDeps, query: string, types: readonly SearchType[] | undefined, limit: number | undefined): Promise<Result<SearchResult>>;
+export {};

package/dist/searchSummary.d.ts

@@ -0,0 +1,20 @@
+import { NormalisedAlbum, NormalisedArtist, NormalisedPlaylist, NormalisedTrack, SearchResult } from './types';
+/** Build the LLM-facing message string for a search result. The
+ *  plain text mirrors the View's grouped sections, one entity per
+ *  line.
+ *
+ *  `query` is user-influenced on the tool path — both the LLM and
+ *  a manual View submission can put arbitrary strings in there.
+ *  Embedding it raw lets a hostile query smuggle line breaks and
+ *  control characters into the LLM's context window (a
+ *  prompt-injection vector via tool output: `query: "x\n\nIgnore
+ *  all previous instructions and …"`). Strip control chars and
+ *  bound the length before interpolating (Codex review on PR
+ *  #1168). */
+export declare function summariseSearch(query: string, result: SearchResult): string;
+export declare function sanitiseQueryForSummary(query: string): string;
+export declare function formatSearchSection<T>(label: string, items: T[], formatter: (item: T, idx: number) => string): string;
+export declare function formatTrackLine(track: NormalisedTrack, idx: number): string;
+export declare function formatArtistLine(artist: NormalisedArtist, idx: number): string;
+export declare function formatAlbumLine(album: NormalisedAlbum, idx: number): string;
+export declare function formatPlaylistLine(playlist: NormalisedPlaylist, idx: number): string;

package/dist/style.css

@@ -0,0 +1,367 @@
+
+.spotify-view[data-v-57a122f2] {
+  /* `h-full + flex column` so the content area can take the
+   * remaining vertical space and scroll, instead of overflowing
+   * into the host's chrome below. Same shape as todo-plugin's
+   * View. */
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  padding: 1rem;
+  font-family:
+    system-ui,
+    -apple-system,
+    sans-serif;
+  /* Critical: a flex child whose intrinsic content is taller than
+   * its allotted space won't shrink unless `min-height: 0`. Without
+   * this the scrollable content area's `overflow: auto` is ignored
+   * and the parent grows past the canvas. */
+  min-height: 0;
+}
+.spotify-connected[data-v-57a122f2] {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+}
+.spotify-content[data-v-57a122f2] {
+  flex: 1;
+  overflow-y: auto;
+  min-height: 0;
+}
+.spotify-header h2[data-v-57a122f2] {
+  font-size: 1.25rem;
+  font-weight: 600;
+  margin: 0 0 0.5rem;
+}
+.spotify-status[data-v-57a122f2] {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.875rem;
+  color: #6b7280;
+  margin-bottom: 1rem;
+}
+.spotify-connected-pill[data-v-57a122f2] {
+  background: #1ed760;
+  color: white;
+  padding: 0.125rem 0.5rem;
+  border-radius: 9999px;
+  font-size: 0.75rem;
+  font-weight: 500;
+}
+.spotify-reconnect[data-v-57a122f2] {
+  margin-left: auto;
+  background: none;
+  border: 1px solid #d1d5db;
+  border-radius: 0.25rem;
+  padding: 0.125rem 0.5rem;
+  cursor: pointer;
+  font-size: 0.75rem;
+  color: #374151;
+}
+.spotify-reconnect[data-v-57a122f2]:hover:not(:disabled) {
+  background: #f3f4f6;
+}
+.spotify-reconnect[data-v-57a122f2]:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+.spotify-expiry[data-v-57a122f2] {
+  font-size: 0.75rem;
+  color: #9ca3af;
+}
+.spotify-configure[data-v-57a122f2] {
+  border: 1px solid #e5e7eb;
+  border-radius: 0.5rem;
+  padding: 1rem;
+  margin-bottom: 1rem;
+  background: #fafafa;
+}
+.spotify-configure-help[data-v-57a122f2] {
+  margin: 0 0 0.75rem;
+  font-size: 0.875rem;
+}
+.spotify-configure-form[data-v-57a122f2] {
+  display: flex;
+  gap: 0.5rem;
+}
+.spotify-input[data-v-57a122f2] {
+  flex: 1;
+  padding: 0.5rem;
+  border: 1px solid #d1d5db;
+  border-radius: 0.375rem;
+  font-family: inherit;
+}
+.spotify-btn-primary[data-v-57a122f2] {
+  background: #1ed760;
+  color: white;
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: 0.375rem;
+  font-weight: 500;
+  cursor: pointer;
+}
+.spotify-btn-primary[data-v-57a122f2]:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+.spotify-connect-section[data-v-57a122f2] {
+  display: flex;
+  justify-content: center;
+  padding: 2rem;
+}
+.spotify-tab-row[data-v-57a122f2] {
+  display: flex;
+  align-items: stretch;
+  border-bottom: 1px solid #e5e7eb;
+  margin-bottom: 1rem;
+}
+.spotify-tabs[data-v-57a122f2] {
+  display: flex;
+  gap: 0.25rem;
+  flex: 1;
+}
+.spotify-tab[data-v-57a122f2] {
+  background: none;
+  border: none;
+  padding: 0.5rem 1rem;
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 0.875rem;
+  color: #6b7280;
+  border-bottom: 2px solid transparent;
+}
+.spotify-tab-active[data-v-57a122f2] {
+  color: #1ed760;
+  border-bottom-color: #1ed760;
+  font-weight: 500;
+}
+.spotify-refresh[data-v-57a122f2] {
+  background: none;
+  border: none;
+  color: #6b7280;
+  cursor: pointer;
+  font-size: 0.75rem;
+  padding: 0 0.5rem;
+}
+.spotify-list[data-v-57a122f2] {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+.spotify-track-row[data-v-57a122f2],
+.spotify-playlist-row[data-v-57a122f2] {
+  border-radius: 0.375rem;
+}
+.spotify-track-row[data-v-57a122f2]:hover,
+.spotify-playlist-row[data-v-57a122f2]:hover {
+  background: #f5f5f5;
+}
+.spotify-track-link[data-v-57a122f2] {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.5rem;
+  background: none;
+  border: none;
+  cursor: pointer;
+  text-align: left;
+  font-family: inherit;
+}
+.spotify-cover[data-v-57a122f2] {
+  width: 2.5rem;
+  height: 2.5rem;
+  border-radius: 0.25rem;
+  object-fit: cover;
+  flex-shrink: 0;
+}
+.spotify-track-meta[data-v-57a122f2] {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+  min-width: 0;
+}
+.spotify-track-name[data-v-57a122f2] {
+  font-weight: 500;
+  font-size: 0.875rem;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.spotify-track-artists[data-v-57a122f2] {
+  font-size: 0.75rem;
+  color: #6b7280;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.spotify-track-album[data-v-57a122f2] {
+  font-size: 0.75rem;
+  color: #9ca3af;
+}
+.spotify-track-duration[data-v-57a122f2] {
+  font-size: 0.75rem;
+  color: #9ca3af;
+  font-variant-numeric: tabular-nums;
+}
+.spotify-now-playing[data-v-57a122f2] {
+  border: 1px solid #e5e7eb;
+  border-radius: 0.5rem;
+  padding: 1rem;
+}
+.spotify-search-form[data-v-57a122f2] {
+  display: flex;
+  gap: 0.5rem;
+  margin-bottom: 1rem;
+}
+.spotify-search-results[data-v-57a122f2] {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+.spotify-search-section h3[data-v-57a122f2] {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: #6b7280;
+  margin: 0 0 0.25rem;
+  padding: 0;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+.spotify-player[data-v-57a122f2],
+.spotify-player-locked[data-v-57a122f2],
+.spotify-devices[data-v-57a122f2] {
+  margin-top: 1rem;
+  padding: 0.75rem 1rem;
+  border: 1px solid #e5e7eb;
+  border-radius: 0.5rem;
+}
+.spotify-player-locked[data-v-57a122f2] {
+  background: #fafafa;
+  color: #6b7280;
+}
+.spotify-player h3[data-v-57a122f2],
+.spotify-player-locked h3[data-v-57a122f2],
+.spotify-devices h3[data-v-57a122f2] {
+  font-size: 0.875rem;
+  font-weight: 600;
+  margin: 0 0 0.5rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: #6b7280;
+}
+.spotify-player-buttons[data-v-57a122f2] {
+  display: flex;
+  gap: 0.5rem;
+  margin-bottom: 0.75rem;
+}
+.spotify-player-btn[data-v-57a122f2] {
+  flex: 1;
+  padding: 0.5rem;
+  background: #1ed760;
+  color: white;
+  border: none;
+  border-radius: 0.375rem;
+  font-size: 1rem;
+  cursor: pointer;
+}
+.spotify-player-btn[data-v-57a122f2]:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+.spotify-player-volume[data-v-57a122f2] {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.875rem;
+}
+.spotify-player-volume input[type="range"][data-v-57a122f2] {
+  flex: 1;
+}
+.spotify-device-row[data-v-57a122f2] {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.375rem 0.5rem;
+  font-size: 0.875rem;
+}
+.spotify-device-name[data-v-57a122f2] {
+  flex: 1;
+  font-weight: 500;
+}
+.spotify-device-type[data-v-57a122f2] {
+  color: #6b7280;
+  font-size: 0.75rem;
+}
+.spotify-device-active[data-v-57a122f2] {
+  background: #1ed760;
+  color: white;
+  padding: 0 0.5rem;
+  border-radius: 9999px;
+  font-size: 0.75rem;
+}
+.spotify-device-transfer[data-v-57a122f2] {
+  background: none;
+  border: 1px solid #d1d5db;
+  border-radius: 0.25rem;
+  padding: 0.125rem 0.5rem;
+  cursor: pointer;
+  font-size: 0.75rem;
+}
+.spotify-now-cover[data-v-57a122f2] {
+  width: 4rem;
+  height: 4rem;
+  border-radius: 0.375rem;
+}
+.spotify-empty[data-v-57a122f2],
+.spotify-loading[data-v-57a122f2] {
+  color: #6b7280;
+  font-size: 0.875rem;
+  text-align: center;
+  padding: 2rem;
+}
+.spotify-error[data-v-57a122f2] {
+  color: #dc2626;
+  font-size: 0.875rem;
+  padding: 0.5rem;
+  background: #fef2f2;
+  border-radius: 0.375rem;
+}
+.spotify-retry[data-v-57a122f2] {
+  background: none;
+  border: 1px solid currentColor;
+  border-radius: 0.25rem;
+  padding: 0.125rem 0.5rem;
+  margin-left: 0.5rem;
+  cursor: pointer;
+  color: inherit;
+  font-size: inherit;
+}
+
+.spotify-preview[data-v-53e3c895] {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.375rem 0.75rem;
+  border-radius: 9999px;
+  background: #f5f5f5;
+  font-size: 0.875rem;
+}
+.spotify-preview-icon[data-v-53e3c895] {
+  color: #1ed760;
+  font-weight: 600;
+}
+.spotify-preview-label[data-v-53e3c895] {
+  font-weight: 500;
+}
+.spotify-preview-summary[data-v-53e3c895] {
+  color: #6b7280;
+  font-size: 0.75rem;
+}
+/*$vite$:1*/

package/dist/time.d.ts

@@ -0,0 +1,2 @@
+export declare const ONE_SECOND_MS = 1000;
+export declare const ONE_MINUTE_MS: number;

package/dist/tokens.d.ts

@@ -0,0 +1,19 @@
+import { FileOps } from 'gui-chat-protocol';
+import { RefreshResponseFields, SpotifyClientConfig, SpotifyTokens } from './types';
+/** Read persisted tokens. Returns null on absent / malformed (=
+ *  caller treats as "not_connected" and walks the user back to the
+ *  connect button). Throws only on the read I/O itself. */
+export declare function readTokens(files: FileOps): Promise<SpotifyTokens | null>;
+/** Write the full token record. */
+export declare function writeTokens(files: FileOps, tokens: SpotifyTokens): Promise<void>;
+/** Read the user-provided Client ID. Returns null when the file is
+ *  absent / malformed (caller treats as "client_id_missing" and
+ *  surfaces the setup guide). */
+export declare function readClientConfig(files: FileOps): Promise<SpotifyClientConfig | null>;
+/** Write the Client ID. The View's "Configure" form posts here
+ *  via `runtime.dispatch({ kind: "configure", clientId })` (PR 2). */
+export declare function writeClientConfig(files: FileOps, config: SpotifyClientConfig): Promise<void>;
+/** Apply a refresh response to the persisted tokens, preserving the
+ *  prior `refreshToken` when Spotify omits a fresh one (the common
+ *  case). Pure — caller persists. */
+export declare function mergeRefreshResponse(prior: SpotifyTokens, response: RefreshResponseFields, now?: Date): SpotifyTokens;