@corenel/harness 0.19.0 → 0.21.0

package/dist/sidecar/host.js

@@ -1,6 +1,7 @@
+import { CHAT_FEATURE, CHAT_ID_RE } 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, isClerkOrgId, WORKFLOW_RUNNER_FEATURE, readWorkflowOkReply, readWorkflowResultsListReply, readWorkflowResultsTakeReply, } 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, 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). */
@@ -69,6 +70,19 @@ export function isSidecarAccountRefusal(e) {
     const msg = e instanceof Error ? e.message : String(e);
     return msg.startsWith(SIDECAR_NOT_ADMITTED);
 }
+/** The sidecar refused this ACCOUNT because its fleet policy limits sign-in
+ * (slice 4). The device is fine and stays paired; retrying changes nothing
+ * until a fleet admin changes the policy. */
+export function isFleetLoginsRefusal(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return msg === `${SIDECAR_NOT_ADMITTED}: ${FLEET_LOGINS_DENIED}`;
+}
+/** The sidecar's fleet sign-in is paused for a reason that clears by itself (SIGN_IN_PAUSED_DENIED). The device is
+ * fine and stays paired, and unlike every other account refusal a retry is expected to succeed later. */
+export function isSignInPausedRefusal(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return msg === `${SIDECAR_NOT_ADMITTED}: ${SIGN_IN_PAUSED_DENIED}`;
+}
 export class SidecarHost {
     constructor(opts) {
         Object.defineProperty(this, "ch", {
@@ -131,6 +145,51 @@ export class SidecarHost {
             writable: true,
             value: new Map()
         });
+        /** Daemon chat (Harness Chat Plan 2): run-inject, chat-list and chat-get replies, by request id. */
+        Object.defineProperty(this, "chatSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "injectPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "chatListPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "chatGetPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** Chat ask_user prompts not yet answered or resolved, by the daemon's ask id,
+         * so a handler registered after one arrived still sees it. */
+        Object.defineProperty(this, "askUserOpen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "askUserHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "askUserResolvedHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "acpSeq", {
             enumerable: true,
             configurable: true,
@@ -854,6 +913,18 @@ export class SidecarHost {
         for (const p of this.cancelPending.values())
             p({ ok: false, reason: 'unsupported' });
         this.cancelPending.clear();
+        // Same reasoning for an inject: answered, not thrown, so a send during a drop settles.
+        for (const p of this.injectPending.values())
+            p({ ok: false, reason });
+        this.injectPending.clear();
+        for (const p of this.chatListPending.values())
+            p.reject(new Error(reason));
+        this.chatListPending.clear();
+        for (const p of this.chatGetPending.values())
+            p.reject(new Error(reason));
+        this.chatGetPending.clear();
+        // The daemon delivers any still-open ask again when the connection comes back.
+        this.askUserOpen.clear();
         for (const p of this.acpPending.values())
             p.reject(new Error(reason));
         this.acpPending.clear();
@@ -1152,10 +1223,14 @@ export class SidecarHost {
             }
             case 'run-accepted': {
                 const p = this.runPending.get(m.id);
-                if (p) {
-                    p.runId = m.runId;
+                if (!p)
+                    return;
+                p.runId = m.runId;
+                // Runtime-validated: a conversation id is only ever a chat id.
+                if (typeof m.conversationId === 'string' && CHAT_ID_RE.test(m.conversationId))
+                    p.onAccepted?.(m.runId, m.conversationId);
+                else
                     p.onAccepted?.(m.runId);
-                }
                 return;
             }
             case 'event': {
@@ -1171,7 +1246,10 @@ export class SidecarHost {
                 if (!p)
                     return;
                 this.runPending.delete(m.id);
-                p.resolve({ runId: m.runId, text: m.text, stopReason: m.stopReason });
+                p.resolve({
+                    runId: m.runId, text: m.text, stopReason: m.stopReason,
+                    ...(m.outcome === 'done' || m.outcome === 'stopped' ? { outcome: m.outcome } : {}),
+                });
                 return;
             }
             case 'run-error': {
@@ -1179,7 +1257,59 @@ export class SidecarHost {
                 if (!p)
                     return;
                 this.runPending.delete(m.id);
-                p.reject(new Error(m.error || 'run failed'));
+                if (p.fail)
+                    p.fail(m.error || 'run failed', m.outcome === 'failed' || m.outcome === 'refused' ? m.outcome : undefined);
+                else
+                    p.reject(new Error(m.error || 'run failed'));
+                return;
+            }
+            case 'run-inject-result': {
+                const p = this.injectPending.get(m.id);
+                if (!p)
+                    return;
+                this.injectPending.delete(m.id);
+                p(m.ok === true ? { ok: true } : { ok: false, ...(typeof m.reason === 'string' ? { reason: m.reason } : {}) });
+                return;
+            }
+            case 'chat-list-result': {
+                const p = this.chatListPending.get(m.id);
+                if (!p)
+                    return;
+                this.chatListPending.delete(m.id);
+                if (m.ok)
+                    p.resolve(Array.isArray(m.chats) ? m.chats : []);
+                else
+                    p.reject(new Error(m.error || 'could not list chats'));
+                return;
+            }
+            case 'chat-get-result': {
+                const p = this.chatGetPending.get(m.id);
+                if (!p)
+                    return;
+                this.chatGetPending.delete(m.id);
+                if (m.ok)
+                    p.resolve(m.conversation);
+                else
+                    p.reject(new Error(m.error || 'could not read the chat'));
+                return;
+            }
+            case 'ask-user': {
+                // Runtime-validated like the rest of what crosses the wire.
+                if (!Number.isSafeInteger(m.id) || typeof m.runId !== 'string' || typeof m.agent !== 'string'
+                    || !Array.isArray(m.questions) || typeof m.deadline !== 'number')
+                    return;
+                const ask = { id: m.id, runId: m.runId, agent: m.agent, questions: m.questions, deadline: m.deadline };
+                this.askUserOpen.set(ask.id, ask);
+                for (const h of [...this.askUserHandlers])
+                    h(ask);
+                return;
+            }
+            case 'ask-user-resolved': {
+                if (!this.askUserOpen.delete(m.id))
+                    return;
+                const by = m.by === 'client' ? 'client' : 'timeout';
+                for (const h of [...this.askUserResolvedHandlers])
+                    h({ id: m.id, by });
                 return;
             }
             case 'cancel-run-result': {
@@ -2096,6 +2226,97 @@ export class SidecarHost {
             this.ch.send({ t: 'cancel-run', id, runId });
         });
     }
+    /** True when the connected daemon holds chats (Harness Chat Plan 2):
+     * `runChat`, `injectRun`, `listChats`, `getChat` and ask_user prompts. An
+     * older daemon would run a chat turn as a plain one-shot run, so check this
+     * before calling any of them. */
+    supportsChat() { return this.features.includes(CHAT_FEATURE); }
+    /** One turn of a daemon chat. `chat.conversationId` absent starts a new
+     * chat; the daemon mints its id and hands it to `onAccepted` with the run
+     * id. Resolves with how the turn ended, a refused or failed one included
+     * (with `error`); rejects only when the connection drops mid-turn. */
+    runChat(agent, text, chat, onEvent, opts) {
+        const id = ++this.runSeq;
+        return new Promise((resolve, reject) => {
+            let runId = null;
+            let conversationId = chat.conversationId ?? null;
+            this.runPending.set(id, {
+                resolve: (r) => resolve({ runId: r.runId, conversationId, text: r.text, stopReason: r.stopReason, outcome: r.outcome ?? 'done' }),
+                reject,
+                fail: (error, outcome) => resolve({ runId, conversationId, text: '', stopReason: '', outcome: outcome ?? 'failed', error }),
+                onEvent,
+                onAccepted: (rid, cid) => {
+                    runId = rid;
+                    if (cid !== undefined)
+                        conversationId = cid;
+                    if (conversationId !== null)
+                        opts?.onAccepted?.(rid, conversationId);
+                },
+            });
+            this.ch.send({
+                t: 'run', id, agent, input: text,
+                chat: {
+                    ...(chat.conversationId !== undefined ? { conversationId: chat.conversationId } : {}),
+                    ...(chat.maxUsd !== undefined ? { maxUsd: chat.maxUsd } : {}),
+                    ...(chat.ref !== undefined ? { ref: chat.ref } : {}),
+                },
+            });
+        });
+    }
+    /** Messages typed while a chat turn runs; `hard` interrupts it. Never
+     * rejects: a refusal or a dropped connection answers `ok: false`. */
+    injectRun(runId, messages, hard) {
+        const id = ++this.chatSeq;
+        return new Promise((resolve) => {
+            this.injectPending.set(id, resolve);
+            this.ch.send({ t: 'run-inject', id, runId, messages, hard });
+        });
+    }
+    /** This user's chats with `agent`; the admin may name a `member`. Rejects
+     * with the daemon's refusal. */
+    listChats(agent, opts) {
+        const id = ++this.chatSeq;
+        return new Promise((resolve, reject) => {
+            this.chatListPending.set(id, { resolve, reject });
+            this.ch.send({
+                t: 'chat-list', id, agent,
+                ...(opts?.ref !== undefined ? { ref: opts.ref } : {}),
+                ...(opts?.member !== undefined ? { member: opts.member } : {}),
+            });
+        });
+    }
+    /** One conversation, to its member or the admin. Rejects with the daemon's
+     * refusal (CHAT_NOT_YOURS, CHAT_NOT_FOUND). */
+    getChat(agent, conversationId, opts) {
+        const id = ++this.chatSeq;
+        return new Promise((resolve, reject) => {
+            this.chatGetPending.set(id, { resolve, reject });
+            this.ch.send({
+                t: 'chat-get', id, agent, conversationId,
+                ...(opts?.ref !== undefined ? { ref: opts.ref } : {}),
+                ...(opts?.member !== undefined ? { member: opts.member } : {}),
+            });
+        });
+    }
+    /** Chat ask_user prompts for this user. Prompts still open when the handler
+     * is added are handed to it at once. Returns the unsubscribe function. */
+    onAskUser(handler) {
+        this.askUserHandlers.add(handler);
+        for (const ask of [...this.askUserOpen.values()])
+            handler(ask);
+        return () => { this.askUserHandlers.delete(handler); };
+    }
+    /** A prompt was answered on another connection, or timed out: drop it. */
+    onAskUserResolved(handler) {
+        this.askUserResolvedHandlers.add(handler);
+        return () => { this.askUserResolvedHandlers.delete(handler); };
+    }
+    /** Answer prompt `id`; null declines. The first answer from any of this
+     * user's or the admin's connections wins; a late one is ignored. */
+    answerAskUser(id, answers) {
+        this.askUserOpen.delete(id);
+        this.ch.send({ t: 'ask-user-answer', id, answers });
+    }
     /** True when the connected sidecar's runner supports cancelling a run. */
     supportsRunCancel() { return this.features.includes('run-cancel'); }
     /** True when the connected daemon fans a delegated callee's own node events