@envseal/prompters 0.1.0

package/dist/registry.js

@@ -0,0 +1,60 @@
+import { IdePrompter } from './ide.js';
+import { LoopbackPrompter } from './loopback.js';
+import { NativePrompter } from './native.js';
+import { NonePrompter } from './none.js';
+import { TtyPrompter } from './tty.js';
+let ide = null;
+let loopback = null;
+let native = null;
+let tty = null;
+const none = new NonePrompter();
+export function allPrompters() {
+    loopback ??= new LoopbackPrompter();
+    native ??= new NativePrompter();
+    ide ??= new IdePrompter();
+    tty ??= new TtyPrompter();
+    return [loopback, native, ide, tty, none];
+}
+/**
+ * Select the first available surface in the order mandated by PLAN.md §5.3:
+ * prefer -> ide -> native-dialog (SEP_PREFER_NATIVE) -> loopback-browser ->
+ * tty (opt-in) -> none. A `CI` environment forces `none` unless `prefer`
+ * names a concrete surface.
+ */
+export async function selectPrompter(opts = {}) {
+    if (opts.prefer !== undefined) {
+        const preferred = allPrompters().find((p) => p.id === opts.prefer);
+        if (preferred === undefined) {
+            throw new Error(`unknown prompter id: ${opts.prefer}`);
+        }
+        if (await preferred.available()) {
+            return preferred;
+        }
+        throw new Error(`preferred prompter is not available: ${opts.prefer}`);
+    }
+    if (process.env.CI !== undefined) {
+        return none;
+    }
+    ide ??= new IdePrompter();
+    if (await ide.available()) {
+        return ide;
+    }
+    if (process.env.SEP_PREFER_NATIVE !== undefined) {
+        native ??= new NativePrompter();
+        if (await native.available()) {
+            return native;
+        }
+    }
+    loopback ??= new LoopbackPrompter();
+    if (await loopback.available()) {
+        return loopback;
+    }
+    if (opts.allowTty === true) {
+        tty ??= new TtyPrompter();
+        if (await tty.available()) {
+            return tty;
+        }
+    }
+    return none;
+}
+//# sourceMappingURL=registry.js.map

package/dist/tty.d.ts

@@ -0,0 +1,10 @@
+import type { Prompter, PromptRequest, PromptResponse } from './types.js';
+export declare class TtyPrompter implements Prompter {
+    readonly id: 'tty';
+    available(): Promise<boolean>;
+    private openReadFd;
+    private openWriteFd;
+    cancel(_ticket: string): Promise<void>;
+    prompt(req: PromptRequest): Promise<PromptResponse>;
+}
+//# sourceMappingURL=tty.d.ts.map

package/dist/tty.js

@@ -0,0 +1,166 @@
+// NOTE: This is NOT the default surface. Opening the controlling TTY collides
+// with a harness's full-screen TUI repainting (PLAN.md §5.3). It is only
+// selected explicitly, or as the last usable fallback when allowed.
+import { openSync, writeSync, closeSync } from 'node:fs';
+import { ReadStream } from 'node:tty';
+import { spawn } from 'node:child_process';
+import { asSecret } from '@envseal/protocol';
+const POSIX_DEVICE = '/dev/tty';
+const WIN_IN = 'CONIN$';
+const WIN_OUT = 'CONOUT$';
+const ENABLE_ECHO_INPUT = 0x4;
+function isPosix() {
+    return process.platform !== 'win32';
+}
+function readLineRaw(inStream, outFd, prompt) {
+    return new Promise((resolve, reject) => {
+        writeSync(outFd, `${prompt}: `);
+        let buffer = '';
+        let done = false;
+        const settle = (value, err) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            process.removeListener('SIGINT', onSigint);
+            inStream.removeListener('data', onData);
+            inStream.removeListener('error', onError);
+            if (err !== undefined) {
+                reject(err);
+            }
+            else {
+                resolve(value);
+            }
+        };
+        const onSigint = () => {
+            settle('');
+        };
+        const onData = (chunk) => {
+            const text = chunk.toString('utf8');
+            const at = text.search(/[\r\n]/);
+            if (at !== -1) {
+                settle(buffer + text.slice(0, at));
+                return;
+            }
+            buffer += text;
+        };
+        const onError = (err) => {
+            settle('', err);
+        };
+        process.once('SIGINT', onSigint);
+        inStream.on('data', onData);
+        inStream.on('error', onError);
+    });
+}
+function winConsoleScript(enableEcho) {
+    const setMode = enableEcho
+        ? '($m -bor 4)'
+        : '($m -band (-bnot 4))';
+    return ("$sig='[DllImport(\"kernel32.dll\",SetLastError=$true)] public static extern bool " +
+        'SetConsoleMode(IntPtr h,uint mode); [DllImport("kernel32.dll",SetLastError=$true)] ' +
+        'public static extern bool GetConsoleMode(IntPtr h,[ref]uint mode); ' +
+        '[DllImport("kernel32.dll",SetLastError=$true)] public static extern IntPtr GetStdHandle(int n);\'; ' +
+        'Add-Type -Namespace EnvSeal -MemberDefinition $sig -Name Native; ' +
+        '$h=[EnvSeal.Native]::GetStdHandle(-10); ' +
+        '[uint32]$m=0; ' +
+        '[void][EnvSeal.Native]::GetConsoleMode($h,[ref]$m); ' +
+        `[void][EnvSeal.Native]::SetConsoleMode($h,${setMode}); `);
+}
+/** Toggle echo on the console input buffer shared by this process (SetConsoleMode). */
+function setWinConinEcho(enabled) {
+    const encoded = Buffer.from(winConsoleScript(enabled), 'utf8').toString('base64');
+    return new Promise((resolve, reject) => {
+        const child = spawn('powershell', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
+            windowsHide: true,
+        });
+        child.once('error', reject);
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`SetConsoleMode failed with exit code ${code}`));
+            }
+        });
+    });
+}
+export class TtyPrompter {
+    id = 'tty';
+    async available() {
+        try {
+            const fd = this.openReadFd();
+            new ReadStream(fd).destroy();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    openReadFd() {
+        return isPosix() ? openSync(POSIX_DEVICE, 'r+') : openSync(WIN_IN, 'r');
+    }
+    openWriteFd(readFd) {
+        return isPosix() ? readFd : openSync(WIN_OUT, 'w');
+    }
+    async cancel(_ticket) {
+        // A raw read is interrupted from the reading side (SIGINT or device close).
+    }
+    async prompt(req) {
+        const results = [];
+        const readFd = this.openReadFd();
+        const writeFd = this.openWriteFd(readFd);
+        const inStream = new ReadStream(readFd);
+        let modeChanged = false;
+        try {
+            if (isPosix()) {
+                inStream.setRawMode(true);
+                modeChanged = true;
+            }
+            else {
+                await setWinConinEcho(false);
+                modeChanged = true;
+            }
+            for (const key of req.keys) {
+                const line = await readLineRaw(inStream, writeFd, formatLabel(key));
+                if (line === '') {
+                    results.push({ key: key.key, outcome: 'skipped' });
+                    continue;
+                }
+                results.push({ key: key.key, outcome: 'entered', value: asSecret(Buffer.from(line, 'utf8')) });
+            }
+        }
+        finally {
+            if (isPosix()) {
+                if (modeChanged) {
+                    try {
+                        inStream.setRawMode(false);
+                    }
+                    catch {
+                        // stream already destroyed
+                    }
+                }
+            }
+            else if (modeChanged) {
+                try {
+                    await setWinConinEcho(true);
+                }
+                catch {
+                    // best-effort restore
+                }
+            }
+            inStream.destroy();
+            if (!isPosix()) {
+                closeSync(writeFd);
+            }
+        }
+        return { ticket: req.ticket, results };
+    }
+}
+function formatLabel(key) {
+    let label = key.key;
+    if (key.description) {
+        label += ` (${key.description})`;
+    }
+    return label;
+}
+//# sourceMappingURL=tty.js.map

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import type { SecretValue } from '@envseal/protocol';
+export interface PromptKeyRequest {
+    key: string;
+    description: string;
+    providerName?: string;
+    signupUrl?: string;
+    docsUrl?: string;
+    formatHint?: string;
+    pattern?: string;
+    optional?: boolean;
+}
+export interface PromptRequest {
+    ticket: string;
+    nonce: string;
+    projectRoot: string;
+    reason: string;
+    keys: PromptKeyRequest[];
+    timeoutMs: number;
+}
+export type PromptKeyResult = {
+    key: string;
+    outcome: 'entered';
+    value: SecretValue;
+} | {
+    key: string;
+    outcome: 'skipped' | 'cancelled' | 'timeout';
+};
+export interface PromptResponse {
+    ticket: string;
+    results: PromptKeyResult[];
+}
+export type PrompterId = 'loopback-browser' | 'native-dialog' | 'ide' | 'tty' | 'none';
+export interface Prompter {
+    readonly id: PrompterId;
+    available(): Promise<boolean>;
+    prompt(req: PromptRequest): Promise<PromptResponse>;
+    cancel(ticket: string): Promise<void>;
+}
+export declare function makeDisplayNonce(): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,18 @@
+import { randomBytes } from 'node:crypto';
+const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+export function makeDisplayNonce() {
+    const bytes = randomBytes(8);
+    let out = '';
+    for (let i = 0; i < 8; i += 1) {
+        const byte = bytes[i];
+        if (byte === undefined) {
+            break;
+        }
+        out += CROCKFORD.charAt(byte & 0x1f);
+        if (i === 3) {
+            out += '-';
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@envseal/prompters",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@envseal/protocol": "0.1.0"
+  },
+  "devDependencies": {
+    "undici": "^7.2.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}