Late API Management Skill

Operational workflows for managing scheduled social media posts via the Late.co API (https://getlate.dev/api/v1). This skill helps you list, reschedule, bulk delete, and sync posts when the posting schedule changes or issues arise.

Prerequisites

• LATE_API_KEY environment variable set (Bearer token, format: sk_...)
• The project's schedule.json in the repo root defines posting time slots per platform

Authentication

All requests use Bearer auth:

curl -H "Authorization: Bearer $env:LATE_API_KEY" https://getlate.dev/api/v1/posts

API Base URL

https://getlate.dev/api/v1

API Reference

Posts

Accounts

Profiles

Queue (Late's built-in scheduling)

Media

Analytics

Publishing Logs

Webhooks

Rate Limits

Additional limits:

• Velocity: 15 posts/hour/account
• Daily: Platform-specific (X: 20, Pinterest: 25, Instagram/Facebook: 100, Threads: 250, others: 50)
• Cooldown: Escalating backoff on repeated errors (10min → 20min → 40min → 24h)

Project-Specific Context

schedule.json Format

The project's schedule.json (repo root) defines local posting time slots:

{
  "timezone": "America/Chicago",
  "platforms": {
    "linkedin": {
      "slots": [
        { "days": ["tue", "wed"], "time": "08:00", "label": "Morning thought leadership" }
      ],
      "avoidDays": ["sat", "sun"]
    }
  }
}

Existing LateApiClient (src/L2-clients/late/lateApi.ts)

The project has a TypeScript client with these methods:

• listProfiles() → LateProfile[]
• listAccounts() → LateAccount[]
• getScheduledPosts(platform?) → LatePost[]
• getDraftPosts(platform?) → LatePost[]
• createPost(params) → LatePost
• updatePost(postId, updates) → LatePost
• deletePost(postId) → void
• uploadMedia(filePath) → {url, type}
• validateConnection() → {valid, profileName?, error?}
• listQueues(profileId, all?) — List all queues for a profile
• createQueue(params) — Create a new queue
• updateQueue(params) — Update queue (supports reshuffleExisting)
• deleteQueue(profileId, queueId) — Delete a queue
• previewQueue(profileId, queueId?, count?) — Preview upcoming slot times
• getNextQueueSlot(profileId, queueId?) — Get next available slot

Approved posts use queue-first scheduling: VidPipe resolves queueId via {platform}-{clipType} naming, sends queuedFromProfile + queueId, and relies on Late FIFO order. Manual scheduledFor is fallback-only.

Local Queue (src/services/postStore.ts)

Published posts are tracked locally in publish-queue/ (pending) and published/ (done). Each item has metadata.json with latePostId, scheduledFor, platform, accountId, status.

Scheduler (src/services/scheduler.ts)

findNextSlot(platform) finds the next available time slot by:

1. Loading schedule.json config
2. Fetching booked slots from Late API + local published items
3. Generating candidates in 14-day chunks, sorted chronologically
4. Returning the first unbooked candidate

Operational Workflows

1. List All Scheduled Posts

curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/posts?status=scheduled" | python -m json.tool

Filter by platform:

curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/posts?status=scheduled&platform=linkedin"

Filter by date range:

curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/posts?status=scheduled&dateFrom=2026-02-01&dateTo=2026-03-01"

2. Reschedule a Single Post

curl -s -X PUT -H "Authorization: Bearer $env:LATE_API_KEY" \
  -H "Content-Type: application/json" \
  "https://getlate.dev/api/v1/posts/{postId}" \
  -d '{"scheduledFor": "2026-02-20T08:00:00-06:00"}'

3. Bulk Reschedule All Posts (Schedule Change)

When schedule.json changes, use this workflow:

1. Read the new schedule from schedule.json
2. Fetch all scheduled posts from Late API
3. For each post, compute the new optimal time slot based on the updated schedule
4. Update each post with the new scheduledFor datetime via PUT /v1/posts/{postId}
5. Report what changed (old time → new time for each post)

Important: Always confirm with the user before executing bulk reschedule. Show them the proposed changes first.

Recommended: Use vidpipe sync-queues --reshuffle for automated bulk reschedule via Late queue system. Use vidpipe realign --queue or vidpipe reschedule --queue for queue-based alternatives.

4. Bulk Delete Scheduled Posts

# First list to confirm what will be deleted
curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/posts?status=scheduled&platform=twitter"

# Then delete each post by ID (published posts CANNOT be deleted)
curl -s -X DELETE -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/posts/{postId}"

Important: Always list and confirm with the user before deleting. Show post content previews.

5. Sync Local Queue with Late API

Compare local published/ metadata with Late API state:

1. Read all local published items from recordings/*/publish-queue/ and published/
2. For each item with a latePostId, fetch the Late post via GET /v1/posts/{postId}
3. Report mismatches:
   • Orphaned in Late: Posts in Late API with no matching local item
   • Orphaned locally: Local items with latePostId that no longer exists in Late
   • Schedule mismatch: scheduledFor differs between local metadata and Late API

6. Validate Late API Connection

curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/profiles"

If this returns profiles, the connection is valid. If 401, the API key is invalid or expired.

7. View Publishing Logs

curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/logs"

Shows publishing attempts with platform API endpoint, HTTP status, request/response bodies, and retry info. Logs are retained for 7 days.

8. Inspect Connected Accounts

curl -s -H "Authorization: Bearer $env:LATE_API_KEY" \
  "https://getlate.dev/api/v1/accounts" | python -m json.tool

Returns all connected social accounts with _id, platform, username, displayName, isActive, profileId.

9. Update Late Queue Slots (with auto-reshuffle)

If you want Late's built-in queue (not the local schedule.json) to reschedule existing posts:

curl -s -X PUT -H "Authorization: Bearer $env:LATE_API_KEY" \
  -H "Content-Type: application/json" \
  "https://getlate.dev/api/v1/queue/slots" \
  -d '{
    "profileId": "PROFILE_ID",
    "timezone": "America/Chicago",
    "slots": [
      {"day": "tue", "time": "08:00"},
      {"day": "wed", "time": "12:00"}
    ],
    "reshuffleExisting": true
  }'

The reshuffleExisting: true flag tells Late to automatically move existing queued posts to match the new slots.

Safety Rules

1. Never delete published posts — the API will reject it anyway (400 error)
2. Always list before bulk operations — show the user what will be affected
3. Confirm destructive actions — ask the user to approve before deleting or rescheduling multiple posts
4. Use dryRun for bulk uploads — test with ?dryRun=true query param first
5. Respect rate limits — add delays between bulk API calls (60 req/min on free plan)
6. Handle 429 responses — check Retry-After header and wait before retrying

Troubleshooting

npm Publish Skill

Complete workflow for publishing packages to the npm registry, including granular access token creation via the npmjs.com web UI.

Prerequisites

• npm account with package write access
• Playwright browser tool available for token creation
• Package must be built (npm run build) and tests passing (npm test)

Publishing Workflow

Step 1: Check if already published

npm view <package-name> version

If the package/version already exists, bump the version in package.json before proceeding.

Step 2: Build and test

npm run build && npm test

Ensure there are no build errors and all tests pass before publishing.

Step 3: Create granular access token (if needed)

If you don't have a valid token:

1. Navigate to https://www.npmjs.com/settings/~/tokens using Playwright browser
2. If not logged in, the user must authenticate (npm sends email OTP)
3. Click "Generate New Token"
4. Fill in:
   • Token name: <package-name>-publish
   • Bypass 2FA: Check the checkbox
   • Packages and scopes → Permissions: "Read and write"
   • Select packages: "All packages" radio button
   • Expiration: 90 days (maximum for write tokens)
5. Click "Generate token"
6. Copy the token from the success page (starts with npm_)

Step 4: Configure and publish

npm config set //registry.npmjs.org/:_authToken=<TOKEN>
npm publish --access public

Step 5: Verify publication

npm view <package-name> version

Confirm the published version matches what you expected.

Step 6: Clean up token from local config

npm config delete //registry.npmjs.org/:_authToken

This removes the token from your local .npmrc so it is not accidentally leaked.

Important Notes

• npm granular tokens with write access have a max 90-day expiry
• Bypass 2FA checkbox MUST be enabled for CLI publishing to work
• The "All packages" radio must be explicitly selected (it's not selected by default despite appearing so)
• Always clean up tokens from local .npmrc after publishing
• Token stays saved in npmjs.com account for re-use within its expiry window

Troubleshooting

Release Skill

Complete workflow for creating a new versioned release of vidpipe, including version bump, release notes, GitHub release, and npm publishing.

Prerequisites

• Clean working tree (git status shows no uncommitted changes)
• All tests passing (npm test)
• gh CLI authenticated (gh auth status)
• npm publish token available (see npm-publish skill)

Release Workflow

Step 1: Determine Version Bump

Check commits since the last tag to decide the bump type:

git log --oneline $(git describe --tags --abbrev=0)..HEAD

• patch (x.x.1): Only bug fixes (fix: commits)
• minor (x.1.0): New features (feat: commits), no breaking changes
• major (1.0.0): Breaking changes (BREAKING CHANGE or !: commits)

Step 2: Bump Version

npm version <patch|minor|major> --no-git-tag-version

This updates package.json and package-lock.json without creating a git tag (we'll do that manually after release notes).

Step 3: Build and Test

npm run build && npm test

All tests must pass before proceeding.

Step 4: Commit Version Bump

git add package.json package-lock.json
git commit -m "chore: bump version to <NEW_VERSION>"
git push origin main

Step 5: Create Git Tag

git tag -a v<NEW_VERSION> -m "v<NEW_VERSION>"
git push origin v<NEW_VERSION>

Step 6: Generate Release Notes

Write release notes that include:

• Features (feat: commits) — describe what's new with user-facing impact
• Bug Fixes (fix: commits) — describe what was broken and how it's fixed
• Documentation — notable doc improvements
• Internal — infrastructure, refactoring, DX improvements

Format as GitHub-flavored markdown with emoji section headers (✨ Features, 🐛 Fixes, 📖 Documentation, 🔧 Internal).

Include a changelog link at the bottom:

**Full Changelog**: https://github.com/htekdev/vidpipe/compare/vOLD...vNEW

Step 7: Create GitHub Release

gh release create v<NEW_VERSION> --title "v<NEW_VERSION> — <SHORT_DESCRIPTION>" --notes "<RELEASE_NOTES>"

Step 8: Publish to npm

Follow the npm-publish skill:

1. Set auth token: npm config set //registry.npmjs.org/:_authToken=<TOKEN>
2. Publish: npm publish --access public
3. Verify: npm view vidpipe version
4. Clean up: npm config delete //registry.npmjs.org/:_authToken

If no token is available, use Playwright to create one (see npm-publish skill).

Step 9: Verify

• GitHub release visible: gh release view v<NEW_VERSION>
• npm version matches: npm view vidpipe version

Important Notes

• Always push commits BEFORE creating the tag (tag should point to a pushed commit)
• Use --no-git-tag-version with npm version to separate the version bump commit from the tag
• Release notes should be written for END USERS, not developers
• The npm token (vidpipe-publish) expires every 90 days — check expiry if publish fails
• If npm registry shows old version after publish, wait 30-60 seconds for propagation

Video Review Skill

Analyze any video file using Google Gemini's vision model. Upload the video, send a custom prompt (or use a default review prompt), and return Gemini's analysis.

Prerequisites

• GEMINI_API_KEY environment variable set (get one at https://aistudio.google.com/apikey)
• Video file must exist on disk (mp4, webm, mov)

How to Use

Run the review-video.ts script in this skill directory with the video path and an optional prompt:

cd C:\Repos\htekdev\video-auto-note-taker
npx tsx .github/skills/video-review/review-video.ts "<video-path>" "<optional-prompt>"

Arguments

1. video-path (required): Absolute or relative path to the video file
2. prompt (optional): Custom prompt to send alongside the video. If omitted, uses a general review prompt that describes what's happening in the video.

Examples

# General review — describe what's in the video
npx tsx .github/skills/video-review/review-video.ts "recordings/my-video/short-clip.mp4"

# Custom prompt — ask specific questions
npx tsx .github/skills/video-review/review-video.ts "recordings/my-video/short-clip.mp4" "Are the captions readable? Do they overlap with any important content on screen?"

# Check caption quality on a short
npx tsx .github/skills/video-review/review-video.ts "recordings/my-video/shorts/clip-square-captioned.mp4" "Describe what you see. Are there any visual issues, glitches, or misaligned elements?"

# Review editorial decisions
npx tsx .github/skills/video-review/review-video.ts "recordings/my-video/my-video-edited.mp4" "Does this video flow well? Are there any jarring cuts or awkward transitions?"

Environment Variables

Output

The script prints Gemini's full analysis to stdout. For large outputs, pipe to a file:

npx tsx .github/skills/video-review/review-video.ts "video.mp4" "What's wrong?" > review-output.md

Default Prompt

When no custom prompt is provided, the script uses:

Describe everything you see in this video in detail. Cover: visual layout, text/captions visible, any overlays or graphics, video quality, audio sync observations, pacing, and anything that looks wrong or could be improved. Be specific with timestamps.

Troubleshooting

• "GEMINI_API_KEY is required": Set the env var in your .env file or shell
• Timeout on large videos: Gemini processes uploads async — long videos may take 30-60s to become ready
• Empty response: Try a simpler prompt or a shorter video clip