@kontourai/flow-agents 0.1.1

package/build/src/runtime-adapters.js

@@ -0,0 +1,146 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readJson, relPath, writeJson } from "./lib/fs.js";
+const ASSET_CLASSES = ["flows", "skills", "docs", "adapters", "evals", "assets"];
+function assetPath(root, value) {
+    if (path.isAbsolute(value))
+        return null;
+    const resolved = path.resolve(root, value);
+    const absRoot = path.resolve(root);
+    return resolved === absRoot || resolved.startsWith(`${absRoot}${path.sep}`) ? resolved : null;
+}
+function loadKitAssets(kitRoot, sourceKind, warnings, errors) {
+    const manifestPath = path.join(kitRoot, "kit.json");
+    if (!fs.existsSync(manifestPath)) {
+        errors.push(`${kitRoot}: missing kit.json`);
+        return [];
+    }
+    let manifest;
+    try {
+        manifest = readJson(manifestPath);
+    }
+    catch (error) {
+        errors.push(`${manifestPath}: ${error.message}`);
+        return [];
+    }
+    const kitId = typeof manifest.id === "string" ? manifest.id : "";
+    const kitName = typeof manifest.name === "string" ? manifest.name : kitId;
+    if (!kitId) {
+        errors.push(`${manifestPath}: missing kit id`);
+        return [];
+    }
+    const assets = [];
+    for (const assetClass of ASSET_CLASSES) {
+        const entries = manifest[assetClass];
+        if (entries === undefined)
+            continue;
+        if (!Array.isArray(entries)) {
+            warnings.push(`${kitId}: ${assetClass} must be a list; skipping section`);
+            continue;
+        }
+        for (const entry of entries) {
+            let rel;
+            let assetId = null;
+            let description;
+            if (typeof entry === "string")
+                rel = entry;
+            else if (typeof entry === "object" && entry !== null) {
+                const record = entry;
+                rel = typeof record.path === "string" ? record.path : undefined;
+                assetId = typeof record.id === "string" ? record.id : null;
+                description = typeof record.description === "string" ? record.description : undefined;
+            }
+            if (!rel) {
+                warnings.push(`${kitId}: ${assetClass} entry missing string path`);
+                continue;
+            }
+            const source = assetPath(kitRoot, rel);
+            if (!source) {
+                warnings.push(`${kitId}: ${assetClass} asset path is not local: ${rel}`);
+                continue;
+            }
+            if (!fs.existsSync(source)) {
+                warnings.push(`${kitId}: ${assetClass} asset path is missing: ${rel}`);
+                continue;
+            }
+            assets.push({ kit_id: kitId, kit_name: kitName, asset_class: assetClass, asset_id: assetId, relative_path: rel, source_path: source, source_kind: sourceKind, description });
+        }
+    }
+    return assets;
+}
+export function readKitInventory(sourceRoot, dest) {
+    const warnings = [];
+    const errors = [];
+    const assets = [];
+    const catalogPath = path.join(sourceRoot, "kits", "catalog.json");
+    if (!fs.existsSync(catalogPath))
+        errors.push(`${catalogPath}: missing Kit Catalog`);
+    else {
+        const catalog = readJson(catalogPath);
+        const kits = catalog.kits;
+        if (Array.isArray(kits)) {
+            kits.forEach((entry, index) => {
+                const rel = typeof entry === "object" && entry !== null ? entry.path : undefined;
+                if (typeof rel !== "string") {
+                    warnings.push(`${catalogPath}: kits[${index}].path missing; skipping`);
+                    return;
+                }
+                const kitRoot = assetPath(sourceRoot, rel);
+                if (!kitRoot || !fs.existsSync(kitRoot))
+                    warnings.push(`${catalogPath}: kits[${index}].path unavailable: ${rel}`);
+                else
+                    assets.push(...loadKitAssets(kitRoot, "builtin", warnings, errors));
+            });
+        }
+    }
+    const registryPath = path.join(dest, "kits", "local", "installed-kits.json");
+    if (fs.existsSync(registryPath)) {
+        const registry = readJson(registryPath);
+        const kits = registry.kits;
+        if (Array.isArray(kits)) {
+            kits.forEach((entry) => {
+                if (typeof entry !== "object" || entry === null)
+                    return;
+                const record = entry;
+                const id = record.id;
+                if (typeof id !== "string")
+                    return;
+                const kitRoot = path.join(dest, "kits", "local", "repositories", id);
+                if (!fs.existsSync(kitRoot))
+                    warnings.push(`${id}: installed kit copy missing at ${kitRoot}; skipping`);
+                else
+                    assets.push(...loadKitAssets(kitRoot, "local", warnings, errors));
+            });
+        }
+    }
+    return { assets, warnings, errors };
+}
+function safeSegment(value) {
+    return value.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^[.-]+|[.-]+$/g, "") || "asset";
+}
+export function activateCodexLocal(sourceRoot, dest) {
+    const inventory = readKitInventory(sourceRoot, dest);
+    const runtimeDir = path.join(dest, ".flow-agents", "runtime", "codex");
+    const generated = [];
+    const skipped = [];
+    for (const asset of inventory.assets) {
+        if (asset.asset_class !== "flows") {
+            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: asset.asset_id, reason: "asset class is diagnostic-only for codex-local" });
+            continue;
+        }
+        if (!asset.asset_id) {
+            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: null, reason: "flow asset is missing an id" });
+            continue;
+        }
+        const output = path.join(runtimeDir, "flows", safeSegment(asset.kit_id), `${safeSegment(asset.asset_id)}.flow.json`);
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.copyFileSync(asset.source_path, output);
+        generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id, source_path: asset.source_path.split(path.sep).join("/") });
+    }
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    const manifest = { schema_version: "1.0", adapter: "codex-local", supported_asset_classes: ["flows"], generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
+    const manifestPath = path.join(runtimeDir, "activation.json");
+    writeJson(manifestPath, manifest);
+    generated.push({ asset_class: "activation-manifest", path: relPath(dest, manifestPath), kit_id: "runtime", asset_id: "codex-local.activation", source_path: manifestPath.split(path.sep).join("/") });
+    return { selected_adapter: "codex-local", supported_asset_classes: ["flows"], generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
+}

package/build/src/tools/build-universal-bundles.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { loadJson, readText, root, walkFiles, writeText } from "./common.js";
+const dist = process.env.FLOW_AGENTS_DIST_DIR ? path.resolve(process.env.FLOW_AGENTS_DIST_DIR) : path.join(root, "dist");
+const manifest = loadJson(path.join(root, "packaging/manifest.json"));
+const packs = loadJson(path.join(root, "packaging/packs.json"));
+const textExtensions = new Set([".css", ".html", ".js", ".json", ".md", ".sh", ".toml", ".txt", ".yaml", ".yml", ".ts"]);
+const dropDiagnostics = [];
+const printDiagnostics = !["0", "false", "no"].includes(String(process.env.FLOW_AGENTS_EXPORT_DIAGNOSTICS ?? "1").toLowerCase());
+function resetDir(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.mkdirSync(dir, { recursive: true });
+}
+function sourceRootPatterns() {
+    return manifest.source_root_aliases.map((alias) => new RegExp(alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"));
+}
+function applySubstitutions(text, substitutions) {
+    let result = text;
+    for (const item of substitutions ?? [])
+        result = result.split(item.from).join(item.to);
+    return result;
+}
+function sanitizeText(text, target, rootReplacement, proseSubstitutions = true) {
+    let result = text;
+    for (const pattern of sourceRootPatterns())
+        result = result.replace(pattern, rootReplacement);
+    if (target === "claude-code" || target === "codex")
+        result = applySubstitutions(result, manifest.target_substitutions.common);
+    if (!proseSubstitutions)
+        return result;
+    if (target === "claude-code")
+        result = applySubstitutions(result, manifest.target_substitutions.claude_code);
+    if (target === "codex")
+        result = applySubstitutions(result, manifest.target_substitutions.codex);
+    return result;
+}
+function isCodeAsset(src, relPath) {
+    return path.basename(src) === "scripts" || relPath.split(path.sep).includes("scripts");
+}
+function copyTree(src, dest, target, rootReplacement) {
+    if (!fs.existsSync(src))
+        return;
+    for (const file of walkFiles(src)) {
+        const relPath = path.relative(src, file);
+        if (path.basename(src) === "evals" && relPath.split(path.sep)[0] === "results")
+            continue;
+        const out = path.join(dest, relPath);
+        if (textExtensions.has(path.extname(file).toLowerCase())) {
+            writeText(out, sanitizeText(readText(file), target, rootReplacement, !isCodeAsset(src, relPath)));
+        }
+        else {
+            fs.mkdirSync(path.dirname(out), { recursive: true });
+            fs.copyFileSync(file, out);
+        }
+    }
+}
+function resolveSourcePath(pathText) {
+    let normalized = pathText;
+    for (const alias of manifest.source_root_aliases)
+        normalized = normalized.split(alias).join(root);
+    normalized = normalized.replace(/^~/, process.env.HOME ?? "");
+    return path.isAbsolute(normalized) ? normalized : path.join(root, normalized);
+}
+function candidatePaths(value) {
+    return value.split(/\s+/).flatMap((raw) => {
+        const part = raw.replace(/^["']|["']$/g, "");
+        if (part.includes("=")) {
+            const maybePath = part.split("=", 2)[1];
+            return maybePath.startsWith("/") ? [maybePath] : [];
+        }
+        return part.startsWith("/") ? [part] : [];
+    });
+}
+function portableAbsolutePath(value) {
+    const candidate = resolveSourcePath(value);
+    if (manifest.source_root_aliases.some((alias) => value.startsWith(alias)))
+        return fs.existsSync(candidate);
+    return fs.existsSync(candidate) && candidate.startsWith(root);
+}
+function sanitizeAgentJson(spec) {
+    const cleaned = JSON.parse(JSON.stringify(spec));
+    const agentName = String(cleaned.name ?? "unknown");
+    const resources = Array.isArray(cleaned.resources) ? cleaned.resources : [];
+    cleaned.resources = resources.filter((resource) => {
+        const source = typeof resource === "object" ? resource.source : resource;
+        if (typeof source !== "string" || !source.startsWith("file://") || source.includes("*"))
+            return true;
+        const keep = fs.existsSync(resolveSourcePath(source.slice("file://".length)));
+        if (!keep)
+            dropDiagnostics.push(`${agentName}: dropped missing resource ${source}`);
+        return keep;
+    });
+    if (cleaned.hooks && typeof cleaned.hooks === "object") {
+        const hooks = {};
+        for (const [hookName, entries] of Object.entries(cleaned.hooks)) {
+            const kept = (Array.isArray(entries) ? entries : []).filter((entry) => candidatePaths(String(entry.command ?? "")).every(portableAbsolutePath));
+            if (kept.length)
+                hooks[hookName] = kept;
+            else if (Array.isArray(entries) && entries.length)
+                dropDiagnostics.push(`${agentName}: no portable entries remain for hook ${hookName}`);
+        }
+        cleaned.hooks = hooks;
+    }
+    return cleaned;
+}
+function modelPrefix(value) {
+    if (value.startsWith("claude-opus"))
+        return "claude-opus";
+    if (value.startsWith("claude-sonnet"))
+        return "claude-sonnet";
+    return value;
+}
+function mapped(mapName, value) {
+    const map = manifest[mapName];
+    return map[modelPrefix(String(value ?? ""))] ?? map.default;
+}
+function resolveCodexModel(spec) {
+    return ["tool-agent-delegate", "tool-agent-handoff"].includes(spec.name) ? "gpt-5.4-mini" : mapped("codex_model_map", spec.model);
+}
+function normalizeCodexText(text) {
+    const replacements = { "—": "-", "–": "-", "→": "->", "←": "<-", "’": "'", "“": '"', "”": '"', "⚡": "[quick]", "🖥️": "[interactive]" };
+    let normalized = text;
+    for (const [from, to] of Object.entries(replacements))
+        normalized = normalized.split(from).join(to);
+    return normalized.normalize("NFKD").replace(/[^\x00-\x7F]/g, "");
+}
+function appendExportNote(body, note) {
+    return `${body.trimEnd()}\n\n## Export Notes\n\n${note}\n`;
+}
+function generatedAgentsSummary(agents) {
+    return agents.slice().sort((a, b) => a.name.localeCompare(b.name)).map((spec) => `- \`${spec.name}\` — ${String(spec.description ?? "").trim()}`).join("\n");
+}
+function exportRootAgentsMd(label, agents, taskDir) {
+    return `# Universal Agent Bundle (${label})\n\nThis bundle was generated from the canonical source in this repo. Treat the repo root as the source of truth and regenerate the bundle instead of editing exported agent files by hand.\n\n## Shared Conventions\n\n- \`skills/\`, \`context/\`, \`powers/\`, \`prompts/\`, \`scripts/\`, and \`evals/\` were copied from the canonical source.\n- Cross-session task artifacts should live under \`${taskDir}\`.\n- Kiro-only hook wiring was stripped from exported non-Kiro agents to keep the package portable.\n\n## Exported Agents\n\n${generatedAgentsSummary(agents)}\n`;
+}
+function exportTargetReadme(label, installHint) {
+    return `# ${label} Bundle\n\nGenerated from the canonical source in this repository.\n\n## Install\n\n\`\`\`bash\n${installHint}\n\`\`\`\n\nOptional pack filtering is available at install time with \`FLOW_AGENTS_PACKS\`.\nThe default pack is always included:\n\n\`\`\`bash\nFLOW_AGENTS_PACKS=development,knowledge ${installHint}\n\`\`\`\n\n## Contents\n\n- Harness-specific agents\n- Shared skills\n- Shared context, powers, prompts, scripts, and evals\n`;
+}
+function mapClaudeTools(allowedTools) {
+    const ordered = [];
+    for (const tool of Array.isArray(allowedTools) ? allowedTools : []) {
+        const mappedTool = manifest.tool_name_map[String(tool)];
+        if (mappedTool && !ordered.includes(mappedTool))
+            ordered.push(mappedTool);
+    }
+    return ordered.length ? ordered : ["Read", "Bash"];
+}
+function exportClaudeAgent(spec) {
+    const prompt = appendExportNote(sanitizeText(spec.prompt, "claude-code", "<bundle-root>"), "Kiro hook wiring and JSON-only runtime fields were omitted. If this agent mentions Kiro-specific scheduler or hook behavior, treat that as optional operational guidance rather than a hard dependency.");
+    return `---\nname: ${spec.name}\ndescription: ${String(spec.description ?? "").trim()}\ntools: ${JSON.stringify(mapClaudeTools(spec.allowedTools))}\nmodel: ${mapped("claude_model_map", spec.model)}\n---\n\n${prompt}`;
+}
+function codexNicknames(agentName) {
+    const base = agentName.replace(/^tool-/, "");
+    return [...new Set([agentName, base, base.replace(/[-_]/g, " ")].map((item) => item.trim()).filter(Boolean))];
+}
+function exportCodexAgent(spec) {
+    const prompt = appendExportNote(normalizeCodexText(sanitizeText(spec.prompt, "codex", "<bundle-root>")), "Exported from a Kiro agent spec. Hooks, resource auto-loading, and tool allowlists were converted into prompt guidance only. Any explicit Kiro scheduler commands are preserved as optional shell workflows.");
+    const description = normalizeCodexText(String(spec.description ?? "")).replace(/"/g, "'");
+    return `# exported from agents/${spec.name}.json\nname = "${spec.name}"\nnickname_candidates = ${JSON.stringify(codexNicknames(spec.name))}\ndescription = "${description}"\nmodel = "${resolveCodexModel(spec)}"\nmodel_reasoning_effort = "${mapped("codex_reasoning_map", spec.model)}"\ndeveloper_instructions = ${JSON.stringify(prompt)}\n`;
+}
+function tomlValue(value) {
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => tomlValue(item)).join(", ")}]`;
+    return JSON.stringify(value);
+}
+function exportCodexConfig() {
+    const lines = ["# Generated from packaging/manifest.json. Edit the manifest, not this file.", ""];
+    const settings = manifest.codex.settings ?? {};
+    for (const [key, value] of Object.entries(settings))
+        lines.push(`${key} = ${tomlValue(value)}`);
+    if (Object.keys(settings).length)
+        lines.push("");
+    if (manifest.codex.tui) {
+        lines.push("[tui]");
+        for (const [key, value] of Object.entries(manifest.codex.tui))
+            lines.push(`${key} = ${tomlValue(value)}`);
+        lines.push("");
+    }
+    lines.push("[features]");
+    for (const [key, value] of Object.entries(manifest.codex.features ?? {}))
+        lines.push(`${key} = ${tomlValue(value)}`);
+    lines.push("");
+    for (const [providerName, providerRaw] of Object.entries(manifest.codex.model_providers ?? {})) {
+        const provider = providerRaw;
+        const scalars = Object.entries(provider).filter(([, value]) => typeof value !== "object" || value === null);
+        if (scalars.length) {
+            lines.push(`[model_providers.${providerName}]`);
+            for (const [key, value] of scalars)
+                lines.push(`${key} = ${tomlValue(value)}`);
+            lines.push("");
+        }
+        for (const [childName, childRaw] of Object.entries(provider).filter(([, value]) => typeof value === "object" && value !== null)) {
+            lines.push(`[model_providers.${providerName}.${childName}]`);
+            for (const [key, value] of Object.entries(childRaw))
+                lines.push(`${key} = ${tomlValue(value)}`);
+            lines.push("");
+        }
+    }
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function exportCodexProfileConfig(profile, settings) {
+    const lines = ["# Generated from packaging/manifest.json. Edit the manifest, not this file.", ""];
+    if ("approvals_reviewer" in settings && !("approvals_reviewer" in profile))
+        lines.push(`approvals_reviewer = ${tomlValue(settings.approvals_reviewer)}`);
+    for (const [key, value] of Object.entries(profile))
+        if (typeof value !== "object" || value === null)
+            lines.push(`${key} = ${tomlValue(value)}`);
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function shellHook(command, timeout = 10, statusMessage) {
+    const hook = { type: "command", command, timeout };
+    if (statusMessage)
+        hook.statusMessage = statusMessage;
+    return hook;
+}
+function claudeTelemetry(event) {
+    return `bash -lc 'root="\${CLAUDE_PROJECT_DIR:-$(pwd)}"; node "$root/scripts/hooks/claude-telemetry-hook.js" ${event} dev'`;
+}
+function claudePolicy(event, script) {
+    return `bash -lc 'root="\${CLAUDE_PROJECT_DIR:-$(pwd)}"; node "$root/scripts/hooks/claude-hook-adapter.js" ${event} ${script.replace(/\.js$/, "")} ${script} default'`;
+}
+function codexRoot(scriptPath) {
+    return `root="\${CODEX_HOME:-}"; if [ -z "$root" ] || [ ! -f "$root/${scriptPath}" ]; then root=$(git rev-parse --show-toplevel 2>/dev/null || pwd); fi`;
+}
+function codexTelemetry(event) {
+    if (event === "PermissionRequest")
+        return `bash -lc '${codexRoot("scripts/telemetry/telemetry.sh")}; bash "$root/scripts/telemetry/telemetry.sh" permissionRequest dev'`;
+    return `bash -lc '${codexRoot("scripts/hooks/codex-telemetry-hook.js")}; node "$root/scripts/hooks/codex-telemetry-hook.js" ${event} dev'`;
+}
+function codexPolicy(script) {
+    return `bash -lc '${codexRoot("scripts/hooks/codex-hook-adapter.js")}; node "$root/scripts/hooks/codex-hook-adapter.js" ${script.replace(/\.js$/, "")} ${script} default'`;
+}
+function exportClaudeSettings() {
+    const hooks = {};
+    for (const event of ["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "PostToolUse", "Stop", "SessionEnd"]) {
+        hooks[event] = [{ hooks: [shellHook(claudeTelemetry(event), 10, "Recording Flow Agents telemetry")] }];
+    }
+    hooks.Stop.push({ hooks: [shellHook(claudePolicy("Stop", "stop-goal-fit.js"), 30, "Running Flow Agents hook policy")] });
+    hooks.UserPromptSubmit.push({ hooks: [shellHook(claudePolicy("UserPromptSubmit", "workflow-steering.js"), 30, "Running Flow Agents hook policy")] });
+    hooks.PostToolUse.push({ hooks: [shellHook(claudePolicy("PostToolUse", "quality-gate.js"), 30, "Running Flow Agents hook policy")] });
+    hooks.PreToolUse.push({ hooks: [shellHook(claudePolicy("PreToolUse", "config-protection.js"), 30, "Running Flow Agents hook policy")] });
+    return `${JSON.stringify({
+        statusLine: { type: "command", command: 'bash -lc \'root="${CLAUDE_PROJECT_DIR:-$(pwd)}"; node "$root/scripts/statusline/flow-agents-statusline.js"\'' },
+        permissions: manifest.claude_code.permissions ?? {},
+        skipDangerousModePermissionPrompt: manifest.claude_code.skipDangerousModePermissionPrompt ?? true,
+        hooks,
+    }, null, 2)}\n`;
+}
+function exportCodexHooks() {
+    const hooks = {};
+    for (const event of ["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "PostToolUse", "Stop"]) {
+        hooks[event] = [{ hooks: [shellHook(codexTelemetry(event), 10, "Recording Flow Agents telemetry")] }];
+    }
+    hooks.Stop.push({ hooks: [shellHook(codexPolicy("stop-goal-fit.js"), 30, "Running Flow Agents hook policy")] });
+    hooks.UserPromptSubmit.push({ hooks: [shellHook(codexPolicy("workflow-steering.js"), 30, "Running Flow Agents hook policy")] });
+    return `${JSON.stringify({ hooks }, null, 2)}\n`;
+}
+function copySharedContent(targetRoot, targetName, token) {
+    const dirs = [...manifest.canonical_copy_dirs];
+    if (fs.existsSync(path.join(root, "kits")) && !dirs.includes("kits"))
+        dirs.push("kits");
+    for (const dir of dirs)
+        copyTree(path.join(root, dir), path.join(targetRoot, dir), targetName, token);
+    for (const file of manifest.root_copy_files ?? []) {
+        const source = path.join(root, file);
+        if (!fs.existsSync(source))
+            throw new Error(`manifest root_copy_files entry missing: ${file}`);
+        const target = path.join(targetRoot, file);
+        if (textExtensions.has(path.extname(source).toLowerCase()))
+            writeText(target, sanitizeText(readText(source), targetName, token));
+        else {
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.copyFileSync(source, target);
+        }
+    }
+    for (const dir of manifest.optional_copy_dirs ?? [])
+        copyTree(path.join(root, dir), path.join(targetRoot, dir), targetName, token);
+    writeText(path.join(targetRoot, "build/package.json"), `${JSON.stringify({ type: "module" }, null, 2)}\n`);
+    const filterBuilt = path.join(root, "build/src/tools/filter-installed-packs.js");
+    const commonBuilt = path.join(root, "build/src/tools/common.js");
+    if (fs.existsSync(filterBuilt))
+        writeText(path.join(targetRoot, "scripts/filter-installed-packs.mjs"), readText(filterBuilt).replace("./common.js", "./common.mjs"));
+    if (fs.existsSync(commonBuilt))
+        writeText(path.join(targetRoot, "scripts/common.mjs"), readText(commonBuilt));
+    copyTree(path.join(root, "build/src"), path.join(targetRoot, "build/src"), targetName, token);
+}
+function installScript(label, defaultDestDisplay, token, destFallbackShell) {
+    const replaceBlock = token ? `\nexport DEST\nfind "$DEST" -type f \\( -name '*.json' -o -name '*.md' -o -name '*.sh' -o -name '*.js' -o -name '*.ts' -o -name '*.yaml' -o -name '*.yml' \\) -print0 | xargs -0 perl -0pi -e 's#${token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}#$ENV{DEST}#g'` : "";
+    const destFallback = destFallbackShell ? `\nif [[ -z "$DEST" ]]; then\n  DEST="${destFallbackShell}"\nfi` : "";
+    const destRequired = !destFallbackShell;
+    const requiredCheck = destRequired ? `if [[ -z "$DEST" ]]; then\n  usage\n  exit 2\nfi\n` : "";
+    const usageDest = destRequired ? "/path/to/workspace" : defaultDestDisplay;
+    return `#!/usr/bin/env bash\nset -euo pipefail\n\nusage() {\n  cat >&2 <<'EOF'\nusage: bash install.sh ${usageDest} [options]\n\nOptions:\n  --telemetry-sink NAME   local-files, local-kontour-console,\n                          kontour-hosted-console, user-hosted-console,\n                          or legacy aliases. May be repeated.\n  --console-url URL       Persist Console telemetry base URL.\n  --console-endpoint URL  Persist full Console telemetry records endpoint URL.\n  --console-token-file PATH\n                          Read Console telemetry bearer token from a file.\n  --console-tenant ID     Persist Console tenant identifier.\nEOF\n}\n\nDEST=""\nDEST_SET=0\nCONSOLE_CONFIG_ARGS=()\nwhile [[ $# -gt 0 ]]; do\n  case "$1" in\n    --telemetry-sink|--telemetry-sinks|--console-url|--console-endpoint|--console-endpoint-url|--console-token-file|--console-tenant|--console-tenant-id)\n      [[ $# -ge 2 ]] || { echo "install.sh: $1 requires a value" >&2; exit 2; }\n      CONSOLE_CONFIG_ARGS+=("$1" "$2")\n      shift 2\n      ;;\n    --help|-h)\n      usage\n      exit 0\n      ;;\n    -*)\n      echo "install.sh: unknown option: $1" >&2\n      usage\n      exit 2\n      ;;\n    *)\n      if [[ "$DEST_SET" -eq 1 ]]; then\n        echo "install.sh: unexpected argument: $1" >&2\n        usage\n        exit 2\n      fi\n      DEST="$1"\n      DEST_SET=1\n      shift\n      ;;\n  esac\ndone${destFallback}\n${requiredCheck}SRC="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"\n\nmkdir -p "$DEST"\nrsync -a ${token ? "--delete " : ""}"$SRC"/ "$DEST"/\nif [[ -n "\${FLOW_AGENTS_PACKS:-}" ]]; then\n  node "$DEST/scripts/filter-installed-packs.mjs" "$DEST" --packs "$FLOW_AGENTS_PACKS"\nfi${replaceBlock}\nif [[ \${#CONSOLE_CONFIG_ARGS[@]} -gt 0 || -n "\${FLOW_AGENTS_TELEMETRY_SINK:-}" || -n "\${FLOW_AGENTS_TELEMETRY_SINKS:-}" || -n "\${FLOW_AGENTS_CONSOLE_URL:-}" || -n "\${CONSOLE_TELEMETRY_URL:-}" || -n "\${CONSOLE_URL:-}" || -n "\${FLOW_AGENTS_CONSOLE_TOKEN_FILE:-}" || -n "\${CONSOLE_TELEMETRY_TOKEN_FILE:-}" ]]; then\n  bash "$DEST/scripts/telemetry/install-console-config.sh" "$DEST/scripts/telemetry/telemetry.conf" "\${CONSOLE_CONFIG_ARGS[@]}"\nfi\necho "Installed ${label} bundle ${token ? "to" : "into"} $DEST"\n`;
+}
+function buildBase(agents) {
+    const bundle = path.join(dist, "base");
+    resetDir(bundle);
+    copySharedContent(bundle, "base", "<bundle-root>");
+    writeText(path.join(bundle, ".flow-agents", ".gitkeep"), "");
+    writeText(path.join(bundle, "AGENTS.md"), exportRootAgentsMd("Base", agents, ".flow-agents"));
+    writeText(path.join(bundle, "README.md"), exportTargetReadme("Base", "bash install.sh /path/to/workspace"));
+    writeText(path.join(bundle, "install.sh"), installScript("Base", "/path/to/workspace"));
+    fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
+}
+function buildKiro(agents) {
+    const bundle = path.join(dist, "kiro");
+    const token = manifest.kiro.path_token;
+    resetDir(bundle);
+    copySharedContent(bundle, "kiro", token);
+    for (const spec of agents)
+        writeText(path.join(bundle, "agents", `${spec.name}.json`), sanitizeText(`${JSON.stringify(sanitizeAgentJson(spec), null, 2)}\n`, "kiro", token));
+    writeText(path.join(bundle, "AGENTS.md"), exportRootAgentsMd("Kiro", agents, ".flow-agents"));
+    writeText(path.join(bundle, "README.md"), exportTargetReadme("Kiro", "bash install.sh $HOME/.flow-agents"));
+    writeText(path.join(bundle, "install.sh"), installScript("Kiro", "$HOME/.flow-agents", token, '${FLOW_AGENTS_DEST:-$HOME/.flow-agents}'));
+    fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
+}
+function buildClaudeCode(agents) {
+    const bundle = path.join(dist, "claude-code");
+    resetDir(bundle);
+    copySharedContent(bundle, "claude-code", "<bundle-root>");
+    writeText(path.join(bundle, manifest.claude_code.task_dir, ".gitkeep"), "");
+    for (const spec of agents)
+        writeText(path.join(bundle, ".claude/agents", `${spec.name}.md`), exportClaudeAgent(spec));
+    for (const skill of fs.readdirSync(path.join(root, "skills"))) {
+        const skillPath = path.join(root, "skills", skill, "SKILL.md");
+        if (fs.existsSync(skillPath))
+            writeText(path.join(bundle, ".claude/skills", skill, "SKILL.md"), sanitizeText(readText(skillPath), "claude-code", "<bundle-root>"));
+    }
+    writeText(path.join(bundle, ".claude/settings.json"), exportClaudeSettings());
+    writeText(path.join(bundle, "AGENTS.md"), exportRootAgentsMd("Claude Code", agents, manifest.claude_code.task_dir));
+    writeText(path.join(bundle, "README.md"), exportTargetReadme("Claude Code", "bash install.sh /path/to/workspace"));
+    writeText(path.join(bundle, "install.sh"), installScript("Claude Code", "/path/to/workspace"));
+    fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
+}
+function buildCodex(agents) {
+    const bundle = path.join(dist, "codex");
+    const excluded = new Set(manifest.codex.excluded_agents ?? []);
+    const targetAgents = agents.filter((spec) => !excluded.has(spec.name));
+    resetDir(bundle);
+    copySharedContent(bundle, "codex", "<bundle-root>");
+    writeText(path.join(bundle, manifest.codex.task_dir, ".gitkeep"), "");
+    writeText(path.join(bundle, ".codex/config.toml"), exportCodexConfig());
+    const settings = manifest.codex.settings ?? {};
+    for (const [profileName, profile] of Object.entries(manifest.codex.profiles ?? {}))
+        writeText(path.join(bundle, ".codex", `${profileName}.config.toml`), exportCodexProfileConfig(profile, settings));
+    writeText(path.join(bundle, ".codex/hooks.json"), exportCodexHooks());
+    for (const spec of targetAgents)
+        writeText(path.join(bundle, ".codex/agents", `${spec.name}.toml`), exportCodexAgent(spec));
+    for (const skill of fs.readdirSync(path.join(root, "skills"))) {
+        const skillPath = path.join(root, "skills", skill, "SKILL.md");
+        if (fs.existsSync(skillPath))
+            writeText(path.join(bundle, ".codex/skills", skill, "SKILL.md"), sanitizeText(readText(skillPath), "codex", "<bundle-root>"));
+    }
+    writeText(path.join(bundle, "AGENTS.md"), exportRootAgentsMd("Codex", targetAgents, manifest.codex.task_dir));
+    writeText(path.join(bundle, "README.md"), exportTargetReadme("Codex", "bash install.sh /path/to/workspace"));
+    writeText(path.join(bundle, "install.sh"), installScript("Codex", "/path/to/workspace"));
+    fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
+}
+function buildCatalog(agents) {
+    const kitsCatalog = path.join(root, "kits/catalog.json");
+    return {
+        source_root: ".",
+        agents: agents.slice().sort((a, b) => a.name.localeCompare(b.name)).map((spec) => spec.name),
+        skills: fs.readdirSync(path.join(root, "skills")).filter((name) => fs.existsSync(path.join(root, "skills", name, "SKILL.md"))).sort(),
+        powers: fs.readdirSync(path.join(root, "powers")).filter((name) => fs.existsSync(path.join(root, "powers", name, "mcp.json"))).sort(),
+        packs: packs.packs ?? [],
+        kits: fs.existsSync(kitsCatalog) ? loadJson(kitsCatalog).kits ?? [] : [],
+    };
+}
+export function main() {
+    fs.mkdirSync(dist, { recursive: true });
+    const agents = fs.readdirSync(path.join(root, "agents")).filter((name) => name.endsWith(".json")).sort().map((name) => loadJson(path.join(root, "agents", name)));
+    buildBase(agents);
+    buildKiro(agents);
+    buildClaudeCode(agents);
+    buildCodex(agents);
+    writeText(path.join(dist, "catalog.json"), `${JSON.stringify(buildCatalog(agents), null, 2)}\n`);
+    writeText(path.join(dist, "README.md"), "# Universal Bundles\n\nRun `npm run build:bundles` from the repo root to regenerate these bundles.\n");
+    console.log("Built bundles:");
+    console.log(" - dist/base");
+    console.log(" - dist/kiro");
+    console.log(" - dist/claude-code");
+    console.log(" - dist/codex");
+    if (printDiagnostics && dropDiagnostics.length) {
+        console.error("Export sanitization diagnostics:");
+        for (const item of dropDiagnostics)
+            console.error(` - ${item}`);
+    }
+    return 0;
+}
+if (import.meta.url === `file://${process.argv[1]}`)
+    process.exit(main());

package/build/src/tools/common.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function findRoot(start) {
+    let current = start;
+    for (;;) {
+        if (fs.existsSync(path.join(current, "package.json")) && fs.existsSync(path.join(current, "packaging")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return start;
+        current = parent;
+    }
+}
+export const root = findRoot(path.dirname(fileURLToPath(import.meta.url)));
+export function rel(file) {
+    const relative = path.relative(root, file).split(path.sep).join("/");
+    return relative.startsWith("..") ? file.split(path.sep).join("/") : relative || ".";
+}
+export function readText(file) {
+    return fs.readFileSync(file, "utf8");
+}
+export function writeText(file, text) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text, "utf8");
+}
+export function loadJson(file) {
+    return JSON.parse(readText(file));
+}
+export function exists(file) {
+    return fs.existsSync(file);
+}
+export function walkFiles(dir) {
+    if (!exists(dir))
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...walkFiles(full));
+        else if (entry.isFile())
+            out.push(full);
+    }
+    return out;
+}
+export function oneLine(value, limit = 240) {
+    const compact = value.replace(/\s+/g, " ").trim();
+    return compact.length <= limit ? compact : `${compact.slice(0, limit - 3).trimEnd()}...`;
+}
+export function markdownTable(headers, rows) {
+    return [
+        `| ${headers.join(" | ")} |`,
+        `| ${headers.map(() => "---").join(" | ")} |`,
+        ...rows.map((row) => `| ${row.map((cell) => cell.replace(/\n/g, " ")).join(" | ")} |`),
+    ];
+}