opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/hooks/session-notification.test.ts

@@ -1,361 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach, spyOn } from "bun:test"
-
-import { createSessionNotification } from "./session-notification"
-import { setMainSession, subagentSessions, _resetForTesting } from "../features/claude-code-session-state"
-import * as utils from "./session-notification-utils"
-
-describe("session-notification", () => {
-  let notificationCalls: string[]
-
-  function createMockPluginInput() {
-    return {
-      $: async (cmd: TemplateStringsArray | string, ...values: any[]) => {
-        // #given - track notification commands (osascript, notify-send, powershell)
-        const cmdStr = typeof cmd === "string" 
-          ? cmd 
-          : cmd.reduce((acc, part, i) => acc + part + (values[i] ?? ""), "")
-        
-        if (cmdStr.includes("osascript") || cmdStr.includes("notify-send") || cmdStr.includes("powershell")) {
-          notificationCalls.push(cmdStr)
-        }
-        return { stdout: "", stderr: "", exitCode: 0 }
-      },
-      client: {
-        session: {
-          todo: async () => ({ data: [] }),
-        },
-      },
-      directory: "/tmp/test",
-    } as any
-  }
-
-  beforeEach(() => {
-    _resetForTesting()
-    notificationCalls = []
-    
-    spyOn(utils, "getOsascriptPath").mockResolvedValue("/usr/bin/osascript")
-    spyOn(utils, "getNotifySendPath").mockResolvedValue("/usr/bin/notify-send")
-    spyOn(utils, "getPowershellPath").mockResolvedValue("powershell")
-    spyOn(utils, "getAfplayPath").mockResolvedValue("/usr/bin/afplay")
-    spyOn(utils, "getPaplayPath").mockResolvedValue("/usr/bin/paplay")
-    spyOn(utils, "getAplayPath").mockResolvedValue("/usr/bin/aplay")
-    spyOn(utils, "startBackgroundCheck").mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    // #given - cleanup after each test
-    subagentSessions.clear()
-    setMainSession(undefined)
-  })
-
-  test("should not trigger notification for subagent session", async () => {
-    // #given - a subagent session exists
-    const subagentSessionID = "subagent-123"
-    subagentSessions.add(subagentSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 0,
-    })
-
-    // #when - subagent session goes idle
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: subagentSessionID },
-      },
-    })
-
-    // Wait for any pending timers
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - notification should NOT be sent
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should not trigger notification when mainSessionID is set and session is not main", async () => {
-    // #given - main session is set, but a different session goes idle
-    const mainSessionID = "main-123"
-    const otherSessionID = "other-456"
-    setMainSession(mainSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 0,
-    })
-
-    // #when - non-main session goes idle
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: otherSessionID },
-      },
-    })
-
-    // Wait for any pending timers
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - notification should NOT be sent
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should trigger notification for main session when idle", async () => {
-    // #given - main session is set
-    const mainSessionID = "main-789"
-    setMainSession(mainSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 10,
-      skipIfIncompleteTodos: false,
-    })
-
-    // #when - main session goes idle
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    // Wait for idle confirmation delay + buffer
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    // #then - notification should be sent
-    expect(notificationCalls.length).toBeGreaterThanOrEqual(1)
-  })
-
-  test("should skip notification for subagent even when mainSessionID is set", async () => {
-    // #given - both mainSessionID and subagent session exist
-    const mainSessionID = "main-999"
-    const subagentSessionID = "subagent-888"
-    setMainSession(mainSessionID)
-    subagentSessions.add(subagentSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 0,
-    })
-
-    // #when - subagent session goes idle
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: subagentSessionID },
-      },
-    })
-
-    // Wait for any pending timers
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - notification should NOT be sent (subagent check takes priority)
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should handle subagentSessions and mainSessionID checks in correct order", async () => {
-    // #given - main session and subagent session exist
-    const mainSessionID = "main-111"
-    const subagentSessionID = "subagent-222"
-    const unknownSessionID = "unknown-333"
-    setMainSession(mainSessionID)
-    subagentSessions.add(subagentSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 0,
-    })
-
-    // #when - subagent session goes idle
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: subagentSessionID },
-      },
-    })
-
-    // #when - unknown session goes idle (not main, not in subagentSessions)
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: unknownSessionID },
-      },
-    })
-
-    // Wait for any pending timers
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - no notifications (subagent blocked by subagentSessions, unknown blocked by mainSessionID check)
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should cancel pending notification on session activity", async () => {
-    // #given - main session is set
-    const mainSessionID = "main-cancel"
-    setMainSession(mainSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 100, // Long delay
-      skipIfIncompleteTodos: false,
-    })
-
-    // #when - session goes idle
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    // #when - activity happens before delay completes
-    await hook({
-      event: {
-        type: "tool.execute.before",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    // Wait for original delay to pass
-    await new Promise((resolve) => setTimeout(resolve, 150))
-
-    // #then - notification should NOT be sent (cancelled by activity)
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should handle session.created event without notification", async () => {
-    // #given - a new session is created
-    const hook = createSessionNotification(createMockPluginInput(), {})
-
-    // #when - session.created event fires
-    await hook({
-      event: {
-        type: "session.created",
-        properties: {
-          info: { id: "new-session", title: "Test Session" },
-        },
-      },
-    })
-
-    // Wait for any pending timers
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - no notification should be triggered
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should handle session.deleted event and cleanup state", async () => {
-    // #given - a session exists
-    const hook = createSessionNotification(createMockPluginInput(), {})
-
-    // #when - session.deleted event fires
-    await hook({
-      event: {
-        type: "session.deleted",
-        properties: {
-          info: { id: "deleted-session" },
-        },
-      },
-    })
-
-    // Wait for any pending timers
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - no notification should be triggered
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should mark session activity on message.updated event", async () => {
-    // #given - main session is set
-    const mainSessionID = "main-message"
-    setMainSession(mainSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 50,
-      skipIfIncompleteTodos: false,
-    })
-
-    // #when - session goes idle, then message.updated fires
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    await hook({
-      event: {
-        type: "message.updated",
-        properties: {
-          info: { sessionID: mainSessionID, role: "user", finish: false },
-        },
-      },
-    })
-
-    // Wait for idle delay to pass
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    // #then - notification should NOT be sent (activity cancelled it)
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should mark session activity on tool.execute.before event", async () => {
-    // #given - main session is set
-    const mainSessionID = "main-tool"
-    setMainSession(mainSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 50,
-      skipIfIncompleteTodos: false,
-    })
-
-    // #when - session goes idle, then tool.execute.before fires
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    await hook({
-      event: {
-        type: "tool.execute.before",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    // Wait for idle delay to pass
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    // #then - notification should NOT be sent (activity cancelled it)
-    expect(notificationCalls).toHaveLength(0)
-  })
-
-  test("should not send duplicate notification for same session", async () => {
-    // #given - main session is set
-    const mainSessionID = "main-dup"
-    setMainSession(mainSessionID)
-
-    const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 10,
-      skipIfIncompleteTodos: false,
-    })
-
-    // #when - session goes idle twice
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    // Wait for first notification
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    await hook({
-      event: {
-        type: "session.idle",
-        properties: { sessionID: mainSessionID },
-      },
-    })
-
-    // Wait for second potential notification
-    await new Promise((resolve) => setTimeout(resolve, 50))
-
-    // #then - only one notification should be sent
-    expect(notificationCalls).toHaveLength(1)
-  })
-})

package/oh-my-opencode/src/hooks/session-notification.ts

@@ -1,330 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { platform } from "os"
-import { subagentSessions, getMainSessionID } from "../features/claude-code-session-state"
-import {
-  getOsascriptPath,
-  getNotifySendPath,
-  getPowershellPath,
-  getAfplayPath,
-  getPaplayPath,
-  getAplayPath,
-  startBackgroundCheck,
-} from "./session-notification-utils"
-
-interface Todo {
-  content: string
-  status: string
-  priority: string
-  id: string
-}
-
-interface SessionNotificationConfig {
-  title?: string
-  message?: string
-  playSound?: boolean
-  soundPath?: string
-  /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
-  idleConfirmationDelay?: number
-  /** Skip notification if there are incomplete todos (default: true) */
-  skipIfIncompleteTodos?: boolean
-  /** Maximum number of sessions to track before cleanup (default: 100) */
-  maxTrackedSessions?: number
-}
-
-type Platform = "darwin" | "linux" | "win32" | "unsupported"
-
-function detectPlatform(): Platform {
-  const p = platform()
-  if (p === "darwin" || p === "linux" || p === "win32") return p
-  return "unsupported"
-}
-
-function getDefaultSoundPath(p: Platform): string {
-  switch (p) {
-    case "darwin":
-      return "/System/Library/Sounds/Glass.aiff"
-    case "linux":
-      return "/usr/share/sounds/freedesktop/stereo/complete.oga"
-    case "win32":
-      return "C:\\Windows\\Media\\notify.wav"
-    default:
-      return ""
-  }
-}
-
-async function sendNotification(
-  ctx: PluginInput,
-  p: Platform,
-  title: string,
-  message: string
-): Promise<void> {
-  switch (p) {
-    case "darwin": {
-      const osascriptPath = await getOsascriptPath()
-      if (!osascriptPath) return
-
-      const esTitle = title.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
-      const esMessage = message.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
-      await ctx.$`${osascriptPath} -e ${"display notification \"" + esMessage + "\" with title \"" + esTitle + "\""}`.catch(() => {})
-      break
-    }
-    case "linux": {
-      const notifySendPath = await getNotifySendPath()
-      if (!notifySendPath) return
-
-      await ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`.catch(() => {})
-      break
-    }
-    case "win32": {
-      const powershellPath = await getPowershellPath()
-      if (!powershellPath) return
-
-      const psTitle = title.replace(/'/g, "''")
-      const psMessage = message.replace(/'/g, "''")
-      const toastScript = `
-[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
-$Template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
-$RawXml = [xml] $Template.GetXml()
-($RawXml.toast.visual.binding.text | Where-Object {$_.id -eq '1'}).AppendChild($RawXml.CreateTextNode('${psTitle}')) | Out-Null
-($RawXml.toast.visual.binding.text | Where-Object {$_.id -eq '2'}).AppendChild($RawXml.CreateTextNode('${psMessage}')) | Out-Null
-$SerializedXml = New-Object Windows.Data.Xml.Dom.XmlDocument
-$SerializedXml.LoadXml($RawXml.OuterXml)
-$Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
-$Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('OpenCode')
-$Notifier.Show($Toast)
-`.trim().replace(/\n/g, "; ")
-      await ctx.$`${powershellPath} -Command ${toastScript}`.catch(() => {})
-      break
-    }
-  }
-}
-
-async function playSound(ctx: PluginInput, p: Platform, soundPath: string): Promise<void> {
-  switch (p) {
-    case "darwin": {
-      const afplayPath = await getAfplayPath()
-      if (!afplayPath) return
-      ctx.$`${afplayPath} ${soundPath}`.catch(() => {})
-      break
-    }
-    case "linux": {
-      const paplayPath = await getPaplayPath()
-      if (paplayPath) {
-        ctx.$`${paplayPath} ${soundPath} 2>/dev/null`.catch(() => {})
-      } else {
-        const aplayPath = await getAplayPath()
-        if (aplayPath) {
-          ctx.$`${aplayPath} ${soundPath} 2>/dev/null`.catch(() => {})
-        }
-      }
-      break
-    }
-    case "win32": {
-      const powershellPath = await getPowershellPath()
-      if (!powershellPath) return
-      ctx.$`${powershellPath} -Command ${"(New-Object Media.SoundPlayer '" + soundPath.replace(/'/g, "''") + "').PlaySync()"}`.catch(() => {})
-      break
-    }
-  }
-}
-
-async function hasIncompleteTodos(ctx: PluginInput, sessionID: string): Promise<boolean> {
-  try {
-    const response = await ctx.client.session.todo({ path: { id: sessionID } })
-    const todos = (response.data ?? response) as Todo[]
-    if (!todos || todos.length === 0) return false
-    return todos.some((t) => t.status !== "completed" && t.status !== "cancelled")
-  } catch {
-    return false
-  }
-}
-
-export function createSessionNotification(
-  ctx: PluginInput,
-  config: SessionNotificationConfig = {}
-) {
-  const currentPlatform = detectPlatform()
-  const defaultSoundPath = getDefaultSoundPath(currentPlatform)
-
-  startBackgroundCheck(currentPlatform)
-
-  const mergedConfig = {
-    title: "OpenCode",
-    message: "Agent is ready for input",
-    playSound: false,
-    soundPath: defaultSoundPath,
-    idleConfirmationDelay: 1500,
-    skipIfIncompleteTodos: true,
-    maxTrackedSessions: 100,
-    ...config,
-  }
-
-  const notifiedSessions = new Set<string>()
-  const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>()
-  const sessionActivitySinceIdle = new Set<string>()
-  // Track notification execution version to handle race conditions
-  const notificationVersions = new Map<string, number>()
-  // Track sessions currently executing notification (prevents duplicate execution)
-  const executingNotifications = new Set<string>()
-
-  function cleanupOldSessions() {
-    const maxSessions = mergedConfig.maxTrackedSessions
-    if (notifiedSessions.size > maxSessions) {
-      const sessionsToRemove = Array.from(notifiedSessions).slice(0, notifiedSessions.size - maxSessions)
-      sessionsToRemove.forEach(id => notifiedSessions.delete(id))
-    }
-    if (sessionActivitySinceIdle.size > maxSessions) {
-      const sessionsToRemove = Array.from(sessionActivitySinceIdle).slice(0, sessionActivitySinceIdle.size - maxSessions)
-      sessionsToRemove.forEach(id => sessionActivitySinceIdle.delete(id))
-    }
-    if (notificationVersions.size > maxSessions) {
-      const sessionsToRemove = Array.from(notificationVersions.keys()).slice(0, notificationVersions.size - maxSessions)
-      sessionsToRemove.forEach(id => notificationVersions.delete(id))
-    }
-    if (executingNotifications.size > maxSessions) {
-      const sessionsToRemove = Array.from(executingNotifications).slice(0, executingNotifications.size - maxSessions)
-      sessionsToRemove.forEach(id => executingNotifications.delete(id))
-    }
-  }
-
-  function cancelPendingNotification(sessionID: string) {
-    const timer = pendingTimers.get(sessionID)
-    if (timer) {
-      clearTimeout(timer)
-      pendingTimers.delete(sessionID)
-    }
-    sessionActivitySinceIdle.add(sessionID)
-    // Increment version to invalidate any in-flight notifications
-    notificationVersions.set(sessionID, (notificationVersions.get(sessionID) ?? 0) + 1)
-  }
-
-  function markSessionActivity(sessionID: string) {
-    cancelPendingNotification(sessionID)
-    notifiedSessions.delete(sessionID)
-  }
-
-  async function executeNotification(sessionID: string, version: number) {
-    if (executingNotifications.has(sessionID)) {
-      pendingTimers.delete(sessionID)
-      return
-    }
-
-    if (notificationVersions.get(sessionID) !== version) {
-      pendingTimers.delete(sessionID)
-      return
-    }
-
-    if (sessionActivitySinceIdle.has(sessionID)) {
-      sessionActivitySinceIdle.delete(sessionID)
-      pendingTimers.delete(sessionID)
-      return
-    }
-
-    if (notifiedSessions.has(sessionID)) {
-      pendingTimers.delete(sessionID)
-      return
-    }
-
-    executingNotifications.add(sessionID)
-    try {
-      if (mergedConfig.skipIfIncompleteTodos) {
-        const hasPendingWork = await hasIncompleteTodos(ctx, sessionID)
-        if (notificationVersions.get(sessionID) !== version) {
-          return
-        }
-        if (hasPendingWork) return
-      }
-
-      if (notificationVersions.get(sessionID) !== version) {
-        return
-      }
-
-      if (sessionActivitySinceIdle.has(sessionID)) {
-        sessionActivitySinceIdle.delete(sessionID)
-        return
-      }
-
-      notifiedSessions.add(sessionID)
-
-      await sendNotification(ctx, currentPlatform, mergedConfig.title, mergedConfig.message)
-
-      if (mergedConfig.playSound && mergedConfig.soundPath) {
-        await playSound(ctx, currentPlatform, mergedConfig.soundPath)
-      }
-    } finally {
-      executingNotifications.delete(sessionID)
-      pendingTimers.delete(sessionID)
-    }
-  }
-
-  return async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    if (currentPlatform === "unsupported") return
-
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.updated" || event.type === "session.created") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = info?.id as string | undefined
-      if (sessionID) {
-        markSessionActivity(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID as string | undefined
-      if (!sessionID) return
-
-      if (subagentSessions.has(sessionID)) return
-
-      // Only trigger notifications for the main session (not subagent sessions)
-      const mainSessionID = getMainSessionID()
-      if (mainSessionID && sessionID !== mainSessionID) return
-
-      if (notifiedSessions.has(sessionID)) return
-      if (pendingTimers.has(sessionID)) return
-      if (executingNotifications.has(sessionID)) return
-
-      sessionActivitySinceIdle.delete(sessionID)
-      
-      const currentVersion = (notificationVersions.get(sessionID) ?? 0) + 1
-      notificationVersions.set(sessionID, currentVersion)
-
-      const timer = setTimeout(() => {
-        executeNotification(sessionID, currentVersion)
-      }, mergedConfig.idleConfirmationDelay)
-
-      pendingTimers.set(sessionID, timer)
-      cleanupOldSessions()
-      return
-    }
-
-    if (event.type === "message.updated" || event.type === "message.created") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = info?.sessionID as string | undefined
-      if (sessionID) {
-        markSessionActivity(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
-      const sessionID = props?.sessionID as string | undefined
-      if (sessionID) {
-        markSessionActivity(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        cancelPendingNotification(sessionInfo.id)
-        notifiedSessions.delete(sessionInfo.id)
-        sessionActivitySinceIdle.delete(sessionInfo.id)
-        notificationVersions.delete(sessionInfo.id)
-        executingNotifications.delete(sessionInfo.id)
-      }
-    }
-  }
-}

package/oh-my-opencode/src/hooks/session-recovery/constants.ts

@@ -1,10 +0,0 @@
-import { join } from "node:path"
-import { getOpenCodeStorageDir } from "../../shared/data-path"
-
-export const OPENCODE_STORAGE = getOpenCodeStorageDir()
-export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
-export const PART_STORAGE = join(OPENCODE_STORAGE, "part")
-
-export const THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"])
-export const META_TYPES = new Set(["step-start", "step-finish"])
-export const CONTENT_TYPES = new Set(["text", "tool", "tool_use", "tool_result"])