@tday-com/mcp 0.0.0-stage → 0.2.0

package/dist/tools.js

@@ -0,0 +1,296 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { z } from "zod";
+import { api, firstImageUrl, normalizeWebsite, query, } from "./api-client.js";
+import { MAX_IMAGE_BYTES, prepareOutputFilePath, validateImageUrl, } from "./download-safety.js";
+import { argsObject, emptyArgsSchema, listArgsSchema, outputSchemas, readOnly, safeIdSchema, safePath, stripPresentationArgs, writeLocal, writeRemote, } from "./tool-schemas.js";
+import { demoImportAvailable, demoTools } from "./tools-demo.js";
+import { knowledgeTools } from "./tools-knowledge.js";
+import { accountTools, imageFormatSchema } from "./tools-account.js";
+import { launchTools } from "./tools-launch.js";
+const PLATFORM_BADGE_NOTE = 'This image carries a "Made with tday.com" badge because the organisation is on the Free plan. The owner can remove it by upgrading (tday_whoami has the link).';
+export { responseFormatFromArgs, safePath } from "./tool-schemas.js";
+export { ALLOWED_IMAGE_HOSTS, MAX_IMAGE_BYTES, prepareOutputFilePath, sandboxFilePath, validateImageUrl, } from "./download-safety.js";
+export { formatToolResultText, stringifyResult, toStructuredContent, } from "./result-format.js";
+export { knowledgeTools, KNOWLEDGE_ENTRY_TYPES } from "./tools-knowledge.js";
+export const tools = [
+    {
+        name: "tday_whoami",
+        title: "Who am I?",
+        description: "Get the linked tday account: every organisation the person belongs to, their role in it (owner, admin or member), its plan, its credit balance and when it refreshes, what the plan's output includes (sizes, the Free badge, voiceover), what upgrading would change, its brands, and links to its usage and billing pages. Each organisation has a `summary` sentence to show the person as it is. A design or launch video spends the credits of its BRAND's organisation, so check the organisation that owns the brand before quoting a balance. Only an owner can change a plan; for an admin or member, say who the owner is instead of telling them to upgrade. Use first to verify MCP is connected to the expected account.",
+        inputSchema: emptyArgsSchema,
+        outputSchema: outputSchemas.whoami,
+        annotations: readOnly,
+        handler: (_args, config) => api(config, "/api/v1/account"),
+    },
+    {
+        name: "tday_list_brands",
+        title: "List brands",
+        description: "List brands accessible to the authenticated user as lightweight summaries. Supports API-backed limit/offset pagination.",
+        inputSchema: listArgsSchema,
+        outputSchema: outputSchemas.listBrands,
+        annotations: readOnly,
+        handler: (args, config) => api(config, `/api/brands/summary${query({ limit: Number(args.limit), offset: Number(args.offset) })}`),
+    },
+    {
+        name: "tday_get_brand",
+        title: "Get brand",
+        description: "Fetch a single brand with its colors, logos, fonts, images, and knowledge base. Use after tday_list_brands when detailed brand context is needed.",
+        inputSchema: argsObject({
+            brandId: safeIdSchema.describe("Brand ID from tday"),
+        }),
+        outputSchema: outputSchemas.getBrand,
+        annotations: readOnly,
+        handler: (args, config) => api(config, safePath("/api/brands/:brandId", args)),
+    },
+    {
+        name: "tday_list_designs",
+        title: "List designs",
+        description: "List the authenticated user's designs as lightweight summaries. Supports API-backed limit/offset pagination.",
+        inputSchema: listArgsSchema,
+        outputSchema: outputSchemas.listDesigns,
+        annotations: readOnly,
+        handler: (args, config) => api(config, `/api/designs/summary${query({ limit: Number(args.limit), offset: Number(args.offset) })}`),
+    },
+    {
+        name: "tday_get_design",
+        title: "Get design",
+        description: "Fetch a single design by id, including its generations. Use after tday_list_designs when generation IDs or full design details are needed.",
+        inputSchema: argsObject({
+            designId: safeIdSchema.describe("Design ID from tday"),
+        }),
+        outputSchema: outputSchemas.getDesign,
+        annotations: readOnly,
+        handler: (args, config) => api(config, safePath("/api/designs/:designId", args)),
+    },
+    {
+        name: "tday_generate_design",
+        title: "Generate design",
+        description: "Generate a new tday design from a text prompt against a brand, then poll with tday_poll_generation until it is completed or failed. An image costs 10 credits from the brand's organisation (tday_get_credit_prices has every price; tday_whoami has the balance) and a failed generation gives them back. The response says which organisation paid and what it has left; a refusal for credits means nothing was started, so do not retry. Omit format for square (1080x1080), or landscape (1200x630) where the plan does not include square.",
+        inputSchema: argsObject({
+            prompt: z
+                .string()
+                .trim()
+                .min(1)
+                .max(5000)
+                .describe("Design prompt. Be specific about audience, format, copy, and visual direction."),
+            brandId: safeIdSchema.describe("Brand ID from tday"),
+            name: z.string().trim().min(1).max(200).optional().describe("Short design name"),
+            format: imageFormatSchema,
+        }),
+        outputSchema: outputSchemas.generate,
+        annotations: writeRemote,
+        handler: (args, config) => api(config, "/api/v1/generate", {
+            method: "POST",
+            body: JSON.stringify(stripPresentationArgs(args)),
+        }),
+    },
+    {
+        name: "tday_poll_generation",
+        title: "Poll generation",
+        description: "Poll a design generation. Returns status (pending/ideating/generating/visualising/reviewing/refining/completed/failed), editorUrl, imageUrl when completed, and platformBadge when the image carries the Free plan's badge. Call repeatedly until status is completed or failed.",
+        inputSchema: argsObject({
+            designId: safeIdSchema.describe("Design ID from tday"),
+            generationId: safeIdSchema.describe("Generation ID from tday"),
+        }),
+        outputSchema: outputSchemas.poll,
+        annotations: { ...readOnly, idempotentHint: true },
+        handler: async (args, config) => {
+            const path = safePath("/api/designs/:designId/generate/:generationId/status?poll=1", args);
+            const data = await api(config, path);
+            const generation = data.complete?.generation;
+            const status = data.status ?? generation?.status ?? "unknown";
+            const imageUrl = firstImageUrl(generation);
+            return {
+                designId: args.designId,
+                generationId: args.generationId,
+                status,
+                editorUrl: `${config.webBaseUrl}/designs/${args.designId}`,
+                ...(imageUrl ? { imageUrl } : {}),
+                ...(generation?.completedAt ? { completedAt: generation.completedAt } : {}),
+                ...(data.platformBadge ? { platformBadge: true, badgeNote: PLATFORM_BADGE_NOTE } : {}),
+                ...(status === "failed"
+                    ? { failureMessage: data.complete?.message ?? "Generation did not complete." }
+                    : {}),
+            };
+        },
+    },
+    {
+        name: "tday_create_brand",
+        title: "Create brand",
+        description: "Create a new brand from a website URL. Extracts colors, fonts, and logos automatically from the site. You can also pass a name and description.",
+        inputSchema: argsObject({
+            website: z
+                .string()
+                .trim()
+                .min(1)
+                .max(2048)
+                .describe("Website URL to extract brand assets from, for example stripe.com or https://stripe.com"),
+            name: z.string().trim().min(1).max(200).optional().describe("Brand name, auto-detected from website if omitted"),
+            description: z.string().trim().min(1).max(1000).optional().describe("Short brand description"),
+            industry: z.string().trim().min(1).max(120).optional().describe("Industry category"),
+        }),
+        outputSchema: outputSchemas.createBrand,
+        annotations: writeRemote,
+        handler: (args, config) => {
+            const body = { website: normalizeWebsite(String(args.website)) };
+            if (args.name)
+                body.name = args.name;
+            if (args.description)
+                body.description = args.description;
+            if (args.industry)
+                body.industry = args.industry;
+            return api(config, "/api/brands", {
+                method: "POST",
+                body: JSON.stringify(body),
+            });
+        },
+    },
+    {
+        name: "tday_download_image",
+        title: "Download image",
+        description: "Download a completed generated design image to a local file. Pass designId + generationId to save the exported file (what a download from tday gives you), or an imageUrl to save that exact image. Writes only inside the current working directory and caps downloads at 50MB.",
+        inputSchema: argsObject({
+            imageUrl: z
+                .string()
+                .trim()
+                .url()
+                .optional()
+                .describe("Completed generation image URL. Optional if designId and generationId are provided."),
+            designId: safeIdSchema.optional().describe("Design ID from tday. Optional if imageUrl is provided."),
+            generationId: safeIdSchema.optional().describe("Generation ID from tday. Optional if imageUrl is provided."),
+            filePath: z
+                .string()
+                .trim()
+                .min(1)
+                .max(500)
+                .describe("Local path to save the image, relative to cwd, for example ./tday-designs/poster.png"),
+            overwrite: z
+                .boolean()
+                .default(false)
+                .describe("Whether to overwrite an existing regular file. Defaults to false for safety."),
+        }),
+        outputSchema: outputSchemas.download,
+        annotations: writeLocal,
+        handler: async (args, config) => {
+            const hasUrl = Boolean(args.imageUrl);
+            const hasIds = Boolean(args.designId && args.generationId);
+            if (!hasUrl && !hasIds) {
+                throw new Error("Provide either imageUrl, or both designId and generationId.");
+            }
+            if ((args.designId && !args.generationId) || (!args.designId && args.generationId)) {
+                throw new Error("designId and generationId must be provided together.");
+            }
+            // The ids win: the export route answers the file a download gets, which for a brand whose
+            // downloads carry the Free-tier badge is a badged copy of the stored (clean) preview.
+            const imageUrl = hasIds
+                ? await imageUrlForGeneration(args, config)
+                : String(args.imageUrl);
+            const url = validateImageUrl(imageUrl);
+            const filePath = await prepareOutputFilePath(String(args.filePath), {
+                overwrite: Boolean(args.overwrite),
+            });
+            const res = await fetch(url.href);
+            if (res.url)
+                validateImageUrl(res.url);
+            if (!res.ok) {
+                throw new Error(`Failed to download image: ${res.status} ${res.statusText}`);
+            }
+            const contentLength = Number(res.headers.get("content-length") ?? 0);
+            if (Number.isFinite(contentLength) && contentLength > MAX_IMAGE_BYTES) {
+                throw new Error(`Image exceeds ${MAX_IMAGE_BYTES / 1024 / 1024}MB limit according to content-length. Download aborted.`);
+            }
+            const contentType = res.headers.get("content-type");
+            if (contentType &&
+                !contentType.toLowerCase().startsWith("image/") &&
+                !contentType.toLowerCase().startsWith("application/octet-stream")) {
+                throw new Error(`Download did not return an image (content-type: ${contentType})`);
+            }
+            // Stream with size cap to prevent OOM from oversized responses.
+            const chunks = [];
+            let totalBytes = 0;
+            const reader = res.body?.getReader();
+            if (!reader) {
+                throw new Error("No response body from image URL");
+            }
+            try {
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    totalBytes += value.byteLength;
+                    if (totalBytes > MAX_IMAGE_BYTES) {
+                        throw new Error(`Image exceeds ${MAX_IMAGE_BYTES / 1024 / 1024}MB limit. Download aborted.`);
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const buffer = Buffer.concat(chunks);
+            const flags = constants.O_WRONLY |
+                constants.O_CREAT |
+                (args.overwrite ? constants.O_TRUNC : constants.O_EXCL) |
+                (constants.O_NOFOLLOW ?? 0);
+            const handle = await open(filePath, flags, 0o600);
+            try {
+                await handle.writeFile(buffer);
+            }
+            finally {
+                await handle.close();
+            }
+            return {
+                saved: true,
+                path: filePath,
+                size: buffer.byteLength,
+            };
+        },
+    },
+    ...accountTools,
+    ...launchTools,
+    ...knowledgeTools,
+    ...demoTools,
+];
+/**
+ * The tools this account is shown: every tool, minus the demo-import tools unless the
+ * account may import (tools-demo.ts). `tools` stays the full set so `callTool` can still
+ * name them; their routes refuse an account without access.
+ */
+export async function listedTools(config) {
+    if (await demoImportAvailable(config))
+        return tools;
+    const hidden = new Set(demoTools.map((tool) => tool.name));
+    return tools.filter((tool) => !hidden.has(tool.name));
+}
+/**
+ * The generation's DOWNLOAD at 1x, from the export route. The image a generation reports is
+ * the clean preview; the export route hands out the file that may leave tday.
+ */
+async function imageUrlForGeneration(args, config) {
+    const data = await api(config, safePath("/api/designs/:designId/generations/:generationId/export", args), { method: "POST", body: JSON.stringify({ scale: 1 }) });
+    const imageUrl = typeof data?.image?.url === "string" ? data.image.url : null;
+    if (!imageUrl) {
+        throw new Error("No image URL found for this generation. Poll tday_poll_generation until status is completed, then try again.");
+    }
+    return imageUrl;
+}
+function formatZodError(name, error) {
+    const details = error.issues
+        .map((issue) => {
+        const path = issue.path.length ? issue.path.join(".") : "arguments";
+        return `${path}: ${issue.message}`;
+    })
+        .join("; ");
+    return `Invalid arguments for ${name}: ${details}`;
+}
+export async function callTool(name, args, config) {
+    const tool = tools.find((t) => t.name === name);
+    if (!tool) {
+        throw new Error(`Unknown tool: ${name}. Available tools: ${tools.map((t) => t.name).join(", ")}`);
+    }
+    const parsed = tool.inputSchema.safeParse(args);
+    if (!parsed.success)
+        throw new Error(formatZodError(tool.name, parsed.error));
+    return tool.handler(parsed.data, config);
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@tday-com/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "MCP server and CLI installer for tday.com - connect Claude Code, Codex, Cursor, and other AI agents to your tday.com account.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "tday",
+    "design-generation",
+    "ai",
+    "claude",
+    "codex",
+    "cursor"
+  ],
+  "homepage": "https://tday.com",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "tday.com",
+  "type": "module",
+  "bin": {
+    "mcp": "dist/cli.js",
+    "tday": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "dev": "tsc -p tsconfig.json --watch",
+    "test": "bun test",
+    "prepublishOnly": "bun run build",
+    "start": "node dist/cli.js serve"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.222.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.80.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/resources": "^2.11.0",
+    "@opentelemetry/sdk-logs": "^0.222.0",
+    "@opentelemetry/sdk-metrics": "^2.11.0",
+    "@opentelemetry/sdk-node": "^0.222.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.2",
+    "typescript": "^5.6.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}