@fastagent-sh/fastagent 0.24.4 → 0.26.0

package/dist/cli/commands/deploy/agentcore.js

@@ -1,32 +1,26 @@
 /**
- * `deploy agentcore`: one CloudFormation stack (runtime + forwarder Lambda behind a Function URL + EventBridge
- * schedules); no resident process.
+ * `deploy agentcore`: one CloudFormation stack (runtime + forwarder Lambda behind a Function URL); the container
+ * sets its EventBridge schedules itself; no resident process.
  */
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
-import { FORWARDER_FILE, TEMPLATE_FILE, agentcoreName, agentcoreStackName, forwarderLogGroup, ingressSessionId, isGeneratedAgentcoreTemplate, planAgentcoreDeploy, } from "../../../deploy/agentcore/plan.js";
+import { FORWARDER_FILE, TEMPLATE_FILE, agentcoreName, agentcoreStackName, forwarderLogGroup, PROBE_PAYLOAD, ingressSessionId, isGeneratedAgentcoreTemplate, planAgentcoreDeploy, } from "../../../deploy/agentcore/plan.js";
 import { deployAgentcoreRun, pickStackOutputs } from "../../../deploy/agentcore/run.js";
 import { awsCli, awsJson } from "../../../deploy/agentcore/aws-cli.js";
 import { agentcoreShell } from "../../../deploy/agentcore/shell.js";
 import { awsRunner, spawnRunner } from "../../../deploy/runner.js";
 import { SECRET_FILE_MODE, exists } from "../../../paths.js";
-import { loadRoutines } from "../../../schedule/discover.js";
 import { assembleSecrets } from "../../../deploy/secrets.js";
 import { failStartup } from "../../fail.js";
-import { isInteractive } from "../../shared.js";
+import { shellArg } from "../../shared.js";
 import { boxLoginStep, registrarsFor } from "./shared.js";
-/** A copy/paste-safe POSIX shell argument for the command hints deploy prints. */
-function shellArg(value) {
-    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
-}
 export const agentcoreHost = {
     isOurs: (path, content) => path.endsWith(TEMPLATE_FILE) && isGeneratedAgentcoreTemplate(content),
-    artifact: TEMPLATE_FILE,
-    async shell({ workspace }) {
-        const name = agentcoreName(basename(workspace));
+    async shell(agentDir) {
+        const name = agentcoreName(basename(agentDir));
         const stack = agentcoreStackName(name);
-        const aws = awsRunner(workspace);
+        const aws = awsRunner(agentDir);
         const read = await awsCli(aws).read(["cloudformation", "describe-stacks", "--stack-name", stack, "--query", "Stacks[0].Outputs", "--output", "json"], awsJson(pickStackOutputs));
         if ("absent" in read)
             throw new Error(`no AgentCore stack ${stack} in this account/region — deploy it first`);
@@ -37,17 +31,8 @@ export const agentcoreHost = {
             throw new Error(`stack ${stack} has no RuntimeArn output — redeploy it`);
         return agentcoreShell(runtimeArn, ingressSessionId(name), aws);
     },
-    async deploy(ctx) {
-        const { opts, agentDir, workspace, config, channels, longConnectionChannels, pre, write } = ctx;
-        const { modelAuth, boxLogin, container, declaredSecrets, values, valueFile } = pre;
-        if (boxLogin) {
-            console.error(`[fastagent] note: AgentCore resets the runtime's storage on every deploy AND after 14 idle days, and the ` +
-                `${boxLogin} login with it: every deploy of this agent ends with a login on the runtime, and after an idle ` +
-                `reset every turn fails until \`fastagent login ${boxLogin} --deployment agentcore\` (the runtime's log says ` +
-                `so). For an agent that must keep answering unattended, set ${boxLogin}'s API key in ${valueFile}.`);
-        }
-        // Long-connection channels are STRUCTURALLY unsupported: the connection is the ingress, and a reclaimed session
-        // has nothing to wake it.
+    validate({ opts, agentDir, pre }) {
+        const longConnectionChannels = pre.channels.filter((channel) => channel.ingress === "long-connection");
         if (longConnectionChannels.length > 0) {
             const msg = `long-connection channel (${longConnectionChannels.map((c) => c.name).join(", ")}) cannot run on AgentCore — there is no ` +
                 `resident process to hold the connection, and nothing wakes a reclaimed session. Switch the channel ` +
@@ -56,50 +41,37 @@ export const agentcoreHost = {
                 failStartup(new Error(`deploy stopped: ${msg}`));
             console.error(`[fastagent] warn: ${msg}`);
         }
-        // Host capability limit, stated before the image is built rather than left to a line in CloudWatch.
-        if (config.sessionControl === true) {
-            console.error(`[fastagent] warn: sessionControl: true has no effect on AgentCore — /control/* is not served here. This ` +
-                `host's only public ingress relays anonymous traffic to the container as trusted (the forwarder holds the ` +
-                `ingress secret and attaches it), and the plane has nothing of its own to verify. Steer sessions from a ` +
-                `host that serves it behind your own auth (docs/design/session-control.md §14).`);
-        }
-        // Wake-ups are a default capability here as everywhere: pending ones are mirrored into one-shot EventBridge
-        // schedules via the forwarder (the wake-alarm mechanism — see deploy/agentcore/plan.ts), which is why every stack
-        // has one.
-        const loaded = await loadRoutines(agentDir).catch(failStartup);
-        if (loaded.failures.length > 0) {
-            failStartup(new Error(`deploy stopped: cannot load routines: ${loaded.failures.map((x) => `${x.label}: ${x.message}`).join("; ")}`));
-        }
-        const acName = agentcoreName(basename(workspace));
-        // Every derived AWS name embeds acName; the tightest ceiling is the Lambda function name
-        // (`fastagent-<name>-forwarder` ≤ 64 chars).
-        if (acName.length > 40) {
-            failStartup(new Error(`deploy stopped: the directory name maps to "${acName}" (${acName.length} chars) — AWS resource ` +
+        const name = agentcoreName(basename(agentDir));
+        // The forwarder Lambda name embeds this name and must fit AWS's 64-character limit.
+        if (name.length > 40) {
+            failStartup(new Error(`deploy stopped: the directory name maps to "${name}" (${name.length} chars) — AWS resource ` +
                 `names derived from it exceed their limits past 40 chars. Deploy from a shorter directory name.`));
         }
+    },
+    async deploy(ctx) {
+        const { opts, agentDir, config, channels, pre, write } = ctx;
+        const { modelAuth, boxLogin, container, declaredSecrets, values, valueFile } = pre;
+        if (boxLogin) {
+            console.error(`[fastagent] note: AgentCore resets the runtime's storage on every deploy AND after 14 idle days, and the ` +
+                `${boxLogin} login with it: every deploy of this agent ends with a login on the runtime, and after an idle ` +
+                `reset every turn fails until \`fastagent login ${boxLogin} --deployment agentcore\` (the runtime's log says ` +
+                `so). For an agent that must keep answering unattended, set ${boxLogin}'s API key in ${valueFile}.`);
+        }
+        // Schedules and wake-ups need nothing from the template beyond the forwarder every stack has: the container
+        // mirrors them into EventBridge schedules itself (schedule/wake-alarm.ts). A schedule that does not build is the
+        // pre-flight's to report.
+        const acName = agentcoreName(basename(agentDir));
         const plan = planAgentcoreDeploy({
             name: acName,
             boxLogin,
             channels,
             secrets: pre.secrets,
-            // ONLY THE ONES WITH A CRON become rules. A routine without one is reached by NAME, through this host's
-            // IAM-gated `routine-run` envelope (channels/agentcore.ts) rather than a route — so it needs no rule and
-            // loses nothing by not having one.
-            schedules: loaded.routines.flatMap((r) => r.cron === undefined ? [] : [{ name: r.name, cron: r.cron, ...(r.tz !== undefined ? { tz: r.tz } : {}) }]),
             idleTimeoutSeconds: config.deploy?.agentcore?.idleTimeoutSeconds,
             ...container,
         });
-        for (const u of plan.untranslatableSchedules) {
-            // Same discipline as Fly's kept-toml time-trigger gate: a deploy whose schedule silently never fires is worse
-            // than a stopped deploy.
-            const msg = `schedule "${u.name}" cannot be expressed as an EventBridge rule — ${u.reason}`;
-            if (opts.run)
-                failStartup(new Error(`deploy stopped: ${msg}`));
-            console.error(`[fastagent] warn: ${msg} — it will NOT fire on this deployment`);
-        }
-        // The template IS the topology (EventBridge rules, wake wiring, secrets).
+        // The template IS the topology (forwarder, alarm wiring, secrets).
         const templateArtifact = plan.artifacts.find((a) => a.path.endsWith(TEMPLATE_FILE));
-        const templateHome = join(workspace, templateArtifact?.path ?? TEMPLATE_FILE);
+        const templateHome = join(agentDir, templateArtifact?.path ?? TEMPLATE_FILE);
         if (!opts.force && templateArtifact && (await exists(templateHome))) {
             const existing = await readFile(templateHome, "utf8");
             if (isGeneratedAgentcoreTemplate(existing) && existing !== templateArtifact.content) {
@@ -108,44 +80,45 @@ export const agentcoreHost = {
                 // rule (deploy.ts) for every host and every path — stating it a second time here is how the two
                 // wordings drift apart.
                 console.error(`[fastagent] warn: ${templateArtifact.path} no longer matches this definition ` +
-                    `(channels/routines or a deploy.agentcore setting changed) — the kept template would ` +
+                    `(channels or a deploy.agentcore setting changed) — the kept template would ` +
                     `silently drop the difference.`);
             }
         }
         await write(plan.artifacts, {
             force: !!opts.force,
-            alwaysWrite: [`${container.agentPrefix}${FORWARDER_FILE}`],
+            alwaysWrite: [FORWARDER_FILE],
         });
         if (opts.run) {
-            return runDeployAgentcore({
+            await runDeployAgentcore({
                 agentDir,
-                workspace,
-                agentPrefix: container.agentPrefix,
                 name: acName,
                 modelAuth,
                 boxLogin,
-                input: opts.input !== false && isInteractive(),
+                answerer: ctx.answerer,
+                rerun: ctx.rerun,
                 channels,
                 declaredSecrets,
                 values,
                 valueFile,
                 topology: plan.topology,
             });
+            return undefined;
         }
         console.log(plan.runbook.join("\n"));
-        return;
+        return undefined;
     },
 };
 /** `deploy agentcore --run`: drive aws + docker to completion. */
 async function runDeployAgentcore(params) {
-    const { agentDir, workspace, agentPrefix, name, channels, topology } = params;
+    const { agentDir, name, channels, topology } = params;
     // Decided before the first side effect: the deploy resets the runtime's storage and the login with it, so with nobody
     // to log it in again it would end at "not logged in" AFTER replacing a runtime that was serving, with the webhooks
-    // a previous deploy registered still pointing at it.
-    if (params.boxLogin && !params.input) {
+    // a previous deploy registered still pointing at it. A coding agent's ticket has someone: its user.
+    if (params.boxLogin && params.answerer.kind === "nobody") {
         failStartup(new Error(`deploy stopped: every AgentCore deploy wipes the runtime's ${params.boxLogin} login, and without a terminal ` +
-            `nobody can log it in again — run this deploy in a terminal, or set ${params.boxLogin}'s API key in ` +
-            `${params.valueFile}`));
+            `nobody can log it in again — run this deploy in a terminal; from a coding agent, run ` +
+            `\`${params.rerun} --json\`, which hands the login to its user; or set ` +
+            `${params.boxLogin}'s API key in ${params.valueFile}`));
     }
     const { secrets, missingSecrets } = assembleSecrets({
         modelAuth: params.modelAuth,
@@ -162,8 +135,8 @@ async function runDeployAgentcore(params) {
     try {
         const outcome = await deployAgentcoreRun({
             name,
-            templatePath: `${agentPrefix}${TEMPLATE_FILE}`,
-            dockerfilePath: `${agentPrefix}Dockerfile`,
+            templatePath: TEMPLATE_FILE,
+            dockerfilePath: "Dockerfile",
             tag: new Date()
                 .toISOString()
                 .replace(/[-:.TZ]/g, "")
@@ -174,8 +147,8 @@ async function runDeployAgentcore(params) {
             valueFile: params.valueFile,
             channels,
             topology,
-            ...boxLoginStep("agentcore", params, (runtimeArn) => agentcoreShell(runtimeArn, ingressSessionId(name), awsRunner(workspace))),
-        }, awsRunner(workspace), spawnRunner("docker", workspace), (m) => console.error(`[fastagent] ${m}`), async (content) => {
+            ...boxLoginStep("agentcore", params, (runtimeArn) => agentcoreShell(runtimeArn, ingressSessionId(name), awsRunner(agentDir))),
+        }, awsRunner(agentDir), spawnRunner("docker", agentDir), (m) => console.error(`[fastagent] ${m}`), async (content) => {
             const path = join(paramsDir, "params.json");
             await writeFile(path, content, { mode: SECRET_FILE_MODE });
             return path;
@@ -183,13 +156,13 @@ async function runDeployAgentcore(params) {
             const path = join(paramsDir, "forwarder.zip");
             await writeFile(path, bytes);
             return path;
-        }, registrarsFor(agentDir));
+        }, registrarsFor(agentDir, params.values, params.answerer));
         if (!outcome.ok)
             failStartup(new Error(`deploy stopped: ${outcome.gate}`));
         console.error(`[fastagent] deployed → ${outcome.runtimeArn}`);
         if (outcome.url)
             console.error(`[fastagent] webhook ingress → ${outcome.url}`);
-        const logsDir = shellArg(workspace);
+        const logsDir = shellArg(agentDir);
         console.error(`[fastagent] runtime logs → fastagent logs agentcore ${logsDir} --follow`);
         console.error(`[fastagent] forwarder logs → fastagent logs agentcore ${logsDir} --source forwarder --follow`);
         // `--run` never prints the runbook, and this is the ONE step in it that nothing else will remind anyone of: a
@@ -200,9 +173,9 @@ async function runDeployAgentcore(params) {
             `--log-group-name <the group \`fastagent logs agentcore ${logsDir} --follow\` resolves> --retention-in-days 14`);
         console.error(`[fastagent] ...and for the forwarder: aws logs put-retention-policy ` +
             `--log-group-name ${forwarderLogGroup(name)} --retention-in-days 14`);
-        console.error(`[fastagent] invoke: aws bedrock-agentcore invoke-agent-runtime --agent-runtime-arn ${outcome.runtimeArn} \\\n` +
+        console.error(`[fastagent] probe: aws bedrock-agentcore invoke-agent-runtime --agent-runtime-arn ${outcome.runtimeArn} \\\n` +
             `  --runtime-session-id "${ingressSessionId(name)}" \\\n` +
-            `  --payload '{"kind":"invoke","session":"cli","text":"hello"}' --cli-binary-format raw-in-base64-out /dev/stdout`);
+            `  --payload '${PROBE_PAYLOAD}' --cli-binary-format raw-in-base64-out /dev/stdout`);
     }
     finally {
         await rm(paramsDir, { recursive: true, force: true });

package/dist/cli/commands/deploy/docker.js

@@ -1,45 +1,38 @@
 /** `deploy docker`: one app service + loopback port + state volume, as a user-owned Compose file. */
 import { mkdir, writeFile } from "node:fs/promises";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { webhookPaths } from "../../../deploy/channel-ingress.js";
-import { DOCKER_COMPOSE_FILE, composeHasTunnelService, isGeneratedCompose, planDockerDeploy, toDockerProjectName, } from "../../../deploy/docker/plan.js";
+import { DOCKER_COMPOSE_FILE, DOCKER_VALUE_FILE, composeHasTunnelService, isGeneratedCompose, planDockerDeploy, toDockerProjectName, } from "../../../deploy/docker/plan.js";
 import { deployDockerRun } from "../../../deploy/docker/run.js";
 import { spawnRunner } from "../../../deploy/runner.js";
 import { openExternalUrl } from "../../../open-url.js";
-import { SECRETS_DIRNAME, SECRET_FILE_MODE, exists, readTextIfExists, resolveStateRoot, } from "../../../paths.js";
-import { dotEnvPath } from "../../../env.js";
+import { SECRET_FILE_MODE, exists, readTextIfExists, resolveStateRoot } from "../../../paths.js";
 import { announceWebhooks } from "../../../tunnel.js";
 import { assembleSecrets } from "../../../deploy/secrets.js";
 import { processShell } from "../../../deploy/box-shell.js";
 import { failStartup } from "../../fail.js";
-import { isInteractive } from "../../shared.js";
-import { boxLoginStep } from "./shared.js";
+import { boxLoginStep, leftToPerson } from "./shared.js";
 export const dockerHost = {
     isOurs: (path, content) => path.endsWith(DOCKER_COMPOSE_FILE) && isGeneratedCompose(content),
-    artifact: DOCKER_COMPOSE_FILE,
-    shell: async ({ agentDir, workspace }) => composeShell(`${basename(agentDir)}/${DOCKER_COMPOSE_FILE}`, workspace),
-    async deploy(ctx) {
-        const { opts, agentDir, workspace, channels, webhookChannels, pre, write } = ctx;
-        const { modelAuth, boxLogin, container, port, declaredSecrets, values, valueFile } = pre;
-        // The generated Compose names `<agent>/.secrets/.env` unconditionally, so it has to be there — Compose refuses
-        // an `env_file` entry pointing at a missing path, and this floor predates `required: false` (Compose 2.24).
-        // Creating it empty is honest: a deployment that declares nothing declares it in an empty file.
-        const composeValueFile = join(agentDir, SECRETS_DIRNAME, ".env");
-        await mkdir(dirname(composeValueFile), { recursive: true });
-        if (!(await exists(composeValueFile)))
-            await writeFile(composeValueFile, "", { mode: SECRET_FILE_MODE });
-        // The pre-flight read whatever `FASTAGENT_SECRETS_DIR` resolved to; the committed Compose cannot, because a
-        // builder's path would not mean the same thing anywhere else. Under `--run` the two files disagreeing is a
-        // DETERMINISTIC failure and gates like every other one: the missing-values gate would pass on the file this
-        // machine reads while `compose up` starts a container whose declared secrets and model are all absent.
-        if (resolve(dotEnvPath(agentDir)) !== resolve(composeValueFile)) {
-            const issue = `FASTAGENT_SECRETS_DIR points this run's values at ${valueFile}, but the generated Compose reads ` +
-                `${relative(workspace, composeValueFile)} (a committed artifact cannot carry this machine's path), so the ` +
+    shell: async (agentDir) => composeShell(DOCKER_COMPOSE_FILE, agentDir),
+    validate({ opts, agentDir, pre }) {
+        if (resolve(agentDir, pre.valueFile) !== join(agentDir, DOCKER_VALUE_FILE)) {
+            const issue = `FASTAGENT_SECRETS_DIR points this run's values at ${pre.valueFile}, but the generated Compose reads ` +
+                `${DOCKER_VALUE_FILE} (a committed artifact cannot carry this machine's path), so the ` +
                 `container would start with none of them. Unset FASTAGENT_SECRETS_DIR, or put the values in that file.`;
             if (opts.run)
                 failStartup(new Error(`deploy stopped: ${issue}`));
             console.error(`[fastagent] warn: ${issue}`);
         }
+    },
+    async deploy(ctx) {
+        const { opts, agentDir, channels, webhookChannels, pre, write } = ctx;
+        const { modelAuth, boxLogin, container, port, declaredSecrets, values, valueFile } = pre;
+        // Compose requires its committed env_file to exist, even when no values are declared.
+        const composeValueFile = join(agentDir, DOCKER_VALUE_FILE);
+        await mkdir(dirname(composeValueFile), { recursive: true });
+        if (!(await exists(composeValueFile)))
+            await writeFile(composeValueFile, "", { mode: SECRET_FILE_MODE });
         // Compose interpolates `$VAR` INSIDE env_file values (`format: raw` needs Compose 2.30), so a credential
         // containing `$` reaches the container rewritten — silently, and differently from what this pre-flight read.
         // No escaping advice: this ONE file is also read literally by `dev`/`start` (`parseEnvContent`) and pushed
@@ -52,7 +45,7 @@ export const dockerHost = {
                 `"$". Prefer a value without "$".`);
         }
         const hasDeclaredChannels = channels.length > 0;
-        const projectName = toDockerProjectName(basename(workspace));
+        const projectName = toDockerProjectName(basename(agentDir));
         const dockerPlan = (tunnel) => planDockerDeploy({
             projectName,
             port,
@@ -70,7 +63,7 @@ export const dockerHost = {
         let plan = dockerPlan(requestedTunnel);
         // An existing Compose file is authoritative: shape its comparison/runbook from the topology on disk, regardless
         // of the current flag.
-        const composeFile = join(workspace, plan.composePath);
+        const composeFile = join(agentDir, plan.composePath);
         let keptWithoutRequestedTunnel = false;
         // Same ownership question as fly.toml: a hand-owned compose file survives --force, so the plan must describe the
         // topology that will actually be there.
@@ -84,13 +77,12 @@ export const dockerHost = {
         if (opts.run) {
             return runDeployDocker({
                 agentDir,
-                workspace,
                 composeFile: plan.composePath,
                 port,
                 requireTunnel: requestedTunnel,
                 modelAuth,
                 boxLogin,
-                input: opts.input !== false && isInteractive(),
+                answerer: ctx.answerer,
                 channels,
                 declaredSecrets,
                 values,
@@ -102,12 +94,13 @@ export const dockerHost = {
                 `edit it, delete it and regenerate, or pass --force`);
         }
         console.log(plan.runbook.join("\n"));
-        return;
+        return `http://127.0.0.1:${port}`;
     },
 };
 /** `deploy docker --run`: reconcile the user-owned local topology, then log the box in if it must. */
 async function runDeployDocker(params) {
-    const { agentDir, workspace, composeFile, port, requireTunnel, channels } = params;
+    const { agentDir, composeFile, port, requireTunnel, channels } = params;
+    const leave = leftToPerson(params.answerer);
     const { secrets, missingSecrets } = assembleSecrets({
         modelAuth: params.modelAuth,
         declared: params.declaredSecrets,
@@ -121,12 +114,14 @@ async function runDeployDocker(params) {
         valueFile: params.valueFile,
         requireTunnel,
         channels,
-        ...boxLoginStep("docker", params, () => composeShell(composeFile, workspace)),
+        ...boxLoginStep("docker", params, () => composeShell(composeFile, agentDir)),
         announce: (tunnelUrl) => announceWebhooks(agentDir, tunnelUrl, channels, {
-            openUrl: openExternalUrl,
+            // A ticket's process opens no browser: its person is told, through `leave`.
+            ...(leave === undefined ? { openUrl: openExternalUrl } : { leave }),
             stateRoot: resolveStateRoot(agentDir),
+            env: Object.fromEntries(params.values),
         }),
-    }, spawnRunner("docker", workspace), (message) => console.error(`[fastagent] ${message}`));
+    }, spawnRunner("docker", agentDir), (message) => console.error(`[fastagent] ${message}`));
     const compose = `docker compose -f ${composeFile}`;
     // Compose reached "up" iff the driver could report where it is.
     const isUp = outcome.ok || outcome.url !== undefined || outcome.tunnelUrl !== undefined;
@@ -144,14 +139,18 @@ async function runDeployDocker(params) {
     if (!outcome.ok)
         failStartup(new Error(`deploy stopped: ${outcome.gate}`));
     if (outcome.tunnelUrl)
-        return;
+        return outcome.tunnelUrl;
     const paths = webhookPaths(channels);
     if (paths.length > 0) {
-        console.error(`[fastagent] note: public ingress is operator-owned — configure your tunnel/proxy, then wire the ` +
-            `default webhook path(s): ${paths.join(", ")} (or your remapped channel routes)`);
+        const unreached = `${paths.join(", ")} receive nothing until a public URL reaches this container — re-run with --tunnel for a ` +
+            `Quick Tunnel, or configure your own tunnel/proxy and point those webhook path(s) (or your remapped channel ` +
+            `routes) at it`;
+        console.error(`[fastagent] note: ${unreached}`);
+        leave?.(unreached);
     }
+    return outcome.url;
 }
 /** `docker compose exec` into the running agent service. */
-function composeShell(composeFile, workspace) {
-    return processShell("docker", (command) => ["compose", "-f", composeFile, "exec", "-T", "agent", "sh", "-c", command], workspace);
+function composeShell(composeFile, agentDir) {
+    return processShell("docker", (command) => ["compose", "-f", composeFile, "exec", "-T", "agent", "sh", "-c", command], agentDir);
 }

package/dist/cli/commands/deploy/fly.js

@@ -8,17 +8,16 @@ import { residencyFor } from "../../../deploy/residency.js";
 import { assembleSecrets } from "../../../deploy/secrets.js";
 import { processShell } from "../../../deploy/box-shell.js";
 import { failStartup } from "../../fail.js";
-import { isInteractive } from "../../shared.js";
+import { FLY_LOGIN, hostLogin } from "./host-login.js";
 import { boxLoginStep, registrarsFor } from "./shared.js";
 export const flyHost = {
     isOurs: (path, content) => path.endsWith("fly.toml") && isGeneratedFlyToml(content),
-    artifact: "fly.toml",
-    async shell({ agentDir, workspace }) {
+    async shell(agentDir) {
         const flyToml = await readTextIfExists(join(agentDir, "fly.toml"));
-        return flyShell((flyToml && parseFlyAppName(flyToml)) ?? toFlyAppName(basename(workspace)), workspace);
+        return flyShell((flyToml && parseFlyAppName(flyToml)) ?? toFlyAppName(basename(agentDir)), agentDir);
     },
     async deploy(ctx) {
-        const { opts, agentDir, workspace, channels, pre, write } = ctx;
+        const { opts, agentDir, channels, pre, write } = ctx;
         const { hasCron, modelAuth, boxLogin, container, port, declaredSecrets, values, valueFile } = pre;
         // Two consistent modes.
         const flyTomlPath = join(agentDir, "fly.toml");
@@ -26,7 +25,7 @@ export const flyHost = {
         // Every decision below turns on ONE question — will `writeArtifacts` keep this file?
         const flyTomlKept = flyToml !== undefined && (!opts.force || !isGeneratedFlyToml(flyToml));
         const keptApp = flyTomlKept ? parseFlyAppName(flyToml) : undefined;
-        const appName = keptApp ?? toFlyAppName(basename(workspace));
+        const appName = keptApp ?? toFlyAppName(basename(agentDir));
         if (keptApp)
             console.error(`[fastagent] app: ${keptApp} (from fly.toml)`);
         if (flyToml !== undefined && !flyTomlKept) {
@@ -58,28 +57,30 @@ export const flyHost = {
             ...container,
         });
         await write(plan.artifacts, { force: !!opts.force });
+        const reachedAt = `https://${appName}.fly.dev`;
         if (opts.run) {
-            return runDeployFly({
+            await runDeployFly({
                 agentDir,
-                workspace,
-                agentPrefix: container.agentPrefix,
                 appName,
                 modelAuth,
                 boxLogin,
-                input: opts.input !== false && isInteractive(),
+                answerer: ctx.answerer,
+                rerun: ctx.rerun,
                 channels,
                 declaredSecrets,
                 values,
                 valueFile,
             });
+            return reachedAt;
         }
         console.log(plan.runbook.join("\n"));
+        return reachedAt;
     },
 };
 /** `deploy fly --run`: drive flyctl to completion (idempotent, resumable). */
 async function runDeployFly(params) {
-    const { agentDir, workspace, agentPrefix, appName, channels } = params;
-    const fly = spawnRunner("fly", workspace);
+    const { agentDir, appName, channels } = params;
+    const fly = spawnRunner("fly", agentDir);
     // Fail fast if flyctl is absent (spawn ENOENT → 127), with the install link — not a confusing auth gate.
     if ((await fly(["version"], { capture: true })).code === 127) {
         failStartup(new Error(`flyctl not found — install it: https://fly.io/docs/flyctl/install, then re-run`));
@@ -95,18 +96,20 @@ async function runDeployFly(params) {
         missingSecrets,
         valueFile: params.valueFile,
         channels,
-        flyConfig: `${agentPrefix}fly.toml`,
-        dockerfile: `${agentPrefix}Dockerfile`,
-        ...boxLoginStep("fly", params, () => flyShell(appName, workspace)),
-    }, fly, (m) => console.error(`[fastagent] ${m}`), registrarsFor(agentDir));
+        flyConfig: "fly.toml",
+        dockerfile: "Dockerfile",
+        ...boxLoginStep("fly", params, () => flyShell(appName, agentDir)),
+        ...hostLogin(FLY_LOGIN, params.answerer, agentDir),
+        forAgent: `${params.rerun} --json`,
+    }, fly, (m) => console.error(`[fastagent] ${m}`), registrarsFor(agentDir, params.values, params.answerer));
     if (!outcome.ok)
         failStartup(new Error(`deploy stopped: ${outcome.gate}`));
     console.error(`[fastagent] deployed → https://${appName}.fly.dev`);
 }
 /** `fly ssh console` into the app's machine, woken first: a suspended machine has no shell to open. */
-function flyShell(app, workspace) {
+function flyShell(app, agentDir) {
     return {
-        ...processShell("fly", (command) => ["ssh", "console", "--app", app, "--quiet", "--command", `sh -c '${command}'`], workspace),
+        ...processShell("fly", (command) => ["ssh", "console", "--app", app, "--quiet", "--command", `sh -c '${command}'`], agentDir),
         // `fly ssh` fails with "no started VMs" while the machine is suspended, and a request is what resumes it. The
         // answer is not the point: a machine that stays down makes the shell fail right after, with Fly's own reason.
         wake: async () => {

package/dist/cli/commands/deploy/host-login.d.ts

@@ -0,0 +1,26 @@
+import type { Answerer } from "./shared.ts";
+export interface BrowserLogin {
+    bin: string;
+    /** The login at a terminal: it opens the browser itself. */
+    atTerminal: string[];
+    /** The login with no terminal: it prints the address, and exits 0 once the person approved there. */
+    unattended: string[];
+    /** The address in what `unattended` prints. */
+    address: RegExp;
+    /** The code a device login's address carries, for the person to check against the page. */
+    userCode?(address: URL): string | undefined;
+    /**
+     * The login that finishes with the code the approval page shows, for a browser that could not reach this machine
+     * (Fly's): `deploy --check <ticket> --code <code>` hands it over.
+     */
+    withCode?(code: string): string[];
+}
+export declare const FLY_LOGIN: BrowserLogin;
+export declare const RAILWAY_LOGIN: BrowserLogin;
+/**
+ * The host's sign-in, through whoever answers, as a driver's `hostLogin`; none for nobody, whose deploy stops at the
+ * host's own gate. Resolves undefined once signed in, else the line saying why not.
+ */
+export declare function hostLogin(login: BrowserLogin, answerer: Answerer, cwd: string): {
+    hostLogin?: () => Promise<string | undefined>;
+};

package/dist/cli/commands/deploy/host-login.js

@@ -0,0 +1,90 @@
+/**
+ * Signing a host's CLI in to the person's account, for a deploy that finds it signed out. At a terminal the host's own
+ * login runs there and opens the browser. In a deploy's ticket it runs with no terminal, where both CLIs print the
+ * address to approve at and finish on their own once approved; that address is the person's step. Never a token: one
+ * set in .secrets/production/.env would travel to the box with every other variable there.
+ */
+import { spawn } from "node:child_process";
+export const FLY_LOGIN = {
+    bin: "fly",
+    atTerminal: ["auth", "login"],
+    unattended: ["auth", "login"],
+    address: /https:\/\/fly\.io\/app\/auth\/cli\/[A-Za-z0-9_-]+/,
+    withCode: (code) => ["auth", "login", "--code", code],
+};
+export const RAILWAY_LOGIN = {
+    bin: "railway",
+    atTerminal: ["login"],
+    unattended: ["login", "--browserless"],
+    address: /https:\/\/railway\.com\/activate\?user_code=[A-Za-z0-9-]+/,
+    userCode: (address) => address.searchParams.get("user_code") ?? undefined,
+};
+/**
+ * The host's sign-in, through whoever answers, as a driver's `hostLogin`; none for nobody, whose deploy stops at the
+ * host's own gate. Resolves undefined once signed in, else the line saying why not.
+ */
+export function hostLogin(login, answerer, cwd) {
+    if (answerer.kind === "nobody")
+        return {};
+    return { hostLogin: signIn(login, answerer, cwd) };
+}
+function signIn(login, answerer, cwd) {
+    if (answerer.kind === "terminal") {
+        return async () => {
+            const code = await exitOf(spawn(login.bin, login.atTerminal, { cwd, stdio: "inherit" }));
+            return code === 0 ? undefined : `\`${login.bin} ${login.atTerminal.join(" ")}\` did not sign in — re-run`;
+        };
+    }
+    const { step } = answerer;
+    return async () => {
+        const child = spawn(login.bin, login.unattended, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let said = "";
+        let shown = false;
+        const hear = (chunk) => {
+            const text = String(chunk);
+            process.stderr.write(text);
+            said = `${said}${text}`.slice(-4096);
+            const found = shown ? null : login.address.exec(said);
+            if (found === null)
+                return;
+            shown = true;
+            const url = found[0];
+            const code = login.userCode?.(new URL(url));
+            step.waits(code ? { url, code } : login.withCode ? { url, takesAddress: true } : { url });
+        };
+        child.stdout.on("data", hear);
+        child.stderr.on("data", hear);
+        const exited = exitOf(child);
+        const handed = new AbortController();
+        const finished = await Promise.race([
+            exited.then((code) => ({ code })),
+            ...(login.withCode
+                ? [
+                    step
+                        .address(AbortSignal.any([step.signal, handed.signal]))
+                        .then((code) => ({ handedCode: code.trim() }))
+                        .catch(() => new Promise(() => { })),
+                ]
+                : []),
+        ]);
+        handed.abort();
+        if ("handedCode" in finished) {
+            child.kill();
+            const args = login.withCode(finished.handedCode);
+            const code = await exitOf(spawn(login.bin, args, { cwd, stdio: ["ignore", "inherit", "inherit"] }));
+            if (code !== 0)
+                return `\`${login.bin}\` refused the code the approval page showed — try the deploy again`;
+        }
+        else if (finished.code !== 0) {
+            return `\`${login.bin} ${login.unattended.join(" ")}\` did not sign in (exit ${finished.code}): ${said.trim()}`;
+        }
+        step.person.carriesOn();
+        return undefined;
+    };
+}
+function exitOf(child) {
+    return new Promise((resolve) => {
+        child.on("error", () => resolve(127));
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}