@vibeframe/cli 0.104.3 → 0.105.2

package/dist/tools/manifest/storyboard.d.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { type AnyTool } from "../define-tool.js";
+export declare const storyboardListTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectDir?: string | undefined;
+}, {
+    projectDir?: string | undefined;
+}>>;
+export declare const storyboardValidateTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectDir?: string | undefined;
+}, {
+    projectDir?: string | undefined;
+}>>;
+export declare const storyboardGetTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    beat: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    beat: string;
+    projectDir?: string | undefined;
+}, {
+    beat: string;
+    projectDir?: string | undefined;
+}>>;
+export declare const storyboardSetTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    beat: z.ZodString;
+    key: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    jsonValue: z.ZodOptional<z.ZodBoolean>;
+    unset: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    beat: string;
+    key: string;
+    projectDir?: string | undefined;
+    value?: string | undefined;
+    unset?: boolean | undefined;
+    jsonValue?: boolean | undefined;
+}, {
+    beat: string;
+    key: string;
+    projectDir?: string | undefined;
+    value?: string | undefined;
+    unset?: boolean | undefined;
+    jsonValue?: boolean | undefined;
+}>>;
+export declare const storyboardMoveTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    beat: z.ZodString;
+    after: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    after: string;
+    beat: string;
+    projectDir?: string | undefined;
+}, {
+    after: string;
+    beat: string;
+    projectDir?: string | undefined;
+}>>;
+export declare const storyboardReviseTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    request: z.ZodString;
+    durationSec: z.ZodOptional<z.ZodNumber>;
+    composer: z.ZodOptional<z.ZodEnum<["claude", "openai", "gemini"]>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    request: string;
+    dryRun?: boolean | undefined;
+    projectDir?: string | undefined;
+    durationSec?: number | undefined;
+    composer?: "claude" | "openai" | "gemini" | undefined;
+}, {
+    request: string;
+    dryRun?: boolean | undefined;
+    projectDir?: string | undefined;
+    durationSec?: number | undefined;
+    composer?: "claude" | "openai" | "gemini" | undefined;
+}>>;
+export declare const planTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectDir: z.ZodOptional<z.ZodString>;
+    stage: z.ZodOptional<z.ZodEnum<["assets", "compose", "sync", "render", "all"]>>;
+    beat: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["agent", "batch", "auto"]>>;
+    skipNarration: z.ZodOptional<z.ZodBoolean>;
+    skipBackdrop: z.ZodOptional<z.ZodBoolean>;
+    skipVideo: z.ZodOptional<z.ZodBoolean>;
+    skipMusic: z.ZodOptional<z.ZodBoolean>;
+    ttsProvider: z.ZodOptional<z.ZodEnum<["auto", "elevenlabs", "kokoro"]>>;
+    voice: z.ZodOptional<z.ZodString>;
+    imageProvider: z.ZodOptional<z.ZodString>;
+    imageQuality: z.ZodOptional<z.ZodEnum<["standard", "hd"]>>;
+    imageSize: z.ZodOptional<z.ZodString>;
+    videoProvider: z.ZodOptional<z.ZodEnum<["seedance", "grok", "kling", "runway", "veo"]>>;
+    musicProvider: z.ZodOptional<z.ZodEnum<["elevenlabs", "replicate"]>>;
+    composer: z.ZodOptional<z.ZodEnum<["claude", "openai", "gemini"]>>;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    voice?: string | undefined;
+    force?: boolean | undefined;
+    projectDir?: string | undefined;
+    beat?: string | undefined;
+    mode?: "auto" | "agent" | "batch" | undefined;
+    composer?: "claude" | "openai" | "gemini" | undefined;
+    stage?: "all" | "assets" | "compose" | "sync" | "render" | undefined;
+    skipNarration?: boolean | undefined;
+    skipBackdrop?: boolean | undefined;
+    imageProvider?: string | undefined;
+    skipVideo?: boolean | undefined;
+    skipMusic?: boolean | undefined;
+    ttsProvider?: "elevenlabs" | "auto" | "kokoro" | undefined;
+    videoProvider?: "grok" | "seedance" | "kling" | "runway" | "veo" | undefined;
+    musicProvider?: "elevenlabs" | "replicate" | undefined;
+    imageQuality?: "standard" | "hd" | undefined;
+    imageSize?: string | undefined;
+}, {
+    voice?: string | undefined;
+    force?: boolean | undefined;
+    projectDir?: string | undefined;
+    beat?: string | undefined;
+    mode?: "auto" | "agent" | "batch" | undefined;
+    composer?: "claude" | "openai" | "gemini" | undefined;
+    stage?: "all" | "assets" | "compose" | "sync" | "render" | undefined;
+    skipNarration?: boolean | undefined;
+    skipBackdrop?: boolean | undefined;
+    imageProvider?: string | undefined;
+    skipVideo?: boolean | undefined;
+    skipMusic?: boolean | undefined;
+    ttsProvider?: "elevenlabs" | "auto" | "kokoro" | undefined;
+    videoProvider?: "grok" | "seedance" | "kling" | "runway" | "veo" | undefined;
+    musicProvider?: "elevenlabs" | "replicate" | undefined;
+    imageQuality?: "standard" | "hd" | undefined;
+    imageSize?: string | undefined;
+}>>;
+export declare const storyboardTools: readonly AnyTool[];

package/dist/tools/manifest/timeline.d.ts

@@ -0,0 +1,173 @@
+/**
+ * @module manifest/timeline
+ * @description Timeline editing tools — wraps the engine's Project methods
+ * with auto load/save bookends.
+ */
+import { z } from "zod";
+import { type AnyTool } from "../define-tool.js";
+export declare const timelineCreateTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    name: z.ZodString;
+    outputPath: z.ZodOptional<z.ZodString>;
+    fps: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    outputPath?: string | undefined;
+    fps?: number | undefined;
+}, {
+    name: string;
+    outputPath?: string | undefined;
+    fps?: number | undefined;
+}>>;
+export declare const timelineInfoTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectPath: string;
+}, {
+    projectPath: string;
+}>>;
+export declare const timelineAddSourceTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    mediaPath: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    projectPath: string;
+    mediaPath: string;
+    name?: string | undefined;
+    duration?: number | undefined;
+}, {
+    projectPath: string;
+    mediaPath: string;
+    name?: string | undefined;
+    duration?: number | undefined;
+}>>;
+export declare const timelineAddClipTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    sourceId: z.ZodString;
+    trackId: z.ZodOptional<z.ZodString>;
+    startTime: z.ZodOptional<z.ZodNumber>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sourceId: string;
+    projectPath: string;
+    duration?: number | undefined;
+    trackId?: string | undefined;
+    startTime?: number | undefined;
+}, {
+    sourceId: string;
+    projectPath: string;
+    duration?: number | undefined;
+    trackId?: string | undefined;
+    startTime?: number | undefined;
+}>>;
+export declare const timelineSplitClipTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    clipId: z.ZodString;
+    splitTime: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    projectPath: string;
+    splitTime: number;
+}, {
+    clipId: string;
+    projectPath: string;
+    splitTime: number;
+}>>;
+export declare const timelineTrimClipTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    clipId: z.ZodString;
+    trimStart: z.ZodOptional<z.ZodNumber>;
+    trimEnd: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    projectPath: string;
+    trimEnd?: number | undefined;
+    trimStart?: number | undefined;
+}, {
+    clipId: string;
+    projectPath: string;
+    trimEnd?: number | undefined;
+    trimStart?: number | undefined;
+}>>;
+export declare const timelineMoveClipTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    clipId: z.ZodString;
+    newStartTime: z.ZodOptional<z.ZodNumber>;
+    newTrackId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    projectPath: string;
+    newStartTime?: number | undefined;
+    newTrackId?: string | undefined;
+}, {
+    clipId: string;
+    projectPath: string;
+    newStartTime?: number | undefined;
+    newTrackId?: string | undefined;
+}>>;
+export declare const timelineDeleteClipTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    clipId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    projectPath: string;
+}, {
+    clipId: string;
+    projectPath: string;
+}>>;
+export declare const timelineDuplicateClipTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    clipId: z.ZodString;
+    newStartTime: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    projectPath: string;
+    newStartTime?: number | undefined;
+}, {
+    clipId: string;
+    projectPath: string;
+    newStartTime?: number | undefined;
+}>>;
+export declare const timelineAddEffectTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    clipId: z.ZodString;
+    effectType: z.ZodString;
+    startTime: z.ZodOptional<z.ZodNumber>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    intensity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    effectType: string;
+    projectPath: string;
+    duration?: number | undefined;
+    startTime?: number | undefined;
+    intensity?: number | undefined;
+}, {
+    clipId: string;
+    effectType: string;
+    projectPath: string;
+    duration?: number | undefined;
+    startTime?: number | undefined;
+    intensity?: number | undefined;
+}>>;
+export declare const timelineAddTrackTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    trackType: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectPath: string;
+    trackType: string;
+    name?: string | undefined;
+}, {
+    projectPath: string;
+    trackType: string;
+    name?: string | undefined;
+}>>;
+export declare const timelineListTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectPath: string;
+}, {
+    projectPath: string;
+}>>;
+export declare const timelineTools: readonly AnyTool[];

package/dist/tools/manifest/walkthrough.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module manifest/walkthrough
+ * @description Universal guide primitive — host-agnostic equivalent of
+ * Claude Code's `/vibe-scene` and `/vibe-pipeline` slash commands.
+ *
+ * Any agent host (Claude Code, Codex, Cursor, Aider, Gemini CLI, OpenCode)
+ * can invoke `guide` to load the same step-by-step authoring guide
+ * the slash commands deliver. Source content is vendored as TS template
+ * literals (see `commands/_shared/walkthroughs/`) so the bundle has zero
+ * filesystem dependencies.
+ */
+import { z } from "zod";
+import { type AnyTool } from "../define-tool.js";
+import { type WalkthroughTopic } from "../../commands/_shared/walkthroughs/walkthroughs.js";
+export declare const guideTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    topic: z.ZodOptional<z.ZodEnum<[WalkthroughTopic, ...WalkthroughTopic[]]>>;
+}, "strip", z.ZodTypeAny, {
+    topic?: WalkthroughTopic | undefined;
+}, {
+    topic?: WalkthroughTopic | undefined;
+}>>;
+export declare const guideTools: readonly AnyTool[];

package/dist/tools/manifest.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Manifest invariants — fails CI on shape drift.
+ *
+ * Runs against the live manifest (no mocks). Each invariant catches a
+ * different class of regression:
+ *
+ * - Name uniqueness + snake_case form
+ * - Schema is a ZodObject (so adapters can derive properties/required)
+ * - MCP adapter round-trip: every entry tagged `mcp` produces a valid
+ *   inputSchema
+ * - Agent adapter round-trip: every entry tagged `agent` registers cleanly
+ */
+export {};

package/dist/tools/zod-to-json-schema.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @module zod-to-json-schema
+ * @description Vendored Zod → JSON Schema converter. Supports the subset of
+ * Zod the VibeFrame manifest uses (object, string, number, boolean, enum,
+ * optional, default, array, literal).
+ *
+ * Why vendored instead of npm `zod-to-json-schema`:
+ * - We don't need refs/$ref/nested defs. All manifest schemas are flat.
+ * - The MCP SDK's `inputSchema` field expects a specific JSON Schema subset
+ *   (`{ type: "object", properties, required }`); the npm package emits
+ *   $schema/dialect URLs that some MCP hosts mishandle.
+ * - The Agent's `parameters` field is structurally identical to MCP's
+ *   `inputSchema` (see `packages/cli/src/agent/types.ts`); one converter
+ *   serves both adapters.
+ * - 150 lines we can debug.
+ *
+ * Coverage gaps (intentional):
+ * - z.union, z.discriminatedUnion: not used by any current tool.
+ * - z.record, z.map, z.tuple, z.intersection: not used.
+ * - z.nullable: not used (we use .optional() everywhere).
+ * - z.transform/preprocess: pre-applied by Zod parse; output schema is the
+ *   "input" view, which is what MCP/Agent need.
+ *
+ * If a manifest entry needs an unsupported feature, this converter throws
+ * loudly so the gap is visible at registration time, not at runtime.
+ */
+import type { ZodTypeAny } from "zod";
+export interface JsonSchema {
+    type: "object" | "string" | "number" | "boolean" | "array";
+    description?: string;
+    enum?: readonly (string | number)[];
+    default?: unknown;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: JsonSchema | boolean;
+}
+/**
+ * Convert a ZodObject schema to a JSON Schema suitable for MCP `inputSchema`.
+ * Throws on unsupported Zod variants.
+ */
+export declare function zodToJsonSchema(schema: ZodTypeAny): JsonSchema;
+/**
+ * The Agent surface uses a `parameters` field that's structurally identical
+ * to MCP's `inputSchema`. This is just an alias to make adapter code clearer.
+ */
+export declare const zodToAgentParameters: typeof zodToJsonSchema;

package/dist/utils/agent-host-detect.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module utils/agent-host-detect
+ *
+ * Detect which agent hosts the user has installed so the v0.61 setup
+ * wizard (`vibe setup`) and project scaffolder (`vibe init`) can tailor
+ * what to write where.
+ *
+ * Detection is best-effort and *informational* — it never blocks setup,
+ * never shells out beyond `which`, and never reads the contents of the
+ * config dirs (just whether they exist).
+ *
+ * Two signals per host:
+ *   - **binary** — found via `which`/`PATH` lookup (fast, exact)
+ *   - **configDir** — known config directory exists in `$HOME` (catches
+ *     installs where the binary isn't on PATH for the current shell)
+ *
+ * A host is "detected" if either signal fires. The caller decides how to
+ * use that — typically `vibe setup` shows them in a summary, `vibe init`
+ * uses them to pick which agent files to scaffold.
+ */
+/** Agent hosts VibeFrame knows how to scaffold for. */
+export type AgentHostId = "claude-code" | "codex" | "cursor" | "aider" | "gemini-cli" | "opencode";
+export interface AgentHostInfo {
+    id: AgentHostId;
+    /** Human-friendly name for prompts and UI. */
+    label: string;
+    /** True when at least one signal fired. */
+    detected: boolean;
+    /** Signals that fired (empty array when `detected` is false). */
+    signals: AgentHostSignal[];
+    /**
+     * Files this host expects in a project. Used by `vibe init` to know
+     * what to scaffold; informational here.
+     */
+    projectFiles: string[];
+}
+export type AgentHostSignal = {
+    kind: "binary";
+    name: string;
+} | {
+    kind: "configDir";
+    path: string;
+};
+/**
+ * Scan the current environment for known agent hosts. Synchronous because
+ * every check is cheap (`existsSync` + `process.env.PATH` walk).
+ */
+export declare function detectAgentHosts(env?: NodeJS.ProcessEnv): AgentHostInfo[];
+/**
+ * Return only detected hosts, ordered by VibeFrame's recommendation:
+ * Claude Code first (we ship slash commands for it), then alphabetical.
+ */
+export declare function detectedAgentHosts(env?: NodeJS.ProcessEnv): AgentHostInfo[];
+/**
+ * One-line status summary suitable for spinners / setup wizards.
+ *
+ * Examples:
+ *   "Claude Code (binary + config), Codex (config)"
+ *   "(none — install Claude Code, Codex, or Cursor for agent integration)"
+ */
+export declare function summariseAgentHosts(hosts: AgentHostInfo[]): string;

package/dist/utils/agent-host-detect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/api-key.d.ts

@@ -0,0 +1,58 @@
+export declare function providerKeyForEnvVar(envVar: string): string | undefined;
+/**
+ * Load environment variables from .env files.
+ * Priority: CWD .env (project-scoped) > monorepo root .env (development)
+ * Later loads don't override earlier values, so CWD takes precedence.
+ */
+export declare function loadEnv(): void;
+/**
+ * Get API key from config, environment, or prompt
+ */
+export declare function getApiKey(envVar: string, providerName: string, optionValue?: string): Promise<string | null>;
+/**
+ * Resolve an API key without prompting.
+ *
+ * This is for library-style execution paths that should respect
+ * `vibe setup --scope project` but must not stop for interactive input
+ * when no key exists. Precedence matches `getApiKey()` up to the prompt:
+ * CLI override > nearest project/user config.yaml > .env/process env.
+ */
+export declare function getConfiguredApiKey(envVar: string, optionValue?: string, options?: {
+    cwd?: string;
+}): Promise<string | undefined>;
+/** True when a key exists in CLI override, config.yaml, .env, or env. */
+export declare function hasConfiguredApiKey(envVar: string, optionValue?: string, options?: {
+    cwd?: string;
+}): Promise<boolean>;
+export declare class ApiKeyError extends Error {
+    envVar: string;
+    providerName: string;
+    constructor(envVar: string, providerName: string);
+    toStructured(): {
+        success: false;
+        error: string;
+        code: string;
+        exitCode: number;
+        suggestion: string;
+        retryable: false;
+    };
+}
+/**
+ * Check if an API key is available without prompting or side effects.
+ *
+ * Sync env-only check — for the config-file fallback (set via `vibe setup`),
+ * use the async {@link getApiKey} instead. Two bugs in the previous
+ * implementation made this lie: (1) `getApiKeyFromConfig` is async and
+ * was called without `await`, so `!!Promise` always returned `true`,
+ * and (2) the function expects a provider key (`"elevenlabs"`) but was
+ * being passed the env-var name (`"ELEVENLABS_API_KEY"`). The result
+ * was that `vibe scene add --tts auto` always took the ElevenLabs path
+ * and crashed with "API key required" even though we were supposed to
+ * fall back to local Kokoro. Caught during pre-HN error-message audit.
+ */
+export declare function hasApiKey(envVar: string): boolean;
+/**
+ * Get API key or throw ApiKeyError if not found.
+ * Use this instead of getApiKey() + manual null check.
+ */
+export declare function requireApiKey(envVar: string, providerName: string, cliOverride?: string): Promise<string>;

package/dist/utils/api-key.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/audio.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get the duration of an audio file using ffprobe
+ * @param filePath - Path to the audio file
+ * @returns Duration in seconds
+ */
+export declare function getAudioDuration(filePath: string): Promise<number>;
+/**
+ * Get the duration of a video file using ffprobe
+ * @param filePath - Path to the video file
+ * @returns Duration in seconds
+ */
+export declare function getVideoDuration(filePath: string): Promise<number>;
+/**
+ * Extend a video naturally to match target duration using progressive techniques.
+ * Uses slowdown, frame interpolation, and freeze frames based on extension ratio.
+ *
+ * @param videoPath - Path to the source video
+ * @param targetDuration - Target duration in seconds
+ * @param outputPath - Path for the extended video output
+ * @returns Promise that resolves when extension is complete
+ */
+export declare function extendVideoNaturally(videoPath: string, targetDuration: number, outputPath: string): Promise<void>;

package/dist/utils/clipboard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Cross-platform clipboard writer. Pipes the text into the OS-native
+ * helper:
+ *   - macOS: `pbcopy`
+ *   - Linux/BSD: `xclip -selection clipboard` (X11) or `wl-copy` (Wayland)
+ *   - Windows: `clip`
+ *
+ * Returns whether the copy succeeded so callers can decide whether to
+ * surface a "✓ Copied to clipboard" hint. Failures are silent — copying
+ * is convenience, never the user's critical path.
+ */
+interface Copier {
+    command: string;
+    args: string[];
+}
+/**
+ * Pick the OS-appropriate copier command. Exported so unit tests can
+ * verify the args without invoking spawn.
+ */
+export declare function resolveCopier(): Copier | null;
+/**
+ * Write `text` to the system clipboard. Resolves to `true` if the
+ * helper exited cleanly, `false` otherwise (missing binary, write
+ * error, unsupported platform).
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+export {};

package/dist/utils/clipboard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/exec-safe.d.ts

@@ -0,0 +1,21 @@
+/** Safe async exec — no shell, args as array */
+export declare function execSafe(cmd: string, args: string[], options?: {
+    timeout?: number;
+    maxBuffer?: number;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/** Safe sync exec — no shell, args as array */
+export declare function execSafeSync(cmd: string, args: string[], options?: {
+    stdio?: "pipe" | "ignore";
+}): string;
+/** Shorthand: ffprobe duration query */
+export declare function ffprobeDuration(filePath: string): Promise<number>;
+/** Shorthand: ffprobe video dimensions */
+export declare function ffprobeVideoSize(filePath: string): Promise<{
+    width: number;
+    height: number;
+}>;
+/** Shorthand: check if a command exists */
+export declare function commandExists(cmd: string): boolean;

package/dist/utils/first-run.d.ts

@@ -0,0 +1,16 @@
+/**
+ * First-run detection for VibeFrame CLI
+ * Shows a welcome banner when user has never configured the tool
+ */
+/**
+ * Check if this is the user's first run (no config and no env vars set)
+ */
+export declare function isFirstRun(): Promise<boolean>;
+/**
+ * Mark that the first-run banner has been shown (won't show again)
+ */
+export declare function markBannerShown(): Promise<void>;
+/**
+ * Show a friendly welcome banner for first-time users
+ */
+export declare function showFirstRunBanner(): void;

package/dist/utils/input-validation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Input validation utilities for agent-safety (agentic CLI hardening).
+ *
+ * Defends against: path traversal, control character injection,
+ * and overly long inputs that agents may hallucinate.
+ */
+/**
+ * Reject strings containing control characters (below ASCII 0x20,
+ * excluding tab, newline, CR which are sometimes intentional).
+ */
+export declare function rejectControlChars(value: string, fieldName?: string): string;
+/**
+ * Validate that a file path does not escape the sandbox directory.
+ * Returns the resolved absolute path.
+ */
+export declare function validateSafePath(inputPath: string, sandbox?: string): string;
+/**
+ * Validate output path — must not traverse outside cwd unless absolute.
+ * Allows absolute paths (user-specified like /tmp/output.mp4).
+ */
+export declare function validateOutputPath(outputPath: string): string;
+/**
+ * Validate a user-provided string (prompt text, etc.) for sanity.
+ * Rejects control chars and caps length to prevent context abuse.
+ */
+export declare function validateTextInput(value: string, fieldName?: string, maxLength?: number): string;

package/dist/utils/key-format.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Soft-validation for API keys pasted into the setup wizard or imported from
+ * .env. Returns whether the value matches the registered prefix and, if not,
+ * the human-readable example so the wizard can show one ⚠ line and continue.
+ *
+ * "Soft" by design: providers occasionally rotate key formats, and a wrong
+ * pattern in our registry should never block a working key. Callers always
+ * persist the value regardless of `ok`.
+ */
+export interface KeyFormatResult {
+    ok: boolean;
+    /** Example string (e.g. "sk-ant-...") — present when `ok === false`. */
+    expected?: string;
+}
+export declare function validateKeyFormat(configKey: string, value: string): KeyFormatResult;