@edge-base/cli 0.1.1

package/dist/commands/destroy.js

@@ -0,0 +1,642 @@
+import { Command } from 'commander';
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+import { ensureCloudflareAuth, ensureWranglerToml, resolveApiToken } from '../lib/cf-auth.js';
+import { getCloudflareDeployManifestPath, readCloudflareDeployManifest, } from '../lib/cloudflare-deploy-manifest.js';
+import { parseWranglerResourceConfig } from '../lib/cloudflare-wrangler-resources.js';
+import { fetchWithTimeout } from '../lib/fetch-with-timeout.js';
+import { raiseCliError, raiseNeedsInput } from '../lib/agent-contract.js';
+import { isJson, isNonInteractive } from '../lib/cli-context.js';
+import { buildLegacyManagedD1DatabaseName, buildManagedD1DatabaseName, } from '../lib/managed-resource-names.js';
+import { resolveProjectWorkerName, resolveProjectWorkerUrl } from '../lib/project-runtime.js';
+import { resolveOptionalServiceKey } from '../lib/resolve-options.js';
+import { wranglerArgs, wranglerCommand } from '../lib/wrangler.js';
+function resolveWorkerNameFromProject(projectDir) {
+    return resolveProjectWorkerName(projectDir);
+}
+function resolveWorkerUrlFromProject(projectDir) {
+    return resolveProjectWorkerUrl(projectDir);
+}
+function resourceKey(resource) {
+    return [resource.type, resource.id ?? '', resource.binding ?? '', resource.name].join(':');
+}
+function mergeDestroyResources(manifest, wranglerContent) {
+    const merged = new Map();
+    for (const resource of manifest?.resources ?? []) {
+        merged.set(resourceKey(resource), resource);
+    }
+    if (wranglerContent) {
+        const wranglerConfig = parseWranglerResourceConfig(wranglerContent);
+        for (const bucket of wranglerConfig.r2Buckets) {
+            const key = resourceKey({
+                type: 'r2_bucket',
+                name: bucket.bucketName,
+                binding: bucket.binding,
+                id: bucket.bucketName,
+            });
+            const existing = merged.get(key);
+            merged.set(key, {
+                type: 'r2_bucket',
+                name: bucket.bucketName,
+                binding: bucket.binding,
+                id: bucket.bucketName,
+                managed: existing?.managed ?? true,
+                source: existing?.source ?? 'wrangler',
+                metadata: {
+                    ...(existing?.metadata ?? {}),
+                    ...(bucket.jurisdiction ? { jurisdiction: bucket.jurisdiction } : {}),
+                },
+            });
+        }
+        const existingBindings = new Set([...merged.values()].map((r) => `${r.type}:${r.binding ?? ''}`));
+        for (const db of wranglerConfig.d1Databases) {
+            if (existingBindings.has(`d1_database:${db.binding}`))
+                continue;
+            const normalizedId = normalizeWranglerResourceId(db.databaseId);
+            const key = resourceKey({
+                type: 'd1_database',
+                name: deriveWranglerD1ResourceName(db.binding, db.databaseName),
+                binding: db.binding,
+                id: normalizedId,
+            });
+            if (!merged.has(key)) {
+                merged.set(key, {
+                    type: 'd1_database',
+                    name: deriveWranglerD1ResourceName(db.binding, db.databaseName),
+                    binding: db.binding,
+                    id: normalizedId,
+                    managed: true,
+                    source: 'wrangler',
+                });
+            }
+        }
+        for (const kv of wranglerConfig.kvNamespaces) {
+            if (existingBindings.has(`kv_namespace:${kv.binding}`))
+                continue;
+            const normalizedId = normalizeWranglerResourceId(kv.id);
+            const key = resourceKey({
+                type: 'kv_namespace',
+                name: deriveWranglerKvName(kv.binding),
+                binding: kv.binding,
+                id: normalizedId,
+            });
+            if (!merged.has(key)) {
+                merged.set(key, {
+                    type: 'kv_namespace',
+                    name: deriveWranglerKvName(kv.binding),
+                    binding: kv.binding,
+                    id: normalizedId,
+                    managed: true,
+                    source: 'wrangler',
+                });
+            }
+        }
+        for (const vec of wranglerConfig.vectorizeIndexes) {
+            if (existingBindings.has(`vectorize:${vec.binding}`))
+                continue;
+            const key = resourceKey({
+                type: 'vectorize',
+                name: vec.indexName,
+                binding: vec.binding,
+                id: vec.indexName,
+            });
+            if (!merged.has(key)) {
+                merged.set(key, {
+                    type: 'vectorize',
+                    name: vec.indexName,
+                    binding: vec.binding,
+                    id: vec.indexName,
+                    managed: true,
+                    source: 'wrangler',
+                });
+            }
+        }
+        for (const hd of wranglerConfig.hyperdriveConfigs) {
+            if (existingBindings.has(`hyperdrive:${hd.binding}`))
+                continue;
+            const key = resourceKey({
+                type: 'hyperdrive',
+                name: hd.binding,
+                binding: hd.binding,
+                id: hd.id,
+            });
+            if (!merged.has(key)) {
+                merged.set(key, {
+                    type: 'hyperdrive',
+                    name: hd.binding,
+                    binding: hd.binding,
+                    id: hd.id,
+                    managed: true,
+                    source: 'wrangler',
+                });
+            }
+        }
+    }
+    return Array.from(merged.values());
+}
+function extractExecErrorFull(error) {
+    if (error && typeof error === 'object') {
+        const stderr = 'stderr' in error ? String(error.stderr ?? '').trim() : '';
+        if (stderr)
+            return stderr;
+        const stdout = 'stdout' in error ? String(error.stdout ?? '').trim() : '';
+        if (stdout)
+            return stdout;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+function extractExecErrorMessage(error) {
+    const full = extractExecErrorFull(error);
+    // Wrangler may append a log-file path as the last line — prefer the last meaningful line.
+    const lines = full.split('\n').filter(Boolean);
+    return lines.at(-1) ?? full;
+}
+function isPlaceholderCloudflareId(value) {
+    if (!value)
+        return false;
+    return /^(local|placeholder)$/i.test(value) || /^YOUR_[A-Z0-9_]+$/i.test(value);
+}
+function normalizeWranglerResourceId(value) {
+    return value && !isPlaceholderCloudflareId(value) ? value : undefined;
+}
+function deriveWranglerD1ResourceName(binding, databaseName) {
+    if (binding === 'AUTH_DB')
+        return 'auth';
+    if (binding === 'CONTROL_DB')
+        return 'control';
+    if (binding.startsWith('DB_D1_')) {
+        return binding.slice('DB_D1_'.length).toLowerCase().replace(/_/g, '-');
+    }
+    return databaseName
+        .replace(/^edgebase-db-/, '')
+        .replace(/^edgebase-/, '');
+}
+function deriveWranglerKvName(binding) {
+    if (binding === 'KV')
+        return 'internal';
+    return binding.toLowerCase().replace(/^kv[_-]?/i, '').replace(/_/g, '-') || binding;
+}
+function runWrangler(projectDir, args, options) {
+    return execFileSync(wranglerCommand(), wranglerArgs(args), {
+        cwd: projectDir,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        input: options?.input,
+    });
+}
+async function confirmDestroy(message) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolveAnswer) => {
+        rl.question(message, (value) => resolveAnswer(value));
+    });
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+async function wipeManagedStorageBucket(workerUrl, serviceKey) {
+    const response = await fetchWithTimeout(`${workerUrl.replace(/\/$/, '')}/admin/api/backup/restore-storage?action=wipe`, {
+        method: 'POST',
+        headers: { 'X-EdgeBase-Service-Key': serviceKey },
+    });
+    if (!response.ok) {
+        throw new Error(`storage wipe failed (${response.status}): ${await response.text()}`);
+    }
+    const payload = await response.json();
+    return typeof payload.deleted === 'number' ? payload.deleted : 0;
+}
+async function listStorageBucketObjects(workerUrl, serviceKey, bucketName, cursor) {
+    const query = new URLSearchParams({ limit: '1000' });
+    if (cursor) {
+        query.set('cursor', cursor);
+    }
+    const response = await fetchWithTimeout(`${workerUrl.replace(/\/$/, '')}/admin/api/data/storage/buckets/${encodeURIComponent(bucketName)}/objects?${query.toString()}`, {
+        headers: { 'X-EdgeBase-Service-Key': serviceKey },
+    });
+    if (!response.ok) {
+        throw new Error(`storage list failed (${response.status}): ${await response.text()}`);
+    }
+    const payload = await response.json();
+    return {
+        keys: (payload.objects ?? [])
+            .map((entry) => (typeof entry.key === 'string' ? entry.key : null))
+            .filter((entry) => Boolean(entry)),
+        cursor: typeof payload.cursor === 'string' && payload.cursor.length > 0 ? payload.cursor : null,
+    };
+}
+async function wipeStorageBucketViaAdmin(workerUrl, serviceKey, bucketName) {
+    let deleted = 0;
+    let cursor = null;
+    do {
+        const page = await listStorageBucketObjects(workerUrl, serviceKey, bucketName, cursor ?? undefined);
+        for (const key of page.keys) {
+            const response = await fetchWithTimeout(`${workerUrl.replace(/\/$/, '')}/admin/api/data/storage/buckets/${encodeURIComponent(bucketName)}/objects/${encodeURIComponent(key)}`, {
+                method: 'DELETE',
+                headers: { 'X-EdgeBase-Service-Key': serviceKey },
+            });
+            if (!response.ok && response.status !== 404) {
+                throw new Error(`storage object delete failed (${response.status}): ${await response.text()}`);
+            }
+            if (response.ok) {
+                deleted += 1;
+            }
+        }
+        cursor = page.cursor;
+    } while (cursor);
+    return deleted;
+}
+async function listTurnstileWidgets(accountId, apiToken) {
+    const response = await fetchWithTimeout(`https://api.cloudflare.com/client/v4/accounts/${accountId}/challenges/widgets`, {
+        headers: { Authorization: `Bearer ${apiToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Turnstile list failed (${response.status}): ${await response.text()}`);
+    }
+    const payload = await response.json();
+    return (payload.result ?? [])
+        .filter((entry) => typeof entry.name === 'string' && typeof entry.sitekey === 'string')
+        .map((entry) => ({ name: entry.name, sitekey: entry.sitekey }));
+}
+async function deleteTurnstileWidget(accountId, apiToken, resource) {
+    const configuredSiteKey = typeof resource.metadata?.siteKey === 'string' ? resource.metadata.siteKey : undefined;
+    const siteKey = configuredSiteKey ?? (await listTurnstileWidgets(accountId, apiToken)).find((widget) => widget.name === resource.name)?.sitekey;
+    if (!siteKey) {
+        throw new Error(`Turnstile widget "${resource.name}" not found (no siteKey in manifest and no matching widget name on account).`);
+    }
+    const response = await fetchWithTimeout(`https://api.cloudflare.com/client/v4/accounts/${accountId}/challenges/widgets/${siteKey}`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${apiToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Turnstile delete failed (${response.status}): ${await response.text()}`);
+    }
+}
+async function deleteD1Database(accountId, apiToken, databaseId) {
+    const response = await fetchWithTimeout(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database/${databaseId}`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${apiToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`D1 delete failed (${response.status}): ${await response.text()}`);
+    }
+}
+function fetchD1DatabaseList(projectDir) {
+    const uuidToName = new Map();
+    try {
+        const output = runWrangler(projectDir, ['wrangler', 'd1', 'list', '--json']);
+        const databases = JSON.parse(output);
+        for (const entry of databases) {
+            if (typeof entry.uuid === 'string' && typeof entry.name === 'string') {
+                uuidToName.set(entry.uuid, entry.name);
+            }
+        }
+    }
+    catch {
+        // Fall back to deterministic naming.
+    }
+    return uuidToName;
+}
+function resolveManagedD1DeleteName(workerName, resource, d1List) {
+    if (resource.id) {
+        const name = d1List.get(resource.id);
+        if (name)
+            return name;
+    }
+    if (workerName) {
+        return buildManagedD1DatabaseName(workerName, resource.name);
+    }
+    return buildLegacyManagedD1DatabaseName(resource.name);
+}
+function formatDestroyPlan(workerName, resources) {
+    const lines = [];
+    if (workerName) {
+        lines.push(`Worker: ${workerName}`);
+    }
+    for (const resource of resources) {
+        if (resource.managed === false)
+            continue;
+        const detail = resource.binding ? `${resource.name} (${resource.binding})` : resource.name;
+        lines.push(`${resource.type}: ${detail}`);
+    }
+    return lines;
+}
+function isAlreadyDeletedError(message) {
+    return /not.?found|does not exist|couldn't find|could not find|could not be found|no such/i.test(message);
+}
+function isR2BucketNotEmptyError(message) {
+    return /bucket.+not empty|bucket you tried to delete.+not empty|\[code:\s*10008\]/i.test(message);
+}
+async function runDeleteStep(label, dryRun, result, action) {
+    if (dryRun) {
+        result.skipped.push(`[dry-run] ${label}`);
+        return;
+    }
+    try {
+        await action();
+        result.deleted.push(label);
+    }
+    catch (error) {
+        const full = extractExecErrorFull(error);
+        if (isAlreadyDeletedError(full)) {
+            result.deleted.push(`${label} (already removed)`);
+        }
+        else {
+            result.failures.push({ label, message: extractExecErrorMessage(error) });
+        }
+    }
+}
+function isManagedResource(resource) {
+    return resource.managed !== false;
+}
+export const _internals = {
+    mergeDestroyResources,
+    isAlreadyDeletedError,
+    isR2BucketNotEmptyError,
+};
+function resolveProjectDir() {
+    const cwd = resolve('.');
+    if (existsSync(getCloudflareDeployManifestPath(cwd)) || existsSync(join(cwd, 'wrangler.toml'))) {
+        return cwd;
+    }
+    const edgebaseSubdir = join(cwd, 'edgebase');
+    if (existsSync(getCloudflareDeployManifestPath(edgebaseSubdir)) || existsSync(join(edgebaseSubdir, 'wrangler.toml'))) {
+        return edgebaseSubdir;
+    }
+    return cwd;
+}
+export const destroyCommand = new Command('destroy')
+    .description('Destroy project-scoped Cloudflare resources for this project')
+    .option('--dry-run', 'Show the deletion plan without removing resources')
+    .option('--service-key <key>', 'Service Key used to wipe the managed STORAGE bucket')
+    .option('--url <url>', 'Worker URL used to wipe the managed STORAGE bucket')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .action(async (options) => {
+    const projectDir = resolveProjectDir();
+    const wranglerPath = join(projectDir, 'wrangler.toml');
+    const manifestPath = getCloudflareDeployManifestPath(projectDir);
+    const manifest = readCloudflareDeployManifest(projectDir);
+    const wranglerContent = existsSync(wranglerPath) ? readFileSync(wranglerPath, 'utf-8') : null;
+    const resources = mergeDestroyResources(manifest, wranglerContent).filter(isManagedResource);
+    const workerName = manifest?.worker.name || resolveWorkerNameFromProject(projectDir);
+    const workerUrl = (options.url
+        || process.env.EDGEBASE_URL
+        || manifest?.worker.url
+        || resolveWorkerUrlFromProject(projectDir)).replace(/\/$/, '');
+    const isTTY = !!process.stdin.isTTY;
+    if (!workerName && resources.length === 0) {
+        const message = `No Cloudflare resources found for this project. (${manifestPath})`;
+        if (isJson()) {
+            console.log(JSON.stringify({ status: 'noop', message }));
+        }
+        else {
+            console.log(chalk.yellow('⚠'), message);
+        }
+        return;
+    }
+    const planLines = formatDestroyPlan(workerName, resources);
+    if (!isJson()) {
+        console.log(chalk.blue(options.dryRun ? '🧹 Previewing Cloudflare destroy...' : '🧹 Destroying Cloudflare resources...'));
+        console.log();
+        for (const line of planLines) {
+            console.log(chalk.dim(`  • ${line}`));
+        }
+        console.log();
+    }
+    if (!options.dryRun && !options.yes) {
+        if (isJson() || !isTTY || isNonInteractive()) {
+            raiseNeedsInput({
+                code: 'destroy_confirmation_required',
+                field: 'yes',
+                message: 'Destroy requires explicit confirmation before deleting Cloudflare resources.',
+                hint: 'Review the deletion plan, then rerun with --yes.',
+                choices: [{
+                        label: 'Approve deletion',
+                        value: 'yes',
+                        args: ['--yes'],
+                        hint: 'Use only after confirming the destroy plan.',
+                    }],
+            });
+        }
+        const confirmed = await confirmDestroy(`  ${chalk.cyan('Proceed with Cloudflare resource deletion?')} (y/N): `);
+        if (!confirmed) {
+            console.log(chalk.yellow('⚠ Destroy cancelled.'));
+            return;
+        }
+    }
+    const cfAuth = options.dryRun ? null : await ensureCloudflareAuth(projectDir, isTTY);
+    if (!options.dryRun && cfAuth?.accountId) {
+        ensureWranglerToml(projectDir, cfAuth.accountId);
+    }
+    const accountId = !isPlaceholderCloudflareId(manifest?.accountId)
+        ? (manifest?.accountId ?? '')
+        : (cfAuth?.accountId ?? '');
+    const apiToken = options.dryRun
+        ? undefined
+        : (() => {
+            try {
+                return resolveApiToken().token;
+            }
+            catch {
+                return process.env.CLOUDFLARE_API_TOKEN;
+            }
+        })();
+    const serviceKey = resolveOptionalServiceKey({ serviceKey: options.serviceKey });
+    const result = { deleted: [], skipped: [], failures: [] };
+    const turnstileResources = resources.filter((resource) => resource.type === 'turnstile_widget');
+    for (const resource of turnstileResources) {
+        await runDeleteStep(`Turnstile ${resource.name}`, !!options.dryRun, result, async () => {
+            if (!accountId) {
+                throw new Error('Cloudflare account id is required for Turnstile deletion.');
+            }
+            if (!apiToken) {
+                throw new Error('Set CLOUDFLARE_API_TOKEN to delete managed Turnstile widgets.');
+            }
+            await deleteTurnstileWidget(accountId, apiToken, resource);
+        });
+    }
+    const r2Resources = resources.filter((resource) => resource.type === 'r2_bucket');
+    for (const resource of r2Resources) {
+        await runDeleteStep(`R2 ${resource.name}`, !!options.dryRun, result, async () => {
+            const jurisdiction = typeof resource.metadata?.jurisdiction === 'string'
+                ? resource.metadata.jurisdiction
+                : undefined;
+            if (resource.binding === 'STORAGE' && workerUrl && serviceKey) {
+                try {
+                    await wipeManagedStorageBucket(workerUrl, serviceKey);
+                }
+                catch {
+                    // Storage wipe may fail if Worker is already deleted — continue with bucket deletion.
+                }
+            }
+            const args = ['wrangler', 'r2', 'bucket', 'delete', resource.name];
+            if (jurisdiction) {
+                args.push(`--jurisdiction=${jurisdiction}`);
+            }
+            try {
+                runWrangler(projectDir, args, { input: 'y\n' });
+            }
+            catch (error) {
+                const full = extractExecErrorFull(error);
+                if (isAlreadyDeletedError(full))
+                    return;
+                if (resource.binding === 'STORAGE'
+                    && workerUrl
+                    && serviceKey
+                    && isR2BucketNotEmptyError(full)) {
+                    await wipeStorageBucketViaAdmin(workerUrl, serviceKey, resource.name);
+                    try {
+                        runWrangler(projectDir, args, { input: 'y\n' });
+                        return;
+                    }
+                    catch (retryError) {
+                        const retryFull = extractExecErrorFull(retryError);
+                        if (isAlreadyDeletedError(retryFull))
+                            return;
+                        throw retryError;
+                    }
+                }
+                if (resource.binding === 'STORAGE' && (!workerUrl || !serviceKey)) {
+                    throw new Error(`${extractExecErrorMessage(error)}. Set --url/EDGEBASE_URL and --service-key/EDGEBASE_SERVICE_KEY if the bucket is not empty.`);
+                }
+                throw error;
+            }
+        });
+    }
+    const storageDeleteFailed = r2Resources.some((r) => r.binding === 'STORAGE' && result.failures.some((f) => f.label === `R2 ${r.name}`));
+    if (workerName && storageDeleteFailed) {
+        result.skipped.push(`Worker ${workerName} (skipped: STORAGE bucket deletion failed — deleting the Worker would prevent future bucket cleanup)`);
+    }
+    else if (workerName) {
+        await runDeleteStep(`Worker ${workerName}`, !!options.dryRun, result, () => {
+            runWrangler(projectDir, ['wrangler', 'delete', workerName, '--force'], { input: 'y\n' });
+        });
+    }
+    const orderedTypes = [
+        'kv_namespace',
+        'd1_database',
+        'vectorize',
+        'hyperdrive',
+    ];
+    const hasD1 = resources.some((r) => r.type === 'd1_database');
+    const d1List = hasD1 && !options.dryRun ? fetchD1DatabaseList(projectDir) : new Map();
+    for (const type of orderedTypes) {
+        for (const resource of resources.filter((entry) => entry.type === type)) {
+            const label = `${type} ${resource.binding ?? resource.name}`;
+            await runDeleteStep(label, !!options.dryRun, result, async () => {
+                if (resource.type === 'kv_namespace') {
+                    if (resource.id) {
+                        runWrangler(projectDir, ['wrangler', 'kv', 'namespace', 'delete', '--namespace-id', resource.id, '-y']);
+                        return;
+                    }
+                    const candidateNames = [
+                        resource.binding,
+                        resource.name,
+                        workerName && resource.binding ? `${workerName}-${resource.binding}` : undefined,
+                    ].filter((value, index, all) => !!value && all.indexOf(value) === index);
+                    let lastError = null;
+                    for (const candidate of candidateNames) {
+                        try {
+                            runWrangler(projectDir, ['wrangler', 'kv', 'namespace', 'delete', candidate, '-y']);
+                            return;
+                        }
+                        catch (error) {
+                            const full = extractExecErrorFull(error);
+                            if (isAlreadyDeletedError(full))
+                                return;
+                            lastError = error;
+                        }
+                    }
+                    throw lastError ?? new Error(`Could not delete KV namespace "${resource.binding ?? resource.name}".`);
+                    return;
+                }
+                if (resource.type === 'd1_database') {
+                    if (resource.id && accountId && apiToken && !isPlaceholderCloudflareId(resource.id)) {
+                        await deleteD1Database(accountId, apiToken, resource.id);
+                        return;
+                    }
+                    const deleteName = resolveManagedD1DeleteName(workerName, resource, d1List);
+                    try {
+                        runWrangler(projectDir, ['wrangler', 'd1', 'delete', deleteName, '-y']);
+                    }
+                    catch (error) {
+                        if (deleteName !== buildLegacyManagedD1DatabaseName(resource.name)) {
+                            runWrangler(projectDir, ['wrangler', 'd1', 'delete', buildLegacyManagedD1DatabaseName(resource.name), '-y']);
+                            return;
+                        }
+                        throw error;
+                    }
+                    return;
+                }
+                if (resource.type === 'vectorize') {
+                    runWrangler(projectDir, ['wrangler', 'vectorize', 'delete', resource.id || `edgebase-${resource.name}`, '-y']);
+                    return;
+                }
+                if (resource.type === 'hyperdrive') {
+                    let hyperdriveId = resource.id;
+                    if (!hyperdriveId) {
+                        // Attempt to resolve ID by name from wrangler hyperdrive list
+                        try {
+                            const listOutput = runWrangler(projectDir, ['wrangler', 'hyperdrive', 'list']);
+                            const namePattern = resource.name === 'auth' ? 'edgebase-auth' : `edgebase-db-${resource.name}`;
+                            const match = listOutput.match(new RegExp(`(${namePattern})\\s.*?([a-f0-9-]{36})`, 'i'))
+                                ?? listOutput.match(new RegExp(`([a-f0-9-]{36}).*?${namePattern}`, 'i'));
+                            hyperdriveId = match?.[2] ?? match?.[1];
+                        }
+                        catch {
+                            // list failed
+                        }
+                    }
+                    if (!hyperdriveId) {
+                        throw new Error(`Hyperdrive id is missing and could not be resolved for "${resource.name}".`);
+                    }
+                    runWrangler(projectDir, ['wrangler', 'hyperdrive', 'delete', hyperdriveId], { input: 'y\n' });
+                }
+            });
+        }
+    }
+    if (!options.dryRun && result.failures.length === 0) {
+        rmSync(manifestPath, { force: true });
+        rmSync(join(projectDir, '.edgebase', 'secrets.json'), { force: true });
+        rmSync(join(projectDir, 'edgebase-schema.lock.json'), { force: true });
+    }
+    if (isJson()) {
+        if (result.failures.length > 0) {
+            raiseCliError({
+                code: 'destroy_partial_failure',
+                message: `Destroy completed with ${result.failures.length} failure(s).`,
+                details: {
+                    worker: workerName,
+                    deleted: result.deleted,
+                    skipped: result.skipped,
+                    failures: result.failures,
+                },
+            });
+        }
+        console.log(JSON.stringify({
+            status: options.dryRun ? 'dry-run' : 'success',
+            worker: workerName,
+            deleted: result.deleted,
+            skipped: result.skipped,
+        }));
+    }
+    else if (result.failures.length === 0) {
+        console.log(chalk.green(`✓ ${options.dryRun ? 'Destroy preview complete.' : 'Cloudflare resources removed.'}`));
+        if (options.dryRun) {
+            console.log(chalk.dim('  Run npx edgebase destroy --yes to execute.'));
+        }
+    }
+    else {
+        raiseCliError({
+            code: 'destroy_partial_failure',
+            message: `Destroy completed with ${result.failures.length} failure(s).`,
+            details: {
+                worker: workerName,
+                deleted: result.deleted,
+                skipped: result.skipped,
+                failures: result.failures,
+            },
+        });
+    }
+});
+//# sourceMappingURL=destroy.js.map