@parlor/agent-host 0.2.0 → 0.3.1

package/dist/daemon.js

@@ -3,10 +3,13 @@ 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 { readUsage, surveyOptions } from "./agent-survey.js";
+import { agentNames, registerAgentTools, unregisterAgentTools, } from "./agent-tools.js";
 import { detectAgents, loadProfiles } from "./agents.js";
 import { connectControl } from "./control.js";
 import { requestDevHostToken } from "./dev-host.js";
 import { devHostKeys } from "./grants.js";
+import { learnedStore } from "./learned.js";
 import { onLines } from "./lines.js";
 import { createAppLink } from "./link.js";
 import { withInheritedLock } from "./lock.js";
@@ -19,8 +22,11 @@ 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 { runTurn } from "./turn.js";
 const CONNECT_TIMEOUT_MS = 15_000;
+/** An agent token is asked for again this long before it runs out. */
+const AGENT_TOKEN_MARGIN_MS = 60_000;
 const OFFLINE_REPORT_MS = 1_000;
 function incompatibleMessage(grant, welcome) {
     return welcome.reason === "host_too_old"
@@ -58,6 +64,8 @@ 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();
@@ -66,6 +74,7 @@ export function createHostDaemon(deps) {
     const platform = platformName();
     let profiles = [];
     let agents = [];
+    const learned = learnedStore(paths.learned);
     let control;
     let startup = Promise.resolve();
     const clients = new Set();
@@ -83,14 +92,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, {
@@ -113,6 +183,7 @@ export function createHostDaemon(deps) {
             policy,
             prompter: deps.prompter,
             now: Date.now,
+            learned: learn,
             pairing: {
                 secret: async () => (await deps.grants.get(link.grant.appOrigin))?.pairingSecret,
                 forget: async () => {
@@ -126,6 +197,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();
@@ -159,7 +232,79 @@ export function createHostDaemon(deps) {
         if (state)
             logEvent("link_closed", { appOrigin: origin, reason });
     };
+    const toolsDeps = () => ({
+        profiles: profiles.filter((profile) => agents.some((agent) => agent.id === profile.id)),
+        hostCommand: join(paths.root, "bin", "parlor-host"),
+        env: agentEnvironment,
+    });
+    const toolsOf = (grant) => {
+        const tools = grant?.agentTools;
+        if (!tools?.on || !tools.name || !tools.agents?.length)
+            return undefined;
+        return {
+            name: tools.name,
+            agents: agentNames(profiles, { name: tools.name, agents: tools.agents }),
+        };
+    };
+    /** 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)
+            return grant;
+        const registered = await registerAgentTools(toolsDeps(), grant);
+        const next = { ...grant, agentTools: { on: true, ...registered } };
+        await deps.grants.save(next);
+        return next;
+    };
+    const removeAgentTools = async (grant) => {
+        const tools = grant?.agentTools;
+        if (!tools?.name || !tools.agents?.length)
+            return;
+        await unregisterAgentTools(toolsDeps(), { name: tools.name, agents: tools.agents });
+    };
+    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();
+    deps.proxy.serveOutside((appOrigin) => {
+        const state = links.get(appOrigin);
+        if (!state || state.link.grant.dev)
+            return undefined;
+        const grant = latest.get(appOrigin) ?? state.link.grant;
+        if (!grant.agentTools?.on || !grant.agentTools.name)
+            return undefined;
+        return {
+            appOrigin,
+            appName: grant.appName,
+            name: grant.agentTools.name,
+            account: grant.account.email ?? grant.account.name,
+            token: async (agent) => {
+                const key = `${grant.grantId}\n${agent}`;
+                const held = agentTokens.get(key);
+                if (held && held.expiresAt - AGENT_TOKEN_MARGIN_MS > Date.now())
+                    return held.token;
+                const fresh = await state.link.api.calls.call("hostAgentToken", {
+                    agent: `${agent} on ${name}`.slice(0, 120),
+                });
+                agentTokens.set(key, fresh);
+                return fresh.token;
+            },
+            askHere: async (question) => (await deps.prompter.answerHere({
+                appName: grant.appName,
+                agent: "Parlor Host",
+                question,
+                choices: [
+                    { id: "allow", label: "Allow" },
+                    { id: "deny", label: "Don't allow" },
+                ],
+            })) === "allow",
+        };
+    });
     const forget = async (grant) => {
+        await removeAgentTools((await deps.grants.get(grant.appOrigin)) ?? grant);
+        latest.delete(grant.appOrigin);
+        for (const key of agentTokens.keys()) {
+            if (key.startsWith(`${grant.grantId}\n`))
+                agentTokens.delete(key);
+        }
         devTokens.delete(grant.appOrigin);
         await deps.grants.remove(grant.appOrigin);
         await deps.keys.remove(grant.appOrigin);
@@ -167,7 +312,9 @@ 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;
         const link = createAppLink(grant, {
             keys,
@@ -176,14 +323,25 @@ export function createHostDaemon(deps) {
             platform,
             fetch: (input, init) => fetch(input, init),
             onWake: () => wake(state),
+            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)
                     return;
                 if (grant.dev)
                     void reattach(grant);
-                else
-                    void closeLink(origin, "revoked").then(() => forget(grant));
+                else {
+                    const removedFrom = toolsOf(latest.get(origin) ?? grant)?.agents;
+                    void closeLink(origin, "revoked")
+                        .then(() => forget(grant))
+                        .then(() => deps.prompter.disconnected?.({ appName: grant.appName, removedFrom }));
+                }
             },
             onIncompatible: (refused, welcome) => {
                 state.incompatible = incompatibleMessage(refused, welcome);
@@ -217,10 +375,19 @@ export function createHostDaemon(deps) {
         }
         return { devices: pinned.map((device) => device.deviceId), presenceDue };
     };
+    /** The agents with what they said about themselves, and the name they use the app by outside. */
+    const describeFor = (origin) => {
+        const tools = latest.get(origin)?.agentTools;
+        return learned
+            .describe(agents, Date.now())
+            .map((agent) => tools?.on && tools.name && tools.agents?.includes(agent.id)
+            ? { ...agent, outsideName: tools.name }
+            : agent);
+    };
     const report = async (state) => {
         const reported = state.link.api.calls.call("hostReport", {
             online: true,
-            agents,
+            agents: describeFor(state.link.grant.appOrigin),
             ...(await pinnedDevices(state)),
         });
         const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("The app did not answer in time.")), CONNECT_TIMEOUT_MS));
@@ -306,6 +473,7 @@ export function createHostDaemon(deps) {
                 await deps.proxy.listen(paths.proxy);
                 profiles = await loadProfiles(paths.agents);
                 agents = await detectAgents(profiles);
+                await learned.load();
                 finishStartup();
             }
             catch (error) {
@@ -323,25 +491,46 @@ export function createHostDaemon(deps) {
             }
         },
         async connect(appOrigin) {
-            const grant = await deps.grants.get(appOrigin);
-            if (!grant || grant.declined) {
+            const saved = await deps.grants.get(appOrigin);
+            if (!saved || saved.declined) {
                 throw new Error(`This computer is not connected to ${appOrigin}.`);
             }
+            const grant = await ensureAgentTools(saved);
             const current = links.get(appOrigin);
             if (current?.link.grant.grantId === grant.grantId) {
+                latest.set(appOrigin, grant);
                 await report(current);
-                return;
+                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));
+            return toolsOf(grant);
+        },
+        async agentTools(appOrigin, on) {
+            const saved = await deps.grants.get(appOrigin);
+            if (!saved || saved.declined || saved.dev) {
+                throw new Error(`This computer is not connected to ${appOrigin}.`);
+            }
+            if (!on)
+                await removeAgentTools(saved);
+            const grant = await ensureAgentTools({ ...saved, agentTools: { on } });
+            if (!on)
+                await deps.grants.save(grant);
+            latest.set(appOrigin, grant);
+            const state = links.get(appOrigin);
+            if (state)
+                await report(state).catch(() => undefined);
+            return toolsOf(grant);
         },
         async disconnect(appOrigin) {
             const state = links.get(appOrigin);
-            const grant = state?.link.grant ?? (await deps.grants.get(appOrigin));
+            const grant = (await deps.grants.get(appOrigin)) ?? state?.link.grant;
             if (!grant)
                 throw new Error(`This computer is not connected to ${appOrigin}.`);
+            const removed = toolsOf(grant);
             if (state) {
                 await state.link.stop({ revoke: true });
             }
@@ -354,11 +543,13 @@ export function createHostDaemon(deps) {
             }
             await closeLink(appOrigin, "disconnected");
             await forget(grant);
+            return removed;
         },
         async handover() {
             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));
@@ -369,9 +560,13 @@ 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", { online: false, agents }),
+                    state.link.api.calls.call("hostReport", {
+                        online: false,
+                        agents: describeFor(state.link.grant.appOrigin),
+                    }),
                     new Promise((resolve) => setTimeout(resolve, OFFLINE_REPORT_MS)),
                 ]).catch(() => undefined)));
             }
@@ -499,12 +694,18 @@ export function createHostDaemon(deps) {
             }
             case "confirm_local_pairing":
                 return confirmPairing(request);
-            case "connect":
-                await daemon.connect(request.appOrigin);
-                return { ok: true };
-            case "disconnect":
-                await daemon.disconnect(request.appOrigin);
-                return { ok: true };
+            case "connect": {
+                const agentTools = await daemon.connect(request.appOrigin);
+                return { ok: true, ...(agentTools ? { agentTools } : {}) };
+            }
+            case "disconnect": {
+                const agentTools = await daemon.disconnect(request.appOrigin);
+                return { ok: true, ...(agentTools ? { agentTools } : {}) };
+            }
+            case "agent_tools": {
+                const agentTools = await daemon.agentTools(request.appOrigin, request.on);
+                return { ok: true, ...(agentTools ? { agentTools } : {}) };
+            }
             case "dev_attach":
                 await attach(request.appOrigin, request.hostToken);
                 return { ok: true };