feat(terminals): kill process without discarding the session, and clear stopped sessions

The UI only ever called the remove RPC, so killing a terminal always discarded it along with its scrollback. Wire up the existing terminate RPC (stop the process, keep the session) and distinguish it from remove in the toolbar: running sessions get a Kill action, stopped ones get Remove. Add a clear-exited RPC (TerminalManager.clearExited) plus a nav-level Clear exited sweep to drop every stopped owned session at once.

Author: antfubot

plugins/terminals/src/client/App.svelte

@@ -33,6 +33,12 @@
 
   const activeSession = $derived(sessions.find(s => s.id === activeId) ?? null)
 
+  // Only own sessions can be killed/removed; hub-aggregated ones are read-only.
+  // `exitedCount` drives the nav-level "Clear exited" sweep.
+  const exitedCount = $derived(
+    sessions.filter(s => !isExternal(s) && s.status !== 'running').length,
+  )
+
   // A focus request that arrived (via the hub's dock-activation slot) before
   // its session showed up in the list. Applied one-shot the moment a matching
   // session appears, then cleared so the user's own tab clicks stay honored.
@@ -212,6 +218,21 @@
     spawn({ presetId: id })
   }
 
+  /** Stop the running process but keep the (now stopped) session and its scrollback. */
+  function killSession(id: string): void {
+    rpc.call('devframes:plugin:terminals:terminate', { id }).catch(() => {})
+  }
+
+  /** Discard a session entirely — process, stream, and scrollback. */
+  function removeSession(id: string): void {
+    rpc.call('devframes:plugin:terminals:remove', { id }).catch(() => {})
+  }
+
+  /** Sweep every stopped session away in one go. */
+  function clearExited(): void {
+    rpc.call('devframes:plugin:terminals:clear-exited').catch(() => {})
+  }
+
   function commitRename(id: string, title: string): void {
     renamingId = null
     rpc.call('devframes:plugin:terminals:rename', { id, title: title.trim() }).catch(() => {})
@@ -287,7 +308,7 @@
                 tabindex="-1"
                 aria-label="Close terminal"
                 class="i-ph-x op0 group-hover:op60 hover:op100! transition-opacity shrink-0"
-                onclick={(e) => { e.stopPropagation(); rpc.call('devframes:plugin:terminals:remove', { id: s.id }).catch(() => {}) }}
+                onclick={(e) => { e.stopPropagation(); removeSession(s.id) }}
                 onkeydown={() => {}}
               ></span>
             {/if}
@@ -305,6 +326,18 @@
       </button>
     </div>
 
+    {#if exitedCount > 0}
+      <button
+        type="button"
+        class={button({ variant: 'outline', size: 'sm', class: 'shrink-0' })}
+        title="Remove all stopped sessions"
+        onclick={() => clearExited()}
+      >
+        <div class="i-ph-broom-duotone"></div>
+        <span class="hidden sm:inline">Clear exited</span>
+      </button>
+    {/if}
+
     {#if presets.length}
       <div class="relative shrink-0">
         <button
@@ -376,9 +409,15 @@
         <button type="button" class={iconButton({ variant: 'ghost', size: 'sm' })} title="Restart" onclick={() => rpc.call('devframes:plugin:terminals:restart', { id: s.id }).catch(() => {})}>
           <div class="i-ph-arrow-clockwise-duotone"></div>
         </button>
-        <button type="button" class={iconButton({ variant: 'ghost', size: 'sm' })} title="Kill" onclick={() => rpc.call('devframes:plugin:terminals:remove', { id: s.id }).catch(() => {})}>
-          <div class="i-ph-trash-duotone"></div>
-        </button>
+        {#if s.status === 'running'}
+          <button type="button" class={iconButton({ variant: 'ghost', size: 'sm' })} title="Kill process" onclick={() => killSession(s.id)}>
+            <div class="i-ph-stop-duotone"></div>
+          </button>
+        {:else}
+          <button type="button" class={iconButton({ variant: 'ghost', size: 'sm' })} title="Remove session" onclick={() => removeSession(s.id)}>
+            <div class="i-ph-trash-duotone"></div>
+          </button>
+        {/if}
       {/if}
     </div>
   {/if}

plugins/terminals/src/node/manager.ts

@@ -483,6 +483,30 @@ export class TerminalManager {
     const session = this.sessions.get(id)
     if (!session)
       throw diagnostics.DP_TERMINALS_0001({ id })
+    this.disposeSession(id, session)
+    this.publish()
+  }
+
+  /**
+   * Drop every stopped (non-running) session this manager owns, closing their
+   * streams and forgetting their scrollback. Sessions still running are left
+   * untouched; aggregated hub sessions aren't owned here so they never appear
+   * in {@link sessions}. Publishes once for the whole sweep.
+   */
+  clearExited(): void {
+    for (const [id, session] of this.sessions) {
+      if (session.info.status !== 'running')
+        this.disposeSession(id, session)
+    }
+    this.publish()
+  }
+
+  /**
+   * Tear a single session down — kill its process, stop polling, dispose the
+   * OSC inspector, close the sink, and drop it from the store — without
+   * publishing. Callers publish once they've finished mutating the store.
+   */
+  private disposeSession(id: string, session: ManagedSession): void {
     const proc = session.proc
     session.proc = undefined
     this.stopProcessPoll(session)
@@ -492,7 +516,6 @@ export class TerminalManager {
     if (!session.sink.closed)
       session.sink.close()
     this.sessions.delete(id)
-    this.publish()
   }
 
   /** Tear everything down — used on server shutdown and in tests. */

plugins/terminals/src/rpc/functions/clear-exited.ts

@@ -0,0 +1,20 @@
+import { defineRpcFunction } from 'devframe'
+import * as v from 'valibot'
+import { getTerminalManager } from '../../node/context'
+
+export const clearExited = defineRpcFunction({
+  name: 'devframes:plugin:terminals:clear-exited',
+  type: 'action',
+  jsonSerializable: true,
+  args: [],
+  returns: v.void(),
+  agent: {
+    description: 'Discard every stopped (exited or errored) terminal session at once. Running sessions are left untouched.',
+    safety: 'destructive',
+  },
+  setup: ctx => ({
+    handler: () => {
+      getTerminalManager(ctx).clearExited()
+    },
+  }),
+})

plugins/terminals/src/rpc/index.ts

@@ -1,5 +1,6 @@
 import type { RpcDefinitionsToFunctions } from 'devframe/rpc'
 import type { TerminalPreset, TerminalsSharedState } from '../types'
+import { clearExited } from './functions/clear-exited'
 import { list } from './functions/list'
 import { presets } from './functions/presets'
 import { remove } from './functions/remove'
@@ -20,6 +21,7 @@ export const serverFunctions = [
   restart,
   rename,
   remove,
+  clearExited,
 ] as const
 
 declare module 'devframe' {

plugins/terminals/test/terminals.test.ts

@@ -247,6 +247,65 @@ describe('@devframes/plugin-terminals', () => {
     expect(list.some(s => s.id === info.id)).toBe(false)
   })
 
+  it('kills a running process but keeps the session as stopped', async () => {
+    const client = bootClient(server.port)
+    await new Promise(r => setTimeout(r, 50))
+
+    const info = await call<TerminalSessionInfo>(client, 'devframes:plugin:terminals:spawn', {
+      command: NODE,
+      args: ['-e', 'setInterval(() => {}, 1000)'],
+      mode: 'readonly',
+    })
+
+    await vi.waitFor(async () => {
+      const list = await sessions(server)
+      expect(list.find(s => s.id === info.id)?.status).toBe('running')
+    })
+
+    // terminate stops the process, but the session (and its scrollback) survive.
+    await call(client, 'devframes:plugin:terminals:terminate', { id: info.id })
+
+    await vi.waitFor(async () => {
+      const list = await sessions(server)
+      const s = list.find(x => x.id === info.id)
+      expect(s).toBeDefined()
+      expect(s?.status).not.toBe('running')
+    })
+
+    await call(client, 'devframes:plugin:terminals:remove', { id: info.id })
+  })
+
+  it('clears stopped sessions, leaving running ones untouched', async () => {
+    const client = bootClient(server.port)
+    await new Promise(r => setTimeout(r, 50))
+
+    // One session exits on its own; another stays alive.
+    const done = await call<TerminalSessionInfo>(client, 'devframes:plugin:terminals:spawn', {
+      command: NODE,
+      args: ['-e', 'process.stdout.write("bye")'],
+      mode: 'readonly',
+    })
+    const alive = await call<TerminalSessionInfo>(client, 'devframes:plugin:terminals:spawn', {
+      command: NODE,
+      args: ['-e', 'setInterval(() => {}, 1000)'],
+      mode: 'readonly',
+    })
+
+    await vi.waitFor(async () => {
+      const list = await sessions(server)
+      expect(list.find(s => s.id === done.id)?.status).toBe('exited')
+      expect(list.find(s => s.id === alive.id)?.status).toBe('running')
+    })
+
+    await call(client, 'devframes:plugin:terminals:clear-exited')
+
+    const list = await sessions(server)
+    expect(list.some(s => s.id === done.id)).toBe(false)
+    expect(list.some(s => s.id === alive.id)).toBe(true)
+
+    await call(client, 'devframes:plugin:terminals:remove', { id: alive.id })
+  })
+
   it('exposes presets and spawns from them', async () => {
     await server.close()
     server = await startTerminalsServer({