fix(desktop): correct Windows process teardown, artifact guard, and taskbar identity

Windows has no signal delivery, so child.kill terminated only the Host PID and
left node-pty shells and subagent hosts holding the loopback port. Kill the
tree with taskkill /T /F in the child adapter, where every caller routes.

Also: the packaged-runtime guard tested for a forward slash and so never fired
on a Windows exec path; set the Application User Model ID so taskbar pinning
survives an installer upgrade; and require the win32 node-pty prebuilds at
pack time.

Author: elkaix

.changeset/desktop-windows-runtime.md

@@ -0,0 +1,5 @@
+---
+'@pymodel/pythinker-desktop': patch
+---
+
+Fix Windows process-tree shutdown, packaged-runtime guards, and taskbar identity in the desktop app

apps/desktop/scripts/verify-packaged-runtime.ts

@@ -9,6 +9,12 @@ const REQUIRED_HOST_FILES = [
   ['@pymodel', 'pythinker-code', 'dist-web', 'index.html'],
 ] as const
 
+const REQUIRED_WINDOWS_NODE_PTY_ENTRIES = [
+  ['node-pty', 'prebuilds', 'win32-x64', 'pty.node'],
+  ['node-pty', 'prebuilds', 'win32-x64', 'conpty.node'],
+  ['node-pty', 'prebuilds', 'win32-x64', 'conpty_console_list.node'],
+] as const
+
 /**
  * Verify the Host files required before the signed application can start.
  * @param context - Electron Builder's completed application directory.
@@ -21,6 +27,10 @@ export async function afterPack(context: AfterPackContext): Promise<void> {
   for (const segments of REQUIRED_HOST_FILES) {
     await access(join(resources, 'host', 'node_modules', ...segments))
   }
+  if (context.electronPlatformName !== 'win32') return
+  for (const segments of REQUIRED_WINDOWS_NODE_PTY_ENTRIES) {
+    await access(join(resources, 'host', 'node_modules', ...segments))
+  }
 }
 
 export default afterPack

apps/desktop/src/host-supervisor.ts

@@ -1,6 +1,6 @@
 /** Supervise the loopback Web Host used by the first desktop application. */
 
-import { spawn, type ChildProcessByStdio } from 'node:child_process'
+import { spawn, spawnSync, type ChildProcessByStdio } from 'node:child_process'
 import type { Readable } from 'node:stream'
 
 const READINESS_PREFIX = 'Pythinker server: '
@@ -297,6 +297,26 @@ export function spawnPythinkerServer(options: SpawnPythinkerServerOptions): Host
   return nodeChildAdapter(process)
 }
 
+/**
+ * Terminate a child and its descendants.
+ *
+ * Windows has no signal delivery: `child.kill` calls TerminateProcess on one
+ * PID, so the Host's own children (node-pty shells, subagent hosts) survive and
+ * keep holding the loopback port. `taskkill /T` walks the tree instead.
+ *
+ * ponytail: /F makes every Windows stop a forced stop — Node cannot deliver a
+ * graceful SIGTERM to a Windows child at all. Add a stdin or IPC shutdown
+ * channel to the Host if graceful Windows teardown is ever needed.
+ */
+function killProcessTree(child: ChildProcessByStdio<null, Readable, Readable>, signal: 'SIGTERM' | 'SIGKILL'): void {
+  if (process.platform !== 'win32' || child.pid === undefined) {
+    child.kill(signal)
+    return
+  }
+  const result = spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { windowsHide: true })
+  if (result.error !== undefined || result.status !== 0) child.kill(signal)
+}
+
 /** Adapt Node's event overloads to the supervisor's explicit ownership API. */
 function nodeChildAdapter(child: ChildProcessByStdio<null, Readable, Readable>): HostChild {
   return {
@@ -312,7 +332,7 @@ function nodeChildAdapter(child: ChildProcessByStdio<null, Readable, Readable>):
       return () => { child.off('error', listener) }
     },
     kill(signal) {
-      child.kill(signal)
+      killProcessTree(child, signal)
     },
   }
 }

apps/desktop/src/main.ts

@@ -2,7 +2,7 @@
 
 import { randomUUID } from 'node:crypto'
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-import { join, resolve } from 'node:path'
+import { isAbsolute, join, resolve } from 'node:path'
 import {
   app,
   BrowserWindow,
@@ -109,7 +109,7 @@ function hostPaths(): { nodeExecutable: string; cliEntry: string; cwd: string; e
 }
 
 function assertHostArtifacts(paths: ReturnType<typeof hostPaths>): void {
-  if (paths.nodeExecutable.includes('/') && !existsSync(paths.nodeExecutable)) {
+  if (isAbsolute(paths.nodeExecutable) && !existsSync(paths.nodeExecutable)) {
     throw new Error(`desktop Node runtime is missing: ${paths.nodeExecutable}`)
   }
   if (!existsSync(paths.cliEntry)) {
@@ -298,6 +298,7 @@ function requestAppQuit(): Promise<void> {
 }
 
 async function boot(): Promise<void> {
+  if (process.platform === 'win32') app.setAppUserModelId('com.pythinker.desktop')
   if (bootQuitPromise !== undefined) return
   initializeDesktopTelemetry()
   const paths = hostPaths()

apps/desktop/tests/host-supervisor.spec.ts

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
   createHostSupervisor,
@@ -314,4 +314,67 @@ describe('desktop Host process', () => {
       expect.objectContaining({ env: { PYTHINKER_DESKTOP: '1', ELECTRON_RUN_AS_NODE: '1' } }),
     )
   })
+
+  it('kills the Windows Host process tree', async () => {
+    const child = {
+      pid: 4242,
+      stdout: { on: vi.fn(), off: vi.fn() },
+      stderr: { on: vi.fn(), off: vi.fn() },
+      on: vi.fn(),
+      off: vi.fn(),
+      kill: vi.fn(),
+    }
+    vi.mocked(spawn).mockReturnValue(child as never)
+    vi.mocked(spawnSync).mockReturnValue({
+      pid: 4242,
+      output: [],
+      stdout: Buffer.alloc(0),
+      stderr: Buffer.alloc(0),
+      status: 0,
+      signal: null,
+    })
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('win32')
+
+    const { spawnPythinkerServer } = await import('../src/host-supervisor')
+    const host = spawnPythinkerServer({
+      nodeExecutable: 'node',
+      cliEntry: '/tmp/launcher.mjs',
+      cwd: '/tmp',
+      env: {},
+    })
+    host.kill('SIGTERM')
+
+    expect(spawnSync).toHaveBeenCalledWith(
+      'taskkill',
+      ['/pid', '4242', '/T', '/F'],
+      { windowsHide: true },
+    )
+    expect(child.kill).not.toHaveBeenCalled()
+  })
+
+  it('uses child.kill unchanged on non-Windows', async () => {
+    const child = {
+      pid: 4242,
+      stdout: { on: vi.fn(), off: vi.fn() },
+      stderr: { on: vi.fn(), off: vi.fn() },
+      on: vi.fn(),
+      off: vi.fn(),
+      kill: vi.fn(),
+    }
+    vi.mocked(spawn).mockReturnValue(child as never)
+    vi.mocked(spawnSync).mockClear()
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('darwin')
+
+    const { spawnPythinkerServer } = await import('../src/host-supervisor')
+    const host = spawnPythinkerServer({
+      nodeExecutable: 'node',
+      cliEntry: '/tmp/launcher.mjs',
+      cwd: '/tmp',
+      env: {},
+    })
+    host.kill('SIGTERM')
+
+    expect(child.kill).toHaveBeenCalledWith('SIGTERM')
+    expect(spawnSync).not.toHaveBeenCalled()
+  })
 })

apps/desktop/tests/verify-packaged-runtime.spec.ts

@@ -38,4 +38,38 @@ describe('packaged desktop runtime verification', () => {
       await rm(appOutDir, { recursive: true, force: true })
     }
   })
+
+  it('rejects a Windows shell whose node-pty native closure was filtered out', async () => {
+    const appOutDir = await mkdtemp(join(tmpdir(), 'pythinker-packaged-runtime-'))
+    try {
+      const resources = join(appOutDir, 'resources', 'host', 'node_modules')
+      const cli = join(resources, '@pymodel', 'pythinker-code', 'dist', 'launcher.mjs')
+      const web = join(resources, '@pymodel', 'pythinker-code', 'dist-web', 'index.html')
+      await mkdir(join(cli, '..'), { recursive: true })
+      await mkdir(join(web, '..'), { recursive: true })
+      await writeFile(cli, '')
+      await writeFile(web, '')
+
+      await expect(afterPack(context(appOutDir, 'win32'))).rejects.toMatchObject({ code: 'ENOENT' })
+    } finally {
+      await rm(appOutDir, { recursive: true, force: true })
+    }
+  })
+
+  it('does not require Windows node-pty entries for a Darwin shell', async () => {
+    const appOutDir = await mkdtemp(join(tmpdir(), 'pythinker-packaged-runtime-'))
+    try {
+      const resources = join(appOutDir, 'Pythinker.app', 'Contents', 'Resources', 'host', 'node_modules')
+      const cli = join(resources, '@pymodel', 'pythinker-code', 'dist', 'launcher.mjs')
+      const web = join(resources, '@pymodel', 'pythinker-code', 'dist-web', 'index.html')
+      await mkdir(join(cli, '..'), { recursive: true })
+      await mkdir(join(web, '..'), { recursive: true })
+      await writeFile(cli, '')
+      await writeFile(web, '')
+
+      await expect(afterPack(context(appOutDir))).resolves.toBeUndefined()
+    } finally {
+      await rm(appOutDir, { recursive: true, force: true })
+    }
+  })
 })