dsh-winrm 0.1.0

package/lib/types/loopback.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Loopback trust fence shared by the host route families: socket address,
+ * Host header, and browser same-origin markers. Packages receive this file as
+ * a generated copy via scripts/sync-shared.mjs; edit the shared source and
+ * re-run the sync instead of editing a copy.
+ *
+ * Semantics: RFC 5735 IPv4 127/8, ::1, IPv4-mapped ::ffff:127/8 (matching the
+ * remote-web-ui gate), localhost hostnames, plus the browser same-origin
+ * markers (sec-fetch-site and Origin) for the request-level fence.
+ * @module dsh-web-ui-shared/host/loopback
+ */
+import type { IncomingMessage } from 'node:http';
+/** IPv4 127/8 predicate (four decimal octets, first == 127). */
+export declare function isIPv4Loopback(v4: string): boolean;
+/** Whether a socket remote address names the loopback range (127/8, ::1, IPv4-mapped). */
+export declare function isLoopbackAddress(address: string | undefined): boolean;
+/** Whether a normalized URL hostname names the loopback authority (localhost, [::1], 127/8). */
+export declare function isLoopbackHostname(hostname: string): boolean;
+/**
+ * Request-level trust fence: a loopback socket address AND a loopback Host
+ * header, plus browser same-origin markers. The socket address is
+ * authoritative; X-Forwarded-For is never trusted.
+ */
+export declare function isLoopbackRequest(request: IncomingMessage): boolean;

package/lib/types/mount-once.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Host single-instance guard shared by the plugin family. The family bundle
+ * (dsh-web-ui-all / dsh-skins) namespaces every child row id (web-ui-*), so
+ * the loader accepts a standalone install of the same package side by side;
+ * without this guard the second instance would still re-register the same
+ * webserver routes, tools, settings namespaces, and system-prompt sections
+ * and fail the boot. mountOnce makes the second host apply a no-op for the
+ * lifetime of the first instance (the browser half is already deduped by
+ * package name in the client module host).
+ *
+ * The registry rides a global symbol so two module instances of the same
+ * package (npm copy vs repository link) still share one verdict. cordis
+ * `ctx.effect` runs its callback immediately and treats the callback's
+ * return value as the fiber disposer, so the unmarker is returned, not run.
+ */
+/**
+ * Wrap a cordis plugin apply so the package runs at most once per process.
+ * The first mount registers normally and unmarks when its fiber disposes;
+ * any later mount of the same package name is a no-op.
+ * @param packageName - npm package identity shared by every install source.
+ * @param fn - the original plugin apply.
+ * @returns an apply of the same shape.
+ */
+export declare function mountOnce<T extends (...args: any[]) => unknown>(packageName: string, fn: T): T;

package/lib/types/powershell.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+/** Marker line prefix carrying the exit code: '__DSH_WINRM__<code>'. */
+export declare const ENVELOPE_MARKER = "__DSH_WINRM__";
+/** 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.
+ */
+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;
+/** JSON: full service table (CIM). */
+export declare function psListServices(): string;
+/** JSON: one service after an action. */
+export declare function psServiceAction(name: string, action: 'start' | 'stop' | 'restart' | 'set-auto' | 'set-manual' | 'set-disabled'): string;
+/** JSON: process table. */
+export declare function psListProcesses(): string;
+/** Kill one process by id. */
+export declare function psKillProcess(id: number): string;
+/** JSON: directory listing. */
+export declare function psListDir(dir: string): string;
+/** Plain: remote file size in bytes (0 when missing). */
+export declare function psFileSize(p: string): string;
+/** Plain: base64 of up to `count` bytes at `offset` (download chunk). */
+export declare function psReadChunk(p: string, offset: number, count: number): string;
+/**
+ * Plain: append `b64` bytes to `p` (Create on first chunk, Append after),
+ * prints the number of bytes written.
+ */
+export declare function psWriteChunk(p: string, b64: string, append: boolean): string;
+/**
+ * Parse the envelope output: { exitCode, text } 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.
+ */
+export declare function parseEnvelope(output: string): {
+    exitCode: number;
+    text: string;
+} | null;
+/**
+ * Remove PowerShell's CLIXML host records from the WinRS stderr stream.
+ *
+ * PowerShell marks its stderr stream with a `#< CLIXML` header line and
+ * serializes the remote host's own progress/verbose records into `<Objs>`
+ * blocks. Both are removed here. Anything else on the stream is genuine
+ * process-level stderr and is preserved verbatim — text written between the
+ * 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.
+ * @returns the stderr text without CLIXML host records.
+ */
+export declare function stripClixml(stderr: string): string;

package/lib/types/protocol.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Wire contract between the host half (routes.ts) and the browser half
+ * (client/api.ts). Pure types only — imported by both halves, bundled into
+ * each, no runtime identity to share.
+ */
+/** WinRM transport flavors. */
+export type WinTransport = 'http' | 'https';
+/** One stored host entry (the ~/.dsh/dsh-winrm.json store shape). */
+export interface WinHostEntry {
+    /** Stable, user-chosen identifier used by every operation. */
+    alias: string;
+    /** Hostname or IP of the target Windows machine. */
+    host: string;
+    /** WinRM port (5985 HTTP, 5986 HTTPS). */
+    port: number;
+    /** Login user. The transport auto-selects NTLM/Negotiate or Basic for local and domain accounts. */
+    user: string;
+    /** Authentication (WinRM password; transport handles NTLM/Negotiate/Basic in-process). */
+    auth: {
+        kind: 'password';
+        password?: string;
+    };
+    /** http (5985) or https (5986). */
+    transport: WinTransport;
+    /** Whether self-signed HTTPS certificates are accepted. */
+    rejectUnauthorized?: boolean;
+    /** Free-form note. */
+    description?: string;
+    /** Deployment environment label (development / production / ...). */
+    environment?: string;
+    /** Free-form tags. */
+    tags: string[];
+    /** Physical location note. */
+    location?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Public (secret-free) projection of an entry, safe for the browser/agent. */
+export interface WinHostSummary {
+    alias: string;
+    host: string;
+    port: number;
+    user: string;
+    auth: 'password';
+    transport: WinTransport;
+    rejectUnauthorized?: boolean;
+    description?: string;
+    environment?: string;
+    tags: string[];
+    location?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Result of one PowerShell command execution. */
+export interface ExecResult {
+    success: boolean;
+    /** Remote exit code, or null when the channel died without one. */
+    exitCode: number | null;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    /** Wall-clock duration of the round trip in ms. */
+    durationMs: number;
+    /** Connection error message when the command never ran. */
+    error?: string;
+}
+/** One Windows service entry. */
+export interface ServiceInfo {
+    name: string;
+    displayName: string;
+    status: string;
+    startMode: string;
+    startName?: string;
+}
+/** One Windows process entry. */
+export interface ProcessInfo {
+    id: number;
+    name: string;
+    cpu?: number;
+    memMB?: number;
+    startTime?: string;
+    path?: string;
+}
+/** One directory listing entry (remote file browser). */
+export interface RemoteDirEntry {
+    name: string;
+    type: 'dir' | 'file' | 'other';
+    size: number;
+    mtimeMs: number;
+}
+/** One server entry in a cluster run. */
+export interface ClusterResult {
+    alias: string;
+    ok: boolean;
+    exitCode?: number | null;
+    timedOut?: boolean;
+    stdout?: string;
+    stderr?: string;
+    durationMs?: number;
+    error?: string;
+}
+/** Transfer progress frame (upload/download). */
+export interface TransferProgress {
+    phase: 'connecting' | 'transferring' | 'done' | 'error';
+    file: string;
+    transferred: number;
+    total: number;
+    percent: number;
+    speedBps?: number;
+    error?: string;
+}
+/** Test-connection outcome. */
+export interface TestResult {
+    ok: boolean;
+    latencyMs?: number;
+    error?: string;
+}
+/** Host edit payload (create/update); 'alias' comes from the URL for updates. */
+export interface WinHostPayload {
+    alias?: string;
+    host: string;
+    port?: number;
+    user: string;
+    /** Authentication. Required on create; on update an omitted auth keeps the stored password. */
+    auth?: WinHostEntry['auth'];
+    transport?: WinTransport;
+    rejectUnauthorized?: boolean;
+    description?: string;
+    environment?: string;
+    tags?: string[];
+    location?: string;
+}
+/** JSON error body used by every route. */
+export interface ApiErrorBody {
+    error: string;
+}
+/** WebSocket console protocol frames (host -> client and client -> host). */
+export type ConsoleServerFrame = {
+    type: 'ready';
+    alias: string;
+} | {
+    type: 'output';
+    data: string;
+} | {
+    type: 'exit';
+    code: number | null;
+    error?: string;
+};
+export type ConsoleClientFrame = {
+    type: 'input';
+    data: string;
+};
+/** Route paths the client calls (shared literals). */
+export declare const WINRM_API_BASE: "/api/dsh-winrm";
+export declare const WINRM_API: {
+    readonly hosts: string;
+    readonly test: string;
+    readonly exec: string;
+    readonly cluster: string;
+    readonly services: string;
+    readonly processes: string;
+    readonly ls: string;
+    readonly upload: string;
+    readonly download: string;
+    readonly console: string;
+};
+/** NDJSON transfer stream line shapes (upload). */
+export type TransferStreamLine = {
+    type: 'progress';
+    progress: TransferProgress;
+} | {
+    type: 'result';
+    ok: boolean;
+    transferredBytes?: number;
+    error?: string;
+};

package/lib/types/routes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The /api/dsh-winrm route family: host CRUD, exec, cluster, services,
+ * processes, remote listing, NDJSON upload progress, binary download, and
+ * the WebSocket PowerShell console upgrade. Every route carries a
+ * loopback-only trust fence (plus browser same-origin markers) — these
+ * endpoints execute commands on remote machines, so LAN-exposed dsh web
+ * deployments must not serve them.
+ */
+import type { WebRoute, WebUpgradeRoute } from '@deepseek-ai/dsh-host-webserver';
+import type { WinRmEngine } from './engine.ts';
+import type { HostStore } from './store.ts';
+/** Route family dependencies. */
+export interface WinrmRoutesDeps {
+    store: HostStore;
+    engine: WinRmEngine;
+    stagingDir?: string;
+    maxUploadBytes?: number;
+}
+/**
+ * Build every /api/dsh-winrm route plus the console upgrade.
+ * @param deps - store, engine, staging dir.
+ */
+export declare function makeRoutes(deps: WinrmRoutesDeps): {
+    routes: WebRoute[];
+    upgrade: WebUpgradeRoute;
+};

package/lib/types/smb.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SMB transfer bridge.
+ *
+ * The WinRM base64 chunk bridge is reliable for small files but breaks for
+ * large artifacts (the WinRM/HTTP envelope rejects large payloads), so whole
+ * files ride the remote admin share. This module mounts the remote host's
+ * admin share with `net use` (password passed via stdin, never argv), copies
+ * whole files with node:fs, then verifies the SHA-256 on both ends.
+ */
+import type { WinHostEntry } from './protocol.ts';
+/** Per-transfer channel selector. */
+export type TransferChannel = 'auto' | 'smb' | 'winrm';
+export interface SmbTransferResult {
+    bytes: number;
+    channel: 'smb';
+}
+/**
+ * Convert a Windows drive path to its UNC admin-share form.
+ * D:\\dir\\file -> \\\\host\\D$\\dir\\file
+ */
+export declare function adminSharePath(host: string, remotePath: string): string;
+/**
+ * Copy one local file to a remote Windows host over SMB, verifying the
+ * remote SHA-256 matches the local source.
+ */
+export declare function uploadSmb(entry: WinHostEntry, localPath: string, remotePath: string, timeoutMs?: number): Promise<SmbTransferResult>;
+/**
+ * Copy one remote Windows file to a local path over SMB and verify the local
+ * SHA-256 matches the remote source.
+ */
+export declare function downloadSmb(entry: WinHostEntry, remotePath: string, localPath: string, timeoutMs?: number): Promise<SmbTransferResult>;

package/lib/types/store.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Host config store: one JSON file (~/.dsh/dsh-winrm.json) holding every
+ * Windows host entry, written atomically (tmp + rename). Secrets (passwords)
+ * live in this user-owned file in plaintext — the same trust model as
+ * dsh-ssh; document it, never log it.
+ */
+import type { WinHostEntry, WinHostPayload, WinHostSummary } from './protocol.ts';
+/** Store file location: <home>/.dsh/dsh-winrm.json. */
+export declare function storePath(): string;
+/** Validate the wire shape of a host payload; returns a message or undefined. */
+export declare function validateHostPayload(payload: unknown): string | undefined;
+/** Validate an alias for creation. */
+export declare function validateAlias(alias: string): string | undefined;
+/**
+ * The host store. Pure file I/O — no cordis dependency, unit-testable.
+ */
+export declare class HostStore {
+    /** The JSON file path. */
+    readonly path: string;
+    /**
+     * @param path - store file path (defaults to the standard location).
+     */
+    constructor(path?: string);
+    /** Load all entries (empty store when the file is absent). */
+    list(): WinHostEntry[];
+    /** Find one entry by alias. */
+    find(alias: string): WinHostEntry | undefined;
+    /** Secret-free projection for the browser and agent surfaces. */
+    summarize(entry: WinHostEntry): WinHostSummary;
+    /** Create one entry. Throws on alias collision or invalid payload. */
+    create(payload: WinHostPayload): WinHostEntry;
+    /** Update the fields present in `patch`; unknown aliases throw. */
+    update(alias: string, patch: Partial<WinHostPayload>): WinHostEntry;
+    /** Remove one entry. */
+    delete(alias: string): void;
+    /**
+     * Last parsed store keyed by file identity. list/find ride every acquire
+     * and GUI refresh; re-reading and re-parsing the whole file each call is
+     * wasted work when the file has not changed. Any save invalidates.
+     */
+    private cache;
+    private load;
+    private save;
+}

package/lib/types/tools.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Agent tools: the DSH-native counterpart of the GUI — every tool talks to
+ * the same engine the web UI uses, so a host configured in the GUI is
+ * immediately operable by any agent, and vice versa.
+ */
+import type { WinRmEngine } from './engine.ts';
+/** The host-list tool. */
+export declare function winrmListTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** The command-execution tool (PowerShell). */
+export declare function winrmExecTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** The service-management tool. */
+export declare function winrmServiceTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** The process-management tool. */
+export declare function winrmProcessTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** The upload tool. */
+export declare function winrmUploadTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** The download tool. */
+export declare function winrmDownloadTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** The cluster tool. */
+export declare function winrmClusterTool(engine: WinRmEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/package.json

@@ -0,0 +1,111 @@
+{
+  "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.0",
+  "type": "module",
+  "packageManager": "pnpm@11.7.0",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ],
+      "platform": "web"
+    }
+  },
+  "dependencies": {
+    "winrm-client": "^0.0.12",
+    "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",
+    "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/schemastery": "^3.18.4",
+    "@types/node": "^22.20.0",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "^18.3.5",
+    "@types/ws": "^8.5.13",
+    "lightningcss": "^1.29.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tsdown": "0.22.2",
+    "typescript": "~5.7.2"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "src",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "RELEASING.md",
+    "scripts"
+  ],
+  "license": "Apache-2.0",
+  "scripts": {
+    "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",
+    "check": "npm run typecheck && npm run build && npm test",
+    "pack:check": "npm pack --dry-run --json",
+    "prepack": "npm run check",
+    "typecheck": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MoRanYue/dsh-winrm.git"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "windows",
+    "winrm",
+    "remote",
+    "powershell",
+    "bundle-plugin"
+  ]
+}

package/scripts/postbuild.mjs

@@ -0,0 +1,40 @@
+/**
+ * Post-build step: wrap the rolldown CJS client bundle in the GUI module
+ * loader handoff (window.__ModuleLoader__.load({id, factory})) and restore
+ * the CJS preamble (var module/exports) that this rolldown generation omits,
+ * exactly matching the official dsh-web-ui artifact shape. Emits
+ * lib/client.js that the loader serves at /plugins/winrm/client.js.
+ *
+ * The source map stays a local debugging aid and is not part of the published
+ * payload (`files` omits `*.map`), so the wrapper does not reference it — a
+ * published bundle must not point at a file that is not shipped.
+ */
+import { readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+
+const lib = fileURLToPath(new URL('../lib/', import.meta.url))
+const id = 'dsh-winrm'
+
+const cjs = readFileSync(join(lib, 'client.cjs'), 'utf8')
+const map = join(lib, 'client.cjs.map')
+const mapJs = join(lib, 'client.js.map')
+try { renameSync(map, mapJs) } catch { /* optional */ }
+
+const body = cjs.replace(/\/\/# sourceMappingURL=client\.cjs\.map\s*$/, '')
+const wrapped = [
+  'window.__ModuleLoader__.load({',
+  '\tid: ' + JSON.stringify(id) + ',',
+  '\tfactory: (require) => {',
+  '\t\tvar module = { exports: {} };',
+  '\t\tvar exports = module.exports;',
+  body,
+  '\t\treturn module.exports;',
+  '\t}',
+  '});',
+  '',
+].join('\n')
+
+writeFileSync(join(lib, 'client.js'), wrapped)
+try { renameSync(join(lib, 'client.cjs'), join(lib, 'client.cjs.bak')) } catch { /* keep both is fine */ }
+console.log('postbuild: wrapped lib/client.js (' + wrapped.length + 'B)')

package/scripts/validate-manifest.mjs

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'))
+if (!pkg.dsh || !pkg.dsh.bundle) {
+  console.error('package.json does not declare dsh.bundle')
+  process.exit(1)
+}
+const patch = pkg.dsh.bundle.patch
+if (!patch || !fs.existsSync(patch)) {
+  console.error('bundle patch not found: ' + String(patch))
+  process.exit(1)
+}
+const patchText = fs.readFileSync(patch, 'utf8')
+if (patchText.trim().length === 0) {
+  console.error(patch + ' is empty')
+  process.exit(1)
+}
+console.log('OK: dsh.bundle -> ' + patch)