Merge branch 'staging-v4' of github.com:simstudioai/sim into staging-v4

Author: icecrasher321

apps/desktop/src/main/index.ts

@@ -433,7 +433,6 @@ function main(): void {
     await localFilesystem.initialize()
     terminal.setSink({
       data: (terminalId, data) => broadcast('terminal:data', terminalId, data),
-      replay: (terminalId, data) => broadcast('terminal:replay', terminalId, data),
       tabs: (state) => broadcast('terminal:tabs', state),
       command: (event) => broadcast('terminal:command', event),
     })

apps/desktop/src/main/ipc.ts

@@ -583,6 +583,14 @@ export function registerIpcHandlers(deps: IpcDeps): void {
         return deps.terminal.executeTool(toolCallId, call.operation, args)
       },
     },
+    'terminal:scrollback': {
+      kind: 'invoke',
+      gate: 'app-origin',
+      requires: 'terminal',
+      denied: '',
+      handler: (terminalId) =>
+        typeof terminalId === 'string' ? deps.terminal.getScrollback(terminalId) : '',
+    },
     'terminal:get-tabs': {
       kind: 'invoke',
       gate: 'app-origin',

apps/desktop/src/main/terminal/index.ts

@@ -96,12 +96,6 @@ class TerminalError extends Error {
 /** Where the service pushes live updates; wired to the renderer by ipc.ts. */
 export interface TerminalSink {
   data(terminalId: string, data: string): void
-  /**
-   * Full scrollback for a freshly mounted panel to repaint from. The renderer
-   * resets before writing it, so anything it painted beforehand is discarded
-   * and cannot duplicate.
-   */
-  replay(terminalId: string, data: string): void
   tabs(state: TerminalTabsState): void
   command(event: TerminalCommandEvent): void
 }
@@ -175,16 +169,26 @@ export class TerminalService {
   start(options: TerminalStartOptions): TerminalTabsState {
     if (this.sessions.size === 0) {
       this.spawn(this.startingCwd(), options.cols, options.rows)
-      return this.getTabs()
-    }
-    // Adopting: the panel is mounting over shells that have been running
-    // without it, so hand back everything already on their screens.
-    for (const session of this.sessions.values()) {
-      this.sink?.replay(session.terminalId, session.takeReplaySnapshot())
     }
     return this.getTabs()
   }
 
+  /**
+   * Everything on a terminal's screen, for a freshly created view to paint
+   * itself from.
+   *
+   * Pulled by the view rather than pushed on start. Pushing meant the repaint
+   * was aimed at whoever happened to be subscribed at the time: on a first
+   * mount that is nobody, because the tab list is still empty and no view
+   * exists yet, so the paint was dropped and the panel came up blank over a
+   * shell that had been running all along. On later mounts it was everybody,
+   * so a panel that already had its content repainted anyway. A view asking
+   * for its own terminal is right in both cases, and asks exactly once.
+   */
+  getScrollback(terminalId: string): string {
+    return this.sessions.get(terminalId)?.takeReplaySnapshot() ?? ''
+  }
+
   /** Opens an additional terminal and makes it active. */
   openTerminal(cwd?: string): TerminalTabsState {
     if (this.sessions.size >= MAX_TERMINALS) {

apps/desktop/src/preload/index.ts

@@ -236,14 +236,8 @@ const api: SimDesktopApi = {
         ipcRenderer.removeListener('terminal:data', listener)
       }
     },
-    onReplay: (callback: (terminalId: string, data: string) => void): (() => void) => {
-      const listener = (_event: unknown, terminalId: string, data: string) =>
-        callback(terminalId, data)
-      ipcRenderer.on('terminal:replay', listener)
-      return () => {
-        ipcRenderer.removeListener('terminal:replay', listener)
-      }
-    },
+    getScrollback: (terminalId: string): Promise<string> =>
+      ipcRenderer.invoke('terminal:scrollback', terminalId),
     onTabs: (callback: (state: TerminalTabsState) => void): (() => void) => {
       const listener = (_event: unknown, state: TerminalTabsState) => callback(state)
       ipcRenderer.on('terminal:tabs', listener)

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/terminal-session/terminal-session.tsx

@@ -22,8 +22,8 @@ import { MAX_TERMINALS } from '@sim/terminal-protocol'
 import { TERMINAL_SESSION_RESOURCE_ID } from '@/lib/copilot/resources/types'
 import {
   closeTerminal,
+  getTerminalScrollback,
   onTerminalData,
-  onTerminalReplay,
   openTerminal,
   resizeTerminal,
   startTerminalSession,
@@ -144,6 +144,7 @@ function TerminalView({ terminalId, active }: { terminalId: string; active: bool
     const host = hostRef.current
     if (!host) return
 
+    let disposed = false
     const terminal = new Terminal({
       allowProposedApi: true,
       cursorBlink: true,
@@ -171,18 +172,32 @@ function TerminalView({ terminalId, active }: { terminalId: string; active: bool
     const disposeResize = terminal.onResize(({ cols, rows }) =>
       resizeTerminal(terminalId, cols, rows)
     )
+    // The desktop app owns the scrollback, so a view opening onto a shell that
+    // has been running without it paints from what is already on that screen.
+    //
+    // Live bytes are held until that paint lands rather than written straight
+    // through: the snapshot is a moment in time, and anything arriving while
+    // it is in flight would either be wiped by the reset or, written first,
+    // appear above the history it followed. Buffering keeps the order true.
+    let painted = false
+    let buffered = ''
     const unsubscribeData = onTerminalData((id, data) => {
-      if (id === terminalId) terminal.write(data)
-    })
-    // The desktop app owns the scrollback, so a panel mounting over a shell
-    // that was already running repaints from it. Resetting first makes the
-    // repaint idempotent, so bytes that arrived before it cannot show up twice.
-    const unsubscribeReplay = onTerminalReplay((id, data) => {
       if (id !== terminalId) return
-      terminal.reset()
-      if (data) terminal.write(data)
+      if (painted) terminal.write(data)
+      else buffered += data
     })
 
+    void getTerminalScrollback(terminalId)
+      .catch(() => '')
+      .then((scrollback) => {
+        if (disposed) return
+        terminal.reset()
+        if (scrollback) terminal.write(scrollback)
+        if (buffered) terminal.write(buffered)
+        buffered = ''
+        painted = true
+      })
+
     // Resizing is debounced, and deliberately not applied to hidden tabs.
     //
     // Every distinct column count reaches the shell as a SIGWINCH and makes it
@@ -212,10 +227,10 @@ function TerminalView({ terminalId, active }: { terminalId: string; active: bool
     observer.observe(host)
 
     return () => {
+      disposed = true
       if (resizeTimer) clearTimeout(resizeTimer)
       observer.disconnect()
       unsubscribeData()
-      unsubscribeReplay()
       disposeData.dispose()
       disposeResize.dispose()
       terminal.dispose()

apps/sim/lib/copilot/generated/tool-catalog-v1.ts

@@ -4825,7 +4825,7 @@ export const Wait: ToolCatalogEntry = {
         description:
           'What you are waiting for, in a few words (e.g. "the test suite to finish"). Shown to the user so the pause is not unexplained.',
       },
-      seconds: { type: 'number', description: 'How long to pause, in seconds. Capped at 30.' },
+      seconds: { type: 'number', description: 'How long to pause, in seconds. Capped at 120.' },
     },
     required: ['seconds'],
   },

apps/sim/lib/copilot/generated/tool-schemas-v1.ts

@@ -4492,7 +4492,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         },
         seconds: {
           type: 'number',
-          description: 'How long to pause, in seconds. Capped at 30.',
+          description: 'How long to pause, in seconds. Capped at 120.',
         },
       },
       required: ['seconds'],

apps/sim/lib/terminal/transport.ts

@@ -59,11 +59,12 @@ export function onTerminalData(callback: (terminalId: string, data: string) => v
 }
 
 /**
- * Subscribes to full-scrollback repaints, sent when attaching to shells that
- * were already running. The panel resets that terminal before writing.
+ * Everything already on a terminal's screen, for a new view to paint itself
+ * from. Empty when the desktop bridge is unavailable, which leaves the view
+ * blank rather than failing the mount.
  */
-export function onTerminalReplay(callback: (terminalId: string, data: string) => void): () => void {
-  return bridge()?.onReplay?.(callback) ?? (() => {})
+export async function getTerminalScrollback(terminalId: string): Promise<string> {
+  return (await bridge()?.getScrollback(terminalId)) ?? ''
 }
 
 export async function startTerminalSession(

packages/desktop-bridge/contract-snapshot.ts

@@ -248,12 +248,11 @@ export interface SimDesktopTerminalApi {
   /** Subscribe to PTY output batches. Returns an unsubscribe function. */
   onData(callback: (terminalId: string, data: string) => void): () => void
   /**
-   * Subscribe to full-scrollback repaints, sent when the panel attaches to a
-   * shell that was already running. Reset the terminal before writing it.
-   * Optional for compatibility with shells predating scrollback replay; without
-   * it the panel simply starts empty over a live shell.
+   * Everything already on a terminal's screen, for a new view to paint itself
+   * from. Pulled per view so the repaint cannot be aimed at the wrong set of
+   * subscribers, or at none at all.
    */
-  onReplay?(callback: (terminalId: string, data: string) => void): () => void
+  getScrollback(terminalId: string): Promise<string>
   /** Subscribe to the open-terminal list and which one is active. */
   onTabs(callback: (state: TerminalTabsState) => void): () => void
   /** Subscribe to command start/end, used for agent attribution in the panel. */

packages/desktop-bridge/src/index.ts

@@ -52,12 +52,11 @@ export interface SimDesktopTerminalApi {
   /** Subscribe to PTY output batches. Returns an unsubscribe function. */
   onData(callback: (terminalId: string, data: string) => void): () => void
   /**
-   * Subscribe to full-scrollback repaints, sent when the panel attaches to a
-   * shell that was already running. Reset the terminal before writing it.
-   * Optional for compatibility with shells predating scrollback replay; without
-   * it the panel simply starts empty over a live shell.
+   * Everything already on a terminal's screen, for a new view to paint itself
+   * from. Pulled per view so the repaint cannot be aimed at the wrong set of
+   * subscribers, or at none at all.
    */
-  onReplay?(callback: (terminalId: string, data: string) => void): () => void
+  getScrollback(terminalId: string): Promise<string>
   /** Subscribe to the open-terminal list and which one is active. */
   onTabs(callback: (state: TerminalTabsState) => void): () => void
   /** Subscribe to command start/end, used for agent attribution in the panel. */