@parlor/agent-host 0.3.0 → 0.3.2

package/dist/daemon.js

@@ -3,8 +3,10 @@ import { createServer } from "node:net";
 import { basename, delimiter, dirname, join } from "node:path";
 import { HOST_PROTOCOL, } from "@parlor/chat";
 import { ActionError, asId, DEV_USER_ID } from "@parlor/core";
+import { removeAgentSkills, writeAgentSkills } from "./agent-skills.js";
+import { readUsage, surveyOptions } from "./agent-survey.js";
 import { agentNames, registerAgentTools, unregisterAgentTools, } from "./agent-tools.js";
-import { detectAgents, loadProfiles } from "./agents.js";
+import { findAgents, loadProfiles } from "./agents.js";
 import { connectControl } from "./control.js";
 import { requestDevHostToken } from "./dev-host.js";
 import { devHostKeys } from "./grants.js";
@@ -21,7 +23,7 @@ import { compareVersions, RELEASE_KEY, signedRelease } from "./release.js";
 import { revokeGrant } from "./revoke.js";
 import { selfEntry } from "./self.js";
 import { installLoginItem, installRelease } from "./service.js";
-import { agentEnvironment } from "./shell-path.js";
+import { agentEnvironment, rereadAgentPath } from "./shell-path.js";
 import { runTurn } from "./turn.js";
 const CONNECT_TIMEOUT_MS = 15_000;
 /** An agent token is asked for again this long before it runs out. */
@@ -63,12 +65,16 @@ export class HostAlreadyRunning extends Error {
         super("Parlor Host is already running on this computer.");
     }
 }
+/** Codex's own CLI throttles its rate-limit reports on the same interval. */
+const USAGE_READ_FLOOR_MS = 30_000;
 export function createHostDaemon(deps) {
     const { paths } = deps;
     const links = new Map();
     const devTokens = new Map();
     const name = computerName();
     const platform = platformName();
+    /** As `agents.json` lists them; `profiles` are these with each `binary` set to the CLI found. */
+    let listedProfiles = [];
     let profiles = [];
     let agents = [];
     const learned = learnedStore(paths.learned);
@@ -89,14 +95,75 @@ export function createHostDaemon(deps) {
             return undefined;
         }
     };
+    /** What an agent said about itself, told to every linked app when it changes what they show. */
+    const learn = (agentId, news) => {
+        void learned
+            .learn(agentId, news)
+            .then((changed) => {
+            if (!changed)
+                return;
+            for (const linked of links.values())
+                void report(linked).catch(() => undefined);
+        })
+            .catch(() => undefined);
+    };
+    /** Ends the reads below on stop or handover, so nothing outlives the daemon. */
+    const stopping = new AbortController();
+    const usageReadAt = new Map();
+    /** The allowance from the agent's own CLI where ACP carries none, at most every 30s per agent. */
+    const refreshUsage = async (agentId) => {
+        const profile = profiles.find((candidate) => candidate.id === agentId);
+        const now = Date.now();
+        if (!profile || stopping.signal.aborted)
+            return;
+        if (now - (usageReadAt.get(agentId) ?? 0) < USAGE_READ_FLOOR_MS)
+            return;
+        usageReadAt.set(agentId, now);
+        const usage = await readUsage(profile, await agentEnvironment(), now).catch(() => undefined);
+        if (usage && !stopping.signal.aborted)
+            learn(agentId, { usage });
+    };
+    let surveyed = false;
+    /**
+     * Options for every agent that has not run a turn yet, so the sidebar can offer a model first.
+     * Once per run, when an app first links: a computer no app uses never starts its agents.
+     */
+    const surveyAgents = async () => {
+        if (surveyed)
+            return;
+        surveyed = true;
+        const env = await agentEnvironment();
+        for (const agent of agents) {
+            const profile = profiles.find((candidate) => candidate.id === agent.id);
+            if (!profile || stopping.signal.aborted)
+                continue;
+            void refreshUsage(agent.id);
+            if (learned.knows(agent.id))
+                continue;
+            const options = await surveyOptions(profile, deps.launcher, env, stopping.signal);
+            if (stopping.signal.aborted)
+                return;
+            logEvent("agent_surveyed", { agentId: agent.id, options: options?.length ?? 0 });
+            if (options && options.length > 0)
+                learn(agent.id, { options });
+        }
+    };
     const running = new Set();
     let handedOver = false;
     let finishing = false;
     let finishHandover = () => undefined;
     const drained = new Promise((resolve) => (finishHandover = resolve));
-    const run = (state, claimed) => {
+    /** A turn runs once here, even when a pushed turn its app took back is claimed again. */
+    const runningTurns = new Set();
+    const run = (state, claimed, how = "claimed") => {
         const { link } = state;
-        logEvent("turn_claimed", { appOrigin: link.grant.appOrigin, turnId: claimed.turnId });
+        if (runningTurns.has(claimed.turnId))
+            return;
+        runningTurns.add(claimed.turnId);
+        logEvent(how === "pushed" ? "turn_pushed" : "turn_claimed", {
+            appOrigin: link.grant.appOrigin,
+            turnId: claimed.turnId,
+        });
         state.turns += 1;
         const turn = (link.grant.dev ? Promise.resolve(DEV_POLICY) : loadPolicy(paths.policy, deps.policy))
             .then((policy) => runTurn(claimed, {
@@ -119,17 +186,7 @@ export function createHostDaemon(deps) {
             policy,
             prompter: deps.prompter,
             now: Date.now,
-            learned: (agentId, news) => {
-                void learned
-                    .learn(agentId, news)
-                    .then((changed) => {
-                    if (!changed)
-                        return;
-                    for (const linked of links.values())
-                        void report(linked).catch(() => undefined);
-                })
-                    .catch(() => undefined);
-            },
+            learned: learn,
             pairing: {
                 secret: async () => (await deps.grants.get(link.grant.appOrigin))?.pairingSecret,
                 forget: async () => {
@@ -143,6 +200,8 @@ export function createHostDaemon(deps) {
         }))
             .then((outcome) => logEvent("turn_finished", { turnId: claimed.turnId, outcome }), (error) => logEvent("turn_finished", { turnId: claimed.turnId, error: String(error) }))
             .finally(() => {
+            runningTurns.delete(claimed.turnId);
+            void refreshUsage(claimed.agent.agentId);
             state.turns -= 1;
             running.delete(turn);
             settleHandover();
@@ -190,21 +249,112 @@ export function createHostDaemon(deps) {
             agents: agentNames(profiles, { name: tools.name, agents: tools.agents }),
         };
     };
+    /** The skill that sends the agents to the app's tools when the user names it, kept current. */
+    const writeSkills = async (grant) => {
+        const tools = grant.agentTools;
+        if (grant.dev || !tools?.on || !tools.name || !tools.agents?.length)
+            return;
+        await writeAgentSkills(tools.agents, {
+            name: tools.name,
+            appName: grant.appName,
+            appOrigin: grant.appOrigin,
+            account: grant.account.email ?? grant.account.name,
+        }, await agentEnvironment());
+    };
+    let toolsWork = Promise.resolve();
+    /** Registering and removing the app with the agents runs one at a time, on the grant as saved by then. */
+    const serially = (work) => {
+        const next = toolsWork.then(work, work);
+        toolsWork = next.catch(() => undefined);
+        return next;
+    };
     /** Registers the app with the agents here once the user chose it and it is not yet. */
-    const ensureAgentTools = async (grant) => {
-        if (!grant.agentTools?.on || grant.dev || grant.agentTools.agents)
+    const ensureAgentTools = (grant) => serially(() => ensureAgentToolsNow(grant));
+    const ensureAgentToolsNow = async (grant) => {
+        if (!grant.agentTools?.on || grant.dev)
+            return grant;
+        if (grant.agentTools.agents) {
+            await writeSkills(grant);
             return grant;
+        }
         const registered = await registerAgentTools(toolsDeps(), grant);
         const next = { ...grant, agentTools: { on: true, ...registered } };
         await deps.grants.save(next);
+        await writeSkills(next);
         return next;
     };
-    const removeAgentTools = async (grant) => {
+    /** Hands the app to agents installed since it was registered with the ones here then. */
+    const handToNewAgents = (origin) => serially(async () => {
+        const grant = await deps.grants.get(origin);
+        if (grant)
+            await handToNewAgentsNow(grant);
+    });
+    const handToNewAgentsNow = async (grant) => {
+        const tools = grant.agentTools;
+        if (grant.declined || grant.dev || !tools?.on || !tools.agents)
+            return;
+        const have = new Set(tools.agents);
+        const fresh = toolsDeps().profiles.filter((profile) => !have.has(profile.id));
+        if (fresh.length === 0) {
+            await writeSkills(grant);
+            return;
+        }
+        const registered = await registerAgentTools({ ...toolsDeps(), profiles: fresh }, grant);
+        if (registered.agents.length === 0) {
+            await writeSkills(grant);
+            return;
+        }
+        const next = {
+            ...grant,
+            agentTools: {
+                on: true,
+                name: registered.name,
+                agents: [...tools.agents, ...registered.agents],
+            },
+        };
+        await deps.grants.save(next);
+        latest.set(grant.appOrigin, next);
+        await writeSkills(next);
+    };
+    let checking;
+    let checkAgain = false;
+    /**
+     * Looks for the agents again because a tab asked: one installed since this computer
+     * started shows in every app's sidebar, and gets the apps the user let its agents use.
+     */
+    const checkAgents = () => {
+        if (checking) {
+            checkAgain = true;
+            return checking;
+        }
+        checking = (async () => {
+            do {
+                checkAgain = false;
+                await rereadAgentPath();
+                const found = await findAgents(listedProfiles);
+                profiles = found.profiles;
+                agents = [...found.agents];
+                for (const grant of await deps.grants.list()) {
+                    await handToNewAgents(grant.appOrigin).catch((error) => logEvent("agent_tools_failed", {
+                        appOrigin: grant.appOrigin,
+                        error: String(error),
+                    }));
+                }
+                await Promise.all([...links.values()].map((state) => report(state, true).catch(() => undefined)));
+                logEvent("agents_checked", { agents: agents.map((agent) => agent.id) });
+            } while (checkAgain);
+        })().finally(() => {
+            checking = undefined;
+        });
+        return checking;
+    };
+    const removeAgentTools = (grant) => serially(async () => {
         const tools = grant?.agentTools;
         if (!tools?.name || !tools.agents?.length)
             return;
         await unregisterAgentTools(toolsDeps(), { name: tools.name, agents: tools.agents });
-    };
+        await removeAgentSkills(tools.agents, tools.name, await agentEnvironment());
+    });
     const agentTokens = new Map();
     /** The grant as last saved, which a link opened before a change still holds the old copy of. */
     const latest = new Map();
@@ -256,6 +406,7 @@ export function createHostDaemon(deps) {
         await deps.pool.forget(grant);
     };
     const open = (grant, keys) => {
+        void surveyAgents().catch(() => undefined);
         const origin = grant.appOrigin;
         latest.set(origin, grant);
         let state;
@@ -266,6 +417,14 @@ export function createHostDaemon(deps) {
             platform,
             fetch: (input, init) => fetch(input, init),
             onWake: () => wake(state),
+            onAgentsCheck: () => void checkAgents(),
+            onPushed: (_link, turn) => {
+                // Tells the app this computer has the turn, while it already starts on it.
+                void link.api.calls
+                    .call("hostAppend", { turnId: turn.turnId, items: [] })
+                    .catch(() => undefined);
+                run(state, turn, "pushed");
+            },
             busy: () => state.turns > 0,
             onRevoked: () => {
                 if (links.get(origin) !== state)
@@ -320,11 +479,13 @@ export function createHostDaemon(deps) {
             ? { ...agent, outsideName: tools.name }
             : agent);
     };
-    const report = async (state) => {
+    /** `agentsChecked` when the agents were just looked for, which a tab waiting on a check reads. */
+    const report = async (state, agentsChecked = false) => {
         const reported = state.link.api.calls.call("hostReport", {
             online: true,
             agents: describeFor(state.link.grant.appOrigin),
             ...(await pinnedDevices(state)),
+            ...(agentsChecked ? { agentsChecked: true } : {}),
         });
         const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("The app did not answer in time.")), CONNECT_TIMEOUT_MS));
         try {
@@ -352,7 +513,7 @@ export function createHostDaemon(deps) {
     const attach = async (origin, hostToken) => {
         await closeLink(origin, "replaced");
         devTokens.set(origin, hostToken);
-        await report(open(await devGrant(origin), devHostKeys(hostToken)));
+        await report(open(await devGrant(origin), devHostKeys(hostToken)), true);
     };
     const reattach = async (grant) => {
         await closeLink(grant.appOrigin, "dev_server_restarted");
@@ -407,8 +568,10 @@ export function createHostDaemon(deps) {
                 openHostLog(join(paths.root, "logs", "daemon.log"));
                 await putHostCommandFirstOnPath(paths.root);
                 await deps.proxy.listen(paths.proxy);
-                profiles = await loadProfiles(paths.agents);
-                agents = await detectAgents(profiles);
+                listedProfiles = await loadProfiles(paths.agents);
+                const found = await findAgents(listedProfiles);
+                profiles = found.profiles;
+                agents = [...found.agents];
                 await learned.load();
                 finishStartup();
             }
@@ -423,7 +586,8 @@ export function createHostDaemon(deps) {
             for (const grant of await deps.grants.list()) {
                 if (grant.declined)
                     continue;
-                void report(open(grant, deps.keys)).catch((error) => logEvent("link_failed", { appOrigin: grant.appOrigin, error: String(error) }));
+                void handToNewAgents(grant.appOrigin).catch(() => undefined);
+                void report(open(grant, deps.keys), true).catch((error) => logEvent("link_failed", { appOrigin: grant.appOrigin, error: String(error) }));
             }
         },
         async connect(appOrigin) {
@@ -435,14 +599,14 @@ export function createHostDaemon(deps) {
             const current = links.get(appOrigin);
             if (current?.link.grant.grantId === grant.grantId) {
                 latest.set(appOrigin, grant);
-                await report(current);
+                await report(current, true);
                 return toolsOf(grant);
             }
             await closeLink(appOrigin, "replaced");
             if (current)
                 await deps.pool.forget(current.link.grant);
             latest.set(appOrigin, grant);
-            await report(open(grant, deps.keys));
+            await report(open(grant, deps.keys), true);
             return toolsOf(grant);
         },
         async agentTools(appOrigin, on) {
@@ -485,6 +649,7 @@ export function createHostDaemon(deps) {
             if (handedOver)
                 return;
             handedOver = true;
+            stopping.abort();
             for (const state of links.values())
                 state.link.drain();
             await Promise.all([...links.values()].map((state) => state.claiming));
@@ -495,6 +660,7 @@ export function createHostDaemon(deps) {
             logEvent("handover_started", { version: deps.release.version });
         },
         async stop() {
+            stopping.abort();
             if (!handedOver) {
                 await Promise.all([...links.values()].map((state) => Promise.race([
                     state.link.api.calls.call("hostReport", {