@agentshouse/kit 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/telegram.js

@@ -955,14 +955,14 @@ async function proveOwner(gateway, token, telegramBotUserId) {
   throw new KitRefusal("telegram_owner_not_proven");
 }
 
-function gatewayContext(session, options, dependencies, signal, summary = emptySummary()) {
+function gatewayContext(session, options, signal, summary = emptySummary()) {
   return {
     session,
     directory: options.directory,
-    dependencies,
+    dependencies: session.dependencies,
     signal,
     gate: rateGate(() => session.now().getTime()),
-    wait: dependencies.wait ?? pause,
+    wait: session.dependencies.wait ?? pause,
     passes: options.passes ?? Number.POSITIVE_INFINITY,
     summary,
   };
@@ -970,7 +970,15 @@ function gatewayContext(session, options, dependencies, signal, summary = emptyS
 
 export async function connectPersonalBot(options, dependencies = {}) {
   const session = await openSession(options, dependencies);
-  const gateway = gatewayContext(session, options, dependencies, options.signal);
+  return maintainControl(
+    session,
+    (signal) => connectBot(session, options, dependencies, signal),
+    options.signal,
+  );
+}
+
+async function connectBot(session, options, dependencies, signal) {
+  const gateway = gatewayContext(session, options, signal);
   const ask = dependencies.prompt ?? (() => askForToken(dependencies));
   const token = (await ask()).trim();
   if (token.length === 0) throw new KitRefusal("telegram_bot_token_required");
@@ -989,7 +997,7 @@ export async function connectPersonalBot(options, dependencies = {}) {
     owner_telegram_user_id: await proveOwner(gateway, token, identity.telegramBotUserId),
     has_topics_enabled: true,
   };
-  await writeOwned(tokenPath(options.directory), `${token}\n`, options.signal);
+  await writeOwned(tokenPath(options.directory), `${token}\n`, signal);
   try {
     await houseCall(gateway, "personal-bot", setup);
   } catch (error) {
@@ -1001,7 +1009,15 @@ export async function connectPersonalBot(options, dependencies = {}) {
 
 export async function disconnectPersonalBot(options, dependencies = {}) {
   const session = await openSession(options, dependencies);
-  const gateway = gatewayContext(session, options, dependencies, options.signal);
+  return maintainControl(
+    session,
+    (signal) => disconnectBot(session, options, signal),
+    options.signal,
+  );
+}
+
+async function disconnectBot(session, options, signal) {
+  const gateway = gatewayContext(session, options, signal);
   const directory = options.directory;
   const marked = await disconnecting(directory);
   let token = null;
@@ -1010,7 +1026,7 @@ export async function disconnectPersonalBot(options, dependencies = {}) {
   } catch (error) {
     if (!marked) throw error;
   }
-  if (!marked) await writeOwned(disconnectPath(directory), "{}\n", options.signal);
+  if (!marked) await writeOwned(disconnectPath(directory), "{}\n", signal);
   if (token !== null) {
     await telegramCall(gateway, token, "deleteWebhook", { drop_pending_updates: false });
     await Promise.all([
@@ -1032,7 +1048,7 @@ export async function serveTelegramGateway(options, dependencies = {}) {
       async (signal) => {
         const stopping = new AbortController();
         const shared = AbortSignal.any([signal, stopping.signal]);
-        const gateway = gatewayContext(session, options, dependencies, shared, summary);
+        const gateway = gatewayContext(session, options, shared, summary);
         summary.abandoned = abandonedOf(await houseCall(gateway, "deliveries/abandoned"));
         await serveActivities(gateway, stopping);
       },

package/src/worker.js

@@ -2,7 +2,11 @@ import { randomBytes } from "node:crypto";
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
-import { agentReadiness, installedAgentCommand, updateDeclaredAgents } from "./agents.js";
+import {
+  installedAgentCommand,
+  readAgentState,
+  reconcileAgentKinds,
+} from "./agents.js";
 import { readBindings, removeBinding, writeBinding } from "./binding.js";
 import { readContinuation, readContinuationRuns, writeContinuation, removeContinuation } from "./continuation.js";
 import { openBridge } from "./bridge.js";
@@ -12,6 +16,7 @@ import { openAssistantDrafts } from "./draft.js";
 import { localReply, localRequest, reconcileInbound } from "./inbound.js";
 import { localFiles } from "./local-files.js";
 import { inheritedEnvironment } from "./command.js";
+import { watchKitAgentWork } from "./kit-work-stream.js";
 import { readConfiguration } from "./configuration.js";
 import { launchBase, readyLaunchDirectory } from "./directory.js";
 import {
@@ -31,7 +36,6 @@ import {
   acceptAssistantText,
   acquireCommands,
   acquireSetup,
-  reportAgentCapabilities,
   acquireOneRun,
   acquireOneResumption,
   admitInteraction,
@@ -40,7 +44,6 @@ import {
   rejectResumption,
   callHouseMcp,
   commitRun,
-  desiredAgents,
   maintainControl,
   mutatingCall,
   observeSessionStart,
@@ -54,11 +57,12 @@ import {
   reportRunOutcome,
   reportSessionHeartbeat,
   reportSessions,
+  serveResident,
   sessionAuthority,
   streamAssistantDraft,
 } from "./house.js";
 import { operationId } from "./operation.js";
-import { runSetup } from "./setup.js";
+import { runSetup, signInWantedAgent } from "./setup.js";
 import { readSettlements, removeSettlement, writeSettlement } from "./settlement.js";
 import { failedReport, terminalReport } from "./terminal.js";
 import {
@@ -666,26 +670,33 @@ async function afterEpochReport(context, pass) {
   return pass();
 }
 
-async function workerPass(context, dependencies) {
-  const { configuration, session, signal } = context;
+async function workerPass(context, dependencies, baseConfiguration) {
+  const { session, signal } = context;
   const reconciled = await reconcile(context);
   if (reconciled.run !== null || reconciled.unresolved.length > 0) return reconciled;
+  context.busy = false;
+  const needsLogin = await queueAgentRefresh(context, dependencies, signal, baseConfiguration);
+  context.startLogins?.(needsLogin);
+  context.busy = true;
+  const { configuration } = context;
   context.inbound = await reconcileInbound(context.directory, session);
   const setup = await acquireSetup(session, signal);
   if (setup !== null) {
     context.setup = await runSetup(
-      { session, configuration, directory: context.directory, dependencies, signal },
+      {
+        session,
+        configuration,
+        directory: context.directory,
+        dependencies,
+        signal,
+        waitAgentLogin: context.waitAgentLogin,
+      },
       setup.request,
     );
+    await context.recordSetupLogins?.(context.setup);
+    const needsLogin = await queueAgentRefresh(context, dependencies, signal, undefined, true);
+    context.startLogins?.(needsLogin);
   }
-  context.agents = await updateDeclaredAgents(
-    { directory: context.directory, at: dependencies.now?.() },
-    configuration,
-    dependencies,
-  );
-  const readiness = await agentReadiness({ directory: context.directory }, configuration, dependencies);
-  await reportAgentCapabilities(session, readiness.agents);
-  if (readiness.refused !== null) throw readiness.refused;
   const resumption = await acquireOneResumption(session);
   if (resumption !== null) return { ...reconciled, run: await superviseResumption(context, resumption) };
   const assignment = await acquireOneRun(session);
@@ -698,7 +709,7 @@ async function workerContext(options, dependencies) {
   const runtime = workerRuntime(options.directory, dependencies.tmux ?? "tmux");
   const launcher = dependencies.launcher ?? [process.execPath, LAUNCHER_MAIN];
   const tmux = await readyTmux(runtime);
-  const session = await openSession(options, dependencies);
+  const session = await openSession({ ...options, acquire: true }, dependencies);
   const context = {
     configuration,
     runtime,
@@ -709,15 +720,59 @@ async function workerContext(options, dependencies) {
     directory: options.directory,
     files: { originals: [], failures: [] },
     epochReport: null,
+    agentRefresh: Promise.resolve(),
+    configurationPath: options.configuration,
+    busy: false,
+    deferredRemoval: false,
   };
   return { context, tmux };
 }
 
+async function refreshAgentCapabilities(context, dependencies, signal, configuration, pointer = false) {
+  const base = configuration ?? (await readConfiguration(context.configurationPath));
+  const busy = context.busy || (await readBindings(context.directory)).length > 0;
+  const result = await reconcileAgentKinds(
+    { directory: context.directory },
+    context.session,
+    base,
+    dependencies,
+    signal,
+    {
+      pointer,
+      busy,
+      lastDesired: context.lastDesired,
+      onDesired: (wanted) => context.cancelLogins?.(wanted),
+    },
+  );
+  context.deferredRemoval = result.retained.length > 0;
+  context.configuration = result.selected;
+  context.agents = result.updated;
+  context.lastDesired = [...result.selected.agents];
+  if (result.refused !== null) throw result.refused;
+  return result.reported.filter(
+    (agent) =>
+      result.selected.agents.includes(agent.kind) && agent.release !== null && !agent.signed_in,
+  );
+}
+
+function queueAgentRefresh(context, dependencies, signal, configuration, pointer = false) {
+  const refreshed = context.agentRefresh.then(() =>
+    refreshAgentCapabilities(context, dependencies, signal, configuration, pointer),
+  );
+  context.agentRefresh = refreshed.catch(() => {});
+  return refreshed;
+}
+
 async function controlledPass(context, dependencies, configuration, signal) {
-  context.configuration = { ...configuration, agents: await desiredAgents(context.session, signal) };
   context.signal = signal;
   context.session.signal = signal;
-  return afterEpochReport(context, () => workerPass(context, dependencies));
+  context.busy = true;
+  try {
+    return await afterEpochReport(context, () => workerPass(context, dependencies, configuration));
+  } finally {
+    context.busy = false;
+    if (context.deferredRemoval) context.onIdle?.();
+  }
 }
 
 export async function runWorkers(options, dependencies = {}) {
@@ -740,17 +795,134 @@ export async function runWorkers(options, dependencies = {}) {
   };
 }
 
-export async function runResident(options, dependencies = {}) {
-  const { context } = await workerContext(options, dependencies);
-  await maintainControl(context.session, async (signal) => {
-    while (!signal.aborted) {
-      const configuration = await readConfiguration(options.configuration);
-      await controlledPass(context, dependencies, configuration, signal);
+function residentWake() {
+  let pending = false;
+  let release = null;
+  return {
+    notify() {
+      pending = true;
+      release?.();
+    },
+    async wait(milliseconds, signal) {
+      if (pending) {
+        pending = false;
+        return;
+      }
+      const pause = new AbortController();
       try {
-        await delay(dependencies.residentIntervalMs ?? 30_000, undefined, { signal });
+        await Promise.race([
+          new Promise((resolve) => {
+            release = resolve;
+          }),
+          delay(milliseconds, undefined, { signal: AbortSignal.any([signal, pause.signal]) }),
+        ]);
       } catch (error) {
         if (!signal.aborted) throw error;
+      } finally {
+        release = null;
+        pending = false;
+        pause.abort();
+      }
+    },
+  };
+}
+
+export async function runResident(options, dependencies = {}) {
+  const { context } = await workerContext(options, dependencies);
+  await maintainControl(context.session, async (signal) => {
+    const closeResident = await serveResident(context.session, context.directory, signal);
+    context.busy = true;
+    const wake = residentWake();
+    const watcher = new AbortController();
+    let failure = null;
+    const logins = new Map();
+    const attemptedLogins = new Map();
+    context.cancelLogins = (wanted) => {
+      for (const [kind, running] of logins) {
+        if (!wanted.includes(kind)) running.controller.abort();
+      }
+      for (const kind of attemptedLogins.keys()) {
+        if (!wanted.includes(kind)) attemptedLogins.delete(kind);
       }
+    };
+    context.recordSetupLogins = async (modules) => {
+      for (const module of modules) {
+        if (module.category !== "agent" || module.status !== "needs_attention") continue;
+        const release = (await readAgentState(context.directory, module.name)).release;
+        if (release !== null) attemptedLogins.set(module.name, release);
+      }
+    };
+    context.startLogins = (agents) => {
+      for (const agent of agents) {
+        const { kind, release } = agent;
+        if (logins.has(kind) || attemptedLogins.get(kind) === release) continue;
+        const controller = new AbortController();
+        const loginSignal = AbortSignal.any([signal, controller.signal]);
+        const task = (async () => {
+          if ((await acquireSetup(context.session, loginSignal)) !== null) return;
+          attemptedLogins.set(kind, release);
+          await signInWantedAgent({ ...context, dependencies, signal: loginSignal }, kind);
+          await queueAgentRefresh(context, dependencies, signal, undefined, true);
+        })()
+          .catch((error) => {
+            if (loginSignal.aborted) return;
+            failure = error;
+            wake.notify();
+          })
+          .finally(() => logins.delete(kind));
+        logins.set(kind, { controller, task });
+      }
+    };
+    context.waitAgentLogin = async (kind) => {
+      await logins.get(kind)?.task;
+    };
+    let pointerPending = false;
+    let pointerTask = null;
+    const pointer = () => {
+      pointerPending = true;
+      if (pointerTask !== null) return;
+      pointerTask = (async () => {
+        while (pointerPending && !signal.aborted) {
+          pointerPending = false;
+          const needsLogin = await queueAgentRefresh(context, dependencies, signal, undefined, true);
+          context.startLogins(needsLogin);
+        }
+      })()
+        .catch((error) => {
+          if (signal.aborted) return;
+          failure = error;
+          wake.notify();
+        })
+        .finally(() => {
+          pointerTask = null;
+          if (pointerPending && !signal.aborted) pointer();
+        });
+    };
+    context.onIdle = pointer;
+    const watching = (dependencies.watchKitAgentWork ?? watchKitAgentWork)(
+      context.session,
+      AbortSignal.any([signal, watcher.signal]),
+      pointer,
+      dependencies,
+    ).catch((error) => {
+      failure = error;
+      wake.notify();
+    });
+    try {
+      while (!signal.aborted) {
+        if (failure !== null) throw failure;
+        const configuration = await readConfiguration(options.configuration);
+        await controlledPass(context, dependencies, configuration, signal);
+        await wake.wait(dependencies.residentIntervalMs ?? 30_000, signal);
+      }
+    } finally {
+      watcher.abort();
+      await watching;
+      if (pointerTask !== null) await pointerTask;
+      for (const running of logins.values()) running.controller.abort();
+      await Promise.all([...logins.values()].map((running) => running.task));
+      await context.agentRefresh;
+      await closeResident();
     }
   }, options.signal);
 }