@songsid/agend 2.2.0-alpha.9 → 2.2.0-beta.10

package/dist/instance-lifecycle.d.ts

@@ -105,13 +105,23 @@ export interface LifecycleContext {
      * Offer a one-tap re-login beside an auth alert. Optional: contexts without
      * it (tests, lightweight fleets) still get the alert's written remedy.
      */
-    offerBackendLogin?(targetInstance: string, backend: string): Promise<void>;
+    /** `profile` (#1699 part 2): the button signs that credential profile in, not the backend's default login. */
+    offerBackendLogin?(targetInstance: string, backend: string, profile?: string): Promise<void>;
+    /**
+     * The credential profile an instance's CLI signs in with on `backend` (#1699 follow-up), or null for that backend's
+     * default login. Absent: every instance is on the default login (as before profiles).
+     */
+    credentialProfileOf?(name: string, backend: string): string | null;
     /** Notify a clean CLI exit and offer an admin-only restart action in General. */
     notifyNormalExit(name: string): Promise<void>;
     /** Tell every General, as an agent, that kiro-cli can no longer run this instance as configured. */
     queueKiroIncompatNotice?(name: string, reason: string): void;
     /** True for a dynamic ClassicBot channel instance (not a fleet topic). */
     isClassicInstance?(name: string): boolean;
+    /** All OTHER configured kiro cwd's, fleet + ClassicBot, including stopped
+     * instances. Absent means the complete roster cannot be proven (#1624).
+     */
+    kiroPeerWorkingDirectories?(name: string): string[];
     /** True while the fleet is stopping on purpose or an `agend update` is running. */
     isPlannedRestart(): boolean;
     /** Suppress only incident kinds caused by the active tmux server storm. */
@@ -277,10 +287,10 @@ export declare class InstanceLifecycle {
     private activitySeedNow;
     /** When each instance was last woken or started for work — the pre-claim lease clock. */
     private wokeAt;
-    /** backend → last auth-error alert time, so one expiry sends one alert. */
+    /** login (backend, or backend:profile) → last auth-error alert time, so one expiry sends one alert. */
     private lastAuthAlertAt;
     /**
-     * backend → cached token-free auth verification (see AUTH_VERIFY_CACHE_MS).
+     * login (backend, or backend:profile) → cached token-free auth verification (see AUTH_VERIFY_CACHE_MS).
      * The PROMISE is cached, not the result: a shared credential expiring makes
      * every instance of the backend fire in the same tick, and they must join
      * one in-flight check instead of each spawning their own.
@@ -357,10 +367,20 @@ export declare class InstanceLifecycle {
      * CLI is not. Cached per backend so simultaneous alerts run one check.
      */
     private verifyAuthError;
+    /**
+     * The credential profile a running instance signs in with (#1699 follow-up): its login is that profile's, so its
+     * auth error is judged, cached and reported against that login — never the backend's default one, which can be fine
+     * while the profile's has expired.
+     */
+    private profileOf;
+    private static loginKey;
     private verifyCodexQuota;
     private verifyClaudeQuota;
-    /** Same verification keyed by backend (used by startup pre-flight priming). */
-    verifyBackendAuth(backend: string): Promise<"valid" | "invalid" | "unknown">;
+    /**
+     * Same verification keyed by login — a backend's default one, or one of its credential profiles, probed with that
+     * profile's environment (used by startup pre-flight priming).
+     */
+    verifyBackendAuth(backend: string, profile?: string | null): Promise<"valid" | "invalid" | "unknown">;
     /**
      * Startup pre-flight: warm the per-backend auth verification cache so the
      * detectors that fire seconds later (login-screen scan, MCP-died gate) get an
@@ -368,7 +388,10 @@ export declare class InstanceLifecycle {
      * anything, because e.g. codex on a custom provider runs fine while
      * `codex login status` reports logged out (live-verified on this fleet).
      */
-    primeAuthVerification(backends: Iterable<string>): void;
+    primeAuthVerification(logins: Iterable<{
+        backend: string;
+        profile: string | null;
+    }>): void;
     /**
      * One alert per backend per cooldown, naming every affected instance — a CLI's
      * credentials are shared, so N instances failing is ONE problem with ONE fix

package/dist/instance-lifecycle.js

@@ -19,6 +19,7 @@ import { reportProviderRateLimit } from "./usage/provider-alerts.js";
 import { isFleetStartCommandLine } from "./fleet-lock.js";
 import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 import { BACKEND_AUTH_CHECKS, checkAuthStatus, LOGIN_FLOWS } from "./login-flows.js";
+import { CHAT_PROFILE_LOGIN_BACKENDS, credentialProfileEnv, credentialProfileLoginCommand } from "./backend/credential-profile.js";
 import { fetchClaudeUsage, fetchCodexUsage } from "./usage/providers.js";
 import { assertExplicitInstanceRemoval, authorizeExplicitInstanceRemoval } from "./instance-removal.js";
 import { capturePendingTargetReconciliation, finishTargetReconciliation, reconcileTargetBeforeStart, RECONCILIATION_WRITE_DRAIN_TIMEOUT_MS, retireCapturedTargetWindows, } from "./delivery-reconciliation.js";
@@ -258,10 +259,10 @@ export class InstanceLifecycle {
     activitySeedNow = new Set();
     /** When each instance was last woken or started for work — the pre-claim lease clock. */
     wokeAt = new Map();
-    /** backend → last auth-error alert time, so one expiry sends one alert. */
+    /** login (backend, or backend:profile) → last auth-error alert time, so one expiry sends one alert. */
     lastAuthAlertAt = new Map();
     /**
-     * backend → cached token-free auth verification (see AUTH_VERIFY_CACHE_MS).
+     * login (backend, or backend:profile) → cached token-free auth verification (see AUTH_VERIFY_CACHE_MS).
      * The PROMISE is cached, not the result: a shared credential expiring makes
      * every instance of the backend fire in the same tick, and they must join
      * one in-flight check instead of each spawning their own.
@@ -370,7 +371,19 @@ export class InstanceLifecycle {
      * CLI is not. Cached per backend so simultaneous alerts run one check.
      */
     verifyAuthError(name) {
-        return this.verifyBackendAuth(this.backendOf(name));
+        const backend = this.backendOf(name);
+        return this.verifyBackendAuth(backend, this.profileOf(name, backend));
+    }
+    /**
+     * The credential profile a running instance signs in with (#1699 follow-up): its login is that profile's, so its
+     * auth error is judged, cached and reported against that login — never the backend's default one, which can be fine
+     * while the profile's has expired.
+     */
+    profileOf(name, backend) {
+        return this.ctx.credentialProfileOf?.(name, backend) ?? null;
+    }
+    static loginKey(backend, profile) {
+        return profile ? `${backend}:${profile}` : backend;
     }
     verifyCodexQuota() {
         if (this.codexQuotaVerifyInFlight)
@@ -396,14 +409,19 @@ export class InstanceLifecycle {
         });
         return promise;
     }
-    /** Same verification keyed by backend (used by startup pre-flight priming). */
-    verifyBackendAuth(backend) {
-        const cached = this.authVerifyCache.get(backend);
+    /**
+     * Same verification keyed by login — a backend's default one, or one of its credential profiles, probed with that
+     * profile's environment (used by startup pre-flight priming).
+     */
+    verifyBackendAuth(backend, profile = null) {
+        const key = InstanceLifecycle.loginKey(backend, profile);
+        const cached = this.authVerifyCache.get(key);
         if (cached && Date.now() - cached.at < AUTH_VERIFY_CACHE_MS)
             return cached.promise;
         const check = LOGIN_FLOWS[backend]?.authCheck ?? BACKEND_AUTH_CHECKS[backend];
-        const promise = check ? checkAuthStatus(check) : Promise.resolve("unknown");
-        this.authVerifyCache.set(backend, { at: Date.now(), promise });
+        const env = profile ? credentialProfileEnv(getAgendHome(), backend, profile) : null;
+        const promise = check ? (env ? checkAuthStatus(check, env) : checkAuthStatus(check)) : Promise.resolve("unknown");
+        this.authVerifyCache.set(key, { at: Date.now(), promise });
         return promise;
     }
     /**
@@ -413,11 +431,16 @@ export class InstanceLifecycle {
      * anything, because e.g. codex on a custom provider runs fine while
      * `codex login status` reports logged out (live-verified on this fleet).
      */
-    primeAuthVerification(backends) {
-        for (const backend of new Set(backends)) {
-            void this.verifyBackendAuth(backend).then(result => {
+    primeAuthVerification(logins) {
+        const seen = new Set();
+        for (const { backend, profile } of logins) {
+            const key = InstanceLifecycle.loginKey(backend, profile);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            void this.verifyBackendAuth(backend, profile).then(result => {
                 if (result === "invalid") {
-                    this.ctx.logger.warn({ backend }, "Pre-flight auth check failed — marking backend as auth-suspect");
+                    this.ctx.logger.warn({ backend, profile }, "Pre-flight auth check failed — marking backend as auth-suspect");
                 }
             }).catch(() => { });
         }
@@ -430,27 +453,43 @@ export class InstanceLifecycle {
      */
     notifyAuthErrorOnce(name, message, notificationTarget = name) {
         const backend = this.backendOf(name);
+        // #1699 follow-up: a credential profile is a login of its own — its own alert, its own instances, its own fix.
+        const profile = this.profileOf(name, backend);
+        const key = InstanceLifecycle.loginKey(backend, profile);
         const now = Date.now();
-        const last = this.lastAuthAlertAt.get(backend) ?? 0;
+        const last = this.lastAuthAlertAt.get(key) ?? 0;
         if (now - last < AUTH_ALERT_COOLDOWN_MS) {
-            this.ctx.logger.info({ name, backend }, "auth error suppressed (backend already alerted)");
+            this.ctx.logger.info({ name, backend, profile }, "auth error suppressed (this login already alerted)");
             return;
         }
-        this.lastAuthAlertAt.set(backend, now);
-        const affected = [...this.daemons.keys()].filter(n => this.backendOf(n) === backend);
+        this.lastAuthAlertAt.set(key, now);
+        const affected = [...this.daemons.keys()].filter(n => this.backendOf(n) === backend && this.profileOf(n, backend) === profile);
         const others = affected.filter(n => n !== name);
+        const on = profile ? `\`${backend}\` profile \`${profile}\`` : `\`${backend}\``;
         const scope = others.length
-            ? `${affected.length} instances on \`${backend}\`: ${affected.join(", ")}`
-            : `\`${name}\` (${backend})`;
-        const remedy = backend === "opencode"
-            ? "Run `opencode auth login` in a terminal, then wake the affected instance(s)."
-            : `Use \`/login ${backend}\` to re-login remotely.`;
-        const dispatched = this.notifyIncident(notificationTarget, "auth_error", `🔑 ${message}\n\nAffects ${scope}. Credentials are shared per backend — one re-login restores all of them; affected instances pause until then. ${remedy}`);
+            ? `${affected.length} instances on ${on}: ${affected.join(", ")}`
+            : profile ? `\`${name}\` (${backend}, profile \`${profile}\`)` : `\`${name}\` (${backend})`;
+        // A profile is signed in with its own variable: `/login <backend>` would sign the DEFAULT login in. claude-code's
+        // can be signed in from chat (`/login <backend> <profile>`, #1699 part 2); the others' on the host.
+        const profileLogin = profile ? credentialProfileLoginCommand(getAgendHome(), backend, profile) : null;
+        const chatLogin = !!profileLogin && CHAT_PROFILE_LOGIN_BACKENDS.has(backend);
+        const remedy = chatLogin
+            ? `Use \`/login ${backend} ${profile}\` to sign that profile in remotely (or run \`${profileLogin}\` on the host).`
+            : profileLogin
+                ? `Run \`${profileLogin}\` on the host, then wake the affected instance(s).`
+                : backend === "opencode"
+                    ? "Run `opencode auth login` in a terminal, then wake the affected instance(s)."
+                    : `Use \`/login ${backend}\` to re-login remotely.`;
+        const shared = profile
+            ? "Credentials are shared per profile — one sign-in restores all of them; affected instances pause until then."
+            : "Credentials are shared per backend — one re-login restores all of them; affected instances pause until then.";
+        const dispatched = this.notifyIncident(notificationTarget, "auth_error", `🔑 ${message}\n\nAffects ${scope}. ${shared} ${remedy}`);
         // Only alongside an alert somebody actually saw: a button on its own, or one
-        // trailing a suppressed alert, is a control with no explanation next to it.
-        if (dispatched) {
-            void this.ctx.offerBackendLogin?.(notificationTarget, backend)
-                .catch(err => this.ctx.logger.warn({ err, backend }, "Could not offer the re-login button"));
+        // trailing a suppressed alert, is a control with no explanation next to it. For a profile only where its login
+        // runs from chat, and then the button carries the profile — the plain button signs the default login in.
+        if (dispatched && (!profileLogin || chatLogin)) {
+            void (profile ? this.ctx.offerBackendLogin?.(notificationTarget, backend, profile) : this.ctx.offerBackendLogin?.(notificationTarget, backend))
+                ?.catch(err => this.ctx.logger.warn({ err, backend, profile }, "Could not offer the re-login button"));
         }
     }
     /**
@@ -503,7 +542,9 @@ export class InstanceLifecycle {
     attachLaunchWarningHandler(name, daemon) {
         daemon.on("backend_launch_warning", safeHandler((data) => {
             this.ctx.eventLog?.insert(name, "backend_launch_warning", { message: data.message });
-            this.ctx.notifyInstanceTopic(name, t("inst.backend_launch_warning", name, data.message));
+            // #1794: a quiet warning changes nothing for the user — the Log tab keeps it, the topic does not get it.
+            if (data.quiet !== true)
+                this.ctx.notifyInstanceTopic(name, t("inst.backend_launch_warning", name, data.message));
         }, this.ctx.logger, `daemon.backend_launch_warning[${name}]`));
     }
     /**
@@ -804,6 +845,14 @@ export class InstanceLifecycle {
             // (Kept `description` for kind === "dialog" rather than a dedicated
             // kiro interactionKind: a new union member would flow into the category
             // labels, summaries and every exhaustive match for one picker's text.)
+            // #1691: a prompt no table knows — what it asks (one sanitised, bounded line from the daemon, never the pane), and
+            // that AgEnD will not press anything.
+            if (data.unrecognised) {
+                const asked = data.question ? t("inst.unrecognised_prompt_question", data.question) : "";
+                this.notifyIncident(name, "dialog_parked", t("inst.unrecognised_prompt", name, asked));
+                this.ctx.notifyFleetError?.(t("fleet.unrecognised_prompt", name, asked));
+                return;
+            }
             const category = data.kind && data.kind !== "dialog" ? interactionCategory(data.kind, data.backend) : null;
             const text = category ? t("inst.interaction_parked", name, category) : data.holdOnly
                 ? t("inst.dialog_parked_hold", name, data.description)
@@ -1218,7 +1267,9 @@ export class InstanceLifecycle {
         if (seedNow)
             daemon.seedActivityNow();
         // Read at each spawn so a fleet.yaml reload is honoured (#984).
-        daemon.setPeerWorkingDirectories(() => peerWorkingDirectories(this.ctx.fleetConfig, name, backendName));
+        daemon.setPeerWorkingDirectories(backendName === "kiro-cli"
+            ? this.ctx.kiroPeerWorkingDirectories ? () => this.ctx.kiroPeerWorkingDirectories(name) : undefined
+            : () => peerWorkingDirectories(this.ctx.fleetConfig, name, backendName));
         daemon.setStatusEmojiAvoidList(() => this.ctx.statusEmojiAvoidList?.(name));
         // Before start: the first spawn builds the command and emits its launch
         // warning synchronously inside Daemon.start, long before