@onepointfour-packs/flaredeck-agent 0.2.39 → 0.2.40

package/dist/serve.js

@@ -347,6 +347,14 @@ export async function serve(opts) {
      */
     const localMcp = [...(config.mcpServers ?? [])];
     let lastMcpNote = '';
+    /**
+     * The workspace's GitHub connection, from FlareDeck — current at every session, refreshed there
+     * with the OAuth App's secret this public package cannot hold. When set it wins over the
+     * machine's own github.json; when absent the machine's login works exactly as before.
+     */
+    let flaredeckGithub = null;
+    /** The command guard's config, so a rotated OpenRouter key reaches it (see refreshMcp). */
+    let jevCfg = null;
     const refreshMcp = async () => {
         try {
             const { hydrateMcpServers, mcpConfigFetcher } = await import('./hydrate.js');
@@ -359,6 +367,16 @@ export async function serve(opts) {
                 lastMcpNote = hydrated.note;
                 log('tool', hydrated.note);
             }
+            const gh = hydrated.github ?? null;
+            if (!!gh !== !!flaredeckGithub || gh?.login !== flaredeckGithub?.login) {
+                log('tool', gh ? `GitHub: using FlareDeck's connection (@${gh.login ?? 'unknown'})` : 'GitHub: this machine\'s own login');
+            }
+            flaredeckGithub = gh;
+            // The workspace's model keys: Jev's OpenRouter key and Gemini, kept current every session.
+            const { setProvidersFromFlaredeck } = await import('./providers.js');
+            setProvidersFromFlaredeck(hydrated.providers);
+            if (jevCfg)
+                jevCfg.apiKey = loadProviders().openrouter?.apiKey ?? jevCfg.apiKey;
             return hydrated.missingRequired ?? null;
         }
         catch (e) {
@@ -568,7 +586,8 @@ export async function serve(opts) {
      * Its refusals and its asks both end up in decisions.jsonl beside the config.
      */
     const jevKey = loadProviders().openrouter?.apiKey;
-    const guard = jevGuard({
+    // Kept as an object so a key rotated in FlareDeck reaches the guard at the next session.
+    const guard = jevGuard(jevCfg = {
         apiKey: jevKey ?? '',
         decider: (req, opt) => decider(req, opt),
         log: (t) => log('tool', t),
@@ -844,16 +863,23 @@ export async function serve(opts) {
     let readyReported = false;
     /** Walls the agent cannot climb, checked in code — never by asking the model. */
     const walls = async () => {
-        config.github = loadGitHub() ?? config.github;
-        const login = await canPublish(config.github).catch(() => null);
+        /* FlareDeck's token is checked from a LOCAL, never put into config.github: saveConfig writes
+           config.github to github.json, and the hourly OAuth refresh calls saveConfig — so FlareDeck's
+           token would have been copied onto this machine's disk, and survived Disconnect there. */
+        if (!flaredeckGithub)
+            config.github = loadGitHub() ?? config.github;
+        const gh = flaredeckGithub ? { accessToken: flaredeckGithub.token } : config.github;
+        const login = await canPublish(gh).catch(() => null);
         if (login)
-            return { check: 'github', reason: `GitHub refuses this machine's login, so nothing I write can be published. Somebody signs it in again on this machine: \`flaredeck-agent login --github-token ghp_…\` (a classic token with repo and workflow scope does not expire).` };
-        if (config.github?.accessToken) {
+            return { check: 'github', reason: flaredeckGithub
+                    ? `GitHub refuses FlareDeck's connection (@${flaredeckGithub.login ?? 'unknown'}), so nothing I write can be published. Reconnect GitHub on Integrations.`
+                    : `GitHub refuses this machine's login, so nothing I write can be published. Somebody signs it in again on this machine: \`flaredeck-agent login --github-token ghp_…\` (a classic token with repo and workflow scope does not expire).` };
+        if (gh?.accessToken) {
             for (const c of [{ path: config.repo }, ...(await checkouts(config.repo, config.repos))]) {
                 const remote = await new Promise((resolve) => {
                     execFile('git', ['remote', 'get-url', 'origin'], { cwd: c.path }, (err, out) => resolve(err ? '' : String(out).trim()));
                 });
-                const why = remote ? await canPushTo(config.github.accessToken, remote) : null;
+                const why = remote ? await canPushTo(gh.accessToken, remote) : null;
                 if (why)
                     return { check: 'github', reason: `${why} Nothing I write in ${c.path} could be published. Fix the access, or sign this machine in with an account that has it.` };
             }
@@ -1035,6 +1061,14 @@ export async function serve(opts) {
     /** Worktrees whose environment comes down unless a turn returns to them first. */
     const idleStops = new Map();
     const ENV_IDLE_MS = 20 * 60_000;
+    /**
+     * Checkouts with a sign-in still waiting for a person, and since when. Their environment is
+     * kept up: the sign-in browser is open ON it, and stopping it left that page retrying a dead
+     * server — hundreds of ERR_CONNECTION_REFUSED lines — and a sign-in nobody could finish.
+     * Bounded, so a sign-in that never settles cannot keep an environment up for ever.
+     */
+    const signInPending = new Map();
+    const SIGN_IN_HOLD_MS = 2 * 60 * 60_000;
     const scheduleEnvironmentStop = (cwd) => {
         const before = idleStops.get(cwd);
         if (before)
@@ -1044,6 +1078,11 @@ export async function serve(opts) {
             // Never the checkout a turn is in right now, even if the timer and the turn cross.
             if (cwd === turnCwd && state.working)
                 return;
+            const waiting = signInPending.get(cwd);
+            if (waiting && Date.now() - waiting < SIGN_IN_HOLD_MS) {
+                scheduleEnvironmentStop(cwd);
+                return;
+            }
             void stopEnvironment(cwd).then((ok) => { if (ok)
                 log('tool', `environment stopped in ${cwd.split('/').pop()} (idle 20m)`); }).catch(() => { });
         }, ENV_IDLE_MS));
@@ -1393,6 +1432,15 @@ export async function serve(opts) {
      * harness reads it and queues the card itself, as the ordinary card event it should always
      * have been — with a worktree, a branch, and everything else a card turn gets.
      */
+    /**
+     * Pickups per card since anything real happened on it. A card whose work is done but which was
+     * never moved out of the in-progress lane came back every sweep and every restart, each time a
+     * turn that found "nothing new to act on" — and it blocked every other card. After two such
+     * pickups the harness leaves it and says so; any real event on the card (a comment, a move, an
+     * assignment) clears the count.
+     */
+    const resumedIdle = new Map();
+    const RESUME_IDLE_LIMIT = 2;
     const resumeOwnWork = async () => {
         /* Not `live.size`: a session kept WARM for a follow-up is a cache, not work, and blocking on
            it meant the card in progress was never resumed within fifteen minutes of any turn. */
@@ -1426,7 +1474,13 @@ export async function serve(opts) {
         for (const c of mine) {
             if (sessions.has(c.code) || live.has(c.code))
                 continue;
+            if ((resumedIdle.get(c.code) ?? 0) >= RESUME_IDLE_LIMIT)
+                continue;
             const card = await opts.deck?.card(c.code).catch(() => null);
+            // Waiting on a person: nothing to do until they answer, and their answer is an event that
+            // wakes this agent anyway. Reopening it only spends a turn finding that out again.
+            if (card?.needs_human)
+                continue;
             if (String(card?.lane?.type ?? '').toLowerCase() === 'inprogress') {
                 next = c;
                 break;
@@ -1434,6 +1488,11 @@ export async function serve(opts) {
         }
         if (!next)
             return false;
+        const n = (resumedIdle.get(next.code) ?? 0) + 1;
+        resumedIdle.set(next.code, n);
+        if (n === RESUME_IDLE_LIMIT) {
+            log('warn', `${next.code}: picked up ${n} times with nothing new on it — after this one I leave it. Move it out of in-progress, or comment on it, to change that.`);
+        }
         log('tool', `picking ${next.code} back up — it is yours and already in progress`);
         if (enqueue({
             id: `resume-${next.code}-${Date.now()}`,
@@ -1526,6 +1585,10 @@ export async function serve(opts) {
                 if (event.event !== 'ask')
                     log('event', event.line);
                 // A sweep or a typed question is work, but it is not a card — see startCard.
+                // Something real happened on this card — not the harness's own pickup — so it may have
+                // work again: clear the idle-pickup count that stops it being resumed.
+                if (event.cardCode && !String(event.id ?? '').startsWith('resume-'))
+                    resumedIdle.delete(event.cardCode);
                 status.startCard(current, !!event.cardKey);
                 void report();
                 let didWork = true;
@@ -2115,9 +2178,18 @@ export async function serve(opts) {
                 base: startFrom ?? (await baseBranch(cwd)),
                 card: event.cardCode || key,
                 onAuthFailure: (why) => {
-                    void enterPause({ check: 'github', reason: `GitHub refused this machine's login when I pushed (${why.slice(0, 160)}), so nothing I write can be published. Somebody signs it in again on this machine: \`flaredeck-agent login --github-token ghp_…\` (a classic token with repo and workflow scope does not expire).` });
+                    void enterPause({ check: 'github', reason: flaredeckGithub
+                            ? `GitHub refused FlareDeck's connection (@${flaredeckGithub.login ?? 'unknown'}) when I pushed (${why.slice(0, 160)}), so nothing I write can be published. Reconnect GitHub on Integrations, and check that the account can push to this repository (an org may need to approve the OAuth App).`
+                            : `GitHub refused this machine's login when I pushed (${why.slice(0, 160)}), so nothing I write can be published. Somebody signs it in again on this machine: \`flaredeck-agent login --github-token ghp_…\` (a classic token with repo and workflow scope does not expire).` });
                 },
                 token: async () => {
+                    // FlareDeck's connection first, asked again at every push: it refreshes the token
+                    // centrally, so an agent running all day never pushes with an expired one.
+                    if (flaredeckGithub) {
+                        await refreshMcp();
+                        if (flaredeckGithub)
+                            return flaredeckGithub.token;
+                    }
                     // Read fresh at every push: the login is the machine's, so signing in again from
                     // any pane fixes an agent that has been running all day with the old one.
                     config.github = loadGitHub() ?? config.github;
@@ -2245,6 +2317,25 @@ export async function serve(opts) {
                             ...(card.board ? { board: card.board } : {}),
                             ...(card.code ? { code: card.code } : {}),
                         };
+                        // Held up while the person has not signed in yet — see signInPending.
+                        const signCwd = turnCwd;
+                        if (signCwd)
+                            signInPending.set(signCwd, Date.now());
+                        /* The page's console, forwarded — but a page retrying something gone repeats one
+                           line hundreds of times. The first is logged; repeats are counted and summarised. */
+                        let lastNote = '';
+                        let repeats = 0;
+                        const pageNote = (t) => {
+                            if (t === lastNote) {
+                                repeats++;
+                                if (repeats === 3 || repeats % 50 === 0)
+                                    log('tool', `sign-in: (the same line ${repeats + 1}× so far) ${t.slice(0, 120)}`);
+                                return;
+                            }
+                            lastNote = t;
+                            repeats = 0;
+                            log('tool', `sign-in: ${t}`);
+                        };
                         void signInSession({
                             url,
                             launch: () => chromium.launch(HEADLESS_FULL),
@@ -2257,9 +2348,11 @@ export async function serve(opts) {
                                     `session is kept for the whole project, so this is once, not once per card.`, 'sign_in', undefined, [{ url: viewer, label: 'Sign in' }]);
                                 settle({ asked: true, where: viewer });
                             },
-                            onNote: (t) => log('tool', `sign-in: ${t}`),
+                            onNote: pageNote,
                         })
                             .then(async (r) => {
+                            if (signCwd)
+                                signInPending.delete(signCwd);
                             if (!r.ok || !r.session) {
                                 log('warn', `sign-in for "${part}" did not finish: ${r.why ?? 'nothing was saved'}`);
                                 /* Say so ON THE CARD. The flag already raised carries a link to a viewer
@@ -2979,10 +3072,21 @@ function prompt(event, isLead = false) {
             'dispatch, re-assign, or change anything else — this is a review, not a card to work.',
         ].join('\n');
     }
+    // A card the HARNESS picked back up because it sits in progress with this agent's name on it.
+    // Finished work left there comes back on every check and blocks every other card.
+    const resumed = String(event.id ?? '').startsWith('resume-')
+        ? ['', 'You were handed this card again only because it is still in an in-progress lane assigned to',
+            'you. If its work is already finished — answered, delivered, nothing left for you — move it on to',
+            'its next lane with update-card-status NOW. Left in progress, it is handed back to you on every',
+            'check and FlareDeck will not let you start any other card. If it is waiting on a PERSON and you',
+            'may not move it yourself, call set-needs-human saying what they need to do — a card waiting on a',
+            'person is not handed back to you, and their answer wakes you.']
+        : [];
     return [
         `A FlareDeck event just arrived for you:`,
         '',
         event.line,
+        ...resumed,
         '',
         'Deal with it. Read the card before you change anything — INCLUDING its agent notes, where a',
         'previous session may have left you a handover: what it got to, what it tried that failed,',