@cursor/bdk 0.2.15 → 0.2.17

package/dist/internal/convert-grokbot/answers.js

@@ -0,0 +1,443 @@
+/**
+ * Answers for `bdk init --from-grokbot`: the create-agent answers an export
+ * uses, plus the export decisions. Grok Bot collects them in chat and passes
+ * an answers file; a TTY asks the same questions with the same defaults.
+ * Answers name secrets and connectors; they never carry secret values.
+ */
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { envPrefixFromName } from "../../channels/slack/credentials.js";
+import { CLI_COMMAND_NAME } from "../distribution.js";
+import { MAX_SECRET_NAME_LENGTH, validateSettableSecretName } from "../hosting.js";
+import { AGENT_FIELDS, agentName, CHANNELS } from "../interview/agent-questions.js";
+import { checkedString, collectAnswers, field, listAnswer, } from "../interview/question.js";
+import { isRecord } from "../is-record.js";
+import { slugify } from "../slug.js";
+import { connectorUrlError, defaultSlackBotName, namespaceError, redactSecretValues, repoNameError, slackBotNameError, } from "./checks.js";
+import { formatIssues, versionSchema } from "./recipe.js";
+import { liveChannel } from "./routine.js";
+export const GROKBOT_ANSWERS_VERSION = 1;
+export const KINDS = ["skills", "routines", "plugins"];
+export const MEMORY_MODES = ["skill", "kv", "drop"];
+export const CONNECTOR_AUTH = ["cursor-account", "oauth", "secret"];
+export const DEPLOY_WHEN = ["after-review", "now", "scheduled", "never"];
+export const SLACK_APPS = ["new", "move"];
+export const SLACK_CUTOVERS = ["manual", "after-deploy", "scheduled"];
+const slug = z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "must be a lowercase slug");
+const instant = z
+    .string()
+    .datetime({ offset: true, message: "must be an ISO 8601 time with a timezone" });
+const secretName = checkedString(validateSettableSecretName);
+const slackOn = (answers) => listAnswer(answers.channels).includes("slack");
+function agentField(id) {
+    const found = AGENT_FIELDS.find((f) => f.question.id === id);
+    if (found === undefined) {
+        throw new Error(`No create-agent question "${id}".`);
+    }
+    return found;
+}
+/** Identity, surface, and item choices; recipe defaults are patched in per bot. */
+const BASE_FIELDS = [
+    agentField("name"),
+    field("identity", {
+        id: "description",
+        label: "Description",
+        prompt: "What does the bot do, in a sentence or two?",
+    }, z.string().min(1)),
+    agentField("location"),
+    agentField("model"),
+    agentField("channels"),
+    field("export", {
+        id: "memory",
+        label: "Memory",
+        prompt: "What should happen to the bot's memories?",
+        hint: "skill: a knowledge skill the agent reads on demand. kv: data in bot/lib/memory-seed.json for your own seeding code (BDK has no built-in KV seed). drop: leave them behind.",
+        choices: [...MEMORY_MODES],
+        default: "skill",
+    }, z.enum(MEMORY_MODES)),
+    ...KINDS.map((kind) => field("export", {
+        id: `${kind}.include`,
+        label: `Include ${kind}`,
+        prompt: `Which ${kind} should come along?`,
+        multi: true,
+        default: "all",
+    }, z.array(slug))),
+];
+/** One set per recipe plugin; `*` is its slug and `{plugin}` its name. */
+const CONNECTOR_FIELDS = [
+    field("export", {
+        id: "connectors.*.auth",
+        label: "Auth",
+        prompt: "How should {plugin} authenticate?",
+        hint: `cursor-account: tools run through your Cursor account's connector, with no secret in the project. oauth: host OAuth against the server URL (\`${CLI_COMMAND_NAME} mcp oauth\`). secret: a bearer token read from a named secret.`,
+        choices: [...CONNECTOR_AUTH],
+        default: "cursor-account",
+    }, z.enum(CONNECTOR_AUTH)),
+    field("export", {
+        id: "connectors.*.server",
+        label: "Connector name",
+        prompt: "Name of the {plugin} connector in your Cursor account?",
+    }, z.string().min(1)),
+    field("export", { id: "connectors.*.url", label: "Server URL", prompt: "{plugin} MCP server URL?" }, checkedString(connectorUrlError)),
+    field("export", {
+        id: "connectors.*.secret",
+        label: "Secret name",
+        prompt: "Secret that holds the {plugin} token?",
+        hint: `A name only, like LINEAR_API_KEY. Set the value later with \`${CLI_COMMAND_NAME} secrets set\`.`,
+    }, secretName),
+];
+/** One per routine placeholder; `*.*` is the routine slug and placeholder id. */
+const FILL_IN_FIELD = field("export", {
+    id: "fillIns.*.*",
+    label: "{placeholder}",
+    prompt: "{routine}: {placeholder}?",
+    optional: true,
+}, z.string().min(1));
+const DECISION_FIELDS = [
+    field("export", {
+        id: "secrets.names",
+        label: "Secret names",
+        prompt: "Other secret names to list in SECRETS.md?",
+        hint: "Names only, UPPER_SNAKE_CASE. Names the generated files read are always listed.",
+        multi: true,
+        other: true,
+        optional: true,
+    }, z.array(secretName)),
+    field("export", {
+        id: "secrets.reauth",
+        label: "Fresh sign-in",
+        prompt: "Which other connectors need a fresh sign-in?",
+        hint: "OAuth connectors always do; they are listed without asking.",
+        multi: true,
+        optional: true,
+    }, z.array(slug)),
+    field("export", {
+        id: "repo.name",
+        label: "Repository",
+        prompt: `Repository name? (recorded only; ${CLI_COMMAND_NAME} does not create repositories)`,
+        default: (answers) => answers.name?.slice(0, 100),
+    }, checkedString(repoNameError)),
+    field("export", {
+        id: "repo.namespace",
+        label: "Repository namespace",
+        prompt: "Repository owner or namespace? (recorded only)",
+        optional: true,
+    }, checkedString(namespaceError)),
+    field("export", {
+        id: "deploy.when",
+        label: "Deploy",
+        prompt: `When should it deploy? (recorded only; ${CLI_COMMAND_NAME} does not deploy)`,
+        choices: [...DEPLOY_WHEN],
+        default: "after-review",
+    }, z.enum(DEPLOY_WHEN)),
+    field("export", {
+        id: "deploy.at",
+        label: "Deploy at",
+        prompt: "Deploy at (ISO 8601 with a timezone)?",
+        when: (answers) => answers["deploy.when"] === "scheduled",
+    }, instant),
+    field("export", {
+        id: "slack.app",
+        label: "Slack app",
+        prompt: "Mint a new Slack app, or move the bot's existing one?",
+        choices: [...SLACK_APPS],
+        default: "new",
+        when: slackOn,
+    }, z.enum(SLACK_APPS)),
+    field("export", {
+        id: "slack.cutover",
+        label: "Slack cutover",
+        prompt: "When should Slack traffic switch to the BDK agent?",
+        choices: [...SLACK_CUTOVERS],
+        default: "manual",
+        when: slackOn,
+    }, z.enum(SLACK_CUTOVERS)),
+    field("export", {
+        id: "slack.cutoverAt",
+        label: "Slack cutover at",
+        prompt: "Switch Slack traffic at (ISO 8601 with a timezone)?",
+        when: (answers) => slackOn(answers) && answers["slack.cutover"] === "scheduled",
+    }, instant),
+    field("export", {
+        id: "slack.teamPrefix",
+        label: "Team prefix",
+        prompt: "Team prefix the Slack bot name must start with?",
+        optional: true,
+        when: slackOn,
+    }, z.string().min(1)),
+    field("export", {
+        id: "slack.botName",
+        label: "Slack bot name",
+        prompt: "Slack bot display name?",
+        hint: 'Starts with the team prefix and must not contain "Grok".',
+        check: (value, answers) => slackBotNameError(value, answers["slack.teamPrefix"]),
+        when: slackOn,
+    }, z.string().min(1)),
+    field("export", {
+        id: "slack.justification",
+        label: "Security justification",
+        prompt: "Security justification for the Slack app review?",
+        hint: "What the bot does in Slack and why it needs its scopes. Saved for the Slack app setup.",
+        default: (answers) => answers.description,
+        when: slackOn,
+    }, z.string().min(1)),
+];
+/** Every question an answers file can answer, in asking order. */
+const FIELDS = [
+    ...BASE_FIELDS,
+    ...CONNECTOR_FIELDS,
+    FILL_IN_FIELD,
+    ...DECISION_FIELDS,
+];
+/** Whether an item survives the include answer; an unasked include keeps everything. */
+function isSelected(answers, kind, item) {
+    const include = answers[`${kind}.include`];
+    return include === undefined || listAnswer(include).includes(item);
+}
+function exportName(name) {
+    const candidate = slugify(name, "grokbot");
+    return agentName.safeParse(candidate).success ? candidate : `${candidate}-bot`;
+}
+/** The channels the recipe's live triggers use. */
+function botChannels(bot) {
+    const used = new Set([...bot.skills, ...bot.routines].flatMap((item) => item.triggers).map(liveChannel));
+    return CHANNELS.filter((channel) => used.has(channel)).join(", ") || "none";
+}
+function defaultSecretName(plugin) {
+    const prefix = envPrefixFromName(plugin.slug).slice(0, MAX_SECRET_NAME_LENGTH - "MCP__TOKEN".length);
+    const name = `${prefix}_TOKEN`;
+    return validateSettableSecretName(name) === undefined ? name : `MCP_${name}`;
+}
+function patch(f, question) {
+    return { ...f, question: { ...f.question, ...question } };
+}
+function pluginFields(plugin) {
+    const id = (key) => `connectors.${plugin.slug}.${key}`;
+    const included = (answers) => isSelected(answers, "plugins", plugin.slug);
+    const auth = (answers) => (included(answers) ? answers[id("auth")] : undefined);
+    const patches = {
+        auth: { when: included },
+        server: { default: plugin.name, when: (answers) => auth(answers) === "cursor-account" },
+        url: { when: (answers) => auth(answers) === "oauth" || auth(answers) === "secret" },
+        secret: { default: defaultSecretName(plugin), when: (answers) => auth(answers) === "secret" },
+    };
+    return CONNECTOR_FIELDS.map((f) => {
+        const key = f.question.id.split(".").at(-1) ?? "";
+        return patch(f, {
+            id: id(key),
+            prompt: f.question.prompt.replace("{plugin}", plugin.name),
+            ...patches[key],
+        });
+    });
+}
+function fillInField(routine, fill) {
+    return patch(FILL_IN_FIELD, {
+        id: `fillIns.${routine.slug}.${fill.id}`,
+        label: fill.label,
+        prompt: `${routine.name}: ${fill.label}?`,
+        when: (answers) => isSelected(answers, "routines", routine.slug),
+    });
+}
+/** The questions for one recipe, in asking order. */
+export function grokbotFields(bot) {
+    const patches = {
+        name: { default: exportName(bot.name) },
+        description: { default: bot.description },
+        channels: { default: botChannels(bot) },
+        memory: { when: () => bot.memory.length > 0 },
+        "secrets.reauth": {
+            choices: bot.plugins.map((plugin) => ({ value: plugin.slug, label: plugin.name })),
+            when: () => bot.plugins.length > 0,
+        },
+        "slack.botName": {
+            default: (answers) => defaultSlackBotName(bot.name, answers["slack.teamPrefix"]),
+        },
+    };
+    for (const kind of KINDS) {
+        const items = bot[kind];
+        patches[`${kind}.include`] = {
+            choices: items.map((item) => ({ value: item.slug, label: item.name })),
+            when: () => items.length > 0,
+        };
+    }
+    return [
+        ...BASE_FIELDS.map((f) => patch(f, patches[f.question.id])),
+        ...bot.plugins.flatMap(pluginFields),
+        ...bot.routines.flatMap((routine) => routine.fillIns.map((fill) => fillInField(routine, fill))),
+        ...DECISION_FIELDS.map((f) => patch(f, patches[f.question.id])),
+    ];
+}
+function child(node, key) {
+    if (!Object.hasOwn(node, key)) {
+        node[key] = {};
+    }
+    return node[key];
+}
+/** Schemas nested by dotted id; a `*` segment becomes a record. */
+function shapeOf(entries) {
+    const tree = {};
+    for (const [id, schema] of entries) {
+        const path = id.split(".");
+        const leaf = path.pop() ?? id;
+        path.reduce(child, tree)[leaf] = schema;
+    }
+    return mapValues(tree, (node) => toZod(node).optional());
+}
+function toZod(node) {
+    if (node instanceof z.ZodType) {
+        return node;
+    }
+    const record = node;
+    return Object.hasOwn(record, "*")
+        ? z.record(z.string(), toZod(record["*"]))
+        : z.object(mapValues(record, (value) => toZod(value).optional())).strict();
+}
+function mapValues(record, fn) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, fn(value)]));
+}
+const EXCLUDES = KINDS.map((kind) => [`${kind}.exclude`, z.array(slug)]);
+/** An answers file: every field optional, unknown fields rejected. */
+const answersSchema = z
+    .object({
+    $schema: z.string().optional(),
+    version: versionSchema(GROKBOT_ANSWERS_VERSION),
+    ...shapeOf([...FIELDS.map((f) => [f.question.id, f.schema]), ...EXCLUDES]),
+})
+    .strict();
+export async function resolveAnswers(input) {
+    const file = answersSchema.safeParse(input.answers ?? {});
+    if (!file.success) {
+        return { ok: false, error: `Invalid answers: ${formatIssues(file.error)}` };
+    }
+    const { $schema: _schema, version: _version, ...rest } = file.data;
+    const given = foldExcludes(flatten(rest), input.bot);
+    const fields = grokbotFields(input.bot);
+    const collected = await collectAnswers({
+        questions: fields.map((f) => f.question),
+        given,
+        interactive: input.interactive,
+        ask: input.ask,
+        out: input.out,
+        show: (text) => redactSecretValues(text).text,
+        missing: (question) => `add ${question.id} to the answers file (${question.prompt})`,
+    });
+    if (!collected.ok) {
+        return collected;
+    }
+    const multi = new Set(fields.filter((f) => f.question.multi).map((f) => f.question.id));
+    const answers = answersSchema.parse({
+        version: GROKBOT_ANSWERS_VERSION,
+        ...unflatten(collected.answers, multi),
+    });
+    return {
+        ok: true,
+        answers,
+        defaulted: collected.defaulted,
+        ignored: Object.keys(given).filter((id) => !(id in collected.answers)),
+    };
+}
+/** `exclude` narrows `include` (everything when unset or `all`), so only `include` is asked. */
+function foldExcludes(given, bot) {
+    for (const kind of KINDS) {
+        const exclude = given[`${kind}.exclude`];
+        if (exclude === undefined || bot[kind].length === 0) {
+            continue;
+        }
+        const include = given[`${kind}.include`];
+        const kept = (include === undefined || include.trim() === "all"
+            ? bot[kind].map((item) => item.slug)
+            : listAnswer(include)).filter((item) => !listAnswer(exclude).includes(item));
+        delete given[`${kind}.exclude`];
+        given[`${kind}.include`] = kept.length === 0 ? "none" : kept.join(", ");
+    }
+    return given;
+}
+function flatten(value, prefix = "", out = {}) {
+    if (Array.isArray(value)) {
+        out[prefix] = value.length === 0 ? "none" : value.join(", ");
+    }
+    else if (isRecord(value)) {
+        for (const [key, nested] of Object.entries(value)) {
+            flatten(nested, prefix === "" ? key : `${prefix}.${key}`, out);
+        }
+    }
+    else if (value !== undefined) {
+        out[prefix] = String(value);
+    }
+    return out;
+}
+function unflatten(answers, multi) {
+    const out = {};
+    for (const [id, raw] of Object.entries(answers)) {
+        const path = id.split(".");
+        const leaf = path.pop() ?? id;
+        path.reduce(child, out)[leaf] = multi.has(id) ? listAnswer(raw) : raw;
+    }
+    return out;
+}
+/**
+ * JSON Schema for answers files, annotated from the questions so a chat
+ * client can render one widget per field: `title`, `description`, a static
+ * `default`, `x-labels` for choice labels, and `x-round` for the round.
+ */
+export function answersJsonSchema() {
+    const json = zodToJsonSchema(answersSchema, {
+        $refStrategy: "none",
+        target: "jsonSchema7",
+    });
+    for (const f of FIELDS) {
+        annotate(json, f.question.id.split("."), fieldMeta(f));
+    }
+    for (const kind of KINDS) {
+        annotate(json, [kind, "exclude"], {
+            title: `Exclude ${kind}`,
+            description: `Which ${kind} should stay behind, applied after the include list.`,
+            "x-round": "export",
+        });
+    }
+    annotate(json, ["$schema"], { description: "Path or URL of this schema, for editors. Ignored." });
+    annotate(json, ["version"], { description: "Answers format version." });
+    annotate(json, ["connectors"], {
+        description: "How each recipe plugin connects, keyed by plugin slug.",
+    });
+    annotate(json, ["fillIns"], {
+        description: "Values for recipe placeholders, keyed by routine slug, then placeholder id (e.g. slack_channel). Unfilled placeholders stay in the text.",
+    });
+    return {
+        $schema: json.$schema,
+        title: `${CLI_COMMAND_NAME} init --from-grokbot answers`,
+        description: "Decisions for exporting a Grok Bot recipe. Every field is optional: a missing answer takes the default an interactive run offers. Names only, never secret values.",
+        ...json,
+    };
+}
+function fieldMeta({ question, round }) {
+    const meta = {
+        title: question.label,
+        description: question.hint === undefined ? question.prompt : `${question.prompt} ${question.hint}`,
+        "x-round": round,
+    };
+    if (typeof question.default === "string" && question.default !== "all") {
+        meta.default = question.multi ? listAnswer(question.default) : question.default;
+    }
+    const labeled = (question.choices ?? []).filter((choice) => typeof choice !== "string");
+    if (labeled.length > 0) {
+        meta["x-labels"] = Object.fromEntries(labeled.map((choice) => [choice.value, choice.label]));
+    }
+    return meta;
+}
+function annotate(json, path, meta) {
+    let node = json;
+    for (const key of path) {
+        const parent = isRecord(node) ? node : {};
+        node =
+            key === "*"
+                ? parent.additionalProperties
+                : isRecord(parent.properties)
+                    ? parent.properties[key]
+                    : undefined;
+    }
+    if (!isRecord(node)) {
+        throw new Error(`The answers JSON Schema has no ${path.join(".")}.`);
+    }
+    Object.assign(node, meta);
+}

package/dist/internal/convert-grokbot/bot.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The bot a recipe describes. Slugs are claimed here once, so questions,
+ * answers, and output paths all name items the same way. Names become one
+ * printable line and prose loses unprintable characters, so recipe text is
+ * safe to show in a terminal or a list.
+ */
+import type { GrokbotRecipe } from "./recipe.js";
+import { type CronTrigger, type FillIn, type Trigger } from "./routine.js";
+export interface BotSkill {
+    slug: string;
+    name: string;
+    description: string;
+    body: string;
+    /** The skill's own schedule, when its frontmatter has one. */
+    triggers: CronTrigger[];
+}
+export interface BotRoutine {
+    slug: string;
+    name: string;
+    description: string;
+    job: string;
+    triggers: Trigger[];
+    fillIns: FillIn[];
+}
+export interface BotPlugin {
+    slug: string;
+    name: string;
+}
+export interface BotMemory {
+    kind?: string;
+    createdAt?: string;
+    content: string;
+}
+export interface Bot {
+    name: string;
+    description: string;
+    avatar?: {
+        color?: string;
+        shape?: string;
+    };
+    skills: BotSkill[];
+    routines: BotRoutine[];
+    plugins: BotPlugin[];
+    memory: BotMemory[];
+    /** Slug of the skill a new user starts with. */
+    gettingStarted?: string;
+    unknownFields: string[];
+}
+export declare function botFromRecipe(recipe: GrokbotRecipe, unknownFields?: string[]): Bot;
+//# sourceMappingURL=bot.d.ts.map

package/dist/internal/convert-grokbot/bot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../../../src/internal/convert-grokbot/bot.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,MAAM,EAGX,KAAK,OAAO,EACb,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAOD,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,aAAa,GAAE,MAAM,EAAO,GAAG,GAAG,CA6CtF"}

package/dist/internal/convert-grokbot/bot.js

@@ -0,0 +1,72 @@
+/**
+ * The bot a recipe describes. Slugs are claimed here once, so questions,
+ * answers, and output paths all name items the same way. Names become one
+ * printable line and prose loses unprintable characters, so recipe text is
+ * safe to show in a terminal or a list.
+ */
+import { parseYamlFrontmatter } from "../frontmatter.js";
+import { isRecord } from "../is-record.js";
+import { SlugRegistry, slugify } from "../slug.js";
+import { plainText, singleLine } from "./checks.js";
+import { parseRoutineContent, routineFillIns, } from "./routine.js";
+/** List answers read these as keywords, so no item slug may take them. */
+const LIST_KEYWORDS = ["all", "none"];
+/** Connection file names a plugin slug may not take. */
+const RESERVED_CONNECTIONS = ["cursor", "account"];
+export function botFromRecipe(recipe, unknownFields = []) {
+    const skillSlugs = slugRegistry();
+    const skills = recipe.skills.map((skill) => {
+        const { data, body } = parseYamlFrontmatter(skill.content);
+        const trigger = isRecord(data.trigger) ? data.trigger : {};
+        const name = singleLine(skill.name);
+        return {
+            slug: skillSlugs.claim(slugify(name, "skill")),
+            name,
+            description: plainText(skill.description),
+            body: body.trim(),
+            triggers: typeof trigger.schedule === "string"
+                ? [{ kind: "cron", cron: trigger.schedule, paused: trigger.enabled === false }]
+                : [],
+        };
+    });
+    const routineSlugs = slugRegistry();
+    const routines = recipe.routines.map((routine) => {
+        const parsed = parseRoutineContent(routine.content);
+        return {
+            slug: routineSlugs.claim(slugify(routine.slug, "routine")),
+            name: singleLine(routine.name),
+            description: plainText(routine.description),
+            job: parsed.job,
+            triggers: parsed.triggers,
+            fillIns: routineFillIns([parsed.job, routine.description], parsed.askFor),
+        };
+    });
+    const start = recipe.gettingStarted === undefined ? undefined : singleLine(recipe.gettingStarted.skill);
+    return {
+        name: singleLine(recipe.profile.name),
+        description: plainText(recipe.profile.description),
+        avatar: recipe.profile.avatarColor === undefined && recipe.profile.avatarShape === undefined
+            ? undefined
+            : { color: recipe.profile.avatarColor, shape: recipe.profile.avatarShape },
+        skills,
+        routines,
+        plugins: pluginsFrom(recipe.plugins),
+        memory: recipe.memory,
+        gettingStarted: skills.find((skill) => skill.name === start)?.slug,
+        unknownFields,
+    };
+}
+function slugRegistry(reserved = []) {
+    const slugs = new SlugRegistry();
+    for (const slug of [...LIST_KEYWORDS, ...reserved]) {
+        slugs.claim(slug);
+    }
+    return slugs;
+}
+function pluginsFrom(plugins) {
+    const slugs = slugRegistry(RESERVED_CONNECTIONS);
+    return plugins.map((plugin) => {
+        const name = singleLine(plugin.name);
+        return { slug: slugs.claim(slugify(name, "connector")), name };
+    });
+}

package/dist/internal/convert-grokbot/checks.d.ts

@@ -0,0 +1,26 @@
+/** Validation for export answers that land in names, URLs, and review text. */
+export declare const SLACK_BOT_NAME_MAX = 80;
+/** Recipe text for a name or list item: one line, nothing unprintable. */
+export declare function singleLine(text: string): string;
+/** Recipe prose: line breaks and tabs kept, anything else unprintable dropped. */
+export declare function plainText(text: string): string;
+/** Text as a markdown code span, so it reads as data; a backtick would end the span. */
+export declare function code(text: string): string;
+/**
+ * A Slack bot name starts with the team prefix and never reads as "Grok",
+ * including through separators, accents, or look-alike letters.
+ */
+export declare function slackBotNameError(name: string, teamPrefix?: string): string | undefined;
+/** The recipe name under the team prefix, or `Bot` when that name cannot pass. */
+export declare function defaultSlackBotName(name: string, teamPrefix?: string): string;
+/** Remote MCP URL: https, with credentials kept out of it. */
+export declare function connectorUrlError(url: string): string | undefined;
+export declare function repoNameError(name: string): string | undefined;
+export declare function namespaceError(name: string): string | undefined;
+export declare function redactSecretValues(text: string): {
+    text: string;
+    redacted: number;
+};
+/** Every string in a JSON-shaped value, redacted. */
+export declare function redactDeep<T>(value: T): T;
+//# sourceMappingURL=checks.d.ts.map

package/dist/internal/convert-grokbot/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../../src/internal/convert-grokbot/checks.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAI/E,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAMrC,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED,wFAAwF;AACxF,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzC;AAmCD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAmBvF;AAED,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAS7E;AA6BD,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoBjE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI9D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI/D;AAeD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAOnF;AAED,qDAAqD;AACrD,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAazC"}