@fastagent-sh/fastagent 0.28.0 → 0.30.0

package/dist/cli/commands/channels.js

@@ -0,0 +1,230 @@
+/**
+ * `fastagent channels setup <name>`: set up one channel's platform app for one instance (channel-setup.md §2): ask a
+ * person for the values only they have, check them with the platform, and keep them in the instance's value file.
+ * With `--record-url`: record, in the configuration a deploy delivers, the URL a person set on a Slack or Lark app's
+ * page, once the deployment confirms the platform reaches it there (§5).
+ */
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { recordChannelUrl } from "../channel-app.js";
+import { isSetupKind, setUpChannel } from "../channel-setup.js";
+import { webhookPath } from "../../channels/webhooks.js";
+import { enterAgentEnv } from "../../env.js";
+import { readInstanceConfigFile, resolveConfig } from "../../harnesses/pi-durable/config.js";
+import { chosenIngress } from "../../harnesses/pi-durable/definition.js";
+import { buildDefinitionShape, loadSourceDefinition } from "../../harnesses/pi-durable/open.js";
+import { setChannelConfig } from "../../authoring.js";
+import { INSTANCE_CONFIG_FILE, selectAgentEnvironment } from "../../paths.js";
+import { markDevServe, unmarkDevServe } from "../../serving-command.js";
+import { dotEnvPath, loadEnvValues } from "../../value-file.js";
+import { agentDirOrExit, failStartup, failUsage } from "../fail.js";
+import { enterEnvFile } from "../instance.js";
+import { isInteractive, shellArg } from "../shared.js";
+import { checkTicket, printReport, refusedCheck, runTicket, startTicket, ticketExitCode, ticketReport, } from "../ticket.js";
+import { stripTrailingSlashes } from "../../strip-edges.js";
+/** Without a terminal, how long a setup stays open for the person to finish their part. */
+const UNATTENDED_TIMEOUT_SECONDS = 900;
+export async function runChannelsSetup(name, dirArg, opts) {
+    if (opts.check !== undefined)
+        return checkSetup(name, opts.check, opts);
+    if (opts.recordUrl)
+        return recordUrl(name, dirArg, opts);
+    if (!isSetupKind(name)) {
+        failUsage(`${name}: \`channels setup\` sets up telegram, slack, feishu and lark`);
+    }
+    if (opts.ticket !== undefined) {
+        // The process `startTicket` started: it takes the ticket before anything slow (the definition is loaded to plan),
+        // then does the whole setup, its person the ticket's.
+        await runTicket(opts.ticket, async (step) => ({
+            ...(await carryOut(await planSetup(name, dirArg, opts), step.person)),
+        }));
+        process.exit(0);
+    }
+    const plan = await planSetup(name, dirArg, opts);
+    if (opts.input === false || opts.json || !isInteractive())
+        return setUpUnattended(plan, opts);
+    const outcome = await carryOut(plan).catch(failStartup);
+    console.error("  next steps:");
+    for (const line of outcome.next_steps)
+        console.error(`    ${line}`);
+    // Platform sockets left open would hold a one-shot command open after everything durable is done.
+    process.exit(0);
+}
+async function planSetup(kind, dirArg, opts) {
+    if (opts.ingress !== undefined && opts.ingress !== "webhook" && opts.ingress !== "connection") {
+        failUsage(`--ingress must be "webhook" or "connection", got "${opts.ingress}"`);
+    }
+    const agentDir = agentDirOrExit(resolve(dirArg));
+    // The development instance is the default one; naming a configuration or a value file is naming another.
+    const dev = opts.config === undefined && opts.envFile === undefined;
+    selectAgentEnvironment(dev ? "dev" : "production");
+    if (dev)
+        markDevServe();
+    else
+        unmarkDevServe();
+    enterEnvFile(opts.envFile);
+    enterAgentEnv(agentDir);
+    const file = dotEnvPath(agentDir);
+    const config = opts.config !== undefined ? resolve(opts.config) : dev ? join(agentDir, INSTANCE_CONFIG_FILE) : undefined;
+    if (opts.ingress !== undefined && config === undefined) {
+        failUsage("--ingress writes into a configuration: pass --config <file>, the one `deploy --config` delivers");
+    }
+    const definition = await loadSourceDefinition(agentDir).catch(failStartup);
+    const instance = config !== undefined && existsSync(config) ? await readInstanceConfigFile(config).catch(failStartup) : undefined;
+    const effective = resolveConfig(definition, instance);
+    const way = opts.ingress ?? chosenIngress(effective, kind, dev);
+    // A channel file that names its factory receives one way whatever the configuration says: setting the app up for
+    // the other would change nothing but the app.
+    if (existsSync(join(agentDir, "src", "channels", `${kind}.ts`))) {
+        try {
+            buildDefinitionShape(definition, process.env, {
+                settings: definition.config.defaults?.settings ?? {},
+                channels: { [kind]: { ingress: way } },
+            });
+        }
+        catch (error) {
+            failStartup(new Error(`the agent does not build for ${kind} to receive by ${way} (${error.message})`));
+        }
+    }
+    const publicUrl = effective.http?.publicUrl;
+    return {
+        kind,
+        agentDir,
+        dev,
+        file,
+        way,
+        publicUrl,
+        writeIngress: opts.ingress === undefined ? undefined : config,
+        rerun: `fastagent channels setup ${kind} ${shellArg(agentDir)}` +
+            `${opts.ingress === undefined ? "" : ` --ingress ${opts.ingress}`}` +
+            `${opts.config === undefined ? "" : ` --config ${shellArg(resolve(opts.config))}`}` +
+            `${opts.envFile === undefined ? "" : ` --env-file ${shellArg(resolve(opts.envFile))}`}`,
+    };
+}
+/** The setup itself, once its person's part can be done: the values, the way written down, and what comes next. */
+async function carryOut(plan, person) {
+    const outcome = await setUpChannel({
+        kind: plan.kind,
+        agentDir: plan.agentDir,
+        file: plan.file,
+        way: plan.way,
+        dev: plan.dev,
+        rerun: plan.rerun,
+        ...(plan.publicUrl === undefined ? {} : { publicUrl: plan.publicUrl }),
+        ...(person === undefined ? {} : { person }),
+    });
+    if (plan.writeIngress !== undefined) {
+        await setChannelConfig(plan.agentDir, plan.kind, { ingress: plan.way }, { config: plan.writeIngress });
+        console.error(`[fastagent] wrote channels.${plan.kind}.ingress "${plan.way}" to ${plan.writeIngress}`);
+    }
+    const serve = plan.dev
+        ? "fastagent dev"
+        : `fastagent start --env-file ${shellArg(plan.file)}   # or, from .secrets/production/.env, fastagent deploy <host> --run`;
+    return { written: outcome.written, kept: outcome.kept, next_steps: [serve, ...outcome.after] };
+}
+/** The command that reads a setup's ticket, as every such ticket records it. */
+const setupCheck = (kind) => `fastagent channels setup ${kind} --check`;
+/**
+ * A setup with no one at a terminal to ask, for a coding agent: it runs in a process of its own (ticket.ts), and the
+ * command returns once the person has a step to take, it is done, or it is still working at it. What only the person
+ * has is pasted on a page of the setup's own, never asked for in the agent's conversation and never typed into a file.
+ */
+async function setUpUnattended(plan, opts) {
+    const timeout = opts.timeout === undefined ? UNATTENDED_TIMEOUT_SECONDS : Number(opts.timeout);
+    if (!Number.isInteger(timeout) || timeout <= 0)
+        failUsage("--timeout must be a whole number of seconds");
+    const ticket = await startTicket({
+        // One setup per agent, channel and value file: another one's is its own business.
+        subject: `channels-setup:${plan.kind}:${plan.file}`,
+        action: `set up the ${plan.kind} app`,
+        check: setupCheck(plan.kind),
+        restart: plan.rerun,
+        timeoutSeconds: timeout,
+        waitsFirst: false,
+        whenRunning: "replace",
+        command: {
+            file: process.execPath,
+            args: [
+                ...process.execArgv,
+                process.argv[1],
+                "channels",
+                "setup",
+                plan.kind,
+                plan.agentDir,
+                ...(opts.ingress === undefined ? [] : ["--ingress", opts.ingress]),
+                ...(opts.config === undefined ? [] : ["--config", resolve(opts.config)]),
+                ...(opts.envFile === undefined ? [] : ["--env-file", resolve(opts.envFile)]),
+            ],
+            cwd: process.cwd(),
+        },
+    });
+    reportSetup(ticket, opts, "started");
+    process.exit(ticketExitCode(ticket));
+}
+/** `channels setup <name> --check <ticket>`. */
+async function checkSetup(name, id, opts) {
+    const refused = refusedCheck(id, setupCheck(name));
+    if (refused !== undefined)
+        failUsage(refused);
+    // There: refusedCheck read it, and a ticket is pruned only a day after it ends.
+    const ticket = (await checkTicket(id));
+    reportSetup(ticket, opts, "checked");
+    process.exit(ticketExitCode(ticket));
+}
+/** A setup's ticket for whoever started or checked it: the shared report, and what a finished setup adds. */
+function reportSetup(ticket, opts, when) {
+    const { json, text } = ticketReport(ticket, when, (result) => {
+        const written = result.written ?? [];
+        const kept = result.kept ?? [];
+        const next = result.next_steps ?? [];
+        return {
+            fields: { written, kept, next_steps: next },
+            text: [...(written.length > 0 ? [`wrote ${written.join(", ")}`] : []), ...next.map((line) => `next: ${line}`)],
+            next: "The app is set up. Its next steps are in next_steps.",
+        };
+    });
+    printReport(opts.json, json, text);
+}
+async function recordUrl(name, dirArg, opts) {
+    if (name !== "slack" && name !== "lark") {
+        failUsage(`${name}: only slack and lark have a URL a person sets (the instance points the others itself)`);
+    }
+    if (opts.config === undefined)
+        failUsage("--record-url writes into the configuration a deploy delivers: pass --config <file>");
+    const agentDir = agentDirOrExit(resolve(dirArg));
+    selectAgentEnvironment("production");
+    enterEnvFile(opts.envFile);
+    // The deployment's /health and the platform are reached as the instance's values and environment say, a proxy included.
+    enterAgentEnv(agentDir);
+    const config = resolve(opts.config);
+    const source = await readInstanceConfigFile(config).catch(failStartup);
+    const named = source.values.http?.publicUrl;
+    const configured = typeof named === "string" ? stripTrailingSlashes(named) : undefined;
+    // `--url` is where this machine reads the deployment's /health; the URL the box confirms is the configuration's
+    // own http.publicUrl when it names one, the one the platforms reach.
+    const reach = (opts.url === undefined ? undefined : stripTrailingSlashes(opts.url)) ?? configured;
+    const base = configured ?? reach;
+    if (reach === undefined || base === undefined) {
+        failUsage(`${config} names no http.publicUrl: pass --url <the deployment's public URL>`);
+    }
+    const kind = name;
+    const url = `${base}${webhookPath(kind)}`;
+    const outcome = await healthOutcome(`${reach}/health`, kind).catch(failStartup);
+    if (outcome !== "registered") {
+        failStartup(new Error(`${kind}: the deployment at ${reach} reports it ${outcome ?? "not listed"}, not reached at ${url} yet — save ` +
+            `${url} on the app's page (the platform verifies it with the deployment), then run this again`));
+    }
+    await recordChannelUrl(agentDir, config, kind, url, loadEnvValues(dotEnvPath(agentDir))).catch(failStartup);
+    printReport(opts.json, { status: "done", channel: kind, url, config }, [`recorded ${url} for ${kind} in ${config}`]);
+}
+/** The outcome the deployment's `/health` reports for `kind`, or undefined when it lists none. */
+async function healthOutcome(healthUrl, kind) {
+    let body;
+    try {
+        body = (await (await fetch(healthUrl, { signal: AbortSignal.timeout(10_000) })).json());
+    }
+    catch (error) {
+        throw new Error(`could not read ${healthUrl}: ${String(error)}`, { cause: error });
+    }
+    return body.webhooks?.find((entry) => entry.channel === kind)?.outcome;
+}

package/dist/cli/commands/content.d.ts

@@ -1,6 +1,10 @@
 import { type SourceOptions } from "../../content/source.ts";
+import { type InstanceFlags } from "../instance.ts";
 /** A name refusal is the caller's to fix by naming another (exit 2); anything else is a startup failure (exit 1). */
 export declare function failEdit(hint: string): (error: unknown) => never;
-export declare function runContentList(dirArg: string, json: boolean): Promise<void>;
-export declare function runContentAdd(source: string, dirArg: string, opts: SourceOptions): Promise<void>;
-export declare function runContentRemove(name: string, dirArg: string): Promise<void>;
+export declare function runContentList(dirArg: string, json: boolean, flags?: InstanceFlags): Promise<void>;
+export declare function runContentAdd(source: string, dirArg: string, opts: SourceOptions & {
+    program?: boolean;
+    instance?: InstanceFlags;
+}): Promise<void>;
+export declare function runContentRemove(name: string, dirArg: string, flags?: InstanceFlags): Promise<void>;

package/dist/cli/commands/content.js

@@ -1,12 +1,13 @@
 /**
- * `fastagent content list|add|remove`: what the agent works on, as `context.json` declares it and
- * `context.local.json` binds it on this machine.
+ * `fastagent content list|add|remove`: what the agent works on, as the program's `context.json` declares it and the
+ * instance's configuration adds to it.
  */
 import { resolve } from "node:path";
 import { ContentNameError, addContent, listContent, removeContent } from "../../authoring.js";
 import { readContentSource } from "../../content/source.js";
 import { contentLines } from "../content-view.js";
 import { failStartup, failUsage } from "../fail.js";
+import { enterContentScope } from "../instance.js";
 /** A name refusal is the caller's to fix by naming another (exit 2); anything else is a startup failure (exit 1). */
 export function failEdit(hint) {
     return (error) => {
@@ -15,30 +16,35 @@ export function failEdit(hint) {
         failStartup(error);
     };
 }
-export async function runContentList(dirArg, json) {
-    const { content, absent } = await listContent(resolve(dirArg)).catch(failStartup);
+export async function runContentList(dirArg, json, flags) {
+    const dir = resolve(dirArg);
+    const { content } = await listContent(dir, enterContentScope(dir, flags)).catch(failStartup);
     if (json) {
-        console.log(JSON.stringify({ content, absent }, null, 2));
+        console.log(JSON.stringify({ content }, null, 2));
         return;
     }
-    for (const [label, value] of contentLines(content, absent))
+    for (const [label, value] of contentLines(content))
         console.log(`${`${label}:`.padEnd(10)} ${value}`);
 }
 export async function runContentAdd(source, dirArg, opts) {
+    const dir = resolve(dirArg);
+    const { program, instance, ...options } = opts;
     const { addition, notes } = await Promise.resolve()
-        .then(() => readContentSource(source, process.cwd(), opts))
+        .then(() => readContentSource(source, process.cwd(), options))
         .catch(failStartup);
     for (const note of notes)
         console.error(`[fastagent] ${note}`);
-    const { name, content, notes: left } = await addContent(resolve(dirArg), addition).catch(failEdit(" — pass --name"));
+    const scope = enterContentScope(dir, instance);
+    const { name, content, notes: left, } = await addContent(dir, { ...addition, ...(program ? { program } : {}) }, scope).catch(failEdit(" — pass --name"));
     const added = content.filter((entry) => entry.name === name);
     for (const [label, value] of contentLines(added))
         console.error(`[fastagent] ${label} ${value}`);
     for (const note of left)
         console.error(`[fastagent] ${note}`);
 }
-export async function runContentRemove(name, dirArg) {
-    const removed = await removeContent(resolve(dirArg), name).catch(failEdit(""));
+export async function runContentRemove(name, dirArg, flags) {
+    const dir = resolve(dirArg);
+    const removed = await removeContent(dir, name, enterContentScope(dir, flags)).catch(failEdit(""));
     console.error(`[fastagent] removed content ${removed.name}`);
     for (const note of removed.notes)
         console.error(`[fastagent] ${note}`);

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

@@ -11,10 +11,11 @@ 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 { assembleSecrets } from "../../../deploy/secrets.js";
+import { deploySecrets } from "./secrets-step.js";
 import { failStartup } from "../../fail.js";
 import { shellArg } from "../../shared.js";
-import { boxLoginStep, registrarsFor } from "./shared.js";
+import { ownPublicUrl } from "../../../deploy/container.js";
+import { boxLoginStep, registrarsFor, urlRecorder } from "./shared.js";
 export const agentcoreHost = {
     isOurs: (path, content) => path.endsWith(TEMPLATE_FILE) && isGeneratedAgentcoreTemplate(content),
     async shell(agentDir) {
@@ -55,7 +56,7 @@ export const agentcoreHost = {
             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}.`);
+                `so). For an agent that must keep answering unattended, set ${boxLogin}'s API key with \`fastagent secrets set agentcore <its variable>\`.`);
         }
         // 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
@@ -98,9 +99,13 @@ export const agentcoreHost = {
                 rerun: ctx.rerun,
                 channels,
                 declaredSecrets,
+                modelKey: pre.modelKey,
+                api: ctx.api,
                 values,
                 valueFile,
                 topology: plan.topology,
+                publicUrl: ownPublicUrl(container.config),
+                config: opts.config,
             });
             return undefined;
         }
@@ -111,24 +116,23 @@ export const agentcoreHost = {
 /** `deploy agentcore --run`: drive aws + docker to completion. */
 async function runDeployAgentcore(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. 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; 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({
+    const secretsStep = deploySecrets({
+        host: "agentcore",
+        label: "AWS Secrets Manager",
+        agentDir,
+        opts: { config: params.config },
+        answerer: params.answerer,
+        api: params.api,
         modelAuth: params.modelAuth,
-        declared: params.declaredSecrets,
+        modelKey: params.modelKey,
+        declaredSecrets: params.declaredSecrets,
+        valueFile: params.valueFile,
         values: params.values,
     });
-    // The wake-alarm shared secret (container ↔ forwarder).
-    secrets.FASTAGENT_WAKE_SECRET = crypto.randomUUID();
-    // The forwarder→runtime ingress secret: what makes an envelope the forwarder's rather than any IAM principal's.
-    secrets.FASTAGENT_INGRESS_SECRET = crypto.randomUUID();
+    // The model's key on the target is a credential like a key in the value file: the runtime has it from its first
+    // invocation, so there is no login to run on the box. Only the target can say, hence after the secrets step.
+    let keyOnTarget = false;
+    const login = boxLoginStep("agentcore", params, (runtimeArn) => agentcoreShell(runtimeArn, ingressSessionId(name), awsRunner(agentDir))).boxLogin;
     // The params temp dir holds the ONE file carrying secret values (file:// parameter-overrides — never argv);
     // 0700/0600 and removed after the run, success or gate.
     const paramsDir = await mkdtemp(join(tmpdir(), "fastagent-agentcore-"));
@@ -142,12 +146,40 @@ async function runDeployAgentcore(params) {
                 .replace(/[-:.TZ]/g, "")
                 .slice(0, 14),
             region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION,
-            secrets,
-            missingSecrets,
-            valueFile: params.valueFile,
+            provideSecrets: async (store) => {
+                const gate = await secretsStep(store);
+                if (gate !== undefined)
+                    return gate;
+                const held = await store.names();
+                keyOnTarget = params.modelKey.variables.some((variable) => held.has(variable));
+                // Decided before the build and the stack: 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. A coding agent's ticket has someone:
+                // its user.
+                if (params.boxLogin && !keyOnTarget && params.answerer.kind === "nobody") {
+                    return (`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; from a coding agent, run ` +
+                        `\`${params.rerun} --json\`, which hands the login to its user; or set ` +
+                        `${params.boxLogin}'s API key with \`fastagent secrets set agentcore ${params.modelKey.variables[0] ?? "<its variable>"}\``);
+                }
+                return undefined;
+            },
+            // The wake-alarm shared secret (container ↔ forwarder).
+            wakeSecret: crypto.randomUUID(),
+            // The forwarder→runtime ingress secret: what makes an envelope the forwarder's rather than any IAM principal's.
+            ingressSecret: crypto.randomUUID(),
             channels,
             topology,
-            ...boxLoginStep("agentcore", params, (runtimeArn) => agentcoreShell(runtimeArn, ingressSessionId(name), awsRunner(agentDir))),
+            ...(params.publicUrl === undefined ? {} : { publicUrl: params.publicUrl }),
+            ...urlRecorder(agentDir, params.config, params.values, params.answerer),
+            ...(login === undefined
+                ? {}
+                : {
+                    boxLogin: {
+                        ...login,
+                        run: async (runtimeArn) => (keyOnTarget ? undefined : login.run(runtimeArn)),
+                    },
+                }),
         }, 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 });
@@ -156,7 +188,7 @@ async function runDeployAgentcore(params) {
             const path = join(paramsDir, "forwarder.zip");
             await writeFile(path, bytes);
             return path;
-        }, registrarsFor(agentDir, params.values, params.answerer));
+        }, registrarsFor(params.values, params.answerer));
         if (!outcome.ok)
             failStartup(new Error(`deploy stopped: ${outcome.gate}`));
         console.error(`[fastagent] deployed → ${outcome.runtimeArn}`);

package/dist/cli/commands/deploy/channel-apps.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The production Feishu or Lark app a deploy sets up on the spot when the target's values hold none: the same
+ * `channels setup` a person runs by hand, aimed at the production value file (channel-setup.md §6).
+ */
+import type { DeclaredChannel } from "../../../channels/discover.ts";
+import type { SetupWay } from "../../../channels/setup.ts";
+import type { Person } from "../../person.ts";
+export interface ChannelAppSetup {
+    kind: "feishu" | "lark";
+    way: SetupWay;
+}
+/** The names of the values `app`'s setup would keep. */
+export declare const channelAppNames: ({ kind, way }: ChannelAppSetup) => string[];
+/** The Feishu and Lark channels whose app has no value yet in `values`. */
+export declare function unpreparedChannelApps(channels: readonly DeclaredChannel[], values: ReadonlyMap<string, string>): ChannelAppSetup[];
+/** Set each of `apps` up for production, its person's steps taken by `person` (absent: at this terminal). */
+export declare function prepareChannelApps(agentDir: string, apps: readonly ChannelAppSetup[], rerun: string, person?: Person): Promise<void>;

package/dist/cli/commands/deploy/channel-apps.js

@@ -0,0 +1,30 @@
+import { dotEnvPath } from "../../../value-file.js";
+import { setUpChannel, setupNames } from "../../channel-setup.js";
+/** The names of the values `app`'s setup would keep. */
+export const channelAppNames = ({ kind, way }) => setupNames(kind, way);
+/** The Feishu and Lark channels whose app has no value yet in `values`. */
+export function unpreparedChannelApps(channels, values) {
+    return ["feishu", "lark"].flatMap((kind) => {
+        const channel = channels.find((entry) => entry.name === kind);
+        if (!channel)
+            return [];
+        const way = channel.ingress === "webhook" ? "webhook" : "connection";
+        return setupNames(kind, way).some((name) => !values.get(name)?.trim()) ? [{ kind, way }] : [];
+    });
+}
+/** Set each of `apps` up for production, its person's steps taken by `person` (absent: at this terminal). */
+export async function prepareChannelApps(agentDir, apps, rerun, person) {
+    const file = dotEnvPath(agentDir);
+    for (const { kind, way } of apps) {
+        console.error(`[fastagent] ${kind}: preparing the production app for ${way} in ${file}`);
+        const input = { kind: kind, agentDir, file, way, dev: false, rerun };
+        const { after } = await setUpChannel(person === undefined ? input : { ...input, person });
+        // What is left (the publish, a scope to approve) is not the deploy's to finish: the person is told.
+        for (const line of after) {
+            if (person === undefined)
+                console.error(`[fastagent] next: ${line}`);
+            else
+                person.afterwards(line);
+        }
+    }
+}