@opentui/ssh

Every export of @opentui/ssh in the main-branch source, from its type declarations. A version names the release that added an export after the module's first release.

Functions#

function createServer(config?: Omit<ServerConfig, "auth"> & { auth?: "open"; }): ServerBuilder<IdentityFor<"open">>function createServer<A extends AuthConfig>(config: ServerConfig<A>): ServerBuilder<IdentityFor<A | "open">>function createServer<A extends AuthMethods>(config: Omit<ServerConfig, "auth"> & { auth: A; }): ServerBuilder<IdentityFor<A>>

SSH

function logging<Id extends Identity = Identity>(options?: LoggingOptions<Id>): Middleware<Id>

SSH

Classes#

class ConfigError extends SshErrorconstructor ConfigError(message: string)

SSH

class DenyError extends Errorconstructor DenyError(reason?: string)

SSH

• readonly property DenyError.reason: string | undefined

class OutputPressureError extends SshErrorconstructor OutputPressureError()

Added in 0.6.0SSH

class SshError extends Errorconstructor SshError(code: string, message: string)

SSH

• readonly property SshError.code: string

Interfaces#

interface AuthMethods extends CredentialMethods

SSH

• property AuthMethods.none?: never

interface Handoff<Add extends object = object>

SSH

• readonly property Handoff.[HANDOFF]: Add

interface ListenInfo

SSH

• property ListenInfo.fingerprints: string[]
• property ListenInfo.host: string
• property ListenInfo.port: number

interface LoggingOptions<Id extends Identity = Identity>

SSH

• property LoggingOptions.log?: (event: LogEvent<Id>) => void

interface MiddlewareSession<Id extends Identity = Identity, Ctx extends object = object> extends SessionCommon<Id>

SSH

• method MiddlewareSession.deny(reason?: string): never
• readonly property MiddlewareSession.context: Ctx

interface PublicKeyPolicy

SSH

• property PublicKeyPolicy.allow?: (ctx: { username: string; fingerprint: string; publicKey: PublicKey; }) => boolean | Promise<boolean>
• property PublicKeyPolicy.authorizedKeys?: string | string[]

interface RemoteAddress

SSH

• readonly property RemoteAddress.address: string
• readonly property RemoteAddress.port?: number

interface Server

SSH

• method Server.close(): Promise<void>
• method Server.listen(port?: number, host?: string): Promise<ListenInfo>

interface ServerBuilder<Id extends Identity = Identity, Ctx extends object = {}>

SSH

• method ServerBuilder.serve(handler: SessionHandler<Id, Ctx>): Server
• method ServerBuilder.use<Add extends object>(mw: MiddlewareFunction<Id, Ctx, Add>): ServerBuilder<Id, Ctx & Add>

interface ServerConfig<A extends AuthConfig = "open">

SSH

• property ServerConfig.auth?: A
• property ServerConfig.hostKey?: { path: string; } | { pem: string | Buffer | (string | Buffer)[]; }
• property ServerConfig.idleTimeout?: string | number
• property ServerConfig.limits?: { session?: { perConnection?: number; global?: number; }; }
• property ServerConfig.maxTimeout?: string | number
• property ServerConfig.onError?: (err: unknown) => void
• property ServerConfig.startupBanner?: boolean

interface Session<Id extends Identity = Identity, Ctx extends object = {}> extends SessionCommon<Id>

SSH

• readonly property Session.context: Ctx
• readonly property Session.renderer: CliRenderer

Types#

type AuthConfig = "open" | AuthMethods

SSH

type Identity = { method: "none"; username: string; } | { method: "password"; username: string; } | { method: "keyboard-interactive"; username: string; } | { method: "publickey"; username: string; fingerprint: string; publicKey: PublicKey; }

SSH

type IdentityFor<A extends AuthConfig = "open"> = A extends "open" ? Extract<Identity, { method: "none"; }> : A extends AuthMethods ? CredentialVariant[ConfiguredCredentialKeys<A> & keyof CredentialVariant] : never

SSH

type LogEvent<Id extends Identity = Identity> = (LogEventCommon<Id> & { type: "connect"; durationMs?: never; }) | (LogEventCommon<Id> & { type: "disconnect"; durationMs: number; })

SSH

type Middleware<Id extends Identity = Identity, Add extends object = object> = (session: MiddlewareSession<Id>, next: Next) => Handoff<Add> | Promise<Handoff<Add>>

SSH

type MiddlewareFunction<Id extends Identity = Identity, Ctx extends object = object, Add extends object = object> = (session: MiddlewareSession<Id, Ctx>, next: Next) => Handoff<Add> | Promise<Handoff<Add>>

SSH

type PublicKey = { algorithm: string; blob: Buffer; }

SSH

type SessionHandler<Id extends Identity = Identity, Ctx extends object = {}> = (session: Session<Id, Ctx>) => void | Promise<void>

SSH

Namespaces and re-exports#

call Next(): Promise<Handoff>call Next<Add extends object>(add: Add): Promise<Handoff<Add>>interface Next

SSH