@vibesdotdev/external 0.0.0-stage → 1.0.0-rc.0

package/dist/presets/executor.js

@@ -0,0 +1,629 @@
+/**
+ * Recipe Executor
+ *
+ * Executes preset recipes step-by-step, handling file operations,
+ * command execution, hook installation, and MCP configuration.
+ *
+ * Files are read and written through the handed runtime's filesystem and
+ * commands run through its execution kind as argv (no shell). A step that
+ * fails reports it once: `success: false`, a value-free `error` line (a
+ * CapabilityError's own message, else the failure's class name and code)
+ * and the `failure` facts; a raw error message never reaches the result.
+ */
+import * as z from 'zod/v4';
+import { dirname, isAbsolute, join } from '@vibesdotdev/filesystem';
+import { CapabilityError, CaughtFailureSchema, isCapabilityError, valueFreeFailure } from '@vibesdotdev/kernel';
+import { runCapture } from '@vibesdotdev/kernel/execution';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import { getPathRoots } from '@vibesdotdev/paths';
+import { redactCredentials } from '@vibesdotdev/shared/utils';
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import { resolveExternalCommand } from "../detection/command-probe.js";
+import { parseHostConfig } from "../detection/config-document.js";
+import { runAdapterCodegen } from "../pack/adapter-codegen.js";
+import { parseTomlDocument } from "../utils/toml.js";
+import { externalFileSystem, readTextIfPresent, setFileMode } from "../utils/runtime-fs.js";
+import { backupFiles, describeRestoreError, restoreFiles } from "./file-backup.js";
+import { resolveExternalHostImplementation } from "../external-tool/runtime.js";
+import { resolveExternalSessionId } from "../session-capability.js";
+import { isConfigObject, ownValue, setOwn } from "../plugins/installers/config-value.js";
+import { ExternalOperationDescriptorSchema, resolveExternalRuntimeServices } from "../runtime.js";
+/** Why a command step inherits the user's environment. */
+const COMMAND_INHERIT_REASON = 'A preset command step runs a host tool in the user environment it configures.';
+/** The most command output a step's message carries. */
+const COMMAND_OUTPUT_EXCERPT = 2048;
+// Failure reporting
+/** One line naming a failure without its value: a CapabilityError's message, else class name and code. */
+function failureText(failure) {
+    if (failure instanceof Error && isCapabilityError(failure))
+        return failure.message;
+    const facts = valueFreeFailure(failure);
+    return facts.code ? `${facts.name} (${facts.code})` : facts.name;
+}
+function refusal(message, reason, details) {
+    const options = { reason, retryable: false };
+    if (details !== undefined)
+        options.details = details;
+    return new CapabilityError(message, 'INVALID_INPUT', options);
+}
+// Variable Interpolation
+function interpolate(template, variables) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => Object.hasOwn(variables, key) ? (variables[key] ?? match) : match);
+}
+/**
+ * A recipe path: `~` is the runtime's `paths/roots` user home, and a relative
+ * path is the recipe's project directory, never the executable's cwd.
+ */
+function expandPath(path, ctx) {
+    if (path.startsWith('~')) {
+        return join(getPathRoots(ctx.runtime).userHome, path.slice(1));
+    }
+    return isAbsolute(path) ? path : join(ctx.projectDir, path);
+}
+// Step Executors
+async function executeFileWrite(step, ctx) {
+    const path = expandPath(interpolate(step.path, ctx.variables), ctx);
+    const content = interpolate(step.content, ctx.variables);
+    if (ctx.dryRun) {
+        return { step: 0, type: 'file-write', success: true, message: `Would write ${path}`, filesCreated: [path], skipped: false };
+    }
+    try {
+        const fs = await externalFileSystem(ctx.runtime);
+        if (!step.overwrite && (await fs.exists(path))) {
+            return { step: 0, type: 'file-write', success: true, message: `File exists, skipping: ${path}`, skipped: true };
+        }
+        if (step.createDirs)
+            await fs.mkdir(dirname(path), { recursive: true });
+        await fs.writeFile(path, content, 'utf-8');
+        if (step.mode !== undefined)
+            await setFileMode(ctx.runtime, path, step.mode);
+        return { step: 0, type: 'file-write', success: true, message: `Created ${path}`, filesCreated: [path] };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'file-write', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function readEditTarget(fs, path, format) {
+    if (format === 'yaml') {
+        throw new CapabilityError('A yaml file-edit step cannot run: External declares no YAML parser.', 'UNAVAILABLE', {
+            reason: 'host-config-format-unsupported',
+            retryable: false,
+            details: { path, format }
+        });
+    }
+    const content = (await readTextIfPresent(fs, path)) ?? '';
+    return { content, document: content ? parseHostConfig(content, path, format) : {} };
+}
+async function executeFileEdit(step, ctx) {
+    const path = expandPath(interpolate(step.path, ctx.variables), ctx);
+    if (ctx.dryRun) {
+        return { step: 0, type: 'file-edit', success: true, message: `Would edit ${path}`, filesModified: [path], skipped: false };
+    }
+    try {
+        const fs = await externalFileSystem(ctx.runtime);
+        // Every input is parsed before anything is written.
+        const existing = await readEditTarget(fs, path, step.format);
+        const updated = step.format === 'json'
+            ? JSON.stringify(deepMerge(existing.document, step.merge, step.arrayStrategy), null, 2)
+            : mergeTomlDocument(existing.content, materializeTomlPatch(existing.document, step.merge, step.arrayStrategy));
+        if (step.format === 'toml')
+            parseTomlDocument(updated);
+        await fs.mkdir(dirname(path), { recursive: true });
+        await fs.writeFile(path, updated, 'utf-8');
+        return { step: 0, type: 'file-edit', success: true, message: `Updated ${path}`, filesModified: [path] };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'file-edit', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function executeCommand(step, ctx) {
+    const command = interpolate(step.command, ctx.variables);
+    const args = step.args.map((a) => interpolate(a, ctx.variables));
+    if (ctx.dryRun) {
+        return { step: 0, type: 'command', success: true, message: `Would run: ${command} ${args.join(' ')}` };
+    }
+    let exitCode;
+    let output;
+    try {
+        const captureOptions = {
+            envMode: 'inherit',
+            inheritReason: COMMAND_INHERIT_REASON,
+            cwd: step.cwd ? expandPath(step.cwd, ctx) : ctx.projectDir
+        };
+        if (step.env)
+            captureOptions.env = step.env;
+        const result = await runCapture(ctx.runtime, command, args, captureOptions);
+        exitCode = result.exitCode;
+        output = step.silent ? '' : redactCredentials(`${result.stdout}${result.stderr}`).slice(-COMMAND_OUTPUT_EXCERPT);
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        if (step.allowFailure) {
+            return {
+                step: 0,
+                type: 'command',
+                success: true,
+                message: `Command failed (allowed): ${failureText(failure)}`,
+                failure: valueFreeFailure(failure)
+            };
+        }
+        return { step: 0, type: 'command', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+    if (exitCode === 0 || step.allowFailure) {
+        return { step: 0, type: 'command', success: true, message: output ? `Executed: ${command}\n${output}` : `Executed: ${command}` };
+    }
+    return { step: 0, type: 'command', success: false, error: `Command failed with code ${exitCode}` };
+}
+async function executeHookInstall(step, ctx) {
+    if (ctx.dryRun) {
+        return { step: 0, type: 'hook-install', success: true, message: `Would install hooks: ${step.hooks.join(', ')}` };
+    }
+    try {
+        const externalHost = await resolveExternalHostImplementation(ctx.runtime, step.target);
+        const result = await externalHost.installHooks({
+            projectDir: ctx.projectDir,
+            global: step.global ?? ctx.global,
+            vibesPath: interpolate(step.vibesPath, ctx.variables),
+            dryRun: false,
+            hooks: step.hooks
+        });
+        return {
+            step: 0,
+            type: 'hook-install',
+            success: result.success,
+            message: result.message,
+            error: result.error,
+            failure: result.failure,
+            filesModified: result.registeredSettings ? [result.registeredSettings] : undefined
+        };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'hook-install', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+/** The answer of a provider operation, read field by field: one malformed field never hides the others. */
+const OperationOptionsSchema = z.record(z.string(), JsonValueSchema);
+const OperationAnswerSchema = z.object({
+    status: z.string().optional().catch(undefined),
+    ok: z.boolean().optional().catch(undefined),
+    message: z.string().optional().catch(undefined),
+    changes: z
+        .array(z.object({ path: z.string().optional().catch(undefined) }).catch({}))
+        .optional()
+        .catch(undefined)
+});
+const ExternalOperationImplementationSchema = z.custom((value) => value instanceof Object && 'execute' in value && Object(value).execute instanceof Function);
+async function executeOperation(step, ctx) {
+    try {
+        const candidate = ctx.runtime.query('external/operation').withId(step.operationId).descriptors()[0];
+        if (candidate === undefined) {
+            throw new CapabilityError('The external operation is not registered.', 'NOT_FOUND', {
+                reason: 'external-operation-unregistered',
+                retryable: false,
+                details: { operationId: step.operationId }
+            });
+        }
+        const descriptor = ExternalOperationDescriptorSchema.parse(candidate);
+        if (descriptor.hostId !== ctx.target) {
+            throw refusal('The external operation belongs to another host.', 'external-operation-host-mismatch', {
+                operationId: step.operationId,
+                hostId: descriptor.hostId,
+                target: ctx.target
+            });
+        }
+        const implementation = ExternalOperationImplementationSchema.safeParse(await ctx.runtime.query('external/operation').withId(step.operationId).resolve());
+        if (!implementation.success) {
+            throw refusal('The external operation implementation has no execute().', 'external-operation-invalid', {
+                operationId: step.operationId
+            });
+        }
+        const rawOptions = { ...step.options, global: ctx.global, dryRun: ctx.dryRun };
+        const definedOptions = Object.fromEntries(Object.entries(rawOptions).filter(([, value]) => value !== undefined));
+        const parsedOptions = OperationOptionsSchema.safeParse(definedOptions);
+        if (!parsedOptions.success) {
+            throw refusal('The external operation options are not JSON values.', 'external-operation-options-invalid', {
+                operationId: step.operationId
+            });
+        }
+        const answer = OperationAnswerSchema.safeParse(await implementation.data.execute({ arguments: {}, options: parsedOptions.data }, ctx, await resolveExternalRuntimeServices(ctx.runtime)));
+        if (!answer.success) {
+            throw refusal('The external operation answered with no result object.', 'external-operation-answer-invalid', {
+                operationId: step.operationId
+            });
+        }
+        const value = answer.data;
+        return {
+            step: 0,
+            type: 'operation',
+            success: value.status !== 'error' && value.ok !== false,
+            message: value.message ?? `Executed ${step.operationId}`,
+            filesModified: (value.changes ?? []).flatMap((change) => (change.path === undefined ? [] : [change.path]))
+        };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'operation', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function executeFileBackup(step, ctx) {
+    const baseDir = expandPath(interpolate(step.baseDir, ctx.variables), ctx);
+    const files = step.files.map((f) => interpolate(f, ctx.variables));
+    if (ctx.dryRun) {
+        return { step: 0, type: 'file-backup', success: true, message: `Would backup ${files.join(', ')} under ${baseDir}`, skipped: false };
+    }
+    try {
+        const result = await backupFiles({
+            fs: await externalFileSystem(ctx.runtime),
+            baseDir,
+            files,
+            backupDirName: step.backupDirName,
+            dryRun: false
+        });
+        if (!result) {
+            return { step: 0, type: 'file-backup', success: true, message: `No existing files to backup under ${baseDir}`, skipped: true };
+        }
+        if (step.variable)
+            ctx.variables[step.variable] = result.backupDir;
+        return {
+            step: 0,
+            type: 'file-backup',
+            success: true,
+            message: `Backed up ${result.backedUpFiles.length} file(s) to ${result.backupDir}`,
+            filesCreated: [result.backupDir]
+        };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'file-backup', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function executeFileRestore(step, ctx) {
+    const baseDir = expandPath(interpolate(step.baseDir, ctx.variables), ctx);
+    const backupDir = step.backupDir ? expandPath(interpolate(step.backupDir, ctx.variables), ctx) : undefined;
+    const backupTimestamp = step.backupTimestamp ? interpolate(step.backupTimestamp, ctx.variables) : undefined;
+    if (ctx.dryRun) {
+        return {
+            step: 0,
+            type: 'file-restore',
+            success: true,
+            message: `Would restore into ${baseDir} from ${backupDir ?? backupTimestamp ?? 'latest'}`,
+            skipped: false
+        };
+    }
+    try {
+        const result = await restoreFiles({
+            fs: await externalFileSystem(ctx.runtime),
+            baseDir,
+            backupDir,
+            backupTimestamp,
+            backupDirName: step.backupDirName,
+            files: step.files,
+            dryRun: false
+        });
+        const errors = result.errors.map(describeRestoreError).join('; ');
+        if (result.errors.length > 0 && result.restored.length === 0) {
+            return { step: 0, type: 'file-restore', success: false, error: errors };
+        }
+        return {
+            step: 0,
+            type: 'file-restore',
+            success: true,
+            message: `Restored ${result.restored.length} file(s) from ${result.backupDir}`,
+            filesModified: result.restored.map((f) => join(baseDir, f)),
+            error: result.errors.length > 0 ? errors : undefined
+        };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'file-restore', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function executeAdapterCodegen(step, ctx) {
+    try {
+        const externalHost = await resolveExternalHostImplementation(ctx.runtime, ctx.target);
+        const result = await runAdapterCodegen(ctx.runtime, {
+            adapterId: step.adapterId,
+            projectDir: ctx.projectDir,
+            outputDir: step.outputDir,
+            tier: step.tier,
+            global: step.global,
+            dryRun: ctx.dryRun,
+            manifest: externalHost.manifest,
+            hostId: ctx.target,
+            // Comes from the execution context, never from the recipe step:
+            // tool→skill projection is retired and only an explicit
+            // `--include-tools` request may re-enable it.
+            includeTools: ctx.includeTools
+        });
+        return {
+            step: 0,
+            type: 'adapter-codegen',
+            success: result.success,
+            message: result.message,
+            filesCreated: result.outputPath ? [result.outputPath] : undefined
+        };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'adapter-codegen', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function executeMcpConfigure(step, ctx) {
+    if (ctx.dryRun) {
+        return { step: 0, type: 'mcp-configure', success: true, message: `Would configure MCP server: ${step.serverName}` };
+    }
+    try {
+        const externalHost = await resolveExternalHostImplementation(ctx.runtime, step.target);
+        const argumentValue = (flag) => {
+            const exactIndex = step.args.indexOf(flag);
+            if (exactIndex >= 0 && exactIndex + 1 < step.args.length)
+                return step.args[exactIndex + 1];
+            return step.args.find((argument) => argument.startsWith(`${flag}=`))?.slice(flag.length + 1);
+        };
+        // The provider-owned recipe declares the MCP catalog explicitly. `--client`
+        // is a legacy host selector, not a catalog declaration; host identity comes
+        // from the resolved external/host descriptor instead of an alias table.
+        const result = await externalHost.installMcp({
+            projectDir: ctx.projectDir,
+            global: step.global ?? ctx.global,
+            vibesPath: ctx.vibesPath,
+            dryRun: ctx.dryRun,
+            tier: step.tier,
+            mcpClientId: argumentValue('--preset')
+        });
+        return {
+            step: 0,
+            type: 'mcp-configure',
+            success: result.success,
+            message: result.message,
+            error: result.error,
+            filesCreated: result.filesCreated,
+            filesModified: result.filesModified
+        };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'mcp-configure', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+}
+async function executePrompt(step, ctx) {
+    // In non-interactive mode or dry run, use defaults
+    if (ctx.dryRun || step.default) {
+        if (step.variable && step.default)
+            ctx.variables[step.variable] = step.default;
+        return { step: 0, type: 'prompt', success: true, message: `Using default: ${step.default || 'yes'}`, skipped: ctx.dryRun };
+    }
+    // Automated execution skips prompts; an interactive UI would ask here.
+    return { step: 0, type: 'prompt', success: true, message: 'Prompt skipped (non-interactive)', skipped: true };
+}
+/** Whether a validate check holds. A check that cannot be answered throws, and the step reports that failure. */
+async function checkHolds(check, target, ctx) {
+    switch (check) {
+        case 'tool-installed':
+        case 'command-available':
+            if (!target)
+                throw refusal('This validate check needs a target.', 'validate-target-required', { check });
+            return (await resolveExternalCommand(ctx.runtime, target)) !== null;
+        case 'file-exists':
+            if (!target)
+                throw refusal('This validate check needs a target.', 'validate-target-required', { check });
+            return (await externalFileSystem(ctx.runtime)).exists(expandPath(target, ctx));
+        case 'session-active':
+            return (await resolveExternalSessionId(ctx.runtime)) !== undefined;
+        case 'vibes-authenticated': {
+            const account = await getVibesClient('account', ctx.runtime);
+            await account.ensureLoaded();
+            return account.isAuthenticated();
+        }
+    }
+}
+async function executeValidate(step, ctx) {
+    const target = step.target ? interpolate(step.target, ctx.variables) : undefined;
+    if (ctx.dryRun) {
+        return { step: 0, type: 'validate', success: true, message: `Would validate: ${step.check}${target ? ` (${target})` : ''}` };
+    }
+    let holds;
+    try {
+        holds = await checkHolds(step.check, target, ctx);
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return { step: 0, type: 'validate', success: false, error: failureText(failure), failure: valueFreeFailure(failure) };
+    }
+    if (holds)
+        return { step: 0, type: 'validate', success: true, message: `Validated: ${step.check}${target ? ` (${target})` : ''}` };
+    const message = step.message || `Validation failed: ${step.check}`;
+    if (step.fatal)
+        return { step: 0, type: 'validate', success: false, error: message };
+    return { step: 0, type: 'validate', success: true, message: `${message} (non-fatal)`, skipped: true };
+}
+// Main Executor
+async function executeStep(step, ctx) {
+    switch (step.type) {
+        case 'file-write':
+            return executeFileWrite(step, ctx);
+        case 'file-edit':
+            return executeFileEdit(step, ctx);
+        case 'file-copy':
+            return { step: 0, type: 'file-copy', success: true, skipped: true };
+        case 'file-backup':
+            return executeFileBackup(step, ctx);
+        case 'file-restore':
+            return executeFileRestore(step, ctx);
+        case 'command':
+            return executeCommand(step, ctx);
+        case 'hook-install':
+            return executeHookInstall(step, ctx);
+        case 'mcp-configure':
+            return executeMcpConfigure(step, ctx);
+        case 'adapter-codegen':
+            return executeAdapterCodegen(step, ctx);
+        case 'operation':
+            return executeOperation(step, ctx);
+        case 'prompt':
+            return executePrompt(step, ctx);
+        case 'validate':
+            return executeValidate(step, ctx);
+    }
+}
+export async function executeRecipe(recipe, ctx) {
+    const results = [];
+    const filesCreated = [];
+    const filesModified = [];
+    // The caller resolves the immutable Vibes command for this invocation.
+    // It must override recipe defaults such as `vibesPath: "vibes"` so every
+    // projected edge (MCP, hooks, generated assets) executes the same build.
+    const variables = { ...recipe.variables, vibesPath: ctx.vibesPath, ...ctx.variables };
+    const execCtx = { ...ctx, variables };
+    for (const [index, step] of recipe.steps.entries()) {
+        const result = await executeStep(step, execCtx);
+        result.step = index;
+        results.push(result);
+        if (result.filesCreated)
+            filesCreated.push(...result.filesCreated);
+        if (result.filesModified)
+            filesModified.push(...result.filesModified);
+        // Stop on failure
+        if (!result.success) {
+            return {
+                preset: recipe.id,
+                target: ctx.target,
+                success: false,
+                dryRun: ctx.dryRun,
+                steps: results,
+                filesCreated,
+                filesModified,
+                aliasesCreated: [],
+                nextSteps: [],
+                error: result.error
+            };
+        }
+    }
+    return {
+        preset: recipe.id,
+        target: ctx.target,
+        success: true,
+        dryRun: ctx.dryRun,
+        steps: results,
+        filesCreated,
+        filesModified,
+        aliasesCreated: [],
+        nextSteps: generateNextSteps(ctx.target)
+    };
+}
+// Helpers
+function generateNextSteps(target) {
+    return [`Launch: vibes dev external launch ${target}`, 'Start a vibes session: vibes dev session init'];
+}
+function mergeArrays(existing, incoming, strategy) {
+    if (strategy === 'append')
+        return [...existing, ...incoming];
+    if (strategy === 'replace')
+        return [...incoming];
+    return [...new Set([...existing, ...incoming])];
+}
+/** Deep-merge `source` into a copy of `target`; own keys only, so `__proto__` is an ordinary key. */
+function deepMerge(target, source, strategy = 'merge') {
+    const result = {};
+    for (const [key, value] of Object.entries(target))
+        setOwn(result, key, value);
+    for (const [key, incoming] of Object.entries(source)) {
+        const current = ownValue(result, key);
+        if (Array.isArray(incoming) && Array.isArray(current))
+            setOwn(result, key, mergeArrays(current, incoming, strategy));
+        else if (isConfigObject(incoming) && isConfigObject(current))
+            setOwn(result, key, deepMerge(current, incoming, strategy));
+        else
+            setOwn(result, key, incoming);
+    }
+    return result;
+}
+/** The TOML patch a merge writes: arrays combined with the existing value per strategy, tables recursed. */
+function materializeTomlPatch(existing, source, strategy = 'merge') {
+    const patch = {};
+    for (const [key, incoming] of Object.entries(source)) {
+        const current = ownValue(existing, key);
+        if (Array.isArray(incoming) && Array.isArray(current))
+            setOwn(patch, key, mergeArrays(current, incoming, strategy));
+        else if (isConfigObject(incoming))
+            setOwn(patch, key, materializeTomlPatch(isConfigObject(current) ? current : {}, incoming, strategy));
+        else
+            setOwn(patch, key, incoming);
+    }
+    return patch;
+}
+function mergeTomlDocument(content, patch) {
+    const lines = content ? content.split('\n') : [];
+    applyTomlPatch(lines, [], patch);
+    return lines.join('\n').replace(/\n*$/, '\n');
+}
+function applyTomlPatch(lines, tablePath, patch) {
+    for (const [key, value] of Object.entries(patch)) {
+        if (isConfigObject(value))
+            applyTomlPatch(lines, [...tablePath, key], value);
+        else
+            upsertTomlValue(lines, tablePath, key, value);
+    }
+}
+function upsertTomlValue(lines, tablePath, key, value) {
+    const renderedKey = formatTomlKey(key);
+    const renderedLine = `${renderedKey} = ${serializeTomlValue(value)}`;
+    const keyPattern = new RegExp(`^\\s*${escapeRegExp(renderedKey)}\\s*=`);
+    const tableName = tablePath.map(formatTomlKey).join('.');
+    if (tablePath.length === 0) {
+        const tableStart = lines.findIndex((line) => parseTomlTableHeader(line) !== undefined);
+        const end = tableStart === -1 ? lines.length : tableStart;
+        const existingIndex = lines.slice(0, end).findIndex((line) => keyPattern.test(line));
+        if (existingIndex !== -1) {
+            lines[existingIndex] = renderedLine;
+            return;
+        }
+        lines.splice(end, 0, renderedLine);
+        if (tableStart !== -1)
+            lines.splice(end + 1, 0, '');
+        return;
+    }
+    const headerIndex = lines.findIndex((line) => parseTomlTableHeader(line) === tableName);
+    if (headerIndex === -1) {
+        while (lines.at(-1) === '')
+            lines.pop();
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(`[${tableName}]`, renderedLine);
+        return;
+    }
+    let end = headerIndex + 1;
+    while (end < lines.length && parseTomlTableHeader(lines[end] ?? '') === undefined)
+        end++;
+    const existingOffset = lines.slice(headerIndex + 1, end).findIndex((line) => keyPattern.test(line));
+    if (existingOffset !== -1) {
+        lines[headerIndex + 1 + existingOffset] = renderedLine;
+        return;
+    }
+    while (end > headerIndex + 1 && lines[end - 1] === '')
+        end--;
+    lines.splice(end, 0, renderedLine);
+}
+function parseTomlTableHeader(line) {
+    const match = line.trim().match(/^\[\[?([^\]]+)\]\]?(?:\s*#.*)?$/);
+    return match?.[1];
+}
+function formatTomlKey(key) {
+    return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** A TOML scalar or array; `null` (no TOML spelling) is refused `INVALID_INPUT` `toml-value-unsupported`. */
+function serializeTomlValue(value) {
+    if (value === null || isConfigObject(value)) {
+        throw refusal('A TOML file-edit value has no TOML spelling (null or a nested table in an array).', 'toml-value-unsupported');
+    }
+    if (Array.isArray(value))
+        return `[${value.map(serializeTomlValue).join(', ')}]`;
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=executor.js.map