Initial commit: OpenTerminal v0.1.0

Open-source terminal app (local + SSH): split panes, themes, SFTP,
server monitoring, broadcast input, ZMODEM, system tray, single instance.
Electron + React + TypeScript. MIT License.

tests/ssh-session-e2e.mjs

@@ -0,0 +1,151 @@
+/**
+ * Session-layer e2e (M2). Drives the REAL session routing (src/main/pty.ts +
+ * src/main/ssh.ts, bundled by esbuild with an electron stub) against an
+ * in-process ssh2.Server — the same openSession/write/resize/kill pipeline the
+ * app uses, minus the IPC + renderer shells.
+ *
+ * Pre-req: npx esbuild src/main/pty.ts --bundle --platform=node --format=cjs
+ *          --outfile=tests/.session-e2e.cjs --external:@lydell/node-pty
+ *          --external:ssh2 --alias:electron=./tests/electron-stub.cjs
+ * Run:     node tests/ssh-session-e2e.mjs  (must exit 0)
+ */
+
+import pkg from 'ssh2'
+import { createHash } from 'crypto'
+import { createRequire } from 'module'
+const require_ = createRequire(import.meta.url)
+const { Server, utils } = pkg
+
+const fail = (msg) => {
+  console.error(`FAIL: ${msg}`)
+  process.exit(1)
+}
+
+// ---- 1. Loopback ssh server --------------------------------------------------
+const serverKey = utils.generateKeyPairSync('ed25519')
+let serverPort = 0
+let seenWindowChange = { cols: 0, rows: 0 }
+
+const srv = new Server({ hostKeys: [serverKey.private] }, (client) => {
+  client.on('authentication', (ctx) => {
+    if (ctx.method === 'password' && ctx.username === 'test' && ctx.password === 'test') {
+      ctx.accept()
+    } else {
+      ctx.reject(['password'])
+    }
+  })
+  client.on('ready', () => {
+    client.on('session', (accept) => {
+      const session = accept()
+      session.on('pty', (accept) => accept())
+      session.on('window-change', (accept, reject, info) => {
+        seenWindowChange = { cols: info.cols, rows: info.rows }
+        accept && accept()
+      })
+      session.on('shell', (accept) => {
+        const stream = accept()
+        stream.write('SESSION-E2E-BANNER\n')
+        stream.on('data', (d) => {
+          const data = d.toString('utf8')
+          stream.write(data)
+          if (data.includes('exit')) {
+            stream.end()
+            client.end()
+          }
+        })
+      })
+    })
+  })
+  client.on('error', () => {})
+})
+
+await new Promise((resolve, reject) => {
+  srv.on('error', reject)
+  srv.listen(0, '127.0.0.1', () => {
+    serverPort = srv.address().port
+    resolve()
+  })
+})
+console.log(`[e2e] ssh server listening on 127.0.0.1:${serverPort}`)
+
+// ---- 2. Load the real session layer ------------------------------------------
+// esbuild replaces 'electron' with tests/electron-stub.cjs via --alias.
+const sessionLayer = require_('./.session-e2e.cjs')
+
+const events = []
+sessionLayer.configureSessionRuntime({
+  broadcast: (channel, payload) => events.push({ channel, payload }),
+  getConnection: (id) => {
+    if (id !== 'conn-1') fail(`unexpected connectionId ${id}`)
+    return {
+      id: 'conn-1',
+      name: 'loopback',
+      host: '127.0.0.1',
+      port: serverPort,
+      username: 'test',
+      auth: 'password',
+      askPasswordAtConnect: false,
+      askPassphraseAtConnect: false,
+      keepaliveIntervalSec: 0,
+      createdAt: Date.now(),
+      savedAuth: { hasPassword: true, hasKeyContent: false, hasPassphrase: false }
+    }
+  },
+  getSecret: (conn, field) => (field === 'password' ? 'test' : undefined),
+  touch: (id) => events.push({ channel: 'touched', payload: id }),
+  knownHosts: {
+    check: (host, port, key) => {
+      const fp = 'SHA256:' + createHash('sha256').update(key).digest('base64').replace(/=+$/, '')
+      return { status: 'match', fingerprint: fp }
+    },
+    accept: () => {}
+  },
+  promptHostKey: () => fail('promptHostKey must not fire for matching keys')
+})
+
+// ---- 3. Drive the pipeline ----------------------------------------------------
+const timer = setTimeout(() => fail('e2e timed out'), 15000)
+const openResult = await sessionLayer.openSession({ kind: 'ssh', connectionId: 'conn-1' })
+if (!openResult?.id) fail('openSession did not resolve with an id')
+console.log(`[e2e] session open: ${openResult.id}`)
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms))
+const seenData = (needle) =>
+  events.some((e) => e.channel === 'pty:data' && typeof e.payload?.data === 'string' && e.payload.data.includes(needle))
+
+// banner should already have streamed once the shell opened
+for (let i = 0; i < 50 && !seenData('SESSION-E2E-BANNER'); i++) await wait(100)
+if (!seenData('SESSION-E2E-BANNER')) fail('banner never arrived via PTY_DATA broadcast')
+console.log('[e2e] banner received through session data plane')
+
+// replay buffer: a late subscriber must still get the banner
+const replay = await sessionLayer.getSessionReplay(openResult.id)
+if (!replay.includes('SESSION-E2E-BANNER')) fail('replay buffer missing the banner')
+console.log('[e2e] replay buffer serves the banner to late subscribers')
+
+sessionLayer.writePty(openResult.id, 'ping-session-e2e\n')
+for (let i = 0; i < 50 && !seenData('ping-session-e2e'); i++) await wait(100)
+if (!seenData('ping-session-e2e')) fail('written data never echoed back')
+console.log('[e2e] write -> echo round-trip ok')
+
+sessionLayer.resizePty(openResult.id, 111, 33)
+for (let i = 0; i < 50 && seenWindowChange.cols !== 111; i++) await wait(100)
+if (seenWindowChange.cols !== 111 || seenWindowChange.rows !== 33) fail(`resize not propagated (${JSON.stringify(seenWindowChange)})`)
+console.log('[e2e] resize propagated (111x33)')
+
+sessionLayer.killPty(openResult.id)
+const exited = events.find((e) => e.channel === 'pty:exit' && e.payload?.id === openResult.id)
+if (!exited) {
+  // 'close' on the client stream may lag slightly behind kill
+  for (let i = 0; i < 50 && !events.some((e) => e.channel === 'pty:exit' && e.payload?.id === openResult.id); i++) await wait(100)
+}
+if (!events.some((e) => e.channel === 'pty:exit' && e.payload?.id === openResult.id)) fail('PTY_EXIT never broadcast after killPty')
+console.log('[e2e] kill -> PTY_EXIT ok')
+
+if (!events.some((e) => e.channel === 'touched' && e.payload === 'conn-1')) fail('lastConnectedAt touch not recorded')
+console.log('[e2e] connection touch recorded')
+
+clearTimeout(timer)
+srv.close()
+console.log('[e2e] ALL CHECKS PASSED')
+process.exit(0)