dsh-winrm 0.1.1 → 0.2.0

package/lib/types/engine/client.d.ts

@@ -2,11 +2,11 @@
  * WinRM transport bridge.
  *
  * Runs each PowerShell payload over a native Node.js WinRM client
- * (winrm-client) — no Python/pywinrm subprocess. The script rides the
- * UTF-8 base64 envelope (marker + base64 of UTF-8 output) so Chinese and
- * any codepage output survives the WinRM transport losslessly; the envelope
- * is base64-encoded with `-EncodedCommand`, keeping the command line a
- * single ASCII-safe line that WinRS/cmd.exe cannot mangle.
+ * (winrm-client) — no Python/pywinrm subprocess. The script is delivered on
+ * the WinRS **stdin** stream and answers on the UTF-8 base64 envelope, so
+ * Chinese and any codepage output survives the transport losslessly and the
+ * command line stays a constant, ASCII-safe line that WinRS/cmd.exe cannot
+ * mangle. See powershell.ts for why the command line cannot carry the script.
  *
  * Auth is chosen per attempt (HTTPS: Basic first, then NTLM; HTTP: NTLM
  * first, then Basic) with fallback, so a host that only enables one scheme

package/lib/types/powershell.d.ts

@@ -1,28 +1,82 @@
 /**
- * PowerShell snippet builders. Every payload rides the UTF-8 base64
- * envelope: the WinRM host prints only ASCII (marker + base64 of UTF-8 text)
- * so Chinese / any codepage output survives the transport losslessly. One-shot
- * commands execute directly in the PowerShell session created by WinRM.
+ * PowerShell snippet builders and the WinRM UTF-8 envelope.
+ *
+ * The user script is delivered on the WinRS **stdin** stream, not on the
+ * command line. WinRS hands the command line to cmd.exe, which caps it at
+ * ~8191 characters; `-EncodedCommand` inflates a script by 2.67x
+ * (UTF-16LE → base64), so the command line can carry only about 1.5 KB of
+ * script. That silently broke every large payload — most visibly the 48 KiB
+ * transfer chunk, whose embedded base64 alone is ~65K characters.
+ *
+ * So the command line is now a *constant* outer script and the user script
+ * rides stdin, which has no such limit (verified to 200 KB).
+ *
+ * The outer script reads a byte count, then that many bytes, starts a child
+ * `powershell.exe` and feeds it the script on its stdin. The process boundary
+ * is what makes `exit N` and an uncaught `throw` survivable: they terminate
+ * the *child*, and the outer script is still alive to print the envelope.
+ * `-EncodedCommand` for the child also sidesteps the execution policy
+ * entirely — the policy governs `.ps1` files, not encoded commands — so no
+ * temp file is written and no policy block can lose the envelope.
+ *
+ * The child body is `& (...) 2>&1 | Out-String -Stream`. Both halves matter:
+ * `2>&1` pulls error records into the success stream, `Out-String -Stream`
+ * stringifies them onto stdout *line by line*. Plain `Out-String` would also
+ * stringify them but buffers the whole pipeline, discarding everything
+ * produced before a mid-script `exit`; bare `2>&1` without `Out-String`
+ * leaves the records to be re-serialized as CLIXML on stderr, where the
+ * envelope's CLIXML stripping deletes the text outright.
+ *
+ * The envelope is three lines — a marker with the exit code, then one base64
+ * line per stream:
+ *
+ *     __DSH_WINRM__<code>
+ *     O:<base64 of UTF-8 stdout>
+ *     E:<base64 of UTF-8 stderr>
+ *
+ * Every payload is ASCII, so the transport cannot corrupt it and Chinese
+ * output survives losslessly. The `O:` / `E:` labels are load-bearing: the
+ * WinRM client trims each response chunk, which can eat the newline between
+ * two lines, and base64 never contains `:`, so the labels stay parseable
+ * even when the separators vanish.
  */
 /** Marker line prefix carrying the exit code: '__DSH_WINRM__<code>'. */
 export declare const ENVELOPE_MARKER = "__DSH_WINRM__";
+/** Max characters per stdin Send; split on code points, never mid-surrogate-pair. */
+export declare const STDIN_CHUNK_CHARS = 16384;
 /** PS single-quoted literal (doubles embedded quotes). */
 export declare function sq(value: string): string;
 /** Base64 of a UTF-16LE PowerShell script, for -EncodedCommand. */
 export declare function encodeCommand(script: string): string;
 /**
- * The UTF-8 WinRM session script: runs `userScript` inside a script block,
- * merges stderr, prints the exit-code marker and base64 of UTF-8 output.
+ * The constant powershell.exe command line that runs the envelope.
+ *
+ * Deliberately takes no payload: keeping the command line under cmd.exe's
+ * ~8191-character cap is the whole point of the stdin channel.
+ */
+export declare function powershellCommandLine(): string;
+/**
+ * The stdin payload for one command: the UTF-8 **byte** count, a newline, then
+ * the raw script.
+ *
+ * The count is in bytes, not characters, because the outer script sizes its
+ * receive buffer from it — a script with multi-byte characters would otherwise
+ * be truncated mid-character.
+ * @param userScript - the PowerShell script to run.
+ * @returns the payload to send on WinRS stdin.
+ */
+export declare function scriptPayload(userScript: string): string;
+/**
+ * Split a payload into Send-sized pieces without cutting a surrogate pair.
+ *
+ * `Command.doSendInput` encodes each piece to UTF-8 independently, so a lone
+ * surrogate at a chunk boundary would be replaced with U+FFFD and corrupt the
+ * script. Iterating with `for…of` yields whole code points, so a pair always
+ * stays in one piece.
+ * @param payload - the full stdin payload.
+ * @returns the pieces to send in order; never empty.
  */
-export declare function wrapEnvelope(userScript: string): string;
-/** One-shot script body for the PowerShell session already created by WinRM. */
-export declare function winrmPowerShellScript(userScript: string): string;
-/** The full powershell.exe command line (ASCII-safe) for a script body. */
-export declare function powershellCommandLine(script: string): string;
-/** One-shot non-interactive PowerShell command line (envelope-wrapped). */
-export declare function execCommandLine(userScript: string): string;
-/** Interactive bootstrap for the streaming console (keeps the shell alive). */
-export declare function consoleCommandLine(): string;
+export declare function splitScriptPayload(payload: string): string[];
 /** JSON: full service table (CIM). */
 export declare function psListServices(): string;
 /** JSON: one service after an action. */
@@ -43,20 +97,23 @@ export declare function psReadChunk(p: string, offset: number, count: number): s
  */
 export declare function psWriteChunk(p: string, b64: string, append: boolean): string;
 /**
- * Parse the envelope output: { exitCode, text } or null when absent.
+ * Parse the three-line envelope: { exitCode, stdout, stderr } or null when absent.
  *
- * The base64 body is optional and the separating newline may be missing: a
- * command that printed nothing emits the marker alone (an empty string has
- * no base64 body), and a transport that trims each response drops the
- * trailing newline. The exit code is signed because `$LASTEXITCODE` can be
- * negative.
+ * Fields are located by their `O:` / `E:` labels rather than by splitting on
+ * newlines, because the WinRM client trims every response chunk and can drop
+ * the newline that separated two lines. base64's alphabet has no colon, so a
+ * label can only ever be a delimiter and the search cannot land on payload
+ * data. The exit code is signed because `$LASTEXITCODE` can be negative.
+ * @param output - the raw stdout accumulated from the WinRS stdout stream.
+ * @returns the decoded envelope, or null when the marker is missing.
  */
 export declare function parseEnvelope(output: string): {
     exitCode: number;
-    text: string;
+    stdout: string;
+    stderr: string;
 } | null;
 /**
- * Remove PowerShell's CLIXML host records from the WinRS stderr stream.
+ * Remove PowerShell's CLIXML host records from a stderr stream.
  *
  * PowerShell marks its stderr stream with a `#< CLIXML` header line and
  * serializes the remote host's own progress/verbose records into `<Objs>`
@@ -65,9 +122,10 @@ export declare function parseEnvelope(output: string): {
  * header and a record block (for example `[Console]::Error`) is real output,
  * not part of the CLIXML payload.
  *
- * The script's own error output is already merged into stdout by the
- * envelope, so this only removes transport-level noise.
- * @param stderr - raw stderr text captured from the WinRS stream.
+ * The script's own PowerShell errors are already stringified into the
+ * envelope's stdout by `Out-String -Stream`, so this only removes
+ * transport-level noise such as module-load progress.
+ * @param stderr - raw stderr text captured from the WinRS stream or the envelope.
  * @returns the stderr text without CLIXML host records.
  */
 export declare function stripClixml(stderr: string): string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-winrm",
   "description": "Remote Windows administration for the dsh web GUI: WinRM/PowerShell Remoting host config store (~/.dsh/dsh-winrm.json), PowerShell exec / streaming console / service & process management / base64-chunked file transfer / cluster execution, plus agent tools (winrm_list, winrm_exec, winrm_service, winrm_process, winrm_upload, winrm_download, winrm_cluster). Runs entirely on a native Node.js WinRM client (winrm-client) — no Python/pywinrm required. Standalone Cordis plugin — mounted via cordis.patch.yml + a profile node_modules link, no dsh source changes.",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "packageManager": "pnpm@11.7.0",
   "engines": {
@@ -44,25 +44,25 @@
     "ws": "^8.18.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-host-webserver": "^0.1.7-alpha.2",
-    "@deepseek-ai/dsh-llm": "^0.1.7-alpha.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.7-alpha.2",
-    "@deepseek-ai/dsh-tools": "^0.1.7-alpha.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.7-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.7-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.7-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.7-alpha.2 || ^0.2.0-rc.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
     "@deepseek-ai/cordis-plugin-loader": "^1.0.5",
-    "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-layout": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.2",
     "@deepseek-ai/schemastery": "^3.18.4",
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
@@ -89,7 +89,8 @@
     "build": "tsc -p tsconfig.build.json && tsdown && node scripts/postbuild.mjs",
     "bundle": "tsdown",
     "watch": "tsdown --watch",
-    "test": "node --experimental-strip-types --test tests/*.test.ts tests/*.test.mjs",
+    "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "verify:live": "node --experimental-strip-types scripts/verify-live.mts",
     "check": "npm run typecheck && npm run build && npm test",
     "pack:check": "npm pack --dry-run --json",
     "prepack": "npm run check",

package/scripts/verify-live.mts

@@ -0,0 +1,116 @@
+// Live verification against a real WinRM host — exercises the stdin channel,
+// the labelled envelope, the exit-code semantics, and a full transfer round
+// trip. Unlike the unit tests this needs a reachable host, so it is a
+// maintainer tool rather than part of `npm test`.
+//
+// Run from the repo root so `winrm-client` resolves:
+//   node --experimental-strip-types scripts/verify-live.mts
+import { HostStore } from '../src/store.ts'
+import { connOf, runScript, TRANSFER_CHUNK, uploadBuffer, downloadChunks, remoteFileSize } from '../src/engine/client.ts'
+import { psWriteChunk, psReadChunk, psFileSize } from '../src/powershell.ts'
+
+const store = new HostStore()
+const entry = store.list()[0]
+if (!entry) throw new Error('no host configured')
+const conn = connOf(entry)
+
+type Case = { name: string; script: string; code?: number; out?: string | RegExp; err?: string; contains?: string }
+const cases: Case[] = [
+  { name: 'plain', script: `Write-Output "hi"`, code: 0, out: 'hi' },
+  { name: 'empty', script: `''`, code: 0, out: '' },
+  { name: 'utf8', script: `Write-Output '中文测试 ✓ 𝄞'`, code: 0, out: '中文测试 ✓ 𝄞' },
+  { name: 'out then exit 3', script: `Write-Output 'before'; exit 3`, code: 3, out: 'before' },
+  { name: 'utf8 exit 5', script: `Write-Output '中文'; exit 5`, code: 5, out: '中文' },
+  { name: 'throw', script: `throw 'kaboom'`, code: 1, contains: 'kaboom' },
+  { name: 'nonterm error', script: `Get-ChildItem C:\\definitely-not-here-xyz`, code: 0, contains: 'Cannot find path' },
+  { name: 'write-error', script: `Write-Error "werr"`, code: 0, contains: 'werr' },
+  { name: 'cmd exit 7', script: `cmd /c exit 7`, code: 7 },
+  { name: 'stderr only', script: `[Console]::Error.WriteLine('e1')`, code: 0, out: '', err: 'e1' },
+  { name: 'out and err', script: `Write-Output 'o1'; [Console]::Error.WriteLine('e1')`, code: 0, out: 'o1', err: 'e1' },
+  { name: 'flush before exit', script: `Write-Output 'before'; exit 4`, code: 4, out: 'before' },
+  { name: 'error then exit', script: `Get-ChildItem C:\\definitely-not-here-xyz; exit 6`, code: 6, contains: 'Cannot find path' },
+  { name: 'exit in function', script: `function f { exit 9 }; f`, code: 9 },
+  { name: 'negative-ish LASTEXITCODE', script: `cmd /c "exit 0"`, code: 0 },
+  { name: 'pipeline ok', script: `1..3 | ForEach-Object { $_ }`, code: 0, out: '1\r\n2\r\n3' },
+]
+
+let bad = 0
+console.log('=== edge cases ===')
+for (const c of cases) {
+  try {
+    const r = await runScript(conn, c.script, { timeoutMs: 60_000 })
+    const problems: string[] = []
+    if (c.code !== undefined && r.exitCode !== c.code) problems.push(`code=${r.exitCode} want=${c.code}`)
+    if (typeof c.out === 'string' && r.stdout.trimEnd() !== c.out) problems.push(`out=${JSON.stringify(r.stdout)} want=${JSON.stringify(c.out)}`)
+    if (c.err !== undefined && r.stderr.trim() !== c.err) problems.push(`err=${JSON.stringify(r.stderr)} want=${JSON.stringify(c.err)}`)
+    if (c.contains !== undefined && !r.stdout.includes(c.contains)) problems.push(`missing ${JSON.stringify(c.contains)}`)
+    if (problems.length > 0) { bad++; console.log(`BAD  ${c.name}: ${problems.join('; ')}`) }
+    else console.log(`ok   ${c.name} [${r.durationMs}ms]`)
+  } catch (error) {
+    bad++
+    console.log(`THREW ${c.name}: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}
+
+// Big output that a mid-script exit must not truncate.
+{
+  const r = await runScript(conn, `1..2000 | ForEach-Object { "line$_" }; exit 5`, { timeoutMs: 120_000 })
+  const lines = r.stdout.trim().split(/\r?\n/).length
+  const ok = r.exitCode === 5 && lines >= 2000
+  if (!ok) bad++
+  console.log(`${ok ? 'ok  ' : 'BAD '} flush big then exit: code=${r.exitCode} lines=${lines} [${r.durationMs}ms]`)
+}
+
+// Scripts far past the ~8191-char command line: the whole point of the rewrite.
+console.log('=== large payloads (command line cannot carry these) ===')
+for (const size of [5_000, 50_000, 200_000]) {
+  const r = await runScript(conn, `# ${'x'.repeat(size)}\nWrite-Output 'ok'`, { timeoutMs: 120_000 })
+  const ok = r.exitCode === 0 && r.stdout.trim() === 'ok'
+  if (!ok) bad++
+  console.log(`${ok ? 'ok  ' : 'BAD '} script=${size} chars code=${r.exitCode} out=${JSON.stringify(r.stdout.trim())} [${r.durationMs}ms]`)
+}
+
+// Multi-byte payload: length is counted in bytes, split on code points.
+{
+  const r = await runScript(conn, `# ${'中'.repeat(50_000)}\nWrite-Output 'ok'`, { timeoutMs: 120_000 })
+  const ok = r.exitCode === 0 && r.stdout.trim() === 'ok'
+  if (!ok) bad++
+  console.log(`${ok ? 'ok  ' : 'BAD '} multibyte 150KB code=${r.exitCode} [${r.durationMs}ms]`)
+}
+
+// The transfer chunk that used to blow the command line (~65K base64 chars).
+console.log('=== transfer chunk (previously structurally broken) ===')
+{
+  const r = await runScript(conn, psReadChunk('C:\\Windows\\System32\\notepad.exe', 0, TRANSFER_CHUNK), { timeoutMs: 120_000 })
+  const bytes = Buffer.from(r.stdout.trim(), 'base64').length
+  const ok = r.exitCode === 0 && bytes === TRANSFER_CHUNK
+  if (!ok) bad++
+  console.log(`${ok ? 'ok  ' : 'BAD '} read ${TRANSFER_CHUNK} bytes: code=${r.exitCode} decoded=${bytes} [${r.durationMs}ms]`)
+}
+
+// Real upload/download round trip well past the old limit.
+console.log('=== upload/download round trip ===')
+{
+  const remote = 'C:\\temp\\dsh-winrm-verify\\blob.bin'
+  const data = Buffer.alloc(200 * 1024)
+  for (let i = 0; i < data.length; i++) data[i] = (i * 31 + 7) & 0xff
+  const written = await uploadBuffer(conn, remote, data, undefined, 120_000)
+  const size = await remoteFileSize(conn, remote, 60_000)
+  const chunks: Buffer[] = []
+  const read = await downloadChunks(conn, remote, b64 => { chunks.push(Buffer.from(b64, 'base64')) }, undefined, 120_000)
+  const back = Buffer.concat(chunks)
+  const same = back.length === data.length && back.equals(data)
+  const ok = written === data.length && size === data.length && read === data.length && same
+  if (!ok) bad++
+  console.log(`${ok ? 'ok  ' : 'BAD '} 200KB round trip: written=${written} size=${size} read=${read} identical=${same}`)
+  await runScript(conn, `Remove-Item -LiteralPath 'C:\\temp\\dsh-winrm-verify' -Recurse -Force -ErrorAction SilentlyContinue`, { timeoutMs: 60_000 })
+}
+
+// Sanity: a script that never reaches the envelope must not claim success.
+{
+  const r = await runScript(conn, `Write-Output 'ok'`, { timeoutMs: 60_000 })
+  console.log(`ok   sanity re-check code=${r.exitCode} out=${JSON.stringify(r.stdout.trim())}`)
+}
+
+console.log(bad === 0 ? '\nALL PASS' : `\n${bad} FAILURE(S)`)
+process.exit(bad === 0 ? 0 : 1)

package/src/engine/client.ts

@@ -2,11 +2,11 @@
  * WinRM transport bridge.
  *
  * Runs each PowerShell payload over a native Node.js WinRM client
- * (winrm-client) — no Python/pywinrm subprocess. The script rides the
- * UTF-8 base64 envelope (marker + base64 of UTF-8 output) so Chinese and
- * any codepage output survives the WinRM transport losslessly; the envelope
- * is base64-encoded with `-EncodedCommand`, keeping the command line a
- * single ASCII-safe line that WinRS/cmd.exe cannot mangle.
+ * (winrm-client) — no Python/pywinrm subprocess. The script is delivered on
+ * the WinRS **stdin** stream and answers on the UTF-8 base64 envelope, so
+ * Chinese and any codepage output survives the transport losslessly and the
+ * command line stays a constant, ASCII-safe line that WinRS/cmd.exe cannot
+ * mangle. See powershell.ts for why the command line cannot carry the script.
  *
  * Auth is chosen per attempt (HTTPS: Basic first, then NTLM; HTTP: NTLM
  * first, then Basic) with fallback, so a host that only enables one scheme
@@ -16,7 +16,7 @@
 
 import { Command, Shell } from 'winrm-client'
 import type { WinHostEntry } from '../protocol.ts'
-import { parseEnvelope, powershellCommandLine, psFileSize, psReadChunk, psWriteChunk, stripClixml, winrmPowerShellScript } from '../powershell.ts'
+import { parseEnvelope, powershellCommandLine, psFileSize, psReadChunk, psWriteChunk, scriptPayload, splitScriptPayload, stripClixml } from '../powershell.ts'
 
 /** Connection parameters for one target (transport-agnostic projection of a host entry). */
 export interface WinRMParams {
@@ -86,11 +86,11 @@ function baseParams(conn: WinRMParams, authMethod: WinrmAuth) {
 }
 
 /**
- * One shell lifecycle: create → run the encoded script → receive until the
- * command completes → delete. Bounded by an overall deadline; on timeout the
- * delete is fired without blocking the caller.
+ * One shell lifecycle: create → run the constant envelope script → push the
+ * payload on stdin → receive until the command completes → delete. Bounded by
+ * an overall deadline; on timeout the delete is fired without blocking.
  * @param conn - connection parameters.
- * @param envelope - the wrapped UTF-8 envelope script (already prepared).
+ * @param payload - the stdin payload (`<byteCount>\n<script>`).
  * @param timeoutMs - command execution budget measured from just after Execute.
  * @param authMethod - the auth scheme for this attempt.
  * @returns stdout/stderr captured from the WinRS streams.
@@ -98,7 +98,7 @@ function baseParams(conn: WinRMParams, authMethod: WinrmAuth) {
  */
 async function attemptOnce(
   conn: WinRMParams,
-  envelope: string,
+  payload: string,
   timeoutMs: number,
   authMethod: WinrmAuth,
 ): Promise<{ stdout: string; stderr: string }> {
@@ -117,8 +117,10 @@ async function attemptOnce(
       void Shell.doDeleteShell({ ...base, shellId }).catch(() => undefined)
       throw new WinrmTimedOut()
     }
-    const command = powershellCommandLine(envelope)
-    const commandId = await Command.doExecuteCommand({ ...base, shellId, command })
+    const commandId = await Command.doExecuteCommand({ ...base, shellId, command: powershellCommandLine() })
+    for (const piece of splitScriptPayload(payload)) {
+      await Command.doSendInput({ ...base, shellId, commandId, input: piece })
+    }
     const receive = { ...base, shellId, commandId }
     const commandDeadline = Date.now() + timeoutMs
     let stdout = ''
@@ -156,21 +158,21 @@ async function attemptOnce(
  * succeeds. A timeout aborts immediately (retrying auth would waste the
  * remaining budget on a reachable-but-slow host).
  * @param conn - connection parameters.
- * @param envelope - the wrapped UTF-8 envelope script.
+ * @param payload - the stdin payload (`<byteCount>\n<script>`).
  * @param timeoutMs - command execution budget.
  * @returns captured stdout/stderr.
  * @throws WinrmTimedOut on deadline; the last auth/transport error when every scheme fails.
  */
 async function runWinrm(
   conn: WinRMParams,
-  envelope: string,
+  payload: string,
   timeoutMs: number,
 ): Promise<{ stdout: string; stderr: string }> {
   const candidates: WinrmAuth[] = conn.useHttps ? ['basic', 'ntlm'] : ['ntlm', 'basic']
   let lastError: unknown
   for (const authMethod of candidates) {
     try {
-      return await attemptOnce(conn, envelope, timeoutMs, authMethod)
+      return await attemptOnce(conn, payload, timeoutMs, authMethod)
     } catch (error) {
       if (error instanceof WinrmTimedOut) throw error
       lastError = error
@@ -186,11 +188,11 @@ export async function runScript(
 ): Promise<{ stdout: string; stderr: string; exitCode: number | null; timedOut: boolean; durationMs: number }> {
   const started = Date.now()
   const timeoutMs = options.timeoutMs ?? 60_000
-  const envelope = winrmPowerShellScript(script)
+  const payload = scriptPayload(script)
 
   let outcome: { stdout: string; stderr: string }
   try {
-    outcome = await runWinrm(conn, envelope, timeoutMs)
+    outcome = await runWinrm(conn, payload, timeoutMs)
   } catch (error) {
     if (error instanceof WinrmTimedOut) {
       return { stdout: '', stderr: '', exitCode: null, timedOut: true, durationMs: Date.now() - started }
@@ -207,10 +209,10 @@ export async function runScript(
   const exitCode = parsed !== null ? parsed.exitCode : 1
   // A script that reached the envelope leaves only the host's CLIXML records
   // on stderr; an aborted one keeps its stderr untouched for diagnosis.
-  const stderr = parsed !== null ? stripClixml(outcome.stderr) : outcome.stderr
+  const stderr = parsed !== null ? stripClixml(parsed.stderr) : outcome.stderr
   options.onChunk?.({ output: raw, stderr })
   return {
-    stdout: parsed !== null ? parsed.text : raw,
+    stdout: parsed !== null ? parsed.stdout : raw,
     stderr,
     exitCode,
     timedOut: false,