videobook 0.0.0-stage → 0.2.0

package/dist/tools/post.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { schedulePost } from "../scheduled-posts.js";
+import { X_PREMIUM_POST_MAX_CHARACTERS } from "../x/account.js";
+const SCHEDULE_LEAD_MS = 5_000;
+function postToolResultMessage(result) {
+    const posted = result.status === "partially_posted"
+        ? `Root post published, but follow-up ${result.followup_error?.reply_number ?? ""} failed: ${result.followup_error?.message ?? "unknown error"}`
+        : `Posted to X${result.replies.length > 0 ? ` with ${result.replies.length} follow-up replies` : ""}`;
+    if (result.cell_address) {
+        return result.status === "partially_posted"
+            ? `Root post published as ${result.cell_address}, but follow-up ${result.followup_error?.reply_number ?? ""} failed: ${result.followup_error?.message ?? "unknown error"}`
+            : `${posted} as ${result.cell_address}`;
+    }
+    if (result.cell_error) {
+        return `${posted}; notebook cell could not be created: ${result.cell_error}`;
+    }
+    return posted;
+}
+export function postToolResultPayload(result, platform) {
+    return {
+        status: result.status,
+        platform,
+        tweet_id: result.tweet_id,
+        tweet_url: result.tweet_url,
+        replies: result.replies,
+        followup_error: result.followup_error,
+        ...(result.cell_id ? { cell_id: result.cell_id } : {}),
+        ...(result.cell_address ? { cell_address: result.cell_address } : {}),
+        message: postToolResultMessage(result),
+    };
+}
+const followupSchema = z.object({
+    text: z.string().max(X_PREMIUM_POST_MAX_CHARACTERS).optional(),
+    image_asset_ids: z.array(z.string()).max(4).optional(),
+}).refine((value) => Boolean(value.text?.length || value.image_asset_ids?.length), { message: "A follow-up needs text or at least one image" });
+export function postDef() {
+    return {
+        name: "post",
+        description: "Publish a video or image asset to a social platform. Currently supports X (Twitter); Instagram is planned. Scheduled posts persist across server restarts.",
+        schema: {
+            post_cell_id: z.string().uuid().optional().describe("Existing Post cell to publish; uses its frozen media and caption"),
+            asset_id: z.string().optional().describe("Asset to post (e.g. vid-clip-name, img-photo-name)"),
+            book_id: z.string().describe("Book id containing the asset"),
+            platform: z.enum(["x"]).default("x").describe("Target platform; defaults to 'x'"),
+            text: z
+                .string()
+                .trim()
+                .max(X_PREMIUM_POST_MAX_CHARACTERS)
+                .optional()
+                .describe("Title of the root post (X limit 280 chars, or 25000 when the connected account has X Premium; service_status with service x reports post_max_characters). Publishing requires one; pass it only when the user supplied it, since the confirm sheet asks for a missing title before applying."),
+            orientation: z
+                .enum(["portrait", "landscape"])
+                .optional()
+                .describe("Force a target video orientation. Pads with black bars to 1080x1920 (portrait) or 1920x1080 (landscape) before upload. Skipped when source already matches."),
+            scheduled_for: z
+                .string()
+                .datetime()
+                .optional()
+                .describe("ISO 8601 timestamp to publish at. Omit to post immediately."),
+            followups: z
+                .array(followupSchema)
+                .max(25)
+                .optional()
+                .describe("Ordered replies to publish as a thread after the root post."),
+        },
+        handler: async (args) => {
+            const { asset_id, post_cell_id, book_id, platform = "x", text, orientation, scheduled_for, followups, } = args;
+            if (platform !== "x") {
+                return {
+                    isError: true,
+                    content: [
+                        { type: "text", text: `Unsupported platform: ${platform}` },
+                    ],
+                };
+            }
+            if (!text?.trim() && !post_cell_id) {
+                return {
+                    isError: true,
+                    content: [
+                        { type: "text", text: "A post title is required" },
+                    ],
+                };
+            }
+            let prepared;
+            try {
+                prepared = await queue.enqueueAndWait(`post-prepare-${post_cell_id ?? asset_id}-${Date.now()}`, { type: "post_prepare_x", bookId: book_id, assetId: asset_id, postCellId: post_cell_id, text, orientation, followups });
+            }
+            catch (error) {
+                return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] };
+            }
+            const frozenAssetId = prepared.definition.source.snapshotArtifactId;
+            if (scheduled_for) {
+                const when = new Date(scheduled_for).getTime();
+                if (Number.isNaN(when)) {
+                    return {
+                        isError: true,
+                        content: [
+                            { type: "text", text: `Invalid scheduled_for: ${scheduled_for}` },
+                        ],
+                    };
+                }
+                if (when - Date.now() > SCHEDULE_LEAD_MS) {
+                    try {
+                        const result = await schedulePost({ asset_id: frozenAssetId, book_id, platform, text, post_cell_id: prepared.id }, scheduled_for);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        status: "scheduled",
+                                        schedule_id: result.schedule_id,
+                                        scheduled_for: result.scheduled_for,
+                                        platform,
+                                        cell_id: prepared.id,
+                                        cell_address: prepared.address,
+                                    }),
+                                },
+                            ],
+                        };
+                    }
+                    catch (err) {
+                        return {
+                            isError: true,
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Failed to schedule post: ${err instanceof Error ? err.message : String(err)}`,
+                                },
+                            ],
+                        };
+                    }
+                }
+            }
+            const jobId = `post-x-${prepared.id}`;
+            try {
+                const result = await queue.enqueueAndWait(jobId, {
+                    type: "post_to_x",
+                    assetId: frozenAssetId,
+                    postCellId: prepared.id,
+                    bookId: book_id,
+                    text,
+                    orientation,
+                    followups,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(postToolResultPayload(result, platform)),
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: `Post failed: ${err instanceof Error ? err.message : String(err)}`,
+                        },
+                    ],
+                };
+            }
+        },
+    };
+}

package/dist/tools/prompt-history.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import { PROMPT_SURFACES, isPromptSurface } from "../prompt-surfaces.js";
+import { listBookEngines } from "../queue.js";
+const SURFACE_LIST = PROMPT_SURFACES.join(", ");
+const MAX_HISTORY_PAGE_SIZE = 1000;
+function invalidSurface(value) {
+    return {
+        isError: true,
+        content: [
+            {
+                type: "text",
+                text: `Invalid surface "${String(value)}". Expected one of: ${SURFACE_LIST}`,
+            },
+        ],
+    };
+}
+export function recordPromptDef(engine) {
+    return {
+        name: "record_prompt",
+        description: "Append a user-typed prompt to the per-surface, per-project Dolt history. " +
+            "Surfaces: " +
+            SURFACE_LIST +
+            ".",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            surface: z
+                .string()
+                .describe(`Which input surface generated this prompt (${SURFACE_LIST})`),
+            prompt: z.string().describe("The raw user-typed prompt to store"),
+            params: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe("Optional params blob captured alongside the prompt (model, variant, platform, ...)"),
+        },
+        handler: async (args) => {
+            const { surface, prompt, params } = args;
+            if (!isPromptSurface(surface))
+                return invalidSurface(surface);
+            if (!prompt.trim()) {
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify({ id: null }) },
+                    ],
+                };
+            }
+            const result = await engine.prompts.record({
+                surface,
+                prompt,
+                ...(params ? { context: params } : {}),
+            });
+            if (!result.ok)
+                return errorResult(result.error.message);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify({ id: result.value.id }) },
+                ],
+            };
+        },
+    };
+}
+function errorResult(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+function readBookPrompts(engine, surface, limit) {
+    const filter = surface ? { surface } : {};
+    const entries = engine.prompts.list({ ...filter, limit });
+    if (!entries.ok)
+        return entries.error.message;
+    const count = engine.prompts.count(filter);
+    if (!count.ok)
+        return count.error.message;
+    const book = engine.book.get().name;
+    return {
+        total: count.value,
+        entries: entries.value.map((entry) => ({
+            id: entry.id,
+            surface: entry.surface,
+            prompt: entry.prompt,
+            params: entry.context,
+            created_at: entry.createdAt,
+            book,
+        })),
+    };
+}
+function mergePromptPages(pages) {
+    return {
+        total: pages.reduce((sum, page) => sum + page.total, 0),
+        entries: pages
+            .flatMap((page) => page.entries)
+            .sort((left, right) => right.created_at - left.created_at),
+    };
+}
+async function scopeEngines(engine, scope) {
+    if (scope === "book")
+        return [engine];
+    const engines = await listBookEngines();
+    return engines.includes(engine) ? engines : [engine, ...engines];
+}
+export function listPromptHistoryDef(engine) {
+    return {
+        name: "list_prompt_history",
+        description: "List recent prompts newest-first, for one surface or every surface, in the current book or across the whole library.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            surface: z
+                .string()
+                .optional()
+                .describe(`Which input surface to read history for (${SURFACE_LIST}); omit for every surface`),
+            scope: z
+                .enum(["book", "library"])
+                .optional()
+                .describe("book (default) reads this book; library reads every book in the library"),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(MAX_HISTORY_PAGE_SIZE)
+                .optional()
+                .describe(`Max entries to return (default 100, capped at ${MAX_HISTORY_PAGE_SIZE})`),
+            offset: z
+                .number()
+                .int()
+                .nonnegative()
+                .optional()
+                .describe("Number of newer entries to skip"),
+        },
+        handler: async (args) => {
+            const { surface, scope, limit, offset } = args;
+            if (surface !== undefined && !isPromptSurface(surface)) {
+                return invalidSurface(surface);
+            }
+            const pageLimit = limit ?? 100;
+            const pageOffset = offset ?? 0;
+            const pages = [];
+            for (const bookEngine of await scopeEngines(engine, scope ?? "book")) {
+                const page = readBookPrompts(bookEngine, surface, pageOffset + pageLimit);
+                if (typeof page === "string")
+                    return errorResult(page);
+                pages.push(page);
+            }
+            const merged = mergePromptPages(pages);
+            const pageEntries = merged.entries.slice(pageOffset, pageOffset + pageLimit);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            entries: pageEntries,
+                            page: {
+                                offset: pageOffset,
+                                limit: pageLimit,
+                                total: merged.total,
+                                has_more: pageOffset + pageEntries.length < merged.total,
+                            },
+                        }),
+                    },
+                ],
+            };
+        },
+    };
+}

package/dist/tools/provider-key-status.js

@@ -0,0 +1,248 @@
+import { createElevenLabs, createKie, createOpenAi, createXai } from "../usage-providers.js";
+import { isPlaceholderApiKey } from "../api-key.js";
+import { getDefaultSecretStore, isSecretEnvKey, maskEnvValue, } from "../env-secrets.js";
+// Row order: live-checked providers first, then the rest grouped by provider.
+const KEY_REGISTRY = {
+    KIE_API_KEY: { provider: "kie", label: "Kie", live: "kie-credits" },
+    ELEVENLABS_API_KEY: { provider: "elevenlabs", label: "ElevenLabs", live: "elevenlabs-credits" },
+    OPENAI_API_KEY: { provider: "openai", label: "OpenAI", live: "openai-tokens" },
+    XAI_API_KEY: { provider: "xai", label: "xAI", live: "xai-tokens" },
+    X_CLIENT_ID: { provider: "x", label: "X OAuth" },
+    X_CLIENT_SECRET: { provider: "x", label: "X OAuth" },
+    DROPBOX_CLIENT_ID: { provider: "dropbox", label: "Dropbox OAuth" },
+    DROPBOX_CLIENT_SECRET: { provider: "dropbox", label: "Dropbox OAuth" },
+    KIMI_CODING_API_KEY: { provider: "kimicoding", label: "Kimi Coding" },
+    FAL_API_KEY: { provider: "fal", label: "FAL" },
+    DASHSCOPE_API_KEY: { provider: "dashscope", label: "DashScope" },
+    B2_ACCESS_KEY_ID: { provider: "b2", label: "Backblaze B2" },
+    B2_SECRET_ACCESS_KEY: { provider: "b2", label: "Backblaze B2" },
+    B2_REGION: { provider: "b2", label: "Backblaze B2" },
+    B2_BUCKET: { provider: "b2", label: "Backblaze B2" },
+    B2_ENDPOINT: { provider: "b2", label: "Backblaze B2" },
+    B2_ARCHIVE_PREFIX: { provider: "b2", label: "Backblaze B2" },
+};
+const ROW_ORDER = [
+    "KIE_API_KEY",
+    "ELEVENLABS_API_KEY",
+    "OPENAI_API_KEY",
+    "XAI_API_KEY",
+    "X_CLIENT_ID",
+    "X_CLIENT_SECRET",
+    "DROPBOX_CLIENT_ID",
+    "DROPBOX_CLIENT_SECRET",
+    "KIMI_CODING_API_KEY",
+    "FAL_API_KEY",
+    "DASHSCOPE_API_KEY",
+    "B2_ACCESS_KEY_ID",
+    "B2_SECRET_ACCESS_KEY",
+    "B2_REGION",
+    "B2_BUCKET",
+    "B2_ENDPOINT",
+    "B2_ARCHIVE_PREFIX",
+];
+const TOKEN_LOOKUP_TEXT = "Videobook token lookup";
+const OPENAI_TOKEN_LOOKUP_MODEL = "gpt-5.4";
+const XAI_TOKEN_LOOKUP_MODEL = "grok-4.20-reasoning";
+function sanitizeMessage(error, apiKey) {
+    const message = error instanceof Error ? error.message : String(error);
+    return apiKey ? message.replaceAll(apiKey, "[redacted]") : message;
+}
+async function readKieCredits(apiKey) {
+    const provider = createKie({ apiKey, timeout: 30_000 });
+    const response = await provider.get.api.v1.chat.credit();
+    if (response.code !== 200) {
+        throw new Error(`Kie credit endpoint returned ${response.code}: ${response.msg}`);
+    }
+    if (typeof response.data !== "number") {
+        throw new Error("Kie credit endpoint did not return a numeric balance");
+    }
+    return response.data;
+}
+function formatInteger(value) {
+    return Math.round(value).toLocaleString("en-US");
+}
+function formatElevenLabsSubscriptionMessage(subscription) {
+    const remaining = formatInteger(subscription.remaining_character_count);
+    const limit = formatInteger(subscription.character_limit);
+    const used = formatInteger(subscription.character_count);
+    return `${subscription.tier} plan: ${remaining} of ${limit} characters remaining (${used} used)`;
+}
+async function readElevenLabsCredits(apiKey) {
+    const provider = createElevenLabs({ apiKey, timeout: 30_000 });
+    const subscription = await provider.v1.user.subscription();
+    if (!Number.isFinite(subscription.remaining_character_count)) {
+        throw new Error("ElevenLabs subscription endpoint did not return a numeric remaining character count");
+    }
+    return {
+        value: subscription.remaining_character_count,
+        message: formatElevenLabsSubscriptionMessage(subscription),
+    };
+}
+async function readOpenAiTokens(apiKey) {
+    const provider = createOpenAi({ apiKey, timeout: 30_000 });
+    const response = await provider.post.v1.responses.inputTokens({
+        model: OPENAI_TOKEN_LOOKUP_MODEL,
+        input: TOKEN_LOOKUP_TEXT,
+    });
+    return {
+        value: response.input_tokens,
+        model: OPENAI_TOKEN_LOOKUP_MODEL,
+    };
+}
+async function readXaiTokens(apiKey) {
+    const provider = createXai({ apiKey, timeout: 30_000 });
+    const response = await provider.post.v1.tokenizeText({
+        model: XAI_TOKEN_LOOKUP_MODEL,
+        text: TOKEN_LOOKUP_TEXT,
+    });
+    return {
+        value: response.token_ids.length,
+        model: XAI_TOKEN_LOOKUP_MODEL,
+    };
+}
+function creditsInfo(status, message) {
+    return { status, value: null, unit: "credits", fetchedAt: null, message };
+}
+function tokenLookupInfo(status, message) {
+    return { status, value: null, unit: "tokens", model: null, fetchedAt: null, message };
+}
+function unavailableCredits(message) {
+    return creditsInfo("unavailable", message);
+}
+function unavailableTokenLookup(message) {
+    return tokenLookupInfo("unavailable", message);
+}
+const NO_CREDITS_MESSAGE = "Credit balance is not available for this provider";
+const NO_TOKEN_LOOKUP_MESSAGE = "Token lookup is not available for this provider";
+function buildKeyBase(envKey, store) {
+    const entry = KEY_REGISTRY[envKey];
+    const source = store.getSource(envKey);
+    const secret = isSecretEnvKey(envKey);
+    const raw = store.getValue(envKey);
+    const value = !raw || raw.startsWith("op://") ? null : raw;
+    let keyStatus = "configured";
+    if (value === null)
+        keyStatus = "missing";
+    else if (isPlaceholderApiKey(value))
+        keyStatus = "placeholder";
+    const maskedKey = keyStatus !== "configured" || value === null
+        ? null
+        : secret
+            ? maskEnvValue(value)
+            : value;
+    return {
+        base: {
+            envKey,
+            provider: entry.provider,
+            label: entry.label,
+            keyStatus,
+            maskedKey,
+            secret,
+            source,
+            editable: source !== "1password",
+        },
+        value: keyStatus === "configured" ? value : null,
+    };
+}
+function statusOnlyInfo(base) {
+    if (base.keyStatus === "missing") {
+        const message = `${base.envKey} environment variable is not set`;
+        return { ...base, credits: creditsInfo("missing_key", message), tokenLookup: tokenLookupInfo("missing_key", message) };
+    }
+    if (base.keyStatus === "placeholder") {
+        const message = `${base.envKey} is a placeholder; refusing to call the real API`;
+        return { ...base, credits: creditsInfo("placeholder_key", message), tokenLookup: tokenLookupInfo("placeholder_key", message) };
+    }
+    return {
+        ...base,
+        credits: unavailableCredits(NO_CREDITS_MESSAGE),
+        tokenLookup: unavailableTokenLookup(NO_TOKEN_LOOKUP_MESSAGE),
+    };
+}
+function normalizeCreditLookupResult(result) {
+    if (typeof result === "number") {
+        return { value: result, message: null };
+    }
+    return result;
+}
+async function creditLookupInfo(base, apiKey, readCredits) {
+    const tokenLookup = unavailableTokenLookup(NO_TOKEN_LOOKUP_MESSAGE);
+    try {
+        const result = normalizeCreditLookupResult(await readCredits(apiKey));
+        return {
+            ...base,
+            credits: {
+                status: "ok",
+                value: result.value,
+                unit: "credits",
+                fetchedAt: new Date().toISOString(),
+                message: result.message,
+            },
+            tokenLookup,
+        };
+    }
+    catch (error) {
+        return {
+            ...base,
+            credits: creditsInfo("error", sanitizeMessage(error, apiKey)),
+            tokenLookup,
+        };
+    }
+}
+async function tokenLookupKeyInfo(base, apiKey, readTokens) {
+    const credits = unavailableCredits(NO_CREDITS_MESSAGE);
+    try {
+        const result = await readTokens(apiKey);
+        return {
+            ...base,
+            credits,
+            tokenLookup: {
+                status: "ok",
+                value: result.value,
+                unit: "tokens",
+                model: result.model,
+                fetchedAt: new Date().toISOString(),
+                message: null,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ...base,
+            credits,
+            tokenLookup: tokenLookupInfo("error", sanitizeMessage(error, apiKey)),
+        };
+    }
+}
+export async function getProviderKeyStatus(deps = {}) {
+    const store = deps.store ?? getDefaultSecretStore();
+    const creditReaders = {
+        "kie-credits": deps.readKieCredits ?? readKieCredits,
+        "elevenlabs-credits": deps.readElevenLabsCredits ?? readElevenLabsCredits,
+    };
+    const tokenReaders = {
+        "openai-tokens": deps.readOpenAiTokens ?? readOpenAiTokens,
+        "xai-tokens": deps.readXaiTokens ?? readXaiTokens,
+    };
+    const providers = await Promise.all(ROW_ORDER.map((envKey) => {
+        const { base, value } = buildKeyBase(envKey, store);
+        const live = KEY_REGISTRY[envKey].live;
+        if (!live || value === null)
+            return Promise.resolve(statusOnlyInfo(base));
+        if (live === "kie-credits" || live === "elevenlabs-credits") {
+            return creditLookupInfo(base, value, creditReaders[live]);
+        }
+        return tokenLookupKeyInfo(base, value, tokenReaders[live]);
+    }));
+    return { providers };
+}
+export function providerKeyStatusDef(deps = {}) {
+    return {
+        name: "provider_key_status",
+        description: "List all managed environment keys with their source (1password = injected via op run, read-only; env = from .env, editable), masked values, and live credit/token lookups for supported providers. Never exposes secret values.",
+        schema: {},
+        handler: async () => ({
+            content: [{ type: "text", text: JSON.stringify(await getProviderKeyStatus(deps)) }],
+        }),
+    };
+}