@tday-com/mcp 0.0.0-stage → 0.3.0

package/dist/installer.js

@@ -0,0 +1,150 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { startCallbackServer } from "./installer-callback.js";
+import { patchAllAgents, previewAllAgents } from "./installer-agents.js";
+import { installSlashCommands } from "./installer-slash-command.js";
+import { capturePublished } from "./package-info.js";
+const WEB_URL = (process.env.TDAY_WEB_URL ?? "https://tday.com").replace(/\/+$/, "");
+const API_URL = (process.env.TDAY_API_URL ?? WEB_URL).replace(/\/+$/, "").replace(/\/api$/i, "");
+const TIMEOUT_MS = 5 * 60 * 1000;
+export async function runInstaller(args) {
+    const skipBrowser = args.includes("--no-browser");
+    const dryRun = args.includes("--dry-run");
+    console.log("tday MCP installer\n");
+    if (dryRun) {
+        console.log("Dry run - no files will be written, no browser opened.\n");
+        const results = previewAllAgents({ capture: true });
+        for (const r of results) {
+            console.log(`  [${r.action}] ${r.name} - ${r.message}`);
+        }
+        return;
+    }
+    const state = randomBytes(16).toString("hex");
+    const clientName = detectClientLabel();
+    console.log("1. Starting local callback listener…");
+    const { port, done } = await startCallbackServer({
+        expectedState: state,
+        timeoutMs: TIMEOUT_MS,
+    });
+    const callbackUrl = `http://127.0.0.1:${port}/cb`;
+    const authUrl = `${WEB_URL}/cli/auth` +
+        `?callback=${encodeURIComponent(callbackUrl)}` +
+        `&state=${encodeURIComponent(state)}` +
+        `&client=${encodeURIComponent(clientName)}`;
+    console.log("2. Sign in to tday in your browser to authorize this MCP connection:\n");
+    console.log(`   ${authUrl}\n`);
+    if (!skipBrowser) {
+        openBrowser(authUrl);
+    }
+    console.log("3. Waiting for authorization (timeout 5 min)…\n");
+    let token;
+    try {
+        const result = await done;
+        token = result.token;
+    }
+    catch (err) {
+        console.error(`\nAuthorization failed: ${err.message}`);
+        process.exit(1);
+    }
+    console.log("4. Verifying account link…");
+    const ok = await verifyToken(token);
+    if (!ok) {
+        console.error(`Account link verification failed against ${API_URL}/api/billing/info. Nothing was saved.`);
+        process.exit(1);
+    }
+    saveConfig(token);
+    console.log(`   Saved secure local connection to ${configPath()} (chmod 0600)\n`);
+    const access = await accountAccess(token);
+    console.log("5. Patching installed AI agents (Claude Code, Cursor, Gemini CLI, Codex, VS Code)…");
+    const results = patchAllAgents({ capture: access.capture });
+    for (const r of results) {
+        const tag = r.action === "patched" ? "+" : r.action === "manual" ? "!" : "-";
+        console.log(`   ${tag} ${r.name}: ${r.message}`);
+    }
+    console.log("\n6. Installing Claude Code slash commands...");
+    const cmds = installSlashCommands(access);
+    for (const cmd of cmds.filter((c) => c.installed))
+        console.log(`   + ${cmd.path}`);
+    if (cmds.some((cmd) => !cmd.installed))
+        console.log("   - Skipped (Claude Code not found)");
+    const names = cmds.filter((cmd) => cmd.installed).map((cmd) => `/${cmd.name}`);
+    console.log(`\nDone. Restart your AI agent.${names.length ? ` In Claude Code, type / to see: ${names.join(", ")}` : ""}`);
+}
+async function accountAccess(token) {
+    const read = async (path) => {
+        try {
+            const res = await fetch(`${API_URL}${path}`, { headers: { authorization: `Bearer ${token}`, accept: "application/json" } });
+            if (!res.ok)
+                return null;
+            const body = (await res.json());
+            return typeof body === "object" && body !== null && !Array.isArray(body) ? body : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const [me, account, published] = await Promise.all([read("/api/capture/me"), read("/api/v1/account"), capturePublished()]);
+    const brands = published && Array.isArray(me?.brands) ? me.brands : [];
+    const features = account?.features;
+    return {
+        capture: brands.length > 0,
+        demos: brands.some((brand) => brand?.localDemos === true),
+        launchVideos: features?.launchVideos === true,
+    };
+}
+function configPath() {
+    return join(homedir(), ".tday", "config.json");
+}
+function saveConfig(token) {
+    const path = configPath();
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    writeFileSync(path, JSON.stringify({ token, apiBaseUrl: API_URL, webBaseUrl: WEB_URL }, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+    chmodSync(path, 0o600);
+}
+async function verifyToken(token) {
+    try {
+        const res = await fetch(`${API_URL}/api/billing/info`, {
+            headers: { authorization: `Bearer ${token}` },
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function detectClientLabel() {
+    if (process.env.TDAY_CLIENT_LABEL)
+        return process.env.TDAY_CLIENT_LABEL;
+    if (process.env.TERM_PROGRAM === "Claude Code")
+        return "claude-code";
+    if (process.env.CURSOR_TRACE_ID)
+        return "cursor";
+    return "tday-cli";
+}
+export function openBrowser(url) {
+    const platform = process.platform;
+    const warn = () => console.warn("Could not open the browser. Open the printed URL manually to continue.");
+    try {
+        let child;
+        if (platform === "darwin") {
+            child = spawn("open", [url], { detached: true, stdio: "ignore" });
+        }
+        else if (platform === "win32") {
+            child = spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+        }
+        else {
+            child = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+        }
+        child.once("error", warn);
+        child.unref();
+    }
+    catch {
+        warn();
+    }
+}

package/dist/package-info.js

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs";
+export const PACKAGE_NAME = "@tday-com/mcp";
+export function packageVersion() {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version;
+}
+export function pinnedPackageSpec() {
+    return `${PACKAGE_NAME}@${packageVersion()}`;
+}
+export const CAPTURE_PACKAGE_NAME = "@tday-com/capture";
+export const CAPTURE_PACKAGE_VERSION = "0.2.0";
+export function pinnedCaptureSpec() {
+    return `${CAPTURE_PACKAGE_NAME}@${CAPTURE_PACKAGE_VERSION}`;
+}
+export async function capturePublished() {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${CAPTURE_PACKAGE_NAME.replace("/", "%2f")}/${CAPTURE_PACKAGE_VERSION}`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/prompts.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export function featureArg(raw) {
+    const text = (raw ?? "").replace(/["\r\n\t]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 160);
+    return text || null;
+}
+export function launchVideoPrompt(raw) {
+    const feature = featureArg(raw);
+    return [
+        `Make a tday launch video of ${feature ? `the feature "${feature}"` : "the newest feature that has no launch video yet"}.`,
+        feature
+            ? `1. Find it with tday_list_features (search "${feature}") and use its id. If several match, show them and ask which.`
+            : '1. Call tday_list_features with without "launch_video" and offer the newest feature it lists, with the next two as alternatives.',
+        "   If tday asks for a brand, list them with tday_list_brands and ask which.",
+        "2. Before spending anything, quote the price (tday_get_credit_prices) and the balance (tday_whoami), and ask me to confirm and whether I want a voiceover or another length.",
+        "3. Call tday_create_launch_video with the featureId and the options I chose, then poll tday_poll_launch_video every 20-30 seconds until it is ready.",
+        "4. Show me the reviewUrl as a link and offer the MP4 (tday_get_launch_video_mp4).",
+    ].join("\n");
+}
+export const FEATURES_PROMPT = [
+    "Show me my tday features, newest first, and which have a launch video: call tday_list_features (if tday asks for a brand, list them with tday_list_brands and ask which).",
+    "List each feature's name, when it was added, and its launch video: finished, being made, or none.",
+    "Then offer to make a launch video of the newest feature that has none.",
+].join("\n");
+const userText = (text) => ({ messages: [{ role: "user", content: { type: "text", text } }] });
+export function registerPrompts(server) {
+    const registerPrompt = server.registerPrompt.bind(server);
+    registerPrompt("launch-video", {
+        title: "Launch video of a feature",
+        description: "Make a launch video of a feature: the one you name, or the newest feature without one. Quotes the credits before it starts.",
+        argsSchema: { feature: z.string().optional().describe("The feature's name. Leave empty for the newest feature without a launch video.") },
+    }, ({ feature }) => userText(launchVideoPrompt(feature)));
+    registerPrompt("features", {
+        title: "Latest features",
+        description: "The brand's newest features and which already have a launch video.",
+    }, () => userText(FEATURES_PROMPT));
+}

package/dist/result-format.js

@@ -0,0 +1,130 @@
+const MAX_TEXT_CHARS = 25_000;
+export function stringifyResult(result) {
+    return JSON.stringify(result, (_key, value) => (typeof value === "bigint" ? value.toString() : value), 2);
+}
+export function toStructuredContent(result) {
+    return isRecord(result) ? result : { result };
+}
+export function formatToolResultText(toolName, result, format, markdown) {
+    const text = format === "markdown" ? markdownResult(toolName, result, markdown) : stringifyResult(result);
+    return truncateText(text);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function truncateText(text) {
+    if (text.length <= MAX_TEXT_CHARS)
+        return text;
+    return `${text.slice(0, MAX_TEXT_CHARS)}\n\n[Response text truncated at ${MAX_TEXT_CHARS} characters. Use structuredContent or narrower list/get calls for the complete data.]`;
+}
+function markdownResult(toolName, result, markdown) {
+    if (!isRecord(result))
+        return String(result);
+    if (markdown)
+        return markdown(result);
+    switch (toolName) {
+        case "tday_whoami":
+            return markdownWhoami(result);
+        case "tday_list_brands":
+            return markdownList("Brands", result.brands, ["id", "name", "role", "status", "industry"]);
+        case "tday_list_designs":
+            return markdownList("Designs", result.designs, ["id", "name", "brandName", "currentStep", "updatedAt"]);
+        case "tday_generate_design":
+            return [
+                "# Generation queued",
+                `- Design ID: ${result.designId ?? "unknown"}`,
+                `- Generation ID: ${result.generationId ?? "unknown"}`,
+                `- Status: ${result.status ?? "unknown"}`,
+                result.editorUrl ? `- Editor: ${result.editorUrl}` : undefined,
+                "",
+                "Poll with `tday_poll_generation` until status is `completed` or `failed`.",
+            ].filter(Boolean).join("\n");
+        case "tday_poll_generation":
+            return [
+                "# Generation status",
+                `- Design ID: ${result.designId ?? "unknown"}`,
+                `- Generation ID: ${result.generationId ?? "unknown"}`,
+                `- Status: ${result.status ?? "unknown"}`,
+                result.imageUrl ? `- Image URL: ${result.imageUrl}` : undefined,
+                result.editorUrl ? `- Editor: ${result.editorUrl}` : undefined,
+                result.failureMessage ? `- Failure: ${result.failureMessage}` : undefined,
+            ].filter(Boolean).join("\n");
+        case "tday_download_image":
+            return [
+                "# Image downloaded",
+                `- Saved: ${result.saved ? "yes" : "no"}`,
+                `- Path: ${result.path ?? "unknown"}`,
+                `- Size: ${result.size ?? 0} bytes`,
+            ].join("\n");
+        default:
+            return `\`\`\`json\n${stringifyResult(result)}\n\`\`\``;
+    }
+}
+function markdownWhoami(result) {
+    const account = isRecord(result.account) ? result.account : {};
+    const subscription = isRecord(result.subscription) ? result.subscription : {};
+    return [
+        "# tday account",
+        `- Name: ${display(account.name)}`,
+        `- Email: ${display(account.email)}`,
+        `- Auth source: ${display(isRecord(result.auth) ? result.auth.source : undefined)}`,
+        `- Plan: ${display(subscription.plan ?? subscription.name ?? subscription.tier)}`,
+        balanceLine(result),
+    ].join("\n");
+}
+function balanceLine(result) {
+    const credits = isRecord(result.credits) ? result.credits : null;
+    if (credits && credits.enabled === true) {
+        if (typeof credits.balance !== "number")
+            return `- Credits: ${display(credits.balance)}`;
+        if (credits.grant === null)
+            return "- Credits: usage is covered by your contract";
+        const grant = typeof credits.grant === "number" ? ` of ${formatCount(credits.grant)}` : "";
+        const refresh = typeof credits.refreshesAt === "string" ? `, refreshes ${formatDay(credits.refreshesAt)}` : "";
+        const low = credits.lowBalance === "low" || credits.lowBalance === "critical" ? " (running low)" : "";
+        return `- Credits: ${formatCount(credits.balance)}${grant} left${refresh}${low}`;
+    }
+    const legacy = isRecord(result.apiBalance) ? result.apiBalance : null;
+    if (legacy && typeof legacy.balanceCents === "number") {
+        return `- Prepaid balance: $${(legacy.balanceCents / 100).toFixed(2)}`;
+    }
+    return `- Balance: ${display(result.apiBalance)}`;
+}
+function formatCount(value) {
+    return Math.trunc(value).toLocaleString("en-US");
+}
+function formatDay(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return iso;
+    return date.toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+}
+export function markdownList(title, value, columns) {
+    const items = Array.isArray(value) ? value.filter(isRecord) : [];
+    const lines = [`# ${title}`, ""];
+    if (items.length === 0) {
+        lines.push("No items returned.");
+        return lines.join("\n");
+    }
+    lines.push(`Returned ${items.length} item${items.length === 1 ? "" : "s"}.`, "");
+    lines.push(`| ${columns.join(" | ")} |`);
+    lines.push(`| ${columns.map(() => "---").join(" | ")} |`);
+    for (const item of items) {
+        lines.push(`| ${columns.map((column) => escapeMarkdownCell(display(item[column]))).join(" | ")} |`);
+    }
+    return lines.join("\n");
+}
+export function display(value) {
+    if (value === null || value === undefined || value === "")
+        return "-";
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint") {
+        return String(value);
+    }
+    return JSON.stringify(value, (_key, v) => (typeof v === "bigint" ? v.toString() : v));
+}
+function escapeMarkdownCell(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n/g, " ");
+}

package/dist/server.js

@@ -0,0 +1,43 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config.js";
+import { packageVersion } from "./package-info.js";
+import { registerPrompts } from "./prompts.js";
+import { tools, formatToolResultText, responseFormatFromArgs, toStructuredContent, } from "./tools.js";
+export async function runServer() {
+    const config = await loadConfig();
+    const server = new McpServer({ name: "tday-mcp-server", version: packageVersion() });
+    registerTools(server, tools, config);
+    registerPrompts(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+export function registerTools(server, list, config) {
+    const registerTool = server.registerTool.bind(server);
+    for (const tool of list) {
+        registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            outputSchema: tool.outputSchema,
+            annotations: {
+                readOnlyHint: tool.annotations.readOnlyHint,
+                destructiveHint: tool.annotations.destructiveHint,
+                idempotentHint: tool.annotations.idempotentHint,
+                openWorldHint: tool.annotations.openWorldHint,
+            },
+        }, async (args) => {
+            const rawArgs = args ?? {};
+            const result = await tool.handler(rawArgs, config);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatToolResultText(tool.name, result, responseFormatFromArgs(rawArgs), tool.markdown),
+                    },
+                ],
+                structuredContent: toStructuredContent(result),
+            };
+        });
+    }
+}

package/dist/tool-schemas.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+export const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
+const responseFormatSchema = z
+    .enum(["json", "markdown"])
+    .default("json")
+    .describe("Text response format. Defaults to json for backward compatibility; structuredContent is always returned when the MCP client supports it.");
+export const safeIdSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .regex(SAFE_ID, "must contain only letters, numbers, underscores, and hyphens");
+export function argsObject(shape) {
+    return z
+        .object({
+        ...shape,
+        response_format: responseFormatSchema,
+    })
+        .strict();
+}
+export const emptyArgsSchema = argsObject({});
+export const listArgsSchema = argsObject({
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(50)
+        .describe("Maximum items to return. Defaults to 50."),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe("Number of items to skip for pagination. Defaults to 0."),
+});
+export function safePath(template, params) {
+    return template.replace(/:(\w+)/g, (_, key) => {
+        const val = String(params[key] ?? "");
+        if (!SAFE_ID.test(val)) {
+            throw new Error(`Invalid ${key}: must contain only letters, numbers, underscores, and hyphens (got "${val}")`);
+        }
+        return encodeURIComponent(val);
+    });
+}
+export function stripPresentationArgs(args) {
+    const { response_format: _responseFormat, ...rest } = args;
+    return rest;
+}
+export function responseFormatFromArgs(args) {
+    return args.response_format === "markdown" ? "markdown" : "json";
+}
+const anyRecord = z.record(z.unknown());
+const paginationSchema = z
+    .object({
+    total_count: z.number().optional(),
+    total: z.number().optional(),
+    count: z.number(),
+    offset: z.number(),
+    limit: z.number(),
+    has_more: z.boolean().optional(),
+    hasMore: z.boolean().optional(),
+    next_offset: z.number().optional(),
+    nextOffset: z.number().optional(),
+})
+    .passthrough();
+export const outputSchemas = {
+    whoami: z
+        .object({
+        account: z.unknown().optional(),
+        organizations: z.array(anyRecord).optional(),
+        defaultOrganizationId: z.string().nullable().optional(),
+        features: z.unknown().optional(),
+        links: z.unknown().optional(),
+        notes: z.array(z.string()).optional(),
+    })
+        .passthrough(),
+    creditPrices: z
+        .object({
+        priceVersion: z.number().optional(),
+        actions: z.array(anyRecord).optional(),
+        launchVideos: z.array(anyRecord).optional(),
+        launchVideoRevisions: z.array(anyRecord).optional(),
+        monthlyCredits: z.unknown().optional(),
+        notes: z.array(z.string()).optional(),
+    })
+        .passthrough(),
+    usage: z
+        .object({
+        organization: anyRecord.optional(),
+        balance: z.unknown().optional(),
+        usage: z.unknown().optional(),
+        links: z.unknown().optional(),
+    })
+        .passthrough(),
+    listBrands: z
+        .object({
+        brands: z.array(anyRecord),
+        pagination: paginationSchema.optional(),
+    })
+        .passthrough(),
+    getBrand: z
+        .object({
+        brand: anyRecord.optional(),
+        role: z.string().optional(),
+    })
+        .passthrough(),
+    listDesigns: z
+        .object({
+        designs: z.array(anyRecord),
+        archivedCount: z.number().optional(),
+        pagination: paginationSchema.optional(),
+    })
+        .passthrough(),
+    getDesign: z
+        .object({
+        design: anyRecord.optional(),
+    })
+        .passthrough(),
+    createBrand: z
+        .object({
+        brand: anyRecord.optional(),
+        reviewStatus: z.string().optional(),
+    })
+        .passthrough(),
+    generate: z
+        .object({
+        designId: z.string(),
+        generationId: z.string(),
+        status: z.string(),
+        editorUrl: z.string(),
+        statusUrl: z.string(),
+        format: z.string().optional(),
+        formatNote: z.string().optional(),
+        credits: z.unknown().optional(),
+    })
+        .passthrough(),
+    poll: z
+        .object({
+        designId: z.string(),
+        generationId: z.string(),
+        status: z.string(),
+        editorUrl: z.string(),
+        imageUrl: z.string().optional(),
+        completedAt: z.string().nullable().optional(),
+        platformBadge: z.boolean().optional(),
+        badgeNote: z.string().optional(),
+        failureMessage: z.string().optional(),
+    })
+        .passthrough(),
+    download: z
+        .object({
+        saved: z.boolean(),
+        path: z.string(),
+        size: z.number(),
+    })
+        .passthrough(),
+};
+export const readOnly = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+};
+export const writeRemote = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+};
+export const writeLocal = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true,
+};

package/dist/tools-account.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { api, query } from "./api-client.js";
+import { argsObject, outputSchemas, readOnly, safeIdSchema } from "./tool-schemas.js";
+export const accountTools = [
+    {
+        name: "tday_get_credit_prices",
+        title: "Credit prices",
+        description: "What each thing costs in credits at today's price list: an image design, an edit, design videos, launch videos (every length, with or without music and voiceover, already added up), a launch video revision, scans, and each plan's monthly credits. Use it to tell the person what something will cost BEFORE starting it, next to the balance from tday_whoami.",
+        inputSchema: argsObject({}),
+        outputSchema: outputSchemas.creditPrices,
+        annotations: readOnly,
+        handler: (_args, config) => api(config, "/api/v1/credits/prices"),
+    },
+    {
+        name: "tday_get_usage",
+        title: "Credit usage",
+        description: "One organisation's credit balance and what it has spent this grant period, by action, by brand and by person, plus a link to its usage page. Pass organizationId from tday_whoami; omitted, the organisation the person owns.",
+        inputSchema: argsObject({
+            organizationId: safeIdSchema.optional().describe("Organisation ID from tday_whoami"),
+        }),
+        outputSchema: outputSchemas.usage,
+        annotations: readOnly,
+        handler: (args, config) => api(config, `/api/v1/usage${query({ organizationId: typeof args.organizationId === "string" ? args.organizationId : undefined })}`),
+    },
+];
+export const IMAGE_FORMATS = ["square", "ig_post", "story", "fb_post", "linkedin_post", "desktop", "a4_page"];
+export const imageFormatSchema = z
+    .enum(IMAGE_FORMATS)
+    .optional()
+    .describe("Preset size: square 1080x1080, ig_post 1080x1350 (4:5 portrait), story 1080x1920 (9:16), fb_post 1200x630, linkedin_post 1200x627, desktop 1920x1080, a4_page. Portrait, square and story are on the paid plans where the plan gates sizes (tday_whoami output.allSizes); asking for one that is not included is refused with an upgrade link.");

package/dist/tools-features.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { api, query } from "./api-client.js";
+import { argsObject, readOnly, safeIdSchema } from "./tool-schemas.js";
+const MAX_FEATURES = 50;
+export const LIST_FEATURES_DESCRIPTION = "List a brand's features (its Launch page catalog), newest added first, with the videos each already has: how many launch videos are finished or being made, and the latest one with its link. " +
+    "Use it for the newest feature, for the features that still have no launch video (without: launch_video), or to find a feature's id for tday_create_launch_video. " +
+    "brandId may be left out when the account has one brand; otherwise pass one from tday_list_brands. `more` counts the features not listed. Spends no credits.";
+const featureListSchema = z
+    .object({
+    brand: z.object({ id: z.string(), name: z.string() }).passthrough(),
+    counts: z.record(z.unknown()),
+    features: z.array(z.record(z.unknown())),
+    more: z.number(),
+})
+    .passthrough();
+export const featureTools = [
+    {
+        name: "tday_list_features",
+        title: "List features",
+        description: LIST_FEATURES_DESCRIPTION,
+        inputSchema: argsObject({
+            brandId: safeIdSchema.optional().describe("Brand ID from tday_list_brands. Optional when the account has one brand."),
+            without: z
+                .enum(["launch_video"])
+                .optional()
+                .describe("launch_video: only features with no launch video finished or being made."),
+            search: z.string().trim().min(1).max(160).optional().describe("Only features whose title contains this, ignoring case."),
+            limit: z.number().int().min(1).max(MAX_FEATURES).default(20).describe(`How many to list, newest first (at most ${MAX_FEATURES}). Defaults to 20.`),
+        }),
+        outputSchema: featureListSchema,
+        annotations: readOnly,
+        handler: (args, config) => api(config, `/api/v1/features${query({
+            brandId: typeof args.brandId === "string" ? args.brandId : undefined,
+            without: typeof args.without === "string" ? args.without : undefined,
+            q: typeof args.search === "string" ? args.search : undefined,
+            limit: typeof args.limit === "number" ? args.limit : undefined,
+        })}`),
+    },
+];