darlink-ai

name	darlink-ai
version	1.0.4
displayName	Darlink AI — Smart Video Editing Powered by Conversational AI
description	Darlink-ai brings a new dimension to video editing by letting you direct changes through natural conversation rather than complex timelines. Trim dead air, reorder scenes, adjust pacing, apply color grading, and stitch segments together — all by describing what you want. Built for content creators, indie filmmakers, and social media teams who need fast turnaround without steep learning curves. Darlink-ai understands context across your edits, so follow-up instructions refine rather than restart. Supports mp4, mov, avi, webm, and mkv formats.
metadata	{"openclaw":{"emoji":"🎬","requires":{"env":["NEMO_TOKEN"],"configPaths":["~/.config/nemovideo/"]},"primaryEnv":"NEMO_TOKEN"}}
homepage	https://nemovideo.com
apiDomain	https://mega-api-prod.nemovideo.ai
repository	https://github.com/nemovideo/nemovideo_skills

0. First Contact

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

⚡ Darlink Ai at your service! Upload a video or tell me what you're looking for.

Try saying:

• "add effects to this clip"
• "edit my video"
• "help me create a short video"

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.

Edit Videos by Talking to Darlink AI

Darlink-ai reimagines the editing workflow by replacing manual timeline scrubbing with a back-and-forth dialogue. Instead of hunting for the right cut point or wrestling with keyframe curves, you describe the outcome you want — 'tighten the opening to under 10 seconds' or 'make the color warmer in the second half' — and the skill interprets that intent into precise, frame-accurate operations on your footage.

Under the hood, the OpenClaw agent acts as the reasoning layer between your instructions and the video processing pipeline. It parses conversational input, resolves ambiguities by asking clarifying questions when needed, and dispatches the appropriate editing operations in sequence. The agent maintains memory of prior instructions within a session, so each new request builds on what came before rather than treating the project as a blank slate.

This makes darlink-ai particularly well-suited for iterative creative work — the kind where you need to see a rough cut, react to it, and refine in real time. Whether you are assembling a short-form reel, cutting a product demo, or trimming a long interview down to its sharpest moments, the conversational model keeps you in a creative flow state rather than a technical one.

Environment Variables

Variable	Required	Default
NEMO_TOKEN	No	Auto-generated (100 free credits, expires in 7 days, revocable via Settings → API Tokens)
NEMO_API_URL	No	https://mega-api-prod.nemovideo.ai
NEMO_WEB_URL	No	https://nemovideo.com
NEMO_CLIENT_ID	No	Auto-generated UUID, persisted to ~/.config/nemovideo/client_id (UUID only, no secrets)
SKILL_SOURCE	No	Auto-detected from install path, fallback unknown

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 to the Correct Endpoint

Use the table below to determine which API endpoint should handle each type of user request.

User says...	Action	Skip SSE
"export" / "导出" / "download" / "send me the video"	→ §3.5 Export	✅
"credits" / "积分" / "balance" / "余额"	→ §3.3 Credits	✅
"status" / "状态" / "show tracks"	→ §3.4 State	✅
"upload" / "上传" / user sends file	→ §3.2 Upload	✅
Everything else (generate, edit, add BGM…)	→ §3.1 SSE	❌

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 New 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 editing can begin, a session must be established to maintain conversation context. All subsequent requests within the same editing task should reference this session identifier.

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 Transmitting 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 to the editing engine are delivered through a Server-Sent Events stream that returns real-time responses.

SSE Handling

Event	Action
Text response	Apply GUI translation (§4), present to user
Tool call/result	Wait silently, don't forward
heartbeat / empty data:	Keep waiting. Every 2 min: "⏳ Still working..."
Stream closes	Process final response

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 SSE stream. When no text payload is received within the expected window, do not treat this as an error — instead, immediately poll the task state endpoint to check for a completed result, surface a neutral status message to the user such as 'Your edit is being processed,' and proceed once the state endpoint confirms completion.

Two-stage generation: After the raw edited video is produced, the backend automatically initiates a second processing stage that layers in background music and generates a title overlay — no additional prompt is required. The first stage delivers the cut video, and the second stage enriches it; both must complete before presenting the final result to the user.

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 video and audio file uploads are supported through the designated upload endpoint prior to referencing them in any editing request.

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 submitting any edit operation to confirm the user has a sufficient balance to proceed.

3.4 Retrieving Current Task 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 Triggering Export and Delivering the Result

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

Exporting a finished project does not deduct any credits from the user's balance. To deliver the final video: (a) confirm the task state shows completion, (b) call the export endpoint with the session and task identifiers, (c) poll until the export status is ready, (d) retrieve the download URL from the response, and (e) present the URL to the user as the deliverable.

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 an SSE stream drops unexpectedly, follow these five steps to recover gracefully: (1) detect the disconnection event and log the last received event ID; (2) wait a brief back-off interval before attempting to reconnect; (3) re-establish the SSE connection using the same session identifier and passing the last event ID in the reconnect header; (4) if the stream does not resume within the retry window, fall back to polling the task state endpoint directly; (5) once task completion is confirmed through either method, continue the normal delivery flow as if no interruption occurred.

4. Translating Backend Behavior into GUI Concepts

The backend is designed with the assumption that a graphical interface is present, so under no circumstances should raw GUI-layer instructions or interface directives be forwarded directly to the user.

Backend says	You do
"click [button]" / "点击"	Execute via API
"open [panel]" / "打开"	Show state via §3.4
"drag/drop" / "拖拽"	Send edit via SSE
"preview in timeline"	Show track summary
"Export button" / "导出"	Execute §3.5
"check account/billing"	Check §3.3

Keep content descriptions. Strip GUI actions.

5. Recommended Conversational Interaction Patterns

• Confirm the user's intent before initiating any operation that will consume credits, giving them a clear opportunity to cancel. • After submitting an edit request, proactively communicate processing status at regular intervals so the user is never left wondering if something went wrong. • When an edit completes silently with no text response, bridge the gap with a brief neutral status update rather than leaving the conversation idle. • If the user's request is ambiguous about timing, style, or scope, ask one focused clarifying question before proceeding rather than making assumptions. • Always present the export download URL as the final step, framed as the deliverable, so the user knows the task is fully complete.

6. Known Constraints and Limitations

• The conversational AI cannot preview frames or inspect raw video content directly — it relies entirely on metadata and task state responses. • Session identifiers are not permanent; do not assume a session remains valid across separate user conversations or after extended inactivity. • Credit balances are read-only from the API perspective — the skill cannot add, refund, or adjust credits under any circumstances. • Only the file formats and MIME types explicitly accepted by the upload endpoint are supported; attempting to upload unsupported formats will result in a rejection error. • The two-stage post-processing pipeline for BGM and title overlays runs automatically and cannot be skipped or reordered by the skill.

7. Error Response Handling

The table below maps each HTTP error code returned by the API to its likely cause and the recommended recovery action.

Code	Meaning	Action
0	Success	Continue
1001	Bad/expired token	Re-auth via anonymous-token (tokens expire after 7 days)
1002	Session not found	New session §3.0
2001	No credits	Anonymous: show registration URL with ?bind=<id> (get <id> from create-session or state response when needed). Registered: "Top up at nemovideo.ai"
4001	Unsupported file	Show supported formats
4002	File too large	Suggest compress/trim
400	Missing X-Client-Id	Generate Client-Id and retry (see §1)
402	Free plan export blocked	Subscription tier issue, NOT credits. "Register at nemovideo.ai to unlock export."
429	Rate limit (1 token/client/7 days)	Retry in 30s once

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

Always verify the API version header in every response to ensure compatibility with the expected contract; if the version does not match the supported range, halt and surface a compatibility warning rather than proceeding. The access token must include all required scopes for session management, file upload, task polling, and export operations — requests made with a token missing any of these scopes will be rejected with a 403 response and must not be retried until a properly scoped token is obtained.