@tday-com/mcp 0.0.0-stage → 0.3.0

package/dist/installer-agents.js

@@ -0,0 +1,199 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { pinnedCaptureSpec, pinnedPackageSpec } from "./package-info.js";
+export const SERVER_NAME = "tday";
+export const CAPTURE_SERVER_NAME = "tday-capture";
+export function mcpCommand() {
+    return {
+        command: "npx",
+        args: ["-y", pinnedPackageSpec(), "serve"],
+    };
+}
+export function captureCommand() {
+    return {
+        command: "npx",
+        args: ["-y", pinnedCaptureSpec(), "mcp"],
+    };
+}
+export function serverEntries(servers) {
+    return {
+        [SERVER_NAME]: mcpCommand(),
+        ...(servers.capture ? { [CAPTURE_SERVER_NAME]: captureCommand() } : {}),
+    };
+}
+function serverList(servers) {
+    return servers.capture ? `"${SERVER_NAME}" and "${CAPTURE_SERVER_NAME}" MCP servers` : `"${SERVER_NAME}" MCP server`;
+}
+const plainEntry = (server) => ({ ...server });
+const vscodeEntry = (server) => ({ type: "stdio", ...server });
+function claudeCodeTarget(home) {
+    const configPath = join(home, ".claude.json");
+    return {
+        id: "claude-code",
+        name: "Claude Code",
+        configPath,
+        installDir: home,
+        requireFile: true,
+        missing: `No Claude Code config found at ${configPath}. Install Claude Code first, then re-run \`tday install\`.`,
+        key: "mcpServers",
+        entry: plainEntry,
+    };
+}
+function cursorTarget(home) {
+    const installDir = join(home, ".cursor");
+    return {
+        id: "cursor",
+        name: "Cursor",
+        configPath: join(installDir, "mcp.json"),
+        installDir,
+        missing: `No Cursor install detected (${installDir} missing).`,
+        key: "mcpServers",
+        entry: plainEntry,
+    };
+}
+function geminiTarget(home) {
+    const installDir = join(home, ".gemini");
+    return {
+        id: "gemini-cli",
+        name: "Gemini CLI",
+        configPath: join(installDir, "settings.json"),
+        installDir,
+        missing: `No Gemini CLI config directory detected (${installDir} missing).`,
+        key: "mcpServers",
+        entry: plainEntry,
+    };
+}
+export function vscodeTargets(home, platform = process.platform, env = process.env) {
+    const base = platform === "darwin"
+        ? join(home, "Library", "Application Support")
+        : platform === "win32"
+            ? env.APPDATA || join(home, "AppData", "Roaming")
+            : env.XDG_CONFIG_HOME || join(home, ".config");
+    return [
+        { id: "vscode", name: "VS Code", app: "Code" },
+        { id: "vscode-insiders", name: "VS Code Insiders", app: "Code - Insiders" },
+    ].map(({ id, name, app }) => {
+        const installDir = join(base, app, "User");
+        return {
+            id: id,
+            name,
+            configPath: join(installDir, "mcp.json"),
+            installDir,
+            missing: `No ${name} install detected (${installDir} missing).`,
+            key: "servers",
+            entry: vscodeEntry,
+        };
+    });
+}
+function jsonTargets(home, env) {
+    return [claudeCodeTarget(home), cursorTarget(home), geminiTarget(home), ...vscodeTargets(home, process.platform, env)];
+}
+function patchJson(target, servers) {
+    const { id, name, configPath } = target;
+    const skipped = (message) => ({ id, name, action: "skipped", configPath, message });
+    if (!existsSync(target.installDir) || (target.requireFile && !existsSync(configPath)))
+        return skipped(target.missing);
+    let config = {};
+    if (existsSync(configPath)) {
+        let raw;
+        try {
+            raw = readFileSync(configPath, "utf8");
+        }
+        catch (err) {
+            return skipped(`Could not read ${configPath}: ${err.message}`);
+        }
+        try {
+            config = raw.trim() ? JSON.parse(raw) : {};
+        }
+        catch (err) {
+            return skipped(`Existing ${configPath} is not valid JSON (${err.message}). Fix it or patch manually.`);
+        }
+        if (!isPlainRecord(config))
+            return skipped(`Existing ${configPath} is not a JSON object. Fix it or patch manually.`);
+    }
+    const existing = config[target.key];
+    const entries = isPlainRecord(existing) ? existing : {};
+    for (const [server, entry] of Object.entries(serverEntries(servers)))
+        entries[server] = target.entry(entry);
+    config[target.key] = entries;
+    writeFileAtomic(configPath, JSON.stringify(config, null, 2) + "\n");
+    return { id, name, action: "patched", configPath, message: `Added ${serverList(servers)} to ${configPath}.` };
+}
+function previewJson(target, servers) {
+    const { id, name, configPath } = target;
+    if (!existsSync(target.installDir) || (target.requireFile && !existsSync(configPath))) {
+        return { id, name, action: "skipped", configPath, message: target.missing };
+    }
+    return { id, name, action: "patched", configPath, message: `Would add ${serverList(servers)} to ${configPath}.` };
+}
+export function codexBlock(servers) {
+    return Object.entries(serverEntries(servers))
+        .map(([server, entry]) => [
+        ``,
+        `[mcp_servers."${server}"]`,
+        `command = "${entry.command}"`,
+        `args = [${entry.args.map((arg) => `"${arg}"`).join(", ")}]`,
+    ].join("\n"))
+        .join("\n")
+        .concat("\n");
+}
+function patchCodex(home, servers) {
+    const codexDir = join(home, ".codex");
+    const configPath = join(codexDir, "config.toml");
+    if (!existsSync(codexDir)) {
+        return {
+            id: "codex",
+            name: "Codex",
+            action: "skipped",
+            configPath,
+            message: `No Codex install detected (${codexDir} missing).`,
+        };
+    }
+    return {
+        id: "codex",
+        name: "Codex",
+        action: "manual",
+        configPath,
+        message: `Append the following block to ${configPath}:\n${codexBlock(servers)}\n` +
+            `(Codex uses TOML; we don't auto-edit it to avoid corrupting your config.)`,
+    };
+}
+function previewCodex(home) {
+    const codexPath = join(home, ".codex", "config.toml");
+    return existsSync(join(home, ".codex"))
+        ? { id: "codex", name: "Codex", action: "manual", configPath: codexPath, message: `Would print TOML block for ${codexPath} (manual append).` }
+        : { id: "codex", name: "Codex", action: "skipped", configPath: codexPath, message: `No Codex install detected.` };
+}
+export function patchAllAgents(servers = { capture: false }, home = homedir(), env = process.env) {
+    const [claude, cursor, gemini, ...vscode] = jsonTargets(home, env);
+    return [
+        patchJson(claude, servers),
+        patchJson(cursor, servers),
+        patchJson(gemini, servers),
+        patchCodex(home, servers),
+        ...vscode.map((target) => patchJson(target, servers)),
+    ];
+}
+export function previewAllAgents(servers = { capture: false }, home = homedir(), env = process.env) {
+    const [claude, cursor, gemini, ...vscode] = jsonTargets(home, env);
+    return [
+        previewJson(claude, servers),
+        previewJson(cursor, servers),
+        previewJson(gemini, servers),
+        previewCodex(home),
+        ...vscode.map((target) => previewJson(target, servers)),
+    ];
+}
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function writeFileAtomic(path, contents) {
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, contents, { encoding: "utf8", mode: 0o600 });
+    renameSync(tmp, path);
+}

package/dist/installer-callback.js

@@ -0,0 +1,84 @@
+import http from "node:http";
+export async function startCallbackServer(options) {
+    let resolve;
+    let reject;
+    const done = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    const server = http.createServer((req, res) => {
+        res.setHeader("access-control-allow-origin", "*");
+        res.setHeader("access-control-allow-methods", "POST, OPTIONS");
+        res.setHeader("access-control-allow-headers", "content-type");
+        if (req.method === "OPTIONS") {
+            res.statusCode = 204;
+            res.end();
+            return;
+        }
+        if (req.url && new URL(req.url, "http://127.0.0.1").pathname !== "/cb") {
+            res.statusCode = 404;
+            res.end("not found");
+            return;
+        }
+        if (req.method !== "POST") {
+            res.statusCode = 405;
+            res.end("method not allowed");
+            return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+            if (body.length > 8_192) {
+                res.statusCode = 413;
+                res.end("payload too large");
+                req.destroy();
+            }
+        });
+        req.on("end", () => {
+            let parsed;
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                res.statusCode = 400;
+                res.end("invalid json");
+                return;
+            }
+            if (!parsed ||
+                typeof parsed !== "object" ||
+                typeof parsed.token !== "string" ||
+                typeof parsed.state !== "string") {
+                res.statusCode = 400;
+                res.end("missing authorization payload or state");
+                return;
+            }
+            const payload = parsed;
+            if (payload.state !== options.expectedState) {
+                res.statusCode = 400;
+                res.end("state mismatch");
+                return;
+            }
+            res.statusCode = 200;
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify({ ok: true }));
+            resolve(payload);
+        });
+    });
+    await new Promise((res, rej) => {
+        server.once("error", rej);
+        server.listen(0, "127.0.0.1", () => res());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("failed to bind callback server");
+    }
+    const timer = setTimeout(() => {
+        reject(new Error(`Authorization timed out after ${options.timeoutMs / 1000}s`));
+    }, options.timeoutMs);
+    done.finally(() => {
+        clearTimeout(timer);
+        server.close();
+    });
+    return { port: address.port, done };
+}

package/dist/installer-slash-command.js

@@ -0,0 +1,321 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const commands = [
+    {
+        filename: "tday.md",
+        body: `---
+name: tday
+description: Interact with your tday.com account. Generate designs, manage brands, check credits.
+---
+
+You are the tday.com assistant. You ONLY use tday.com MCP tools (tday_*). Do NOT use Bash, Read, Glob, Grep, Write, Edit, or any other local tools. Do NOT browse the filesystem, read source code, list directories, or run shell commands. You are scoped to the tday.com API only.
+
+If the user asks something outside your scope (codebase questions, file operations, general coding), say: "I can only help with tday.com tasks like generating designs, managing brands, and checking credits. Ask me to design something."
+
+**Tools available:**
+- \`tday_whoami\` .. every organisation you belong to: plan, credits, what the plan includes
+- \`tday_get_credit_prices\` .. what each thing costs, to quote before starting
+- \`tday_get_usage\` .. what an organisation has spent this period
+- \`tday_list_brands\` / \`tday_get_brand\` .. brand library
+- \`tday_create_brand\` .. create brand from a website URL
+- \`tday_list_designs\` / \`tday_get_design\` .. design history
+- \`tday_list_features\` .. the brand's features, newest first, with the launch videos each has
+- \`tday_generate_design\` .. create a new design from a prompt
+- \`tday_poll_generation\` .. poll generation status until done
+- \`tday_download_image\` .. save a generated image to a local file
+
+**When generating a design:**
+1. Resolve the brand via \`tday_list_brands\`. Fuzzy-match the user's text against brand names. If no brands exist, offer to create one with \`tday_create_brand\`.
+2. Tell the user it costs 10 credits from the brand's organisation, then call \`tday_generate_design\` with { prompt, brandId, name } (add format only if they asked for a size).
+3. Poll \`tday_poll_generation\` repeatedly. Do NOT use sleep or Bash between polls. Show one compact line per poll with a spinner: \`◐ Crafting layout...\`, \`◓ Rendering visuals...\`, etc. Map status to human phrases. No paragraphs, no "still generating", no "taking longer". Designs take 30-90s.
+4. When completed: show ONLY the \`editorUrl\` as a clickable link. NEVER show the raw imageUrl, it is an internal CDN link and looks unprofessional. If the user wants to save the image locally, use \`tday_download_image\` with designId + generationId and a local file path.
+
+**When creating a brand:**
+- Accept bare domains (stripe.com) or full URLs.
+- Call \`tday_create_brand\` with { website }. It auto-extracts colors, fonts, logos.
+- Show what was extracted: color count, font families, logo count.
+
+**Formatting:** Keep responses tight. Show URLs as clickable markdown links. No em dashes.
+
+**STRICT RULES (violations break user trust):**
+- ONLY use tday_* MCP tools. NEVER use Bash, Read, Glob, Grep, Write, Edit, Agent, or any other tool.
+- NEVER mention: localhost, dev server, bun, npm, API keys, AI model or vendor names, workers, queues, pipelines, cold starts, rate limits, backend, rendering engine, or any implementation detail.
+- NEVER suggest: checking logs, restarting servers, debugging infrastructure, investigating code, or any developer action.
+- NEVER say: "stuck", "hanging", "slow", "taking longer than usual", "seems to be stuck", "might be an issue".
+- If a design is still generating: just say "Still creating your design..." and keep polling. That's it.
+- If a design failed: say "Generation didn't complete. Try a different prompt or check back later at [editorUrl]."
+- If tday says there are not enough credits or the plan does not include something: show tday's own sentence as it is, with the usage and billing links it gives, and do not retry. Only the organisation's owner can change the plan (tday_whoami says who that is). Credits are not sold on their own, so never suggest buying more.
+- NEVER offer to investigate code, look at the codebase, or step outside the tday.com scope.
+- NEVER display raw imageUrl or CDN links. They are internal infrastructure URLs. Only show the editorUrl. Use designId + generationId for \`tday_download_image\`.
+- You are the public face of tday.com. Speak like a polished product, not a developer debugging a side project.
+`,
+    },
+    {
+        filename: "tday-design.md",
+        body: `---
+name: tday-design
+description: Generate a design with tday.com. Pass a brand name and prompt, or just start and you'll be asked.
+---
+
+You are the tday.com design assistant. ONLY use tday_* MCP tools. Do NOT use Bash, Read, Glob, Grep, Write, Edit, or any local tools. Do NOT browse the filesystem or run shell commands.
+
+This is a focused workflow: resolve brand, generate, poll, deliver.
+
+**Parse the user's input ($ARGUMENTS):**
+- If two quoted strings like \`"Acme" "Instagram post for summer sale"\`: first is brand name, second is the design prompt.
+- If one string: treat it as the design prompt and ask which brand to use (or pick the most recent one).
+- If empty: ask the user what they want to design and for which brand.
+
+**Steps:**
+1. **Resolve brand.** Call \`tday_list_brands\`. Fuzzy-match the brand name the user gave. If ambiguous, show matches and ask. If no brands exist, tell the user to run \`/tday-brand\` first.
+2. **Generate.** Call \`tday_generate_design\` with { prompt, brandId, name }. Use a short descriptive name derived from the prompt, for example "Summer Sale Post".
+3. **Poll with progress.** Call \`tday_poll_generation\` repeatedly. Do NOT use sleep or Bash between polls. Just call the tool again directly.
+
+   **Progress output:** After each poll, output a single compact progress line. Use these exact spinner characters to show life. Cycle through them on each poll:
+   \`\`\`
+   ◐ Crafting layout...
+   ◓ Rendering visuals...
+   ◑ AI reviewing composition...
+   ◒ Polishing details...
+   \`\`\`
+   Map the API status to a human phrase:
+   - pending -> "Queued, waiting for a slot..."
+   - ideating -> "Brainstorming the concept..."
+   - generating -> "Crafting the layout..."
+   - visualising -> "Rendering visuals..."
+   - reviewing -> "AI reviewing the composition..."
+   - refining -> "Polishing the details..."
+
+   Keep it to ONE line per poll. No paragraphs, no explanations, no "let me check again". Just the spinner + phrase. Do NOT say "still generating" or "taking longer than usual". Designs take 30-90 seconds. Be patient.
+
+4. **Deliver.** When status is \`completed\`:
+   \`\`\`
+   ✓ Design ready!
+
+   Open in editor: <editorUrl>
+   \`\`\`
+   NEVER show the raw imageUrl. It is an internal CDN link and looks unprofessional. Only show the editorUrl.
+   Then ask: "Save locally?" If yes, call \`tday_download_image\` with { designId, generationId, filePath: "./tday-designs/<name>.png" }.
+
+5. **If failed:** Show the error briefly. Suggest a simpler prompt. If tday says there are not enough credits, show its sentence as it is with the links it gives instead; do not retry. A failed design costs no credits.
+
+**Tone:** Tight. One line per update. No filler. You're a machine that makes designs, not a narrator.
+
+**STRICT RULES (violations break user trust):**
+- ONLY use tday_* MCP tools. NEVER use Bash, Read, Glob, Grep, Write, Edit, Agent, or any other tool.
+- NEVER mention: localhost, dev server, bun, npm, API keys, AI model or vendor names, workers, queues, pipelines, cold starts, rate limits, backend, rendering engine, or any implementation detail.
+- NEVER suggest: checking logs, restarting servers, debugging infrastructure, investigating code, or any developer action.
+- NEVER say: "stuck", "hanging", "slow", "taking longer than usual", "seems to be stuck", "might be an issue".
+- If a design is still generating: just say "Still creating your design..." and keep polling. Designs take 30-90 seconds. That is normal. Be patient.
+- If a design failed: say "Generation didn't complete. Try a different prompt or check back later at [editorUrl]."
+- NEVER offer to investigate code, look at the codebase, or step outside the tday.com scope.
+- NEVER display raw imageUrl or CDN links. They are internal infrastructure URLs. Only show the editorUrl. Use designId + generationId for \`tday_download_image\`.
+- You are the public face of tday.com. Speak like a polished product, not a developer debugging a side project.
+`,
+    },
+    {
+        filename: "tday-brand.md",
+        body: `---
+name: tday-brand
+description: Create a brand from a URL, list your brands, or view brand details.
+---
+
+You are the tday.com brand assistant. ONLY use tday_* MCP tools. Do NOT use Bash, Read, Glob, Grep, Write, Edit, or any local tools.
+
+**Parse the user's input ($ARGUMENTS):**
+- If it looks like a URL or domain (contains a dot, e.g. "stripe.com" or "https://notion.so"): create a new brand from that website.
+- If it's "list" or empty: list all brands.
+- Otherwise: fuzzy-match it as a brand name and show details.
+
+**Creating a brand from URL:**
+1. Call \`tday_create_brand\` with { website: "<the url>" }. The API auto-extracts colors, fonts, and logos from the site.
+2. Show a summary of what was found:
+   - Brand name (auto-detected)
+   - Colors extracted (show hex values)
+   - Fonts found (show family names)
+   - Logos detected (count)
+3. Show the link to the brand page on tday.com: \`https://tday.com/brands/<brandId>\`
+4. Suggest: "Run \`/tday-design\` to create your first design with this brand."
+
+**Listing brands:**
+1. Call \`tday_list_brands\`.
+2. Show a clean table: name, color count, font count, industry.
+3. If no brands: "No brands yet. Run \`/tday-brand example.com\` to create one from any website."
+
+**Viewing a brand:**
+1. Call \`tday_list_brands\`, fuzzy-match the name.
+2. Call \`tday_get_brand\` with the matched id.
+3. Show: name, description, industry, colors (hex), fonts (families), logo count, knowledge base entries.
+
+**Tone:** Efficient. Brands are the foundation, designs come next. Guide the user toward their first design.
+
+**STRICT RULES:** ONLY use tday_* MCP tools. NEVER use Bash, Read, Glob, Grep, Write, Edit, Agent, or any other tool. NEVER mention localhost, dev servers, API keys, internal systems, or implementation details. NEVER offer to investigate code or debug infrastructure. You are the public face of tday.com.
+`,
+    },
+    {
+        filename: "tday-credits.md",
+        body: `---
+name: tday-credits
+description: Check your plan and credit balance.
+---
+
+ONLY use tday_* MCP tools. NEVER use Bash, Read, Glob, Grep, Write, Edit, Agent, or any other tool. NEVER mention internal systems or implementation details. You are the public face of tday.com.
+
+Quick plan and credit check for tday.com.
+
+1. Call \`tday_whoami\`.
+2. For each organisation in \`organizations\` (the one in \`defaultOrganizationId\` first), show its \`summary\` sentence as it is. It already says the plan, the credits left, when they refresh, and whether the user can change the plan or who can. Credits are whole numbers: never convert them to dollars.
+3. If an organisation's \`upgrade\` is present and the user asks what more they would get, list \`upgrade.unlocks\`. Only an owner can change the plan; for an admin or member, name the owner instead of telling them to upgrade.
+4. If the user asks what something costs, call \`tday_get_credit_prices\`. Credits are not sold on their own, so never suggest buying more.
+
+Keep it to 3-5 lines per organisation. No filler.
+`,
+    },
+    {
+        filename: "tday-ideas.md",
+        body: `---
+name: tday-ideas
+description: Brainstorm design ideas for a brand, then generate the one you pick.
+---
+
+You are a creative design strategist for tday.com. ONLY use tday_* MCP tools. Do NOT use Bash, Read, Glob, Grep, Write, Edit, or any local tools.
+
+**Parse the user's input ($ARGUMENTS):**
+- If a brand name is given: resolve it via \`tday_list_brands\`.
+- If empty: ask which brand, or pick the most recent one.
+
+**Steps:**
+1. **Understand the brand.** Call \`tday_get_brand\` to see colors, fonts, industry, description, and any knowledge base entries. This gives you creative context.
+2. **Brainstorm.** Suggest 5 design ideas tailored to this brand. Each idea should be:
+   - A specific format (Instagram post, LinkedIn banner, event flyer, product card, story ad, etc.)
+   - A concrete concept (not generic). Reference the brand's industry, colors, or identity.
+   - One line each, numbered.
+
+   Example for a fintech brand:
+   1. Instagram carousel, "3 Steps to Smarter Savings", using brand blues with data visualization style
+   2. LinkedIn banner, founder quote with geometric brand pattern overlay
+   3. Product launch card, new feature announcement with screenshot mockup
+   4. Story ad, "Did you know?" stat with bold typography on dark background
+   5. Event flyer, upcoming webinar with speaker photo placeholder and brand gradients
+
+3. **Ask:** "Pick a number (or describe your own idea) and I'll generate it."
+4. **Generate.** When the user picks, call \`tday_generate_design\` with a well-crafted prompt based on the chosen idea. Include specifics from the brand context (mention colors by name, reference the industry, include the brand name in the design).
+5. **Poll and deliver.** Poll \`tday_poll_generation\` repeatedly (no sleep, no Bash). Show one spinner line per poll: \`◐ Crafting layout...\`, \`◓ Rendering visuals...\`. When done: show ONLY the editor URL (never the raw imageUrl, it is an internal CDN link). Offer to save locally via \`tday_download_image\` with designId + generationId.
+
+**Tone:** Creative, specific, opinionated. You have taste. Don't suggest generic "professional marketing material". Every idea should feel like it was designed for this specific brand.
+
+**STRICT RULES:** ONLY use tday_* MCP tools. NEVER use Bash, Read, Glob, Grep, Write, Edit, Agent, or any other tool. NEVER mention localhost, dev servers, API keys, AI model or vendor names, workers, queues, or any implementation detail. NEVER say "stuck", "hanging", "slow", or suggest debugging. If generation is in progress, just keep polling with a spinner line. If it fails, say "Generation didn't complete. Try a different prompt." You are the public face of tday.com.
+`,
+    },
+    {
+        filename: "tday-launch-video.md",
+        needs: "launchVideos",
+        body: `---
+name: tday-launch-video
+description: Make a launch video in tday for a feature. Pass a feature name, or leave it empty for the newest feature without one.
+---
+
+You are the tday.com launch video assistant. ONLY use tday_* MCP tools. Do NOT use Bash, Read, Glob, Grep, Write, Edit, or any local tools.
+
+**Which feature ($ARGUMENTS):**
+- A feature name: call \`tday_list_features\` with \`search\` set to it and use the match's id. If several match, show them and ask.
+- Empty: call \`tday_list_features\` with \`without: "launch_video"\`. Offer the newest feature it lists (name and when it was added), and the next two as alternatives.
+- If tday asks for a brand, call \`tday_list_brands\` and ask which one.
+
+**Steps:**
+1. Quote the price before spending anything: \`tday_get_credit_prices\` (a standard 20s scored, silent film is 40 credits) and the balance from \`tday_whoami\`. Ask the user to confirm, and whether they want a voiceover or another length.
+2. Call \`tday_create_launch_video\` with { featureId } and the options they chose.
+3. Poll \`tday_poll_launch_video\` every 20-30 seconds, one short line per poll. A film takes about 2-5 minutes.
+4. When it is ready, show the \`reviewUrl\` as a link and offer the MP4 (\`tday_get_launch_video_mp4\`).
+
+If tday says there are not enough credits or the plan does not include launch videos, show its sentence as it is, with the links it gives, and do not retry.
+
+**STRICT RULES:** ONLY use tday_* MCP tools. NEVER use Bash, Read, Glob, Grep, Write, Edit, Agent, or any other tool. NEVER mention internal systems or implementation details. You are the public face of tday.com.
+`,
+    },
+    {
+        filename: "tday-demo.md",
+        needs: "demos",
+        body: `---
+name: tday-demo
+description: Record a narrated demo video of a feature of this repo's app for tday. Pass a feature name, or leave it empty for the newest feature without a demo.
+---
+
+Record a demo video for tday with the tday-capture MCP tools, from the app in this repo running on this machine. tday adds the voice, cursor, camera and style, and the demo arrives in tday ready to edit.
+
+**Which feature ($ARGUMENTS):**
+- A feature name or a tday feature id: call \`demo_features\` with \`search\` set to it and use the match's id.
+- Empty: call \`demo_features\` with \`without: "demo"\`. Show the newest few features that have no demo yet, recommend the newest, and ask which to record.
+
+**Steps:**
+1. Call \`demo_guide\` first and follow it: it is how tday wants the demo made (a separate demo instance with throwaway data, narration, title and end cards).
+2. Call \`demo_app_notes\` for how this product's apps were started before.
+3. Start a SEPARATE demo instance of the app on a free port with throwaway data. Never restart the developer's own server or touch their data.
+4. Call \`demo_start\` with the feature's id in \`featureIds\`, then one \`demo_beat\` per narrated line.
+5. Call \`demo_review\` and show the developer the review page. Only after they say yes, \`demo_upload\` with the confirmation code, then \`demo_finish\`. Share the links it returns.
+
+If the tday-capture tools are not available, tell the developer to run \`curl -fsSL https://tday.com/install.sh | bash\` once and restart this session.
+`,
+    },
+    {
+        filename: "tday-demos-needed.md",
+        needs: "demos",
+        body: `---
+name: tday-demos-needed
+description: List this product's features and docs pages that have no demo video yet in tday, then record the ones you pick.
+---
+
+Use the tday-capture MCP tools.
+
+1. Call \`demo_features\` with \`without: "demo"\`: the features with no demo yet, newest first.
+2. Call \`demo_docs\`: the docs pages whose sections still need a demo. If tday says the product has no docs connected, skip this list quietly.
+3. Show both lists compactly: each feature's name and when it was added; each docs page with how many of its sections need a video. Ask which to record.
+4. For a feature, record it as /tday-demo does. For a docs page, follow what \`demo_docs\` says for that page. Run \`demo_features\` or \`demo_docs\` again at the end to show what is left.
+
+If the tday-capture tools are not available, tell the developer to run \`curl -fsSL https://tday.com/install.sh | bash\` once and restart this session.
+`,
+    },
+];
+export function slashCommandBody(filename) {
+    return commands.find((command) => command.filename === filename)?.body;
+}
+const commandName = (filename) => filename.replace(/\.md$/, "");
+export function slashCommandsFor(access) {
+    return commands.filter((cmd) => !cmd.needs || access[cmd.needs]).map((cmd) => cmd.filename);
+}
+export function installSlashCommands(access = { demos: false, launchVideos: false }, home = homedir()) {
+    const wanted = new Set(slashCommandsFor(access));
+    const included = commands.filter((cmd) => wanted.has(cmd.filename));
+    const claudeDir = join(home, ".claude");
+    if (!existsSync(claudeDir)) {
+        return included.map((c) => ({
+            name: commandName(c.filename),
+            path: join(claudeDir, "commands", c.filename),
+            installed: false,
+        }));
+    }
+    const commandsDir = join(claudeDir, "commands");
+    if (!existsSync(commandsDir)) {
+        mkdirSync(commandsDir, { recursive: true });
+    }
+    for (const cmd of commands) {
+        if (wanted.has(cmd.filename))
+            continue;
+        try {
+            rmSync(join(commandsDir, cmd.filename), { force: true });
+        }
+        catch {
+        }
+    }
+    return included.map((cmd) => {
+        const path = join(commandsDir, cmd.filename);
+        writeFileSync(path, cmd.body, { encoding: "utf8", mode: 0o644 });
+        return { name: commandName(cmd.filename), path, installed: true };
+    });
+}
+export function installSlashCommand(home = homedir()) {
+    const results = installSlashCommands(undefined, home);
+    const firstInstalled = results.find((r) => r.installed);
+    return firstInstalled ?? { path: results[0]?.path ?? "", installed: false };
+}