Updates

Author: Sg312

apps/desktop/package.json

@@ -18,6 +18,7 @@
     "start": "electron .",
     "package:dir": "bun run build && electron-builder --mac dir --publish never",
     "package:mac": "bun run build && electron-builder --mac --publish never",
+    "install:local": "bun run scripts/install-local.ts",
     "type-check": "tsc --noEmit",
     "lint": "biome check --write --unsafe .",
     "lint:check": "biome check .",

apps/desktop/scripts/install-local.ts

@@ -0,0 +1,126 @@
+/**
+ * Local dev-install: packages the app from the current checkout and replaces
+ * /Applications/Sim.app with it — the "run it like a real Mac app" loop
+ * before official distribution. Signing/notarization are not involved; the
+ * locally built app never carries a quarantine flag, so Gatekeeper doesn't
+ * mind.
+ *
+ *   bun run install:local              # build → install → open (origin unchanged)
+ *   bun run install:local --local      # …pointed at http://localhost:3000
+ *   bun run install:local --dev        # …pointed at https://www.dev.sim.ai
+ *   bun run install:local --staging    # …pointed at https://www.staging.sim.ai
+ *   bun run install:local --prod       # …pointed at https://www.sim.ai
+ *   bun run install:local --no-open    # build → install only
+ *
+ * The origin flag writes the app's persisted settings (same as changing the
+ * server URL in Settings), so it survives relaunches; each origin keeps its
+ * own isolated session partition. A running installed copy is quit before
+ * replacing. Note the installed app and `bun run dev` share the same profile
+ * and single-instance lock, so only one can run at a time.
+ */
+import { execFileSync, spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+const APP_NAME = 'Sim.app'
+const INSTALL_PATH = `/Applications/${APP_NAME}`
+const RELEASE_DIRS = ['release/mac-universal', 'release/mac-arm64', 'release/mac']
+/** Matches the app's userData path (app.setName('Sim') in src/main/index.ts). */
+const SETTINGS_PATH = join(homedir(), 'Library/Application Support/Sim/settings.json')
+
+const ORIGIN_FLAGS: Record<string, string> = {
+  '--local': 'http://localhost:3000',
+  '--dev': 'https://www.dev.sim.ai',
+  '--staging': 'https://www.staging.sim.ai',
+  '--prod': 'https://www.sim.ai',
+}
+
+function run(command: string, args: string[]): void {
+  const result = spawnSync(command, args, { stdio: 'inherit' })
+  if (result.status !== 0) {
+    console.error(`\n✖ ${command} ${args.join(' ')} failed`)
+    process.exit(result.status ?? 1)
+  }
+}
+
+function localBuildStamp(): string {
+  try {
+    const sha = execFileSync('git', ['rev-parse', '--short', 'HEAD']).toString().trim()
+    const dirty = execFileSync('git', ['status', '--porcelain']).toString().trim() ? '+dirty' : ''
+    return `${sha}${dirty}`
+  } catch {
+    return 'unknown'
+  }
+}
+
+function quitInstalledApp(): void {
+  // Match only processes launched from the installed bundle — never the dev
+  // instance running out of node_modules/electron.
+  const running = spawnSync('pgrep', ['-f', `${INSTALL_PATH}/Contents/MacOS/`]).status === 0
+  if (!running) return
+  console.log('• Quitting the running installed app…')
+  spawnSync('osascript', ['-e', 'tell application "Sim" to quit'])
+  // Poll briefly; fall back to a hard kill so the install never half-replaces
+  // a live bundle.
+  for (let i = 0; i < 20; i++) {
+    if (spawnSync('pgrep', ['-f', `${INSTALL_PATH}/Contents/MacOS/`]).status !== 0) return
+    execFileSync('sleep', ['0.25'])
+  }
+  spawnSync('pkill', ['-f', `${INSTALL_PATH}/Contents/MacOS/`])
+}
+
+/**
+ * Points the installed app at an environment by writing its persisted
+ * settings — the same field the in-app Settings window edits. Merges into the
+ * existing file so window bounds, shortcuts, etc. survive.
+ */
+function applyOrigin(origin: string): void {
+  let settings: Record<string, unknown> = {}
+  try {
+    settings = JSON.parse(readFileSync(SETTINGS_PATH, 'utf8')) as Record<string, unknown>
+  } catch {
+    // Missing or corrupt settings file — start fresh; the app validates on load.
+  }
+  settings.origin = origin
+  mkdirSync(dirname(SETTINGS_PATH), { recursive: true })
+  writeFileSync(SETTINGS_PATH, `${JSON.stringify(settings, null, 2)}\n`)
+  console.log(`• Server origin set to ${origin}`)
+  if (origin.startsWith('http://localhost')) {
+    console.log('  (make sure the sim dev server is running on :3000)')
+  }
+}
+
+const originFlags = process.argv.filter((arg) => arg in ORIGIN_FLAGS)
+if (originFlags.length > 1) {
+  console.error(`✖ Pass at most one of ${Object.keys(ORIGIN_FLAGS).join(', ')}`)
+  process.exit(1)
+}
+
+console.log('• Packaging the app from the current checkout…')
+run('bun', ['run', 'package:dir'])
+
+const builtApp = RELEASE_DIRS.map((dir) => join(dir, APP_NAME)).find(existsSync)
+if (!builtApp) {
+  console.error(`✖ No built app found under ${RELEASE_DIRS.join(', ')}`)
+  process.exit(1)
+}
+
+quitInstalledApp()
+
+console.log(`• Installing ${builtApp} → ${INSTALL_PATH}`)
+rmSync(INSTALL_PATH, { recursive: true, force: true })
+// ditto preserves the code signature and extended attributes, unlike cp.
+run('ditto', [builtApp, INSTALL_PATH])
+
+if (originFlags.length === 1) {
+  applyOrigin(ORIGIN_FLAGS[originFlags[0]])
+}
+
+console.log(`✔ Installed Sim (${localBuildStamp()}) to ${INSTALL_PATH}`)
+
+if (!process.argv.includes('--no-open')) {
+  run('open', [INSTALL_PATH])
+} else {
+  console.log(`  Launch it with: open ${INSTALL_PATH}`)
+}

apps/desktop/src/main/browser-agent/driver.ts

@@ -569,19 +569,29 @@ export async function executeTool(
 ): Promise<{ ok: boolean; result?: unknown; error?: string }> {
   const run = async () => {
     logger.info('Executing browser tool', { tool })
-    const execution = executeToolInner(tool, params)
-    const raced =
-      tool === 'browser_request_takeover'
-        ? execution
-        : Promise.race([
-            execution,
-            sleep(TOOL_WATCHDOG_MS).then(() => {
-              throw new ToolError(
-                'The browser did not finish this action in time. Take a browser_snapshot to see the current page state.'
-              )
-            }),
-          ])
-    return withNotices(await raced)
+    const keepHiddenPageActive = tool !== 'browser_request_takeover'
+    if (keepHiddenPageActive) {
+      session.setAutomationActive(true)
+    }
+    try {
+      const execution = executeToolInner(tool, params)
+      const raced =
+        tool === 'browser_request_takeover'
+          ? execution
+          : Promise.race([
+              execution,
+              sleep(TOOL_WATCHDOG_MS).then(() => {
+                throw new ToolError(
+                  'The browser did not finish this action in time. Take a browser_snapshot to see the current page state.'
+                )
+              }),
+            ])
+      return withNotices(await raced)
+    } finally {
+      if (keepHiddenPageActive) {
+        session.setAutomationActive(false)
+      }
+    }
   }
 
   const settled = toolQueue.then(run, run)

apps/desktop/src/main/browser-agent/session.test.ts

@@ -14,6 +14,7 @@ interface MockView {
     }
     setWindowOpenHandler: ReturnType<typeof vi.fn>
     loadURL: ReturnType<typeof vi.fn>
+    setBackgroundThrottling: ReturnType<typeof vi.fn>
   }
   setBounds: ReturnType<typeof vi.fn>
   setVisible: ReturnType<typeof vi.fn>
@@ -64,6 +65,17 @@ describe('browser-agent session', () => {
     expect(session.listTabs()[0]).toMatchObject({ tabId: first.id, active: true })
   })
 
+  it('only disables hidden-page throttling while browser automation is active', () => {
+    const tab = session.ensureTab()
+    const contents = (tab.view as unknown as MockView).webContents
+
+    session.setAutomationActive(true)
+    expect(contents.setBackgroundThrottling).toHaveBeenLastCalledWith(false)
+
+    session.setAutomationActive(false)
+    expect(contents.setBackgroundThrottling).toHaveBeenLastCalledWith(true)
+  })
+
   it('requireTab refuses when no page is open yet', () => {
     expect(() => session.requireTab()).toThrow(/No page is open yet/)
   })

apps/desktop/src/main/browser-agent/session.ts

@@ -47,6 +47,8 @@ let getMainWindow: () => BrowserWindow | null = () => null
 let panelBounds: BrowserPanelBounds | null = null
 let panelLeaseAt = 0
 let leaseTimer: ReturnType<typeof setInterval> | null = null
+/** Prevent hidden-page throttling only while an agent action needs the page to make progress. */
+let automationActive = false
 /** The window currently hosting the active view, for re-parenting checks. */
 let hostedWindow: BrowserWindow | null = null
 
@@ -86,9 +88,9 @@ function createTabView(): WebContentsView {
       sandbox: true,
       webSecurity: true,
       webviewTag: false,
-      // Pages keep running (timers, fetches) while the panel is hidden or
-      // covered — automation must not depend on panel visibility.
-      backgroundThrottling: false,
+      // Visible pages remain full speed. Hidden pages may be throttled unless
+      // a browser tool is actively waiting on them.
+      backgroundThrottling: !automationActive,
       spellcheck: false,
     },
   })
@@ -120,6 +122,19 @@ export function hasSession(): boolean {
   return tabs.some((tab) => !tab.view.webContents.isDestroyed())
 }
 
+/**
+ * Keeps hidden pages responsive during an agent action, then returns them to
+ * Chromium's normal background throttling so they cannot contend with Sim.
+ */
+export function setAutomationActive(active: boolean): void {
+  automationActive = active
+  for (const tab of tabs) {
+    if (!tab.view.webContents.isDestroyed()) {
+      tab.view.webContents.setBackgroundThrottling(!active)
+    }
+  }
+}
+
 /** The view currently attached to the host window (attach only on change —
  * re-adding an attached view re-stacks it and can flicker the composite). */
 let attachedView: WebContentsView | null = null

apps/desktop/src/main/config.ts

@@ -26,6 +26,11 @@ export interface DesktopSettings {
   /** Quick Ask launcher accelerator — one of the presets in shortcuts.ts, or 'disabled'. */
   launcherShortcut?: string
   trayEnabled?: boolean
+  notificationsEnabled?: boolean
+  notificationSounds?: boolean
+  notificationsOnlyWhenUnfocused?: boolean
+  launchAtLogin?: boolean
+  autoDownloadUpdates?: boolean
 }
 
 export type OriginValidation = { ok: true; origin: string } | { ok: false; error: string }
@@ -91,6 +96,11 @@ export function isSafeInternalPath(path: unknown): path is string {
 const DEFAULT_SETTINGS: DesktopSettings = {
   origin: DEFAULT_ORIGIN,
   blockThirdPartyAnalytics: true,
+  notificationsEnabled: true,
+  notificationSounds: true,
+  notificationsOnlyWhenUnfocused: true,
+  launchAtLogin: false,
+  autoDownloadUpdates: true,
 }
 
 export interface ConfigStore {

apps/desktop/src/main/desktop-settings.ts

@@ -0,0 +1,104 @@
+import type {
+  DesktopNotificationPayload,
+  DesktopPreferenceKey,
+  DesktopPreferences,
+} from '@sim/desktop-bridge'
+import type { BrowserWindow } from 'electron'
+import { app, Notification } from 'electron'
+import type { ConfigStore } from '@/main/config'
+import { isSafeInternalPath } from '@/main/config'
+
+const PREFERENCE_KEYS: ReadonlySet<string> = new Set<DesktopPreferenceKey>([
+  'notificationsEnabled',
+  'notificationSounds',
+  'notificationsOnlyWhenUnfocused',
+  'launchAtLogin',
+  'autoDownloadUpdates',
+])
+
+export function isDesktopPreferenceKey(value: unknown): value is DesktopPreferenceKey {
+  return typeof value === 'string' && PREFERENCE_KEYS.has(value)
+}
+
+export interface DesktopSettingsService {
+  getPreferences(): DesktopPreferences
+  setPreference(key: DesktopPreferenceKey, value: boolean): DesktopPreferences
+  notify(payload: DesktopNotificationPayload): boolean
+  applySystemPreferences(): void
+}
+
+interface DesktopSettingsServiceDeps {
+  config: ConfigStore
+  getMainWindow: () => BrowserWindow | null
+  openMainWindowAt: (route?: string) => void
+  setAutoDownloadUpdates: (enabled: boolean) => void
+}
+
+function readPreferences(config: ConfigStore): DesktopPreferences {
+  return {
+    notificationsEnabled: config.get('notificationsEnabled') ?? true,
+    notificationSounds: config.get('notificationSounds') ?? true,
+    notificationsOnlyWhenUnfocused: config.get('notificationsOnlyWhenUnfocused') ?? true,
+    launchAtLogin: config.get('launchAtLogin') ?? false,
+    autoDownloadUpdates: config.get('autoDownloadUpdates') ?? true,
+  }
+}
+
+/**
+ * Owns device preferences and their native side effects. Renderer code can
+ * request a change, but only this main-process service touches login items,
+ * updater policy, window focus, or OS notifications.
+ */
+export function createDesktopSettingsService(
+  deps: DesktopSettingsServiceDeps
+): DesktopSettingsService {
+  const applyLaunchAtLogin = (enabled: boolean) => {
+    // Registering an unpackaged Electron binary at login is surprising and
+    // points at the wrong executable. Persist the dev preference, then apply
+    // it when the packaged app starts.
+    if (app.isPackaged) {
+      app.setLoginItemSettings({ openAtLogin: enabled })
+    }
+  }
+
+  return {
+    getPreferences: () => readPreferences(deps.config),
+    setPreference(key, value) {
+      deps.config.set(key, value)
+      if (key === 'launchAtLogin') {
+        applyLaunchAtLogin(value)
+      } else if (key === 'autoDownloadUpdates') {
+        deps.setAutoDownloadUpdates(value)
+      }
+      return readPreferences(deps.config)
+    },
+    notify(payload) {
+      const preferences = readPreferences(deps.config)
+      if (!preferences.notificationsEnabled || !Notification.isSupported()) {
+        return false
+      }
+      const window = deps.getMainWindow()
+      if (preferences.notificationsOnlyWhenUnfocused && window?.isFocused()) {
+        return false
+      }
+
+      const notification = new Notification({
+        title: payload.title,
+        body: payload.body,
+        silent: !preferences.notificationSounds,
+      })
+      notification.on('click', () => {
+        deps.openMainWindowAt(
+          payload.route && isSafeInternalPath(payload.route) ? payload.route : undefined
+        )
+      })
+      notification.show()
+      return true
+    },
+    applySystemPreferences() {
+      const preferences = readPreferences(deps.config)
+      applyLaunchAtLogin(preferences.launchAtLogin)
+      deps.setAutoDownloadUpdates(preferences.autoDownloadUpdates)
+    },
+  }
+}