@remixmate/cli 0.9.71 → 0.9.73

package/dist/project/trace.js

@@ -1,278 +1,5 @@
-/**
- * Execution-trace self-reporting — tell the backend what this invocation
- * actually did, so a locally-run pipeline is not a blind spot.
- *
- * Why this exists: the cloud agent records every tool call, its arguments AND
- * its result into `media_chat_turn_trace` (ab-agent/src/trace-persist.ts). The
- * local path records nothing — a take created from codex / claude code has an
- * empty conversation, zero tool calls and zero credits in the analytics tables,
- * so every session-level metric silently excludes it.
- *
- * What we can honestly report and what we cannot: the CLI is a child process
- * spawned once per skill call. It never sees the user's prompt or the host's
- * reply — those live in the host's own transcript. So this module reports the
- * one thing it genuinely observes: the invocation itself.
- *
- * See docs/product/cli/cli-session-record-design.md §5.
- */
-import os from 'node:os';
-import { cleanDiagnosticText, outcomeOf } from '../diagnostics.js';
-import { billingSummary } from '../billing.js';
-import { packageVersion } from '../install.js';
-import { mmPost } from '../http.js';
-/** Same ceiling ab-agent uses for a tool result — one table, one limit. */
-const TOOL_RESULT_MAX = 16 * 1024;
-/** Raw bytes held before trimming. Generous: trimming is the tail, cleaning is cheap. */
-const RAW_CAPTURE_MAX = 64 * 1024;
-/** Per-argument ceiling. Prompts and narration bodies are content, not evidence. */
-const ARG_VALUE_MAX = 512;
-/** `error_summary` is varchar(1024). */
-const ERROR_SUMMARY_MAX = 1024;
-const FLUSH_TIMEOUT_MS = 10_000;
-const SENSITIVE_KEY = /token|secret|password|api[_-]?key|authorization/i;
-/**
- * Whether this invocation should report at all.
- *
- * The rule is deliberately narrow: report only when THIS process resolved the
- * take. Everything else is already covered by someone else —
- *   - under the cloud agent, CONVERSATION_ID arrives pre-set and ab-agent's own
- *     TurnTracer already recorded the very same call;
- *   - a nested `gen-image` spawned by prepare-video-assets inherits its
- *     parent's CONVERSATION_ID, and the parent's row already covers it.
- * Since runner.ts only builds a tracer after resolving a take itself, this
- * function just honours the kill switch.
- */
-export function tracingEnabled(env = process.env) {
-    return (env.REMIXMATE_TRACE ?? '').trim() !== '0';
-}
-/**
- * Collects one invocation's evidence and posts it as a single turn.
- *
- * Lifecycle (runner.ts): `begin()` → output flows through the tap → `finish()`
- * in a finally block. Every failure mode ends in a warning on stderr: a lost
- * trace row must never cost the user a render they already paid for.
- */
-export class InvocationTrace {
-    opts;
-    chunks = '';
-    restore = null;
-    flushed = false;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    /** Returns null when tracing is off — callers can then skip output capture entirely. */
-    static begin(opts) {
-        if (!tracingEnabled())
-            return null;
-        if (!opts.take.conversationId)
-            return null;
-        return new InvocationTrace(opts);
-    }
-    /**
-     * Tap both output streams.
-     *
-     * One tap covers both dispatch paths: in-process handlers write here
-     * directly, and the Python child's piped output is re-emitted through the
-     * same `write` (see runner.ts). Restored in finish().
-     */
-    installCapture() {
-        if (this.restore)
-            return;
-        const out = process.stdout.write.bind(process.stdout);
-        const err = process.stderr.write.bind(process.stderr);
-        const tap = (original) => ((chunk, ...rest) => {
-            this.absorb(chunk);
-            return original(chunk, ...rest);
-        });
-        process.stdout.write = tap(out);
-        process.stderr.write = tap(err);
-        this.restore = () => {
-            process.stdout.write = out;
-            process.stderr.write = err;
-        };
-    }
-    /** Feed captured output. Keeps a bounded tail — the decisive line is the last one. */
-    absorb(chunk) {
-        try {
-            const text = typeof chunk === 'string'
-                ? chunk
-                : chunk instanceof Uint8Array
-                    ? Buffer.from(chunk).toString('utf8')
-                    : '';
-            if (!text)
-                return;
-            this.chunks += text;
-            if (this.chunks.length > RAW_CAPTURE_MAX * 2) {
-                this.chunks = this.chunks.slice(-RAW_CAPTURE_MAX);
-            }
-        }
-        catch {
-            // Capturing must never break the thing being captured.
-        }
-    }
-    /**
-     * Emit the turn. Idempotent; never throws.
-     *
-     * `error` is the dispatcher's caught exception when there is one — a Python
-     * child that exits non-zero gives us no exception, only its output, which is
-     * exactly why the tail buffer exists.
-     */
-    async finish(exitCode, durationMs, error) {
-        this.restore?.();
-        this.restore = null;
-        if (this.flushed)
-            return;
-        this.flushed = true;
-        const { skillName, args, take, ctx } = this.opts;
-        const output = condense(this.chunks);
-        const outcome = outcomeOf(exitCode);
-        const isError = exitCode !== 0;
-        const rows = [];
-        let stepSeq = 0;
-        // One env row per take, not per call: it describes the toolchain, and the
-        // toolchain does not change between two calls of the same pipeline.
-        if (take.created) {
-            rows.push({ sessionId: take.sessionKey, stepSeq: stepSeq++, kind: 'env', env: envSnapshot(take) });
-        }
-        rows.push({
-            sessionId: take.sessionKey,
-            stepSeq: stepSeq++,
-            kind: 'tool_call',
-            toolName: `cli__${skillName.replace(/-/g, '_')}`,
-            toolUseId: (process.env.AB_OPERATION_ID ?? '').slice(0, 64),
-            toolInput: sanitiseArgs(args),
-            toolResult: output || '[no output captured]',
-            isError,
-            durationMs: Math.round(durationMs),
-        });
-        rows.push({
-            sessionId: take.sessionKey,
-            stepSeq: stepSeq++,
-            kind: 'turn_result',
-            outcome,
-            errorSummary: isError ? summariseError(error, output) : '',
-            credits: billingSummary()?.credits ?? 0,
-        });
-        try {
-            await mmPost(ctx, `/chat/conversation/${encodeURIComponent(take.conversationId)}/trace`, 
-            // appendTurn: the server allocates turn_seq. N unrelated processes
-            // cannot number themselves, and cli-project-binding §5.1 already ruled
-            // out keeping local state. Older backends ignore the field and every
-            // row lands on turn 0 — still ordered, just ungrouped.
-            { appendTurn: true, traces: rows }, { timeoutMs: FLUSH_TIMEOUT_MS });
-        }
-        catch (err) {
-            process.stderr.write(`⚠️  执行轨迹未能上报（不影响本次产物）: ${cleanDiagnosticText(err.message, 256)}\n`);
-        }
-    }
-}
-/** Which rung of the grouping ladder produced this key (cli-project-binding §5.1). */
-function keySource(key) {
-    if (key.startsWith('custom:'))
-        return 'env-override';
-    if (key.startsWith('job:'))
-        return 'render-job';
-    return 'host';
-}
-/**
- * What this take was produced by. Mirrors ab-agent's envSnapshot() in purpose:
- * answer "which version started failing" without storing anything large.
- */
-function envSnapshot(take) {
-    return {
-        // The discriminator every cross-channel metric needs — a CLI "turn" is one
-        // skill call, a cloud turn is a whole user request. Never compare blindly.
-        channel: 'cli',
-        cli_version: packageVersion(),
-        host: take.host || 'unknown',
-        take_key_source: keySource(take.sessionKey),
-        node: process.version,
-        platform: `${os.platform()}-${os.arch()}`,
-    };
-}
-/**
- * Flags → a trace-safe object.
- *
- * Credentials are dropped outright; long strings are cut to their opening
- * because an argument like `--prompt` is *content*, and this table is evidence,
- * not an archive of what the user wrote.
- */
-export function sanitiseArgs(args) {
-    const out = {};
-    for (const [key, value] of Object.entries(args).slice(0, 40)) {
-        if (SENSITIVE_KEY.test(key)) {
-            out[key] = '[redacted]';
-            continue;
-        }
-        if (typeof value === 'boolean') {
-            out[key] = value;
-            continue;
-        }
-        if (Array.isArray(value)) {
-            out[key] = value.slice(0, 20).map((v) => cleanDiagnosticText(String(v), ARG_VALUE_MAX));
-            continue;
-        }
-        out[key] = cleanDiagnosticText(String(value), ARG_VALUE_MAX);
-    }
-    return out;
-}
-/**
- * Captured output → the tail we store.
- *
- * Two transformations before truncating, both about spending the 16KB on
- * things a human would read:
- *   - progress lines are the machine protocol — one fat JSON object per phase,
- *     marked by a `__progress__` field (progress.ts, and the same shape from the
- *     Python skills). Their payload is noise here, but WHICH PHASE a failed run
- *     reached is the single most useful fact about it, so the line collapses to
- *     its phase name instead of being dropped.
- *   - `__diagnostic_v1__` lines are our own structured log of this very run;
- *     keeping them would store the same verdict twice.
- *
- * Then keeps the TAIL, unlike ab-agent's head-first cleanText: a command's
- * verdict — the error, or the URL it produced — is its last line.
- */
-export function condense(raw) {
-    if (!raw)
-        return '';
-    const compacted = raw
-        .split('\n')
-        .map((line) => {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('__diagnostic_v1__'))
-            return null;
-        if (!trimmed.startsWith('{') || !trimmed.includes('"__progress__"'))
-            return line;
-        try {
-            const phase = JSON.parse(trimmed).phase;
-            return typeof phase === 'string' ? `· phase=${phase}` : '· progress';
-        }
-        catch {
-            return '· progress';
-        }
-    })
-        .filter((line) => line !== null)
-        .join('\n')
-        .trim();
-    // Slice the tail before cleaning: cleanDiagnosticText truncates head-first.
-    const tail = compacted.length > TOOL_RESULT_MAX ? compacted.slice(-TOOL_RESULT_MAX) : compacted;
-    return cleanDiagnosticText(tail, TOOL_RESULT_MAX);
-}
-/**
- * The one-line verdict.
- *
- * A thrown SkillError carries it directly. A Python child does not throw — it
- * just exits non-zero, so fall back to the last line it printed, which is where
- * argparse errors, tracebacks and our own ❌ messages end up.
- */
-function summariseError(error, output) {
-    if (error instanceof Error && error.message) {
-        return cleanDiagnosticText(error.message, ERROR_SUMMARY_MAX);
-    }
-    const lastLine = output
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l && !l.startsWith('· phase='))
-        .pop();
-    return lastLine ? cleanDiagnosticText(lastLine, ERROR_SUMMARY_MAX) : '';
-}
+var k=Object.defineProperty;var n=(e,t)=>k(e,"name",{value:t,configurable:!0});import d from"node:os";import{cleanDiagnosticText as u,outcomeOf as v}from"../diagnostics.js";import{billingSummary as I}from"../billing.js";import{packageVersion as b}from"../install.js";import{mmPost as M}from"../http.js";const l=16*1024,m=64*1024,_=512,g=1024,R=1e4,w=/token|secret|password|api[_-]?key|authorization/i;function T(e=process.env){return(e.REMIXMATE_TRACE??"").trim()!=="0"}n(T,"tracingEnabled");class y{static{n(this,"InvocationTrace")}opts;chunks="";restore=null;flushed=!1;constructor(t){this.opts=t}static begin(t){return!T()||!t.take.conversationId?null:new y(t)}installCapture(){if(this.restore)return;const t=process.stdout.write.bind(process.stdout),r=process.stderr.write.bind(process.stderr),s=n(o=>((c,...i)=>(this.absorb(c),o(c,...i))),"tap");process.stdout.write=s(t),process.stderr.write=s(r),this.restore=()=>{process.stdout.write=t,process.stderr.write=r}}absorb(t){try{const r=typeof t=="string"?t:t instanceof Uint8Array?Buffer.from(t).toString("utf8"):"";if(!r)return;this.chunks+=r,this.chunks.length>m*2&&(this.chunks=this.chunks.slice(-m))}catch{}}async finish(t,r,s){if(this.restore?.(),this.restore=null,this.flushed)return;this.flushed=!0;const{skillName:o,args:c,take:i,ctx:S}=this.opts,f=W(this.chunks),A=v(t),h=t!==0,a=[];let p=0;i.created&&a.push({sessionId:i.sessionKey,stepSeq:p++,kind:"env",env:U(i)}),a.push({sessionId:i.sessionKey,stepSeq:p++,kind:"tool_call",toolName:`cli__${o.replace(/-/g,"_")}`,toolUseId:(process.env.AB_OPERATION_ID??"").slice(0,64),toolInput:x(c),toolResult:f||"[no output captured]",isError:h,durationMs:Math.round(r)}),a.push({sessionId:i.sessionKey,stepSeq:p++,kind:"turn_result",outcome:A,errorSummary:h?$(s,f):"",credits:I()?.credits??0});try{await M(S,`/chat/conversation/${encodeURIComponent(i.conversationId)}/trace`,{appendTurn:!0,traces:a},{timeoutMs:R})}catch(E){process.stderr.write(`⚠️  执行轨迹未能上报（不影响本次产物）: ${u(E.message,256)}
+`)}}}function O(e){return e.startsWith("custom:")?"env-override":e.startsWith("job:")?"render-job":"host"}n(O,"keySource");function U(e){return{channel:"cli",cli_version:b(),host:e.host||"unknown",take_key_source:O(e.sessionKey),node:process.version,platform:`${d.platform()}-${d.arch()}`}}n(U,"envSnapshot");function x(e){const t={};for(const[r,s]of Object.entries(e).slice(0,40)){if(w.test(r)){t[r]="[redacted]";continue}if(typeof s=="boolean"){t[r]=s;continue}if(Array.isArray(s)){t[r]=s.slice(0,20).map(o=>u(String(o),_));continue}t[r]=u(String(s),_)}return t}n(x,"sanitiseArgs");function W(e){if(!e)return"";const t=e.split(`
+`).map(s=>{const o=s.trim();if(o.startsWith("__diagnostic_v1__"))return null;if(!o.startsWith("{")||!o.includes('"__progress__"'))return s;try{const c=JSON.parse(o).phase;return typeof c=="string"?`· phase=${c}`:"· progress"}catch{return"· progress"}}).filter(s=>s!==null).join(`
+`).trim(),r=t.length>l?t.slice(-l):t;return u(r,l)}n(W,"condense");function $(e,t){if(e instanceof Error&&e.message)return u(e.message,g);const r=t.split(`
+`).map(s=>s.trim()).filter(s=>s&&!s.startsWith("· phase=")).pop();return r?u(r,g):""}n($,"summariseError");export{y as InvocationTrace,W as condense,x as sanitiseArgs,T as tracingEnabled};

package/dist/registry.js

@@ -1,70 +1,3 @@
-/**
- * Skill registry — scan skills/ and load skill.json definitions.
- *
- * Validation and entry-normalization live in `skill-schema.ts` (shared with
- * the build-time manifest generator and smoke test). A record that fails
- * validation is skipped with a warning rather than crashing the whole CLI.
- */
-import { readdirSync, readFileSync, existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { normalizeEntry, resolveAuthMode, validateSkillJson, } from './skill-schema.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export const SKILLS_DIR = path.resolve(__dirname, '..', 'skills');
-function loadOne(skillDir) {
-    const skillJsonPath = path.join(skillDir, 'skill.json');
-    if (!existsSync(skillJsonPath))
-        return null;
-    const skillId = path.basename(skillDir);
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(skillJsonPath, 'utf-8'));
-    }
-    catch (err) {
-        console.error(`[remixmate] failed to parse ${skillJsonPath}:`, err);
-        return null;
-    }
-    const errors = validateSkillJson(raw, skillId);
-    if (errors.length > 0) {
-        console.warn(`[remixmate] skipping ${skillId}:\n${errors.map((e) => `    - ${e}`).join('\n')}`);
-        return null;
-    }
-    // validateSkillJson guarantees a resolvable entry.
-    const entry = normalizeEntry(raw);
-    const def = {
-        name: raw.name,
-        toolName: raw.toolName,
-        description: raw.description,
-        parameters: raw.parameters ?? {},
-        entry,
-        auth: resolveAuthMode(raw),
-        createsTake: raw.createsTake === true,
-        joinsTake: raw.joinsTake === true,
-        createsTakeUnless: Array.isArray(raw.createsTakeUnless) ? raw.createsTakeUnless : [],
-        skillDir,
-    };
-    if (entry.type === 'python') {
-        def.scriptAbsolutePath = path.join(skillDir, entry.scriptPath);
-    }
-    return def;
-}
-export function loadSkills(baseDir = SKILLS_DIR) {
-    if (!existsSync(baseDir)) {
-        console.warn(`[remixmate] skills directory not found: ${baseDir}`);
-        return [];
-    }
-    const skills = [];
-    for (const entry of readdirSync(baseDir)) {
-        const skillDir = path.join(baseDir, entry);
-        if (!statSync(skillDir).isDirectory())
-            continue;
-        const def = loadOne(skillDir);
-        if (def)
-            skills.push(def);
-    }
-    skills.sort((a, b) => a.name.localeCompare(b.name));
-    return skills;
-}
-export function findSkill(name, baseDir) {
-    return loadSkills(baseDir).find((s) => s.name === name) ?? null;
-}
+var p=Object.defineProperty;var a=(r,t)=>p(r,"name",{value:t,configurable:!0});import{readdirSync as u,readFileSync as f,existsSync as m,statSync as d}from"node:fs";import o from"node:path";import{fileURLToPath as k}from"node:url";import{normalizeEntry as y,resolveAuthMode as h,validateSkillJson as S}from"./skill-schema.js";const T=o.dirname(k(import.meta.url)),j=o.resolve(T,"..","skills");function x(r){const t=o.join(r,"skill.json");if(!m(t))return null;const n=o.basename(r);let e;try{e=JSON.parse(f(t,"utf-8"))}catch(l){return console.error(`[remixmate] failed to parse ${t}:`,l),null}const s=S(e,n);if(s.length>0)return console.warn(`[remixmate] skipping ${n}:
+${s.map(l=>`    - ${l}`).join(`
+`)}`),null;const i=y(e),c={name:e.name,toolName:e.toolName,description:e.description,parameters:e.parameters??{},entry:i,auth:h(e),createsTake:e.createsTake===!0,joinsTake:e.joinsTake===!0,createsTakeUnless:Array.isArray(e.createsTakeUnless)?e.createsTakeUnless:[],skillDir:r};return i.type==="python"&&(c.scriptAbsolutePath=o.join(r,i.scriptPath)),c}a(x,"loadOne");function $(r=j){if(!m(r))return console.warn(`[remixmate] skills directory not found: ${r}`),[];const t=[];for(const n of u(r)){const e=o.join(r,n);if(!d(e).isDirectory())continue;const s=x(e);s&&t.push(s)}return t.sort((n,e)=>n.name.localeCompare(e.name)),t}a($,"loadSkills");function I(r,t){return $(t).find(n=>n.name===r)??null}a(I,"findSkill");export{j as SKILLS_DIR,I as findSkill,$ as loadSkills};

package/dist/runner.js

@@ -1,225 +1,7 @@
-/**
- * Skill dispatcher — routes a parsed invocation to either:
- *   - spawn `python3 <scriptAbsolutePath> --flag value ...` (entry.type === 'python')
- *   - call a TS handler from handlers/ (entry.type === 'http' | 'builtin')
- *
- * Authorization happens HERE, once, before either path — see auth/ensure.ts for
- * why. Python children receive the resolved credential through their environment
- * and never read the credential store themselves.
- *
- * Resolves to the child process's exit code so cli.ts can propagate it.
- */
-import { diagnostic, cleanDiagnosticText, traceHeaders } from './diagnostics.js';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { findSkill, SKILLS_DIR } from './registry.js';
-import { HANDLERS } from './handlers/index.js';
-import { EXIT, SkillError } from './errors.js';
-import { authChildEnv, ensureAuth } from './auth/ensure.js';
-import { emitBillingFooter } from './billing.js';
-import { resolveHttpContext } from './http.js';
-import { ensureTake, findTake } from './project/take.js';
-import { InvocationTrace } from './project/trace.js';
-/** Read the token override accepted by both the TS handlers and the Python skills. */
-function tokenFlag(args) {
-    const value = args.token ?? args.priv_token;
-    return typeof value === 'string' ? value : undefined;
-}
-export async function runSkill(skillName, opts) {
-    const started = performance.now();
-    let exitCode = EXIT.ERROR;
-    let failure;
-    let trace = null;
-    traceHeaders();
-    const skill = findSkill(skillName, opts.baseDir ?? SKILLS_DIR);
-    if (!skill) {
-        process.stderr.write(`❌ skill not found: ${skillName}\n`);
-        diagnostic(EXIT.USAGE, performance.now() - started);
-        return EXIT.USAGE;
-    }
-    try {
-        const auth = await ensureAuth({
-            mode: skill.auth,
-            apiBaseUrl: typeof opts.parsedArgs.api_base_url === 'string' ? opts.parsedArgs.api_base_url : undefined,
-            flagToken: tokenFlag(opts.parsedArgs),
-        });
-        const attached = await applyTakeContext(skill, opts, auth);
-        if (attached) {
-            // Only a take THIS process resolved gets reported — see trace.ts for why
-            // the cloud path and nested pipeline children must stay silent.
-            trace = InvocationTrace.begin({
-                skillName: skill.name,
-                args: opts.parsedArgs,
-                take: attached.take,
-                ctx: attached.ctx,
-            });
-            trace?.installCapture();
-        }
-        switch (skill.entry.type) {
-            case 'python':
-                // Python children talk to ab-api themselves and print their own billing
-                // footer; nothing was charged through this process.
-                exitCode = await runPython(skill, opts.rawArgs, auth, trace);
-                break;
-            case 'http':
-            case 'builtin':
-                exitCode = await runHandler(skill, opts.parsedArgs, auth);
-                break;
-        }
-    }
-    catch (err) {
-        failure = err;
-        if (err instanceof SkillError) {
-            process.stderr.write(cleanDiagnosticText(err.message) + '\n');
-            exitCode = err.exitCode;
-        }
-        else {
-            process.stderr.write(`❌ unexpected error: ${cleanDiagnosticText(err.stack ?? err.message)}\n`);
-            exitCode = EXIT.ERROR;
-        }
-        // Single exit point below: the trace flush in `finally` must run before the
-        // value leaves, and an `await` there defeats TS's reachability analysis on
-        // returns made from inside the try/catch.
-    }
-    finally {
-        // In `finally` because a run can fail *after* a billed step (e.g. the image
-        // generated and was charged, then the upload timed out) — spend gets
-        // reported either way. No-ops when nothing was charged.
-        diagnostic(exitCode, performance.now() - started, failure);
-        emitBillingFooter();
-        // Last, so the billing footer is still inside the captured tail. Never
-        // throws and never changes the exit code — a lost trace row must not cost
-        // the user a render they already paid for.
-        await trace?.finish(exitCode, performance.now() - started, failure);
-    }
-    return exitCode;
-}
-/**
- * Decide the take mode from the skill's declaration *and* what this particular
- * invocation was asked to do.
- *
- * The manifest flags alone are not enough, because they describe the skill, not
- * the call: `render-video --help` prints usage and exits, and
- * `render-video --resolve-only` stops after asset resolution. Both used to run
- * the full createsTake path, so a help query was enough to mint an empty take
- * and lazily create 「未分类」 — the exact clutter project/take.ts sets out to
- * avoid ("an empty VideoProject is worse clutter than an unattributed image").
- *
- * Note that a downgraded run still *joins*: when its own pipeline already
- * started a take under the same grouping key, assets it generates stay attached.
- */
-export function resolveTakeMode(skill, args) {
-    // Introspection — the skill prints its usage and exits without producing
-    // anything, so it must not touch the backend at all.
-    if (args.help === true || args.h === true)
-        return 'none';
-    if (skill.createsTake) {
-        const downgraded = (skill.createsTakeUnless ?? []).some((key) => args[key] === true);
-        return downgraded ? 'join' : 'create';
-    }
-    return skill.joinsTake ? 'join' : 'none';
-}
-/**
- * Attach this invocation to a take, publishing the result as `CONVERSATION_ID`.
- * That variable is the only thing that makes an uploaded asset reachable from
- * the web app — it rides the upload as `x-conversation-id` and lands in
- * `file.conversation_id`.
- *
- * Writes `process.env` rather than returning a child-env patch, because the two
- * dispatch paths consume it differently: spawned Python inherits the process
- * environment, while http/builtin handlers run in-process and read it via
- * resolveHttpContext(). Four of the seven take-joining skills are in-process
- * handlers, so a child-env-only patch would silently do nothing for them.
- * Safe here because the CLI runs exactly one skill per process.
- *
- * Two deliberate non-behaviours:
- *   - An already-set CONVERSATION_ID is left alone. The cloud agent injects its
- *     own, and so does our own parent when prepare-video-assets shells out to
- *     gen-image / gen-voice. Re-deriving would fork the conversation.
- *   - Any failure is downgraded to a warning. Attribution is a convenience;
- *     losing it must never cost the user a render they already paid for. The
- *     asset still uploads, just unattributed — exactly the old behaviour.
- */
-async function applyTakeContext(skill, opts, auth) {
-    const mode = resolveTakeMode(skill, opts.parsedArgs);
-    if (mode === 'none')
-        return null;
-    if ((process.env.CONVERSATION_ID ?? '').trim())
-        return null;
-    if (!auth.token)
-        return null;
-    try {
-        const ctx = await resolveHttpContext(skill.name, {
-            apiBaseUrl: auth.apiBaseUrl,
-            preflightToken: auth.token,
-        });
-        let take;
-        if (mode === 'create') {
-            const jobIdArg = opts.parsedArgs.job_id;
-            const jobId = typeof jobIdArg === 'number' ? jobIdArg : Number(jobIdArg);
-            const flagProject = opts.parsedArgs.project;
-            take = await ensureTake(ctx, {
-                jobId: Number.isFinite(jobId) ? jobId : undefined,
-                flagProjectId: typeof flagProject === 'string' ? flagProject : undefined,
-            });
-        }
-        else {
-            take = await findTake(ctx);
-        }
-        if (!take)
-            return null;
-        process.env.CONVERSATION_ID = take.conversationId;
-        process.stdout.write(`📁 take ${take.created ? 'created' : 'reused'}: ${take.videoProjectId} ` +
-            `(project ${take.projectId}${take.attempt ? `, attempt ${take.attempt}` : ''})\n`);
-        return { take, ctx };
-    }
-    catch (err) {
-        process.stderr.write(`⚠️  无法归属本次产物（内容仍会正常生成，但不会出现在项目里）: ${cleanDiagnosticText(err.message)}\n`);
-        return null;
-    }
-}
-/**
- * Spawn the Python skill.
- *
- * `stdio: 'inherit'` is the default and stays the default: the child writes
- * straight to the terminal, which is exactly what a CLI should do. It does mean
- * the parent sees nothing, so a failed render can only ever be reported as
- * "exit code 1" — for the most valuable step in the pipeline.
- *
- * So when (and only when) we are tracing, stdout/stderr are piped and re-emitted
- * verbatim, which routes them through the capture tap. stdin stays inherited so
- * interactive prompts still work. Resolving on `close` rather than `exit` in
- * that mode matters: `exit` can fire while the last chunk is still in the pipe,
- * which is precisely the chunk holding the error message.
- */
-async function runPython(skill, rawArgs, auth, trace) {
-    if (!skill.scriptAbsolutePath) {
-        throw new SkillError(`skill ${skill.name} has entry.type=python but no scriptAbsolutePath`);
-    }
-    const cwd = path.dirname(skill.scriptAbsolutePath);
-    return await new Promise((resolve) => {
-        const proc = spawn('python3', [skill.scriptAbsolutePath, ...rawArgs], {
-            cwd,
-            stdio: trace ? ['inherit', 'pipe', 'pipe'] : 'inherit',
-            env: { ...process.env, ...authChildEnv(auth), PYTHONUNBUFFERED: '1' },
-        });
-        if (trace) {
-            proc.stdout?.on('data', (chunk) => process.stdout.write(chunk));
-            proc.stderr?.on('data', (chunk) => process.stderr.write(chunk));
-        }
-        proc.on(trace ? 'close' : 'exit', (code) => resolve(code ?? EXIT.ERROR));
-        proc.on('error', (err) => {
-            process.stderr.write(`❌ failed to spawn python3: ${err.message}\n`);
-            resolve(EXIT.SPAWN_FAILED);
-        });
-    });
-}
-async function runHandler(skill, args, auth) {
-    const handlerKey = skill.entry.handler;
-    const handler = HANDLERS[handlerKey];
-    if (!handler) {
-        throw new SkillError(`handler not registered: ${handlerKey} (skill ${skill.name})`);
-    }
-    await handler(args, { skillName: skill.name, auth });
-    return EXIT.OK;
-}
+var m=Object.defineProperty;var c=(r,e)=>m(r,"name",{value:e,configurable:!0});import{diagnostic as l,cleanDiagnosticText as u,traceHeaders as w}from"./diagnostics.js";import{spawn as h}from"node:child_process";import g from"node:path";import{findSkill as y,SKILLS_DIR as A}from"./registry.js";import{HANDLERS as k}from"./handlers/index.js";import{EXIT as d,SkillError as f}from"./errors.js";import{authChildEnv as b,ensureAuth as I}from"./auth/ensure.js";import{emitBillingFooter as T}from"./billing.js";import{resolveHttpContext as E}from"./http.js";import{ensureTake as R,findTake as j}from"./project/take.js";import{InvocationTrace as x}from"./project/trace.js";function $(r){const e=r.token??r.priv_token;return typeof e=="string"?e:void 0}c($,"tokenFlag");async function M(r,e){const s=performance.now();let n=d.ERROR,i,o=null;w();const a=y(r,e.baseDir??A);if(!a)return process.stderr.write(`❌ skill not found: ${r}
+`),l(d.USAGE,performance.now()-s),d.USAGE;try{const t=await I({mode:a.auth,apiBaseUrl:typeof e.parsedArgs.api_base_url=="string"?e.parsedArgs.api_base_url:void 0,flagToken:$(e.parsedArgs)}),p=await N(a,e,t);switch(p&&(o=x.begin({skillName:a.name,args:e.parsedArgs,take:p.take,ctx:p.ctx}),o?.installCapture()),a.entry.type){case"python":n=await P(a,e.rawArgs,t,o);break;case"http":case"builtin":n=await S(a,e.parsedArgs,t);break}}catch(t){i=t,t instanceof f?(process.stderr.write(u(t.message)+`
+`),n=t.exitCode):(process.stderr.write(`❌ unexpected error: ${u(t.stack??t.message)}
+`),n=d.ERROR)}finally{l(n,performance.now()-s,i),T(),await o?.finish(n,performance.now()-s,i)}return n}c(M,"runSkill");function v(r,e){return e.help===!0||e.h===!0?"none":r.createsTake?(r.createsTakeUnless??[]).some(n=>e[n]===!0)?"join":"create":r.joinsTake?"join":"none"}c(v,"resolveTakeMode");async function N(r,e,s){const n=v(r,e.parsedArgs);if(n==="none"||(process.env.CONVERSATION_ID??"").trim()||!s.token)return null;try{const i=await E(r.name,{apiBaseUrl:s.apiBaseUrl,preflightToken:s.token});let o;if(n==="create"){const a=e.parsedArgs.job_id,t=typeof a=="number"?a:Number(a),p=e.parsedArgs.project;o=await R(i,{jobId:Number.isFinite(t)?t:void 0,flagProjectId:typeof p=="string"?p:void 0})}else o=await j(i);return o?(process.env.CONVERSATION_ID=o.conversationId,process.stdout.write(`📁 take ${o.created?"created":"reused"}: ${o.videoProjectId} (project ${o.projectId}${o.attempt?`, attempt ${o.attempt}`:""})
+`),{take:o,ctx:i}):null}catch(i){return process.stderr.write(`⚠️  无法归属本次产物（内容仍会正常生成，但不会出现在项目里）: ${u(i.message)}
+`),null}}c(N,"applyTakeContext");async function P(r,e,s,n){if(!r.scriptAbsolutePath)throw new f(`skill ${r.name} has entry.type=python but no scriptAbsolutePath`);const i=g.dirname(r.scriptAbsolutePath);return await new Promise(o=>{const a=h("python3",[r.scriptAbsolutePath,...e],{cwd:i,stdio:n?["inherit","pipe","pipe"]:"inherit",env:{...process.env,...b(s),PYTHONUNBUFFERED:"1"}});n&&(a.stdout?.on("data",t=>process.stdout.write(t)),a.stderr?.on("data",t=>process.stderr.write(t))),a.on(n?"close":"exit",t=>o(t??d.ERROR)),a.on("error",t=>{process.stderr.write(`❌ failed to spawn python3: ${t.message}
+`),o(d.SPAWN_FAILED)})})}c(P,"runPython");async function S(r,e,s){const n=r.entry.handler,i=k[n];if(!i)throw new f(`handler not registered: ${n} (skill ${r.name})`);return await i(e,{skillName:r.name,auth:s}),d.OK}c(S,"runHandler");export{v as resolveTakeMode,M as runSkill};