@corenel/harness 0.17.0 → 0.19.0

package/dist/sidecar/host.js

@@ -1,6 +1,18 @@
 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, isClerkOrgId, } from '@corenel/protocol';
+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, 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). */
+const MALFORMED_REPLY = 'the daemon sent a reply this app cannot read';
+/** A workflow request the daemon has not answered by now never will be on
+ * this connection (a lost reply): it settles not ok, so the caller (the
+ * copy-home pass, say) is freed rather than held until the connection drops
+ * (M8). A package put carries up to 8 MiB, so it waits longer, sized for a
+ * slow link. */
+export const WORKFLOW_REQUEST_TIMEOUT_MS = 60000;
+export const WORKFLOW_PUT_TIMEOUT_MS = 120000;
+const NO_ANSWER = 'the sidecar did not answer in time';
 /** Decode a base64 chunk to bytes (atob is available in the browser and Node 18+). */
 function b64ToBytes(b64) {
     const bin = atob(b64);
@@ -236,6 +248,20 @@ export class SidecarHost {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "workflowsSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** One pending map for the five workflow-* requests; each method checks it
+         * got its own reply type, then checks and rebuilds the reply itself. */
+        Object.defineProperty(this, "workflowsPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "accessSeq", {
             enumerable: true,
             configurable: true,
@@ -798,7 +824,9 @@ export class SidecarHost {
             const proven = this.verifiedSidecarJkt !== null && this.provenSidecarId !== null && m.sidecarId === this.provenSidecarId;
             const jkt = proven ? this.opts.deviceKey?.jkt : undefined;
             const orgId = isClerkOrgId(m.orgId) ? m.orgId : undefined;
-            assertion = jkt ? (await this.opts.onIdentityChallenge?.({ nonce: m.nonce, sidecarId: m.sidecarId, jkt, ...(orgId ? { orgId } : {}) })) ?? null : null;
+            // The daemon's trusted issuer, for explaining a refusal only; bounded.
+            const issuer = typeof m.issuer === 'string' && m.issuer.length <= 512 ? m.issuer : undefined;
+            assertion = jkt ? (await this.opts.onIdentityChallenge?.({ nonce: m.nonce, sidecarId: m.sidecarId, jkt, ...(orgId ? { orgId } : {}), ...(issuer ? { issuer } : {}) })) ?? null : null;
         }
         catch {
             assertion = null;
@@ -867,6 +895,9 @@ export class SidecarHost {
         for (const p of this.crewDeployPending.values())
             p.reject(new Error(reason));
         this.crewDeployPending.clear();
+        for (const p of this.workflowsPending.values())
+            p.reject(new Error(reason));
+        this.workflowsPending.clear();
         for (const p of this.accessPending.values())
             p.reject(new Error(reason));
         this.accessPending.clear();
@@ -1502,6 +1533,18 @@ export class SidecarHost {
                 p.resolve(m.reply);
                 return;
             }
+            case 'workflow-package-result':
+            case 'workflow-results-list-result':
+            case 'workflow-results-take-result':
+            case 'workflow-results-ack-result':
+            case 'workflow-stop-result': {
+                const p = this.workflowsPending.get(m.id);
+                if (!p)
+                    return;
+                this.workflowsPending.delete(m.id);
+                p.resolve(m);
+                return;
+            }
             case 'member-result': {
                 const p = this.memberReplies.get(m.id);
                 if (!p)
@@ -1515,6 +1558,7 @@ export class SidecarHost {
                         ...(m.adminLabel !== undefined ? { adminLabel: m.adminLabel } : {}),
                         ...(m.adminId !== undefined ? { adminId: m.adminId } : {}),
                         ...(m.admin !== undefined ? { admin: m.admin } : {}),
+                        ...(m.noAdmin === true ? { noAdmin: true } : {}),
                         ...(m.members ? { members: m.members } : {}),
                     }
                     : { ok: false, code: m.code, error: m.error });
@@ -2375,12 +2419,101 @@ export class SidecarHost {
     }
     /** The machine's deploy list, statuses and audit. */
     crewDeployments() { return this.crewDeployRequest((id) => ({ t: 'crew-deployments', id })); }
-    crewDeploy(ref, reason) { return this.crewDeployRequest((id) => ({ t: 'crew-deploy', id, ref, ...(reason ? { reason } : {}) })); }
+    /** Deploy an agent or a workflow. `workspaceId`: where a deployed
+     * WORKFLOW's results go (the daemon refuses it on an agent). */
+    crewDeploy(ref, reason, workspaceId) {
+        return this.crewDeployRequest((id) => ({ t: 'crew-deploy', id, ref, ...(reason ? { reason } : {}), ...(workspaceId ? { workspaceId } : {}) }));
+    }
     crewUndeploy(ref, reason) { return this.crewDeployRequest((id) => ({ t: 'crew-undeploy', id, ref, ...(reason ? { reason } : {}) })); }
     crewPause(ref, reason) { return this.crewDeployRequest((id) => ({ t: 'crew-pause', id, ref, reason })); }
     crewResume(ref, reason) { return this.crewDeployRequest((id) => ({ t: 'crew-resume', id, ref, ...(reason ? { reason } : {}) })); }
     /** Stop a run AND record who stopped it and why (the plain `cancelRun` records nothing). */
     crewStop(ref, runId, reason) { return this.crewDeployRequest((id) => ({ t: 'crew-stop', id, ref, runId, reason })); }
+    /** True when the connected daemon runs deployed workflows (package intake,
+     * the results outbox, and `workflow-stop`). Feature-detected from the welcome. */
+    supportsWorkflows() { return this.features.includes(WORKFLOW_RUNNER_FEATURE); }
+    /** One workflow-* request. A refusal resolves; only a dropped connection
+     * rejects. Callers check the feature first, so nothing is sent to a daemon
+     * without it. */
+    /** One workflow-* request: its reply, or null when the daemon did not
+     * answer within `timeoutMs` (the request is then forgotten, so a late reply
+     * is dropped). Only a dropped connection rejects. */
+    workflowsRequest(build, timeoutMs = WORKFLOW_REQUEST_TIMEOUT_MS) {
+        const id = ++this.workflowsSeq;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (!this.workflowsPending.delete(id))
+                    return;
+                resolve(null);
+            }, timeoutMs);
+            this.workflowsPending.set(id, {
+                resolve: (m) => { clearTimeout(timer); resolve(m); },
+                reject: (e) => { clearTimeout(timer); reject(e); },
+            });
+            this.ch.send(build(id));
+        });
+    }
+    /** Send one packaged workflow (`.pdpkg`, base64) to the daemon. */
+    async workflowPackagePut(req) {
+        if (!this.supportsWorkflows())
+            return { ok: false, error: NO_WORKFLOWS };
+        const m = await this.workflowsRequest((id) => ({
+            t: 'workflow-package-put', id, packageId: req.packageId, workspaceId: req.workspaceId, sha256: req.sha256, pkg: req.pkg,
+        }), WORKFLOW_PUT_TIMEOUT_MS);
+        if (!m)
+            return { ok: false, error: NO_ANSWER };
+        if (m.t !== 'workflow-package-result')
+            return { ok: false, error: WRONG_REPLY };
+        return readWorkflowOkReply(m.reply) ?? { ok: false, error: MALFORMED_REPLY };
+    }
+    /** The results waiting for `workspaceId` in this connection's outbox. Every
+     * item is checked to be one of that workspace's own results. */
+    async workflowResultsList(workspaceId) {
+        if (!this.supportsWorkflows())
+            return { ok: false, error: NO_WORKFLOWS };
+        const m = await this.workflowsRequest((id) => ({ t: 'workflow-results-list', id, workspaceId }));
+        if (!m)
+            return { ok: false, error: NO_ANSWER };
+        if (m.t !== 'workflow-results-list-result')
+            return { ok: false, error: WRONG_REPLY };
+        return readWorkflowResultsListReply(m.reply, workspaceId) ?? { ok: false, error: MALFORMED_REPLY };
+    }
+    /** One waiting result's text. Nothing is deleted until `workflowResultsAck`. */
+    async workflowResultsTake(path) {
+        if (!this.supportsWorkflows())
+            return { ok: false, error: NO_WORKFLOWS };
+        const m = await this.workflowsRequest((id) => ({ t: 'workflow-results-take', id, path }));
+        if (!m)
+            return { ok: false, error: NO_ANSWER };
+        if (m.t !== 'workflow-results-take-result')
+            return { ok: false, error: WRONG_REPLY };
+        return readWorkflowResultsTakeReply(m.reply) ?? { ok: false, error: MALFORMED_REPLY };
+    }
+    /** The result at `path` is safely home: the daemon deletes it. */
+    async workflowResultsAck(path) {
+        if (!this.supportsWorkflows())
+            return { ok: false, error: NO_WORKFLOWS };
+        const m = await this.workflowsRequest((id) => ({ t: 'workflow-results-ack', id, path }));
+        if (!m)
+            return { ok: false, error: NO_ANSWER };
+        if (m.t !== 'workflow-results-ack-result')
+            return { ok: false, error: WRONG_REPLY };
+        return readWorkflowOkReply(m.reply) ?? { ok: false, error: MALFORMED_REPLY };
+    }
+    /** Stop a running deployed workflow: every live run of `ref`, or only
+     * `runId`. The daemon records who stopped it and why. */
+    async workflowStop(ref, reason, workspaceId, runId) {
+        if (!this.supportsWorkflows())
+            return { ok: false, error: NO_WORKFLOWS };
+        const m = await this.workflowsRequest((id) => ({
+            t: 'workflow-stop', id, ref, reason, ...(workspaceId ? { workspaceId } : {}), ...(runId ? { runId } : {}),
+        }));
+        if (!m)
+            return { ok: false, error: NO_ANSWER };
+        if (m.t !== 'workflow-stop-result')
+            return { ok: false, error: WRONG_REPLY };
+        return readWorkflowOkReply(m.reply) ?? { ok: false, error: MALFORMED_REPLY };
+    }
     /** True when the connected daemon keeps per-agent access (team mode, Part B). */
     supportsAgentAccess() { return this.features.includes(AGENT_ACCESS_FEATURE); }
     /** One access-* request. `ok: false` is the daemon's considered answer and