@corenel/harness 0.5.0 → 0.5.1

package/dist/sidecar/server.js

@@ -1,4 +1,9 @@
 import { SIDECAR_PROTOCOL, errMessage, isLoopbackHost, } from '@corenel/protocol';
+/** How long the welcome waits on `clientDirName` before going out without it. A
+ * manifest write is a few milliseconds; anything near this is a wedged disk, and
+ * a client left with no handshake at all is worse than one that has to fall back
+ * to deducing its own directory. */
+const DIR_NAME_TIMEOUT_MS = 3000;
 /** True for anything with a callable `.then` -- covers native Promises and any
  * other thenable a caller's `onClient` might return, without assuming it's a
  * real Promise instance (the declared type is `() => void`; an async function
@@ -91,6 +96,14 @@ export class SidecarServer {
             writable: true,
             value: void 0
         });
+        /** The friendly label from the same `hello`, kept beside `clientId` so the
+         * dirName resolver is handed the identity the manifest keys on. */
+        Object.defineProperty(this, "clientName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** Detach function for this connection's attendance attachment, set on a
          * successful `hello` when `opts.attendance` is wired. Called once, on channel
          * close, so a dead connection stops receiving/counting toward asks. */
@@ -100,6 +113,23 @@ export class SidecarServer {
             writable: true,
             value: void 0
         });
+        /** The synced directory THIS connection belongs to, once resolved -- the same
+         * value echoed in `welcome.dirName`. Retained so `hosts-list` can stamp
+         * `self` and `hosts-forget` can refuse the caller's own tree from the
+         * daemon's own knowledge rather than from anything the client claimed. */
+        Object.defineProperty(this, "dirName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Detach for this connection's entry in the shared hosts live set. */
+        Object.defineProperty(this, "hostsDetach", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** Detach callbacks for runs this connection is watching, so a dropped socket
          * stops the hub fanning out into a dead channel. */
         Object.defineProperty(this, "runDetachers", {
@@ -247,6 +277,10 @@ export class SidecarServer {
         this.ch.onClose?.(() => {
             this.attendedDetach?.();
             this.attendedDetach = undefined;
+            // Leave the live set, or this directory reads as connected for ever and
+            // could never be reclaimed -- the refusal would outlive the connection.
+            this.hostsDetach?.();
+            this.hostsDetach = undefined;
             // A dropped connection must stop receiving run events, or the hub keeps
             // fanning out into a dead channel for the rest of the run.
             for (const detach of this.runDetachers)
@@ -452,6 +486,40 @@ export class SidecarServer {
             case 'host-sync-delete':
                 void this.onHostSyncDelete(m);
                 return;
+            case 'agent-pause-list':
+                // `ok: false`, not an empty list: telling an unauthenticated caller
+                // "this daemon is holding no pauses" is a claim it has not earned, the
+                // same reasoning as room-list below.
+                if (!this.authed) {
+                    this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                this.onAgentPauseList(m);
+                return;
+            case 'agent-pause-set':
+                if (!this.authed) {
+                    this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onAgentPauseSet(m);
+                return;
+            case 'hosts-list':
+                // `ok: false`, not an empty estate: telling an unauthenticated caller
+                // "this daemon holds no synced hosts" is a claim it has not earned --
+                // the same reasoning as agent-pause-list above.
+                if (!this.authed) {
+                    this.ch.send({ t: 'hosts-list-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onHostsList(m);
+                return;
+            case 'hosts-forget':
+                if (!this.authed) {
+                    this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onHostsForget(m);
+                return;
             case 'room-open':
                 if (!this.authed) {
                     this.ch.send({ t: 'room-open-result', id: m.id, ok: false, problems: ['not authenticated'] });
@@ -492,6 +560,34 @@ export class SidecarServer {
                 }
                 void this.onRoomResume(m);
                 return;
+            case 'room-interject':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-interject-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomInterject(m);
+                return;
+            case 'room-findings':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-findings-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomFindings(m);
+                return;
+            case 'room-finding-edit':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomFindingEdit(m);
+                return;
+            case 'room-close':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-close-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomClose(m);
+                return;
             default:
                 // welcome / denied / invoke-result / host-call / event / run-accepted /
                 // run-done / permission-ask / permission-resolved are host-side.
@@ -523,6 +619,7 @@ export class SidecarServer {
             const name = typeof m.clientName === 'string' && m.clientName
                 ? m.clientName.slice(0, MAX_IDENTITY_FIELD_LEN)
                 : clientId;
+            this.clientName = name;
             // Best-effort, fire-and-forget: a throwing/rejecting `onClient` must never
             // deny/break an otherwise valid, authenticated handshake -- identity
             // recording is informational, not part of the auth decision. Covers BOTH
@@ -552,6 +649,52 @@ export class SidecarServer {
             });
         }
         this.opts.log?.(`paired — ${this.tools.size} ${this.tools.size === 1 ? 'tool' : 'tools'} advertised (host dir: ${this.hostStateDir})`);
+        /* THE ONE THING THAT WAITS. The welcome carries the synced directory name
+         * this daemon resolved for this connection, and the client has no other way
+         * to learn it -- it could previously only deduce it, and got null whenever
+         * no workspace was open or two hosts held the same workspace id, leaving a
+         * management surface unable to say which registrations were its own.
+         *
+         * Bounded, and every failure ends the same way as an older daemon: no
+         * `dirName` on the welcome. A handshake that never arrives would be a far
+         * worse trade than a client that falls back to deducing. */
+        const identity = this.clientId === undefined
+            ? undefined
+            : { clientId: this.clientId, name: this.clientName ?? this.clientId };
+        if (this.opts.clientDirName && identity) {
+            void this.resolveDirName(this.opts.clientDirName, identity).then((dirName) => {
+                this.sendWelcome(dirName);
+            });
+            return;
+        }
+        this.sendWelcome(null);
+    }
+    /** Resolve the connection's synced directory name, or null for every failure
+     * mode there is (throw, rejection, non-string, timeout). */
+    async resolveDirName(resolve, identity) {
+        try {
+            const timed = new Promise((res) => setTimeout(() => res(null), DIR_NAME_TIMEOUT_MS));
+            const got = await Promise.race([Promise.resolve(resolve(identity)), timed]);
+            return typeof got === 'string' && got ? got : null;
+        }
+        catch (err) {
+            this.opts.log?.(`clientDirName failed: ${errMessage(err)}`);
+            return null;
+        }
+    }
+    sendWelcome(dirName) {
+        /* Remembered BEFORE the welcome goes out, because `self` and the
+         * forget-your-own-tree refusal are both answered from it. A daemon too old
+         * to resolve one, or a client with no identity, leaves it undefined -- and
+         * then every entry reads `self: false` and nothing is refused on that
+         * ground, which is correct: this connection genuinely has no directory. */
+        if (dirName) {
+            this.dirName = dirName;
+            // Only a resolved directory can be attached: an unidentified connection
+            // is not "connected as" anything, and marking it would pin a tree it
+            // has no claim to.
+            this.hostsDetach = this.opts.hosts?.attach(dirName);
+        }
         const tools = [...this.tools.values()].map(({ run: _run, ...decl }) => decl);
         // Advertise the loopback HTTP proxy so the host can route local-LLM calls
         // through us (server-side fetch, no browser CORS) instead of failing, and
@@ -583,8 +726,21 @@ export class SidecarServer {
             // operator declared somewhere a checkout may be written, so a client only
             // offers "start from a repository" where it would actually work.
             ...(this.opts.sessions?.canClone ? ['session-clone'] : []),
+            // Whether this daemon HOLDS pauses. Advertised only with a real store
+            // behind it, so a client offers "Pause" only where pausing would actually
+            // stop the agent -- the alternative is a button that reports success on a
+            // daemon that keeps firing.
+            ...(this.opts.pauses ? ['agent-pause'] : []),
+            // Whether this daemon can report and reclaim its synced host directories.
+            // Advertised only with a real manifest behind it, so a client never
+            // offers a destructive control to a daemon that would refuse it.
+            ...(this.opts.hosts ? ['hosts-admin'] : []),
         ];
-        this.ch.send({ t: 'welcome', tools, features, ...(this.opts.info ? { info: this.opts.info } : {}) });
+        this.ch.send({
+            t: 'welcome', tools, features,
+            ...(this.opts.info ? { info: this.opts.info } : {}),
+            ...(dirName ? { dirName } : {}),
+        });
     }
     /** Proxy a host HTTP request server-side. Restricted to LOOPBACK targets — the
      * sidecar must never be usable as an SSRF pivot to internal/metadata hosts. The
@@ -1159,6 +1315,103 @@ export class SidecarServer {
             this.ch.send({ t: 'roots-add-result', id: m.id, ok: false, error: errMessage(e) });
         }
     }
+    /** Every synced host directory, with `self` stamped from THIS connection's
+     * own resolved directory -- never from anything the client sent. */
+    async onHostsList(m) {
+        if (!this.opts.hosts) {
+            this.ch.send({ t: 'hosts-list-result', id: m.id, ok: false, error: 'this daemon does not administer synced hosts' });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'hosts-list-result', id: m.id, ok: true, hosts: this.stampSelf(await this.opts.hosts.list()) });
+        }
+        catch (err) {
+            this.ch.send({ t: 'hosts-list-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    stampSelf(hosts) {
+        return hosts.map((h) => ({ ...h, self: this.dirName !== undefined && h.dirName === this.dirName }));
+    }
+    /**
+     * Delete one synced tree and its manifest entry.
+     *
+     * THE REFUSALS ARE THE FEATURE. A client's UI is not a guard -- this message
+     * carries a `dirName` the client chose, so both rules that make the operation
+     * safe are enforced here: the caller's OWN directory is refused outright, and
+     * the port refuses any directory a client is attached as. The first is
+     * checked here rather than left to the second because it is answerable from
+     * this connection's own identity and yields the more useful sentence.
+     */
+    async onHostsForget(m) {
+        if (!this.opts.hosts) {
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: 'this daemon does not administer synced hosts' });
+            return;
+        }
+        if (typeof m.dirName !== 'string' || !m.dirName) {
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: 'dirName must be a non-empty string' });
+            return;
+        }
+        if (this.dirName !== undefined && m.dirName === this.dirName) {
+            this.ch.send({
+                t: 'hosts-forget-result', id: m.id, ok: false,
+                error: 'That is this connection’s own synced directory. Disconnect this client first, then remove it from another one.',
+            });
+            return;
+        }
+        try {
+            const outcome = await this.opts.hosts.forget(m.dirName);
+            if (!outcome.ok) {
+                this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: outcome.reason });
+                return;
+            }
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: true, hosts: this.stampSelf(await this.opts.hosts.list()) });
+        }
+        catch (err) {
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    onAgentPauseList(m) {
+        if (!this.opts.pauses) {
+            // An honest empty answer for a daemon without the capability: it is
+            // holding no pauses, which is true. The feature gate is what tells a
+            // client whether it may OFFER the control.
+            this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: true, pauses: [] });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: true, pauses: this.opts.pauses.list() });
+        }
+        catch (err) {
+            this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onAgentPauseSet(m) {
+        if (!this.opts.pauses) {
+            // NOT an empty success. Accepting a pause this daemon cannot hold would
+            // leave the operator believing an agent had been stopped while it kept
+            // firing on the hour -- the exact failure the feature exists to end.
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: 'this daemon does not hold agent pauses' });
+            return;
+        }
+        // Runtime-validate: the message arrived via `JSON.parse(...) as SidecarMsg`,
+        // so the declared types guarantee nothing. Both fields become part of a
+        // persisted key.
+        if (typeof m.owner !== 'string' || typeof m.agent !== 'string' || !m.agent) {
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: 'owner must be a string and agent a non-empty string' });
+            return;
+        }
+        try {
+            const pauses = await this.opts.pauses.set(m.owner, m.agent, m.paused === true);
+            // Republish before replying: the caller's own row and every other
+            // connected client's must change together, or a second browser keeps
+            // offering "Pause" on an agent already paused.
+            this.opts.pauses.refresh();
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: true, pauses });
+        }
+        catch (err) {
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
     async onRoomOpen(m) {
         if (!this.opts.rooms) {
             this.ch.send({ t: 'room-open-result', id: m.id, ok: false, problems: ['this sidecar does not host rooms'] });
@@ -1236,7 +1489,7 @@ export class SidecarServer {
             return;
         }
         try {
-            const room = await this.opts.rooms.answer(m.roomId, m.participantId, m.text);
+            const room = await this.opts.rooms.answer(m.roomId, m.participantId, m.text, m.addressed);
             this.ch.send({ t: 'room-answer-result', id: m.id, ok: true, room });
         }
         catch (err) {
@@ -1245,6 +1498,64 @@ export class SidecarServer {
             this.ch.send({ t: 'room-answer-result', id: m.id, ok: false, error: errMessage(err) });
         }
     }
+    async onRoomInterject(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-interject-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const room = await this.opts.rooms.interject(m.roomId, m.participantId, m.text);
+            this.ch.send({ t: 'room-interject-result', id: m.id, ok: true, room });
+        }
+        catch (err) {
+            // A room failure must never kill the connection; the client gets a
+            // refusal it can render instead of a socket that went quiet.
+            this.ch.send({ t: 'room-interject-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomClose(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-close-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const room = await this.opts.rooms.close(m.roomId, m.participantId, m.reason);
+            this.ch.send({ t: 'room-close-result', id: m.id, ok: true, room });
+        }
+        catch (err) {
+            this.ch.send({ t: 'room-close-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomFindings(m) {
+        if (!this.opts.rooms) {
+            // A daemon without the capability hosts no rooms, so it holds no
+            // findings -- an honest empty document, the same answer `room-list`
+            // gives. The catch below is the different thing: a real read that failed.
+            this.ch.send({ t: 'room-findings-result', id: m.id, ok: true, findings: [] });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'room-findings-result', id: m.id, ok: true, findings: await this.opts.rooms.findings(m.roomId) });
+        }
+        catch (err) {
+            this.ch.send({ t: 'room-findings-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomFindingEdit(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const findings = await this.opts.rooms.editFinding(m.roomId, m.participantId, m.edit);
+            this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: true, findings });
+        }
+        catch (err) {
+            // A refused edit must never kill the connection; the person gets the
+            // reason their edit did not land.
+            this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
     async onHostSyncPut(m) {
         const identity = this.requireHostSyncIdentity();
         if ('error' in identity) {