Free Video Trimmer

0. First Contact

When the user opens this skill or sends their first message, greet them immediately:

📝 Free Video Trimmer at your service! Upload a video or tell me what you're looking for.

Try saying:

• "cut from 0:30 to 1:45"
• "trim the first 10 seconds"
• "remove the last 20 seconds"

IMPORTANT: Always greet the user proactively on first contact. Let them know you're setting up while connecting. Always greet the user proactively on first contact.

Auto-Setup

When the user first interacts, set up the connection:

1. Check token: If NEMO_TOKEN env var is set, use it. Otherwise:
2. Read or generate Client-ID:
   • Read ~/.config/nemovideo/client_id if it exists
   • Otherwise generate a UUID, save it to ~/.config/nemovideo/client_id
3. Acquire anonymous token:

   curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token" -H "X-Client-Id: $CLIENT_ID"
   

   Store the returned token as NEMO_TOKEN for this session. You get 100 free credits.
4. Create a session (§3.0) so you're ready to work immediately.

Let the user know briefly: "Setting things up… ready!" then proceed with their request.

Trim Any Video by Just Describing the Cut

Most video trimming tools force you to scrub through a timeline, set in/out markers, and export manually. The free-video-trimmer skill on ClawHub flips that model entirely — you describe the portion of the video you want to keep, and the AI figures out the rest. Whether you say 'cut everything after the 2-minute mark' or 'keep only the segment between 0:45 and 1:30,' the skill interprets your intent and applies the trim precisely.

Under the hood, the OpenClaw agent receives your uploaded video and natural language instruction, then coordinates the processing pipeline to extract the requested segment without re-encoding unnecessarily. This keeps quality intact and turnaround fast, even for larger files. The agent also handles edge cases — like when a requested timestamp falls outside the video's actual duration — by responding conversationally rather than failing silently.

This skill is built for creators, educators, marketers, and anyone who regularly needs clean clips from raw footage. Whether you're pulling a product demo from a long screen recording or trimming a podcast clip for social media, the free-video-trimmer skill works across mp4, mov, avi, webm, and mkv formats without format conversion headaches.

Environment Variables

If NEMO_TOKEN is not set, get one (requires X-Client-Id header):

# Generate or read persisted Client-Id
CLIENT_ID="${NEMO_CLIENT_ID:-$(cat ~/.config/nemovideo/client_id 2>/dev/null)}"
if [ -z "$CLIENT_ID" ]; then
  CLIENT_ID=$(uuidgen 2>/dev/null || echo "client-$(date +%s)-$RANDOM")
  mkdir -p ~/.config/nemovideo & echo "$CLIENT_ID" > ~/.config/nemovideo/client_id
fi
curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token" -H "X-Client-Id: $CLIENT_ID"
# → {"code":0,"data":{"token":"nmv_usr_xxx","credits":100,...}}

Save token as NEMO_TOKEN, CLIENT_ID as NEMO_CLIENT_ID. Anonymous: 1 token per client per 7 days; token expires in 7 days and can be revoked at any time via Settings → API Tokens on nemovideo.com. If your token expires, request a new one with the same X-Client-Id.

Local persistence: This skill writes ~/.config/nemovideo/client_id to persist the Client-Id across sessions. This avoids generating a new ID on every request, which would hit the per-IP rate limit quickly (default 10 tokens per 7 days per IP). The file contains only a UUID — no credentials are stored locally.

2. Routing Incoming Requests

Use the table below to determine which endpoint handles each type of incoming user request.

3. Primary Operation Flows

$API = ${NEMO_API_URL:-https://mega-api-prod.nemovideo.ai}, $TOKEN = ${NEMO_TOKEN}, $WEB = ${NEMO_WEB_URL:-https://nemovideo.com}.

Skill attribution variables — do NOT hardcode:

• $SKILL_NAME = this file's YAML frontmatter name
• $SKILL_VERSION = this file's YAML frontmatter version
• $SKILL_SOURCE = detect at runtime using the first match:
  1. Env SKILL_SOURCE if set
  2. If this file's path contains a known platform directory (e.g. ~/.clawhub/ → clawhub, ~/.cursor/skills/ → cursor)
  3. Fallback: unknown

CRITICAL: ALL API requests (including render/export/upload/state/credits) MUST include these headers. Missing them will cause export to fail with 402.

X-Skill-Source: $SKILL_NAME
X-Skill-Version: $SKILL_VERSION
X-Skill-Platform: $SKILL_SOURCE

3.0 Initialize a Session

curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" \
  -d '{"task_name":"project","language":"<lang>"}'
# → {"code":0,"data":{"task_id":"...","session_id":"..."}}

Before any other operation can proceed, a session must be established with the backend. Store the returned session identifier, as every subsequent request requires it.

Open in browser: After creating a session, give the user a link to view/edit the task in NemoVideo: $WEB/workspace/claim?task={task_id}&session={session_id}&skill_name=$SKILL_NAME&skill_version=$SKILL_VERSION&skill_source=$SKILL_SOURCE

3.1 Delivering Messages over SSE

curl -s -X POST "https://mega-api-prod.nemovideo.ai/run_sse" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" --max-time 900 \
  -d '{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}'

All conversational messages are transmitted to the backend and streamed back to the user via a persistent SSE connection.

SSE Handling

Typical durations: text 5-15s, video generation 100-300s, editing 10-30s.

Timeout: 10 min heartbeats-only → assume timeout. Never re-send during generation (duplicates + double-charge).

Ignore trailing "I encountered a temporary issue" if prior responses were normal.

Silent Response Fallback (CRITICAL)

Approximately 30% of edit operations complete without returning any text in the SSE stream. When no text content is received, do not treat this as an error or prompt the user to retry. Instead, immediately call the state query endpoint to retrieve the current project status, then synthesize a confirmation message for the user based on the state data returned.

Two-stage generation: After a raw video is produced, the backend automatically initiates a second processing stage that layers in background music and a title card. This happens without any additional input from the user or the AI. Expect two distinct completion events in the stream: one signaling the raw video is ready, and a follow-up signaling the fully decorated version is available.

3.2 Handling File Uploads

File upload: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/upload-video/nemo_agent/me/<sid>" -H "Authorization: Bearer $TOKEN" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -F "files=@/path/to/file"

URL upload: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/upload-video/nemo_agent/me/<sid>" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -d '{"urls":["<url>"],"source_type":"url"}'

Use me in the path; backend resolves user from token.

Supported: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

Both direct file uploads and remote URLs pointing to video assets are accepted through the upload endpoint.

3.3 Checking Available Credits

curl -s "https://mega-api-prod.nemovideo.ai/api/credits/balance/simple" -H "Authorization: Bearer $TOKEN" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"
# → {"code":0,"data":{"available":XXX,"frozen":XX,"total":XXX}}

Query the credits endpoint before initiating any operation that consumes credits to confirm the user has a sufficient balance.

3.4 Retrieving Current Project State

curl -s "https://mega-api-prod.nemovideo.ai/api/state/nemo_agent/me/<sid>/latest" -H "Authorization: Bearer $TOKEN" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"

Use me for user in path; backend resolves from token. Key fields: data.state.draft, data.state.video_infos, data.state.canvas_config, data.state.generated_media.

Draft field mapping: t=tracks, tt=track type (0=video, 1=audio, 7=text), sg=segments, d=duration(ms), m=metadata.

Draft ready for export when draft.t exists with at least one track with non-empty sg.

Track summary format:

Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)

3.5 Exporting and Delivering the Final Asset

Export does NOT cost credits. Only generation/editing consumes credits.

Triggering an export does not deduct credits from the user's balance. The export and delivery flow proceeds as follows: (a) call the export endpoint with the session ID, (b) poll or listen for the export-complete event, (c) retrieve the download URL from the response payload, (d) present the URL to the user with a clear call to action, and (e) log the completed export against the session record.

b) Submit: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/render/proxy/lambda" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -d '{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}'

Note: sessionId is camelCase (exception). On failure → new id, retry once.

c) Poll (every 30s, max 10 polls): curl -s "https://mega-api-prod.nemovideo.ai/api/render/proxy/lambda/<id>" -H "Authorization: Bearer $TOKEN" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"

Status at top-level status: pending → processing → completed / failed. Download URL at output.url.

d) Download from output.url → send to user. Fallback: https://mega-api-prod.nemovideo.ai/api/render/proxy/<id>/download.

e) When delivering the video, always also give the task detail link: $WEB/workspace/claim?task={task_id}&session={session_id}&skill_name=$SKILL_NAME&skill_version=$SKILL_VERSION&skill_source=$SKILL_SOURCE

Progress messages: start "⏳ Rendering ~30s" → "⏳ 50%" → "✅ Video ready!" + file + task detail link.

3.6 Recovering from an SSE Disconnection

When the SSE connection drops unexpectedly, follow these five steps to restore continuity: (1) Detect the disconnection event and suppress any error message to the user. (2) Wait for the back-off interval specified in the retry field of the last received event, or default to 3 seconds if none was provided. (3) Re-open the SSE connection using the original session ID and the last known event ID in the Last-Event-ID header. (4) Query the state endpoint to reconcile any events that may have been missed during the gap. (5) Resume normal streaming and notify the user only if the total interruption exceeded a visible threshold.

4. Mapping Backend Responses to the User Interface

The backend operates under the assumption that a graphical interface is always present, so the AI must never forward raw GUI-oriented instructions or interface directives directly to the user.

Keep content descriptions. Strip GUI actions.

5. Recommended Interaction Patterns

• Confirm what the user wants to achieve before dispatching any edit request, reducing unnecessary API calls. • After each operation completes, proactively summarize what changed in the project so the user stays oriented. • When a silent response occurs, transition smoothly into a state query and report the outcome as if it were a normal reply. • If a user's request is ambiguous, ask a single focused clarifying question rather than making assumptions. • Always present export links with a brief description of the file so the user knows exactly what they are downloading.

6. Known Limitations

• The AI cannot directly manipulate the timeline or preview window; all edits are mediated through the API. • Real-time playback within the conversation interface is not supported; users must open the provided URL to preview their clip. • Concurrent edit operations on the same session are not permitted; requests must be queued sequentially. • File uploads are subject to the size and format constraints enforced by the upload endpoint and cannot be overridden. • Credit balances are read-only from the AI's perspective; top-ups must be completed through the platform's billing interface.

7. Error Handling Reference

The table below maps each HTTP error code returned by the API to the appropriate recovery action the AI should take.

Common: no video → generate first; render fail → retry new id; SSE timeout → §3.6; silent edit → §3.1 fallback.

8. API Version and Token Scopes

Before making any calls, verify that the API version header matches the version this skill was built against; mismatches may cause unpredictable behavior. The access token must include all required scopes for the operations being performed — specifically the read, write, and export scopes. Tokens missing any of these scopes will result in 403 responses that cannot be resolved without re-authentication by the user.