@cargo-ai/cdk 0.1.1

package/build/src/deploy/apply.js

@@ -0,0 +1,219 @@
+// The apply engine — the live half. It compiles, then walks the plan in
+// topological order: for each drifted resource it resolves the tokens in its
+// spec to the real outputs its dependencies produced, calls the matching
+// executor (passing the prior state entry for idempotency), records the new
+// outputs, and persists state AFTER EACH resource so a mid-deploy crash leaves a
+// recoverable cargo.state.json. Returns the next State.
+//
+// Side effects are injected as `Executors` (one per kind), so this stays pure
+// and testable. A host binds them to @cargo-ai/api; tests bind mocks.
+import { dependenciesOf, resolveSecrets, resolveTokens, } from "../core.js";
+import { compile, } from "./compile.js";
+const PLACEHOLDER = /\$\{[A-Za-z0-9_]+\}/;
+// Refuse to send an unresolved `env("X")` placeholder (a missing secret/config
+// value) to a live create. Walks the resolved spec for `${NAME}` strings.
+function assertNoPlaceholders(id, value) {
+    if (typeof value === "string") {
+        if (PLACEHOLDER.test(value)) {
+            throw new Error(`${id}: unresolved placeholder "${value}" — set the environment variable before deploying.`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            assertNoPlaceholders(id, item);
+        return;
+    }
+    if (value !== null && typeof value === "object") {
+        for (const item of Object.values(value))
+            assertNoPlaceholders(id, item);
+    }
+}
+export async function apply(input, executors, persist, readers, onProgress) {
+    const { plan, errors } = compile(input);
+    if (errors.length > 0) {
+        const detail = errors.map((e) => `${e.id}: ${e.message}`).join("; ");
+        throw new Error(`apply aborted — fix plan errors first: ${detail}`);
+    }
+    const byId = new Map(input.nodes.map((n) => [n.id, n]));
+    // Resolved outputs by resource id, seeded from prior state so unchanged
+    // ("noop") dependencies still resolve for their dependents.
+    const outputs = new Map();
+    for (const [id, entry] of Object.entries(input.state?.resources ?? {})) {
+        outputs.set(id, entry.outputs);
+    }
+    const state = {
+        version: input.state?.version ?? 1,
+        workspaceUuid: input.state?.workspaceUuid ?? "",
+        resources: { ...(input.state?.resources ?? {}) },
+    };
+    const applied = [];
+    const skipped = [];
+    // Resources whose produced outputs changed identity this run (e.g. a file
+    // whose content changed got a new uuid). The plan is in topological order, so
+    // a dependency is recorded here before any dependent is processed.
+    const changedOutputs = new Set();
+    // How many resources will actually be applied — drives the (index/total)
+    // counter. Promoted noops (stale-dependency re-applies) bump it as they occur.
+    let total = plan.filter((e) => e.change !== "noop").length;
+    let index = 0;
+    for (const entry of plan) {
+        const node = byId.get(entry.id);
+        if (node === undefined)
+            continue; // delete entries — handled by destroy
+        let change = entry.change;
+        if (change === "noop") {
+            // A noop's own spec hash is unchanged, but if one of its dependencies
+            // produced a NEW output identity this run, the tokens in this spec now
+            // resolve to different values than its live config holds (e.g. it still
+            // points at a file uuid that was just deleted). Re-apply it so it
+            // re-points at the new value; otherwise it silently dangles.
+            const deps = dependenciesOf(node.spec);
+            const stale = Array.from(deps).some((d) => changedOutputs.has(d));
+            if (!stale) {
+                skipped.push(entry);
+                continue;
+            }
+            change = "update";
+            total += 1; // a noop promoted to a re-apply — count it
+        }
+        index += 1;
+        // `change` is create|update here (noop was skipped/promoted above; delete
+        // entries have no node and were `continue`d). `index`/`total` are fixed for
+        // this resource, so the start/done events share one payload.
+        const progress = {
+            id: node.id,
+            change: change,
+            index,
+            total,
+        };
+        onProgress?.({ phase: "start", ...progress });
+        // tokens (deferred outputs) then secrets (deferred env reads) — both resolve
+        // to real values here, at apply, just before the executor runs.
+        const resolved = resolveSecrets(resolveTokens(node.spec, outputs));
+        assertNoPlaceholders(node.id, resolved);
+        const prior = input.state?.resources[node.id];
+        let produced;
+        try {
+            produced = await runExecutor(node, resolved, prior, executors);
+        }
+        catch (error) {
+            // Tag the failure with the resource that failed and surface the API's
+            // structured detail — executors throw `@cargo-ai/api` FetcherErrors whose
+            // bare `message` is often a terse "Invalid configuration", with the
+            // actionable bits (reason, status, which field) on `reason`/`status`/`data`.
+            throw new Error(`${node.id}: ${describeExecutorError(error)}`, {
+                cause: error,
+            });
+        }
+        // Carry the "adopted" marker forward across updates so destroy keeps
+        // releasing (not deleting) a resource the CDK adopted or imported, even for
+        // kinds whose executor doesn't echo it back.
+        if (prior?.outputs["adopted"] === "true" &&
+            produced["adopted"] === undefined) {
+            produced["adopted"] = "true";
+        }
+        if (outputsChanged(prior?.outputs, produced)) {
+            changedOutputs.add(node.id);
+        }
+        outputs.set(node.id, produced);
+        const newEntry = {
+            hash: entry.hash,
+            uuid: produced.uuid,
+            outputs: produced,
+            deps: Array.from(dependenciesOf(node.spec)),
+        };
+        state.resources[entry.id] = newEntry;
+        // Capture a baseline fingerprint of the just-applied live resource so a
+        // later `refresh` can tell whether it was changed out-of-band. Best-effort:
+        // a read failure must not fail the deploy.
+        if (readers !== undefined) {
+            try {
+                const live = await readers[node.kind](newEntry);
+                if (live.fingerprint !== undefined)
+                    newEntry.live = live.fingerprint;
+            }
+            catch {
+                // leave newEntry.live unset — refresh will report "unknown"
+            }
+        }
+        if (persist !== undefined)
+            persist(state);
+        onProgress?.({ phase: "done", ...progress });
+        applied.push(change === entry.change ? entry : { ...entry, change });
+    }
+    return { state, applied, skipped };
+}
+// Flatten an executor error into the most actionable one-line string we can.
+// `@cargo-ai/api` FetcherErrors put a terse summary on `.message` (e.g.
+// "Invalid configuration") and the useful detail on `.reason` (a code),
+// `.status` (HTTP), and `.data` (the response body, often naming the bad
+// field). We duck-type those so the engine stays free of an `@cargo-ai/api`
+// import.
+function describeExecutorError(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const e = error;
+    const parts = [e.message];
+    if (typeof e.reason === "string" &&
+        e.reason.length > 0 &&
+        e.reason !== e.message) {
+        parts.push(`reason=${e.reason}`);
+    }
+    if (typeof e.status === "number")
+        parts.push(`status=${String(e.status)}`);
+    if (e.data !== null && typeof e.data === "object") {
+        const extra = Object.entries(e.data)
+            .filter(([k, v]) => k !== "errorMessage" &&
+            k !== "reason" &&
+            v !== undefined &&
+            v !== null)
+            .map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+        if (extra.length > 0)
+            parts.push(extra.join(" "));
+    }
+    return parts.join(" | ");
+}
+// True when a resource's produced outputs differ from its prior outputs in any
+// token-resolvable field — i.e. its identity (uuid / datasetUuid / url / …)
+// changed, so dependents referencing it must re-apply. A brand-new resource
+// (no prior) always counts as changed. The bookkeeping-only "adopted" marker is
+// ignored so carrying it forward doesn't spuriously invalidate dependents.
+function outputsChanged(prior, produced) {
+    if (prior === undefined)
+        return true;
+    const keys = new Set([...Object.keys(prior), ...Object.keys(produced)]);
+    for (const key of keys) {
+        if (key === "adopted")
+            continue;
+        if (prior[key] !== produced[key])
+            return true;
+    }
+    return false;
+}
+function runExecutor(node, resolved, prior, executors) {
+    switch (node.kind) {
+        case "connector":
+            return executors.connector(resolved, prior);
+        case "model":
+            return executors.model(resolved, prior);
+        case "agent":
+            return executors.agent(resolved, prior);
+        case "play":
+            return executors.play(resolved, prior);
+        case "tool":
+            return executors.tool(resolved, prior);
+        case "mcpServer":
+            return executors.mcpServer(resolved, prior);
+        case "folder":
+            return executors.folder(resolved, prior);
+        case "file":
+            return executors.file(resolved, prior);
+        case "worker":
+            return executors.worker(resolved, prior);
+        case "app":
+            return executors.app(resolved, prior);
+        case "context":
+            return executors.context(resolved, prior);
+    }
+}

package/build/src/deploy/audit.d.ts

@@ -0,0 +1,14 @@
+export type AuditEntry = {
+    runId: string;
+    at: string;
+    command: string;
+    workspaceUuid: string;
+    ok: boolean;
+    summary?: Record<string, unknown>;
+    error?: string;
+};
+/** A short, unique id for one CDK run, surfaced to the user and the audit log. */
+export declare function newRunId(): string;
+/** Append one audit record. Best-effort — never throws into the caller. */
+export declare function appendAudit(root: string, entry: AuditEntry): void;
+//# sourceMappingURL=audit.d.ts.map

package/build/src/deploy/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../../src/deploy/audit.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,kFAAkF;AAClF,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAOD,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAMjE"}

package/build/src/deploy/audit.js

@@ -0,0 +1,25 @@
+// A local, append-only audit trail of every mutating CDK run (deploy / destroy /
+// import / prune). Each line of `cargo.state.audit.jsonl` records who ran what,
+// against which workspace, and the outcome — so a workspace's change history is
+// reconstructable without a backend. It's a local operational log; git-ignore it.
+import { randomUUID } from "node:crypto";
+import { appendFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+const AUDIT_FILE = "cargo.state.audit.jsonl";
+/** A short, unique id for one CDK run, surfaced to the user and the audit log. */
+export function newRunId() {
+    return randomUUID().slice(0, 8);
+}
+function auditPath(root) {
+    const dir = isAbsolute(root) ? root : resolve(process.cwd(), root);
+    return join(dir, AUDIT_FILE);
+}
+/** Append one audit record. Best-effort — never throws into the caller. */
+export function appendAudit(root, entry) {
+    try {
+        appendFileSync(auditPath(root), `${JSON.stringify(entry)}\n`);
+    }
+    catch {
+        // a failed audit write must not fail the command
+    }
+}

package/build/src/deploy/compile.d.ts

@@ -0,0 +1,36 @@
+import { type ResourceKind, type ResourceNode } from "../core.js";
+export type ChangeType = "create" | "update" | "noop" | "delete";
+export type PlanEntry = {
+    id: string;
+    kind: ResourceKind;
+    slug: string;
+    change: ChangeType;
+    hash: string;
+};
+export type ValidationError = {
+    id: string;
+    message: string;
+};
+export type StateEntry = {
+    hash: string;
+    uuid: string;
+    outputs: Record<string, string>;
+    deps?: string[];
+    live?: string;
+};
+export type State = {
+    version: number;
+    workspaceUuid: string;
+    resources: Record<string, StateEntry>;
+};
+export type CompileInput = {
+    nodes: readonly ResourceNode[];
+    state?: State;
+};
+export type CompileResult = {
+    order: string[];
+    plan: PlanEntry[];
+    errors: ValidationError[];
+};
+export declare function compile(input: CompileInput): CompileResult;
+//# sourceMappingURL=compile.d.ts.map

package/build/src/deploy/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/deploy/compile.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,YAAY,EAElB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEjE,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IAIb,IAAI,EAAE,MAAM,CAAC;IAGb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAIhC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAKhB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AACF,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAGhB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B,CAAC;AAmEF,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,CAuC1D"}

package/build/src/deploy/compile.js

@@ -0,0 +1,99 @@
+// The offline reconcile engine. Pure + testable — no IO, no network. It takes
+// the resources declared via define* (the registry's nodes), validates the
+// token graph, topologically orders it, content-hashes each resource, and diffs
+// against the prior cargo.state.json to produce create/update/noop.
+//
+// Dependencies are derived from tokens embedded in each resource's spec, so the
+// graph is whatever the handle wiring expressed — no string slugs to resolve.
+import { createHash } from "node:crypto";
+import { dependenciesOf, stableStringify, } from "../core.js";
+function hashOf(value) {
+    return ("sha256:" +
+        createHash("sha256")
+            .update(stableStringify(value))
+            .digest("hex")
+            .slice(0, 16));
+}
+function validate(nodes, edges) {
+    const errors = [];
+    const ids = new Set(nodes.map((n) => n.id));
+    for (const node of nodes) {
+        for (const dep of edges.get(node.id) ?? new Set()) {
+            if (!ids.has(dep)) {
+                errors.push({
+                    id: node.id,
+                    message: `references unknown resource "${dep}"`,
+                });
+            }
+        }
+    }
+    return errors;
+}
+function topoSort(nodes, edges) {
+    const visited = new Map();
+    const order = [];
+    const cycle = [];
+    function visit(id) {
+        const state = visited.get(id);
+        if (state === "done")
+            return true;
+        if (state === "visiting") {
+            cycle.push(id);
+            return false;
+        }
+        visited.set(id, "visiting");
+        for (const dep of edges.get(id) ?? new Set()) {
+            if (!edges.has(dep))
+                continue; // unknown dep — reported by validate()
+            if (!visit(dep)) {
+                cycle.push(id);
+                return false;
+            }
+        }
+        visited.set(id, "done");
+        order.push(id);
+        return true;
+    }
+    const ids = nodes.map((n) => n.id).sort();
+    for (const id of ids) {
+        if (cycle.length > 0)
+            break;
+        visit(id);
+    }
+    return { order, cycle };
+}
+export function compile(input) {
+    const { nodes } = input;
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const edges = new Map();
+    for (const node of nodes) {
+        edges.set(node.id, dependenciesOf(node.spec));
+    }
+    const errors = validate(nodes, edges);
+    const { order, cycle } = topoSort(nodes, edges);
+    if (cycle.length > 0) {
+        errors.push({
+            id: cycle[0] ?? "(graph)",
+            message: `cyclic dependency: ${cycle.join(" → ")}`,
+        });
+    }
+    const plan = order.map((id) => {
+        const node = byId.get(id);
+        const hash = hashOf(node.spec);
+        const prior = input.state?.resources[id];
+        const change = prior === undefined ? "create" : prior.hash === hash ? "noop" : "update";
+        return { id, kind: node.kind, slug: node.slug, change, hash };
+    });
+    // Resources in state but no longer in code — candidates to prune. Appended
+    // after the apply order; the actual removal runs in dependency-safe order.
+    const deletes = [];
+    for (const [id, entry] of Object.entries(input.state?.resources ?? {})) {
+        if (byId.has(id))
+            continue;
+        const kind = id.slice(0, id.indexOf(":"));
+        const slug = id.slice(id.indexOf(":") + 1);
+        deletes.push({ id, kind, slug, change: "delete", hash: entry.hash });
+    }
+    deletes.sort((a, b) => a.id.localeCompare(b.id));
+    return { order, plan: [...plan, ...deletes], errors };
+}

package/build/src/deploy/destroy.d.ts

@@ -0,0 +1,20 @@
+import type { Api } from "@cargo-ai/api";
+export type DestroyResult = {
+    removed: string[];
+    released: string[];
+};
+/**
+ * Remove the given state ids in dependency-safe order (dependents first),
+ * releasing adopted resources instead of deleting them, and persisting state
+ * after each. Shared by `destroy` (tear down all) and deploy's `--prune` (remove
+ * resources dropped from code).
+ */
+export declare function removeResources(root: string, api: Api, ids: string[]): Promise<DestroyResult>;
+/**
+ * Tear down state-tracked resources. With `target`, removes just that id;
+ * otherwise removes everything in state.
+ */
+export declare function destroy(root: string, api: Api, opts?: {
+    target?: string;
+}): Promise<DestroyResult>;
+//# sourceMappingURL=destroy.d.ts.map

package/build/src/deploy/destroy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destroy.d.ts","sourceRoot":"","sources":["../../../src/deploy/destroy.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAMzC,MAAM,MAAM,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAkGtE;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EAAE,GACZ,OAAO,CAAC,aAAa,CAAC,CA4BxB;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,GAAG,EACR,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,OAAO,CAAC,aAAa,CAAC,CA4BxB"}

package/build/src/deploy/destroy.js

@@ -0,0 +1,153 @@
+// destroy — tear down resources recorded in cargo.state.json (everything, or a
+// single target id), deleting by uuid in dependency-safe order (dependents
+// before their dependencies) and persisting state after each removal.
+//
+// Deletion is always by the stored uuid: play and agent have no slug, so the
+// state entry is the only handle on them.
+import { readState, writeState } from "./state.js";
+// Coarse fallback order (dependents first) used as the tiebreak between
+// resources with no recorded dependency between them, and for state written
+// before per-resource deps were tracked.
+const REMOVE_ORDER = [
+    "context",
+    "play",
+    "agent",
+    "mcpServer",
+    "tool",
+    "worker",
+    "app",
+    "file",
+    "model",
+    "connector",
+    "folder",
+];
+const KNOWN_KINDS = new Set(REMOVE_ORDER);
+function kindOf(id) {
+    const colon = id.indexOf(":");
+    const kind = colon === -1 ? "" : id.slice(0, colon);
+    if (!KNOWN_KINDS.has(kind)) {
+        // A malformed or future-scheme state id would otherwise reach `remove`'s
+        // switch, match no case, no-op, and still get deleted from state — silently
+        // orphaning the live resource. Refuse loudly instead.
+        throw new Error(`cannot destroy "${id}": unrecognized resource kind "${kind}". Refusing ` +
+            `to drop state for an entry it can't delete.`);
+    }
+    return kind;
+}
+// Order the ids so a resource is removed before anything it depends on
+// (dependents first), using the deps recorded in state. Within an independent
+// group, REMOVE_ORDER breaks the tie. Cycles can't occur (the apply graph is a
+// DAG); a stray self/missing edge is simply ignored.
+function removalOrder(ids, state) {
+    const inSet = new Set(ids);
+    // We DFS post-order (dependencies-first) then reverse for dependents-first, so
+    // seed + recurse in REVERSE REMOVE_ORDER → ties come out in REMOVE_ORDER.
+    const reverseKind = (a, b) => REMOVE_ORDER.indexOf(kindOf(b)) - REMOVE_ORDER.indexOf(kindOf(a));
+    const seeds = [...ids].sort(reverseKind);
+    const visited = new Set();
+    const postorder = [];
+    const visit = (id) => {
+        if (visited.has(id))
+            return;
+        visited.add(id);
+        const deps = (state.resources[id]?.deps ?? [])
+            .filter((dep) => inSet.has(dep) && dep !== id)
+            .sort(reverseKind);
+        for (const dep of deps)
+            visit(dep);
+        postorder.push(id);
+    };
+    for (const id of seeds)
+        visit(id);
+    return postorder.reverse();
+}
+async function remove(api, kind, uuid) {
+    switch (kind) {
+        case "connector":
+            return api.connection.connector.remove(uuid);
+        case "model":
+            await api.storage.model.remove(uuid);
+            return;
+        case "play":
+            return api.orchestration.play.remove(uuid);
+        case "agent":
+            return api.ai.agent.remove(uuid);
+        case "tool":
+            return api.orchestration.tool.remove(uuid);
+        case "mcpServer":
+            return api.ai.mcpServer.remove(uuid);
+        case "folder":
+            return api.workspaceManagement.folder.remove(uuid);
+        case "file":
+            return api.content.file.remove(uuid);
+        case "worker":
+            return api.hosting.worker.remove(uuid);
+        case "app":
+            return api.hosting.app.remove(uuid);
+        case "context":
+            // The context repository is a per-workspace singleton with no delete API
+            // (and `defineContext` is additive) — destroy just drops it from state,
+            // never deleting repo files.
+            return;
+    }
+}
+/**
+ * Remove the given state ids in dependency-safe order (dependents first),
+ * releasing adopted resources instead of deleting them, and persisting state
+ * after each. Shared by `destroy` (tear down all) and deploy's `--prune` (remove
+ * resources dropped from code).
+ */
+export async function removeResources(root, api, ids) {
+    const state = readState(root);
+    if (state === undefined)
+        return { removed: [], released: [] };
+    const present = removalOrder(ids.filter((id) => id in state.resources), state);
+    const removed = [];
+    const released = [];
+    for (const id of present) {
+        const entry = state.resources[id];
+        if (entry === undefined)
+            continue;
+        if (entry.outputs["adopted"] === "true") {
+            // Adopted: the CDK linked an existing resource it didn't create. Release
+            // it (drop from state) without deleting the underlying Cargo resource.
+            delete state.resources[id];
+            writeState(root, state);
+            released.push(id);
+            continue;
+        }
+        await remove(api, kindOf(id), entry.uuid);
+        delete state.resources[id];
+        writeState(root, state);
+        removed.push(id);
+    }
+    return { removed, released };
+}
+/**
+ * Tear down state-tracked resources. With `target`, removes just that id;
+ * otherwise removes everything in state.
+ */
+export async function destroy(root, api, opts = {}) {
+    const state = readState(root);
+    if (state === undefined)
+        return { removed: [], released: [] };
+    // Targeting one resource must not leave dependents pointing at a deleted uuid.
+    // Refuse if any other state entry still depends on the target.
+    if (opts.target !== undefined && opts.target in state.resources) {
+        const target = opts.target;
+        const dependents = Object.entries(state.resources)
+            .filter(([id, e]) => id !== target && (e.deps ?? []).includes(target))
+            .map(([id]) => id);
+        if (dependents.length > 0) {
+            throw new Error(`cannot destroy "${target}": ${String(dependents.length)} resource(s) ` +
+                `still depend on it (${dependents.join(", ")}). Remove those first, ` +
+                `or destroy without --target.`);
+        }
+    }
+    const ids = opts.target !== undefined
+        ? opts.target in state.resources
+            ? [opts.target]
+            : []
+        : Object.keys(state.resources);
+    return removeResources(root, api, ids);
+}

package/build/src/deploy/executors.live.d.ts

@@ -0,0 +1,4 @@
+import type { Api } from "@cargo-ai/api";
+import type { Executors } from "./apply.js";
+export declare function liveExecutors(api: Api): Executors;
+//# sourceMappingURL=executors.live.d.ts.map

package/build/src/deploy/executors.live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executors.live.d.ts","sourceRoot":"","sources":["../../../src/deploy/executors.live.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAIzC,OAAO,KAAK,EAAE,SAAS,EAAW,MAAM,YAAY,CAAC;AA4BrD,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,CAyjBjD"}