@yeaft/webchat-agent 0.1.534 → 0.1.536

package/connection/message-router.js

@@ -36,7 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -436,6 +436,32 @@ export async function handleMessage(msg) {
       handleUnifyUserMemoryRemove(msg);
       break;
 
+    // task-334m: Group CRUD + D1 seed wiring (§Δ10 334m + R6 §Δ31.2).
+    // All handlers reply via `group_crud_result`; mutating ops additionally
+    // emit `group_roster_changed` (add/remove/default) or
+    // `group_list_updated` (create/rename/archive) for listener sync.
+    case 'unify_list_groups':
+      handleUnifyListGroups(msg);
+      break;
+    case 'unify_create_group':
+      handleUnifyCreateGroup(msg);
+      break;
+    case 'unify_rename_group':
+      handleUnifyRenameGroup(msg);
+      break;
+    case 'unify_archive_group':
+      handleUnifyArchiveGroup(msg);
+      break;
+    case 'unify_add_member':
+      handleUnifyAddMember(msg);
+      break;
+    case 'unify_remove_member':
+      handleUnifyRemoveMember(msg);
+      break;
+    case 'unify_set_default_vp':
+      handleUnifySetDefaultVp(msg);
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.534",
+  "version": "0.1.536",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/groups/group-crud.js

@@ -0,0 +1,250 @@
+/**
+ * group-crud.js — High-level Group CRUD API (task-334m).
+ *
+ * Wraps the primitives from group-store.js + roster.js into the 5 operations
+ * wired to WS events (§Δ10 334m + R6 §Δ31.2):
+ *   createGroupFromSpec  — wizard "create new group" (empty or user-picked roster)
+ *   renameGroup          — update meta.name; preserves roster / defaultVpId
+ *   archiveGroup         — rename dir to `.archived-<ts>-<id>` (soft delete)
+ *   addMember            — roster.addVp + save; sets defaultVpId if first
+ *   removeMember         — roster.removeVp + save; clears/rotates defaultVpId
+ *
+ * Plus the D1 bootstrap helper:
+ *   ensureDefaultGroupIfEmpty(yeaftDir, {libDir}) — if NO group exists on
+ *   disk, seed `grp_default` with roster = every VP in the library, and
+ *   defaultVpId = alphabetically first vpId. No-op when ≥1 group present.
+ *
+ * Hard constraints (PM):
+ *   (a) We don't touch 334o storage primitives (storage/index.js) — we call
+ *       group-store.openGroup / saveMeta which already go through openLog.
+ *   (b) We don't touch VP entity (vp-store.js / vp-loader.js) — only read
+ *       via scanVpLibrary to know which VPs exist at seed time.
+ *   (c) When `addMember` is called with an empty roster and no defaultVpId
+ *       resolvable, callers surface `no_default_vp` via `createGroupFromSpec`;
+ *       on `removeMember` we permit the empty state (UI nudges the user).
+ *
+ * Error shape — every throw is a `GroupCrudError` with a stable `.code`:
+ *   'not_found'        — group id has no dir / meta
+ *   'duplicate'        — createGroup collided with an existing id
+ *   'invalid_name'     — display name empty after trim
+ *   'no_default_vp'    — seed with empty VP library OR roster empties to []
+ *                        and the caller asked for a defaultVpId. (D1 spec)
+ *   'reserved'/'invalid_vp_id'/... — bubbled from ids.js validators
+ */
+
+import { existsSync, renameSync } from 'fs';
+import { randomBytes } from 'crypto';
+import { join } from 'path';
+import {
+  openGroup, createGroup, listGroups, loadGroupMeta,
+} from './group-store.js';
+import { addVp as rosterAdd, removeVp as rosterRemove, setDefaultVp } from './roster.js';
+import { seedDefaultGroup, DEFAULT_GROUP_ID } from './seed-default.js';
+import { nextGroupId, validateVpId, isReservedVpId } from './ids.js';
+import { scanVpLibrary, DEFAULT_VP_LIB_DIR } from '../vp/vp-store.js';
+
+export class GroupCrudError extends Error {
+  constructor(code, groupId, message) {
+    super(message || `${code}: ${groupId}`);
+    this.name = 'GroupCrudError';
+    this.code = code;
+    this.groupId = groupId;
+  }
+}
+
+function groupsRoot(yeaftDir) {
+  return join(yeaftDir, 'groups');
+}
+
+/** Build a safe group id from a display name (slug + ulid-lite suffix). */
+export function makeGroupId(name) {
+  const slug = String(name || 'group')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 24) || 'group';
+  return nextGroupId(slug);
+}
+
+/**
+ * (B) D1 seed — called at boot (or when multi-VP is first enabled). Idempotent:
+ * returns `{seeded:false}` if any group already exists on disk (including
+ * `grp_default`). When empty, seeds with roster = full VP library, sorted
+ * alphabetically; defaultVpId = roster[0].
+ *
+ * When the VP library is also empty, we still seed an empty-roster group so
+ * the UI has somewhere to land — but defaultVpId is null and downstream
+ * message send will return `no_default_vp` until the user adds a VP.
+ */
+export function ensureDefaultGroupIfEmpty(yeaftDir, options = {}) {
+  const libDir = options.libDir || DEFAULT_VP_LIB_DIR;
+  const existing = listGroups(groupsRoot(yeaftDir));
+  if (existing.length > 0) {
+    return { seeded: false, groupId: existing[0].id };
+  }
+
+  // Sort VP ids alphabetically (stable for tests / deterministic UI).
+  // NB: vp-store returns records with `.id` (not `.vpId`) — keep this in sync.
+  const vps = scanVpLibrary({ dir: libDir })
+    .map(v => v && v.id)
+    .filter(v => typeof v === 'string' && v.length > 0);
+  vps.sort((a, b) => a.localeCompare(b));
+
+  const defaultVpId = vps[0] || null;
+  const { group, created } = seedDefaultGroup(yeaftDir, {
+    name: options.name || 'Default',
+    roster: vps,
+    defaultVpId,
+  });
+  return {
+    seeded: created,
+    groupId: group.id,
+    defaultVpId,
+    rosterSize: vps.length,
+  };
+}
+
+/**
+ * (A.1) Create group from a wizard spec. `spec.roster` is authoritative —
+ * we do NOT auto-expand to the full VP library here. That's D1's job only.
+ *
+ * @param {string} yeaftDir
+ * @param {{name:string, roster?:string[], defaultVpId?:string|null}} spec
+ * @returns {{id:string, name:string, roster:string[], defaultVpId:string|null}}
+ */
+export function createGroupFromSpec(yeaftDir, spec) {
+  const name = String(spec && spec.name || '').trim();
+  if (!name) throw new GroupCrudError('invalid_name', null, 'group name required');
+
+  const roster = Array.isArray(spec.roster) ? spec.roster.slice() : [];
+  // Validate every member up-front so we fail before touching fs.
+  for (const vpId of roster) {
+    if (isReservedVpId(vpId)) {
+      throw new GroupCrudError('reserved', null, `reserved vpId: ${vpId}`);
+    }
+    const v = validateVpId(vpId);
+    if (!v.ok) throw new GroupCrudError(v.reason, null, `invalid vpId: ${vpId}`);
+  }
+
+  // defaultVpId resolution: explicit > roster[0] > null. Null is allowed at
+  // create time (empty roster) — the wizard modal warns the user downstream
+  // (task-334m spec: `no_default_vp` surfaced on first send, not on create).
+  let defaultVpId = spec.defaultVpId || null;
+  if (defaultVpId && !roster.includes(defaultVpId)) {
+    throw new GroupCrudError('default_not_in_roster', null, `${defaultVpId} not in roster`);
+  }
+  if (!defaultVpId) defaultVpId = roster[0] || null;
+
+  const id = makeGroupId(name);
+  const root = groupsRoot(yeaftDir);
+  if (existsSync(join(root, id))) {
+    // Extremely unlikely (ulid suffix), but surface deterministically.
+    throw new GroupCrudError('duplicate', id);
+  }
+
+  const handle = createGroup(root, { id, name, roster, defaultVpId });
+  const meta = handle.getMeta();
+  handle.close();
+  return meta;
+}
+
+/**
+ * (A.2) Rename — updates meta.name; preserves everything else.
+ */
+export function renameGroup(yeaftDir, groupId, newName) {
+  const name = String(newName || '').trim();
+  if (!name) throw new GroupCrudError('invalid_name', groupId);
+  const handle = requireGroup(yeaftDir, groupId);
+  const meta = handle.getMeta();
+  handle.saveMeta({ ...meta, name });
+  const next = handle.getMeta();
+  handle.close();
+  return next;
+}
+
+/**
+ * (A.3) Archive — renames the dir to `.archived-<ts>-<id>`. Directory
+ * prefix `.` keeps `listGroups` from picking it up (readdirSync filter in
+ * the caller). Reversible: user can rename back manually for recovery.
+ *
+ * We do NOT support hard-delete here — that's an upstream UI flow with its
+ * own second-confirm modal (acceptance #4 in task-334-slice-specs.md 334m).
+ */
+export function archiveGroup(yeaftDir, groupId) {
+  const root = groupsRoot(yeaftDir);
+  const srcDir = join(root, groupId);
+  if (!existsSync(srcDir) || !loadGroupMeta(srcDir)) {
+    throw new GroupCrudError('not_found', groupId);
+  }
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  // Append 4 hex chars to disambiguate same-millisecond archives (nit #5).
+  const suffix = randomBytes(2).toString('hex');
+  const dstDir = join(root, `.archived-${ts}-${suffix}-${groupId}`);
+  renameSync(srcDir, dstDir);
+  return { groupId, archivedAs: dstDir };
+}
+
+/**
+ * (A.4) Add a VP to the group roster. Idempotent — no-op if already present.
+ * Returns the new meta.
+ */
+export function addMember(yeaftDir, groupId, vpId) {
+  const handle = requireGroup(yeaftDir, groupId);
+  try {
+    const meta = handle.getMeta();
+    const next = rosterAdd(meta, vpId);
+    handle.saveMeta(next);
+    return handle.getMeta();
+  } finally {
+    handle.close();
+  }
+}
+
+/**
+ * (A.5) Remove a VP from the group roster. If the removed id was default,
+ * roster.removeVp rotates to the next member (or null).
+ */
+export function removeMember(yeaftDir, groupId, vpId) {
+  const handle = requireGroup(yeaftDir, groupId);
+  try {
+    const meta = handle.getMeta();
+    if (!meta.roster.includes(vpId)) {
+      // Treat as idempotent no-op — UI wants the post-state.
+      return meta;
+    }
+    const next = rosterRemove(meta, vpId);
+    handle.saveMeta(next);
+    return handle.getMeta();
+  } finally {
+    handle.close();
+  }
+}
+
+/** Expose default-VP setter for UI "set as default" affordance. */
+export function setGroupDefaultVp(yeaftDir, groupId, vpId) {
+  const handle = requireGroup(yeaftDir, groupId);
+  try {
+    const meta = handle.getMeta();
+    const next = setDefaultVp(meta, vpId);
+    handle.saveMeta(next);
+    return handle.getMeta();
+  } finally {
+    handle.close();
+  }
+}
+
+function requireGroup(yeaftDir, groupId) {
+  const root = groupsRoot(yeaftDir);
+  const dir = join(root, groupId);
+  if (!existsSync(dir) || !loadGroupMeta(dir)) {
+    throw new GroupCrudError('not_found', groupId);
+  }
+  return openGroup(root, groupId);
+}
+
+/** Convenience: snapshot all non-archived groups for WS broadcast. */
+export function snapshotGroups(yeaftDir) {
+  return listGroups(groupsRoot(yeaftDir));
+}
+
+export { DEFAULT_GROUP_ID };

package/unify/groups/index.js

@@ -37,6 +37,18 @@ export {
   seedDefaultGroup,
   DEFAULT_GROUP_ID,
 } from './seed-default.js';
+export {
+  GroupCrudError,
+  makeGroupId,
+  ensureDefaultGroupIfEmpty,
+  createGroupFromSpec,
+  renameGroup,
+  archiveGroup,
+  addMember,
+  removeMember,
+  setGroupDefaultVp,
+  snapshotGroups,
+} from './group-crud.js';
 export {
   nextMsgId,
   nextGroupId,

package/unify/session.js

@@ -31,6 +31,7 @@ import { getThreadStore } from './threads/store.js';
 import { createIntentClassifier } from './router/intent-classifier.js';
 import { initInputQueueStore } from './input-queue/store.js';
 import { createDispatcher } from './pipeline/dispatcher.js';
+import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { join } from 'path';
 import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from 'fs';
 
@@ -164,6 +165,20 @@ export async function loadSession(options = {}) {
     idleArchiveDays: config.unify?.autoArchiveIdleDays ?? 0,
   });
 
+  // ─── 5c. D1 first-boot seed (task-334m) ─────────────────
+  //         When no groups exist on disk AND we're not in read-only mode,
+  //         seed a default group with roster = all VPs in the library,
+  //         defaultVpId = alphabetically first. Idempotent — no-op when
+  //         any group already exists. Never throws; failure logs a warning
+  //         so session load always succeeds.
+  if (!config._readOnly) {
+    try {
+      ensureDefaultGroupIfEmpty(yeaftDir);
+    } catch (err) {
+      console.warn(`[Yeaft] ensureDefaultGroupIfEmpty failed: ${err?.message || err}`);
+    }
+  }
+
   // ─── 6. Load skills ────────────────────────────────────
   let skillManager;
   if (skipSkills) {

package/unify/web-bridge.js

@@ -33,6 +33,16 @@ import {
   handleUnifyUserMemoryWrite as _handleUnifyUserMemoryWrite,
   handleUnifyUserMemoryRemove as _handleUnifyUserMemoryRemove,
 } from './user-memory.js';
+import {
+  GroupCrudError,
+  createGroupFromSpec,
+  renameGroup,
+  archiveGroup,
+  addMember,
+  removeMember,
+  setGroupDefaultVp,
+  snapshotGroups,
+} from './groups/group-crud.js';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -253,6 +263,151 @@ export function handleUnifyVpRead(msg) {
   sendVpCrudResult({ op: 'read', requestId, ok: true, vpId, vp });
 }
 
+/**
+ * task-334m: Group CRUD wired to WS events (§Δ10 334m + R6 §Δ31.2).
+ *
+ * Message shapes (wire):
+ *   unify_list_groups    { requestId? }
+ *   unify_create_group   { payload: {name, roster?, defaultVpId?}, requestId? }
+ *   unify_rename_group   { groupId, name, requestId? }
+ *   unify_archive_group  { groupId, requestId? }
+ *   unify_add_member     { groupId, vpId, requestId? }
+ *   unify_remove_member  { groupId, vpId, requestId? }
+ *   unify_set_default_vp { groupId, vpId, requestId? }
+ *
+ * Replies (sendUnifyEvent):
+ *   { type: 'group_crud_result', op, requestId, ok, group?, groups?, error?: {code, groupId?, message?} }
+ *
+ * Post-change broadcast (when meta mutates):
+ *   { type: 'group_roster_changed', groupId, roster, defaultVpId, name }
+ */
+function sendGroupCrudResult(payload) {
+  sendUnifyEvent({ type: 'group_crud_result', ...payload });
+}
+
+function sendGroupSnapshotBroadcast() {
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    if (!yeaftDir) return;
+    const groups = snapshotGroups(yeaftDir);
+    sendUnifyEvent({ type: 'group_list_updated', groups });
+  } catch (err) {
+    console.warn('[Unify] sendGroupSnapshotBroadcast failed:', err?.message || err);
+  }
+}
+
+function sendGroupRosterChanged(group) {
+  if (!group) return;
+  sendUnifyEvent({
+    type: 'group_roster_changed',
+    groupId: group.id,
+    name: group.name,
+    roster: group.roster,
+    defaultVpId: group.defaultVpId,
+  });
+}
+
+function groupErrorPayload(err) {
+  return {
+    code: err instanceof GroupCrudError ? err.code : 'unknown',
+    groupId: err && err.groupId,
+    message: err && err.message,
+  };
+}
+
+export function handleUnifyListGroups(msg) {
+  const requestId = msg && msg.requestId;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const groups = snapshotGroups(yeaftDir);
+    sendGroupCrudResult({ op: 'list', requestId, ok: true, groups });
+  } catch (err) {
+    sendGroupCrudResult({ op: 'list', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
+export function handleUnifyCreateGroup(msg) {
+  const requestId = msg && msg.requestId;
+  const payload = (msg && msg.payload) || {};
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const group = createGroupFromSpec(yeaftDir, payload);
+    sendGroupCrudResult({ op: 'create', requestId, ok: true, group });
+    sendGroupSnapshotBroadcast();
+  } catch (err) {
+    sendGroupCrudResult({ op: 'create', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
+export function handleUnifyRenameGroup(msg) {
+  const requestId = msg && msg.requestId;
+  const groupId = msg && msg.groupId;
+  const name = msg && msg.name;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const group = renameGroup(yeaftDir, groupId, name);
+    sendGroupCrudResult({ op: 'rename', requestId, ok: true, group });
+    sendGroupSnapshotBroadcast();
+  } catch (err) {
+    sendGroupCrudResult({ op: 'rename', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
+export function handleUnifyArchiveGroup(msg) {
+  const requestId = msg && msg.requestId;
+  const groupId = msg && msg.groupId;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const result = archiveGroup(yeaftDir, groupId);
+    sendGroupCrudResult({ op: 'archive', requestId, ok: true, groupId: result.groupId });
+    sendGroupSnapshotBroadcast();
+  } catch (err) {
+    sendGroupCrudResult({ op: 'archive', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
+export function handleUnifyAddMember(msg) {
+  const requestId = msg && msg.requestId;
+  const groupId = msg && msg.groupId;
+  const vpId = msg && msg.vpId;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const group = addMember(yeaftDir, groupId, vpId);
+    sendGroupCrudResult({ op: 'add_member', requestId, ok: true, group });
+    sendGroupRosterChanged(group);
+  } catch (err) {
+    sendGroupCrudResult({ op: 'add_member', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
+export function handleUnifyRemoveMember(msg) {
+  const requestId = msg && msg.requestId;
+  const groupId = msg && msg.groupId;
+  const vpId = msg && msg.vpId;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const group = removeMember(yeaftDir, groupId, vpId);
+    sendGroupCrudResult({ op: 'remove_member', requestId, ok: true, group });
+    sendGroupRosterChanged(group);
+  } catch (err) {
+    sendGroupCrudResult({ op: 'remove_member', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
+export function handleUnifySetDefaultVp(msg) {
+  const requestId = msg && msg.requestId;
+  const groupId = msg && msg.groupId;
+  const vpId = msg && msg.vpId;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const group = setGroupDefaultVp(yeaftDir, groupId, vpId);
+    sendGroupCrudResult({ op: 'set_default_vp', requestId, ok: true, group });
+    sendGroupRosterChanged(group);
+  } catch (err) {
+    sendGroupCrudResult({ op: 'set_default_vp', requestId, ok: false, error: groupErrorPayload(err) });
+  }
+}
+
 /**
  * task-318 rev-1 fix: install live-setter bridge between the session's
  * runtime handles (engineRegistry + threadStore) and `ctx.unifyRuntimeSettings`,
@@ -845,6 +1000,10 @@ export async function handleUnifyChat(msg) {
       // serverTime) so a freshly-connected client can restore inflight
       // status without waiting for the next engine event.
       sendThreadListSnapshot();
+      // task-334m: push initial groups snapshot so the Sidebar Groups
+      // section renders the full list immediately (including the D1
+      // default group seeded during session bootstrap).
+      sendGroupSnapshotBroadcast();
     }
 
     // ─── Per-call AbortController (task-320) ──
@@ -1318,6 +1477,8 @@ export async function handleUnifyLoadHistory(msg) {
   // mutation-delta stream; `thread_list_snapshot` is the single
   // authoritative "everything right now" payload.
   sendThreadListSnapshot();
+  // task-334m: replay groups snapshot so Sidebar Groups rebuilds on refresh.
+  sendGroupSnapshotBroadcast();
 
   const limit = msg.limit || 50;
   const messages = session.conversationStore.loadRecent(limit);