Blue Picture Video Editor App

0. First Contact

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

📝 Ready to blue picture video editor app! Just send me a video or describe your project.

Try saying:

• "speed up by 2x"
• "add a fade-in transition"
• "make it look cinematic"

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 "$API/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.

Edit Videos by Simply Describing What You Want

The blue-picture-video-editor-app skill reframes how video editing gets done. Instead of navigating complex timelines and nested menus, you describe your intent — 'cut the first three seconds, boost contrast, and add a fade-out' — and the skill interprets that instruction into precise editing operations applied to your footage.

Under the hood, this skill is powered by the OpenClaw agent, which parses natural language editing requests and maps them to a structured sequence of video processing tasks. The OpenClaw agent handles context across a conversation, so you can refine your edits iteratively — asking for a brighter grade, then requesting a different cut point — without starting over each time. It maintains awareness of your project state throughout the session.

This approach is purpose-built for the blue-picture-video-editor-app use case: creators who work quickly across multiple formats and need an editing assistant that understands both visual language and technical constraints. Whether you are cutting a short-form reel or assembling a longer documentary sequence, the skill adapts to your pacing. File compatibility covers mp4, mov, avi, webm, and mkv, ensuring your source material works regardless of camera origin or export pipeline.

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 "$API/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 following table to determine which endpoint handles each type of user request.

3. Primary Workflow Sequences

$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 Initializing a Session

curl -s -X POST "$API/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 editing actions can occur, a session must be established with the backend. This session token ties all subsequent requests together under a single editing context.

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

3.1 Delivering Messages Through SSE

curl -s -X POST "$API/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 to the editor are transmitted via Server-Sent Events, which stream the backend's response back in real time.

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 editing operations complete without returning any text in the response stream. When no text content is detected after the SSE stream closes, do not treat this as an error or prompt the user to retry. Instead, immediately call the state query endpoint to confirm the edit was applied, then acknowledge success to the user based on the returned project state.

Two-stage generation: When a raw video edit is processed, the backend automatically triggers a second processing stage that layers in background music and generates a title overlay — no additional instruction is needed from the assistant. Plan for two distinct completion events: the first signals raw video readiness, and the second confirms the fully composed output with BGM and title applied.

3.2 Handling File Uploads

File upload: curl -s -X POST "$API/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 "$API/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 video and image assets can be uploaded directly through the designated upload endpoint for use within the current editing session.

3.3 Checking Available Credits

curl -s "$API/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 credit-consuming operation to confirm the user has a sufficient balance.

3.4 Retrieving Current Project State

curl -s "$API/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 Video

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

Triggering an export does not deduct any credits from the user's account. The export sequence proceeds as follows: (a) call the export endpoint with the current session ID, (b) poll for export job completion using the returned job token, (c) once the status indicates completion retrieve the download URL, (d) present the URL to the user as their finished video, and (e) log the export event in the session record.

b) Submit: curl -s -X POST "$API/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 "$API/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: $API/api/render/proxy/<id>/download.

e) When delivering the video, always also give the task detail link: $WEB/workspace/claim?token=$TOKEN&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

If the SSE connection drops before the stream completes, follow these recovery steps: (1) Wait two seconds before attempting any recovery action to avoid flooding the server. (2) Call the state query endpoint to determine whether the backend finished processing despite the disconnection. (3) If the state confirms completion, surface the result to the user as normal. (4) If the state shows the operation is still in progress, re-establish the SSE connection using the original session ID and message token. (5) If the state reflects a failed or unknown status, notify the user that a temporary issue occurred and offer to resubmit the last request.

4. Translating GUI Concepts for the Backend

The backend operates under the assumption that all interactions originate from a graphical interface, so the assistant must never forward GUI-specific instructions or interface labels directly to the API.

Keep content descriptions. Strip GUI actions.

5. Recommended Interaction Patterns

• Always confirm the session is active before sending any editing instruction, re-initializing if the session has expired. • After every SSE stream closes, verify the outcome via the state endpoint rather than relying solely on streamed text. • When a user requests an operation that consumes credits, surface the current balance and obtain confirmation before proceeding. • Break complex multi-step edits into sequential single-intent messages rather than bundling multiple instructions into one request. • If the backend returns an unexpected status code, consult the error table and resolve the condition before retrying the original request.

6. Known Limitations

• The assistant cannot directly manipulate the video timeline or access raw frame data; all edits are mediated through the messaging endpoint. • Session tokens are not persistent across separate user conversations and must be re-created for each new session. • Simultaneous export jobs for the same session are not supported; a second export request must wait until the first job resolves. • File uploads are limited to the formats and size thresholds defined in the upload endpoint specification; the assistant should validate these constraints client-side before attempting an upload. • Credit balances are read-only from the assistant's perspective; top-up flows must be handled through the user's account portal outside this skill.

7. Error Identification and Resolution

The table below maps each HTTP status code and backend error identifier to its cause and the recommended corrective action.

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

8. API Version and Required Token Scopes

Before going live, confirm that the integration is targeting the current stable API version documented in the developer portal — using a deprecated version may result in undocumented behavior. The OAuth token presented with each request must include all scopes required by the endpoints in use; missing scopes will produce 403 responses regardless of token validity. Review the scope list whenever new endpoints are added to the skill to ensure the token covers all necessary permissions.