@youtubesearch/cli 0.1.2

package/README.md

@@ -0,0 +1,51 @@
+# @youtubesearch/cli
+
+Agent-optimized YouTube search, transcripts, and summaries from your shell —
+the CLI for the [YouTubeSearch](https://youtubesearch.dev) API. Results to
+stdout, diagnostics to stderr, `--json` everywhere, meaningful exit codes.
+
+```bash
+npx @youtubesearch/cli search "karpathy intro to large language models" --limit 5
+npx @youtubesearch/cli video zjkBMFhNj_g
+npx @youtubesearch/cli transcript zjkBMFhNj_g --start 1663 --end 2012 --format markdown
+npx @youtubesearch/cli summary zjkBMFhNj_g --sections executive_summary,key_points
+```
+
+All of the above work **keyless** on cached content. For everything else, get
+a free key (1,000 credits/month) at [youtubesearch.dev](https://youtubesearch.dev):
+
+```bash
+npx @youtubesearch/cli auth login     # stores the key in your config dir, mode 0600
+npx @youtubesearch/cli auth status    # shows the key + credit balance
+```
+
+## Commands
+
+| Command | Does |
+|---|---|
+| `search <query>` | Search videos (`--limit`, `--duration`, `--recency`, `--channel`) |
+| `video <id>` | Metadata, stats, chapters |
+| `transcript <id>` | Timestamped transcript (`--format`, `--start`, `--end`, `--max-tokens`) |
+| `summary <id>` | Structured summary (`--sections a,b,c`) |
+| `auth login` / `auth status` | Manage the stored API key |
+
+Exit codes: `0` success · `1` API/network error · `2` usage error · `3` auth error.
+
+## Environment
+
+| Var | What |
+|---|---|
+| `YOUTUBESEARCH_API_KEY` | API key; overrides the stored config |
+| `YOUTUBESEARCH_API_BASE` | API base URL (default `https://api.youtubesearch.dev`) |
+
+## From source
+
+Node ≥ 20, zero runtime dependencies:
+
+```bash
+npm ci && npm run build
+node dist/cli.js --help
+```
+
+API docs: [youtubesearch.dev/docs](https://youtubesearch.dev/docs) ·
+MIT © 2026 YouTubeSearch

package/dist/api.js

@@ -0,0 +1,66 @@
+// Fetch wrapper for the YouTubeSearch REST API + typed error handling.
+const DEFAULT_BASE = "https://api.youtubesearch.dev";
+export function apiBase() {
+    const override = process.env.YOUTUBESEARCH_API_BASE;
+    const base = override && override.trim() !== "" ? override.trim() : DEFAULT_BASE;
+    return base.replace(/\/+$/, "");
+}
+/** An error response from the API (wire format {error, message}) or a network failure (status 0). */
+export class ApiError extends Error {
+    code;
+    status;
+    retryAfter;
+    constructor(code, message, status, retryAfter = null) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.retryAfter = retryAfter;
+        this.name = "ApiError";
+    }
+}
+export async function apiRequest(path, key, options = {}) {
+    const url = new URL(apiBase() + path);
+    for (const [name, value] of Object.entries(options.query ?? {})) {
+        if (value !== undefined)
+            url.searchParams.set(name, String(value));
+    }
+    const headers = { accept: "application/json" };
+    if (key)
+        headers.authorization = `Bearer ${key}`;
+    if (options.body !== undefined)
+        headers["content-type"] = "application/json";
+    let res;
+    try {
+        res = await fetch(url, {
+            method: options.method ?? "GET",
+            headers,
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+    }
+    catch (err) {
+        throw new ApiError("NETWORK", describeFetchError(err), 0);
+    }
+    const text = await res.text();
+    let data;
+    try {
+        data = text === "" ? undefined : JSON.parse(text);
+    }
+    catch {
+        data = undefined;
+    }
+    if (!res.ok) {
+        const body = (data ?? {});
+        const code = typeof body.error === "string" ? body.error : `HTTP_${res.status}`;
+        const message = typeof body.message === "string" ? body.message : text || res.statusText || "request failed";
+        throw new ApiError(code, message, res.status, res.headers.get("retry-after"));
+    }
+    return data;
+}
+function describeFetchError(err) {
+    if (err instanceof Error) {
+        const cause = err.cause;
+        const causeMessage = cause instanceof Error ? cause.message : undefined;
+        return causeMessage ? `${err.message} (${causeMessage})` : err.message;
+    }
+    return String(err);
+}

package/dist/cli.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+// youtubesearch — agent-facing CLI for the YouTubeSearch REST API.
+// Results to stdout, diagnostics to stderr.
+// Exit codes: 0 success, 1 API/network error, 2 usage error, 3 auth error.
+import { readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { parseArgs } from "node:util";
+import { ApiError, apiBase, apiRequest } from "./api.js";
+import { configPath, displayKey, readConfig, resolveKey, writeConfig } from "./config.js";
+import { renderCredits, renderSearch, renderSummary, renderVideo } from "./render.js";
+// A closed pipe (e.g. `youtubesearch ... | head`) is a normal way for a
+// consumer to stop reading — exit quietly instead of crashing.
+process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE")
+        process.exit(0);
+    throw err;
+});
+class UsageError extends Error {
+}
+const TOP_USAGE = `Usage: youtubesearch <command> [options]
+
+Agent-optimized YouTube search, transcripts, and summaries.
+
+Commands:
+  search <query>     Search videos (POST /v1/search)
+  video <id>         Video metadata: stats, chapters (GET /v1/videos/{id})
+  transcript <id>    Timestamped transcript (GET /v1/videos/{id}/transcript)
+  summary <id>       Structured summary (GET /v1/videos/{id}/summary)
+  auth login         Store an API key in the local config
+  auth status        Show the configured key and credit balance
+
+Options:
+  --help             Show this help (each command also accepts --help)
+  --version          Print the CLI version
+
+Environment:
+  YOUTUBESEARCH_API_KEY   API key; overrides the stored config
+  YOUTUBESEARCH_API_BASE  API base URL (default ${apiBase()})
+
+Without a key the CLI still works on the keyless tier (cached content only).
+Exit codes: 0 success, 1 API or network error, 2 usage error, 3 auth error.
+`;
+const SEARCH_USAGE = `Usage: youtubesearch search <query> [options]
+
+Options:
+  --limit <n>                          Max results (server default 10, max 20)
+  --duration <short|medium|long>       Filter by video length
+  --recency <hour|day|week|month|year> Filter by upload time
+  --channel <name>                     Filter by channel
+  --json                               Print the raw JSON response
+  --help                               Show this help
+`;
+const VIDEO_USAGE = `Usage: youtubesearch video <id> [options]
+
+Options:
+  --json    Print the raw JSON response
+  --help    Show this help
+`;
+const TRANSCRIPT_USAGE = `Usage: youtubesearch transcript <id> [options]
+
+Options:
+  --format <markdown|json|plain>  Output format (default markdown)
+  --start <seconds>               Window start
+  --end <seconds>                 Window end
+  --max-tokens <n>                Truncate to roughly this many tokens
+  --help                          Show this help
+
+markdown/plain print the transcript text; json prints the full JSON response.
+`;
+const SUMMARY_USAGE = `Usage: youtubesearch summary <id> [options]
+
+Options:
+  --sections <a,b,c>  Comma-separated section names (e.g. key_points,insights)
+  --json              Print the raw JSON response
+  --help              Show this help
+`;
+const AUTH_USAGE = `Usage: youtubesearch auth <login|status>
+
+Subcommands:
+  login [--key ys_live_...]  Store an API key (reads stdin when --key is absent)
+  status                     Show the configured key and credit balance
+`;
+const AUTH_LOGIN_USAGE = `Usage: youtubesearch auth login [--key ys_live_...]
+
+Stores the key in ${configPath()} (mode 0600).
+When --key is absent the key is read from stdin.
+`;
+const AUTH_STATUS_USAGE = `Usage: youtubesearch auth status
+
+Shows whether a key is configured and its credit balance (GET /v1/credits).
+`;
+/**
+ * Subcommand pattern: the command name has already been shifted off, so the
+ * remaining args (flags after the subcommand) get a strict parse.
+ */
+function parseFlags(args, flags) {
+    try {
+        const { values, positionals } = parseArgs({
+            args,
+            options: { ...flags, help: { type: "boolean" } },
+            strict: true,
+            allowPositionals: true,
+        });
+        return { values, positionals };
+    }
+    catch (err) {
+        throw new UsageError(err instanceof Error ? err.message : String(err));
+    }
+}
+function parseNumberFlag(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const n = Number(value);
+    if (typeof value !== "string" || value.trim() === "" || !Number.isFinite(n)) {
+        throw new UsageError(`${flag} expects a number, got '${String(value)}'`);
+    }
+    return n;
+}
+function parseChoiceFlag(value, flag, choices) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !choices.includes(value)) {
+        throw new UsageError(`${flag} must be one of: ${choices.join(", ")}`);
+    }
+    return value;
+}
+function requireId(positionals, usage) {
+    const id = positionals[0];
+    if (!id)
+        throw new UsageError(`missing <id> argument\n${usage.trimEnd()}`);
+    if (positionals.length > 1) {
+        throw new UsageError(`unexpected extra argument '${positionals[1]}'`);
+    }
+    return id;
+}
+function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function readLineFromStdin() {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin });
+        let done = false;
+        rl.once("line", (line) => {
+            done = true;
+            rl.close();
+            resolve(line);
+        });
+        rl.once("close", () => {
+            if (!done)
+                resolve("");
+        });
+    });
+}
+function cliVersion() {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version ?? "0.0.0";
+}
+// ---------------------------------------------------------------- commands
+async function cmdAuthLogin(args) {
+    const { values } = parseFlags(args, { key: { type: "string" } });
+    if (values.help) {
+        process.stdout.write(AUTH_LOGIN_USAGE);
+        return 0;
+    }
+    let key = typeof values.key === "string" ? values.key.trim() : "";
+    if (key === "") {
+        if (process.stdin.isTTY)
+            process.stderr.write("Enter your API key (ys_live_...): ");
+        key = (await readLineFromStdin()).trim();
+    }
+    if (key === "") {
+        throw new UsageError("no API key provided (pass --key or pipe the key on stdin)");
+    }
+    const config = readConfig();
+    config.api_key = key;
+    writeConfig(config);
+    process.stdout.write(`Saved API key ${displayKey(key)} to ${configPath()}\n`);
+    return 0;
+}
+async function cmdAuthStatus(args) {
+    const { values } = parseFlags(args, {});
+    if (values.help) {
+        process.stdout.write(AUTH_STATUS_USAGE);
+        return 0;
+    }
+    const { key, source } = resolveKey();
+    if (!key) {
+        process.stdout.write("No API key configured (keyless tier: cached content only).\n" +
+            "Run 'youtubesearch auth login' to add one.\n");
+        return 0;
+    }
+    const from = source === "env" ? "YOUTUBESEARCH_API_KEY env var" : configPath();
+    process.stdout.write(`API key: ${displayKey(key)} (from ${from})\n`);
+    const credits = await apiRequest("/v1/credits", key);
+    process.stdout.write(renderCredits(credits));
+    return 0;
+}
+async function cmdSearch(args) {
+    const { values, positionals } = parseFlags(args, {
+        limit: { type: "string" },
+        duration: { type: "string" },
+        recency: { type: "string" },
+        channel: { type: "string" },
+        json: { type: "boolean" },
+    });
+    if (values.help) {
+        process.stdout.write(SEARCH_USAGE);
+        return 0;
+    }
+    const query = positionals.join(" ").trim();
+    if (query === "")
+        throw new UsageError(`missing <query> argument\n${SEARCH_USAGE.trimEnd()}`);
+    const limit = parseNumberFlag(values.limit, "--limit");
+    const duration = parseChoiceFlag(values.duration, "--duration", ["short", "medium", "long"]);
+    const recency = parseChoiceFlag(values.recency, "--recency", [
+        "hour",
+        "day",
+        "week",
+        "month",
+        "year",
+    ]);
+    const channel = typeof values.channel === "string" ? values.channel : undefined;
+    const body = { query };
+    if (limit !== undefined)
+        body.limit = limit;
+    if (duration || recency || channel)
+        body.filters = { duration, recency, channel };
+    const { key } = resolveKey();
+    const result = await apiRequest("/v1/search", key, { method: "POST", body });
+    if (values.json)
+        printJson(result);
+    else
+        process.stdout.write(renderSearch(result));
+    return 0;
+}
+async function cmdVideo(args) {
+    const { values, positionals } = parseFlags(args, { json: { type: "boolean" } });
+    if (values.help) {
+        process.stdout.write(VIDEO_USAGE);
+        return 0;
+    }
+    const id = requireId(positionals, VIDEO_USAGE);
+    const { key } = resolveKey();
+    const result = await apiRequest(`/v1/videos/${encodeURIComponent(id)}`, key);
+    if (values.json)
+        printJson(result);
+    else
+        process.stdout.write(renderVideo(result));
+    return 0;
+}
+async function cmdTranscript(args) {
+    const { values, positionals } = parseFlags(args, {
+        format: { type: "string" },
+        start: { type: "string" },
+        end: { type: "string" },
+        "max-tokens": { type: "string" },
+    });
+    if (values.help) {
+        process.stdout.write(TRANSCRIPT_USAGE);
+        return 0;
+    }
+    const id = requireId(positionals, TRANSCRIPT_USAGE);
+    const format = parseChoiceFlag(values.format, "--format", ["markdown", "json", "plain"]) ?? "markdown";
+    const { key } = resolveKey();
+    const result = await apiRequest(`/v1/videos/${encodeURIComponent(id)}/transcript`, key, {
+        query: {
+            format,
+            start: parseNumberFlag(values.start, "--start"),
+            end: parseNumberFlag(values.end, "--end"),
+            max_tokens: parseNumberFlag(values["max-tokens"], "--max-tokens"),
+        },
+    });
+    if (format === "json") {
+        printJson(result);
+        return 0;
+    }
+    const payload = (result ?? {});
+    if (payload.truncated === true) {
+        process.stderr.write("note: transcript truncated (--max-tokens)\n");
+    }
+    const text = typeof payload.transcript === "string" ? payload.transcript : "";
+    process.stdout.write(text.endsWith("\n") || text === "" ? text : text + "\n");
+    return 0;
+}
+async function cmdSummary(args) {
+    const { values, positionals } = parseFlags(args, {
+        sections: { type: "string" },
+        json: { type: "boolean" },
+    });
+    if (values.help) {
+        process.stdout.write(SUMMARY_USAGE);
+        return 0;
+    }
+    const id = requireId(positionals, SUMMARY_USAGE);
+    const sections = typeof values.sections === "string" ? values.sections : undefined;
+    const { key } = resolveKey();
+    const result = await apiRequest(`/v1/videos/${encodeURIComponent(id)}/summary`, key, {
+        query: { sections },
+    });
+    if (values.json)
+        printJson(result);
+    else
+        process.stdout.write(renderSummary(result));
+    return 0;
+}
+// ---------------------------------------------------------------- dispatch
+async function run(argv) {
+    const command = argv[0];
+    if (command === undefined) {
+        process.stderr.write(TOP_USAGE);
+        return 2;
+    }
+    if (command === "--help" || command === "-h" || command === "help") {
+        process.stdout.write(TOP_USAGE);
+        return 0;
+    }
+    if (command === "--version" || command === "-v") {
+        process.stdout.write(cliVersion() + "\n");
+        return 0;
+    }
+    const rest = argv.slice(1);
+    switch (command) {
+        case "auth": {
+            const sub = rest[0];
+            if (sub === "login")
+                return cmdAuthLogin(rest.slice(1));
+            if (sub === "status")
+                return cmdAuthStatus(rest.slice(1));
+            if (sub === "--help" || sub === "-h") {
+                process.stdout.write(AUTH_USAGE);
+                return 0;
+            }
+            throw new UsageError(sub === undefined ? `missing auth subcommand\n${AUTH_USAGE.trimEnd()}` : `unknown auth subcommand '${sub}'`);
+        }
+        case "search":
+            return cmdSearch(rest);
+        case "video":
+            return cmdVideo(rest);
+        case "transcript":
+            return cmdTranscript(rest);
+        case "summary":
+            return cmdSummary(rest);
+        default:
+            throw new UsageError(`unknown command '${command}'\nRun 'youtubesearch --help' for usage.`);
+    }
+}
+async function main() {
+    try {
+        process.exitCode = await run(process.argv.slice(2));
+    }
+    catch (err) {
+        if (err instanceof UsageError) {
+            process.stderr.write(`error: ${err.message}\n`);
+            process.exitCode = 2;
+            return;
+        }
+        if (err instanceof ApiError) {
+            process.stderr.write(`${err.code}: ${err.message}\n`);
+            if (err.status === 401 && err.code === "KEY_REQUIRED") {
+                process.stderr.write("hint: run 'youtubesearch auth login' to configure an API key\n");
+            }
+            if ((err.status === 402 || err.status === 429) && err.retryAfter) {
+                process.stderr.write(`retry-after: ${err.retryAfter}s\n`);
+            }
+            process.exitCode = err.status === 401 || err.status === 403 ? 3 : 1;
+            return;
+        }
+        process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/config.js

@@ -0,0 +1,56 @@
+// XDG config read/write for the stored API key.
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function configDir() {
+    if (process.platform === "win32") {
+        const base = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        return join(base, "youtubesearch");
+    }
+    const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(base, "youtubesearch");
+}
+export function configPath() {
+    return join(configDir(), "config.json");
+}
+export function readConfig() {
+    try {
+        const parsed = JSON.parse(readFileSync(configPath(), "utf8"));
+        if (parsed !== null && typeof parsed === "object")
+            return parsed;
+    }
+    catch {
+        // Missing or unreadable config is the same as no config.
+    }
+    return {};
+}
+export function writeConfig(config) {
+    mkdirSync(configDir(), { recursive: true, mode: 0o700 });
+    const file = configPath();
+    writeFileSync(file, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+    // writeFileSync's mode only applies when creating the file; enforce it on
+    // overwrite too so the key never sits in a group/world-readable file.
+    chmodSync(file, 0o600);
+}
+/** Resolve the API key: YOUTUBESEARCH_API_KEY env var wins over the config file. */
+export function resolveKey() {
+    const envKey = process.env.YOUTUBESEARCH_API_KEY;
+    if (envKey)
+        return { key: envKey, source: "env" };
+    const fileKey = readConfig().api_key;
+    if (fileKey)
+        return { key: fileKey, source: "config" };
+    return {};
+}
+/**
+ * Display form of a key: prefix + first 4 and last 4 chars of the random part.
+ * Never returns the full key.
+ */
+export function displayKey(key) {
+    const match = /^(ys_[a-z]+_)(.*)$/.exec(key);
+    const prefix = match ? match[1] : "";
+    const random = match ? match[2] : key;
+    if (random.length <= 8)
+        return `${prefix}${"*".repeat(random.length)}`;
+    return `${prefix}${random.slice(0, 4)}...${random.slice(-4)}`;
+}

package/dist/render.js

@@ -0,0 +1,117 @@
+// Human-readable rendering for stdout (plain text, no colors — agent-friendly).
+function asDict(value) {
+    return value !== null && typeof value === "object" ? value : {};
+}
+function str(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export function formatDuration(seconds) {
+    const total = num(seconds);
+    if (total === undefined)
+        return undefined;
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = Math.floor(total % 60);
+    const pad = (n) => String(n).padStart(2, "0");
+    return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${m}:${pad(s)}`;
+}
+function formatViews(count) {
+    const n = num(count);
+    return n === undefined ? undefined : `${n.toLocaleString("en-US")} views`;
+}
+export function renderSearch(result) {
+    const videos = asDict(result).videos;
+    if (!Array.isArray(videos) || videos.length === 0)
+        return "No results.\n";
+    const blocks = videos.map((entry, i) => {
+        const v = asDict(entry);
+        const lines = [`${i + 1}. ${str(v.title) ?? "(untitled)"}`];
+        const meta = [str(v.channel), formatDuration(v.duration_s), formatViews(v.view_count), str(v.published)]
+            .filter((part) => part !== undefined)
+            .join(" | ");
+        if (meta)
+            lines.push(`   ${meta}`);
+        if (str(v.youtube_id))
+            lines.push(`   https://youtu.be/${v.youtube_id}`);
+        if (str(v.description_snippet))
+            lines.push(`   ${v.description_snippet}`);
+        return lines.join("\n");
+    });
+    return blocks.join("\n\n") + "\n";
+}
+export function renderVideo(result) {
+    const v = asDict(result);
+    const lines = [str(v.title) ?? "(untitled)"];
+    const published = str(v.published_at);
+    const meta = [
+        str(v.channel),
+        formatDuration(v.duration_s),
+        formatViews(v.view_count),
+        published ? `published ${published.slice(0, 10)}` : undefined,
+    ]
+        .filter((part) => part !== undefined)
+        .join(" | ");
+    if (meta)
+        lines.push(meta);
+    if (str(v.youtube_id))
+        lines.push(`https://youtu.be/${v.youtube_id}`);
+    const description = str(v.description);
+    if (description)
+        lines.push("", description.trim());
+    if (Array.isArray(v.chapters) && v.chapters.length > 0) {
+        lines.push("", "Chapters:");
+        for (const entry of v.chapters) {
+            const chapter = asDict(entry);
+            const at = formatDuration(chapter.start_s) ?? "?";
+            lines.push(`  [${at}] ${str(chapter.title) ?? ""}`.trimEnd());
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+export function renderSummary(result) {
+    const sections = asDict(asDict(result).sections);
+    const entries = Object.entries(sections);
+    if (entries.length === 0)
+        return "No sections returned.\n";
+    const blocks = entries.map(([name, value]) => `## ${titleCase(name)}\n\n${renderSectionValue(value)}`);
+    return blocks.join("\n\n") + "\n";
+}
+function titleCase(name) {
+    return name
+        .split("_")
+        .map((word) => (word === "" ? word : word[0].toUpperCase() + word.slice(1)))
+        .join(" ");
+}
+function renderSectionValue(value) {
+    if (typeof value === "string")
+        return value.trim();
+    if (Array.isArray(value)) {
+        return value.map((item) => `- ${renderListItem(item)}`).join("\n");
+    }
+    return JSON.stringify(value, null, 2);
+}
+function renderListItem(item) {
+    if (typeof item === "string")
+        return item;
+    const o = asDict(item);
+    // timestamps section: {time, description}
+    if (str(o.time) && str(o.description))
+        return `[${o.time}] ${o.description}`;
+    // resources section: {name, url, ...}
+    if (str(o.name))
+        return str(o.url) ? `${o.name} (${o.url})` : `${o.name}`;
+    return JSON.stringify(item);
+}
+export function renderCredits(result) {
+    const c = asDict(result);
+    const lines = [
+        `Tier: ${str(c.tier) ?? "unknown"}`,
+        `Monthly allowance: ${num(c.monthly_allowance) ?? "?"} credits`,
+        `Used this month: ${num(c.used_this_month) ?? "?"}`,
+        `Remaining: ${num(c.remaining) ?? "?"}`,
+    ];
+    return lines.join("\n") + "\n";
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@youtubesearch/cli",
+  "version": "0.1.2",
+  "description": "Agent-optimized YouTube search, transcripts, and summaries. CLI for the YouTubeSearch API.",
+  "license": "MIT",
+  "homepage": "https://youtubesearch.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/youtubesearch-dev/youtubesearch.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/youtubesearch-dev/youtubesearch/issues"
+  },
+  "type": "module",
+  "bin": {
+    "youtubesearch": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "typescript": "^5.9"
+  }
+}