@remixmate/cli 0.1.1 → 0.9.1

package/dist/auth/device-flow-runner.js

@@ -0,0 +1,62 @@
+/**
+ * Shared Device Flow orchestration used by BOTH `remixmate login` (interactive,
+ * full device-code lifetime) and the automatic browser auth that kicks in when
+ * a skill call finds no token (bounded by a short wait window).
+ *
+ * Centralizing the request → open browser → poll → persist sequence keeps the
+ * two entry points byte-for-byte consistent (Requirement 4.1/4.2) and means the
+ * credential written by auto-login is indistinguishable from `login`'s.
+ *
+ * Security: the PrivToken value is NEVER written to the provided sink.
+ */
+import { DeviceFlowError, openBrowser, pollForToken, requestDeviceCode, } from './device-flow.js';
+import { setCredential } from './credential-store.js';
+function nowSec() {
+    return Math.floor(Date.now() / 1000);
+}
+/**
+ * Run one full Device Flow against `apiBaseUrl`. On approval the PrivToken is
+ * persisted via setCredential (keychain or file, same as `login`) and only the
+ * non-secret outcome is returned.
+ */
+export async function runDeviceFlow(apiBaseUrl, opts = {}) {
+    const write = opts.write ?? ((msg) => process.stderr.write(msg));
+    const clientLabel = opts.clientLabel ?? `remixmate-cli (${process.platform} ${process.arch})`;
+    try {
+        const code = await requestDeviceCode(apiBaseUrl, clientLabel);
+        const openUrl = code.verificationUriComplete ?? code.verificationUri;
+        // Always print the URL + user code, even when the browser auto-opens, so a
+        // host (Claude Code / Codex) can relay it to the user.
+        write(`\n请在浏览器中完成授权：\n  ${code.verificationUri}\n设备码：${code.userCode}\n\n`);
+        if (openBrowser(openUrl)) {
+            write('已尝试自动打开浏览器…\n');
+        }
+        else {
+            write('无法自动打开浏览器，请手动复制上面的地址。\n');
+        }
+        write('等待授权中（可在浏览器确认）…\n');
+        const result = await pollForToken(apiBaseUrl, code, { maxWaitMs: opts.maxWaitMs });
+        if (result.status === 'approved' && result.privToken) {
+            const { usedKeychain, keychainError } = await setCredential(apiBaseUrl, {
+                privToken: result.privToken,
+                userLabel: result.userLabel,
+                createdAt: nowSec(),
+            });
+            if (!usedKeychain && keychainError) {
+                write('（系统钥匙串不可用，凭证已写入受保护的本地文件 ~/.config/remixmate/credentials.json）\n');
+            }
+            return { status: 'approved', userLabel: result.userLabel };
+        }
+        if (result.status === 'access_denied')
+            return { status: 'denied' };
+        if (result.timedOut)
+            return { status: 'timeout' };
+        return { status: 'expired' };
+    }
+    catch (err) {
+        if (err instanceof DeviceFlowError) {
+            return { status: 'error', message: err.message };
+        }
+        throw err;
+    }
+}

package/dist/auth/device-flow.d.ts

@@ -0,0 +1,52 @@
+/**
+ * OAuth 2.0 Device Authorization Grant (RFC 8628) client for `remixmate login`.
+ *
+ * The device/code and device/token endpoints are PUBLIC (no auth), so this uses
+ * plain fetch against the ab-api base URL rather than the authenticated mmPost.
+ * On approval the backend returns the user's existing PrivToken (Route B).
+ */
+export interface DeviceCodeResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete?: string;
+    interval: number;
+    expiresIn: number;
+}
+/** Device-token poll sub-states (mirrors backend model.DeviceTokenStatus*). */
+export type TokenStatus = 'authorization_pending' | 'slow_down' | 'approved' | 'access_denied' | 'expired_token' | 'invalid_grant';
+export interface TokenResult {
+    status: TokenStatus;
+    privToken?: string;
+    userLabel?: string;
+    /**
+     * Set when polling stopped because the caller-supplied `maxWaitMs` window
+     * elapsed BEFORE the device code's own expiry. Lets callers distinguish a
+     * short-wait timeout ("authorize then re-run") from a real expired code.
+     */
+    timedOut?: boolean;
+}
+export declare class DeviceFlowError extends Error {
+}
+/** Request a fresh device_code/user_code. 30s timeout, no retries here. */
+export declare function requestDeviceCode(apiBaseUrl: string, clientLabel: string): Promise<DeviceCodeResponse>;
+/**
+ * Try to open `url` in the default browser. Returns false when no opener is
+ * available (caller then prints the URL for manual entry).
+ */
+export declare function openBrowser(url: string): boolean;
+/**
+ * Poll device/token until a terminal outcome. Honors `interval` (+5s on
+ * slow_down), retries transient network failures up to 3 consecutive times, and
+ * bounds total time by the device code's `expiresIn`.
+ *
+ * When `opts.maxWaitMs` is supplied, polling also stops once that window
+ * elapses (whichever comes first). A stop caused by `maxWaitMs` returns
+ * `{ status: 'expired_token', timedOut: true }` so callers can tell a
+ * short-wait timeout apart from a genuinely expired device code.
+ *
+ * Resolves with the final TokenResult (status 'approved' carries the token).
+ */
+export declare function pollForToken(apiBaseUrl: string, code: DeviceCodeResponse, opts?: {
+    maxWaitMs?: number;
+}): Promise<TokenResult>;

package/dist/auth/device-flow.js

@@ -0,0 +1,115 @@
+/**
+ * OAuth 2.0 Device Authorization Grant (RFC 8628) client for `remixmate login`.
+ *
+ * The device/code and device/token endpoints are PUBLIC (no auth), so this uses
+ * plain fetch against the ab-api base URL rather than the authenticated mmPost.
+ * On approval the backend returns the user's existing PrivToken (Route B).
+ */
+import { spawn } from 'node:child_process';
+export class DeviceFlowError extends Error {
+}
+async function postJson(url, body, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        const text = await resp.text();
+        if (!resp.ok) {
+            throw new DeviceFlowError(`HTTP ${resp.status}: ${text.slice(0, 200)}`);
+        }
+        return JSON.parse(text);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Request a fresh device_code/user_code. 30s timeout, no retries here. */
+export async function requestDeviceCode(apiBaseUrl, clientLabel) {
+    const env = await postJson(`${apiBaseUrl}/auth/device/code`, { clientLabel }, 30_000);
+    if (env.code !== 0 || !env.data) {
+        throw new DeviceFlowError(env.msg || 'failed to obtain device code');
+    }
+    return env.data;
+}
+/**
+ * Try to open `url` in the default browser. Returns false when no opener is
+ * available (caller then prints the URL for manual entry).
+ */
+export function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' :
+        process.platform === 'win32' ? 'cmd' :
+            'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Poll device/token until a terminal outcome. Honors `interval` (+5s on
+ * slow_down), retries transient network failures up to 3 consecutive times, and
+ * bounds total time by the device code's `expiresIn`.
+ *
+ * When `opts.maxWaitMs` is supplied, polling also stops once that window
+ * elapses (whichever comes first). A stop caused by `maxWaitMs` returns
+ * `{ status: 'expired_token', timedOut: true }` so callers can tell a
+ * short-wait timeout apart from a genuinely expired device code.
+ *
+ * Resolves with the final TokenResult (status 'approved' carries the token).
+ */
+export async function pollForToken(apiBaseUrl, code, opts = {}) {
+    const expiryDeadline = Date.now() + code.expiresIn * 1000;
+    const waitDeadline = opts.maxWaitMs != null ? Date.now() + opts.maxWaitMs : Number.POSITIVE_INFINITY;
+    const deadline = Math.min(expiryDeadline, waitDeadline);
+    let intervalMs = Math.max(code.interval, 1) * 1000;
+    let consecutiveErrors = 0;
+    // Wait one interval before the first poll (approval can't have happened yet).
+    await sleep(intervalMs);
+    while (Date.now() < deadline) {
+        let env;
+        try {
+            env = await postJson(`${apiBaseUrl}/auth/device/token`, { deviceCode: code.deviceCode }, 15_000);
+            consecutiveErrors = 0;
+        }
+        catch (err) {
+            consecutiveErrors += 1;
+            if (consecutiveErrors >= 3) {
+                throw new DeviceFlowError(`polling failed: ${err.message}`);
+            }
+            await sleep(intervalMs);
+            continue;
+        }
+        if (env.code !== 0 || !env.data) {
+            throw new DeviceFlowError(env.msg || 'unexpected token response');
+        }
+        const result = env.data;
+        switch (result.status) {
+            case 'approved':
+            case 'access_denied':
+            case 'expired_token':
+            case 'invalid_grant':
+                return result;
+            case 'slow_down':
+                intervalMs += 5_000;
+                break;
+            case 'authorization_pending':
+            default:
+                break;
+        }
+        await sleep(intervalMs);
+    }
+    // Stopped on the wait window rather than the code's own expiry.
+    const timedOut = waitDeadline <= expiryDeadline;
+    return { status: 'expired_token', timedOut };
+}

package/dist/auth/environment.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure environment predicates that gate the auto device-login feature.
+ *
+ * Everything here is synchronous, side-effect free, never touches the network
+ * and never reads a PrivToken. The conservative bias is: when in doubt, treat
+ * the environment as headless so we fail fast rather than pop a useless browser.
+ *
+ * See .kiro/specs/cli-auto-device-login/design.md (Requirement 1.4–1.7).
+ */
+/** Total kill switch: hosts can force-disable auto auth and fall back to fail-fast. */
+export declare function autoAuthDisabled(): boolean;
+/**
+ * Whether the process is likely running without a desktop session capable of
+ * opening a browser.
+ *
+ *   - CI environments are always treated as headless.
+ *   - On Linux a browser needs an X11 / Wayland display; absence → headless.
+ *   - macOS / Windows are assumed to have a GUI session available.
+ */
+export declare function isHeadless(): boolean;
+/**
+ * Master gate for auto authorization. Only true when auto auth is not disabled
+ * AND the environment can plausibly open a browser for the user.
+ */
+export declare function canAutoAuth(): boolean;

package/dist/auth/environment.js

@@ -0,0 +1,48 @@
+/**
+ * Pure environment predicates that gate the auto device-login feature.
+ *
+ * Everything here is synchronous, side-effect free, never touches the network
+ * and never reads a PrivToken. The conservative bias is: when in doubt, treat
+ * the environment as headless so we fail fast rather than pop a useless browser.
+ *
+ * See .kiro/specs/cli-auto-device-login/design.md (Requirement 1.4–1.7).
+ */
+/** Total kill switch: hosts can force-disable auto auth and fall back to fail-fast. */
+export function autoAuthDisabled() {
+    return (process.env.REMIXMATE_NO_BROWSER_AUTH ?? '').trim() === '1';
+}
+/** Heuristic detection of common CI environments (no desktop → headless). */
+function isCI() {
+    const e = process.env;
+    return !!(e.CI ||
+        e.CONTINUOUS_INTEGRATION ||
+        e.GITHUB_ACTIONS ||
+        e.GITLAB_CI ||
+        e.BUILDKITE ||
+        e.CIRCLECI ||
+        e.TRAVIS ||
+        e.JENKINS_URL);
+}
+/**
+ * Whether the process is likely running without a desktop session capable of
+ * opening a browser.
+ *
+ *   - CI environments are always treated as headless.
+ *   - On Linux a browser needs an X11 / Wayland display; absence → headless.
+ *   - macOS / Windows are assumed to have a GUI session available.
+ */
+export function isHeadless() {
+    if (isCI())
+        return true;
+    if (process.platform === 'linux') {
+        return !((process.env.DISPLAY ?? '').trim() || (process.env.WAYLAND_DISPLAY ?? '').trim());
+    }
+    return false;
+}
+/**
+ * Master gate for auto authorization. Only true when auto auth is not disabled
+ * AND the environment can plausibly open a browser for the user.
+ */
+export function canAutoAuth() {
+    return !autoAuthDisabled() && !isHeadless();
+}

package/dist/auth/resolve.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Single source of truth for PrivToken resolution precedence, shared by the
+ * CLI commands and the HTTP layer (src/http.ts wires this in — Wave 2 task 4.3).
+ *
+ * Precedence (high → low), per requirements 7.1–7.4:
+ *   1. explicit --token flag (caller override)
+ *   2. PRIV_TOKEN environment variable  (CI / agent-embedded hosts)
+ *   3. Credential_Store entry for the active API base URL (written by `login`)
+ *
+ * A value that is empty after trimming whitespace is treated as ABSENT, so an
+ * exported-but-empty `PRIV_TOKEN=""` falls through to the credential store
+ * rather than masking it.
+ */
+export type CredentialSource = 'flag' | 'env' | 'credential-store';
+export interface ResolvedToken {
+    privToken: string;
+    source: CredentialSource;
+    /** Present only for the credential-store source. */
+    userLabel?: string;
+}
+/**
+ * Resolve the PrivToken following the documented precedence. Returns null when
+ * no source yields a token (callers render the not-authenticated message).
+ */
+export declare function resolvePrivToken(opts: {
+    flag?: string;
+    apiBaseUrl: string;
+}): Promise<ResolvedToken | null>;
+/** Human-readable hint shown when resolution fails (no token echoed). */
+export declare const NOT_AUTHENTICATED_HINT = "\u274C not authenticated \u2014 run `remixmate login`, set PRIV_TOKEN, or pass --token";

package/dist/auth/resolve.js

@@ -0,0 +1,44 @@
+/**
+ * Single source of truth for PrivToken resolution precedence, shared by the
+ * CLI commands and the HTTP layer (src/http.ts wires this in — Wave 2 task 4.3).
+ *
+ * Precedence (high → low), per requirements 7.1–7.4:
+ *   1. explicit --token flag (caller override)
+ *   2. PRIV_TOKEN environment variable  (CI / agent-embedded hosts)
+ *   3. Credential_Store entry for the active API base URL (written by `login`)
+ *
+ * A value that is empty after trimming whitespace is treated as ABSENT, so an
+ * exported-but-empty `PRIV_TOKEN=""` falls through to the credential store
+ * rather than masking it.
+ */
+import { getCredential } from './credential-store.js';
+/** Trim and return undefined when empty, so empty == absent everywhere. */
+function clean(value) {
+    if (value == null)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+/**
+ * Resolve the PrivToken following the documented precedence. Returns null when
+ * no source yields a token (callers render the not-authenticated message).
+ */
+export async function resolvePrivToken(opts) {
+    const flag = clean(opts.flag);
+    if (flag)
+        return { privToken: flag, source: 'flag' };
+    const env = clean(process.env.PRIV_TOKEN);
+    if (env)
+        return { privToken: env, source: 'env' };
+    const stored = await getCredential(opts.apiBaseUrl);
+    if (stored && clean(stored.privToken)) {
+        return {
+            privToken: stored.privToken,
+            source: 'credential-store',
+            userLabel: stored.userLabel,
+        };
+    }
+    return null;
+}
+/** Human-readable hint shown when resolution fails (no token echoed). */
+export const NOT_AUTHENTICATED_HINT = '❌ not authenticated — run `remixmate login`, set PRIV_TOKEN, or pass --token';

package/dist/cli.js

@@ -14,6 +14,9 @@ import path from 'node:path';
 import { loadSkills, SKILLS_DIR } from './registry.js';
 import { parseArgv } from './argv.js';
 import { runSkill } from './runner.js';
+import { runAuthCommand } from './auth/commands.js';
+/** Reserved auth verbs handled before skill dispatch. */
+const AUTH_VERBS = new Set(['login', 'logout', 'whoami']);
 /**
  * SKILL_BASE_DIR can arrive as a relative path (e.g. from a developer .env or
  * from ab-agent's spawn env). The cli script's cwd isn't a stable anchor for
@@ -40,6 +43,9 @@ function printUsage() {
     const skills = loadSkills(resolveBaseDir());
     process.stdout.write('Usage:\n');
     process.stdout.write('  remixmate --list                      List all skills\n');
+    process.stdout.write('  remixmate login                       Authorize this CLI via the browser\n');
+    process.stdout.write('  remixmate logout                      Remove stored credentials\n');
+    process.stdout.write('  remixmate whoami                      Show the current identity\n');
     process.stdout.write('  remixmate <name> [--flag value ...]   Invoke a skill\n');
     process.stdout.write('  remixmate <name> --help               Show skill-specific help\n');
     process.stdout.write('\nAvailable skills:\n');
@@ -63,6 +69,11 @@ async function main() {
         printList();
         process.exit(0);
     }
+    // Auth verbs are handled before skill dispatch so they never collide with skill names.
+    if (AUTH_VERBS.has(argv[0])) {
+        const code = await runAuthCommand(argv[0], argv.slice(1));
+        process.exit(code);
+    }
     if (argv[0].startsWith('-')) {
         process.stderr.write(`❌ unknown option: ${argv[0]}\n`);
         printUsage();

package/dist/handlers/gen-digital-human.js

@@ -89,7 +89,7 @@ async function pollVideoStatus(ctx, generationId) {
     return url;
 }
 export async function genDigitalHuman(input, ctxIn) {
-    const ctx = resolveHttpContext(ctxIn.skillName, {
+    const ctx = await resolveHttpContext(ctxIn.skillName, {
         apiBaseUrl: input.api_base_url,
         privateToken: input.priv_token,
     });

package/dist/handlers/gen-image.js

@@ -61,7 +61,7 @@ export async function genImage(input, ctxIn) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
         throw new SkillError('❌ Please provide --prompt to describe the image');
     }
-    const ctx = resolveHttpContext(ctxIn.skillName, {
+    const ctx = await resolveHttpContext(ctxIn.skillName, {
         apiBaseUrl: input.api_base_url,
         privateToken: input.priv_token,
     });

package/dist/handlers/gen-video.js

@@ -106,7 +106,7 @@ export async function genVideo(input, ctxIn) {
     const duration = toNumber(input.duration, 'duration') ?? (isVeoModel(model) ? 8 : 5);
     const seed = toNumber(input.seed, 'seed');
     validateParamsForModel(model, duration, ratio, resolution, references.length);
-    const ctx = resolveHttpContext(ctxIn.skillName, {
+    const ctx = await resolveHttpContext(ctxIn.skillName, {
         apiBaseUrl: input.api_base_url,
         privateToken: input.priv_token,
     });

package/dist/handlers/gen-voice.js

@@ -53,7 +53,7 @@ export async function genVoice(input, ctxIn) {
     if (isTrue(input.list_voices)) {
         if (isTrue(input.local))
             return listVoicesLocal();
-        const ctx = resolveHttpContext(ctxIn.skillName, {
+        const ctx = await resolveHttpContext(ctxIn.skillName, {
             apiBaseUrl: input.api_base_url,
             privateToken: input.priv_token,
         });
@@ -69,7 +69,7 @@ export async function genVoice(input, ctxIn) {
     if (speed < 0.5 || speed > 2.0) {
         throw new SkillError('❌ speed must be in the range 0.5~2.0');
     }
-    const ctx = resolveHttpContext(ctxIn.skillName, {
+    const ctx = await resolveHttpContext(ctxIn.skillName, {
         apiBaseUrl: input.api_base_url,
         privateToken: input.priv_token,
     });

package/dist/http.d.ts

@@ -5,10 +5,12 @@
  * x-conversation-id), business-code error handling (result.code != 0), and the
  * env var resolution order that every Python skill used to duplicate.
  *
- * Token resolution order (high → low):
- *   1. opts.privateToken                — caller override
- *   2. process.env.PRIV_TOKEN           — process env
- *   3. throws SkillError                — non-interactive failure
+ * Token resolution order (high → low), shared with the CLI auth commands via
+ * src/auth/resolve.ts:
+ *   1. opts.privateToken              — caller override (maps to --token/--priv-token)
+ *   2. process.env.PRIV_TOKEN         — process env (CI / agent-embedded hosts)
+ *   3. Credential_Store[apiBaseUrl]   — written by `remixmate login`
+ *   (none) → throws SkillError        — non-interactive failure
  *
  * Base URL resolution:
  *   1. opts.apiBaseUrl                  — caller override
@@ -19,6 +21,8 @@ export declare class SkillError extends Error {
     readonly exitCode: number;
     constructor(message: string, exitCode?: number);
 }
+/** Resolve the ab-api base URL the same way for authenticated and device-flow calls. */
+export declare function resolveApiBaseUrl(flag?: string): string;
 export interface HttpContext {
     apiBaseUrl: string;
     privateToken: string;
@@ -29,7 +33,7 @@ export interface HttpContext {
 export declare function resolveHttpContext(skillName: string, opts?: {
     apiBaseUrl?: string;
     privateToken?: string;
-}): HttpContext;
+}): Promise<HttpContext>;
 export interface MmResponse<T = unknown> {
     code: number;
     msg?: string;

package/dist/http.js

@@ -5,16 +5,20 @@
  * x-conversation-id), business-code error handling (result.code != 0), and the
  * env var resolution order that every Python skill used to duplicate.
  *
- * Token resolution order (high → low):
- *   1. opts.privateToken                — caller override
- *   2. process.env.PRIV_TOKEN           — process env
- *   3. throws SkillError                — non-interactive failure
+ * Token resolution order (high → low), shared with the CLI auth commands via
+ * src/auth/resolve.ts:
+ *   1. opts.privateToken              — caller override (maps to --token/--priv-token)
+ *   2. process.env.PRIV_TOKEN         — process env (CI / agent-embedded hosts)
+ *   3. Credential_Store[apiBaseUrl]   — written by `remixmate login`
+ *   (none) → throws SkillError        — non-interactive failure
  *
  * Base URL resolution:
  *   1. opts.apiBaseUrl                  — caller override
  *   2. process.env.MM_API_BASE_URL      — process env
  *   3. http://localhost:2999/api        — local dev fallback
  */
+import { resolvePrivToken, NOT_AUTHENTICATED_HINT } from './auth/resolve.js';
+import { attemptAutoLogin } from './auth/auto-login.js';
 const DEFAULT_API_BASE_URL = 'http://localhost:2999/api';
 export class SkillError extends Error {
     exitCode;
@@ -24,15 +28,25 @@ export class SkillError extends Error {
         this.name = 'SkillError';
     }
 }
-export function resolveHttpContext(skillName, opts = {}) {
-    const apiBaseUrl = (opts.apiBaseUrl ?? process.env.MM_API_BASE_URL ?? DEFAULT_API_BASE_URL).replace(/\/+$/, '');
-    const privateToken = opts.privateToken ?? process.env.PRIV_TOKEN ?? '';
-    if (!privateToken) {
-        throw new SkillError('❌ PRIV_TOKEN is not configured (set the env var or pass --priv-token)');
+/** Resolve the ab-api base URL the same way for authenticated and device-flow calls. */
+export function resolveApiBaseUrl(flag) {
+    return (flag ?? process.env.MM_API_BASE_URL ?? DEFAULT_API_BASE_URL).replace(/\/+$/, '');
+}
+export async function resolveHttpContext(skillName, opts = {}) {
+    const apiBaseUrl = resolveApiBaseUrl(opts.apiBaseUrl);
+    let resolved = await resolvePrivToken({ flag: opts.privateToken, apiBaseUrl });
+    // Only when flag/env/store are all empty do we try automatic browser auth.
+    // attemptAutoLogin self-gates (cloud env / headless / disabled → returns null
+    // immediately), so the env-injected path never reaches it (zero regression).
+    if (!resolved) {
+        resolved = await attemptAutoLogin(apiBaseUrl);
+    }
+    if (!resolved) {
+        throw new SkillError(NOT_AUTHENTICATED_HINT);
     }
     return {
         apiBaseUrl,
-        privateToken,
+        privateToken: resolved.privToken,
         skillName,
         agentName: process.env.AGENT_NAME || undefined,
         conversationId: process.env.CONVERSATION_ID || undefined,

package/dist/manifest.json

@@ -1,11 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.1.1",
-  "generatedAt": "2026-06-08T05:59:50.921Z",
+  "version": "0.9.1",
+  "generatedAt": "2026-06-13T02:35:04.526Z",
   "skills": [
     {
       "id": "export-jianying",
       "tier": "orchestration",
+      "category": "consuming",
       "title": "Jianying (CapCut) Draft Export",
       "summary": "Jianying (CapCut) draft export: package asset URLs into a draft ZIP that Jianying can import. Supports automatic conversion from a RenderPlan.",
       "triggers": [
@@ -28,6 +29,7 @@
     {
       "id": "gen-digital-human",
       "tier": "atomic",
+      "category": "asset",
       "title": "Digital-Human Talking-Head",
       "summary": "Digital-human video: list available avatars; produce a talking-head video from text via TTS, or drive an avatar from an existing audio URL.",
       "triggers": [
@@ -50,6 +52,7 @@
     {
       "id": "gen-image",
       "tier": "atomic",
+      "category": "asset",
       "title": "AI Image Generation",
       "summary": "AI image generation: produce an image from a text prompt. Supports Seedream and Gemini models, plus image-to-image with reference images.",
       "triggers": [
@@ -73,6 +76,7 @@
     {
       "id": "gen-script",
       "tier": "orchestration",
+      "category": "authoring",
       "title": "Video Script Generation",
       "summary": "Video script generation: turn a topic into a structured Video DSL (JSON) that describes the full video — scene structure, asset requirements, and narrative flow.",
       "triggers": [
@@ -95,6 +99,7 @@
     {
       "id": "gen-video",
       "tier": "atomic",
+      "category": "asset",
       "title": "AI Video Generation",
       "summary": "AI video generation: produce a short video clip from a text prompt. Supports Seedance and Veo models, plus first/last frame and reference images.",
       "triggers": [
@@ -117,6 +122,7 @@
     {
       "id": "gen-voice",
       "tier": "atomic",
+      "category": "asset",
       "title": "Text-to-Speech (Minimax)",
       "summary": "Text-to-speech (TTS): synthesize narration audio from text via the Minimax TTS model. Returns the persisted audio URL — no download needed.",
       "triggers": [
@@ -138,6 +144,7 @@
     {
       "id": "prepare-video-assets",
       "tier": "orchestration",
+      "category": "authoring",
       "title": "Video Asset Preparation",
       "summary": "Resolves and generates every asset (image / audio / video) referenced by a Video DSL, persists a RenderPlan to the database, and returns a job_id for the subsequent render_video call. This is Phase 1 of the two-phase video pipeline; Phase 3 (Remotion render) lives in render_video.",
       "triggers": [
@@ -165,6 +172,7 @@
     {
       "id": "render-video",
       "tier": "orchestration",
+      "category": "authoring",
       "title": "Remotion Video Renderer",
       "summary": "Loads a persisted RenderPlan by job_id and drives the Remotion engine to produce the final video. Assets must already be generated via prepare_video_assets — this skill never resolves or regenerates assets.",
       "triggers": [
@@ -192,6 +200,7 @@
     {
       "id": "template-registry",
       "tier": "orchestration",
+      "category": "authoring",
       "title": "Video Template Registry",
       "summary": "List all available video templates (templateId / name / aspect ratio / style tags). Template-to-DSL binding is no longer exposed as a separate step — once prepare_video_assets receives a template_id it runs the full DSL→RenderPlan pipeline internally.",
       "triggers": [
@@ -204,14 +213,15 @@
       "runtime": "python",
       "envVars": [
         "PRIV_TOKEN",
-        "VIDEO_TEMPLATE_REGISTRY",
         "VIDEO_TEMPLATE_REGISTRY_URL",
+        "MM_API_BASE_URL",
         "VIDEO_TEMPLATE_REGISTRY_HTTP_METHOD"
       ]
     },
     {
       "id": "video-parser",
       "tier": "tool",
+      "category": "consuming",
       "title": "Video Deconstruction",
       "summary": "Video deconstruction: split a video into reusable assets (audio extraction, ASR transcript, keyframe extraction, scene segmentation).",
       "triggers": [
@@ -233,6 +243,7 @@
     {
       "id": "web-capture",
       "tier": "tool",
+      "category": "consuming",
       "title": "Web Page Capture",
       "summary": "Drive a headless browser (Playwright Python) to capture any URL to local files: full-page / element / region screenshots, fixed-duration / condition-triggered / auto-scroll recordings, and storyboard videos (highlight / focus / zoom / scroll / virtual-cursor click / caption / title-card / arrow / numbered sequence / redact / code-line highlight). Two entry scripts: scripts/screenshot.py (stills) and scripts/record.py (webm video, storyboards, templates).",
       "triggers": [