@remixmate/cli 0.9.63 → 0.9.65

package/dist/template/project.js

@@ -0,0 +1,110 @@
+/**
+ * Starter-project discovery, template identity (K4) and the shared output helper.
+ */
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { EXIT, SkillError } from '../errors.js';
+import { CHECK_ENTRY, IDENTITY_FILE } from './constants.js';
+import { usageError } from './args.js';
+// ── project root ─────────────────────────────────────────────────────────────
+/** Walk up from `start` to the directory holding `.remixmate/check/index.mjs`. */
+export function findProjectRoot(start = process.cwd()) {
+    let dir = path.resolve(start);
+    for (;;) {
+        if (existsSync(path.join(dir, CHECK_ENTRY)))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function requireProjectRoot(start) {
+    const root = findProjectRoot(start);
+    if (!root) {
+        throw new SkillError(`❌ 当前目录不在模板工程内（找不到 ${CHECK_ENTRY}）。\n` +
+            '   先运行 remixmate template init <dir>，再进入该目录执行。', EXIT.USAGE);
+    }
+    return root;
+}
+/** A template name is a single directory under templates/ — never a path. */
+export function validateTemplateName(name) {
+    if (!name)
+        throw usageError('缺少模板名：remixmate template <command> <name>');
+    if (name === '.' || name === '..' || /[\\/]/.test(name) || name.startsWith('-')) {
+        throw usageError(`模板名不合法: ${name}（应为 templates/ 下的目录名）`);
+    }
+    return name;
+}
+export function requireTemplateDir(root, name) {
+    const dir = path.join(root, 'templates', name);
+    if (!existsSync(path.join(dir, 'template.json'))) {
+        throw new SkillError(`❌ 找不到 templates/${name}/template.json`, EXIT.USAGE);
+    }
+    return dir;
+}
+export function readJsonFile(file) {
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (err) {
+        throw new SkillError(`❌ ${path.basename(file)} 解析失败: ${err.message}`);
+    }
+}
+/** kebab-case slug of a directory name; falls back to `template` when nothing survives. */
+export function kebabSlug(input) {
+    const slug = input
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug || 'template';
+}
+/** First-publish key: `my-<slug>-<6 hex>`. */
+export function generateTemplateKey(dirName, hex = randomBytes(3).toString('hex')) {
+    return `my-${kebabSlug(dirName)}-${hex}`;
+}
+export function readIdentity(templateDir) {
+    const file = path.join(templateDir, IDENTITY_FILE);
+    if (!existsSync(file))
+        return null;
+    const raw = readJsonFile(file);
+    if (typeof raw.templateKey !== 'string' || !raw.templateKey) {
+        throw new SkillError(`❌ ${IDENTITY_FILE} 缺少 templateKey，请修复或删除该文件后重试`);
+    }
+    return { templateKey: raw.templateKey, version: typeof raw.version === 'number' ? raw.version : 0 };
+}
+/** Stable key: the identity file wins, so renaming the directory never forks a template. */
+export function resolveTemplateKey(templateDir) {
+    const id = readIdentity(templateDir);
+    if (id)
+        return { templateKey: id.templateKey, existing: true };
+    return { templateKey: generateTemplateKey(path.basename(templateDir)), existing: false };
+}
+export function writeIdentity(templateDir, identity) {
+    writeFileSync(path.join(templateDir, IDENTITY_FILE), JSON.stringify(identity, null, 2) + '\n', 'utf8');
+}
+// ── output ───────────────────────────────────────────────────────────────────
+/**
+ * Human text goes to stdout by default. With --json it moves to stderr so the
+ * last stdout line is the JSON result (progress lines still go to stdout —
+ * hosts parse them by their `__progress__` marker).
+ */
+export class Output {
+    json;
+    constructor(json) {
+        this.json = json;
+    }
+    info(line = '') {
+        ;
+        (this.json ? process.stderr : process.stdout).write(line + '\n');
+    }
+    warn(line) {
+        process.stderr.write(line + '\n');
+    }
+    result(obj) {
+        if (this.json)
+            process.stdout.write(JSON.stringify(obj) + '\n');
+    }
+}

package/dist/template/publish.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `remixmate template publish <name> [--name <displayName>] [--dry-run]`
+ *
+ * Ported from template-library `scripts/publish-private.mjs` — same ab-api
+ * contract (prepareSave → presignUpload → PUT → save, isBuiltin=false), same
+ * tar excludes. Differences, all from the spec:
+ *   - the key is stable per template directory (K4 `.remixmate.json`), so a
+ *     re-publish updates instead of forking, and renaming the dir is harmless;
+ *   - the starter's own `check` runs first (requirement 6.2);
+ *   - the project files stay read-only except for `.remixmate.json` — server
+ *     normalization only touches a staging copy.
+ *
+ * Never printed: the token and the presigned upload URL.
+ */
+import { type CoreSurface } from './render-client.js';
+export interface PublishOptions {
+    name: string;
+    displayName?: string;
+    dryRun?: boolean;
+    json?: boolean;
+    token?: string;
+    apiBaseUrl?: string;
+    cwd?: string;
+}
+export interface PublishResult {
+    ok: true;
+    name: string;
+    templateKey: string;
+    version: number | null;
+    dryRun: boolean;
+    created: boolean;
+}
+type Json = Record<string, any>;
+/** tar argv with the shared exclude list — exported for tests. */
+export declare function tarArgs(srcDir: string, outFile: string): string[];
+/**
+ * Core preflight: the template's declared coreExports must all exist on the
+ * target ab-render (the tar never carries core). Returns a block reason or null.
+ * "Couldn't check" is a block, not a pass.
+ */
+export declare function evaluateCoreSurface(manifest: Json, surface: CoreSurface | null, warn?: (m: string) => void): string | null;
+export declare function runPublish(opts: PublishOptions): Promise<PublishResult>;
+export {};

package/dist/template/publish.js

@@ -0,0 +1,182 @@
+/**
+ * `remixmate template publish <name> [--name <displayName>] [--dry-run]`
+ *
+ * Ported from template-library `scripts/publish-private.mjs` — same ab-api
+ * contract (prepareSave → presignUpload → PUT → save, isBuiltin=false), same
+ * tar excludes. Differences, all from the spec:
+ *   - the key is stable per template directory (K4 `.remixmate.json`), so a
+ *     re-publish updates instead of forking, and renaming the dir is harmless;
+ *   - the starter's own `check` runs first (requirement 6.2);
+ *   - the project files stay read-only except for `.remixmate.json` — server
+ *     normalization only touches a staging copy.
+ *
+ * Never printed: the token and the presigned upload URL.
+ */
+import { cpSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { EXIT, SkillError } from '../errors.js';
+import { mmPost, resolveHttpContext } from '../http.js';
+import { emitProgress } from '../progress.js';
+import { IDENTITY_FILE, TAR_EXCLUDES } from './constants.js';
+import { runCheck } from './check.js';
+import { Output, readJsonFile, requireProjectRoot, requireTemplateDir, resolveTemplateKey, validateTemplateName, writeIdentity, } from './project.js';
+import { runProcess } from './proc.js';
+import { fetchCoreSurface, resolveRenderBaseUrl } from './render-client.js';
+/** tar argv with the shared exclude list — exported for tests. */
+export function tarArgs(srcDir, outFile) {
+    const args = ['-czf', outFile];
+    for (const ex of TAR_EXCLUDES)
+        args.push(`--exclude=${ex}`);
+    args.push('-C', srcDir, '.');
+    return args;
+}
+/**
+ * Core preflight: the template's declared coreExports must all exist on the
+ * target ab-render (the tar never carries core). Returns a block reason or null.
+ * "Couldn't check" is a block, not a pass.
+ */
+export function evaluateCoreSurface(manifest, surface, warn = () => { }) {
+    if (!surface)
+        return 'ab-render /health 未返回 coreSurface —— 该实例版本过旧，无法校验 core 契约';
+    if (!surface.available)
+        return `ab-render 无法读取 template-core：${surface.error ?? '未知原因'}`;
+    if (!Array.isArray(manifest.coreExports)) {
+        return 'template.json 缺少 coreExports —— 先运行 remixmate template check 生成';
+    }
+    const have = new Set(surface.exports ?? []);
+    const missing = manifest.coreExports.filter((n) => !have.has(n));
+    const declared = typeof manifest.coreVersion === 'string' ? manifest.coreVersion : null;
+    // `versions` is a K5 addition; older instances only expose packageVersion.
+    const offered = Array.isArray(surface.versions) && surface.versions.length > 0
+        ? surface.versions
+        : surface.packageVersion ? [surface.packageVersion] : [];
+    if (missing.length > 0) {
+        return (`目标 ab-render 的 template-core 缺少导出：${missing.join(', ')}。` +
+            `模板声明需要 core@${declared ?? '(未声明)'}，平台当前提供 ${offered.length ? offered.map((v) => `core@${v}`).join(', ') : '(未知版本)'}。` +
+            '请改用平台已有的导出，或等平台升级 core 后再发布。');
+    }
+    if (declared && offered.length > 0 && !offered.includes(declared)) {
+        warn(`  ⚠ 模板声明 core@${declared}，平台提供 ${offered.join(', ')} —— 导出齐全可以渲染，但效果未必与本地完全一致`);
+    }
+    return null;
+}
+function tarball(srcDir, outFile) {
+    return runProcess('tar', tarArgs(srcDir, outFile), { stdio: 'pipe' }).then((r) => {
+        if (r.code !== 0)
+            throw new SkillError(`❌ 打包失败（tar 退出码 ${r.code}）: ${r.stderr.trim().slice(0, 300)}`);
+    });
+}
+async function putToOss(uploadUrl, bytes) {
+    let res;
+    try {
+        // Content-Type must equal what ab-api signed, or OSS answers SignatureDoesNotMatch.
+        res = await fetch(uploadUrl, { method: 'PUT', headers: { 'Content-Type': 'application/gzip' }, body: new Uint8Array(bytes) });
+    }
+    catch (err) {
+        throw new SkillError(`❌ 上传模板包失败（网络错误）: ${err.message}`, EXIT.BACKEND_UNREACHABLE);
+    }
+    if (res.status >= 300) {
+        // Body/URL intentionally omitted: the URL is presigned.
+        throw new SkillError(`❌ 上传模板包失败（OSS HTTP ${res.status}）`, res.status >= 500 ? EXIT.BACKEND_UNREACHABLE : EXIT.ERROR);
+    }
+}
+export async function runPublish(opts) {
+    const out = new Output(Boolean(opts.json));
+    const name = validateTemplateName(opts.name);
+    const root = requireProjectRoot(opts.cwd);
+    const tplDir = requireTemplateDir(root, name);
+    emitProgress({ phase: 'template-publish:check', progress: 0.05 });
+    const checkCode = await runCheck({ name, cwd: root, stdio: opts.json ? 'stderr' : 'inherit' });
+    if (checkCode !== 0) {
+        throw new SkillError(`❌ 本地校验未通过（check 退出码 ${checkCode}），已中止发布。`, checkCode === 2 ? EXIT.USAGE : EXIT.ERROR);
+    }
+    // Re-read after check: it refreshes coreVersion / coreExports.
+    const templateJson = readJsonFile(path.join(tplDir, 'template.json'));
+    const { templateKey, existing } = resolveTemplateKey(tplDir);
+    const displayName = opts.displayName ?? (typeof templateJson.name === 'string' && templateJson.name ? templateJson.name : name);
+    const coreVersion = typeof templateJson.coreVersion === 'string' ? templateJson.coreVersion : '';
+    // Credentials before any network call, so a missing login is exit 4 rather
+    // than a confusing preflight failure. Dry-run needs none.
+    let ctx = null;
+    if (!opts.dryRun) {
+        ctx = await resolveHttpContext('template-publish', { privateToken: opts.token, apiBaseUrl: opts.apiBaseUrl });
+    }
+    const renderBase = resolveRenderBaseUrl();
+    out.info(`模板          ${name}`);
+    out.info(`templateKey   ${templateKey}${existing ? '' : '（首次发布，新生成）'}`);
+    out.info(`名称          ${displayName}`);
+    out.info(`coreVersion   ${coreVersion || '(未声明)'}`);
+    emitProgress({ phase: 'template-publish:preflight', progress: 0.15 });
+    const surface = await fetchCoreSurface(renderBase);
+    const blocked = evaluateCoreSurface(templateJson, surface, (m) => out.warn(m));
+    if (blocked)
+        throw new SkillError(`❌ core 预检未通过：${blocked}`);
+    out.info(`core 预检     通过（${surface?.exports.length ?? 0} 个导出）`);
+    if (opts.dryRun) {
+        out.info('\n[dry-run] 将依次调用 prepareSave → presignUpload → 上传 → save（isBuiltin=false）');
+        out.info(`[dry-run] 打包排除：${TAR_EXCLUDES.join(', ')}（保留 dsl-example.json）`);
+        const result = { ok: true, name, templateKey, version: null, dryRun: true, created: !existing };
+        out.result({ ...result });
+        return result;
+    }
+    const http = ctx;
+    let staging;
+    try {
+        emitProgress({ phase: 'template-publish:prepare', progress: 0.3 });
+        const prepared = await mmPost(http, '/remotionTemplate/prepareSave', {
+            templateJson,
+            name: displayName,
+            templateKey,
+            ...(coreVersion ? { coreVersion } : {}),
+        });
+        const resolvedKey = prepared?.templateKey || templateKey;
+        const normalized = prepared?.templateJson || templateJson;
+        // Staging copy: server normalization never touches the project files.
+        staging = mkdtempSync(path.join(os.tmpdir(), 'remixmate-publish-'));
+        const pkgDir = path.join(staging, 'pkg');
+        cpSync(tplDir, pkgDir, { recursive: true });
+        rmSync(path.join(pkgDir, IDENTITY_FILE), { force: true });
+        writeFileSync(path.join(pkgDir, 'template.json'), JSON.stringify(normalized, null, 2) + '\n', 'utf8');
+        if (JSON.stringify(normalized) !== JSON.stringify(templateJson)) {
+            out.warn('  ⚠ 服务端规范化后的 template.json 与本地不同；本次上传使用规范化版本，本地文件未改动。');
+        }
+        emitProgress({ phase: 'template-publish:pack', progress: 0.45 });
+        const tarPath = path.join(staging, `${resolvedKey}.tar.gz`);
+        await tarball(pkgDir, tarPath);
+        const bytes = readFileSync(tarPath);
+        out.info(`打包          ${(bytes.length / 1024).toFixed(0)} KB`);
+        emitProgress({ phase: 'template-publish:presign', progress: 0.55 });
+        const grant = await mmPost(http, '/remotionTemplate/presignUpload', { templateKey: resolvedKey });
+        if (!grant?.uploadUrl)
+            throw new SkillError('❌ presignUpload 未返回 uploadUrl');
+        emitProgress({ phase: 'template-publish:upload', progress: 0.7 });
+        await putToOss(String(grant.uploadUrl), bytes);
+        emitProgress({ phase: 'template-publish:save', progress: 0.85 });
+        await mmPost(http, '/remotionTemplate/save', {
+            templateKey: resolvedKey,
+            name: displayName,
+            isBuiltin: false,
+            sourceOssKey: grant.sourceOssKey,
+            version: grant.version,
+            templateJson: normalized,
+            ...(coreVersion ? { coreVersion } : {}),
+        });
+        const version = typeof grant.version === 'number' ? grant.version : Number(grant.version) || 0;
+        writeIdentity(tplDir, { templateKey: resolvedKey, version });
+        emitProgress({ phase: 'template-publish:done', progress: 1, templateKey: resolvedKey });
+        out.info(`\n✅ 已发布为你的私有模板`);
+        out.info(`  templateKey  ${resolvedKey}`);
+        out.info(`  version      ${version}`);
+        out.info(`  （已写入 templates/${name}/${IDENTITY_FILE}，再次发布会更新同一个模板）`);
+        out.info('\n出片：');
+        out.info(`  remixmate render-video --template-id ${resolvedKey} …`);
+        const result = { ok: true, name, templateKey: resolvedKey, version, dryRun: false, created: !existing };
+        out.result({ ...result });
+        return result;
+    }
+    finally {
+        if (staging)
+            rmSync(staging, { recursive: true, force: true });
+    }
+}

package/dist/template/render-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal ab-render client for preview (/renderDraft) and publish preflight (/health).
+ *
+ * ab-render is a different origin from ab-api but verifies the same PrivToken,
+ * so the token is resolved against the ab-api base (where `remixmate login`
+ * stored it) and sent to ab-render as X-Priv-Token. All routes are POST.
+ */
+import { SkillError } from '../errors.js';
+export declare function resolveRenderBaseUrl(): string;
+/** Business error from ab-render (`code != 0`), payload kept for issue rendering. */
+export declare class RenderBusinessError extends SkillError {
+    readonly code: number;
+    readonly payload: {
+        code?: number;
+        msg?: string;
+        data?: unknown;
+    };
+    constructor(message: string, code: number, payload: {
+        code?: number;
+        msg?: string;
+        data?: unknown;
+    });
+}
+export declare function renderPost<T = Record<string, unknown>>(base: string, route: string, body: unknown, opts: {
+    token?: string;
+    skillName: string;
+    timeoutMs?: number;
+}): Promise<T>;
+export interface CoreSurface {
+    available: boolean;
+    exports: string[];
+    digest?: string;
+    packageVersion?: string | null;
+    /** K5 addition; older ab-render instances omit it. */
+    versions?: string[];
+    error?: string | null;
+}
+/** /health → coreSurface, or null when the instance predates the core contract. */
+export declare function fetchCoreSurface(base: string): Promise<CoreSurface | null>;

package/dist/template/render-client.js

@@ -0,0 +1,79 @@
+/**
+ * Minimal ab-render client for preview (/renderDraft) and publish preflight (/health).
+ *
+ * ab-render is a different origin from ab-api but verifies the same PrivToken,
+ * so the token is resolved against the ab-api base (where `remixmate login`
+ * stored it) and sent to ab-render as X-Priv-Token. All routes are POST.
+ */
+import { traceHeaders } from '../diagnostics.js';
+import { NOT_AUTHENTICATED_HINT } from '../auth/resolve.js';
+import { EXIT, SkillError } from '../errors.js';
+import { DEFAULT_RENDER_BASE_URL } from './constants.js';
+export function resolveRenderBaseUrl() {
+    return ((process.env.AB_RENDER_URL ?? '').trim() || DEFAULT_RENDER_BASE_URL).replace(/\/+$/, '');
+}
+/** Business error from ab-render (`code != 0`), payload kept for issue rendering. */
+export class RenderBusinessError extends SkillError {
+    code;
+    payload;
+    constructor(message, code, payload) {
+        super(message, EXIT.ERROR);
+        this.code = code;
+        this.payload = payload;
+    }
+}
+export async function renderPost(base, route, body, opts) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 60_000);
+    const headers = {
+        'Content-Type': 'application/json',
+        'x-invoke-skill': opts.skillName,
+        ...traceHeaders(),
+    };
+    if (opts.token)
+        headers['X-Priv-Token'] = opts.token;
+    let res;
+    try {
+        res = await fetch(`${base}${route}`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body ?? {}),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        const why = err.name === 'AbortError' ? '请求超时' : err.message;
+        throw new SkillError(`❌ ab-render 不可达（${base}${route}）：${why}`, EXIT.BACKEND_UNREACHABLE);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const text = await res.text();
+    if (res.status === 401)
+        throw new SkillError(NOT_AUTHENTICATED_HINT, EXIT.NOT_AUTHENTICATED);
+    if (res.status >= 500) {
+        throw new SkillError(`❌ ab-render ${route} HTTP ${res.status}`, EXIT.BACKEND_UNREACHABLE);
+    }
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new SkillError(`❌ ab-render ${route} 返回非 JSON（HTTP ${res.status}）`);
+    }
+    if (json.code !== undefined && json.code !== 0) {
+        if (json.code === 401) {
+            throw new SkillError(`${NOT_AUTHENTICATED_HINT}\n   （ab-render: ${json.msg ?? 'code=401'}）`, EXIT.NOT_AUTHENTICATED);
+        }
+        throw new RenderBusinessError(`❌ ab-render ${route} code=${json.code}: ${json.msg ?? 'unknown'}`, json.code, json);
+    }
+    return (json.data ?? json);
+}
+/** /health → coreSurface, or null when the instance predates the core contract. */
+export async function fetchCoreSurface(base) {
+    const data = await renderPost(base, '/health', {}, {
+        skillName: 'template-publish',
+        timeoutMs: 15_000,
+    });
+    return data?.coreSurface ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.9.63",
+  "version": "0.9.65",
   "description": "AI media generation skills for Claude Code / Codex — 12 skills covering image, video, voice, digital human, web screenshot, web recording, script, template registry, rendering, Jianying export, and video deconstruction.",
   "type": "module",
   "main": "dist/index.js",

package/skills/template-authoring/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: template-authoring
+description: |
+  Create your own reusable video template locally and publish it as a private template on RemixMate.
+  Scaffolds a starter project (`remixmate template init <dir>`) with Remotion Studio preview, local validation,
+  remote draft preview and one-command publishing. Purely local until preview/publish; no login needed to start.
+  Use this skill whenever the user wants to:
+  - 做视频模板 / 自定义视频模板 / 创建模板 / 自己写一个模板 / 把这个画面做成模板
+  - template authoring, create a video template, build a custom Remotion template
+  - preview or publish a template they are developing locally
+triggers:
+  - 做视频模板
+  - 自定义视频模板
+  - 创建模板 / 新建模板 / 自己写一个视频模板
+  - 预览或发布我本地开发的模板
+  - template authoring
+  - create video template / build a custom video template
+  - publish my own Remotion template
+---
+
+# Template Authoring
+
+Guides a local agent (Codex, Claude Code, WorkBuddy, TraeWork) through building a video template
+on the RemixMate template SDK and publishing it as the user's **private** template.
+
+The project itself carries the authoritative guide: after `init`, read the project's `AGENTS.md`
+(Claude Code: `CLAUDE.md`, same content). It documents the template contract, the template-core
+public API and the Remotion rules. This skill only describes the workflow — do not invent template
+fields; take them from that guide and from the bundled examples.
+
+## Workflow
+
+1. **Create the project** (no login):
+   ```bash
+   remixmate template init <dir>
+   ```
+   Refuses a non-empty directory unless `--force`. Needs only Node ≥ 18 and npm.
+   As a skill call: `remixmate template-authoring --dir <dir> [--force]`.
+2. **Open the project and read `AGENTS.md`** before writing any code. Examples live in
+   `examples/` (read-only — copy one into `templates/<name>/` and edit the copy).
+3. **Develop with live preview**: `npm run dev` opens Remotion Studio.
+4. **Validate locally** (no login):
+   ```bash
+   remixmate template check <name>          # add --json for a machine-readable issue list
+   ```
+   Fix every reported issue (`file` / `rule` / `message` / `fix`). `check` also refreshes the
+   template's core contract fields — never hand-edit those.
+5. **Remote draft preview** (login required): renders on the real platform renderer.
+   ```bash
+   remixmate template preview <name>
+   ```
+   Draft limits: long edge ≤ 1280 px, short edge ≤ 720 px, ≤ 60 s.
+6. **Publish** (login required):
+   ```bash
+   remixmate template publish <name> [--name "<display name>"]
+   ```
+   The first publish writes `templates/<name>/.remixmate.json` with the template key; publishing
+   again updates the same template. Keep that file.
+7. **Render with it**:
+   ```bash
+   remixmate render-video --template-id <templateKey> ...
+   ```
+   `remixmate template list` shows the user's private templates.
+
+## Notes
+
+- Not logged in → exit code 4: run `remixmate login`. Backend unreachable → exit code 5.
+- Quota errors from publish (template count / package size / file count) are shown verbatim; relay them.
+- TraeWork only reads project-level skills: inside the project run `remixmate install --project` once.

package/skills/template-authoring/skill.json

@@ -0,0 +1,32 @@
+{
+  "name": "template-authoring",
+  "toolName": "template_authoring",
+  "tier": "tool",
+  "category": "meta",
+  "title": "Video Template Authoring",
+  "description": "Start authoring a custom video template locally: scaffolds a starter project (Remotion Studio preview, local validation, remote draft preview, publishing as the user's private template) into the given directory. After this, follow the project's AGENTS.md and use `remixmate template check|preview|publish`. Local-only; requires Node >= 18 and npm.",
+  "auth": "none",
+  "envVars": [
+    "REMIXMATE_STARTER_TARBALL"
+  ],
+  "entry": {
+    "type": "builtin",
+    "handler": "template-init"
+  },
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "dir": {
+        "type": "string",
+        "description": "Target directory for the new template project (must be empty unless force is set)"
+      },
+      "force": {
+        "type": "boolean",
+        "description": "Allow scaffolding into a non-empty directory (existing files with the same name are overwritten)"
+      }
+    },
+    "required": [
+      "dir"
+    ]
+  }
+}

package/skills/template-authoring/version.json

@@ -0,0 +1,7 @@
+{
+  "skillName": "template-authoring",
+  "repoName": "agent-skill-media-maker",
+  "skillId": "pending-template-authoring",
+  "version": "V1",
+  "skillDescription": "Local video-template authoring skill: scaffolds a RemixMate template starter project (`remixmate template init <dir>`), then guides the agent through the project's AGENTS.md, `npm run dev`, `remixmate template check`, `remixmate template preview`, `remixmate template publish`, and rendering with `remixmate render-video --template-id <templateKey>`.\n\nUse this skill whenever the user asks for any of:\n- 做视频模板 / 自定义视频模板 / 创建模板\n- template authoring, create a video template\n- preview or publish a template they develop locally"
+}

package/skills/template-registry/SKILL.md

@@ -78,7 +78,7 @@ remixmate template-registry --list-templates
 
 ### Show templates to the user
 
-When the user asks to see / browse / pick templates, they decide by *watching* samples, not by reading definitions. The list adds, per template, the number of samples and a link to its web detail page (playable samples, layouts, a copy-ready prompt) whenever the backend serves them (`↳ samples: N · <url>` in the table; `showcases.count` / `showcases.pageUrl` in JSON).
+When the user asks to see / browse / pick templates, they decide by *watching* samples, not by reading definitions. The list adds, per template, a link to its web detail page (playable samples, layouts, a copy-ready prompt) and the number of samples whenever the backend serves them — table: `↳ detail: <url>` and `↳ samples: N`; JSON: each summary's `pageUrl` and `showcases.count`; `--template-id`: top-level `pageUrls`.
 
 - Present each template as: name, aspect ratios, sample count, and its `pageUrl` as a clickable Markdown link. Keep the URL exactly as printed.
 - When the user wants to see what one template looks like, give its link, or run `remixmate template-registry --open <templateId>` (prints the URL; opens the browser only from an interactive terminal — relay the printed URL either way).
@@ -111,7 +111,7 @@ print(json.dumps(binding, ensure_ascii=False, indent=2))
 | `--filter-aspect` | Keep only templates declaring this aspect ratio (e.g. `9:16`). | none |
 | `--filter-language` | Keep only templates whose `contentLanguage` includes this code (`zh`/`en`); language-agnostic templates always show. | none |
 | `--include-beta` | Also show `status: beta` templates (same effect as `ENABLE_BETA_TEMPLATES=1`). | off |
-| `--json-output` | List mode: emit `{ "templates": [...] }` summaries (or full definitions with `--full`) instead of the table. Detail mode (`--template-id`) is always compact JSON. Summaries carry `showcases: { count, pageUrl, items }` and detail mode a top-level `showcases` map when the backend serves samples (absent otherwise). | off |
+| `--json-output` | List mode: emit `{ "templates": [...] }` summaries (or full definitions with `--full`) instead of the table. Detail mode (`--template-id`) is always compact JSON. Summaries carry `pageUrl` (web detail page) and `showcases: { count, pageUrl, items }`; detail mode carries top-level `pageUrls` and `showcases` maps. Each is absent when the backend does not serve it. | off |
 | `--open <id>` | Print the template's web detail page URL (samples, layouts) and open the browser when run from an interactive terminal. Exits 1 when the backend has no link for it. Cannot be combined with `--template-id`. | — |
 
 ### List vs. detail