@brimveyn/aimux 1.22.4 → 1.22.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.22.4",
+  "version": "1.22.5",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode, Kimi side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",

package/src/git/worktree.ts

@@ -206,7 +206,7 @@ export async function removeGitWorktree({
   force: boolean
 }): Promise<void> {
   if (!isInsideAimuxWorktreeRoot(targetPath)) {
-    throw new Error(`refusing to delete worktree outside Aimux temp root: ${targetPath}`)
+    throw new Error(`refusing to delete worktree outside Aimux worktree root: ${targetPath}`)
   }
   const result = force
     ? await $`git -C ${repoPath} worktree remove --force ${targetPath}`.quiet().nothrow()

package/src/platform/play-sound.ts

@@ -141,6 +141,7 @@ function findPlayer(platform: string): string | null {
 }
 
 let lastPlayedAt = 0
+let playing: { kill: () => void } | null = null
 
 /**
  * Whether enough time has passed since the last sound. Separate from the play
@@ -151,16 +152,17 @@ export function shouldPlayNow(now: number, previous: number): boolean {
 }
 
 /**
- * Play a sound file. Returns whether a player was actually spawned, which is
- * what the settings screen's "Test sound" row reports.
+ * Play a sound file. Returns false only when nothing could play at all — a
+ * missing player or a failed spawn — which is what the settings screen's "Test
+ * sound" row reports. A throttled call is not a failure.
+ *
+ * The throttle covers every caller, the test row included: held down, its key
+ * repeats tens of times a second, and one live player per press is enough to
+ * take CoreAudio down with it.
  */
-export function playSoundFile(
-  path: string,
-  options?: { ignoreThrottle?: boolean; volume?: number }
-): boolean {
+export function playSoundFile(path: string, options?: { volume?: number }): boolean {
   const now = Date.now()
-  const throttled = options?.ignoreThrottle !== true
-  if (throttled && !shouldPlayNow(now, lastPlayedAt)) return false
+  if (!shouldPlayNow(now, lastPlayedAt)) return true
   const platform = process.platform
   const bin = findPlayer(platform)
   if (bin == null) {
@@ -169,10 +171,11 @@ export function playSoundFile(
   }
   const argv = soundPlayerArgv(platform, bin, path, options?.volume ?? DEFAULT_VOLUME)
   try {
-    Bun.spawn(argv, { stderr: 'ignore', stdin: 'ignore', stdout: 'ignore' })
-    // A test press does not start the window: it would swallow a real
-    // notification arriving in the next few hundred milliseconds.
-    if (throttled) lastPlayedAt = now
+    // Cut the previous one rather than layer on top of it. Players come and go
+    // on their own, so killing an already-exited one has to be harmless.
+    playing?.kill()
+    playing = Bun.spawn(argv, { stderr: 'ignore', stdin: 'ignore', stdout: 'ignore' })
+    lastPlayedAt = now
     return true
   } catch (error) {
     logDebug('platform.playSound.error', {

package/src/platform/worktree-paths.ts

@@ -2,12 +2,23 @@ import { createHash } from 'node:crypto'
 import { lstat, mkdir, realpath, rmdir } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
 
-const DEFAULT_WORKTREE_ROOT = '/tmp/aimux-wt'
+// Worktrees hold uncommitted work, so they live in the XDG data dir, not /tmp:
+// a reboot clears /tmp on macOS and on most Linux distros, and took the work
+// with it. The old root stays recognized (never generated) so worktrees created
+// before this change are still classified and deleted as aimux-managed.
+const LEGACY_WORKTREE_ROOT = '/tmp/aimux-wt'
 const MAX_SLUG_LENGTH = 24
 
+function defaultWorktreeRoot(): string {
+  const xdgData = process.env.XDG_DATA_HOME
+  const base =
+    xdgData != null && xdgData !== '' ? xdgData : join(process.env.HOME ?? '.', '.local', 'share')
+  return join(base, 'aimux', 'worktrees')
+}
+
 export function getAimuxWorktreeRoot(): string {
   const root = process.env.AIMUX_WORKTREE_ROOT
-  return root != null && root !== '' ? root : DEFAULT_WORKTREE_ROOT
+  return root != null && root !== '' ? root : defaultWorktreeRoot()
 }
 
 export function sanitizePathSegment(input: string, maxLength = MAX_SLUG_LENGTH): string {
@@ -42,9 +53,10 @@ export function makeWorktreePath({
 
 export function isInsideAimuxWorktreeRoot(path: string): boolean {
   const normalizeTmp = (value: string) => value.replace(/^\/private\/tmp(?=\/|$)/, '/tmp')
-  const root = `${normalizeTmp(resolve(getAimuxWorktreeRoot()))}/`
   const target = `${normalizeTmp(resolve(path))}/`
-  return target.startsWith(root)
+  return [getAimuxWorktreeRoot(), LEGACY_WORKTREE_ROOT].some((root) =>
+    target.startsWith(`${normalizeTmp(resolve(root))}/`)
+  )
 }
 
 export async function ensureAimuxWorktreeRoot(): Promise<string> {
@@ -80,13 +92,13 @@ export async function pruneEmptyWorktreeParent(worktreePath: string): Promise<vo
 export async function assertSafeAimuxWorktreePath(path: string): Promise<void> {
   const root = await ensureAimuxWorktreeRoot()
   if (!isInsideAimuxWorktreeRoot(path)) {
-    throw new Error(`refusing worktree path outside Aimux temp root: ${path}`)
+    throw new Error(`refusing worktree path outside Aimux worktree root: ${path}`)
   }
   // Create the repo-scoped parent (<root>/r-<hash>) before resolving it: git
   // worktree add does not create intermediate dirs, and realpath() would throw
   // ENOENT on the first worktree for a repo. mkdir(recursive) leaves an
   // existing symlink in place, so the realpath check below still catches an
-  // escape out of the temp root.
+  // escape out of the worktree root.
   const parent = resolve(path, '..')
   await mkdir(parent, { recursive: true })
   const realRoot = await realpath(root)

package/src/settings/sections/notifications.ts

@@ -45,10 +45,10 @@ function selectedVolume(): number {
  * user has set the row to `off`, which is what makes it safe to call on every
  * status edge.
  */
-export function playNotificationSound(options?: { ignoreThrottle?: boolean }): boolean {
+export function playNotificationSound(): boolean {
   const path = resolveSoundPath(selectedSoundId())
   if (path == null) return false
-  return playSoundFile(path, { ...options, volume: selectedVolume() })
+  return playSoundFile(path, { volume: selectedVolume() })
 }
 
 export const NOTIFICATIONS_SECTION: SettingSection = {
@@ -89,7 +89,7 @@ export const NOTIFICATIONS_SECTION: SettingSection = {
           toast.info('Notification sound is off')
           return
         }
-        if (!playNotificationSound({ ignoreThrottle: true })) {
+        if (!playNotificationSound()) {
           toast.error('Could not play that sound — no audio player found')
         }
       },