cross-runtime destroy: scan all runtimes, --name without config

- `findDestroyTargets()` probes Lambda + CF for named proxy
- `destroyByRuntime()` / `destroyCfByName()` / `destroyLambdaByName()` work without full config
- CLI: `--name`, `--runtime`, `--region` options; shows discovery summary before confirming
- `gc` subcommand deferred

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ryan-williams

specs/destroy-gc.md specs/done/destroy-gc.mdspecs/destroy-gc.md renamed to specs/done/destroy-gc.md

@@ -40,3 +40,12 @@ Discovers all `cors-prxy`-tagged resources (via `cors-prxy ls`) and cross-refere
 - CF cleanup: Worker name is deterministic (`cors-prxy-{name}`), delete via API
 - `destroy` should confirm before deleting (unless `--yes`), showing what will be removed
 - `destroy` should be idempotent — silently skip resources that don't exist
+
+## Implementation (done)
+
+- `findDestroyTargets()` in `deploy.ts`: probes both runtimes for the named proxy, returns `DestroyTarget[]` with runtime, name, and human-readable detail
+- `destroyByRuntime()` in `deploy.ts`: dispatches to `destroyCfByName()` or `destroyLambdaByName()`
+- `destroyCfByName()` in `deploy-cf.ts`: destroy by name without full config
+- `destroyLambdaByName()` in `deploy-lambda.ts`: destroy by name + region without full config
+- CLI `destroy` updated: `--name` (no config needed), `--runtime` filter, `--region` for Lambda, shows discovery summary before confirming
+- `gc` subcommand deferred (nice-to-have per spec)

src/cli.ts

@@ -140,18 +140,46 @@ program
 
 program
   .command("destroy")
-  .description("Remove deployed proxy")
+  .description("Remove deployed proxy (searches all runtimes by default)")
   .option("-c, --config <path>", "Config file path", ".cors-prxy.json")
+  .option("-n, --name <name>", "Proxy name (no config file needed)")
+  .option("--runtime <runtime>", "Only destroy specific runtime (lambda, cloudflare)")
+  .option("--region <region>", "AWS region for Lambda lookup", "us-east-1")
   .option("-y, --yes", "Skip confirmation")
   .action(async (opts) => {
-    const config = await loadConfig(opts.config)
-    const runtime = resolveRuntime(config)
+    const { findDestroyTargets, destroyByRuntime } = await import("./deploy.js")
+    const runtimeFilter = opts.runtime as Runtime | undefined
+
+    let name: string
+    let region: string
+    let config: import("./config.js").CorsProxyConfig | undefined
+
+    if (opts.name) {
+      name = opts.name
+      region = opts.region
+    } else {
+      config = await loadConfig(opts.config)
+      name = config.name
+      region = config.region
+    }
+
+    const targets = await findDestroyTargets(name, region, runtimeFilter)
+
+    if (targets.length === 0) {
+      console.log(`No resources found for "${name}".`)
+      return
+    }
+
+    console.log(`Found resources for "${name}":`)
+    for (const t of targets) {
+      console.log(`  ${t.detail}`)
+    }
 
     if (!opts.yes) {
       const readline = await import("node:readline")
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
       const answer = await new Promise<string>(resolve => {
-        rl.question(`Destroy proxy "${config.name}" (${runtime})? [y/N] `, resolve)
+        rl.question(`\nDestroy all? [y/N] `, resolve)
       })
       rl.close()
       if (answer.toLowerCase() !== "y") {
@@ -160,8 +188,9 @@ program
       }
     }
 
-    const { destroy } = await import("./deploy.js")
-    await destroy(config)
+    for (const target of targets) {
+      await destroyByRuntime(target.runtime, target.name, config)
+    }
     console.log("Done.")
   })
 

src/deploy-cf.ts

@@ -171,9 +171,13 @@ export async function deployCf(config: CorsProxyConfig): Promise<DeployResult> {
 }
 
 export async function destroyCf(config: CorsProxyConfig): Promise<void> {
+  await destroyCfByName(config.name, config)
+}
+
+export async function destroyCfByName(name: string, config?: CorsProxyConfig): Promise<void> {
   const { apiToken } = getCfAuth()
   const accountId = await resolveAccountId(apiToken, config)
-  const workerName = getWorkerName(config)
+  const workerName = config?.cloudflare?.workerName ?? `cors-prxy-${name}`
 
   console.log(`Deleting Cloudflare Worker: ${workerName}`)
   const resp = await cfApi(

src/deploy-lambda.ts

@@ -267,13 +267,17 @@ export async function deployLambda(config: CorsProxyConfig): Promise<DeployResul
 }
 
 export async function destroyLambda(config: CorsProxyConfig): Promise<void> {
+  await destroyLambdaByName(config.name, config.region)
+}
+
+export async function destroyLambdaByName(name: string, region: string): Promise<void> {
   const { DeleteFunctionCommand, DeleteFunctionUrlConfigCommand } = await import("@aws-sdk/client-lambda")
   const { DeleteRoleCommand, DeleteRolePolicyCommand } = await import("@aws-sdk/client-iam")
 
-  const lambda = new LambdaClient({ region: config.region })
-  const iam = new IAMClient({ region: config.region })
-  const functionName = config.name
-  const roleName = `cors-prxy-${config.name}-role`
+  const lambda = new LambdaClient({ region })
+  const iam = new IAMClient({ region })
+  const functionName = name
+  const roleName = `cors-prxy-${name}-role`
 
   // Delete Function URL
   try {

src/deploy.ts

@@ -1,5 +1,5 @@
 import { resolveRuntime } from "./config.js"
-import type { CorsProxyConfig } from "./config.js"
+import type { CorsProxyConfig, Runtime } from "./config.js"
 import type { DeployResult } from "./deploy-lambda.js"
 
 export type { DeployResult }
@@ -14,12 +14,93 @@ export async function deploy(config: CorsProxyConfig): Promise<DeployResult> {
   return deployLambda(config)
 }
 
-export async function destroy(config: CorsProxyConfig): Promise<void> {
-  const runtime = resolveRuntime(config)
+export interface DestroyTarget {
+  runtime: Runtime
+  name: string
+  detail: string
+}
+
+/** Discover what resources exist for a given name across runtimes. */
+export async function findDestroyTargets(
+  name: string,
+  region: string,
+  runtimeFilter?: Runtime,
+): Promise<DestroyTarget[]> {
+  const targets: DestroyTarget[] = []
+
+  if (!runtimeFilter || runtimeFilter === "lambda") {
+    try {
+      const { LambdaClient, GetFunctionCommand, GetFunctionUrlConfigCommand } = await import("@aws-sdk/client-lambda")
+      const client = new LambdaClient({ region })
+      await client.send(new GetFunctionCommand({ FunctionName: name }))
+      let urlInfo = ""
+      try {
+        const urlResp = await client.send(new GetFunctionUrlConfigCommand({ FunctionName: name }))
+        urlInfo = urlResp.FunctionUrl ? ` + Function URL` : ""
+      } catch {}
+      targets.push({
+        runtime: "lambda",
+        name,
+        detail: `Lambda: ${name} (${region})${urlInfo} + IAM role`,
+      })
+    } catch (err) {
+      const errName = (err as { name?: string }).name
+      if (errName !== "ResourceNotFoundException") {
+        const msg = err instanceof Error ? err.message : String(err)
+        if (!msg.includes("expired") && !msg.includes("credentials") && !msg.includes("Could not load")) {
+          if (runtimeFilter === "lambda") throw err
+        }
+      }
+    }
+  }
+
+  if (!runtimeFilter || runtimeFilter === "cloudflare") {
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN
+    if (apiToken) {
+      try {
+        const { resolveAccountId } = await import("./deploy-cf.js")
+        const accountId = await resolveAccountId(apiToken)
+        const workerName = `cors-prxy-${name}`
+        const resp = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/scripts/${workerName}`, {
+          headers: { Authorization: `Bearer ${apiToken}` },
+        })
+        if (resp.ok) {
+          targets.push({
+            runtime: "cloudflare",
+            name,
+            detail: `CF Worker: ${workerName}`,
+          })
+        }
+      } catch {}
+    }
+  }
+
+  return targets
+}
+
+/** Destroy resources for a single runtime. */
+export async function destroyByRuntime(
+  runtime: Runtime,
+  name: string,
+  config?: CorsProxyConfig,
+): Promise<void> {
   if (runtime === "cloudflare") {
-    const { destroyCf } = await import("./deploy-cf.js")
-    return destroyCf(config)
+    const { destroyCfByName } = await import("./deploy-cf.js")
+    await destroyCfByName(name, config)
+  } else {
+    const { destroyLambdaByName } = await import("./deploy-lambda.js")
+    const region = config?.region ?? "us-east-1"
+    await destroyLambdaByName(name, region)
+  }
+}
+
+/** Destroy all runtimes for a config (cross-runtime). */
+export async function destroy(config: CorsProxyConfig, runtimeFilter?: Runtime): Promise<void> {
+  const targets = await findDestroyTargets(config.name, config.region, runtimeFilter)
+  for (const target of targets) {
+    await destroyByRuntime(target.runtime, target.name, config)
+  }
+  if (targets.length === 0) {
+    console.log("No resources found to destroy.")
   }
-  const { destroyLambda } = await import("./deploy-lambda.js")
-  return destroyLambda(config)
 }