@sparkelf/dsh-group-chat 0.5.4 → 0.5.6

package/lib/index.js

@@ -791,48 +791,35 @@ const cleanupRoomSessions = async (input) => {
 		errors
 	};
 };
+//#endregion
+//#region src/room-workspace.ts
 /**
-* Register a room's Session with the workspace that owns its directory.
+* Give a room's Session the workspace that makes it selectable.
 *
-* The shell's `openSession` selects a Session that belongs to a Workspace, so a room created
-* with a `cwd` and no workspace id is not selectable until this runs. Registration is idempotent
-* on the registry (`attachSession` checks membership before writing), which is what lets the
-* discovery poll run it on every boot without duplicating rows.
+* The path is the Session's own `cwd`: that is the one path `attachSession` will accept, and it
+* is stable for the life of the Session (a room's directory is fixed when the Session is
+* created). Reuse is by exact path, so opening the same room twice never creates a second
+* workspace.
 *
-* Never throws: a room that cannot be registered still reads and writes through its Host, only
-* the main view cannot follow it, and that is a state worth reporting rather than a failed open.
-* @param registry - the workspace registry surface, absent on a minimal host.
-* @param directory - the room directory the workspace is resolved by.
+* @param registry - the workspace registry, absent on a minimal host.
+* @param path - the room Session's directory.
+* @param title - display title for a newly created workspace.
 * @param sessionId - the room's canonical Session.
-* @param log - optional warning sink; the plugin passes its Cordis logger.
-* @returns whether the Session is now attached.
+* @returns which workspace the room belongs to, and whether this call created it.
+* @throws when the registry refuses the create or the attach; the caller decides how to report.
 */
-const attachRoomSession = async (registry, directory, sessionId, log) => {
-	if (registry === void 0) {
-		log?.warn?.("[group-chat] the workspace registry is unavailable; the room session stays unlisted", sessionId);
-		return {
-			attached: false,
-			reason: "registry-unavailable"
-		};
-	}
-	try {
-		const workspace = await registry.resolveByPath(directory);
-		if (workspace === void 0) {
-			log?.warn?.("[group-chat] no workspace owns the room directory; the room session stays unlisted", sessionId, directory);
-			return {
-				attached: false,
-				reason: "workspace-not-found"
-			};
-		}
-		await workspace.attachSession(sessionId);
-		return { attached: true };
-	} catch (error) {
-		log?.warn?.("[group-chat] attaching the room session to its workspace failed", sessionId, error);
-		return {
-			attached: false,
-			reason: "attach-failed"
-		};
-	}
+const ensureRoomWorkspace = async (registry, path, title, sessionId) => {
+	if (registry === void 0) return {
+		workspaceId: void 0,
+		created: false
+	};
+	const existing = await registry.resolveByPath(path);
+	const workspace = existing ?? await registry.create(path, title);
+	await workspace.attachSession(sessionId);
+	return {
+		workspaceId: workspace.id,
+		created: existing === void 0
+	};
 };
 /**
 * Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
@@ -9298,7 +9285,10 @@ var RoomSessions = class {
 	*/
 	async ensure(roomId, room) {
 		const existing = this.existing(roomId);
-		if (existing !== void 0) return existing;
+		if (existing !== void 0) {
+			this.titleRoomSession(existing, room.name);
+			return existing;
+		}
 		const pending = this.pending.get(roomId);
 		if (pending !== void 0) return pending;
 		const opening = this.open(roomId, room).finally(() => {
@@ -9314,7 +9304,6 @@ var RoomSessions = class {
 		const resumed = await this.resolvePersisted(sessionId, directory);
 		if (resumed !== void 0) {
 			await this.installRoomModel(resumed, room, false);
-			await this.attachToWorkspace(sessionId, directory);
 			return resumed;
 		}
 		const created = await this.ctx.sessionController.create({
@@ -9329,7 +9318,7 @@ var RoomSessions = class {
 		const session = this.existing(roomId);
 		if (session === void 0) throw new Error(`group-chat could not open a session for room ${roomId}`);
 		await this.installRoomModel(session, room, true);
-		await this.attachToWorkspace(sessionId, directory);
+		this.titleRoomSession(session, room.name);
 		return session;
 	}
 	/** Load a persisted room Session, or `undefined` only when the controller denies it exists. */
@@ -9377,18 +9366,22 @@ var RoomSessions = class {
 		return hostService(this.ctx, "workspaceRegistry");
 	}
 	/**
-	* Attach the room's Session to the workspace that owns its directory.
+	* Give the room's Session the title a reader expects, once.
 	*
-	* The shell's `openSession` selects a Session that belongs to a Workspace, so a room created
-	* with a `cwd` alone is not selectable and clicking it moves the highlight only. Attaching is
-	* idempotent on the registry side, and every failure here is logged rather than fatal: a room
-	* whose registration failed still reads and writes through its Host, only the main view
-	* cannot follow it.
-	* @param sessionId - the room's canonical Session.
-	* @param directory - the room directory the workspace is resolved by.
+	* A room Session starts titled from its first message, which reads like an ordinary
+	* conversation in the sidebar. Renaming happens only while the Session has never carried a
+	* `session/title` event: once the plugin or the reader has named it, that choice stands.
+	* @param session - the room's Session.
+	* @param name - the room name, used as `群聊·<name>`.
 	*/
-	async attachToWorkspace(sessionId, directory) {
-		await attachRoomSession(hostService(this.ctx, "workspaceRegistry"), directory, sessionId, this.ctx.logger);
+	titleRoomSession(session, name) {
+		if (session.snapshotEvents().some((event) => event.type === "session/title")) return;
+		const titles = hostService(this.ctx, "sessionTitle");
+		try {
+			titles?.rename(session, `群聊·${name}`);
+		} catch (error) {
+			this.ctx.logger?.warn?.("[group-chat] naming the room session failed", session.id, error);
+		}
 	}
 	/** Hide a replacement the controller minted instead of honoring the room id. */
 	async archiveReplacement(sessionId) {
@@ -10063,6 +10056,33 @@ const handleRoomRequest = async (route, httpMethod, payload, url, backend, runti
 	* `purge: true` plus `confirm` equal to the room id. The canonical room Session is never a
 	* candidate, and neither is another room's Session or a subagent child.
 	*/
+	/**
+	* Make one room the view: resolve its Session, give it the workspace that makes it selectable,
+	* and answer with the Session id. The browser cannot do any of this itself -- it has no registry
+	* and no workspace, and `openSession` refuses a Session no workspace owns.
+	*/
+	const openMatch = /^rooms\/([^/]+)\/open$/u.exec(route);
+	if (openMatch !== null && openMatch[1] !== void 0) {
+		if (httpMethod !== "POST") throw new RouteRefusal("opening a room accepts POST", 405);
+		const targetRoomId = decodeURIComponent(openMatch[1]);
+		const room = (await backend.listRooms()).find((candidate) => candidate.id === targetRoomId);
+		if (room === void 0) throw new RouteRefusal("this account is not a member of that room", 404);
+		const session = await new RoomSessions(ctx).ensure(targetRoomId, {
+			name: room.name,
+			...room.cwd === null ? {} : { cwd: room.cwd },
+			agentPreset: room.agentPreset ?? void 0,
+			modelProvider: room.modelProvider ?? void 0,
+			model: room.model ?? void 0,
+			reasoningEffort: room.reasoningEffort ?? void 0
+		});
+		const directory = session.header.cwd ?? resolveRoomDirectory(targetRoomId, room.cwd);
+		const workspace = await ensureRoomWorkspace(hostService(ctx, "workspaceRegistry"), directory, `群聊·${room.name}`, session.id);
+		return {
+			sessionId: session.id,
+			workspaceId: workspace.workspaceId,
+			workspaceCreated: workspace.created
+		};
+	}
 	const cleanupMatch = /^rooms\/([^/]+)\/sessions\/cleanup$/u.exec(route);
 	if (cleanupMatch !== null && cleanupMatch[1] !== void 0) {
 		if (httpMethod !== "POST") throw new RouteRefusal("session cleanup accepts POST", 405);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkelf/dsh-group-chat",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Human-agent group chat for DataOps-managed DSH workspaces: rooms broadcast to every member, and only a member's own @mention wakes that member's agent.",
   "type": "module",
   "main": "./lib/index.js",