@corenel/harness 0.22.0 → 0.23.0

package/dist/sidecar/host.js

@@ -1,7 +1,7 @@
-import { CHAT_FEATURE, CHAT_ID_RE, FS_CHANGED_FEATURE } from '@corenel/protocol';
+import { CHAT_FEATURE, CHAT_ID_RE, FS_CHANGED_FEATURE, MCP_ALLOW_FEATURE } from '@corenel/protocol';
 import { asEcPublicJwk, jwkThumbprint, verifySignature, randomToken, serverProofPayload, clientProofPayload, parseEnrollmentCode, bytesToB64url, codeProof, codeHash, } from './deviceKeys.js';
 import { capabilityMissingMessage } from './hostCapability.js';
-import { SIDECAR_PROTOCOL, HOST_METHODS, errMessage, RUN_TASK_FEATURE, RUN_PLAN_FEATURE, CREW_DEPLOY_FEATURE, DEVICES_FEATURE, AGENT_ACCESS_FEATURE, AGENT_RUNS_FEATURE, PEER_LINKS_FEATURE, CHILD_EVENTS_FEATURE, PEER_DAEMON_FEATURE, TEAM_MEMBERS_FEATURE, SPEECH_FEATURE, encodePcm16, FLEET_LOGINS_DENIED, SIGN_IN_PAUSED_DENIED, isClerkOrgId, WORKFLOW_RUNNER_FEATURE, readWorkflowOkReply, readWorkflowResultsListReply, readWorkflowResultsTakeReply, } from '@corenel/protocol';
+import { SIDECAR_PROTOCOL, HOST_METHODS, errMessage, ATTENDANCE_LEAVE_FEATURE, RUN_TASK_FEATURE, RUN_PLAN_FEATURE, CREW_DEPLOY_FEATURE, FLEET_ITEMS_FEATURE, FLEET_USE_FEATURE, DEVICES_FEATURE, AGENT_ACCESS_FEATURE, AGENT_RUNS_FEATURE, PEER_LINKS_FEATURE, CHILD_EVENTS_FEATURE, PEER_DAEMON_FEATURE, TEAM_MEMBERS_FEATURE, SPEECH_FEATURE, encodePcm16, FLEET_LOGINS_DENIED, SIGN_IN_PAUSED_DENIED, isClerkOrgId, WORKFLOW_RUNNER_FEATURE, readWorkflowOkReply, readWorkflowResultsListReply, readWorkflowResultsTakeReply, } from '@corenel/protocol';
 const NO_WORKFLOWS = 'this daemon does not run workflows';
 const WRONG_REPLY = 'the daemon answered with the wrong reply';
 /** A reply that failed its check (protocol workflowWire.ts readers). */
@@ -13,6 +13,11 @@ const MALFORMED_REPLY = 'the daemon sent a reply this app cannot read';
  * slow link. */
 export const WORKFLOW_REQUEST_TIMEOUT_MS = 60000;
 export const WORKFLOW_PUT_TIMEOUT_MS = 120000;
+/** After a fleet workflow call is stopped, how long the host waits for the sidecar's answer before it settles the
+ * call itself (a lost reply, a hung daemon, a cancel that did not land): Stop never hangs. Shorter than
+ * WORKFLOW_REQUEST_TIMEOUT_MS because a person is waiting on Stop. A late answer is dropped. */
+export const FLEET_CALL_STOP_GRACE_MS = 15000;
+export const FLEET_CALL_STOPPED = 'The fleet workflow call was stopped.';
 const NO_ANSWER = 'the sidecar did not answer in time';
 /** The longest root or path an `fs-changed` may name; a real one is far shorter. */
 const MAX_FS_CHANGE_LEN = 4096;
@@ -306,6 +311,43 @@ export class SidecarHost {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "fleetItemsSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "fleetItemsPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** One id sequence for the three fleet-use requests; each has its own reply map. */
+        Object.defineProperty(this, "fleetUseSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "fleetSkillCatalogPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "fleetWorkflowCatalogPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "fleetWorkflowCallPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "crewDeploySeq", {
             enumerable: true,
             configurable: true,
@@ -985,6 +1027,18 @@ export class SidecarHost {
         for (const p of this.crewDeployPending.values())
             p.reject(new Error(reason));
         this.crewDeployPending.clear();
+        for (const p of this.fleetItemsPending.values())
+            p.reject(new Error(reason));
+        this.fleetItemsPending.clear();
+        for (const p of this.fleetSkillCatalogPending.values())
+            p.reject(new Error(reason));
+        this.fleetSkillCatalogPending.clear();
+        for (const p of this.fleetWorkflowCatalogPending.values())
+            p.reject(new Error(reason));
+        this.fleetWorkflowCatalogPending.clear();
+        for (const p of this.fleetWorkflowCallPending.values())
+            p.reject(new Error(reason));
+        this.fleetWorkflowCallPending.clear();
         for (const p of this.workflowsPending.values())
             p.reject(new Error(reason));
         this.workflowsPending.clear();
@@ -1562,7 +1616,11 @@ export class SidecarHost {
                 if (!p)
                     return;
                 this.mcpAdminPending.delete(m.id);
-                p.resolve({ ok: true });
+                p.resolve({
+                    ok: true,
+                    ...(typeof m.reloadError === 'string' ? { reloadError: m.reloadError } : {}),
+                    ...(Array.isArray(m.servers) ? { servers: m.servers } : {}),
+                });
                 return;
             }
             case 'mcp-admin-error': {
@@ -1575,7 +1633,11 @@ export class SidecarHost {
                 this.mcpAdminPending.delete(m.id);
                 // `reason` carried through so a caller can tell an ordinary refusal
                 // ("this server wants a pasted token") from a real failure.
-                p.resolve(m.reason ? { ok: false, error: m.error, reason: m.reason } : { ok: false, error: m.error });
+                p.resolve({
+                    ok: false, error: m.error,
+                    ...(m.reason ? { reason: m.reason } : {}),
+                    ...(m.code ? { code: m.code } : {}),
+                });
                 return;
             }
             /* A progress push, not a reply: the request stays pending. Delivered to
@@ -1702,6 +1764,38 @@ export class SidecarHost {
                 p.resolve(m.reply);
                 return;
             }
+            case 'fleet-items-result': {
+                const p = this.fleetItemsPending.get(m.id);
+                if (!p)
+                    return;
+                this.fleetItemsPending.delete(m.id);
+                p.resolve(m.reply);
+                return;
+            }
+            case 'fleet-skill-catalog-result': {
+                const p = this.fleetSkillCatalogPending.get(m.id);
+                if (!p)
+                    return;
+                this.fleetSkillCatalogPending.delete(m.id);
+                p.resolve(m.reply);
+                return;
+            }
+            case 'fleet-workflow-catalog-result': {
+                const p = this.fleetWorkflowCatalogPending.get(m.id);
+                if (!p)
+                    return;
+                this.fleetWorkflowCatalogPending.delete(m.id);
+                p.resolve(m.reply);
+                return;
+            }
+            case 'fleet-workflow-call-result': {
+                const p = this.fleetWorkflowCallPending.get(m.id);
+                if (!p)
+                    return;
+                this.fleetWorkflowCallPending.delete(m.id);
+                p.resolve(m.reply);
+                return;
+            }
             case 'workflow-package-result':
             case 'workflow-results-list-result':
             case 'workflow-results-take-result':
@@ -2421,6 +2515,16 @@ export class SidecarHost {
     answerPermission(id, decision, note) {
         this.ch.send({ t: 'permission-answer', id, decision, ...(note ? { note } : {}) });
     }
+    /** Stop attending on this connection while it stays open for this client's
+     * own calls: the daemon sends it no more permission asks, and an ask nobody
+     * else attends gets its unattended policy at once. Sent only to a daemon
+     * that advertises it (an older one would drop it unread); false when not. */
+    leaveAttendance() {
+        if (!this.features.includes(ATTENDANCE_LEAVE_FEATURE))
+            return false;
+        this.ch.send({ t: 'attendance-leave' });
+        return true;
+    }
     /** Push one definition file's content to the daemon, to be persisted under
      * this client's own `<stateDir>/hosts/<dirName>/` (Slice 2 host sync).
      * Resolves on `host-sync-result { ok: true }`; rejects with the daemon's
@@ -2584,8 +2688,8 @@ export class SidecarHost {
     /** The MCP servers configured on this machine, with credential PRESENCE.
      * There is no read path for a credential value anywhere in this feature. */
     mcpServers() { return this.sendMcpAdmin({ t: 'mcp-servers-list' }); }
-    /** Add a server to this machine's daemon.json. Takes effect on daemon
-     * restart -- the config plane cannot reach into a running daemon. */
+    /** Add a server to this machine's daemon.json. Resolves after the daemon
+     * applied it (`reloadError` when it could not yet). */
     mcpAddServer(name, url, hosted = false, authUrl) {
         /* Each field sent only when it has a value, so the message an older daemon
          * receives is byte-identical to what it received before these existed. */
@@ -2622,6 +2726,18 @@ export class SidecarHost {
     mcpSetCredential(name, header, value) {
         return this.sendMcpAdmin({ t: 'mcp-set-credential', name, header, value });
     }
+    /** Whether this daemon takes `mcpSetAllow`. */
+    supportsMcpAllow() { return this.features.includes(MCP_ALLOW_FEATURE); }
+    /** Switch which of server `name`'s tools this machine's `mcpAllow` grants:
+     * exactly `tools`, replacing that server's entries. Empty turns them all
+     * off. Resolves after the daemon applied it. Refused here, sending nothing,
+     * against a daemon without the feature: an older one would never answer. */
+    mcpSetAllow(name, tools) {
+        if (!this.supportsMcpAllow()) {
+            return Promise.resolve({ ok: false, error: 'this daemon cannot switch MCP tools -- update it and reconnect' });
+        }
+        return this.sendMcpAdmin({ t: 'mcp-allow-set', name, tools });
+    }
     sendMcpAdmin(body) {
         const id = ++this.mcpSeq;
         return new Promise((resolve, reject) => {
@@ -2687,6 +2803,78 @@ export class SidecarHost {
             this.ch.send(send(id));
         });
     }
+    /** True when the connected sidecar lists its fleet items. */
+    supportsFleetItems() { return this.features.includes(FLEET_ITEMS_FEATURE); }
+    /** The fleet agents, skills and workflows installed on the connected
+     * sidecar. `ok: false` is its considered answer and resolves; only a dropped
+     * connection rejects. Against a sidecar without the feature nothing is sent. */
+    fleetItems() {
+        if (!this.supportsFleetItems())
+            return Promise.resolve({ ok: false, error: 'this sidecar does not list fleet items' });
+        const id = ++this.fleetItemsSeq;
+        return new Promise((resolve, reject) => {
+            this.fleetItemsPending.set(id, { resolve, reject });
+            this.ch.send({ t: 'fleet-items', id });
+        });
+    }
+    /** True when the connected sidecar offers its fleet skills and workflows for use. */
+    supportsFleetUse() { return this.features.includes(FLEET_USE_FEATURE); }
+    /** The fleet skills the connected sidecar offers now. `ok: false` is its considered answer and resolves; only
+     * a dropped connection rejects. Against a sidecar without the feature nothing is sent. */
+    fleetSkillCatalog() {
+        if (!this.supportsFleetUse())
+            return Promise.resolve({ ok: false, error: 'this sidecar does not offer fleet items' });
+        const id = ++this.fleetUseSeq;
+        return new Promise((resolve, reject) => {
+            this.fleetSkillCatalogPending.set(id, { resolve, reject });
+            this.ch.send({ t: 'fleet-skill-catalog', id });
+        });
+    }
+    /** The fleet workflows the connected sidecar can run now. Same contract as fleetSkillCatalog. */
+    fleetWorkflowCatalog() {
+        if (!this.supportsFleetUse())
+            return Promise.resolve({ ok: false, error: 'this sidecar does not offer fleet items' });
+        const id = ++this.fleetUseSeq;
+        return new Promise((resolve, reject) => {
+            this.fleetWorkflowCatalogPending.set(id, { resolve, reject });
+            this.ch.send({ t: 'fleet-workflow-catalog', id });
+        });
+    }
+    /** Run one fleet workflow on the connected sidecar and wait for its final text. Aborting `signal` sends
+     * `fleet-workflow-cancel` and waits up to FLEET_CALL_STOP_GRACE_MS for the sidecar's answer (the run settles as
+     * stopped); with none by then the call is forgotten (a late answer is dropped) and resolves FLEET_CALL_STOPPED.
+     * An already-aborted signal sends nothing. `ok: false` resolves; only a dropped connection rejects. */
+    callFleetWorkflow(name, inputs, signal) {
+        if (!this.supportsFleetUse())
+            return Promise.resolve({ ok: false, error: 'this sidecar does not offer fleet items' });
+        if (signal.aborted)
+            return Promise.resolve({ ok: false, error: FLEET_CALL_STOPPED });
+        const id = ++this.fleetUseSeq;
+        return new Promise((resolve, reject) => {
+            let timer;
+            const onAbort = () => {
+                if (!this.fleetWorkflowCallPending.has(id))
+                    return;
+                this.ch.send({ t: 'fleet-workflow-cancel', id });
+                timer = setTimeout(() => {
+                    if (!this.fleetWorkflowCallPending.delete(id))
+                        return;
+                    resolve({ ok: false, error: FLEET_CALL_STOPPED });
+                }, FLEET_CALL_STOP_GRACE_MS);
+            };
+            const settle = () => {
+                signal.removeEventListener('abort', onAbort);
+                if (timer !== undefined)
+                    clearTimeout(timer);
+            };
+            this.fleetWorkflowCallPending.set(id, {
+                resolve: (r) => { settle(); resolve(r); },
+                reject: (e) => { settle(); reject(e); },
+            });
+            signal.addEventListener('abort', onAbort, { once: true });
+            this.ch.send({ t: 'fleet-workflow-call', id, name, inputs });
+        });
+    }
     /** The machine's deploy list, statuses and audit. */
     crewDeployments() { return this.crewDeployRequest((id) => ({ t: 'crew-deployments', id })); }
     /** Deploy an agent or a workflow. `workspaceId`: where a deployed