@huynle/hub 0.7.4 → 0.8.0

package/src/spoke/fork-revert.ts

@@ -0,0 +1,142 @@
+// Fork and revert (features "fork" and "revert"): the pure parts of the spoke's fork, revertPreview, revert,
+// revertRestore and revertCommit ops. OpenCode semantics (checked against `opencode serve` 2.2.3, see
+// test/spoke-fork-revert.it.test.ts):
+//   - session.fork({sessionID, before}) copies the conversation BEFORE `before` into a new root session (allowed
+//     while the source runs).
+//   - session.revert.stage({sessionID, messageID, files: true}) marks the session reverted from that message and
+//     restores the files the session changed since then; OpenCode refuses it while the session runs
+//     (SessionBusyError). The messages stay in the session's history (message list and context): the CLIENT hides
+//     them, from the reverted message on. The session's `revert` field and session.revert.staged carry it.
+//   - session.revert.clear brings the files back (session.revert.cleared); session.revert.commit removes the hidden
+//     messages (session.revert.committed). The next prompt commits a staged revert by itself.
+import { REVERT_FILE_MAX_CHARS, REVERT_FILES_MAX, type MessageAttachment, type RevertFile, type SessionRevertInfo } from "../protocol"
+
+const record = (value: unknown): Record<string, any> => (value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, any>) : {})
+const STATUS = new Set(["added", "deleted", "modified"])
+const count = (value: unknown): number | undefined => (Number.isSafeInteger(value) && (value as number) >= 0 ? (value as number) : undefined)
+
+export const NOT_A_USER_MESSAGE = "Not a user message of this session"
+export const REVERT_BUSY = "The session is working; wait for it to finish (or stop it) before reverting"
+
+/** Epoch ms of an OpenCode timestamp (number or ISO string). */
+function millis(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined
+  if (typeof value !== "string") return undefined
+  const ms = Date.parse(value)
+  return Number.isNaN(ms) ? undefined : ms
+}
+
+/** The index of the user message `messageID` in the session's messages (oldest first), or -1. */
+export function userIndex(messages: readonly unknown[], messageID: string): number {
+  return messages.findIndex((raw) => {
+    const m = record(raw)
+    return m.id === messageID && m.type === "user"
+  })
+}
+
+/** The text and attachments (metadata, never bytes) of a user message, for the composer. */
+export function userContent(message: unknown): { text: string; attachments: MessageAttachment[] } {
+  const m = record(message)
+  const text =
+    typeof m.text === "string"
+      ? m.text
+      : Array.isArray(m.content)
+        ? m.content.filter((p: any) => p?.type === "text" && typeof p.text === "string").map((p: any) => p.text as string).join("")
+        : ""
+  const attachments: MessageAttachment[] = []
+  if (Array.isArray(m.files)) {
+    m.files.forEach((raw: unknown, index: number) => {
+      const f = record(raw)
+      if (typeof f.mime !== "string") return
+      attachments.push({ index, mime: f.mime, ...(typeof f.name === "string" && f.name ? { name: f.name.slice(0, 200) } : {}) })
+    })
+  }
+  return { text, attachments }
+}
+
+/** User messages from `index` on (the reverted one and those after it). */
+function usersFrom(messages: readonly unknown[], index: number): number {
+  let n = 0
+  for (let i = Math.max(0, index); i < messages.length; i++) if (record(messages[i]).type === "user") n++
+  return n
+}
+
+/** At most REVERT_FILES_MAX files, unique by path, with the total. */
+function bounded(files: readonly RevertFile[]): { files: RevertFile[]; filesTotal: number } {
+  const seen = new Set<string>()
+  const unique = files.filter((f) => {
+    if (!f.file || f.file.length > REVERT_FILE_MAX_CHARS || seen.has(f.file)) return false
+    seen.add(f.file)
+    return true
+  })
+  return { files: unique.slice(0, REVERT_FILES_MAX), filesTotal: unique.length }
+}
+
+/** OpenCode's FileDiffInfo list as revert files (no patches). */
+function diffFiles(raw: unknown): RevertFile[] {
+  if (!Array.isArray(raw)) return []
+  return raw.flatMap((entry) => {
+    const f = record(entry)
+    if (typeof f.file !== "string" || !f.file) return []
+    const additions = count(f.additions)
+    const deletions = count(f.deletions)
+    return [
+      {
+        file: f.file,
+        ...(STATUS.has(f.status) ? { status: f.status as RevertFile["status"] } : {}),
+        ...(additions === undefined ? {} : { additions }),
+        ...(deletions === undefined ? {} : { deletions }),
+      },
+    ]
+  })
+}
+
+/**
+ * What reverting from the user message at `index` would hide, and the files the session's assistant messages
+ * changed from there on (their snapshots' file lists): what a revert with files restores.
+ */
+export function revertPreview(messages: readonly unknown[], index: number): { hidden: number; files: RevertFile[]; filesTotal: number } {
+  const files: RevertFile[] = []
+  for (let i = Math.max(0, index); i < messages.length; i++) {
+    const m = record(messages[i])
+    if (m.type !== "assistant") continue
+    for (const file of Array.isArray(m.snapshot?.files) ? m.snapshot.files : []) if (typeof file === "string" && file) files.push({ file })
+  }
+  return { hidden: usersFrom(messages, index), ...bounded(files) }
+}
+
+/**
+ * The summary of OpenCode's staged revert (session.revert, or session.revert.staged's data.revert) over the
+ * session's messages; undefined when nothing is staged.
+ */
+export function revertSummary(raw: unknown, messages: readonly unknown[]): SessionRevertInfo | undefined {
+  const revert = record(raw)
+  if (typeof revert.messageID !== "string" || !revert.messageID || revert.messageID.length > 300) return undefined
+  const index = messages.findIndex((m) => record(m).id === revert.messageID)
+  const at = index < 0 ? undefined : millis(record(messages[index]).time?.created)
+  return {
+    messageID: revert.messageID,
+    hidden: index < 0 ? 0 : usersFrom(messages, index),
+    ...(at === undefined ? {} : { at }),
+    ...bounded(diffFiles(revert.files)),
+  }
+}
+
+/** The messages a client shows while a revert is staged from `messageID`: those before it (all when unknown). */
+export function visibleMessages<T>(messages: readonly T[], messageID: string | undefined): readonly T[] {
+  if (!messageID) return messages
+  const index = messages.findIndex((m) => record(m).id === messageID)
+  return index < 0 ? messages : messages.slice(0, index)
+}
+
+/** Whether an OpenCode error says the session is busy (a revert refused while it runs). */
+export function busyError(cause: unknown): boolean {
+  const c = record(cause)
+  const text = `${c._tag ?? ""} ${c.name ?? ""} ${cause instanceof Error ? cause.message : String(cause ?? "")}`
+  return /SessionBusy|Session is busy/i.test(text)
+}
+
+/** Same revert summaries (so an unchanged one sends no snapshot). */
+export function sameRevert(a: SessionRevertInfo | undefined, b: SessionRevertInfo | undefined): boolean {
+  return JSON.stringify(a ?? null) === JSON.stringify(b ?? null)
+}

package/src/spoke/hub-rpc.ts

@@ -4,6 +4,7 @@
 // result or an error (redacted should the hub echo it). Labels are sanitised here, so the TUI shows them as is.
 import { HubClient, HubError, HubTransportError, sanitizeLabel, type AgentMessage, type DirectoryEntry } from "../../packages/sdk/src/index.ts"
 import type { HubToolSpoke } from "./hub-tool"
+import type { WhoReach, WhoTeamGroup, WhoTeamRef } from "./who-teams"
 
 /** The RPC error a failure answers with (src/rpc.ts lists them). */
 export type HubRpcErrorCode = "invalid" | "not_connected" | "unsupported" | "unreachable" | "server_error"
@@ -25,6 +26,19 @@ export interface WhoRow {
   readonly state?: string
   readonly online: boolean
   readonly roles: string[]
+  /** HWA-40 (additive): where it runs, its teams (roles there, the caller's reach) and whether it is the caller. */
+  readonly machineID?: string
+  readonly harness?: string
+  readonly teams?: WhoTeamRef[]
+  readonly reach?: WhoReach
+  readonly self?: true
+}
+
+/** /who's answer: the rows, and the team groups when the hub sent them (HWA-40). */
+export interface WhoResult {
+  readonly sessions: WhoRow[]
+  readonly teams?: WhoTeamGroup[]
+  readonly scope?: "team"
 }
 
 export interface MsgResult {
@@ -57,16 +71,23 @@ export async function hubMsg(spoke: HubToolSpoke, value: unknown): Promise<MsgRe
   })
 }
 
-/** /who: the named and role-holding sessions (optionally one project or one role), as session `sessionID`. */
-export async function hubWho(spoke: HubToolSpoke, value: unknown): Promise<{ sessions: WhoRow[] }> {
+/**
+ * /who: the named and role-holding sessions (optionally one project, role or team), as session `sessionID`. A bare
+ * `project` that names one of the caller's teams (listed in a team member's answer) is taken as that team (/who <team>).
+ */
+export async function hubWho(spoke: HubToolSpoke, value: unknown): Promise<WhoResult> {
   const input = inputOf(value)
   const sessionID = optStr(input, "sessionID")
   if (!sessionID) throw new HubRpcError("invalid", "Open a session first: /who asks the hub as the current session.")
   const project = optStr(input, "project")
   const role = optStr(input, "role")
+  const team = optStr(input, "team")
   return withClient(spoke, sessionID, undefined, async (client, signal) => {
-    const { sessions } = await client.who({ ...(project ? { project } : {}), ...(role ? { role } : {}), signal })
-    return { sessions: sessions.map(whoRow) }
+    let answer = await client.who({ ...(project ? { project } : {}), ...(role ? { role } : {}), ...(team ? { team } : {}), signal })
+    // A team member's answer lists all its teams; a bare word naming one of them is /who <team>.
+    if (project && !role && !team && answer.teams?.some((t) => t.name === project)) answer = await client.who({ team: project, signal })
+    const teams = (answer.teams ?? []).map((t) => ({ name: sanitizeLabel(t.name), mode: t.mode, ...(t.paused ? { paused: true } : {}), ...(t.yourRoles?.length ? { yourRoles: t.yourRoles.map((r) => sanitizeLabel(r)) } : {}), members: t.members.map((m) => ({ sessionID: sanitizeLabel(m.sessionID), role: sanitizeLabel(m.role) })) }))
+    return { sessions: answer.sessions.map((e) => whoRow(e, sessionID)), ...(teams.length ? { teams } : {}), ...(answer.scope === "team" ? { scope: "team" as const } : {}) }
   })
 }
 
@@ -93,10 +114,24 @@ async function withClient<T>(
   }
 }
 
-function whoRow(entry: DirectoryEntry): WhoRow {
+const reachRow = (r: DirectoryEntry["reach"]): WhoReach | undefined => (r ? { send: [...r.send], receive: [...r.receive], direction: r.direction, ...(r.unreachable ? { unreachable: true } : {}) } : undefined)
+
+function whoRow(entry: DirectoryEntry, caller?: string): WhoRow {
   const name = entry.name ? sanitizeLabel(entry.name) : ""
   const project = entry.project ? sanitizeLabel(entry.project) : ""
   const state = entry.state ? sanitizeLabel(entry.state) : ""
+  const teams = (entry.teams ?? []).map((t) => {
+    const reach = reachRow(t.reach)
+    return { team: sanitizeLabel(t.team), roles: t.roles.map((r) => sanitizeLabel(r)), ...(reach ? { reach } : {}) }
+  })
+  const reach = reachRow(entry.reach)
+  const extra = {
+    ...(entry.machineID ? { machineID: sanitizeLabel(entry.machineID) } : {}),
+    ...(entry.harness ? { harness: sanitizeLabel(entry.harness) } : {}),
+    ...(teams.length ? { teams } : {}),
+    ...(reach ? { reach } : {}),
+    ...(caller !== undefined && entry.sessionID === caller && teams.length ? { self: true as const } : {}),
+  }
   return {
     sessionID: sanitizeLabel(entry.sessionID),
     ...(name ? { name } : {}),
@@ -104,6 +139,7 @@ function whoRow(entry: DirectoryEntry): WhoRow {
     ...(state ? { state } : {}),
     online: entry.online === true,
     roles: (entry.roles ?? []).map((r) => sanitizeLabel(r.role)).filter(Boolean),
+    ...extra,
   }
 }