@assemblyline-agents/cli 5.0.10 → 6.0.1

package/dist/add.js

@@ -1,501 +1,192 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { allAdapterProviderMetadata, allToolPackPluginMetadata, connectionPluginMetadata, PLUGIN_MANIFEST_RELATIVE_PATH, pluginModuleFromImport, providerModuleFromImport } from "@assemblyline-agents/core";
-import { detectPackageManager } from "./pm.js";
-const GATEWAY_ROLES = new Set(["deploy", "runtime", "state", "blob", "sandbox", "scheduler", "media", "secrets"]);
-/** Channel scaffold helpers, verified against each channel package's exports. */
-const CHANNEL_SCAFFOLDS = {
-    slack: { helper: "defineSlackChannel", packageName: "@assemblyline-agents/slack" },
-    discord: { helper: "defineDiscordChannel", packageName: "@assemblyline-agents/discord" },
-    telegram: { helper: "defineTelegramChannel", packageName: "@assemblyline-agents/telegram" },
-    teams: { helper: "defineTeamsChannel", packageName: "@assemblyline-agents/teams" }
-};
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { isMap, isScalar, isSeq, parseDocument } from "yaml";
+import { appendPluginSelection, runMdPluginAdd } from "./plugin-add.js";
+/** Install, inspect, lock, and select a plugin using only its own declaration. */
 export async function runAddCommand(options) {
-    const detection = detectPackageManager(options.agentRoot);
-    const pm = normalizePm(options.pmOverride) ?? detection.pm;
-    const installDir = detection.projectDir ?? process.cwd();
-    let metadata;
-    if (options.thing.includes("/")) {
-        // Scoped/path plugin package: install first, then read kind/role from its assemblyLineProvider export.
-        await installPackage(options, pm, installDir, options.thing);
-        metadata = await metadataFromPackage(options.thing, options.agentRoot, installDir, options.role);
-    }
-    else {
-        metadata = registryMetadata(options.thing, options.role);
-        if (metadata.packageName)
-            await installPackage(options, pm, installDir, metadata.packageName);
-    }
-    const outcome = wireDeclaration(metadata, options.agentRoot, installDir);
-    for (const line of outcome.lines)
-        console.log(line);
-    for (const line of copyPluginSkills(metadata, options.agentRoot, installDir))
-        console.log(line);
-    printNextSteps(metadata, options.agentRoot, pm);
-}
-function normalizePm(pmOverride) {
-    if (pmOverride === undefined)
-        return undefined;
-    if (pmOverride === "pnpm" || pmOverride === "yarn" || pmOverride === "npm")
-        return pmOverride;
-    throw new Error(`Unknown package manager "${pmOverride}". Use --pm pnpm, yarn, or npm.`);
-}
-async function installPackage(options, pm, installDir, packageName) {
-    const installCommand = `${pm} add ${packageName}`;
-    if (!options.install) {
-        console.log(`Install (skipped by --no-install): ${installCommand}`);
+    if (!existsSync(join(options.agentRoot, "agent.md"))) {
+        throw new Error(`MD-first Assembly Line requires agent.md at ${options.agentRoot}.`);
+    }
+    const added = await runMdPluginAdd({
+        thing: options.thing,
+        agentRoot: options.agentRoot,
+        pmOverride: options.pmOverride,
+        install: options.install,
+        confirmUpgrade: options.confirmUpgrade === true,
+        selectCapability: false,
+        runCommand: options.runCommand
+    });
+    if (!added)
         return;
+    const candidates = declaredSelections(added);
+    const requestedRole = normalizeRole(options.role);
+    const eligible = requestedRole ? candidates.filter((candidate) => candidate.role === requestedRole) : candidates;
+    const selected = chooseSelection(added.name, eligible, requestedRole);
+    if (selected.role === "capability") {
+        if (added.packageName)
+            appendPluginSelection(options.agentRoot, added.name);
+        else
+            console.log(`Local Agent Plugin ${added.name} is active by presence.`);
+    }
+    else if (selected.role === "media") {
+        console.log(`Locked ${added.name}. Select ${selected.name} under channels.<channel>.audio when overriding a channel default.`);
     }
-    console.log(`Installing plugin ${packageName} with ${pm} in ${installDir}.`);
-    const result = await options.runCommand(pm, ["add", packageName], { cwd: installDir });
-    if (result.exitCode !== 0) {
-        throw new Error(`"${installCommand}" failed with exit code ${result.exitCode}.`);
-    }
-}
-function registryMetadata(kind, role) {
-    const all = [...allAdapterProviderMetadata(), ...allToolPackPluginMetadata()];
-    const entries = all.filter((entry) => entry.kind === kind);
-    if (entries.length === 0) {
-        throw new Error([`Unknown plugin or adapter kind "${kind}". Available plugin contributions by role:`, ...kindsByRoleLines(all)].join("\n"));
-    }
-    if (role) {
-        const match = entries.find((entry) => entry.role === role);
-        if (!match) {
-            throw new Error(`"${kind}" has no ${role} provider. Roles for "${kind}": ${roleList(entries)}.`);
-        }
-        return match;
-    }
-    // Prefer installable entries so e.g. `add postgres` means the state package,
-    // not the package-less state-backed scheduler variant.
-    const installable = entries.filter((entry) => entry.packageName);
-    const pool = installable.length > 0 ? installable : entries;
-    const roles = [...new Set(pool.map((entry) => entry.role))];
-    if (roles.length > 1) {
-        // Without --role, `add` defaults to the agent-folder contribution — a
-        // channel scaffold first, then a connection or tool pack. Gateway slots
-        // (state, secrets, ...) offered alongside one stay reachable via --role.
-        for (const preferred of ["channel", "connection", "tools"]) {
-            const match = pool.find((entry) => entry.role === preferred);
-            if (match)
-                return match;
-        }
-    }
-    const first = pool[0];
-    if (roles.length > 1 || !first) {
-        throw new Error(`"${kind}" provides multiple roles: ${roles.join(", ")}. Pass --role <role>, e.g. assembly-line add ${kind} --role ${roles[0]}.`);
-    }
-    return first;
-}
-function roleList(entries) {
-    return [...new Set(entries.map((entry) => entry.role))].sort().join(", ");
-}
-function kindsByRoleLines(all) {
-    const byRole = new Map();
-    for (const entry of all) {
-        const kinds = byRole.get(entry.role) ?? new Set();
-        kinds.add(entry.kind);
-        byRole.set(entry.role, kinds);
-    }
-    return [...byRole.entries()]
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([role, kinds]) => `  ${role}: ${[...kinds].sort().join(", ")}`);
-}
-async function metadataFromPackage(packageName, agentRoot, installDir, role) {
-    const imported = await importPackage(packageName, [agentRoot, installDir]);
-    const pluginModule = pluginModuleFromImport(imported);
-    const pluginEntries = [
-        ...(pluginModule?.connections ?? []).map((connection) => ({
-            ...connection,
-            packageName: connection.packageName ?? packageName
-        })),
-        ...(pluginModule?.toolPacks ?? []).map((toolPack) => ({
-            ...toolPack,
-            packageName: toolPack.packageName || packageName
-        }))
-    ];
-    const providerModule = providerModuleFromImport(imported);
-    if (!providerModule && pluginEntries.length === 0) {
-        throw new Error(`Plugin package ${packageName} does not export assemblyLinePlugin or assemblyLineProvider, so its contributions cannot be determined.`);
-    }
-    const entries = [...pluginEntries, ...(providerModule?.providers ?? []).map((registration) => ({
-            ...registration.metadata,
-            packageName: registration.metadata.packageName ?? packageName
-        }))];
-    if (role) {
-        const match = entries.find((entry) => entry.role === role);
-        if (!match) {
-            throw new Error(`Package ${packageName} has no ${role} provider. Available: ${entries.map((entry) => `${entry.role}:${entry.kind}`).join(", ")}.`);
-        }
-        return match;
-    }
-    // Without --role, plugin contributions (connections, tool packs) are what
-    // `add` scaffolds; provider registrations such as gateway secrets stores
-    // stay reachable through an explicit --role.
-    const candidates = pluginEntries.length > 0 ? pluginEntries : entries;
-    const roles = [...new Set(candidates.map((entry) => entry.role))];
-    const first = candidates[0];
-    if (roles.length > 1 || !first) {
-        throw new Error(`Package ${packageName} provides multiple roles: ${[...new Set(entries.map((entry) => entry.role))].join(", ")}. Pass --role <role>.`);
-    }
-    return first;
-}
-async function importPackage(packageName, startDirs) {
-    const errors = [];
-    const specifiers = [packageName];
-    for (const dir of startDirs) {
-        try {
-            const requireFrom = createRequire(pathToFileURL(join(dir, "package.json")).href);
-            specifiers.push(pathToFileURL(requireFrom.resolve(packageName)).href);
-        }
-        catch (error) {
-            errors.push(error instanceof Error ? error.message : String(error));
-        }
-    }
-    for (const specifier of [...new Set(specifiers)]) {
-        try {
-            return await import(specifier);
-        }
-        catch (error) {
-            errors.push(error instanceof Error ? error.message : String(error));
-        }
-    }
-    throw new Error(`Failed to load plugin package ${packageName}: ${errors.join("; ")}. Install it first (or rerun without --no-install).`);
-}
-function wireDeclaration(metadata, agentRoot, installDir) {
-    if (metadata.role === "tools")
-        return wireToolPack(agentRoot, metadata);
-    if (GATEWAY_ROLES.has(metadata.role))
-        return wireGatewaySlot(agentRoot, metadata.role, metadata.kind);
-    if (metadata.role === "channel")
-        return wireChannel(agentRoot, metadata.kind, metadata.packageName, installDir);
-    if (metadata.role === "connection") {
-        const plugin = asConnectionPluginMetadata(metadata) ?? connectionPluginMetadata(metadata.kind);
-        if (plugin)
-            return wireConnection(agentRoot, plugin);
-    }
-    return {
-        lines: [
-            `${metadata.role} providers are declared in ${metadata.role}s/*.ts, so nothing was wired automatically.`,
-            `Create ${metadata.role}s/${metadata.kind}.ts using the helper exported by ${metadata.packageName ?? "the plugin package"}.`
-        ]
-    };
-}
-function wireToolPack(agentRoot, plugin) {
-    const lines = [];
-    const configPath = plugin.config ? safePluginAgentPath(plugin.config.path) : undefined;
-    if (plugin.config && configPath) {
-        const target = join(agentRoot, configPath);
-        if (existsSync(target)) {
-            lines.push(`${configPath} already exists. Leaving it unchanged.`);
-        }
-        else {
-            mkdirSync(dirname(target), { recursive: true });
-            writeFileSync(target, [
-                `import { ${plugin.config.helper} } from ${JSON.stringify(plugin.packageName)};`,
-                "",
-                `export default ${plugin.config.helper}(${JSON.stringify(plugin.config.options ?? {}, null, 2)});`,
-                ""
-            ].join("\n"));
-            lines.push(`Created ${configPath} for developer-owned ${plugin.kind} configuration.`);
-        }
-    }
-    mkdirSync(join(agentRoot, "tools"), { recursive: true });
-    for (const tool of plugin.tools) {
-        if (!/^[A-Za-z0-9_-]+$/u.test(tool.name)) {
-            throw new Error(`Tool pack ${plugin.kind} declares invalid tool name "${tool.name}".`);
-        }
-        const relativePath = `tools/${tool.name}.ts`;
-        const target = join(agentRoot, relativePath);
-        if (existsSync(target)) {
-            lines.push(`${relativePath} already exists. Leaving it unchanged.`);
+    else {
+        const changed = updateMarkdownSelection(options.agentRoot, selected);
+        console.log(changed
+            ? `Updated agent.md ${selected.role} selection to ${selected.value}.`
+            : `agent.md already selects ${selected.value} for ${selected.role}.`);
+    }
+    printRequirements(selected);
+}
+function declaredSelections(plugin) {
+    const entry = plugin.entry;
+    if (!entry)
+        return [{ role: "capability", name: plugin.name, value: plugin.name }];
+    const selections = [];
+    for (const [name, raw] of Object.entries(entry.sections.providers)) {
+        if (!isRecord(raw) || typeof raw.role !== "string")
             continue;
-        }
-        const configImport = configPath
-            ? [
-                `import config from ${JSON.stringify(`../${configPath.replace(/\.[^./]+$/u, "")}`)};`,
-                ""
-            ]
-            : [];
-        writeFileSync(target, [
-            `import { ${tool.helper} } from ${JSON.stringify(plugin.packageName)};`,
-            ...configImport,
-            `const tool = ${tool.helper}(${configPath ? "config" : ""});`,
-            "",
-            "export default {",
-            "  ...tool,",
-            `  description: ${JSON.stringify(tool.description)},`,
-            "  inputSchema: tool.inputSchema,",
-            "  outputSchema: tool.outputSchema,",
-            `  needsApproval: ${tool.needsApproval === true ? "true" : "false"}`,
-            "};",
-            ""
-        ].join("\n"));
-        lines.push(`Created ${relativePath} using ${tool.helper}().`);
-    }
-    return { lines, already: lines.every((line) => line.includes("already exists")) };
-}
-function safePluginAgentPath(path) {
-    const normalized = path.replace(/\\/gu, "/");
-    if (!normalized.startsWith("tool-config/") || normalized.split("/").includes("..")) {
-        throw new Error(`Plugin configuration path must stay below tool-config/: ${path}`);
-    }
-    return normalized;
-}
-function wireConnection(agentRoot, plugin) {
-    const relativePath = `connections/${plugin.kind}.ts`;
-    const path = join(agentRoot, relativePath);
-    if (existsSync(path))
-        return { lines: [`${relativePath} already exists. Leaving it unchanged.`], already: true };
-    mkdirSync(join(agentRoot, "connections"), { recursive: true });
-    const connectionOptions = plugin.protocol === "a2a"
-        ? [
-            '  agentCardUrl: "https://peer.example.com/.well-known/agent-card.json",',
-            '  tokenEnv: "PEER_A2A_TOKEN",'
-        ]
-        : [];
-    const accessOptions = plugin.protocol === "credential"
-        ? []
-        : [
-            "  // Reviewed tools are enabled and run without an approval surface by default.",
-            "  // Set access to \"approval-required\", \"read-only\", or a custom policy when needed."
-        ];
-    writeFileSync(path, [
-        `import { ${plugin.helper} } from "${plugin.packageName}";`,
-        "",
-        `export default ${plugin.helper}({`,
-        ...connectionOptions,
-        ...accessOptions,
-        "});",
-        ""
-    ].join("\n"));
-    const accessSummary = plugin.protocol === "credential" ? "" : " with reviewed tools enabled";
-    return { lines: [`Created ${relativePath} using ${plugin.helper}()${accessSummary}.`] };
-}
-export function copyPluginSkills(metadata, agentRoot, installDir) {
-    if (metadata.role !== "tools")
-        return [];
-    const packageName = metadata.packageName;
-    const skills = metadata.skills ?? [];
-    if (!packageName || skills.length === 0)
-        return [];
-    const packageRoot = resolvePluginPackageRoot(packageName, metadata.kind, [agentRoot, installDir]);
-    if (!packageRoot)
-        return skills.map((skill) => `Skill ${skill} will be available after ${packageName} is installed.`);
-    return skills.map((skill) => {
-        const target = join(agentRoot, "skills", skill);
-        if (existsSync(target)) {
-            return `skills/${skill}/ already exists. Leaving it unchanged.`;
-        }
-        const source = join(packageRoot, "skills", skill);
-        const bundleSkillNames = pluginBundleSkillNames(source);
-        if (!existsSync(join(source, "SKILL.md")) && bundleSkillNames.length === 0) {
-            return `Plugin ${packageName} does not include skills/${skill}/SKILL.md or a ${PLUGIN_MANIFEST_RELATIVE_PATH} skill plugin.`;
-        }
-        mkdirSync(dirname(target), { recursive: true });
-        cpSync(source, target, { recursive: true });
-        if (bundleSkillNames.length === 0)
-            return `Copied skills/${skill}/ from ${packageName}.`;
-        const collisions = bundleSkillNames.filter((name) => existsSync(join(agentRoot, "skills", name, "SKILL.md")));
-        const lines = [`Copied skill plugin skills/${skill}/ (${bundleSkillNames.length} skills) from ${packageName}.`];
-        for (const name of collisions) {
-            lines.push(`Warning: skill name "${name}" is contributed twice (skill plugin ${skill} and skills/${name}/); compilation will fail until one is removed.`);
-        }
-        return lines.join("\n");
-    });
-}
-/** Contributed skill names of a skill-plugin-shaped directory (empty for standalone skills). */
-function pluginBundleSkillNames(source) {
-    const isBundle = existsSync(join(source, PLUGIN_MANIFEST_RELATIVE_PATH)) || existsSync(join(source, "skills"));
-    if (!isBundle || existsSync(join(source, "SKILL.md")))
-        return [];
-    const nested = join(source, "skills");
-    if (!existsSync(nested))
-        return [];
-    return readdirSync(nested)
-        .filter((entry) => existsSync(join(nested, entry, "SKILL.md")))
-        .sort();
-}
-function resolvePluginPackageRoot(packageName, kind, startDirs) {
-    for (const startDir of startDirs) {
-        try {
-            // Walk up from the resolved entry to the package.json whose name matches:
-            // nested manifests (dist/cjs/package.json shims) do not mark the root.
-            let current = dirname(createRequire(pathToFileURL(join(startDir, "package.json")).href).resolve(packageName));
-            while (current !== dirname(current)) {
-                const packageJson = join(current, "package.json");
-                if (existsSync(packageJson) && packageNameAtPath(packageJson) === packageName)
-                    return current;
-                current = dirname(current);
-            }
-        }
-        catch {
-            // Try the next project root, then the monorepo fallback used by local development.
-        }
-    }
-    const packagesDir = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
-    const workspaceCandidate = join(packagesDir, kind);
-    return existsSync(join(workspaceCandidate, "package.json")) ? workspaceCandidate : undefined;
-}
-function packageNameAtPath(packageJsonPath) {
+        const selectionName = typeof raw.name === "string" ? raw.name : name;
+        const metadata = contractMetadata(raw.contract, plugin.root);
+        selections.push({ role: raw.role, name: selectionName, value: selectionName, ...(metadata ? { metadata } : {}) });
+    }
+    for (const [name, raw] of Object.entries(entry.sections.channels)) {
+        selections.push({ role: "channel", name, value: name, ...(isRecord(raw) ? { metadata: raw } : {}) });
+    }
+    for (const [name, raw] of Object.entries(entry.sections.instrumentation)) {
+        selections.push({ role: "observability", name, value: name, ...(isRecord(raw) ? { metadata: raw } : {}) });
+    }
+    for (const [name, raw] of Object.entries(entry.sections.models)) {
+        if (!isRecord(raw) || typeof raw.defaultModel !== "string") {
+            throw new Error(`Model contribution ${plugin.name}.models.${name} must declare defaultModel for CLI selection.`);
+        }
+        const metadata = contractMetadata(raw.contract, plugin.root);
+        selections.push({ role: "model", name, value: raw.defaultModel, ...(metadata ? { metadata } : {}) });
+    }
+    if (hasCapabilitySurface(entry))
+        selections.push({ role: "capability", name: plugin.name, value: plugin.name });
+    return selections.length > 0 ? selections : [{ role: "capability", name: plugin.name, value: plugin.name }];
+}
+function chooseSelection(pluginName, candidates, requestedRole) {
+    if (candidates.length === 0) {
+        throw new Error(`Plugin ${pluginName} does not contribute role ${requestedRole}. Declared roles are in its ai.assemblyline entry.`);
+    }
+    if (candidates.length === 1)
+        return candidates[0];
+    const named = candidates.filter((candidate) => candidate.name === pluginName);
+    if (named.length === 1)
+        return named[0];
+    const roles = [...new Set(candidates.map((candidate) => candidate.role))].sort();
+    throw new Error(`Plugin ${pluginName} has multiple selectable contributions (${candidates.map((candidate) => `${candidate.role}:${candidate.name}`).join(", ")}). Pass --role ${roles.join("|")}.`);
+}
+function normalizeRole(role) {
+    if (role === "channel")
+        return "channel";
+    if (role === "connection" || role === "tools" || role === "plugin")
+        return "capability";
+    return role;
+}
+function hasCapabilitySurface(entry) {
+    return ["tools", "connections", "hooks", "lifecycle", "composition"]
+        .some((section) => Object.keys(entry.sections[section]).length > 0);
+}
+function contractMetadata(value, pluginRoot) {
+    if (isRecord(value))
+        return value;
+    if (typeof value !== "string" || !value.startsWith("./") || value.includes(".."))
+        return undefined;
     try {
-        return JSON.parse(readFileSync(packageJsonPath, "utf8")).name;
+        const parsed = JSON.parse(readFileSync(resolve(pluginRoot, value), "utf8"));
+        return isRecord(parsed) ? parsed : undefined;
     }
     catch {
         return undefined;
     }
 }
-function asConnectionPluginMetadata(metadata) {
-    const candidate = metadata;
-    return candidate.role === "connection" && typeof candidate.helper === "string"
-        && (candidate.protocol === "credential" || candidate.protocol === "mcp" || candidate.protocol === "a2a" || candidate.protocol === "openapi" || candidate.protocol === "http" || candidate.protocol === "sdk" || candidate.protocol === "cli")
-        ? candidate
-        : undefined;
-}
-function wireGatewaySlot(agentRoot, role, kind) {
-    const path = join(agentRoot, "gateway.ts");
-    const snippet = `  ${role}: adapter("${kind}"),`;
-    if (!existsSync(path)) {
-        writeFileSync(path, gatewayScaffoldSource({ [role]: kind }));
-        return { lines: [`Created gateway.ts with ${role}: adapter("${kind}").`] };
-    }
+function updateMarkdownSelection(agentRoot, selection) {
+    const path = join(agentRoot, "agent.md");
     const source = readFileSync(path, "utf8");
-    const slotPattern = new RegExp(`(\\b${role}\\s*:\\s*adapter\\(\\s*)(["'])([^"']*)\\2`, "u");
-    const match = slotPattern.exec(source);
-    if (match) {
-        if (match[3] === kind) {
-            return { lines: [`gateway.ts already sets ${role}: adapter("${kind}"). Nothing to change.`], already: true };
-        }
-        writeFileSync(path, source.replace(slotPattern, `$1$2${kind}$2`));
-        return { lines: [`gateway.ts: ${role} now uses adapter("${kind}") (was "${match[3]}").`] };
-    }
-    const inserted = insertProperty(source, /defineGateway\(\s*\{/u, snippet);
-    if (inserted) {
-        writeFileSync(path, inserted);
-        return { lines: [`gateway.ts: added ${role}: adapter("${kind}").`] };
-    }
-    return manualEditOutcome("gateway.ts", "defineGateway({ ... })", snippet);
-}
-function wireChannel(agentRoot, kind, packageName, installDir) {
-    const relativePath = `channels/${kind}.ts`;
-    const path = join(agentRoot, "channels", `${kind}.ts`);
-    const scaffold = CHANNEL_SCAFFOLDS[kind];
-    if (!scaffold) {
-        return {
-            lines: [
-                `No channel scaffold is known for "${kind}", so nothing was wired automatically.`,
-                `Create ${relativePath} exporting a ChannelDefinition from ${packageName ?? "the plugin package"}.`
-            ]
-        };
-    }
-    const lines = [];
-    const channelExists = existsSync(path);
-    if (channelExists) {
-        lines.push(`${relativePath} already exists. Leaving it unchanged.`);
-    }
-    else {
-        mkdirSync(join(agentRoot, "channels"), { recursive: true });
-        writeFileSync(path, [
-            `import { ${scaffold.helper} } from "${scaffold.packageName}";`,
-            "",
-            `export default ${scaffold.helper}();`,
-            ""
-        ].join("\n"));
-        lines.push(`Created ${relativePath} using ${scaffold.helper}().`);
-    }
-    if (kind !== "slack")
-        return { lines, already: channelExists };
-    const manifestRelativePath = "slack-app-manifest.json";
-    const manifestPath = join(agentRoot, manifestRelativePath);
-    const manifestExists = existsSync(manifestPath);
-    if (manifestExists) {
-        lines.push(`${manifestRelativePath} already exists. Leaving it unchanged.`);
-    }
-    else {
-        const packageRoot = resolvePluginPackageRoot(packageName ?? scaffold.packageName, kind, [agentRoot, installDir]);
-        const templatePath = packageRoot ? join(packageRoot, "templates", "slack-app-manifest.json") : undefined;
-        if (templatePath && existsSync(templatePath)) {
-            cpSync(templatePath, manifestPath);
-            lines.push(`Created ${manifestRelativePath} from the Slack plugin's default app manifest.`);
-        }
-        else {
-            lines.push(`Slack app manifest template will be available after ${scaffold.packageName} is installed.`);
-        }
-    }
-    return { lines, already: channelExists && manifestExists };
-}
-/** Never guess when the file shape is unexpected: print the exact snippet instead. */
-function manualEditOutcome(file, callShape, snippet) {
-    return {
-        lines: [
-            `Could not confidently edit ${file}; paste this into the ${callShape} call yourself:`,
-            snippet
-        ]
-    };
-}
-/**
- * Inserts a property right after the config call's opening brace. Requires the
- * `adapter` helper to be importable from the existing @assemblyline-agents/core import;
- * returns undefined (caller prints the snippet) when either edit is unsafe.
- */
-function insertProperty(source, openPattern, propertyLine) {
-    const withImport = ensureCoreImport(source, "adapter");
-    if (!withImport)
-        return undefined;
-    const match = openPattern.exec(withImport);
-    if (!match)
+    const frontmatter = splitMarkdownFrontmatter(source);
+    const document = parseDocument(frontmatter.yaml, { uniqueKeys: true, version: "1.2" });
+    if (document.errors.length > 0 || !isMap(document.contents)) {
+        throw new Error(`agent.md frontmatter is malformed: ${document.errors.map((error) => error.message).join("; ")}`);
+    }
+    const key = selection.role === "channel" ? "channels" : selection.role;
+    const pair = mappingPair(document, key);
+    const changed = selection.role === "channel"
+        ? updateChannelNode(document, pair, selection.value)
+        : updateScalarNode(document, pair, key, selection.value);
+    if (changed)
+        writeFileSync(path, `---\n${String(document).trimEnd()}\n---${frontmatter.body}`);
+    return changed;
+}
+function updateScalarNode(document, pair, key, value) {
+    if (!pair) {
+        if (!isMap(document.contents))
+            throw new Error("agent.md frontmatter must be a mapping.");
+        document.contents.add({ key, value });
+        return true;
+    }
+    if (isScalar(pair.value) && pair.value.value === value)
+        return false;
+    pair.value = document.createNode(value);
+    return true;
+}
+function updateChannelNode(document, pair, name) {
+    if (!pair) {
+        if (!isMap(document.contents))
+            throw new Error("agent.md frontmatter must be a mapping.");
+        document.contents.add({ key: "channels", value: [name] });
+        return true;
+    }
+    if (isSeq(pair.value)) {
+        if (pair.value.items.some((item) => isScalar(item) && item.value === name))
+            return false;
+        pair.value.add(name);
+        return true;
+    }
+    if (isMap(pair.value)) {
+        if (pair.value.has(name))
+            return false;
+        pair.value.add({ key: name, value: document.createNode({}) });
+        return true;
+    }
+    throw new Error("agent.md channels must be a list or name-to-options mapping.");
+}
+function splitMarkdownFrontmatter(source) {
+    const opening = /^---[ \t]*\r?\n/u.exec(source);
+    if (!opening)
+        throw new Error("agent.md frontmatter is malformed.");
+    const remainder = source.slice(opening[0].length);
+    const closing = /^---[ \t]*(?:\r?\n|$)/mu.exec(remainder);
+    if (!closing || closing.index === undefined)
+        throw new Error("agent.md frontmatter is malformed.");
+    return { yaml: remainder.slice(0, closing.index), body: remainder.slice(closing.index + closing[0].length - (closing[0].endsWith("\n") ? 1 : 0)) };
+}
+function mappingPair(document, key) {
+    if (!isMap(document.contents))
         return undefined;
-    const index = match.index + match[0].length;
-    return `${withImport.slice(0, index)}\n${propertyLine}${withImport.slice(index)}`;
+    return document.contents.items.find((pair) => isScalar(pair.key) && pair.key.value === key);
 }
-function ensureCoreImport(source, importName) {
-    const importPattern = /import\s*\{([^}]*)\}\s*from\s*(["'])(@assemblyline-agents\/core)\2/u;
-    const match = importPattern.exec(source);
-    if (!match || match[1] === undefined)
-        return undefined;
-    const names = match[1].split(",").map((name) => name.trim()).filter(Boolean);
-    if (names.includes(importName))
-        return source;
-    return source.replace(importPattern, `import { ${[...names, importName].sort().join(", ")} } from ${match[2]}${match[3]}${match[2]}`);
-}
-function printNextSteps(metadata, agentRoot, pm) {
-    const requiredConfig = "requiredConfig" in metadata ? metadata.requiredConfig ?? [] : [];
+function printRequirements(selection) {
+    const requiredConfig = stringList(selection.metadata?.requiredConfig);
+    const optionalConfig = stringList(selection.metadata?.optionalConfig);
+    const requiredCredentials = stringList(selection.metadata?.requiredCredentials);
+    const optionalCredentials = stringList(selection.metadata?.optionalCredentials);
     if (requiredConfig.length > 0)
         console.log(`Set configuration: ${requiredConfig.join(", ")}`);
-    const optionalConfig = "optionalConfig" in metadata ? metadata.optionalConfig ?? [] : [];
     if (optionalConfig.length > 0)
         console.log(`Optional configuration: ${optionalConfig.join(", ")}`);
-    const requiredCredentials = "requiredCredentials" in metadata ? metadata.requiredCredentials ?? [] : [];
     if (requiredCredentials.length > 0)
-        console.log(`Provision credentials: ${requiredCredentials.join(", ")}`);
-    const optionalCredentials = "optionalCredentials" in metadata ? metadata.optionalCredentials ?? [] : [];
+        console.log(`Set credentials: ${requiredCredentials.join(", ")}`);
     if (optionalCredentials.length > 0)
         console.log(`Optional credentials: ${optionalCredentials.join(", ")}`);
-    for (const setup of metadata.setup ?? []) {
-        if (setup.required)
-            console.log(`Setup: ${setup.message}`);
-    }
-    const runner = pm === "pnpm" ? "pnpm assembly-line" : pm === "yarn" ? "yarn assembly-line" : "npx assembly-line";
-    console.log(`Run: ${runner} validate ${agentRoot}`);
 }
-/** The default gateway scaffold shared by `assembly-line init` and `assembly-line add`. */
-export function gatewayScaffoldSource(overrides = {}) {
-    const slots = {
-        deploy: "local",
-        runtime: "node",
-        state: "local",
-        blob: "local",
-        sandbox: "local",
-        scheduler: "local",
-        ...overrides
-    };
-    return [
-        'import { adapter, defineGateway } from "@assemblyline-agents/core";',
-        "",
-        "export default defineGateway({",
-        Object.entries(slots).map(([role, kind]) => `  ${role}: adapter("${kind}")`).join(",\n"),
-        "});",
-        ""
-    ].join("\n");
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 //# sourceMappingURL=add.js.map