Skip to content
Back to search

podcli

Transcribe a podcast episode, shortlist clips, render shorts, and hand off titles and descriptions for publishing. Use when the user wants to process an episode, make clips, or drive podcli from an agent.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/nmbrthirteen/podcli with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/nmbrthirteen/podcli'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/nmbrthirteen--podcli/badge.svg)](/listings/nmbrthirteen--podcli)

HTML

<a href="/listings/nmbrthirteen--podcli"><img src="/api/listings/nmbrthirteen--podcli/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

No prerequisites. The installer fetches a self-contained binary, and the first run provisions Python, Node, FFmpeg, whisper.cpp, and the models it needs into a managed folder.

**macOS and Linux**

curl -fsSL https://podcli.com/install.sh | sh

**Windows (PowerShell)**

irm https://podcli.com/install.ps1 | iex

Runs on macOS (Apple Silicon), Linux (x64 and arm64), and Windows (x64). Intel Macs aren't supported.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 56 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: podcli
  3. description: Transcribe a podcast episode, shortlist clips, render shorts, and hand off titles and descriptions for publishing. Use when the user wants to process an episode, make clips, or drive podcli from an agent.
  4. ---
  5. # podcli
  6. Turn a long episode into short clips with face tracking and burned-in captions. Drive it from the CLI, the studio, or MCP.
  7. ## Setup
  8. ```bash
  9. curl -fsSL https://podcli.com/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 13 on GitHub
  10. podcli setup # once; mcp does not auto-provision
  11. podcli mcp install # Claude Code / Codex, whichever is on PATH
  12. podcli doctor --json # confirm backend, mcp, ffmpeg, models
  13. ```
  14. `--help` and `--version` never download. `podcli mcp` needs setup first because stdout is JSON-RPC.
  15. Clip scoring uses Claude Code or Codex login, or an Anthropic API key. Without those it falls back to heuristics. Speaker diarization needs AssemblyAI, or openai-whisper (a source install, or `podcli setup --speakers`) plus `HF_TOKEN`. The default whisper.cpp engine skips it.
  16. ## Process an episode (CLI)
  17. ```bash
  18. podcli process episode.mp4 --json --yes
  19. ```
  20. JSON on stdout: clip paths, durations, scores, titles, descriptions, tags, caption files. Logs on stderr. `-y/--yes` skips prompts. `NO_COLOR=1` turns off colour and spinners.
  21. Exit codes: 0 success, 1 runtime error, 2 usage, 130 interrupted.
  22. ## Process an episode (MCP)
  23. Prefer the short path so you do not load the full transcript:
  24. 1. `transcribe_podcast` (or `transcribe_start` + `job_status` on a long file)
  25. 2. `rank_clip_candidates(video_path)`: about 20 sentence-aligned candidates
  26. 3. Pick a subset. `suggest_clips` to store them, or `create_clip` / `batch_create_clips` to render
  27. 4. `list_outputs` if you only need paths on disk
  28. One-shot when the user wants finished files, not a review pass:
  29. 1. `process_episode(video_path)`
  30. 2. `job_status(job_id, wait_seconds: 30)` until `done`
  31. 3. Read clip paths, durations, scores, titles, captions from `result`
  32. The original tools stay as they were. These two are extras.
  33. ## After clips exist
  34. Titles, descriptions, thumbnails, brand review: PodStack commands (`/produce-shorts`, `/generate-titles`, `/generate-descriptions`, `/plan-thumbnails`, `/review-content`). Knowledge base is `.podcli/knowledge/`.
  35. Publishing is outside podcli unless YouTube is linked (`youtube` CLI / integrations). Hand the JSON (paths + titles + descriptions + tags) to the user's publisher.
  36. Do not call `get_ui_state(include_transcript: true)` unless you need to rewrite a range; use `rank_clip_candidates`. Do not run `podcli mcp` as the first command on a fresh install; run `podcli setup`.
README.md · README · 176 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="public/podcli-badge.png" height="72" alt="podcli" />
  3. </p>
  4. <p align="center">
  5. <strong>Open-source AI podcast clipper.</strong><br/>
  6. Turn a long episode into short clips with face tracking and burned-in captions. Drive it from the CLI, a web studio, or your coding agent.
  7. </p>
  8. <p align="center">
  9. <a href="https://podcli.com"><strong>podcli.com</strong></a> ·
  10. <a href="https://podcli.com/docs">Docs</a> ·
  11. <a href="#install">Install</a> ·
  12. <a href="#use-it-from-your-agent">MCP</a>
  13. </p>
  14. <p align="center">
  15. <a href="https://github.com/nmbrthirteen/podcli/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue" alt="license: AGPL-3.0" /></a>
  16. <a href="https://github.com/nmbrthirteen/podcli/stargazers"><img src="https://img.shields.io/github/stars/nmbrthirteen/podcli?style=social" alt="stars" /></a>
  17. </p>
  18. <p align="center">
  19. <a href="https://x.com/nikasiradze_/status/2056061654664708570">
  20. <img src="public/promo.gif" alt="Podcli demo" width="720" />
  21. </a>
  22. </p>
  23. <p align="center"><sub>▶ <a href="https://x.com/nikasiradze_/status/2056061654664708570">Watch with sound on X</a></sub></p>
  24. ```bash
  25. podcli process episode.mp4
  26. ```
  27. That one command transcribes the episode, picks the moments worth clipping, crops to the visible face, and burns the captions in. Transcription and rendering run on your machine. Clip scoring uses Claude Code or Codex login, or an Anthropic API key; without those it falls back to heuristics.
  28. ## Install
  29. No prerequisites. The installer fetches a self-contained binary, and the first run provisions Python, Node, FFmpeg, whisper.cpp, and the models it needs into a managed folder.
  30. **macOS and Linux**
  31. ```bash
  32. curl -fsSL https://podcli.com/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 42 on GitHub
  33. ```
  34. **Windows (PowerShell)**
  35. ```powershell
  36. irm https://podcli.com/install.ps1 | iex
  37. ```
  38. Runs on macOS (Apple Silicon), Linux (x64 and arm64), and Windows (x64). Intel Macs aren't supported.
  39. ## Quick start
  40. ```bash
  41. podcli # interactive menu, opens the web studio
  42. podcli process episode.mp4 # transcribe, pick moments, render clips
  43. podcli multicam ~/ep12 # sync every camera and mic, cut to the speaker, render the episode
  44. ```
  45. Clips land in `podcli-clips/` in the directory you ran it from, so each show keeps its own renders. Everything else (knowledge, presets, assets, clip history, cache) lives in one managed folder that follows you between directories. Set `PODCLI_OUTPUT` to render somewhere fixed instead.
  46. ## What you get
  47. **Clips**
  48. - 9:16, 16:9, or 1:1, with captions sized for each canvas
  49. - Face tracking that follows the visible face, split-screen layouts included. Following the active speaker needs AssemblyAI, or a source install with openai-whisper and `HF_TOKEN`
  50. - Multi-segment cuts that drop filler, long pauses, and tangents
  51. - Four caption styles: branded, hormozi, karaoke, subtle
  52. - Logos, intros, outros, and background music from a reusable asset library
  53. - Loudness-normalized audio and hardware encoding on VideoToolbox and NVENC, with a CPU fallback
  54. **Editing the full episode**
  55. - Multicam edit: point at one folder of camera and mic files, confirm who each file belongs to, and podcli syncs them by audio and corrects clock drift between devices
  56. - Automatic camera cuts that follow whoever is talking, with wide shots for crosstalk and a guest's answer held on the guest
  57. - Remote shows too: one file per person becomes a split screen, and a single gallery recording is split into a camera per tile. Questions stay on the split and the guest goes full frame on long answers
  58. - Render the episode as an MP4 with one WAV per person. Studio shoots can also go to Premiere or Final Cut as a timeline that points at your original files
  59. - Same edit from the studio (Multicam edit), the CLI (`podcli multicam <folder>`), or an agent (`manage_multicam`). Re-running reuses the sync and the cut, so only the step you changed runs again
  60. - With podcli Pro, steer the cut in the cloud editor: `podcli multicam <folder> --cloud` uploads per-camera proxies, a mic mix (about 550 MB for a two-hour, three-camera episode), and the transcript. Your original camera files stay on your computer, and `--pull` renders the cut you made there
  61. **Finding the moments**
  62. - Whisper transcription (speaker diarization on AssemblyAI, or openai-whisper from a source install or `podcli setup --speakers`), or bring your own transcript as `.txt`, `.srt`, or `.vtt`
  63. - AssemblyAI as an alternative engine, and yt-dlp to pull an episode straight from a URL
  64. - AI scoring against your knowledge base, checked against your episode database so it stops resuggesting moments you already published
  65. - Audio energy and laughter detection to build highlight reels
  66. **The studio at `localhost:3847`**
  67. - Library, episode workspace, multicam edit, per-clip detail, highlights, thumbnails, content, analytics, assets, knowledge, config, integrations, and MCP setup
  68. - `⌘K` command palette across pages, clips, and assets
  69. - Titles, descriptions, tags, and hashtags, with any section regenerated on your own guidance
  70. - Thumbnail studio for 16:9 and 9:16, with frame and text options
  71. - Transcript corrections that carry through to every render
  72. **Shipping it**
  73. - 32 MCP tools, so an agent can transcribe, score, and render through conversation
  74. - YouTube analytics to see which clips landed
  75. - DaVinci Resolve export as FCPXML when you want to finish by hand
  76. - Presets, clip history with duplicate detection, and a transcript cache
  77. ## Why podcli
  78. If you are weighing podcli against the cloud clippers, this is the difference:
  79. - Runs locally. Transcription and rendering happen on your machine by default, so episodes stay there. Data leaves your machine only through these destinations:
  80. - AssemblyAI, if you pick that engine: the episode audio.
  81. - AI scoring and titles: the transcript goes to podcli Pro when you are signed in, to Anthropic when you set `ANTHROPIC_API_KEY`, and to the provider behind your Claude Code or Codex login.
  82. - podcli Pro, when signed in: knowledge and asset sync, plus rendered clips and transcript slices if you turn on `PODCLI_CLOUD_SYNC=1` (off by default).
  83. - YouTube, if you link it: read-only analytics requests.
  84. - podcli multicam cloud, if you run `podcli multicam --cloud`: per-camera proxies, a mic mix, and the transcript.
  85. - Free and open source under AGPL-3.0. Exports are unlimited, full quality, and watermark-free.
  86. - Agent-native. 32 MCP tools let Claude Code or Codex drive the whole flow, from transcription to rendered clips and publish-ready titles.
  87. - A knowledge base keeps titles, captions, and descriptions in your show's voice, and stops the engine from resuggesting moments you already published.
  88. - DaVinci Resolve handoff. Export any clip as FCPXML when you want to finish the edit yourself.
  89. ## Use it from your agent
  90. podcli is an [MCP](https://modelcontextprotocol.io) server, so an agent can transcribe, suggest clips, and render them through conversation.
  91. ```bash
  92. podcli mcp install # registers it with Claude Code and Codex, whichever CLI is on PATH
  93. ```
  94. `--help` and `--version` never download anything. First run of `process`, `studio`, `transcribe`, or `multicam` provisions the engine. `podcli mcp` does not, because stdout is JSON-RPC. Run `podcli setup` once before you point an agent at it.
  95. ```bash
  96. podcli process episode.mp4 --json --yes
  97. podcli doctor --json
  98. ```
  99. `--json` writes one object to stdout and logs to stderr. `-y/--yes` skips prompts. `NO_COLOR=1` (or a non-TTY) turns off colour and spinners.
  100. `rank_clip_candidates` returns a shortlist so the agent does not have to read the whole transcript. `process_episode` runs the pipeline as one job; poll it with `job_status`. The workflow lives in [SKILL.md](SKILL.md). Tool names are generated into [llms.txt](llms.txt).
  101. Claude Desktop and Codex setup is in the [MCP docs](https://podcli.com/docs/mcp-server).
  102. ## Content workflow
  103. [PodStack](https://github.com/nmbrthirteen/podstack) ships with podcli as a set of Claude Code slash commands. They take a transcript to a publish-ready package: scored moments, titles, descriptions, thumbnail briefs, a brand review, and a publish checklist.
  104. ```
  105. /produce-shorts
  106. ```
  107. The commands live in `.claude/commands/`. [CLAUDE.md](CLAUDE.md) describes each one.
  108. ## Docs
  109. | Guide | What's in it |
  110. | ----- | ------------ |
  111. | [Getting started](https://podcli.com/docs) | Install, first episode, the whole flow |
  112. | [The studio](https://podcli.com/docs/the-studio) | Web UI: library, episodes, content, highlights |
  113. | [CLI](https://podcli.com/docs/cli) | Commands, flags, presets, assets |
  114. | [MCP server](https://podcli.com/docs/mcp-server) | Agent setup and available tools |
  115. | [Captions and formats](https://podcli.com/docs/captions-and-formats) | Styles, aspect ratios, cropping |
  116. | [Configuration](docs/configuration.md) | Environment variables, config profiles, transcript format |
  117. Docs are open source at [nmbrthirteen/podcli-docs](https://github.com/nmbrthirteen/podcli-docs).
  118. ## Contributing
  119. See [CONTRIBUTING.md](CONTRIBUTING.md) for the dev setup and conventions, and [RELEASE.md](RELEASE.md) for how releases are cut.
  120. ## Credits
  121. Content workflow powered by [PodStack](https://github.com/nmbrthirteen/podstack), inspired by [gstack](https://github.com/garrytan/gstack) by Garry Tan.
  122. ## License
  123. AGPL-3.0. See [LICENSE](LICENSE).
  124. Need podcli without AGPL terms? A commercial license is available. Email [siradze@nikusha.me](mailto:siradze@nikusha.me) with a one-line description of your use case.
install.ps1 · Bundled script · 127 lines · 1 finding marked
  1. # podcli installer for Windows - downloads the prebuilt native binary (no Go,
  2. # Node, Python, or ffmpeg needed; the binary provisions those on first run).
  3. # Usage: irm https://raw.githubusercontent.com/nmbrthirteen/podcli/main/install.ps1 | iex
    • Note: Runs a downloaded PowerShell script (iex / Invoke-Expression)
    • Line 3 on GitHub
  4. # Uninstall: & ([scriptblock]::Create((irm https://raw.githubusercontent.com/nmbrthirteen/podcli/main/install.ps1))) -Uninstall
  5. # Purge: & ([scriptblock]::Create((irm https://raw.githubusercontent.com/nmbrthirteen/podcli/main/install.ps1))) -Uninstall -Purge
  6. param([switch]$Uninstall, [switch]$Purge)
  7. $ErrorActionPreference = 'Stop'
  8. $repo = 'nmbrthirteen/podcli'
  9. $target = 'windows-amd64'
  10. $homeDir = Join-Path $env:LOCALAPPDATA 'podcli'
  11. $binDir = Join-Path $homeDir 'bin'
  12. function Get-UserPathEntry {
  13. $key = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment')
  14. if (-not $key) { return $null }
  15. $kind = [Microsoft.Win32.RegistryValueKind]::ExpandString
  16. try { $kind = $key.GetValueKind('Path') } catch {}
  17. [pscustomobject]@{
  18. Key = $key
  19. Kind = $kind
  20. Value = [string]$key.GetValue('Path', '', [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
  21. }
  22. }
  23. function Test-PathEntryEquals {
  24. param([string]$Entry, [string]$Target)
  25. try {
  26. return [IO.Path]::GetFullPath([Environment]::ExpandEnvironmentVariables($Entry)).TrimEnd('\') -ieq [IO.Path]::GetFullPath($Target).TrimEnd('\')
  27. } catch {
  28. return $Entry.TrimEnd('\') -ieq $Target.TrimEnd('\')
  29. }
  30. }
  31. function Send-EnvironmentPathChange {
  32. if (-not ('Podcli.NativeMethods' -as [type])) {
  33. Add-Type -Namespace Podcli -Name NativeMethods -MemberDefinition @'
  34. [DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
  35. public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam, uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);
  36. '@
  37. }
  38. $result = [UIntPtr]::Zero
  39. $status = [Podcli.NativeMethods]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [UIntPtr]::Zero, 'Environment', 0x0002, 5000, [ref]$result)
  40. if ($status -eq [IntPtr]::Zero) {
  41. $errorCode = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
  42. Write-Warning "could not broadcast PATH update (SendMessageTimeout error $errorCode); restart your terminal"
  43. }
  44. }
  45. if ($Uninstall) {
  46. Write-Host "Uninstalling podcli..."
  47. if ($Purge) {
  48. $targets = @($homeDir)
  49. } else {
  50. $targets = @($binDir, (Join-Path $homeDir 'runtime'), (Join-Path $homeDir 'models'))
  51. }
  52. foreach ($p in $targets) {
  53. if (Test-Path $p) {
  54. try {
  55. Remove-Item $p -Recurse -Force -ErrorAction Stop
  56. Write-Host " removed: $p"
  57. } catch {
  58. Write-Warning ("could not remove {0}: {1}" -f $p, $_.Exception.Message)
  59. }
  60. }
  61. }
  62. $pathEntry = Get-UserPathEntry
  63. if ($pathEntry) {
  64. $parts = @($pathEntry.Value -split ';' | Where-Object { $_ })
  65. $kept = @($parts | Where-Object { -not (Test-PathEntryEquals $_ $binDir) })
  66. if ($kept.Count -ne $parts.Count) {
  67. $pathEntry.Key.SetValue('Path', ($kept -join ';'), $pathEntry.Kind)
  68. Send-EnvironmentPathChange
  69. Write-Host " removed from user PATH (restart your terminal)"
  70. }
  71. }
  72. if ($Purge) {
  73. Write-Host " removed podcli and user data."
  74. } else {
  75. Write-Host " removed podcli runtime files. User data preserved; pass -Purge to remove it."
  76. }
  77. exit 0
  78. }
  79. New-Item -ItemType Directory -Force -Path $binDir | Out-Null
  80. $version = $env:PODCLI_VERSION
  81. if (-not $version) {
  82. $rel = Invoke-RestMethod "https://api.github.com/repos/$repo/releases/latest" -Headers @{ 'User-Agent' = 'podcli-install' }
  83. $version = $rel.tag_name -replace '^v', ''
  84. }
  85. $asset = "podcli-$target.exe"
  86. $base = "https://github.com/$repo/releases/download/v$version"
  87. Write-Host "Installing podcli v$version ($target)..."
  88. $dest = Join-Path $binDir 'podcli.exe'
  89. Invoke-WebRequest "$base/$asset" -OutFile $dest -UseBasicParsing
  90. try {
  91. $sums = Invoke-RestMethod "$base/checksums.txt" -Headers @{ 'Accept' = 'text/plain'; 'User-Agent' = 'podcli-install' }
  92. $want = $sums -split "`n" |
  93. Where-Object { $_ -match ([regex]::Escape($asset) + '\s*$') } |
  94. ForEach-Object { ($_ -split '\s+')[0] } | Select-Object -First 1
  95. if ($want) {
  96. $got = (Get-FileHash $dest -Algorithm SHA256).Hash.ToLower()
  97. if ($got -ne $want.ToLower()) { Remove-Item $dest -Force; throw "checksum mismatch (got $got want $want)" }
  98. Write-Host " checksum verified"
  99. } else {
  100. Write-Host " no checksum entry for $asset - skipped verification"
  101. }
  102. } catch {
  103. Write-Host " checksum verification skipped: $($_.Exception.Message)"
  104. }
  105. $pathEntry = Get-UserPathEntry
  106. if ($pathEntry) {
  107. $parts = @($pathEntry.Value -split ';' | Where-Object { $_ })
  108. if (-not ($parts | Where-Object { Test-PathEntryEquals $_ $binDir })) {
  109. $pathEntry.Key.SetValue('Path', ($binDir + ';' + $pathEntry.Value), $pathEntry.Kind)
  110. Send-EnvironmentPathChange
  111. Write-Host " added to PATH (restart your terminal)"
  112. }
  113. }
  114. Write-Host ""
  115. Write-Host "Done - run: podcli"
install.sh · Bundled script · 128 lines · 3 findings marked
  1. #!/bin/sh
  2. # podcli installer - downloads the prebuilt native binary (no Go, Node, Python,
  3. # or ffmpeg needed; the binary provisions those itself on first run).
  4. # Usage: curl -fsSL https://raw.githubusercontent.com/nmbrthirteen/podcli/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 4 on GitHub
  5. # Uninstall: curl -fsSL https://raw.githubusercontent.com/nmbrthirteen/podcli/main/install.sh | sh -s -- --uninstall
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 5 on GitHub
  6. # Purge: curl -fsSL https://raw.githubusercontent.com/nmbrthirteen/podcli/main/install.sh | sh -s -- --uninstall --purge
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 6 on GitHub
  7. set -eu
  8. REPO="nmbrthirteen/podcli"
  9. err() { echo "podcli-install: $*" >&2; exit 1; }
  10. command -v curl >/dev/null 2>&1 || err "curl is required"
  11. os=$(uname -s 2>/dev/null || echo unknown)
  12. arch=$(uname -m 2>/dev/null || echo unknown)
  13. case "$os" in
  14. Darwin) goos=darwin; home_dir="$HOME/Library/Application Support/podcli" ;;
  15. Linux) goos=linux; home_dir="${XDG_DATA_HOME:-$HOME/.local/share}/podcli" ;;
  16. *) err "unsupported OS: $os (on Windows use install.ps1)" ;;
  17. esac
  18. bin_dir="$home_dir/bin"
  19. if [ "${1:-}" = "--uninstall" ]; then
  20. purge=0
  21. [ "${2:-}" = "--purge" ] && purge=1
  22. echo "Uninstalling podcli..."
  23. for d in /usr/local/bin "$HOME/.local/bin"; do
  24. link="$d/podcli"
  25. if [ -L "$link" ] && [ "$(readlink "$link")" = "$bin_dir/podcli" ]; then
  26. if rm -f "$link"; then
  27. echo " removed link: $link"
  28. else
  29. echo " warning: could not remove link: $link" >&2
  30. fi
  31. fi
  32. done
  33. if [ "$purge" = 1 ]; then
  34. set -- "$home_dir"
  35. else
  36. set -- "$bin_dir" "$home_dir/runtime" "$home_dir/models"
  37. fi
  38. for p in "$@"; do
  39. if [ -e "$p" ]; then
  40. if rm -rf "$p"; then
  41. echo " removed: $p"
  42. else
  43. echo " warning: could not remove: $p" >&2
  44. fi
  45. fi
  46. done
  47. if [ "$purge" = 1 ]; then
  48. echo " removed podcli and all managed data from: $home_dir"
  49. else
  50. echo " removed app files from: $home_dir"
  51. echo " kept user data (config, knowledge, presets, assets, history, cache)."
  52. echo " To remove everything, re-run with: --uninstall --purge"
  53. fi
  54. exit 0
  55. fi
  56. case "$arch" in
  57. x86_64|amd64) goarch=amd64 ;;
  58. arm64|aarch64) goarch=arm64 ;;
  59. *) err "unsupported architecture: $arch" ;;
  60. esac
  61. target="${goos}-${goarch}"
  62. if [ "$target" = "darwin-amd64" ]; then
  63. err "Intel Macs aren't supported. Apple Silicon, Linux (x64 and arm64), and Windows (x64) are."
  64. fi
  65. mkdir -p "$bin_dir"
  66. version="${PODCLI_VERSION:-}"
  67. if [ -z "$version" ]; then
  68. version=$(curl -fsSL "https://api.github.com/repos/$REPO/releases/latest" \
  69. | sed -n 's/.*"tag_name":[ ]*"v\{0,1\}\([^"]*\)".*/\1/p' | head -1)
  70. [ -n "$version" ] || err "could not resolve the latest release"
  71. fi
  72. asset="podcli-${target}"
  73. base="https://github.com/$REPO/releases/download/v${version}"
  74. echo "Installing podcli v${version} (${target})..."
  75. tmp=$(mktemp -d)
  76. trap 'rm -rf "$tmp"' EXIT
  77. curl -fSL --proto '=https' --tlsv1.2 "$base/$asset" -o "$tmp/$asset" || err "download failed"
  78. if curl -fsSL "$base/checksums.txt" -o "$tmp/sums" 2>/dev/null; then
  79. want=$(grep "[ /]$asset\$" "$tmp/sums" | awk '{print $1}' | head -1)
  80. if [ -n "$want" ]; then
  81. if command -v sha256sum >/dev/null 2>&1; then
  82. got=$(sha256sum "$tmp/$asset" | awk '{print $1}')
  83. else
  84. got=$(shasum -a 256 "$tmp/$asset" | awk '{print $1}')
  85. fi
  86. [ "$got" = "$want" ] || err "checksum mismatch (got $got want $want)"
  87. echo " checksum verified"
  88. else
  89. echo " no checksum entry for $asset - skipped verification" >&2
  90. fi
  91. else
  92. echo " no checksums.txt in release - skipped verification" >&2
  93. fi
  94. cp "$tmp/$asset" "$bin_dir/podcli"
  95. chmod 0755 "$bin_dir/podcli"
  96. # Apple Silicon's kernel kills cross-compiled (Linux-built) arm64 binaries whose
  97. # signature it won't accept, even with a valid-on-disk ad-hoc signature. Re-sign
  98. # ad-hoc on the Mac so the binary runs.
  99. if [ "$goos" = "darwin" ] && command -v codesign >/dev/null 2>&1; then
  100. codesign --force --sign - "$bin_dir/podcli" >/dev/null 2>&1 || true
  101. fi
  102. echo " installed: $bin_dir/podcli"
  103. linked=""
  104. for d in /usr/local/bin "$HOME/.local/bin"; do
  105. if [ -d "$d" ] && [ -w "$d" ]; then
  106. ln -sf "$bin_dir/podcli" "$d/podcli" 2>/dev/null && { linked="$d/podcli"; break; }
  107. fi
  108. done
  109. echo
  110. if [ -n "$linked" ]; then
  111. echo "Done - run: podcli"
  112. else
  113. echo "Done. Add podcli to your PATH:"
  114. echo " export PATH=\"$bin_dir:\$PATH\""
  115. echo "Then run: podcli"
  116. fi
scripts/gen-docs-manifest.mjs · Bundled script · 135 lines · 2 findings marked
  1. import { readFileSync, writeFileSync, readdirSync } from "fs";
  2. import { execSync } from "child_process";
  3. import { join, dirname } from "path";
  4. import { fileURLToPath } from "url";
  5. const root = join(dirname(fileURLToPath(import.meta.url)), "..");
  6. const read = (p) => readFileSync(join(root, p), "utf8");
  7. function tsSources(dir, acc = []) {
  8. for (const entry of readdirSync(join(root, dir), { withFileTypes: true })) {
  9. const rel = join(dir, entry.name);
  10. if (entry.isDirectory()) tsSources(rel, acc);
  11. else if (entry.name.endsWith(".ts")) acc.push(read(rel));
  12. }
  13. return acc;
  14. }
  15. function collectToolNames(sources) {
  16. const defs = new Map();
  17. const names = [];
  18. let registrations = 0;
  19. for (const src of sources) {
  20. for (const m of src.matchAll(/const\s+(\w+)\s*=\s*\{\s*name:\s*"([^"]+)"/g)) {
  21. defs.set(m[1], m[2]);
  22. }
  23. }
  24. for (const src of sources) {
  25. // server.registerTool (the non-deprecated API, needed for a strict
  26. // input schema that server.tool's raw-shape shorthand can't express)
  27. // takes its name the same way: as the first positional argument.
  28. for (const m of src.matchAll(/server\.(?:registerTool|tool)\(\s*(?:"([^"]+)"|(\w+)\.name)/g)) {
  29. registrations += 1;
  30. if (m[1]) names.push(m[1]);
  31. else if (defs.has(m[2])) names.push(defs.get(m[2]));
  32. }
  33. }
  34. if (names.length !== registrations) {
  35. console.error(`resolved ${names.length} tool names for ${registrations} server.tool(/server.registerTool( registrations`);
  36. process.exit(1);
  37. }
  38. return names.sort();
  39. }
  40. const mainTsx = read("src/ui/client/main.tsx");
  41. const studioRoutes = [...mainTsx.matchAll(/<Route\s+path="([^"]+)"\s+element=\{<(\w+)/g)].flatMap((m) =>
  42. /Navigate/.test(m[0]) ? [] : [{ path: m[1], component: m[2] }],
  43. );
  44. let version = "";
  45. try {
  46. version = execSync("git describe --tags --abbrev=0", { cwd: root }).toString().trim();
  47. } catch {
  48. version = JSON.parse(read("package.json")).version || "";
  49. }
  50. const mcpToolNames = collectToolNames(tsSources("src"));
  51. const manifest = {
  52. version,
  53. packageVersion: JSON.parse(read("package.json")).version || "",
  54. mcpToolCount: mcpToolNames.length,
  55. mcpToolNames,
  56. studioRouteCount: studioRoutes.length,
  57. studioRoutes,
  58. };
  59. writeFileSync(join(root, "docs-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
  60. console.log("wrote docs-manifest.json:", JSON.stringify(manifest));
  61. const toolList = mcpToolNames.map((n) => `- ${n}`).join("\n");
  62. const llms = `# podcli
  63. Open-source AI podcast clipper. Turn a long episode into short clips with face tracking and burned-in captions. Drive it from the CLI, a web studio, or your coding agent.
  64. Install: \`curl -fsSL https://podcli.com/install.sh | sh\`
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 86 on GitHub
  65. Windows: \`irm https://podcli.com/install.ps1 | iex\`
  66. Version: ${manifest.packageVersion}
  67. License: AGPL-3.0. Commercial licensing: siradze@nikusha.me
  68. Repo: https://github.com/nmbrthirteen/podcli
  69. Site: https://podcli.com
  70. ## Platforms
  71. macOS (Apple Silicon), Linux (x64 and arm64), Windows (x64). Intel Macs aren't supported.
  72. ## Auth for AI scoring
  73. Clip scoring uses Claude Code or Codex login, or an Anthropic API key; without those it falls back to heuristics. Speaker diarization needs HF_TOKEN. The local engine is free; podcli Pro is an optional cloud editor and account (\`podcli login\`).
  74. ## First run
  75. \`podcli process episode.mp4\` (or studio / transcribe / multicam) provisions the engine on first run.
  76. \`podcli mcp\` does not: stdout is JSON-RPC. Run \`podcli setup\` once before pointing an agent at it.
  77. \`--help\` and \`--version\` never download anything.
  78. ## Agent CLI
  79. \`\`\`
  80. podcli process episode.mp4 --json --yes
  81. podcli doctor --json
  82. \`\`\`
  83. JSON on stdout; progress and logs on stderr. \`-y/--yes\` skips prompts. \`NO_COLOR=1\` or a non-TTY turns off colour and spinners.
  84. Exit codes: 0 success, 1 runtime error, 2 usage, 130 interrupted.
  85. ## MCP
  86. ${mcpToolNames.length} tools. \`podcli mcp\` on stdio; \`podcli mcp install\` registers with Claude Code and Codex.
  87. ${toolList}
  88. \`rank_clip_candidates\` returns a shortlist so you do not have to read the whole transcript.
  89. \`process_episode\` runs the pipeline as one job; poll it with \`job_status\`.
  90. ## Also
  91. Clips (9:16 / 16:9 / 1:1) and full-episode multicam edit. Knowledge base at .podcli/knowledge/. PodStack slash commands in .claude/commands/.
  92. `;
  93. writeFileSync(join(root, "llms.txt"), llms);
  94. console.log("wrote llms.txt");

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.