tripo-cli 0.1.0

package/dist/src/pipeline/runner.js

@@ -0,0 +1,73 @@
+/**
+ * Chain runner: execute a validated sequence of processing steps, feeding
+ * each step the previous task id. rig-check gates the rig step (stop early
+ * when the model is not riggable, and adopt the recommended rig_type).
+ */
+import { UsageError } from '../core/errors.js';
+import { log, warn } from '../core/output.js';
+import { buildStepRequest } from '../core/requests.js';
+import { runTask } from '../core/task-service.js';
+import { t } from '../i18n.js';
+import { getStep, validateChain } from '../knowledge/chains.js';
+export async function runChain(options) {
+    const { client, chain } = options;
+    validateChain(chain, options.sourceType);
+    const results = [];
+    let currentTaskId = options.sourceTaskId;
+    let rigTypeRecommendation;
+    for (let i = 0; i < chain.length; i++) {
+        const spec = chain[i];
+        const args = { ...spec.args };
+        if (spec.step === 'rig' && rigTypeRecommendation && args.rig_type === undefined) {
+            args.rig_type = rigTypeRecommendation;
+            log(t({ zh: `采用 rig-check 推荐体型:${rigTypeRecommendation}`, en: `using rig-check recommendation: ${rigTypeRecommendation}` }));
+        }
+        const built = buildStepRequest(spec.step, currentTaskId, args);
+        for (const w of built.warnings)
+            warn(w);
+        const result = await runTask({
+            client,
+            request: built.request,
+            taskType: built.taskType,
+            name: `${options.namePrefix}-${spec.step}`,
+            outDir: options.outDir,
+            notify: false,
+            timeoutMs: options.timeoutMs,
+            // Intermediate steps skip download; final step downloads.
+            noDownload: i < chain.length - 1 && spec.step !== 'rig-check',
+            precheckBalance: false, // checked once by the caller
+        });
+        results.push(result);
+        if (spec.step === 'rig-check') {
+            const verdict = await client.getTask(result.task_id);
+            const output = verdict.output ?? {};
+            const riggable = output.riggable;
+            rigTypeRecommendation = typeof output.rig_type === 'string' ? output.rig_type : undefined;
+            if (riggable === false) {
+                const message = t({
+                    zh: 'rig-check 判定该模型不可绑骨,动画链止损停止(后续步骤未执行,未扣积分)',
+                    en: 'rig-check says this model is not riggable; stopping the chain early (no further credits spent)',
+                });
+                warn(message);
+                return { results, stoppedEarly: message };
+            }
+        }
+        // Gate steps (passthrough) inspect the model; the chain continues from
+        // the same upstream task.
+        if (!getStep(spec.step)?.passthrough) {
+            currentTaskId = result.task_id;
+        }
+    }
+    return { results };
+}
+/** Ensure a source task exists + succeeded before chaining onto it. */
+export async function assertSourceReady(client, taskId) {
+    const task = await client.getTask(taskId);
+    if (task.status !== 'success') {
+        throw new UsageError(`task ${taskId} is ${task.status}; processing steps need a successful upstream task` +
+            (task.status === 'running' || task.status === 'queued'
+                ? ` (wait with "tripo task watch ${taskId}")`
+                : ''));
+    }
+    return task.type;
+}

package/dist/src/pipeline/stdin.js

@@ -0,0 +1,40 @@
+/**
+ * NDJSON pipe support: downstream commands read the upstream task result from
+ * stdin, enabling `tripo make cat.png | tripo model texture | tripo anim rig`.
+ */
+/** Read piped NDJSON/JSON from stdin; returns undefined on a TTY. */
+export async function readPipedTask() {
+    if (process.stdin.isTTY)
+        return undefined;
+    const raw = await readAll(process.stdin);
+    return parsePipedText(raw);
+}
+/** Parse piped text: JSON object, NDJSON (last task line wins), or a bare task id. */
+export function parsePipedText(raw) {
+    const text = raw.trim();
+    if (!text)
+        return undefined;
+    const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+            const obj = JSON.parse(lines[i]);
+            if (typeof obj.task_id === 'string') {
+                return { task_id: obj.task_id, type: typeof obj.type === 'string' ? obj.type : undefined };
+            }
+        }
+        catch { }
+    }
+    const last = lines[lines.length - 1];
+    if (/^(task_[A-Za-z0-9_-]+|[0-9a-f-]{36})$/i.test(last))
+        return { task_id: last };
+    return undefined;
+}
+function readAll(stream) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        stream.setEncoding('utf8');
+        stream.on('data', (chunk) => (data += chunk));
+        stream.on('end', () => resolve(data));
+        stream.on('error', reject);
+    });
+}

package/dist/src/program.js

@@ -0,0 +1,147 @@
+/** Command tree assembly + global flags + the error → exit-code boundary. */
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { registerAccountCommands } from './commands/account.js';
+import { registerAiCommand } from './commands/ai.js';
+import { registerAuthCommands } from './commands/login.js';
+import { registerBatchCommand } from './commands/batch.js';
+import { registerCompletionCommand } from './commands/completion.js';
+import { registerConfigCommands } from './commands/config-cmd.js';
+import { registerDoctorCommand } from './commands/doctor.js';
+import { registerDocsCommand } from './commands/docs.js';
+import { registerGenerateCommands } from './commands/generate.js';
+import { registerHomeAction } from './commands/home.js';
+import { registerMakeCommand } from './commands/make.js';
+import { registerMcpCommand } from './commands/mcp.js';
+import { registerProcessCommands } from './commands/process-groups.js';
+import { registerTaskCommands } from './commands/task.js';
+import { registerTopupCommand } from './commands/topup.js';
+import { registerViewCommands } from './commands/view.js';
+import { loadConfig } from './config/config.js';
+import { RefError } from './config/history.js';
+import { ApiError, CliError, UsageError } from './core/errors.js';
+import { configureOutput, errorLine, isJsonMode } from './core/output.js';
+import { setLocale, t } from './i18n.js';
+import { EXIT } from './knowledge/error-catalog.js';
+import { cliVersion } from './version.js';
+export function buildProgram() {
+    const program = new Command();
+    program
+        .name('tripo')
+        .description(t({
+        zh: 'Tripo 3D 智能 CLI — 一句话/一张图,直出可进引擎的 3D 资产\n高频: make(生成) ai(专家规划) view(预览) topup(充值)',
+        en: 'Tripo 3D intelligent CLI — turn a sentence or an image into engine-ready 3D assets\ntop commands: make · ai · view · topup',
+    }))
+        .version(cliVersion(), '-v, --version')
+        .option('--json', 'machine-readable output on stdout (auto-enabled when piped)')
+        .option('--yes', 'skip confirmations (auto-enabled when headless)')
+        .option('--quiet', 'suppress progress logs on stderr')
+        .option('--no-open', 'never auto-open the browser/viewer')
+        .enablePositionalOptions()
+        .showSuggestionAfterError(true);
+    program.hook('preAction', (_thisCommand, actionCommand) => {
+        configureOutput({
+            json: resolveGlobalFlag(actionCommand, 'json', false),
+            yes: resolveGlobalFlag(actionCommand, 'yes', false),
+            quiet: resolveGlobalFlag(actionCommand, 'quiet', false),
+            noOpen: !resolveGlobalFlag(actionCommand, 'open', true),
+        });
+        const lang = loadConfig().language;
+        if (lang)
+            setLocale(lang);
+    });
+    registerMakeCommand(program);
+    registerAiCommand(program);
+    registerViewCommands(program);
+    registerAuthCommands(program);
+    registerTopupCommand(program);
+    registerAccountCommands(program);
+    registerGenerateCommands(program);
+    registerProcessCommands(program);
+    registerTaskCommands(program);
+    registerBatchCommand(program);
+    registerConfigCommands(program);
+    registerDoctorCommand(program);
+    registerDocsCommand(program);
+    registerCompletionCommand(program);
+    registerMcpCommand(program);
+    registerHomeAction(program);
+    attachGlobalFlags(program);
+    return program;
+}
+/**
+ * The 4 global flags live on every leaf command so `tripo balance --json`
+ * works the way people type it (prefix `tripo --json balance` works too).
+ */
+function attachGlobalFlags(cmd) {
+    for (const sub of cmd.commands)
+        attachGlobalFlags(sub);
+    if (cmd.commands.length > 0)
+        return;
+    const has = (long) => cmd.options.some((o) => o.long === long);
+    if (!has('--json'))
+        cmd.option('--json', 'machine-readable output on stdout');
+    if (!has('--yes'))
+        cmd.option('--yes', 'skip confirmations');
+    if (!has('--quiet'))
+        cmd.option('--quiet', 'suppress progress logs on stderr');
+    if (!has('--no-open'))
+        cmd.option('--no-open', 'never auto-open the browser/viewer');
+}
+/**
+ * Resolve a flag along the command chain, innermost explicit value first.
+ * (optsWithGlobals can't do this: a leaf's *default* would shadow an explicit
+ * `tripo --no-open <cmd>` on the root.)
+ */
+function resolveGlobalFlag(cmd, key, def) {
+    for (let c = cmd; c; c = c.parent) {
+        const source = c.getOptionValueSource(key);
+        if (source !== undefined && source !== 'default')
+            return Boolean(c.getOptionValue(key));
+    }
+    return def;
+}
+/** Run the CLI; converts errors into the stable exit-code contract. */
+export async function runCli(argv) {
+    const program = buildProgram();
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export function handleError(err) {
+    // History reference misses (@last with empty history etc.) are usage errors.
+    if (err instanceof RefError)
+        err = new UsageError(err.message);
+    if (err instanceof CliError) {
+        if (isJsonMode()) {
+            process.stdout.write(JSON.stringify({
+                error: err.message,
+                exit_code: err.exitCode,
+                ...(err instanceof ApiError
+                    ? { api_code: err.apiCode, request_id: err.requestId, http_status: err.httpStatus }
+                    : {}),
+                ...(err.suggestion ? { suggestion: err.suggestion } : {}),
+            }) + '\n');
+        }
+        errorLine(err.message);
+        if (err.suggestion)
+            process.stderr.write(pc.dim(`  → ${err.suggestion}\n`));
+        if (err instanceof ApiError && err.requestId) {
+            process.stderr.write(pc.dim(`  request_id: ${err.requestId}\n`));
+        }
+        process.exit(err.exitCode);
+    }
+    // commander already printed its own message for help/version pseudo-errors
+    if (typeof err === 'object' && err !== null && 'code' in err) {
+        const code = err.code ?? '';
+        if (code.startsWith('commander.')) {
+            process.exit(code === 'commander.help' || code === 'commander.version' || code === 'commander.helpDisplayed' ? 0 : EXIT.USAGE);
+        }
+    }
+    const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+    errorLine(message);
+    process.exit(EXIT.FATAL);
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+/** Shared wire types for the Tripo V3 API. */
+export {};

package/dist/src/util/input-detect.js

@@ -0,0 +1,92 @@
+/**
+ * Input classification for `tripo make` and friends: figure out what the user
+ * gave us (text prompt / image / model file / URL / task id / history ref)
+ * without asking them to know the difference.
+ */
+import { existsSync, statSync } from 'node:fs';
+import { extname } from 'node:path';
+export const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.bmp']);
+export const MODEL_EXTS = new Set(['.glb', '.gltf', '.fbx', '.obj', '.stl']);
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TASK_RE = /^task_[A-Za-z0-9_-]+$/;
+const FILE_TOKEN_RE = /^file_[A-Za-z0-9_-]+$/;
+export function detectInput(raw) {
+    const value = raw.trim();
+    if (value.startsWith('@'))
+        return { kind: 'history-ref', value };
+    if (FILE_TOKEN_RE.test(value))
+        return { kind: 'file-token', value };
+    if (TASK_RE.test(value) || UUID_RE.test(value))
+        return { kind: 'task-id', value };
+    if (/^https?:\/\//i.test(value))
+        return { kind: 'url', value };
+    if (isExistingFile(value)) {
+        const ext = extname(value).toLowerCase();
+        if (IMAGE_EXTS.has(ext))
+            return { kind: 'image-file', value };
+        if (MODEL_EXTS.has(ext))
+            return { kind: 'model-file', value };
+        // A real file with an unknown extension is still most likely an asset;
+        // treat by extension guess, otherwise reject early with a clear message.
+        throw new InputDetectError(`"${value}" exists but has an unsupported extension "${ext}" (images: ${[...IMAGE_EXTS].join(' ')}; models: ${[...MODEL_EXTS].join(' ')})`);
+    }
+    // Looks like a path but doesn't exist → almost certainly a typo, not a prompt.
+    if (looksLikePath(value)) {
+        throw new InputDetectError(`file not found: "${value}" (if you meant a text prompt, quote a sentence instead)`);
+    }
+    return { kind: 'text', value };
+}
+export function classifyInputs(args) {
+    if (args.length === 0)
+        throw new InputDetectError('no input given');
+    const detected = args.map(detectInput);
+    const kinds = new Set(detected.map((d) => d.kind));
+    if (kinds.size === 1) {
+        const kind = detected[0].kind;
+        switch (kind) {
+            case 'text':
+                // Multiple bare words are one prompt, joined.
+                return { kind: 'text', values: [{ kind: 'text', value: args.join(' ') }] };
+            case 'image-file':
+                return detected.length === 1
+                    ? { kind: 'image', values: detected }
+                    : { kind: 'multiview', values: detected };
+            case 'model-file':
+                if (detected.length > 1)
+                    throw new InputDetectError('only one model file at a time');
+                return { kind: 'model', values: detected };
+            case 'url':
+                if (detected.length > 1)
+                    return { kind: 'multiview', values: detected };
+                return { kind: 'url-image', values: detected };
+            case 'task-id':
+            case 'history-ref':
+            case 'file-token':
+                if (detected.length > 1)
+                    throw new InputDetectError('only one task reference at a time');
+                return { kind: 'task', values: detected };
+        }
+    }
+    // Mixed images + urls → multiview; anything else mixed is ambiguous.
+    if ([...kinds].every((k) => k === 'image-file' || k === 'url')) {
+        return { kind: 'multiview', values: detected };
+    }
+    throw new InputDetectError(`mixed input types (${[...kinds].join(' + ')}) — pass one kind of input per command`);
+}
+export class InputDetectError extends Error {
+}
+function isExistingFile(p) {
+    try {
+        return existsSync(p) && statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikePath(value) {
+    if (/\s/.test(value))
+        return false;
+    const ext = extname(value).toLowerCase();
+    return ((value.includes('/') || value.includes('\\') || IMAGE_EXTS.has(ext) || MODEL_EXTS.has(ext)) &&
+        !value.includes(' '));
+}

package/dist/src/util/notify.js

@@ -0,0 +1,17 @@
+/** Desktop notification + terminal bell for long-running task completion. */
+import { spawn } from 'node:child_process';
+export function notifyDone(title, message) {
+    try {
+        if (process.platform === 'darwin') {
+            const script = `display notification ${JSON.stringify(message)} with title ${JSON.stringify(title)}`;
+            spawn('osascript', ['-e', script], { stdio: 'ignore', detached: true }).on('error', () => { }); // best-effort
+        }
+        else if (process.platform === 'linux') {
+            spawn('notify-send', [title, message], { stdio: 'ignore', detached: true }).on('error', () => { });
+        }
+    }
+    catch { }
+    // Terminal bell as the lowest common denominator.
+    if (process.stderr.isTTY)
+        process.stderr.write('\x07');
+}

package/dist/src/util/open.js

@@ -0,0 +1,18 @@
+/** Cross-platform "open in default app/browser" without extra dependencies. */
+import { spawn } from 'node:child_process';
+export function openExternal(target) {
+    try {
+        const [cmd, args] = process.platform === 'darwin'
+            ? ['open', [target]]
+            : process.platform === 'win32'
+                ? ['cmd', ['/c', 'start', '', target]]
+                : ['xdg-open', [target]];
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/util/spinner.js

@@ -0,0 +1,62 @@
+/**
+ * Minimal stderr spinner. Interactive TTY gets an animated line; headless
+ * environments get sparse plain-text progress lines (never control codes).
+ */
+import pc from 'picocolors';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function createSpinner(initialText, quiet = false) {
+    const isTTY = Boolean(process.stderr.isTTY);
+    let text = initialText;
+    let frame = 0;
+    let timer;
+    let lastPlainLog = 0;
+    const render = () => {
+        process.stderr.write(`\r\x1b[2K${pc.cyan(FRAMES[frame % FRAMES.length])} ${text}`);
+        frame++;
+    };
+    const clearLine = () => {
+        if (isTTY)
+            process.stderr.write('\r\x1b[2K');
+    };
+    if (!quiet && isTTY) {
+        render();
+        timer = setInterval(render, 100);
+        timer.unref?.();
+    }
+    else if (!quiet) {
+        process.stderr.write(`${initialText}\n`);
+        lastPlainLog = Date.now();
+    }
+    return {
+        update(next) {
+            text = next;
+            if (quiet)
+                return;
+            if (!isTTY) {
+                // Throttle non-TTY progress to one line per 5s to keep logs readable.
+                if (Date.now() - lastPlainLog > 5000) {
+                    process.stderr.write(`${next}\n`);
+                    lastPlainLog = Date.now();
+                }
+            }
+        },
+        succeed(finalText) {
+            if (timer)
+                clearInterval(timer);
+            clearLine();
+            if (!quiet)
+                process.stderr.write(`${pc.green('✓')} ${finalText}\n`);
+        },
+        fail(finalText) {
+            if (timer)
+                clearInterval(timer);
+            clearLine();
+            process.stderr.write(`${pc.red('✗')} ${finalText}\n`);
+        },
+        stop() {
+            if (timer)
+                clearInterval(timer);
+            clearLine();
+        },
+    };
+}

package/dist/src/util/term-image.js

@@ -0,0 +1,28 @@
+/**
+ * Inline image display for capable terminals (iTerm2 OSC 1337; Kitty graphics
+ * protocol consumers also honor the iTerm sequence via icat shims). Falls back
+ * to returning false so callers can open the system viewer instead.
+ */
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+export function terminalSupportsInlineImages() {
+    if (!process.stdout.isTTY)
+        return false;
+    const program = process.env.TERM_PROGRAM ?? '';
+    const term = process.env.TERM ?? '';
+    return program === 'iTerm.app' || program === 'WezTerm' || term.includes('kitty');
+}
+export function printInlineImage(filePath, stream = process.stderr) {
+    if (!terminalSupportsInlineImages())
+        return false;
+    try {
+        const data = readFileSync(filePath);
+        const b64 = data.toString('base64');
+        const name = Buffer.from(basename(filePath)).toString('base64');
+        stream.write(`\x1b]1337;File=name=${name};size=${data.length};inline=1;width=40%:${b64}\x07\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/version.js

@@ -0,0 +1,10 @@
+import { readFileSync } from 'node:fs';
+export function cliVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+/** Shared wire types for the Tripo V3 API. */
+export {};

package/dist/util/input-detect.js

@@ -0,0 +1,93 @@
+/**
+ * Input classification for `tripo make` and friends: figure out what the user
+ * gave us (text prompt / image / model file / URL / task id / history ref)
+ * without asking them to know the difference.
+ */
+import { existsSync, statSync } from 'node:fs';
+import { extname } from 'node:path';
+// Server multipart whitelist: images webp/png/jpeg/bmp/tiff (+jpg), meshes glb/obj/fbx/stl/3mf/usdz.
+export const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.bmp', '.tiff', '.tif']);
+export const MODEL_EXTS = new Set(['.glb', '.gltf', '.fbx', '.obj', '.stl']);
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TASK_RE = /^task_[A-Za-z0-9_-]+$/;
+const FILE_TOKEN_RE = /^file_[A-Za-z0-9_-]+$/;
+export function detectInput(raw) {
+    const value = raw.trim();
+    if (value.startsWith('@'))
+        return { kind: 'history-ref', value };
+    if (FILE_TOKEN_RE.test(value))
+        return { kind: 'file-token', value };
+    if (TASK_RE.test(value) || UUID_RE.test(value))
+        return { kind: 'task-id', value };
+    if (/^https?:\/\//i.test(value))
+        return { kind: 'url', value };
+    if (isExistingFile(value)) {
+        const ext = extname(value).toLowerCase();
+        if (IMAGE_EXTS.has(ext))
+            return { kind: 'image-file', value };
+        if (MODEL_EXTS.has(ext))
+            return { kind: 'model-file', value };
+        // A real file with an unknown extension is still most likely an asset;
+        // treat by extension guess, otherwise reject early with a clear message.
+        throw new InputDetectError(`"${value}" exists but has an unsupported extension "${ext}" (images: ${[...IMAGE_EXTS].join(' ')}; models: ${[...MODEL_EXTS].join(' ')})`);
+    }
+    // Looks like a path but doesn't exist → almost certainly a typo, not a prompt.
+    if (looksLikePath(value)) {
+        throw new InputDetectError(`file not found: "${value}" (if you meant a text prompt, quote a sentence instead)`);
+    }
+    return { kind: 'text', value };
+}
+export function classifyInputs(args) {
+    if (args.length === 0)
+        throw new InputDetectError('no input given');
+    const detected = args.map(detectInput);
+    const kinds = new Set(detected.map((d) => d.kind));
+    if (kinds.size === 1) {
+        const kind = detected[0].kind;
+        switch (kind) {
+            case 'text':
+                // Multiple bare words are one prompt, joined.
+                return { kind: 'text', values: [{ kind: 'text', value: args.join(' ') }] };
+            case 'image-file':
+                return detected.length === 1
+                    ? { kind: 'image', values: detected }
+                    : { kind: 'multiview', values: detected };
+            case 'model-file':
+                if (detected.length > 1)
+                    throw new InputDetectError('only one model file at a time');
+                return { kind: 'model', values: detected };
+            case 'url':
+                if (detected.length > 1)
+                    return { kind: 'multiview', values: detected };
+                return { kind: 'url-image', values: detected };
+            case 'task-id':
+            case 'history-ref':
+            case 'file-token':
+                if (detected.length > 1)
+                    throw new InputDetectError('only one task reference at a time');
+                return { kind: 'task', values: detected };
+        }
+    }
+    // Mixed images + urls → multiview; anything else mixed is ambiguous.
+    if ([...kinds].every((k) => k === 'image-file' || k === 'url')) {
+        return { kind: 'multiview', values: detected };
+    }
+    throw new InputDetectError(`mixed input types (${[...kinds].join(' + ')}) — pass one kind of input per command`);
+}
+export class InputDetectError extends Error {
+}
+function isExistingFile(p) {
+    try {
+        return existsSync(p) && statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikePath(value) {
+    if (/\s/.test(value))
+        return false;
+    const ext = extname(value).toLowerCase();
+    return ((value.includes('/') || value.includes('\\') || IMAGE_EXTS.has(ext) || MODEL_EXTS.has(ext)) &&
+        !value.includes(' '));
+}

package/dist/util/notify.js

@@ -0,0 +1,17 @@
+/** Desktop notification + terminal bell for long-running task completion. */
+import { spawn } from 'node:child_process';
+export function notifyDone(title, message) {
+    try {
+        if (process.platform === 'darwin') {
+            const script = `display notification ${JSON.stringify(message)} with title ${JSON.stringify(title)}`;
+            spawn('osascript', ['-e', script], { stdio: 'ignore', detached: true }).on('error', () => { }); // best-effort
+        }
+        else if (process.platform === 'linux') {
+            spawn('notify-send', [title, message], { stdio: 'ignore', detached: true }).on('error', () => { });
+        }
+    }
+    catch { }
+    // Terminal bell as the lowest common denominator.
+    if (process.stderr.isTTY)
+        process.stderr.write('\x07');
+}

package/dist/util/open.js

@@ -0,0 +1,18 @@
+/** Cross-platform "open in default app/browser" without extra dependencies. */
+import { spawn } from 'node:child_process';
+export function openExternal(target) {
+    try {
+        const [cmd, args] = process.platform === 'darwin'
+            ? ['open', [target]]
+            : process.platform === 'win32'
+                ? ['cmd', ['/c', 'start', '', target]]
+                : ['xdg-open', [target]];
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}