@fastagent-sh/fastagent 0.29.0 → 0.30.1

package/dist/content/resolve.js

@@ -1,83 +1,58 @@
 /**
  * WHERE each content entry is, for THIS instance: the one answer the prompt, the coding tools, authored tools, `info`
- * and `deploy` all read (docs/design/core.md §2). A repository `context.json` declares is fastagent's clone at
- * `content/<name>`, or this machine's own checkout of it where `context.local.json` binds one; a directory only this
- * machine has is where its binding says. Reads the disk (git included); never the network, never a write. Making a
- * clone real is `cloneContent`'s, and only a process that runs the agent asks for it.
+ * and `deploy` all read (docs/design/core.md §2). A repository is fastagent's clone at `content/<name>` in the
+ * instance's working directory; a directory is where the instance configuration says. Reads the disk (git included);
+ * never the network, never a write. Making a clone real is `cloneContent`'s, and only a process that runs the agent
+ * asks for it.
  */
 import { lstatSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { LOCAL_CONTEXT_FILE, contentEntryPath } from "../paths.js";
+import { contentEntryPath } from "../paths.js";
 import { nestingError } from "./declare.js";
-import { checkoutProblem, refNotice, refreshClone } from "./git.js";
+import { refreshClone } from "./git.js";
 import { ensureContentDir } from "./mount.js";
 /** Resolve the agent's content for this instance. Refuses, naming the entry, what cannot be. */
-export function resolveContent(agentDir, { declared, bound }) {
-    const shared = declared.map((entry) => resolveRepository(agentDir, entry, bound.find((binding) => binding.kind === "checkout" && binding.name === entry.name)));
-    const local = bound
-        .filter((binding) => binding.kind === "local" && statOrMissing(binding.path) !== undefined)
-        .map((binding) => resolveLocal(agentDir, binding));
-    return [...shared, ...local];
+export function resolveContent(declared, places) {
+    return declared.map((entry) => entry.kind === "github" ? resolveRepository(places, entry) : resolveLocal(places, entry));
 }
-/**
- * The bindings of a directory only this machine has that point at nothing here: the directory was moved or removed.
- * Not an error, since the binding is this machine's alone; the agent is not told of it, and whoever opens the agent
- * says so.
- */
-export function contentAbsentHere({ bound }) {
-    return bound.filter((binding) => binding.kind === "local" && statOrMissing(binding.path) === undefined);
-}
-/** What is said of a binding {@link contentAbsentHere} returns, after the word "content". */
-export function absentNotice(binding) {
-    return (`${binding.name}: bound in ${LOCAL_CONTEXT_FILE} to ${binding.path}, which does not exist here: the agent is ` +
-        `not told of it`);
-}
-function resolveRepository(agentDir, entry, checkout) {
+function resolveRepository({ workdir }, entry) {
     const { name, description } = entry;
-    const repository = {
-        name,
-        ...(description !== undefined ? { description } : {}),
-        kind: "github",
-        repo: entry.repo,
-        ...(entry.ref !== undefined ? { ref: entry.ref } : {}),
-    };
-    if (checkout !== undefined && statOrMissing(checkout.path) !== undefined) {
-        const location = realpathSync(checkout.path);
-        const notices = checkBinding(agentDir, name, location, entry);
-        return { ...repository, location, notices, clone: false };
-    }
-    const location = contentEntryPath(agentDir, name);
+    const location = contentEntryPath(workdir, name);
     const found = lstatOrMissing(location);
     if (found?.isSymbolicLink()) {
         throw new Error(`content "${name}": content/${name} is a link, and content/ holds only the clones fastagent makes — remove ` +
-            `the link, and bind a checkout of your own in ${LOCAL_CONTEXT_FILE} instead (fastagent content add <dir>)`);
+            `the link, and add the directory it points at as content of its own (fastagent content add <dir>)`);
     }
     if (found && !found.isDirectory())
         throw new Error(`content "${name}": ${location} is not a directory`);
-    const notices = found ? [] : ["not cloned yet: it is cloned when the agent starts"];
-    if (checkout !== undefined) {
-        notices.unshift(`bound in ${LOCAL_CONTEXT_FILE} to ${checkout.path}, which does not exist here: the clone is used`);
-    }
-    return { ...repository, location, notices, clone: true };
-}
-function resolveLocal(agentDir, binding) {
-    const { name, description } = binding;
-    const location = realpathSync(binding.path);
-    checkBinding(agentDir, name, location);
     return {
         name,
         ...(description !== undefined ? { description } : {}),
+        kind: "github",
+        repo: entry.repo,
+        ...(entry.ref !== undefined ? { ref: entry.ref } : {}),
         location,
-        notices: [],
+        notices: found ? [] : ["not cloned yet: it is cloned when the agent starts"],
+    };
+}
+function resolveLocal(places, entry) {
+    const { name, description } = entry;
+    checkDirectory(places, name, entry.path);
+    return {
+        name,
+        ...(description !== undefined ? { description } : {}),
         kind: "local",
+        location: realpathSync(entry.path),
+        notices: [],
     };
 }
 /**
- * Whether the content `name` can be bound to the directory `target` of this machine: a directory, apart from the agent
- * directory, and for a declared repository the root of a checkout of it. Returns what to tell the user (a checkout off
- * its `ref`); refuses, naming the entry, what cannot be.
+ * Whether the content `name` can be the directory `target` of this machine: one that exists, and is apart from the
+ * definition's directory, since a definition is released, content is kept, and one directory cannot be both. The
+ * working directory is the instance's own writable place, so a directory inside it is only a directory the agent
+ * already reaches. Refuses, naming the entry, what cannot be.
  */
-export function checkBinding(agentDir, name, target, repository) {
+export function checkDirectory({ dir }, name, target) {
     const stat = statOrMissing(target);
     if (!stat)
         throw new Error(`content "${name}": ${target} does not exist`);
@@ -85,25 +60,16 @@ export function checkBinding(agentDir, name, target, repository) {
         throw new Error(`content "${name}": ${target} is not a directory`);
     // A symlink can still put one inside the other, so ask of the real paths — including for an agent directory `init`
     // is about to create, which a symlinked ancestor still places.
-    const nested = nestingError(realPathOf(agentDir), realpathSync(target), name);
+    const nested = nestingError(realPathOf(dir), realpathSync(target), name);
     if (nested)
         throw new Error(nested);
-    if (repository === undefined)
-        return [];
-    const problem = checkoutProblem(target, repository.repo);
-    if (problem)
-        throw new Error(`content "${name}": ${target} ${problem}`);
-    const offRef = repository.ref === undefined ? undefined : refNotice(target, repository.ref);
-    return offRef ? [offRef] : [];
 }
 /**
  * Make a clone real, or bring it up to date at its `ref` in place, by git's rules, which never overwrite what the
  * agent did in it (git.ts `refreshClone`): what git refuses, or a remote that cannot be reached, keeps it as it is,
- * with the reason. Only a process that runs the agent calls this. A checkout this machine binds is never cloned over.
+ * with the reason. Only a process that runs the agent calls this.
  */
 export async function cloneContent(entry, env = process.env) {
-    if (!entry.clone)
-        throw new Error(`content "${entry.name}" is bound to the checkout ${entry.location}, not a clone`);
     ensureContentDir(dirname(entry.location));
     return refreshClone(entry.repo, entry.ref, entry.location, env).catch((error) => {
         throw new Error(`content "${entry.name}": ${error.message}`);

package/dist/content/source.d.ts

@@ -1,4 +1,4 @@
-import { type ContentBinding, type ContentEntry } from "./declare.ts";
+import { type ContentEntry } from "./declare.ts";
 export interface SourceOptions {
     name?: string;
     /** A github entry's branch, tag or commit. */
@@ -6,19 +6,18 @@ export interface SourceOptions {
     description?: string;
 }
 /**
- * A content entry to add, by name: the repository `context.json` declares for every instance, this machine's binding
- * in `context.local.json`, or both (a checkout of the declared repository). At least one.
+ * A content entry to add, by name. It is written to the instance's `fastagent.json`, or, with `program`, to the
+ * program's `context.json`, which every instance of it reaches and so holds repositories only.
  */
 export interface ContentAddition {
     name: string;
-    entry?: ContentEntry;
-    binding?: ContentBinding;
+    entry: ContentEntry;
+    program?: boolean;
 }
 /**
  * The addition `source` asks for, with what to tell the user about how it was read. `github:owner/repo` is a
- * repository fastagent clones. The root of a checkout whose `origin` is on GitHub is that repository, declared for
- * every instance and bound to this checkout here. Any other directory, a subdirectory of such a checkout included, is
- * bound on this machine alone. The name defaults to the repository's or the directory's.
+ * repository fastagent clones. Any other source is a directory the agent works in as it is, a checkout of a GitHub
+ * repository included, which is then said. The name defaults to the repository's or the directory's.
  */
 export declare function readContentSource(source: string, cwd: string, options?: SourceOptions): {
     addition: ContentAddition;

package/dist/content/source.js

@@ -1,52 +1,34 @@
 /**
  * What a command's `<source>` adds (`init --content`, `fastagent content add`; docs/design/agent-cli.md §3), read the
- * same way by both: `github:owner/repo`, the root of a GitHub checkout, or any other directory.
+ * same way by both: `github:owner/repo`, or a directory.
  */
-import { realpathSync } from "node:fs";
 import { basename, resolve } from "node:path";
 import { isGithubRepo } from "./declare.js";
 import { checkoutOf, githubRepoOf } from "./git.js";
 /**
  * The addition `source` asks for, with what to tell the user about how it was read. `github:owner/repo` is a
- * repository fastagent clones. The root of a checkout whose `origin` is on GitHub is that repository, declared for
- * every instance and bound to this checkout here. Any other directory, a subdirectory of such a checkout included, is
- * bound on this machine alone. The name defaults to the repository's or the directory's.
+ * repository fastagent clones. Any other source is a directory the agent works in as it is, a checkout of a GitHub
+ * repository included, which is then said. The name defaults to the repository's or the directory's.
  */
 export function readContentSource(source, cwd, options = {}) {
-    const treated = {
-        ...(options.description !== undefined ? { description: options.description } : {}),
-    };
-    const ref = options.ref !== undefined ? { ref: options.ref } : {};
+    const treated = options.description !== undefined ? { description: options.description } : {};
     const repoName = (repo) => repo.slice(repo.indexOf("/") + 1);
     if (source.startsWith("github:")) {
         const repo = source.slice("github:".length);
         if (!isGithubRepo(repo))
             throw new Error(`${source} names no repository: write github:owner/repo`);
+        const ref = options.ref !== undefined ? { ref: options.ref } : {};
         return {
             addition: { name: options.name ?? repoName(repo), entry: { github: repo, ...ref, ...treated } },
             notes: [],
         };
     }
+    if (options.ref !== undefined) {
+        throw new Error(`--ref applies to a repository, and ${resolve(cwd, source)} is a directory`);
+    }
     const dir = resolve(cwd, source);
     const checkout = checkoutOf(dir);
     const repo = checkout?.origin === undefined ? undefined : githubRepoOf(checkout.origin);
-    const atRoot = checkout !== undefined && realpathSync(dir) === realpathSync(checkout.root);
-    if (repo !== undefined && atRoot) {
-        const root = checkout.root;
-        return {
-            addition: {
-                name: options.name ?? repoName(repo),
-                entry: { github: repo, ...ref, ...treated },
-                binding: { path: root },
-            },
-            notes: [],
-        };
-    }
-    if (options.ref !== undefined) {
-        throw new Error(`--ref applies to a repository, and ${dir} is bound as a directory of this machine`);
-    }
-    const notes = repo !== undefined && !atRoot
-        ? [`${dir} is in a checkout of github ${repo}: add github:${repo} for the whole repository`]
-        : [];
-    return { addition: { name: options.name ?? basename(dir), binding: { path: dir, ...treated } }, notes };
+    const notes = repo === undefined ? [] : [`${dir} is in a checkout of github ${repo}: add github:${repo} to have it cloned`];
+    return { addition: { name: options.name ?? basename(dir), entry: { path: dir, ...treated } }, notes };
 }

package/dist/credentials-page.d.ts

@@ -0,0 +1,26 @@
+import type { SetupGuide } from "./channels/setup.ts";
+/** What the person pastes at one step: its fields are checked together. */
+export interface CredentialsStep {
+    label: string;
+    guide: SetupGuide;
+    fields: readonly {
+        name: string;
+        label: string;
+        secret?: boolean;
+    }[];
+}
+export interface CredentialsPage {
+    url: string;
+    /** Settles once every value was accepted; rejects when `accept` failed for a reason other than a refusal. */
+    done: Promise<void>;
+    close(): Promise<void>;
+}
+export declare function startCredentialsPage(input: {
+    /** "Connect Slack". */
+    title: string;
+    /** What the done page says: "Slack connected". */
+    doneHeading: string;
+    steps: readonly CredentialsStep[];
+    /** Check a step's values and keep them. Throws {@link SetupRefused} to stay on the form with the reason; anything else ends the page. */
+    accept(step: number, values: Record<string, string>): Promise<void>;
+}): Promise<CredentialsPage>;

package/dist/credentials-page.js

@@ -0,0 +1,185 @@
+/**
+ * The page where a person pastes the values a channel's setup needs, for a setup that has no terminal (a coding agent's
+ * `--json`): loopback only, one use, and each value goes from the browser to this process and nowhere else (see
+ * setup-page.ts for why it is never the agent's conversation). Each value is checked as it is pasted and handed to
+ * `accept` at once, so a step that passed stays accepted when another is refused: the form then asks only for what is left.
+ */
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { SetupRefused } from "./channels/setup.js";
+import { field, formCard, openButton, privacy, prose, refusal, sendPage, setupRequestUrl, statusCard, step, submit, } from "./setup-page.js";
+function readBody(request) {
+    return new Promise((resolve) => {
+        let body = "";
+        let tooLarge = false;
+        request.on("data", (chunk) => {
+            if (tooLarge)
+                return;
+            body += String(chunk);
+            if (Buffer.byteLength(body) > 16 * 1024)
+                tooLarge = true;
+        });
+        request.on("end", () => resolve(tooLarge ? undefined : body));
+        request.on("error", () => resolve(undefined));
+    });
+}
+// A browser can leave during validation, before either response event can be subscribed to.
+function afterResponse(response, complete) {
+    if (response.destroyed || response.writableFinished)
+        complete();
+    else
+        response.once("close", complete);
+}
+export async function startCredentialsPage(input) {
+    const path = `/setup/${randomBytes(24).toString("hex")}`;
+    const { promise: done, resolve, reject } = Promise.withResolvers();
+    const accepted = new Set();
+    let checking = false;
+    let used = false;
+    let port = 0;
+    const form = (problem) => formCard(input.title, input.steps
+        .map(({ label, guide, fields }, index) => {
+        if (accepted.has(index))
+            return step(index + 1, label, prose(`Saved.`));
+        const here = problem?.step === index ? problem.refusal : undefined;
+        return step(index + 1, label, prose(guide.instructions) +
+            (guide.url === undefined ? "" : openButton("Open", guide.url)) +
+            (here === undefined
+                ? ""
+                : refusal(here.message, here.fix === undefined ? undefined : ` ${here.fix}`, here.why)) +
+            fields
+                .map((one, position) => field({
+                id: one.name,
+                label: one.label,
+                secret: one.secret ?? true,
+                invalid: here !== undefined,
+                autofocus: here !== undefined && position === 0,
+            }))
+                .join(""));
+    })
+        .join("") +
+        submit("Save and check") +
+        privacy());
+    const server = createServer(async (request, response) => {
+        const url = setupRequestUrl(request, response);
+        if (url === undefined)
+            return;
+        const host = request.headers.host ?? "";
+        if (host !== `127.0.0.1:${port}` && host !== `localhost:${port}`) {
+            response.writeHead(421).end("misdirected request\n");
+            return;
+        }
+        if (url.pathname !== path || (request.method !== "GET" && request.method !== "POST")) {
+            response.writeHead(404).end("not found\n");
+            return;
+        }
+        const expired = () => sendPage(response, 404, {
+            title: "FastAgent setup",
+            card: statusCard({
+                state: "failed",
+                heading: "This page is no longer in use",
+                next: "Go back to your coding agent.",
+            }),
+        });
+        if (used) {
+            expired();
+            return;
+        }
+        if (request.method === "GET") {
+            sendPage(response, 200, { title: `${input.title} — FastAgent`, card: form() });
+            return;
+        }
+        const site = request.headers["sec-fetch-site"];
+        if (site !== undefined && site !== "same-origin") {
+            response.writeHead(403).end("forbidden\n");
+            return;
+        }
+        const body = await readBody(request);
+        if (body === undefined) {
+            response.writeHead(413).end("payload too large\n");
+            return;
+        }
+        if (used) {
+            expired();
+            return;
+        }
+        if (checking) {
+            response.writeHead(409).end("another submission is being checked\n");
+            return;
+        }
+        checking = true;
+        const pasted = new URLSearchParams(body);
+        try {
+            for (const [index, { fields }] of input.steps.entries()) {
+                if (accepted.has(index))
+                    continue;
+                try {
+                    const values = {};
+                    for (const { name, label } of fields) {
+                        const value = (pasted.get(name) ?? "").trim();
+                        if (value === "")
+                            throw new SetupRefused(`${label} is needed.`);
+                        values[name] = value;
+                    }
+                    await input.accept(index, values);
+                    accepted.add(index);
+                }
+                catch (error) {
+                    // Only a refusal stays on the form; infrastructure and persistence errors end the setup.
+                    if (!(error instanceof SetupRefused))
+                        throw error;
+                    checking = false;
+                    sendPage(response, 200, { title: `${input.title} — FastAgent`, card: form({ step: index, refusal: error }) });
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            checking = false;
+            used = true;
+            afterResponse(response, () => reject(error));
+            sendPage(response, 200, {
+                title: "Setup stopped — FastAgent",
+                card: statusCard({
+                    state: "failed",
+                    heading: "Setup stopped",
+                    lede: error instanceof Error ? error.message : String(error),
+                    next: "Go back to your coding agent.",
+                }),
+            });
+            return;
+        }
+        used = true;
+        afterResponse(response, resolve);
+        sendPage(response, 200, {
+            title: `${input.doneHeading} — FastAgent`,
+            card: statusCard({
+                state: "done",
+                heading: input.doneHeading,
+                lede: "Your coding agent will say if anything is left to do.",
+                next: "Go back to your coding agent.",
+            }),
+        });
+    });
+    await new Promise((resolveListening, rejectListening) => {
+        server.once("error", rejectListening);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", rejectListening);
+            resolveListening();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("the credentials page did not receive a local TCP port");
+    }
+    port = address.port;
+    return {
+        url: `http://127.0.0.1:${port}${path}`,
+        done,
+        close: () => new Promise((resolveClosed) => {
+            server.close(() => resolveClosed());
+            server.closeAllConnections();
+        }),
+    };
+}

package/dist/declared-secrets.d.ts

@@ -19,19 +19,26 @@ export interface DeclaredSecret {
     name: string;
     /** Where it was declared: "src/tools/x-post.ts", "fastagent.config.ts providers[0]", "context.json" — printed in
      *  runbooks and failures, so it must name a place the author can open. */
-    source: string;
+    declaredIn: string;
     /** What it is for, when the declaration says (`context.json`'s variables do): printed beside it in runbooks. */
     description?: string;
     /** The code runs without it: no start is refused for its absence. */
-    optional?: boolean;
+    optional: boolean;
+    /** Declared by one way of a channel that receives either way (`byIngress`): read only when it receives that way. */
+    when?: {
+        channel: string;
+        ingress: "webhook" | "connection";
+    };
 }
 /** Whether `name` has the shape of an env-var name ({@link ENV_NAME}). */
 export declare function isEnvName(name: string): boolean;
 /** Declared names as a stable list, first declaration winning — the form a carrier iterates. */
 export declare function dedupeSecrets(declared: readonly DeclaredSecret[]): DeclaredSecret[];
+/** The values of `secrets` that are set: what an environment is made of, since a name given no value is not one. */
+export declare function definedValues(secrets: Readonly<Record<string, string | undefined>>): Record<string, string>;
 /** Required names with no value in `env` — empty string counts as missing (an unset `.env` line). A name some
  *  declaration requires is required, whatever another says. */
-export declare function missingSecrets(declared: readonly DeclaredSecret[], env?: NodeJS.ProcessEnv): DeclaredSecret[];
+export declare function missingSecrets(declared: readonly DeclaredSecret[], env: NodeJS.ProcessEnv): DeclaredSecret[];
 /** "X_API_KEY, X_API_SECRET (src/tools/x-post.ts); SLACK_TOKEN (src/channels/slack.ts)" — grouped by the
  *  file to open, since that is the unit the author fixes. */
 export declare function describeSecrets(declared: readonly DeclaredSecret[]): string;

package/dist/declared-secrets.js

@@ -30,17 +30,21 @@ export function dedupeSecrets(declared) {
     const seen = new Set();
     return declared.filter((s) => !seen.has(s.name) && seen.add(s.name));
 }
+/** The values of `secrets` that are set: what an environment is made of, since a name given no value is not one. */
+export function definedValues(secrets) {
+    return Object.fromEntries(Object.entries(secrets).filter((entry) => entry[1] !== undefined));
+}
 /** Required names with no value in `env` — empty string counts as missing (an unset `.env` line). A name some
  *  declaration requires is required, whatever another says. */
-export function missingSecrets(declared, env = process.env) {
-    return dedupeSecrets(declared.filter((s) => s.optional !== true)).filter((s) => !env[s.name]);
+export function missingSecrets(declared, env) {
+    return dedupeSecrets(declared.filter((s) => !s.optional)).filter((s) => !env[s.name]);
 }
 /** "X_API_KEY, X_API_SECRET (src/tools/x-post.ts); SLACK_TOKEN (src/channels/slack.ts)" — grouped by the
  *  file to open, since that is the unit the author fixes. */
 export function describeSecrets(declared) {
     const bySource = new Map();
-    for (const { name, source } of dedupeSecrets(declared)) {
-        bySource.set(source, [...(bySource.get(source) ?? []), name]);
+    for (const { name, declaredIn } of dedupeSecrets(declared)) {
+        bySource.set(declaredIn, [...(bySource.get(declaredIn) ?? []), name]);
     }
     return [...bySource].map(([source, names]) => `${names.join(", ")} (${source})`).join("; ");
 }

package/dist/deploy/agentcore/destroy.d.ts

@@ -1,11 +1,14 @@
 /**
  * `destroy agentcore`: removing what a deploy created, INCLUDING the parts the stack does not own.
  *
- * `aws cloudformation delete-stack` is the obvious move and it leaves three of the four behind, each for its own
+ * `aws cloudformation delete-stack` is the obvious move and it leaves most of them behind, each for its own
  * reason:
  *
  * - the S3 artifact bucket and the ECR repository must exist BEFORE the stack (it reads the forwarder's zip and
  *   the runtime's image from them), so they cannot be stack resources;
+ * - the Secrets Manager secret holds the deployment's values, which must exist before the first deploy and survive a
+ *   stack update, so it is no stack resource either; it is deleted without a recovery window, since a window would
+ *   keep its name from the next deployment of the agent (its values are pushed again from their source);
  * - the forwarder's log group is created by AWS on the Lambda's first WRITE, so no template ever mentions it —
  *   and the deploy put a 14-day retention on it, i.e. it holds data;
  * - the EventBridge schedules are minted at RUNTIME by the container: a recurring one per `schedules/` file, which

package/dist/deploy/agentcore/destroy.js

@@ -1,5 +1,5 @@
 import { awsCli, awsJson, parseLogGroupNames } from "./aws-cli.js";
-import { agentcoreRepoName, agentcoreStackName, deploymentBucketName, forwarderLogGroup, runtimeLogGroupPrefix, recurringSchedulePrefix, toRuntimeName, wakeAlarmPrefix, } from "./plan.js";
+import { agentcoreRepoName, agentcoreSecretName, agentcoreStackName, deploymentBucketName, forwarderLogGroup, runtimeLogGroupPrefix, recurringSchedulePrefix, toRuntimeName, wakeAlarmPrefix, } from "./plan.js";
 /** S3 deletes at most 1000 keys per call. */
 const DELETE_BATCH = 1000;
 /**
@@ -109,6 +109,19 @@ export async function destroyAgentcoreDeployment(plan, runner, announce = () =>
         return gate(`could not tell whether repository ${repo} exists in ${region}: ${repoRead.unreadable}`);
     }
     const repoExists = "ok" in repoRead;
+    const secretName = agentcoreSecretName(plan.name);
+    const secretRead = await aws.present([
+        "secretsmanager",
+        "describe-secret",
+        "--secret-id",
+        secretName,
+        "--output",
+        "json",
+    ]);
+    if ("unreadable" in secretRead) {
+        return gate(`could not tell whether secret ${secretName} exists in ${region}: ${secretRead.unreadable}`);
+    }
+    const secretExists = "ok" in secretRead;
     // BOTH LOG GROUPS. AWS creates each on the first WRITE, so neither is a stack resource — same reason, twice —
     // and the runtime's holds the agent's own stdout/stderr, i.e. what it said in every conversation. `deploy`'s
     // runbook already knows there are two: it sets a retention on each.
@@ -173,6 +186,8 @@ export async function destroyAgentcoreDeployment(plan, runner, announce = () =>
         found.push(`bucket ${bucket} (${keys.length} object version(s))`);
     if (repoExists)
         found.push(`repository ${repo}`);
+    if (secretExists)
+        found.push(`secret ${secretName} (its values are deleted for good, with no recovery window)`);
     for (const name of listedGroups)
         found.push(`log group ${name}`);
     // The one thing this command refuses to delete.
@@ -245,6 +260,15 @@ export async function destroyAgentcoreDeployment(plan, runner, announce = () =>
     if (repoExists) {
         await attempt(`repository ${repo}`, ["ecr", "delete-repository", "--repository-name", repo, "--force"]);
     }
+    if (secretExists) {
+        await attempt(`secret ${secretName}`, [
+            "secretsmanager",
+            "delete-secret",
+            "--secret-id",
+            secretName,
+            "--force-delete-without-recovery",
+        ]);
+    }
     for (const name of logGroups) {
         await attempt(`log group ${name}`, ["logs", "delete-log-group", "--log-group-name", name]);
     }

package/dist/deploy/agentcore/forwarder.js

@@ -1,6 +1,6 @@
 // Generated by `fastagent deploy agentcore` — the deployment's only ingress.
 // (Inside fastagent this file IS the source; the sentence below applies to the copy it is emitted as,
-// the agent directory's `lambda/index.js`.)
+// the agent directory's `agentcore/forwarder/index.js`.)
 // REGENERATED ON EVERY DEPLOY; edits here are overwritten and never deployed. `--run` builds the
 // Lambda package from fastagent's own copy of this source, so this file is the readable MIRROR of
 // what runs (and what the manual runbook zips) — not an input you can change.

package/dist/deploy/agentcore/plan.d.ts

@@ -10,8 +10,7 @@ export interface AgentcorePlanInput extends ContainerInput {
      */
     channels: readonly DeclaredChannel[];
     /**
-     * The runbook's variable list (`deploymentSecrets`): what must have a value, then everything else the value file
-     * carries.
+     * The runbook's variable list (`deploymentSecrets`): the declared names, each hinted by the file that declared it.
      */
     secrets?: readonly DeploymentSecret[];
     /**
@@ -51,7 +50,7 @@ export declare const SECRETS_DIR = "/mnt/data/.secrets";
 export declare const DEFAULT_IDLE_TIMEOUT_SECONDS = 180;
 /** One session's compute lifetime — AWS's own default. Both lifecycle fields cap at 1209600 (14 d). */
 export declare const MAX_LIFETIME_SECONDS = 28800;
-export declare const FORWARDER_FILE = "lambda/index.js";
+export declare const FORWARDER_FILE = "agentcore/forwarder/index.js";
 /**
  * Where the forwarder puts the one-shot schedule for a wake-up. The id inside the name is minted in the
  * container, so this prefix is the only handle anything outside has on the alarms a deployment has pending.
@@ -64,23 +63,10 @@ export declare function wakeAlarmPrefix(name: string): string;
 export declare function recurringSchedulePrefix(name: string): string;
 /** Account-suffixed artifact bucket for S3's global namespace. */
 export declare function deploymentBucketName(name: string, account: string): string;
-/**
- * AgentCore env values max 2048 chars — a value file's variables easily exceed it, so the carrier is CHUNKED across
- * `<NAME>` + `_2`… (collectChunked reassembles at boot).
- */
-export declare const CARRIER_CHUNK_SIZE = 2000;
-export declare const CARRIER_MAX_CHUNKS = 4;
-/** The template's chunked carrier: CloudFormation parameter prefix → container env-var name. */
-export declare const CARRIERS: readonly [{
-    readonly param: "FastagentEnv";
-    readonly env: "FASTAGENT_ENV";
-    readonly what: "base64 JSON of the value file's variables";
-}];
-/** Chunk `i` (0-based) of a carrier: its parameter and env-var names. */
-export declare function carrierChunk(carrier: (typeof CARRIERS)[number], i: number): {
-    param: string;
-    env: string;
-};
+/** The Secrets Manager secret holding a deployment's values: one JSON object of NAME → value (agent-artifact.md §6.2). */
+export declare function agentcoreSecretName(name: string): string;
+/** The environment variable that tells the container which secret to read at its first invocation. */
+export declare const SECRET_ARN_ENV = "FASTAGENT_SECRET_ARN";
 /** The generated template's filename (namespaced under the kit in the agentDir layout). */
 export declare const TEMPLATE_FILE = "agentcore.template.yaml";
 /** The generated template's first-line marker. */
@@ -122,7 +108,7 @@ export declare const PROBE_PAYLOAD: string;
 export declare function ingressSessionId(name: string): string;
 /**
  * The forwarder Lambda source — `forwarder.js` beside this file, the ONE text both the deployment package and the
- * readable `lambda/index.js` artifact are generated from.
+ * readable `agentcore/forwarder/index.js` artifact are generated from.
  */
 export declare function forwarderSource(): string;
 /** Compute the AgentCore deploy plan from the resolved definition. */