@zenalexa/unicli 0.215.1 → 0.216.2

package/src/adapters/reddit/listings.ts

@@ -0,0 +1,223 @@
+import { cli, Strategy } from "../../registry.js";
+import type { AdapterArg, IPage } from "../../types.js";
+import {
+  clampLimit,
+  mapRedditPosts,
+  normalizeSubreddit,
+  redditChildren,
+  redditJson,
+} from "./browser-utils.js";
+
+const POST_COLUMNS = [
+  "rank",
+  "title",
+  "subreddit",
+  "author",
+  "score",
+  "comments",
+  "url",
+];
+
+const LIMIT_ARG: AdapterArg = {
+  name: "limit",
+  type: "int",
+  default: 20,
+  description: "Number of posts",
+};
+
+const SUBREDDIT_ARG: AdapterArg = {
+  name: "subreddit",
+  type: "str",
+  default: "",
+  description: "Subreddit name without r/",
+};
+
+const TIME_ARG: AdapterArg = {
+  name: "time",
+  type: "str",
+  default: "day",
+  choices: ["hour", "day", "week", "month", "year", "all"],
+  description: "Time window",
+};
+
+async function postsFromPath(
+  page: IPage,
+  path: string,
+  kwargs: Record<string, unknown>,
+  params: Record<string, string | number | boolean | undefined> = {},
+): Promise<Array<Record<string, unknown>>> {
+  const limit = clampLimit(kwargs.limit);
+  const data = await redditJson(page, path, { limit, ...params });
+  return mapRedditPosts(redditChildren(data), limit);
+}
+
+cli({
+  site: "reddit",
+  name: "hot",
+  description: "Reddit front page hot posts",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [SUBREDDIT_ARG, LIMIT_ARG],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) => {
+    const subreddit = normalizeSubreddit(kwargs.subreddit);
+    const path = subreddit
+      ? `/r/${encodeURIComponent(subreddit)}/hot.json`
+      : "/r/all/hot.json";
+    return postsFromPath(page as IPage, path, kwargs);
+  },
+});
+
+cli({
+  site: "reddit",
+  name: "frontpage",
+  description: "Reddit front page / r/all",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [LIMIT_ARG],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) =>
+    postsFromPath(page as IPage, "/r/all.json", kwargs),
+});
+
+cli({
+  site: "reddit",
+  name: "popular",
+  description: "Reddit popular posts (/r/popular)",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [LIMIT_ARG],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) =>
+    postsFromPath(page as IPage, "/r/popular.json", kwargs),
+});
+
+cli({
+  site: "reddit",
+  name: "new",
+  description: "Reddit newest posts",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [SUBREDDIT_ARG, LIMIT_ARG],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) => {
+    const subreddit = normalizeSubreddit(kwargs.subreddit);
+    const path = subreddit
+      ? `/r/${encodeURIComponent(subreddit)}/new.json`
+      : "/new.json";
+    return postsFromPath(page as IPage, path, kwargs);
+  },
+});
+
+cli({
+  site: "reddit",
+  name: "top",
+  description: "Reddit top posts",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [SUBREDDIT_ARG, TIME_ARG, LIMIT_ARG],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) => {
+    const subreddit = normalizeSubreddit(kwargs.subreddit);
+    const path = subreddit
+      ? `/r/${encodeURIComponent(subreddit)}/top.json`
+      : "/top.json";
+    return postsFromPath(page as IPage, path, kwargs, {
+      t: String(kwargs.time ?? "day"),
+    });
+  },
+});
+
+cli({
+  site: "reddit",
+  name: "rising",
+  description: "Reddit rising posts",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [SUBREDDIT_ARG, LIMIT_ARG],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) => {
+    const subreddit = normalizeSubreddit(kwargs.subreddit);
+    const path = subreddit
+      ? `/r/${encodeURIComponent(subreddit)}/rising.json`
+      : "/rising.json";
+    return postsFromPath(page as IPage, path, kwargs);
+  },
+});
+
+cli({
+  site: "reddit",
+  name: "subreddit",
+  description: "Get posts from a specific subreddit",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "name",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Subreddit name",
+    },
+    {
+      name: "sort",
+      type: "str",
+      default: "hot",
+      choices: ["hot", "new", "top", "rising"],
+      description: "Sort order",
+    },
+    TIME_ARG,
+    LIMIT_ARG,
+  ],
+  columns: POST_COLUMNS,
+  func: async (page, kwargs) => {
+    const name = normalizeSubreddit(kwargs.name);
+    const sort = String(kwargs.sort ?? "hot");
+    const limit = clampLimit(kwargs.limit);
+    const data = await redditJson(
+      page as IPage,
+      `/r/${encodeURIComponent(name)}/${sort}.json`,
+      {
+        limit,
+        t: sort === "top" ? String(kwargs.time ?? "day") : undefined,
+      },
+    );
+    return mapRedditPosts(redditChildren(data), limit);
+  },
+});
+
+cli({
+  site: "reddit",
+  name: "trending",
+  description: "Reddit trending subreddits",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [LIMIT_ARG],
+  columns: ["name", "subscribers", "title", "description", "url"],
+  func: async (page, kwargs) => {
+    const limit = clampLimit(kwargs.limit, 25);
+    const data = await redditJson(page as IPage, "/subreddits/popular.json", {
+      limit,
+    });
+    return redditChildren(data)
+      .slice(0, limit)
+      .map((child) => {
+        const item = (child.data ?? {}) as Record<string, unknown>;
+        return {
+          name: String(item.display_name ?? ""),
+          subscribers: Number(item.subscribers ?? 0),
+          title: String(item.title ?? ""),
+          description: String(item.public_description ?? "").slice(0, 120),
+          url: item.url ? `https://www.reddit.com${String(item.url)}` : "",
+        };
+      });
+  },
+});

package/src/adapters/reddit/search.ts

@@ -0,0 +1,74 @@
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+import {
+  clampLimit,
+  mapRedditPosts,
+  normalizeSubreddit,
+  redditChildren,
+  redditJson,
+} from "./browser-utils.js";
+
+cli({
+  site: "reddit",
+  name: "search",
+  description: "Search Reddit posts",
+  domain: "www.reddit.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "query",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Search query",
+    },
+    {
+      name: "subreddit",
+      type: "str",
+      default: "",
+      description: "Restrict search to a subreddit",
+    },
+    {
+      name: "sort",
+      type: "str",
+      default: "relevance",
+      choices: ["relevance", "hot", "top", "new", "comments"],
+      description: "Sort order",
+    },
+    {
+      name: "time",
+      type: "str",
+      default: "all",
+      choices: ["hour", "day", "week", "month", "year", "all"],
+      description: "Time window",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of results",
+    },
+  ],
+  columns: ["title", "subreddit", "author", "score", "comments", "url"],
+  func: async (page, kwargs) => {
+    const p = page as IPage;
+    const query = String(kwargs.query ?? "");
+    const subreddit = normalizeSubreddit(kwargs.subreddit);
+    const sort = String(kwargs.sort ?? "relevance");
+    const time = String(kwargs.time ?? "all");
+    const limit = clampLimit(kwargs.limit);
+    const path = subreddit
+      ? `/r/${encodeURIComponent(subreddit)}/search.json`
+      : "/search.json";
+    const data = await redditJson(p, path, {
+      q: query,
+      sort,
+      t: time,
+      limit,
+      restrict_sr: subreddit ? "on" : "off",
+    });
+
+    return mapRedditPosts(redditChildren(data), limit);
+  },
+});

package/src/adapters/spotify/api.ts

@@ -0,0 +1,292 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { cli, Strategy } from "../../registry.js";
+import { intArg, str } from "../_shared/browser-tools.js";
+
+interface SpotifyTokens {
+  access_token?: string;
+  refresh_token?: string;
+  expires_at?: number;
+}
+
+interface SpotifyConfig {
+  SPOTIFY_CLIENT_ID?: string;
+  SPOTIFY_CLIENT_SECRET?: string;
+  SPOTIFY_REDIRECT_URI?: string;
+}
+
+const TOKEN_PATH = join(homedir(), ".unicli", "spotify-tokens.json");
+const ENV_PATH = join(homedir(), ".unicli", "spotify.env");
+
+async function readConfig(): Promise<SpotifyConfig> {
+  const config: SpotifyConfig = {
+    SPOTIFY_CLIENT_ID: process.env.SPOTIFY_CLIENT_ID,
+    SPOTIFY_CLIENT_SECRET: process.env.SPOTIFY_CLIENT_SECRET,
+    SPOTIFY_REDIRECT_URI: process.env.SPOTIFY_REDIRECT_URI,
+  };
+  try {
+    const text = await readFile(ENV_PATH, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+      const match = /^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/.exec(line);
+      if (match) config[match[1] as keyof SpotifyConfig] = match[2];
+    }
+  } catch {
+    // Environment variables are enough for non-interactive use.
+  }
+  return config;
+}
+
+async function readTokens(): Promise<SpotifyTokens> {
+  try {
+    return JSON.parse(await readFile(TOKEN_PATH, "utf8")) as SpotifyTokens;
+  } catch {
+    return {};
+  }
+}
+
+async function writeTokens(tokens: SpotifyTokens): Promise<void> {
+  await mkdir(dirname(TOKEN_PATH), { recursive: true });
+  await writeFile(TOKEN_PATH, JSON.stringify(tokens, null, 2));
+}
+
+async function refreshAccessToken(): Promise<string> {
+  const config = await readConfig();
+  const tokens = await readTokens();
+  if (tokens.access_token && (tokens.expires_at ?? 0) > Date.now() + 60_000) {
+    return tokens.access_token;
+  }
+  if (!tokens.refresh_token) {
+    throw new Error("Spotify refresh token missing. Run spotify auth first.");
+  }
+  if (!config.SPOTIFY_CLIENT_ID || !config.SPOTIFY_CLIENT_SECRET) {
+    throw new Error(`Spotify app config missing in ${ENV_PATH}`);
+  }
+  const response = await fetch("https://accounts.spotify.com/api/token", {
+    method: "POST",
+    headers: {
+      authorization: `Basic ${Buffer.from(
+        `${config.SPOTIFY_CLIENT_ID}:${config.SPOTIFY_CLIENT_SECRET}`,
+      ).toString("base64")}`,
+      "content-type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: tokens.refresh_token,
+    }),
+  });
+  if (!response.ok) {
+    throw new Error(`Spotify token refresh failed: HTTP ${response.status}`);
+  }
+  const data = (await response.json()) as SpotifyTokens & {
+    expires_in?: number;
+  };
+  const next = {
+    ...tokens,
+    ...data,
+    expires_at: Date.now() + Number(data.expires_in ?? 3600) * 1000,
+  };
+  await writeTokens(next);
+  return str(next.access_token);
+}
+
+async function spotifyApi(
+  path: string,
+  init: RequestInit = {},
+): Promise<unknown> {
+  const token = await refreshAccessToken();
+  const response = await fetch(`https://api.spotify.com/v1${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      ...init.headers,
+    },
+  });
+  if (response.status === 204) return { ok: true };
+  if (!response.ok) {
+    const preview = await response.text().catch(() => "");
+    throw new Error(
+      `Spotify API failed: HTTP ${response.status} ${preview.slice(0, 160)}`,
+    );
+  }
+  return response.json();
+}
+
+async function searchTrack(query: string): Promise<string> {
+  const data = (await spotifyApi(
+    `/search?type=track&limit=1&q=${encodeURIComponent(query)}`,
+  )) as { tracks?: { items?: Array<{ uri?: string }> } };
+  const uri = data.tracks?.items?.[0]?.uri;
+  if (!uri) throw new Error(`No Spotify track found for query: ${query}`);
+  return uri;
+}
+
+cli({
+  site: "spotify",
+  name: "auth",
+  description: "Create or complete Spotify OAuth setup",
+  domain: "api.spotify.com",
+  strategy: Strategy.PUBLIC,
+  args: [{ name: "code", type: "str", required: false }],
+  columns: ["status", "url"],
+  func: async (_page, kwargs) => {
+    const config = await readConfig();
+    const redirect =
+      config.SPOTIFY_REDIRECT_URI ?? "http://127.0.0.1:8888/callback";
+    if (!config.SPOTIFY_CLIENT_ID) {
+      throw new Error(`Spotify client id missing in ${ENV_PATH}`);
+    }
+    if (!kwargs.code) {
+      const scopes = [
+        "user-read-playback-state",
+        "user-modify-playback-state",
+        "user-read-currently-playing",
+        "streaming",
+      ].join(" ");
+      const url = new URL("https://accounts.spotify.com/authorize");
+      url.searchParams.set("client_id", config.SPOTIFY_CLIENT_ID);
+      url.searchParams.set("response_type", "code");
+      url.searchParams.set("redirect_uri", redirect);
+      url.searchParams.set("scope", scopes);
+      return [{ status: "open_authorize_url", url: url.href }];
+    }
+    if (!config.SPOTIFY_CLIENT_SECRET) {
+      throw new Error(`Spotify client secret missing in ${ENV_PATH}`);
+    }
+    const response = await fetch("https://accounts.spotify.com/api/token", {
+      method: "POST",
+      headers: {
+        authorization: `Basic ${Buffer.from(
+          `${config.SPOTIFY_CLIENT_ID}:${config.SPOTIFY_CLIENT_SECRET}`,
+        ).toString("base64")}`,
+        "content-type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code: str(kwargs.code),
+        redirect_uri: redirect,
+      }),
+    });
+    if (!response.ok) {
+      throw new Error(`Spotify auth failed: HTTP ${response.status}`);
+    }
+    const data = (await response.json()) as SpotifyTokens & {
+      expires_in?: number;
+    };
+    await writeTokens({
+      ...data,
+      expires_at: Date.now() + Number(data.expires_in ?? 3600) * 1000,
+    });
+    return [{ status: "saved", url: TOKEN_PATH }];
+  },
+});
+
+cli({
+  site: "spotify",
+  name: "status",
+  description: "Show current Spotify playback status",
+  domain: "api.spotify.com",
+  strategy: Strategy.COOKIE,
+  columns: ["track", "artist", "is_playing", "progress_ms"],
+  func: async () => {
+    const data = (await spotifyApi("/me/player")) as {
+      is_playing?: boolean;
+      progress_ms?: number;
+      item?: { name?: string; artists?: Array<{ name?: string }> };
+      device?: { name?: string; volume_percent?: number };
+    };
+    return [
+      {
+        track: data.item?.name ?? "",
+        artist: data.item?.artists?.map((a) => a.name).join(", ") ?? "",
+        is_playing: data.is_playing ?? false,
+        progress_ms: data.progress_ms ?? 0,
+        device: data.device?.name ?? "",
+        volume: data.device?.volume_percent ?? "",
+      },
+    ];
+  },
+});
+
+cli({
+  site: "spotify",
+  name: "volume",
+  description: "Set Spotify playback volume",
+  domain: "api.spotify.com",
+  strategy: Strategy.COOKIE,
+  args: [{ name: "percent", type: "int", required: true, positional: true }],
+  columns: ["ok", "volume"],
+  func: async (_page, kwargs) => {
+    const volume = intArg(kwargs.percent, 50, 100);
+    await spotifyApi(`/me/player/volume?volume_percent=${volume}`, {
+      method: "PUT",
+    });
+    return [{ ok: true, volume }];
+  },
+});
+
+cli({
+  site: "spotify",
+  name: "queue",
+  description: "Add a Spotify track to the playback queue",
+  domain: "api.spotify.com",
+  strategy: Strategy.COOKIE,
+  args: [{ name: "query", type: "str", required: true, positional: true }],
+  columns: ["ok", "uri"],
+  func: async (_page, kwargs) => {
+    const uri = await searchTrack(str(kwargs.query));
+    await spotifyApi(`/me/player/queue?uri=${encodeURIComponent(uri)}`, {
+      method: "POST",
+    });
+    return [{ ok: true, uri }];
+  },
+});
+
+cli({
+  site: "spotify",
+  name: "shuffle",
+  description: "Toggle Spotify shuffle mode",
+  domain: "api.spotify.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "state",
+      type: "str",
+      required: true,
+      positional: true,
+      choices: ["on", "off"],
+    },
+  ],
+  columns: ["ok", "state"],
+  func: async (_page, kwargs) => {
+    const state = str(kwargs.state).toLowerCase() === "on";
+    await spotifyApi(`/me/player/shuffle?state=${state}`, { method: "PUT" });
+    return [{ ok: true, state }];
+  },
+});
+
+cli({
+  site: "spotify",
+  name: "repeat",
+  description: "Set Spotify repeat mode",
+  domain: "api.spotify.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "state",
+      type: "str",
+      required: true,
+      positional: true,
+      choices: ["off", "track", "context"],
+    },
+  ],
+  columns: ["ok", "state"],
+  func: async (_page, kwargs) => {
+    const state = str(kwargs.state, "off");
+    await spotifyApi(`/me/player/repeat?state=${encodeURIComponent(state)}`, {
+      method: "PUT",
+    });
+    return [{ ok: true, state }];
+  },
+});