@corenel/harness 0.21.0 → 0.23.0

package/dist/sidecar/host.js

@@ -1,7 +1,7 @@
-import { CHAT_FEATURE, CHAT_ID_RE } 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,7 +13,23 @@ 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;
+/** An `fs-changed` message's change, or null when it is not one: a root and a
+ * path, each a non-empty string within MAX_FS_CHANGE_LEN with no NUL. */
+export function fsChangeOf(m) {
+    if (typeof m !== 'object' || m === null)
+        return null;
+    const { root, path } = m;
+    const ok = (v) => typeof v === 'string' && v.length > 0 && v.length <= MAX_FS_CHANGE_LEN && !v.includes('\u0000');
+    return ok(root) && ok(path) ? { root, path } : null;
+}
 /** Decode a base64 chunk to bytes (atob is available in the browser and Node 18+). */
 function b64ToBytes(b64) {
     const bin = atob(b64);
@@ -295,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,
@@ -542,6 +595,14 @@ export class SidecarHost {
             writable: true,
             value: []
         });
+        /** Who hears another client's file changes (`fs-changed`), for the life of
+         * this connection. */
+        Object.defineProperty(this, "fsChangeSubs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "sttSeq", {
             enumerable: true,
             configurable: true,
@@ -966,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();
@@ -1048,6 +1121,8 @@ export class SidecarHost {
         for (const s of this.sttStreams.values())
             s.onClosed(reason);
         this.sttStreams.clear();
+        // Nothing more arrives on this connection: its change listeners are let go.
+        this.fsChangeSubs.clear();
         this.ch.close();
     }
     onMessage(m) {
@@ -1136,6 +1211,24 @@ export class SidecarHost {
                 // Unsolicited: the set changed on the daemon (possibly via ANOTHER client).
                 this.opts.onRoots?.({ root: m.root, roots: m.roots });
                 return;
+            case 'fs-changed': {
+                /* Unsolicited, and JSON-parsed off the wire, so the declared strings
+                 * guarantee nothing. Heard only from a daemon that said it sends it,
+                 * and only in the shape it mints: a root and a path, each a short
+                 * non-empty string with no NUL. Anything else is dropped. */
+                if (!this.features.includes(FS_CHANGED_FEATURE))
+                    return;
+                const change = fsChangeOf(m);
+                if (!change)
+                    return;
+                for (const cb of [...this.fsChangeSubs]) {
+                    try {
+                        cb(change);
+                    }
+                    catch { /* one listener's failure must not stop the rest */ }
+                }
+                return;
+            }
             case 'roots-browse-result': {
                 const p = this.rootsPending.get(m.id);
                 if (!p)
@@ -1523,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': {
@@ -1536,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
@@ -1663,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':
@@ -2382,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
@@ -2475,6 +2618,16 @@ export class SidecarHost {
      * and every room-* message is refused server-side; feature-detecting here means
      * the browser never sends one it already knows will be refused. */
     supportsRooms() { return this.features.includes('rooms'); }
+    /** True when the sidecar announces other clients' file changes (`fs-changed`).
+     * An older one never does, and a listener here simply never fires. */
+    supportsFsChanged() { return this.features.includes(FS_CHANGED_FEATURE); }
+    /** Hear every file change another client of this daemon makes through its
+     * file tools: the root the tool used and the root-relative path. Never this
+     * client's own changes (the daemon leaves the writer out). */
+    onFsChanged(cb) {
+        this.fsChangeSubs.add(cb);
+        return () => { this.fsChangeSubs.delete(cb); };
+    }
     /** True when the connected daemon HOLDS agent pauses. Feature-detected from
      * the welcome, so a client offers "Pause" only where pausing would actually
      * stop the agent rather than reporting a success the daemon ignores. */
@@ -2535,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. */
@@ -2573,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) => {
@@ -2638,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