@hiai-gg/hiai-opencode 0.1.1 → 0.1.2

package/src/features/tmux-subagent/session-created-handler.ts

@@ -1,175 +1,175 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { TmuxConfig } from "../../config/schema"
-import type { CapacityConfig, TrackedSession } from "./types"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { decideSpawnActions, type SessionMapping } from "./decision-engine"
-import { executeActions } from "./action-executor"
-import type { SessionCreatedEvent } from "./session-created-event"
-import { createTrackedSession } from "./tracked-session-state"
-
-type OpencodeClient = PluginInput["client"]
-
-export interface SessionCreatedHandlerDeps {
-  client: OpencodeClient
-  tmuxConfig: TmuxConfig
-  serverUrl: string
-  sourcePaneId: string | undefined
-  sessions: Map<string, TrackedSession>
-  pendingSessions: Set<string>
-  isInsideTmux: () => boolean
-  isEnabled: () => boolean
-  getCapacityConfig: () => CapacityConfig
-  getSessionMappings: () => SessionMapping[]
-  waitForSessionReady: (sessionId: string) => Promise<boolean>
-  startPolling: () => void
-}
-
-export async function handleSessionCreated(
-  deps: SessionCreatedHandlerDeps,
-  event: SessionCreatedEvent,
-): Promise<void> {
-  const enabled = deps.isEnabled()
-  log("[tmux-session-manager] onSessionCreated called", {
-    enabled,
-    tmuxConfigEnabled: deps.tmuxConfig.enabled,
-    isInsideTmux: deps.isInsideTmux(),
-    eventType: event.type,
-    infoId: event.properties?.info?.id,
-    infoParentID: event.properties?.info?.parentID,
-  })
-
-  if (!enabled) return
-  if (event.type !== "session.created") return
-
-  const info = event.properties?.info
-  if (!info?.id || !info?.parentID) return
-
-  const sessionId = info.id
-  const title = info.title ?? "Subagent"
-
-  if (deps.sessions.has(sessionId) || deps.pendingSessions.has(sessionId)) {
-    log("[tmux-session-manager] session already tracked or pending", { sessionId })
-    return
-  }
-
-  if (!deps.sourcePaneId) {
-    log("[tmux-session-manager] no source pane id")
-    return
-  }
-
-  deps.pendingSessions.add(sessionId)
-
-  try {
-    const state = await queryWindowState(deps.sourcePaneId)
-    if (!state) {
-      log("[tmux-session-manager] failed to query window state")
-      return
-    }
-
-    log("[tmux-session-manager] window state queried", {
-      windowWidth: state.windowWidth,
-      mainPane: state.mainPane?.paneId,
-      agentPaneCount: state.agentPanes.length,
-      agentPanes: state.agentPanes.map((p) => p.paneId),
-    })
-
-    const decision = decideSpawnActions(
-      state,
-      sessionId,
-      title,
-      deps.getCapacityConfig(),
-      deps.getSessionMappings(),
-    )
-
-    log("[tmux-session-manager] spawn decision", {
-      canSpawn: decision.canSpawn,
-      reason: decision.reason,
-      actionCount: decision.actions.length,
-      actions: decision.actions.map((a) => {
-        if (a.type === "close") return { type: "close", paneId: a.paneId }
-        if (a.type === "replace") {
-          return { type: "replace", paneId: a.paneId, newSessionId: a.newSessionId }
-        }
-        return { type: "spawn", sessionId: a.sessionId }
-      }),
-    })
-
-    if (!decision.canSpawn) {
-      log("[tmux-session-manager] cannot spawn", { reason: decision.reason })
-      return
-    }
-
-    const result = await executeActions(decision.actions, {
-      config: deps.tmuxConfig,
-      serverUrl: deps.serverUrl,
-      windowState: state,
-    })
-
-    for (const { action, result: actionResult } of result.results) {
-      if (action.type === "close" && actionResult.success) {
-        deps.sessions.delete(action.sessionId)
-        log("[tmux-session-manager] removed closed session from cache", {
-          sessionId: action.sessionId,
-        })
-      }
-      if (action.type === "replace" && actionResult.success) {
-        deps.sessions.delete(action.oldSessionId)
-        log("[tmux-session-manager] removed replaced session from cache", {
-          oldSessionId: action.oldSessionId,
-          newSessionId: action.newSessionId,
-        })
-      }
-    }
-
-    if (!result.success || !result.spawnedPaneId) {
-      log("[tmux-session-manager] spawn failed", {
-        success: result.success,
-        results: result.results.map((r) => ({
-          type: r.action.type,
-          success: r.result.success,
-          error: r.result.error,
-        })),
-      })
-      return
-    }
-
-    const sessionReady = await deps.waitForSessionReady(sessionId)
-    if (!sessionReady) {
-      log("[tmux-session-manager] session not ready after timeout, closing spawned pane", {
-        sessionId,
-        paneId: result.spawnedPaneId,
-      })
-
-      await executeActions(
-        [{ type: "close", paneId: result.spawnedPaneId, sessionId }],
-        {
-          config: deps.tmuxConfig,
-          serverUrl: deps.serverUrl,
-          windowState: state,
-        },
-      )
-
-      return
-    }
-
-    deps.sessions.set(
-      sessionId,
-      createTrackedSession({
-        sessionId,
-        paneId: result.spawnedPaneId,
-        description: title,
-      }),
-    )
-
-    log("[tmux-session-manager] pane spawned and tracked", {
-      sessionId,
-      paneId: result.spawnedPaneId,
-      sessionReady,
-    })
-
-    deps.startPolling()
-  } finally {
-    deps.pendingSessions.delete(sessionId)
-  }
-}
+import type { PluginInput } from "@opencode-ai/plugin"
+import type { TmuxConfig } from "../../config/schema"
+import type { CapacityConfig, TrackedSession } from "./types"
+import { log } from "../../shared"
+import { queryWindowState } from "./pane-state-querier"
+import { decideSpawnActions, type SessionMapping } from "./decision-engine"
+import { executeActions } from "./action-executor"
+import type { SessionCreatedEvent } from "./session-created-event"
+import { createTrackedSession } from "./tracked-session-state"
+
+type OpencodeClient = PluginInput["client"]
+
+export interface SessionCreatedHandlerDeps {
+  client: OpencodeClient
+  tmuxConfig: TmuxConfig
+  serverUrl: string
+  sourcePaneId: string | undefined
+  sessions: Map<string, TrackedSession>
+  pendingSessions: Set<string>
+  isInsideTmux: () => boolean
+  isEnabled: () => boolean
+  getCapacityConfig: () => CapacityConfig
+  getSessionMappings: () => SessionMapping[]
+  waitForSessionReady: (sessionId: string) => Promise<boolean>
+  startPolling: () => void
+}
+
+export async function handleSessionCreated(
+  deps: SessionCreatedHandlerDeps,
+  event: SessionCreatedEvent,
+): Promise<void> {
+  const enabled = deps.isEnabled()
+  log("[tmux-session-manager] onSessionCreated called", {
+    enabled,
+    tmuxConfigEnabled: deps.tmuxConfig.enabled,
+    isInsideTmux: deps.isInsideTmux(),
+    eventType: event.type,
+    infoId: event.properties?.info?.id,
+    infoParentID: event.properties?.info?.parentID,
+  })
+
+  if (!enabled) return
+  if (event.type !== "session.created") return
+
+  const info = event.properties?.info
+  if (!info?.id || !info?.parentID) return
+
+  const sessionId = info.id
+  const title = info.title ?? "Subagent"
+
+  if (deps.sessions.has(sessionId) || deps.pendingSessions.has(sessionId)) {
+    log("[tmux-session-manager] session already tracked or pending", { sessionId })
+    return
+  }
+
+  if (!deps.sourcePaneId) {
+    log("[tmux-session-manager] no source pane id")
+    return
+  }
+
+  deps.pendingSessions.add(sessionId)
+
+  try {
+    const state = await queryWindowState(deps.sourcePaneId)
+    if (!state) {
+      log("[tmux-session-manager] failed to query window state")
+      return
+    }
+
+    log("[tmux-session-manager] window state queried", {
+      windowWidth: state.windowWidth,
+      mainPane: state.mainPane?.paneId,
+      agentPaneCount: state.agentPanes.length,
+      agentPanes: state.agentPanes.map((p) => p.paneId),
+    })
+
+    const decision = decideSpawnActions(
+      state,
+      sessionId,
+      title,
+      deps.getCapacityConfig(),
+      deps.getSessionMappings(),
+    )
+
+    log("[tmux-session-manager] spawn decision", {
+      canSpawn: decision.canSpawn,
+      reason: decision.reason,
+      actionCount: decision.actions.length,
+      actions: decision.actions.map((a) => {
+        if (a.type === "close") return { type: "close", paneId: a.paneId }
+        if (a.type === "replace") {
+          return { type: "replace", paneId: a.paneId, newSessionId: a.newSessionId }
+        }
+        return { type: "spawn", sessionId: a.sessionId }
+      }),
+    })
+
+    if (!decision.canSpawn) {
+      log("[tmux-session-manager] cannot spawn", { reason: decision.reason })
+      return
+    }
+
+    const result = await executeActions(decision.actions, {
+      config: deps.tmuxConfig,
+      serverUrl: deps.serverUrl,
+      windowState: state,
+    })
+
+    for (const { action, result: actionResult } of result.results) {
+      if (action.type === "close" && actionResult.success) {
+        deps.sessions.delete(action.sessionId)
+        log("[tmux-session-manager] removed closed session from cache", {
+          sessionId: action.sessionId,
+        })
+      }
+      if (action.type === "replace" && actionResult.success) {
+        deps.sessions.delete(action.oldSessionId)
+        log("[tmux-session-manager] removed replaced session from cache", {
+          oldSessionId: action.oldSessionId,
+          newSessionId: action.newSessionId,
+        })
+      }
+    }
+
+    if (!result.success || !result.spawnedPaneId) {
+      log("[tmux-session-manager] spawn failed", {
+        success: result.success,
+        results: result.results.map((r) => ({
+          type: r.action.type,
+          success: r.result.success,
+          error: r.result.error,
+        })),
+      })
+      return
+    }
+
+    const sessionReady = await deps.waitForSessionReady(sessionId)
+    if (!sessionReady) {
+      log("[tmux-session-manager] session not ready after timeout, closing spawned pane", {
+        sessionId,
+        paneId: result.spawnedPaneId,
+      })
+
+      await executeActions(
+        [{ type: "close", paneId: result.spawnedPaneId, sessionId }],
+        {
+          config: deps.tmuxConfig,
+          serverUrl: deps.serverUrl,
+          windowState: state,
+        },
+      )
+
+      return
+    }
+
+    deps.sessions.set(
+      sessionId,
+      createTrackedSession({
+        sessionId,
+        paneId: result.spawnedPaneId,
+        description: title,
+      }),
+    )
+
+    log("[tmux-session-manager] pane spawned and tracked", {
+      sessionId,
+      paneId: result.spawnedPaneId,
+      sessionReady,
+    })
+
+    deps.startPolling()
+  } finally {
+    deps.pendingSessions.delete(sessionId)
+  }
+}

package/src/features/tmux-subagent/session-deleted-handler.ts

@@ -1,50 +1,50 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { TrackedSession } from "./types"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { decideCloseAction, type SessionMapping } from "./decision-engine"
-import { executeAction } from "./action-executor"
-
-export interface SessionDeletedHandlerDeps {
-  tmuxConfig: TmuxConfig
-  serverUrl: string
-  sourcePaneId: string | undefined
-  sessions: Map<string, TrackedSession>
-  isEnabled: () => boolean
-  getSessionMappings: () => SessionMapping[]
-  stopPolling: () => void
-}
-
-export async function handleSessionDeleted(
-  deps: SessionDeletedHandlerDeps,
-  event: { sessionID: string },
-): Promise<void> {
-  if (!deps.isEnabled()) return
-  if (!deps.sourcePaneId) return
-
-  const tracked = deps.sessions.get(event.sessionID)
-  if (!tracked) return
-
-  log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID })
-
-  const state = await queryWindowState(deps.sourcePaneId)
-  if (!state) {
-    deps.sessions.delete(event.sessionID)
-    return
-  }
-
-  const closeAction = decideCloseAction(state, event.sessionID, deps.getSessionMappings())
-  if (closeAction) {
-    await executeAction(closeAction, {
-      config: deps.tmuxConfig,
-      serverUrl: deps.serverUrl,
-      windowState: state,
-    })
-  }
-
-  deps.sessions.delete(event.sessionID)
-
-  if (deps.sessions.size === 0) {
-    deps.stopPolling()
-  }
-}
+import type { TmuxConfig } from "../../config/schema"
+import type { TrackedSession } from "./types"
+import { log } from "../../shared"
+import { queryWindowState } from "./pane-state-querier"
+import { decideCloseAction, type SessionMapping } from "./decision-engine"
+import { executeAction } from "./action-executor"
+
+export interface SessionDeletedHandlerDeps {
+  tmuxConfig: TmuxConfig
+  serverUrl: string
+  sourcePaneId: string | undefined
+  sessions: Map<string, TrackedSession>
+  isEnabled: () => boolean
+  getSessionMappings: () => SessionMapping[]
+  stopPolling: () => void
+}
+
+export async function handleSessionDeleted(
+  deps: SessionDeletedHandlerDeps,
+  event: { sessionID: string },
+): Promise<void> {
+  if (!deps.isEnabled()) return
+  if (!deps.sourcePaneId) return
+
+  const tracked = deps.sessions.get(event.sessionID)
+  if (!tracked) return
+
+  log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID })
+
+  const state = await queryWindowState(deps.sourcePaneId)
+  if (!state) {
+    deps.sessions.delete(event.sessionID)
+    return
+  }
+
+  const closeAction = decideCloseAction(state, event.sessionID, deps.getSessionMappings())
+  if (closeAction) {
+    await executeAction(closeAction, {
+      config: deps.tmuxConfig,
+      serverUrl: deps.serverUrl,
+      windowState: state,
+    })
+  }
+
+  deps.sessions.delete(event.sessionID)
+
+  if (deps.sessions.size === 0) {
+    deps.stopPolling()
+  }
+}

package/src/features/tmux-subagent/session-message-count.ts

@@ -1,3 +1,3 @@
-export function getMessageCount(data: unknown): number {
-  return Array.isArray(data) ? data.length : 0
-}
+export function getMessageCount(data: unknown): number {
+  return Array.isArray(data) ? data.length : 0
+}

package/src/features/tmux-subagent/session-ready-waiter.ts

@@ -1,44 +1,44 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  SESSION_READY_POLL_INTERVAL_MS,
-  SESSION_READY_TIMEOUT_MS,
-} from "../../shared/tmux"
-import { log } from "../../shared"
-import { parseSessionStatusMap } from "./session-status-parser"
-
-type OpencodeClient = PluginInput["client"]
-
-export async function waitForSessionReady(params: {
-  client: OpencodeClient
-  sessionId: string
-}): Promise<boolean> {
-  const startTime = Date.now()
-
-  while (Date.now() - startTime < SESSION_READY_TIMEOUT_MS) {
-    try {
-      const statusResult = await params.client.session.status({ path: undefined })
-      const allStatuses = parseSessionStatusMap(statusResult.data)
-
-      if (allStatuses[params.sessionId]) {
-        log("[tmux-session-manager] session ready", {
-          sessionId: params.sessionId,
-          status: allStatuses[params.sessionId].type,
-          waitedMs: Date.now() - startTime,
-        })
-        return true
-      }
-    } catch (error) {
-      log("[tmux-session-manager] session status check error", { error: String(error) })
-    }
-
-    await new Promise<void>((resolve) => {
-      setTimeout(resolve, SESSION_READY_POLL_INTERVAL_MS)
-    })
-  }
-
-  log("[tmux-session-manager] session ready timeout", {
-    sessionId: params.sessionId,
-    timeoutMs: SESSION_READY_TIMEOUT_MS,
-  })
-  return false
-}
+import type { PluginInput } from "@opencode-ai/plugin"
+import {
+  SESSION_READY_POLL_INTERVAL_MS,
+  SESSION_READY_TIMEOUT_MS,
+} from "../../shared/tmux"
+import { log } from "../../shared"
+import { parseSessionStatusMap } from "./session-status-parser"
+
+type OpencodeClient = PluginInput["client"]
+
+export async function waitForSessionReady(params: {
+  client: OpencodeClient
+  sessionId: string
+}): Promise<boolean> {
+  const startTime = Date.now()
+
+  while (Date.now() - startTime < SESSION_READY_TIMEOUT_MS) {
+    try {
+      const statusResult = await params.client.session.status({ path: undefined })
+      const allStatuses = parseSessionStatusMap(statusResult.data)
+
+      if (allStatuses[params.sessionId]) {
+        log("[tmux-session-manager] session ready", {
+          sessionId: params.sessionId,
+          status: allStatuses[params.sessionId].type,
+          waitedMs: Date.now() - startTime,
+        })
+        return true
+      }
+    } catch (error) {
+      log("[tmux-session-manager] session status check error", { error: String(error) })
+    }
+
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, SESSION_READY_POLL_INTERVAL_MS)
+    })
+  }
+
+  log("[tmux-session-manager] session ready timeout", {
+    sessionId: params.sessionId,
+    timeoutMs: SESSION_READY_TIMEOUT_MS,
+  })
+  return false
+}

package/src/features/tmux-subagent/session-status-parser.ts

@@ -1,17 +1,17 @@
-type SessionStatus = { type: string }
-
-export function parseSessionStatusMap(data: unknown): Record<string, SessionStatus> {
-  if (typeof data !== "object" || data === null) return {}
-  const record = data as Record<string, unknown>
-
-  const result: Record<string, SessionStatus> = {}
-  for (const [sessionId, value] of Object.entries(record)) {
-    if (typeof value !== "object" || value === null) continue
-    const valueRecord = value as Record<string, unknown>
-    const type = valueRecord["type"]
-    if (typeof type !== "string") continue
-    result[sessionId] = { type }
-  }
-
-  return result
-}
+type SessionStatus = { type: string }
+
+export function parseSessionStatusMap(data: unknown): Record<string, SessionStatus> {
+  if (typeof data !== "object" || data === null) return {}
+  const record = data as Record<string, unknown>
+
+  const result: Record<string, SessionStatus> = {}
+  for (const [sessionId, value] of Object.entries(record)) {
+    if (typeof value !== "object" || value === null) continue
+    const valueRecord = value as Record<string, unknown>
+    const type = valueRecord["type"]
+    if (typeof type !== "string") continue
+    result[sessionId] = { type }
+  }
+
+  return result
+}