Merge branch 'ssh-client'
This commit is contained in:
commit
2922f07c2f
33 files changed
+4694
-99
No files matched your search
@@ -58,6 +58,8 @@ native/kotlin/.kotlin/
|
||||
native/kotlin/build/
|
||||
native/kotlin/shared/build/
|
||||
native/kotlin/local.properties
|
||||
# Go SSH transport build outputs (scripts/go-ssh-build.cjs)
|
||||
native/ssh/build/
|
||||
native/kotlin/plugin/platforms/android/*.aar
|
||||
native/kotlin/plugin/platforms/ios/
|
||||
!native/kotlin/plugin/platforms/
|
||||
|
||||
@@ -0,0 +1,212 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
import android.content.ClipData
|
||||
import android.content.ClipboardManager
|
||||
import android.content.Context
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.security.keystore.KeyGenParameterSpec
|
||||
import android.security.keystore.KeyProperties
|
||||
import android.security.keystore.StrongBoxUnavailableException
|
||||
import android.util.Base64
|
||||
import android.util.Log
|
||||
import com.faceclaw.ssh.faceclawssh.Channel
|
||||
import com.faceclaw.ssh.faceclawssh.Faceclawssh
|
||||
import com.faceclaw.ssh.faceclawssh.Listener
|
||||
import com.faceclaw.ssh.faceclawssh.Signer
|
||||
import java.security.KeyPairGenerator
|
||||
import java.security.KeyStore
|
||||
import java.security.PrivateKey
|
||||
import java.security.Signature
|
||||
import java.security.spec.ECGenParameterSpec
|
||||
import javax.crypto.Cipher
|
||||
import javax.crypto.KeyGenerator
|
||||
import javax.crypto.SecretKey
|
||||
import javax.crypto.spec.GCMParameterSpec
|
||||
|
||||
/**
|
||||
* One SSH channel for the TypeScript side (app/native/ssh.ts), backed by the
|
||||
* gomobile-bound Go transport in native/ssh. `spec` is the Go openSpec JSON.
|
||||
* Events arrive from Go goroutines and are posted to the Looper of the
|
||||
* thread that constructed this object (a JS isolate's own thread), like
|
||||
* FaceclawWebSocket.
|
||||
*/
|
||||
class FaceclawSshChannel(spec: String, useKey: Boolean, listener: FaceclawSshListener) {
|
||||
private val handler = Handler(Looper.myLooper() ?: Looper.getMainLooper())
|
||||
private val channel: Channel
|
||||
|
||||
init {
|
||||
val signer = if (useKey) FaceclawSshKeys.signer() else null
|
||||
channel = Faceclawssh.open(spec, signer, object : Listener {
|
||||
override fun onEvent(kind: String?, payload: String?) {
|
||||
handler.post {
|
||||
try {
|
||||
listener.onEvent(kind, payload)
|
||||
} catch (t: Throwable) {
|
||||
Log.w(TAG, "listener onEvent($kind) failed", t)
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fun send(text: String): Boolean = channel.send(text)
|
||||
|
||||
fun close() = channel.close()
|
||||
|
||||
private companion object {
|
||||
const val TAG = "FaceclawSsh"
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The device's SSH client key and the Terminal app's saved SSH passwords.
|
||||
*
|
||||
* The client key is an ECDSA P-256 key generated inside Android Keystore
|
||||
* (StrongBox when the device has one) and never exportable: only its public
|
||||
* half leaves the keystore, as an authorized_keys line. Passwords are
|
||||
* encrypted with an AES-GCM key that also lives in Keystore, and stored in a
|
||||
* private SharedPreferences file kept apart from the settings store (which is
|
||||
* exported by the settings port).
|
||||
*/
|
||||
object FaceclawSshKeys {
|
||||
private const val TAG = "FaceclawSsh"
|
||||
private const val CLIENT_KEY_ALIAS = "faceclaw-ssh-client"
|
||||
private const val SECRET_KEY_ALIAS = "faceclaw-ssh-secrets"
|
||||
private const val SECRETS_PREFS = "faceclaw_ssh_secrets"
|
||||
private const val GCM_TAG_BITS = 128
|
||||
|
||||
private fun keyStore(): KeyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
|
||||
|
||||
@JvmStatic
|
||||
@Synchronized
|
||||
fun hasClientKey(): Boolean = keyStore().containsAlias(CLIENT_KEY_ALIAS)
|
||||
|
||||
/** Generate the client key if it doesn't exist yet. */
|
||||
@JvmStatic
|
||||
@Synchronized
|
||||
fun ensureClientKey() {
|
||||
if (keyStore().containsAlias(CLIENT_KEY_ALIAS)) return
|
||||
fun spec(strongBox: Boolean): KeyGenParameterSpec {
|
||||
val builder = KeyGenParameterSpec.Builder(CLIENT_KEY_ALIAS, KeyProperties.PURPOSE_SIGN)
|
||||
.setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
|
||||
.setDigests(KeyProperties.DIGEST_SHA256)
|
||||
if (strongBox && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) builder.setIsStrongBoxBacked(true)
|
||||
return builder.build()
|
||||
}
|
||||
val generator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore")
|
||||
try {
|
||||
generator.initialize(spec(strongBox = true))
|
||||
generator.generateKeyPair()
|
||||
} catch (e: Exception) {
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && e is StrongBoxUnavailableException) {
|
||||
Log.i(TAG, "StrongBox unavailable; generating the SSH key in the TEE")
|
||||
} else {
|
||||
Log.w(TAG, "StrongBox key generation failed; retrying in the TEE", e)
|
||||
}
|
||||
generator.initialize(spec(strongBox = false))
|
||||
generator.generateKeyPair()
|
||||
}
|
||||
Log.i(TAG, "generated SSH client key")
|
||||
}
|
||||
|
||||
/** X.509 SubjectPublicKeyInfo DER of the client key, or null if none. */
|
||||
@JvmStatic
|
||||
fun publicKey(): ByteArray? = keyStore().getCertificate(CLIENT_KEY_ALIAS)?.publicKey?.encoded
|
||||
|
||||
/** The client key's authorized_keys line (generating the key if needed). */
|
||||
@JvmStatic
|
||||
fun authorizedKey(comment: String): String {
|
||||
ensureClientKey()
|
||||
return Faceclawssh.authorizedKey(publicKey(), comment)
|
||||
}
|
||||
|
||||
/** The client key's SHA256 fingerprint (generating the key if needed). */
|
||||
@JvmStatic
|
||||
fun fingerprint(): String {
|
||||
ensureClientKey()
|
||||
return Faceclawssh.fingerprint(publicKey())
|
||||
}
|
||||
|
||||
/** A Go Signer over the client key, generating the key if needed. */
|
||||
@JvmStatic
|
||||
fun signer(): Signer? = try {
|
||||
ensureClientKey()
|
||||
val publicKey = publicKey() ?: throw IllegalStateException("client key has no certificate")
|
||||
object : Signer {
|
||||
override fun publicKey(): ByteArray = publicKey
|
||||
override fun sign(data: ByteArray?): ByteArray {
|
||||
val privateKey = keyStore().getKey(CLIENT_KEY_ALIAS, null) as PrivateKey
|
||||
return Signature.getInstance("SHA256withECDSA").run {
|
||||
initSign(privateKey)
|
||||
update(data ?: ByteArray(0))
|
||||
sign()
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (t: Throwable) {
|
||||
Log.w(TAG, "SSH client key unavailable", t)
|
||||
null
|
||||
}
|
||||
|
||||
private fun secretKey(): SecretKey {
|
||||
val store = keyStore()
|
||||
(store.getKey(SECRET_KEY_ALIAS, null) as? SecretKey)?.let { return it }
|
||||
val generator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
|
||||
generator.init(
|
||||
KeyGenParameterSpec.Builder(SECRET_KEY_ALIAS, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
|
||||
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
|
||||
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
|
||||
.setKeySize(256)
|
||||
.build()
|
||||
)
|
||||
return generator.generateKey()
|
||||
}
|
||||
|
||||
private fun prefs(context: Context) =
|
||||
context.applicationContext.getSharedPreferences(SECRETS_PREFS, Context.MODE_PRIVATE)
|
||||
|
||||
@JvmStatic
|
||||
@Synchronized
|
||||
fun setSecret(context: Context, id: String, value: String) {
|
||||
val cipher = Cipher.getInstance("AES/GCM/NoPadding")
|
||||
cipher.init(Cipher.ENCRYPT_MODE, secretKey())
|
||||
val sealed = cipher.iv + cipher.doFinal(value.toByteArray(Charsets.UTF_8))
|
||||
prefs(context).edit().putString(id, Base64.encodeToString(sealed, Base64.NO_WRAP)).apply()
|
||||
}
|
||||
|
||||
/** The saved secret, or "" if none (or it can no longer be decrypted). */
|
||||
@JvmStatic
|
||||
@Synchronized
|
||||
fun getSecret(context: Context, id: String): String {
|
||||
val encoded = prefs(context).getString(id, null) ?: return ""
|
||||
return try {
|
||||
val sealed = Base64.decode(encoded, Base64.NO_WRAP)
|
||||
val cipher = Cipher.getInstance("AES/GCM/NoPadding")
|
||||
val ivLength = 12
|
||||
cipher.init(Cipher.DECRYPT_MODE, secretKey(), GCMParameterSpec(GCM_TAG_BITS, sealed, 0, ivLength))
|
||||
String(cipher.doFinal(sealed, ivLength, sealed.size - ivLength), Charsets.UTF_8)
|
||||
} catch (t: Throwable) {
|
||||
Log.w(TAG, "saved SSH secret unreadable; dropping it", t)
|
||||
prefs(context).edit().remove(id).apply()
|
||||
""
|
||||
}
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
@Synchronized
|
||||
fun removeSecret(context: Context, id: String) {
|
||||
prefs(context).edit().remove(id).apply()
|
||||
}
|
||||
|
||||
/** Put text on the phone's clipboard (from any thread). */
|
||||
@JvmStatic
|
||||
fun copyToClipboard(context: Context, label: String, text: String) {
|
||||
val appContext = context.applicationContext
|
||||
Handler(Looper.getMainLooper()).post {
|
||||
val clipboard = appContext.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
|
||||
clipboard.setPrimaryClip(ClipData.newPlainText(label, text))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
/**
|
||||
* One SSH channel for the TypeScript side (app/native/ssh.ios.ts), backed by
|
||||
* the gomobile-bound Go transport in native/ssh. `spec` is the Go openSpec
|
||||
* JSON. Events arrive on Go threads and queue here; the owning JS isolate
|
||||
* drains them with takeEvents (a JSON array of {kind, payload}).
|
||||
*/
|
||||
@interface FaceclawSshChannel : NSObject
|
||||
- (instancetype)initWithSpec:(NSString *)spec useKey:(BOOL)useKey;
|
||||
- (NSString *)takeEvents;
|
||||
- (BOOL)send:(NSString *)text;
|
||||
- (void)close;
|
||||
@end
|
||||
|
||||
/**
|
||||
* The device's SSH client key (a non-exportable Secure Enclave P-256 key; a
|
||||
* plain keychain key on the simulator, which has no Secure Enclave) and the
|
||||
* Terminal app's saved SSH passwords (keychain generic passwords).
|
||||
*/
|
||||
@interface FaceclawSshKeys : NSObject
|
||||
/** "ecdsa-sha2-nistp256 AAAA... comment"; generates the key if needed. nil on failure. */
|
||||
+ (NSString *)authorizedKeyWithComment:(NSString *)comment;
|
||||
/** "SHA256:..." fingerprint; generates the key if needed. nil on failure. */
|
||||
+ (NSString *)fingerprint;
|
||||
+ (void)setSecret:(NSString *)value forId:(NSString *)secretId;
|
||||
/** The saved secret, or "" if none. */
|
||||
+ (NSString *)secretForId:(NSString *)secretId;
|
||||
+ (void)removeSecretForId:(NSString *)secretId;
|
||||
+ (void)copyToClipboard:(NSString *)text;
|
||||
@end
|
||||
@@ -0,0 +1,234 @@
|
||||
#import "FaceclawSsh.h"
|
||||
#import <Faceclawssh/Faceclawssh.h>
|
||||
#import <Security/Security.h>
|
||||
#import <UIKit/UIKit.h>
|
||||
|
||||
static NSString *const kClientKeyTag = @"com.faceclaw.ssh.client";
|
||||
static NSString *const kSecretService = @"com.faceclaw.ssh.secret";
|
||||
|
||||
#pragma mark - Client key
|
||||
|
||||
static NSData *ClientKeyTagData(void) {
|
||||
return [kClientKeyTag dataUsingEncoding:NSUTF8StringEncoding];
|
||||
}
|
||||
|
||||
static SecKeyRef CopyClientKey(void) {
|
||||
NSDictionary *query = @{
|
||||
(id)kSecClass: (id)kSecClassKey,
|
||||
(id)kSecAttrApplicationTag: ClientKeyTagData(),
|
||||
(id)kSecAttrKeyType: (id)kSecAttrKeyTypeECSECPrimeRandom,
|
||||
(id)kSecReturnRef: @YES,
|
||||
};
|
||||
CFTypeRef key = NULL;
|
||||
if (SecItemCopyMatching((__bridge CFDictionaryRef)query, &key) != errSecSuccess) return NULL;
|
||||
return (SecKeyRef)key;
|
||||
}
|
||||
|
||||
static SecKeyRef CreateClientKey(BOOL secureEnclave) {
|
||||
SecAccessControlRef access = SecAccessControlCreateWithFlags(
|
||||
kCFAllocatorDefault, kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly,
|
||||
secureEnclave ? kSecAccessControlPrivateKeyUsage : 0, NULL);
|
||||
if (!access) return NULL;
|
||||
NSMutableDictionary *attributes = [@{
|
||||
(id)kSecAttrKeyType: (id)kSecAttrKeyTypeECSECPrimeRandom,
|
||||
(id)kSecAttrKeySizeInBits: @256,
|
||||
(id)kSecPrivateKeyAttrs: @{
|
||||
(id)kSecAttrIsPermanent: @YES,
|
||||
(id)kSecAttrApplicationTag: ClientKeyTagData(),
|
||||
(id)kSecAttrAccessControl: (__bridge id)access,
|
||||
},
|
||||
} mutableCopy];
|
||||
if (secureEnclave) attributes[(id)kSecAttrTokenID] = (id)kSecAttrTokenIDSecureEnclave;
|
||||
CFErrorRef error = NULL;
|
||||
SecKeyRef key = SecKeyCreateRandomKey((__bridge CFDictionaryRef)attributes, &error);
|
||||
CFRelease(access);
|
||||
if (!key && error) {
|
||||
NSLog(@"FaceclawSsh: key generation failed (secure enclave %d): %@", secureEnclave, (__bridge NSError *)error);
|
||||
CFRelease(error);
|
||||
}
|
||||
return key;
|
||||
}
|
||||
|
||||
/** The client key, generating it on first use. Caller releases. */
|
||||
static SecKeyRef CopyOrCreateClientKey(void) {
|
||||
@synchronized([FaceclawSshKeys class]) {
|
||||
SecKeyRef key = CopyClientKey();
|
||||
if (key) return key;
|
||||
key = CreateClientKey(YES);
|
||||
#if TARGET_OS_SIMULATOR
|
||||
if (!key) key = CreateClientKey(NO);
|
||||
#endif
|
||||
return key;
|
||||
}
|
||||
}
|
||||
|
||||
/** Uncompressed X9.62 public point (0x04 || X || Y). */
|
||||
static NSData *PublicKeyData(SecKeyRef key) {
|
||||
SecKeyRef publicKey = SecKeyCopyPublicKey(key);
|
||||
if (!publicKey) return nil;
|
||||
NSData *data = (__bridge_transfer NSData *)SecKeyCopyExternalRepresentation(publicKey, NULL);
|
||||
CFRelease(publicKey);
|
||||
return data;
|
||||
}
|
||||
|
||||
@interface FaceclawSshSigner : NSObject <FaceclawsshSigner>
|
||||
@end
|
||||
|
||||
@implementation FaceclawSshSigner {
|
||||
SecKeyRef _key;
|
||||
NSData *_publicKey;
|
||||
}
|
||||
- (instancetype)initWithKey:(SecKeyRef)key {
|
||||
if ((self = [super init])) {
|
||||
_key = (SecKeyRef)CFRetain(key);
|
||||
_publicKey = PublicKeyData(key);
|
||||
}
|
||||
return self;
|
||||
}
|
||||
- (void)dealloc {
|
||||
if (_key) CFRelease(_key);
|
||||
}
|
||||
- (NSData *)publicKey {
|
||||
return _publicKey;
|
||||
}
|
||||
- (NSData *)sign:(NSData *)data error:(NSError **)error {
|
||||
CFErrorRef cfError = NULL;
|
||||
NSData *signature = (__bridge_transfer NSData *)SecKeyCreateSignature(
|
||||
_key, kSecKeyAlgorithmECDSASignatureMessageX962SHA256, (__bridge CFDataRef)(data ?: [NSData data]), &cfError);
|
||||
if (!signature) {
|
||||
if (error) *error = (__bridge_transfer NSError *)cfError;
|
||||
else if (cfError) CFRelease(cfError);
|
||||
}
|
||||
return signature;
|
||||
}
|
||||
@end
|
||||
|
||||
#pragma mark - Channel
|
||||
|
||||
@interface FaceclawSshEventQueue : NSObject <FaceclawsshListener>
|
||||
@property(nonatomic, strong) NSMutableArray *events;
|
||||
@property(nonatomic) BOOL ended;
|
||||
@end
|
||||
|
||||
@implementation FaceclawSshEventQueue
|
||||
- (instancetype)init {
|
||||
if ((self = [super init])) _events = [NSMutableArray array];
|
||||
return self;
|
||||
}
|
||||
- (void)onEvent:(NSString *)kind payload:(NSString *)payload {
|
||||
@synchronized(self) {
|
||||
if (_ended) return;
|
||||
[_events addObject:@{@"kind": kind ?: @"", @"payload": payload ?: @""}];
|
||||
}
|
||||
}
|
||||
@end
|
||||
|
||||
@implementation FaceclawSshChannel {
|
||||
FaceclawsshChannel *_channel;
|
||||
FaceclawSshEventQueue *_queue;
|
||||
}
|
||||
|
||||
- (instancetype)initWithSpec:(NSString *)spec useKey:(BOOL)useKey {
|
||||
if ((self = [super init])) {
|
||||
_queue = [FaceclawSshEventQueue new];
|
||||
FaceclawSshSigner *signer = nil;
|
||||
if (useKey) {
|
||||
SecKeyRef key = CopyOrCreateClientKey();
|
||||
if (key) {
|
||||
signer = [[FaceclawSshSigner alloc] initWithKey:key];
|
||||
CFRelease(key);
|
||||
}
|
||||
}
|
||||
_channel = FaceclawsshOpen(spec, signer, _queue);
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (NSString *)takeEvents {
|
||||
NSArray *events;
|
||||
@synchronized(_queue) {
|
||||
if (_queue.events.count == 0) return @"[]";
|
||||
events = [_queue.events copy];
|
||||
[_queue.events removeAllObjects];
|
||||
}
|
||||
NSData *data = [NSJSONSerialization dataWithJSONObject:events options:0 error:nil];
|
||||
return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] ?: @"[]";
|
||||
}
|
||||
|
||||
- (BOOL)send:(NSString *)text {
|
||||
return [_channel send:text];
|
||||
}
|
||||
|
||||
- (void)close {
|
||||
@synchronized(_queue) {
|
||||
_queue.ended = YES;
|
||||
[_queue.events removeAllObjects];
|
||||
}
|
||||
[_channel close];
|
||||
}
|
||||
@end
|
||||
|
||||
#pragma mark - Keys and secrets
|
||||
|
||||
@implementation FaceclawSshKeys
|
||||
|
||||
+ (NSString *)authorizedKeyWithComment:(NSString *)comment {
|
||||
SecKeyRef key = CopyOrCreateClientKey();
|
||||
if (!key) return nil;
|
||||
NSData *publicKey = PublicKeyData(key);
|
||||
CFRelease(key);
|
||||
NSError *error = nil;
|
||||
NSString *line = FaceclawsshAuthorizedKey(publicKey, comment ?: @"", &error);
|
||||
if (error) NSLog(@"FaceclawSsh: authorizedKey failed: %@", error);
|
||||
return line;
|
||||
}
|
||||
|
||||
+ (NSString *)fingerprint {
|
||||
SecKeyRef key = CopyOrCreateClientKey();
|
||||
if (!key) return nil;
|
||||
NSData *publicKey = PublicKeyData(key);
|
||||
CFRelease(key);
|
||||
NSError *error = nil;
|
||||
NSString *fingerprint = FaceclawsshFingerprint(publicKey, &error);
|
||||
if (error) NSLog(@"FaceclawSsh: fingerprint failed: %@", error);
|
||||
return fingerprint;
|
||||
}
|
||||
|
||||
+ (NSDictionary *)secretQuery:(NSString *)secretId {
|
||||
return @{
|
||||
(id)kSecClass: (id)kSecClassGenericPassword,
|
||||
(id)kSecAttrService: kSecretService,
|
||||
(id)kSecAttrAccount: secretId ?: @"",
|
||||
};
|
||||
}
|
||||
|
||||
+ (void)setSecret:(NSString *)value forId:(NSString *)secretId {
|
||||
NSDictionary *query = [self secretQuery:secretId];
|
||||
SecItemDelete((__bridge CFDictionaryRef)query);
|
||||
NSMutableDictionary *item = [query mutableCopy];
|
||||
item[(id)kSecValueData] = [(value ?: @"") dataUsingEncoding:NSUTF8StringEncoding];
|
||||
item[(id)kSecAttrAccessible] = (id)kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly;
|
||||
OSStatus status = SecItemAdd((__bridge CFDictionaryRef)item, NULL);
|
||||
if (status != errSecSuccess) NSLog(@"FaceclawSsh: saving secret failed: %d", (int)status);
|
||||
}
|
||||
|
||||
+ (NSString *)secretForId:(NSString *)secretId {
|
||||
NSMutableDictionary *query = [[self secretQuery:secretId] mutableCopy];
|
||||
query[(id)kSecReturnData] = @YES;
|
||||
query[(id)kSecMatchLimit] = (id)kSecMatchLimitOne;
|
||||
CFTypeRef result = NULL;
|
||||
if (SecItemCopyMatching((__bridge CFDictionaryRef)query, &result) != errSecSuccess) return @"";
|
||||
NSData *data = (__bridge_transfer NSData *)result;
|
||||
return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] ?: @"";
|
||||
}
|
||||
|
||||
+ (void)removeSecretForId:(NSString *)secretId {
|
||||
SecItemDelete((__bridge CFDictionaryRef)[self secretQuery:secretId]);
|
||||
}
|
||||
|
||||
+ (void)copyToClipboard:(NSString *)text {
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
UIPasteboard.generalPasteboard.string = text ?: @"";
|
||||
});
|
||||
}
|
||||
@end
|
||||
@@ -2,6 +2,7 @@ module FaceclawGraphics {
|
||||
header "FaceclawGraphics.h"
|
||||
header "FaceclawFontRenderer.h"
|
||||
header "FaceclawSocket.h"
|
||||
header "FaceclawSsh.h"
|
||||
header "FaceclawLc3Decoder.h"
|
||||
header "FaceclawSpeech.h"
|
||||
header "FaceclawLocation.h"
|
||||
|
||||
@@ -80,8 +80,10 @@ import it into the new version (see [config transfer](scripts/config-transfer.md
|
||||
* **Integration with Android notifications**: shows the same notification
|
||||
icons your phone does, and popups when notifications arrive.
|
||||
* **Terminal mirroring.** Mirror terminal apps such as Claude Code or Codex
|
||||
CLI with [g2mirror](https://github.com/jimrandomh/g2mirror), view them on
|
||||
the glasses, and send them inputs with the voice assistant.
|
||||
CLI with [g2mirror](https://github.com/jimrandomh/g2mirror), or attach to
|
||||
tmux sessions over SSH (no server-side setup beyond tmux 3.2+), view them
|
||||
on the glasses, and send them inputs with the voice assistant. g2mirror
|
||||
can also be tunnelled over SSH instead of a VPN.
|
||||
* **Media player controls** including playlist and media library navigation,
|
||||
compatible with most Android media players.
|
||||
* **Turn-by-turn directions** (requires a Mapbox API token).
|
||||
|
||||
@@ -1,13 +1,21 @@
|
||||
import { getStringSetting, setStringSetting } from "../../native/settings-store";
|
||||
|
||||
/**
|
||||
* Terminal-app connection registry: the g2mirror hosts the app knows about,
|
||||
* stored as JSON under one settings key so every isolate sees the same list
|
||||
* and change notifications ride the ordinary settings-store channel.
|
||||
* Terminal-app connection registry: the hosts the app knows about, stored as
|
||||
* JSON under one settings key so every isolate sees the same list and change
|
||||
* notifications ride the ordinary settings-store channel.
|
||||
*
|
||||
* A connection is entered as a g2mirror:// connection string (the same form
|
||||
* g2mirror-view accepts): g2mirror://<token>@<host>[:port] for plain
|
||||
* websockets (default port 8737), g2mirrors://... for TLS (default 443).
|
||||
* A connection is entered as a connection string:
|
||||
* - g2mirror://<token>@<host>[:port]: a g2mirror server reached directly
|
||||
* (the same form g2mirror-view accepts) over a plain websocket (default
|
||||
* port 8737); g2mirrors://... for TLS (default 443).
|
||||
* - ssh://<user>@<host>[:port]: tmux on an SSH host (default port 22).
|
||||
* - ssh://<user>@<host>[:port]?g2mirror=<token>[@<host>[:port]]: a g2mirror
|
||||
* server tunnelled over SSH; the address after the token is where the
|
||||
* server listens as seen from the SSH host (default 127.0.0.1:8737).
|
||||
* SSH connections pin the host's key (hostKeys, trusted on first connection
|
||||
* after the user checks its fingerprint); their passwords live in the
|
||||
* platform keystore (app/native/ssh), not here.
|
||||
*/
|
||||
|
||||
export const TERMINAL_CONNECTIONS_KEY = "terminal.connections";
|
||||
@@ -25,6 +33,8 @@ export type TerminalConnection = {
|
||||
serverName: string | null;
|
||||
/** Auto-connect while the Terminal app is open. Toggled by Connect/Disconnect. */
|
||||
enabled: boolean;
|
||||
/** SSH connections: trusted host keys (SSH wire format, base64). */
|
||||
hostKeys: string[];
|
||||
};
|
||||
|
||||
export type ParsedConnectionString = {
|
||||
@@ -54,8 +64,79 @@ export function parseConnectionString(url: string): ParsedConnectionString | nul
|
||||
return { secure, host, port, authToken };
|
||||
}
|
||||
|
||||
/** The host[:port] part of a connection string; "" if it doesn't parse. */
|
||||
export type ParsedSshConnection = {
|
||||
user: string;
|
||||
host: string;
|
||||
port: number;
|
||||
} & (
|
||||
| { mode: "tmux" }
|
||||
| {
|
||||
mode: "g2mirror";
|
||||
authToken: string;
|
||||
/** Where g2mirror-server listens, from the SSH host's point of view. */
|
||||
targetHost: string;
|
||||
targetPort: number;
|
||||
}
|
||||
);
|
||||
|
||||
function decodeComponent(text: string): string {
|
||||
try {
|
||||
return decodeURIComponent(text);
|
||||
} catch {
|
||||
return text;
|
||||
}
|
||||
}
|
||||
|
||||
/** Parse an ssh://user@host[:port][?g2mirror=token[@host[:port]]] string; null if malformed. */
|
||||
export function parseSshConnectionString(url: string): ParsedSshConnection | null {
|
||||
const match = /^ssh:\/\/([^@\s/?]+)@(\[[^\]\s]+\]|[^:/@\s?]+)(?::(\d+))?\/?(?:\?(.*))?$/.exec(url.trim());
|
||||
if (!match) return null;
|
||||
const user = decodeComponent(match[1]!);
|
||||
const host = match[2]!.replace(/^\[(.*)\]$/, "$1");
|
||||
const port = match[3] ? parseInt(match[3], 10) : 22;
|
||||
if (!user || !(port >= 1 && port <= 65535)) return null;
|
||||
const params = new Map<string, string>();
|
||||
for (const part of (match[4] ?? "").split("&").filter(Boolean)) {
|
||||
const equals = part.indexOf("=");
|
||||
if (equals < 0) return null;
|
||||
params.set(part.slice(0, equals), decodeComponent(part.slice(equals + 1)));
|
||||
}
|
||||
for (const key of params.keys()) {
|
||||
if (key !== "g2mirror") return null;
|
||||
}
|
||||
const g2mirror = params.get("g2mirror");
|
||||
if (g2mirror === undefined) return { user, host, port, mode: "tmux" };
|
||||
// token[@host[:port]], split at the last "@" so the token may contain one.
|
||||
const at = g2mirror.lastIndexOf("@");
|
||||
const authToken = at < 0 ? g2mirror : g2mirror.slice(0, at);
|
||||
const target = at < 0 ? "" : g2mirror.slice(at + 1);
|
||||
const targetMatch = /^(\[[^\]\s]+\]|[^:\s]*)(?::(\d+))?$/.exec(target);
|
||||
if (!authToken || !targetMatch) return null;
|
||||
const targetHost = targetMatch[1] || "127.0.0.1";
|
||||
const targetPort = targetMatch[2] ? parseInt(targetMatch[2], 10) : 8737;
|
||||
if (!(targetPort >= 1 && targetPort <= 65535)) return null;
|
||||
return { user, host, port, mode: "g2mirror", authToken, targetHost, targetPort };
|
||||
}
|
||||
|
||||
export type ParsedAnyConnection =
|
||||
| ({ kind: "g2mirror" } & ParsedConnectionString)
|
||||
| ({ kind: "ssh" } & ParsedSshConnection);
|
||||
|
||||
/** Parse any supported connection string; null if it's none of them. */
|
||||
export function parseAnyConnectionString(url: string): ParsedAnyConnection | null {
|
||||
const direct = parseConnectionString(url);
|
||||
if (direct) return { kind: "g2mirror", ...direct };
|
||||
const ssh = parseSshConnectionString(url);
|
||||
return ssh ? { kind: "ssh", ...ssh } : null;
|
||||
}
|
||||
|
||||
/** The [user@]host[:port] part of a connection string (never a token); "" if it doesn't parse. */
|
||||
export function connectionStringHostLabel(url: string): string {
|
||||
const ssh = parseSshConnectionString(url);
|
||||
if (ssh) {
|
||||
const host = ssh.host.includes(":") ? `[${ssh.host}]` : ssh.host;
|
||||
return `${ssh.user}@${host}${ssh.port === 22 ? "" : `:${ssh.port}`}`;
|
||||
}
|
||||
const parsed = parseConnectionString(url);
|
||||
if (!parsed) return "";
|
||||
const defaultPort = parsed.secure ? 443 : 8737;
|
||||
@@ -79,6 +160,7 @@ export function loadConnections(): TerminalConnection[] {
|
||||
url: String(item?.url ?? ""),
|
||||
serverName: typeof item?.serverName === "string" && item.serverName ? item.serverName : null,
|
||||
enabled: item?.enabled !== false,
|
||||
hostKeys: Array.isArray(item?.hostKeys) ? item.hostKeys.filter((key: unknown) => typeof key === "string") : [],
|
||||
}))
|
||||
.filter((connection) => connection.id.length > 0 && connection.url.length > 0);
|
||||
} catch {
|
||||
|
||||
@@ -16,11 +16,17 @@
|
||||
* Each view has its own websocket connection (the protocol allows one attached
|
||||
* session per connection) and its own xterm emulator.
|
||||
*
|
||||
* Connections are g2mirror://<token>@<host>[:port] strings (g2mirrors:// for
|
||||
* TLS), stored as JSON in the settings store (see connections.ts). Each
|
||||
* enabled connection gets a control websocket that backs the session list and
|
||||
* carries unsolicited bell/title notifications; control connections live as
|
||||
* long as the worker so bells keep flowing even if the hub window is closed.
|
||||
* Connections are connection strings stored as JSON in the settings store
|
||||
* (see connections.ts): g2mirror://<token>@<host>[:port] for a g2mirror
|
||||
* server (g2mirrors:// for TLS), ssh://<user>@<host> for tmux over SSH
|
||||
* (TmuxClient), or ssh://<user>@<host>?g2mirror=<token> for a g2mirror server
|
||||
* tunnelled over SSH. Each enabled connection gets a control client that
|
||||
* backs the session list and carries bell/title/activity notifications;
|
||||
* control connections live as long as the worker so bells keep flowing even
|
||||
* if the hub window is closed. SSH connections that need the user (an
|
||||
* unverified or changed host key, a password, an unauthorized key) record
|
||||
* the failure on the control (sshIssue) and offer a page that resolves it
|
||||
* instead of retrying.
|
||||
* The host's server_name (from the init reply) is cached per connection and
|
||||
* used as its display name, falling back to the connection string's
|
||||
* host[:port] before the first successful handshake.
|
||||
@@ -57,7 +63,22 @@ import { getActiveDisplay } from "../../native/active-display";
|
||||
import { GESTURE_DOUBLE_CLICK, type InputEvent } from "../../ui/gestures";
|
||||
import type { KeyEvent } from "../../g2/keyboard/keys";
|
||||
import { encodeTerminalKey, terminalScrollbackKey } from "./terminal-keys";
|
||||
import { G2MirrorClient, type G2MirrorClientOptions, type G2MirrorSession, type G2MirrorState } from "../../native/g2mirror-client";
|
||||
import { G2MirrorClient, type G2MirrorSession, type G2MirrorState } from "../../native/g2mirror-client";
|
||||
import type { TerminalClient } from "./terminal-client";
|
||||
import { TmuxClient, type OpenLineChannel } from "./tmux-client";
|
||||
import {
|
||||
copyToPhoneClipboard,
|
||||
describeSshFailure,
|
||||
getSshSecret,
|
||||
openSshChannel,
|
||||
removeSshSecret,
|
||||
setSshSecret,
|
||||
sshClientKey,
|
||||
type SshEndpoint,
|
||||
type SshFailure,
|
||||
type SshHostKey,
|
||||
} from "../../native/ssh";
|
||||
import { wrapText } from "../../graphics/textwrap";
|
||||
import { onSettingsStoreChanged } from "../../native/settings-store";
|
||||
import { clamp } from "../../util/numeric-util";
|
||||
import {
|
||||
@@ -66,12 +87,22 @@ import {
|
||||
terminalDisplayLayoutSetting,
|
||||
terminalLaunchPresetsSetting,
|
||||
terminalNewConnectionSetting,
|
||||
terminalSshPasswordSetting,
|
||||
terminalWakeOnBellSetting,
|
||||
textSettingMenuItem,
|
||||
toggleSettingMenuItem,
|
||||
} from "../../ui/dashboard-settings";
|
||||
import { terminalFontPickerMenuItem } from "../../ui/font-picker";
|
||||
import { connectionDisplayName, loadConnections, parseConnectionString, saveConnections, TERMINAL_CONNECTIONS_KEY, updateConnection, type TerminalConnection } from "./connections";
|
||||
import {
|
||||
connectionDisplayName,
|
||||
connectionStringHostLabel,
|
||||
loadConnections,
|
||||
parseAnyConnectionString,
|
||||
saveConnections,
|
||||
TERMINAL_CONNECTIONS_KEY,
|
||||
updateConnection,
|
||||
type TerminalConnection,
|
||||
} from "./connections";
|
||||
import { TerminalEmulator } from "./terminal-emulator";
|
||||
import { drawSubmenuIndicator, submenuItem, type MenuItem } from "../../ui/menu";
|
||||
import { Menu, type MenuDrawArgs } from "../../ui/menu-core";
|
||||
@@ -114,6 +145,10 @@ const RECONNECT_MAX_DELAY_MS = 60_000;
|
||||
const NEW_CONNECTION_DRAFT_KEY = "terminal.newConnectionDraft";
|
||||
// Storage key of terminalLaunchPresetsSetting, edited from the window menu.
|
||||
const LAUNCH_PRESETS_KEY = "terminal.launchPresets";
|
||||
// Storage key of terminalSshPasswordSetting (the password page's draft).
|
||||
const SSH_PASSWORD_DRAFT_KEY = "terminal.sshPasswordDraft";
|
||||
// Comment on this device's SSH public key in authorized_keys.
|
||||
const SSH_KEY_COMMENT = "faceclaw";
|
||||
|
||||
type BaseWindow = {
|
||||
windowId: string;
|
||||
@@ -150,10 +185,24 @@ type BaseWindow = {
|
||||
|
||||
/**
|
||||
* What the hub window is showing: the session list, the Manage Connections
|
||||
* section, or the Add-connection screen (type the g2mirror:// string on the
|
||||
* phone, click to save).
|
||||
* section, the Add-connection screen (type the connection string on the
|
||||
* phone, click to save), or a page of text with a click action (verify a
|
||||
* host key, enter a password, show this device's SSH key).
|
||||
*/
|
||||
type HubMode = "sessions" | "connections" | "add";
|
||||
type HubMode = "sessions" | "connections" | "add" | "page";
|
||||
|
||||
type HubPage = {
|
||||
title: string;
|
||||
/** Body text, wrapped to the window; re-read on every paint. */
|
||||
body: () => string;
|
||||
/** Bottom hint line. */
|
||||
hint: string;
|
||||
onClick?: () => void;
|
||||
/** Double-click. */
|
||||
onBack: () => void;
|
||||
/** Runs whenever the page goes away (back, click, window closed). */
|
||||
onLeave?: () => void;
|
||||
};
|
||||
|
||||
type HubWindow = BaseWindow & {
|
||||
kind: "hub";
|
||||
@@ -170,6 +219,8 @@ type HubWindow = BaseWindow & {
|
||||
sessionOrder: string[];
|
||||
/** Parse-failure message shown on the Add-connection screen. */
|
||||
addError: string;
|
||||
/** The page shown in mode "page". */
|
||||
page: HubPage | null;
|
||||
};
|
||||
|
||||
type ViewWindow = BaseWindow & {
|
||||
@@ -188,7 +239,7 @@ type ViewWindow = BaseWindow & {
|
||||
label: string;
|
||||
/** Sidebar-icon character (">3"); "" if every glyph was taken at open time. */
|
||||
glyph: string;
|
||||
client: G2MirrorClient;
|
||||
client: TerminalClient;
|
||||
emulator: TerminalEmulator;
|
||||
receivedData: boolean;
|
||||
attachRequested: boolean;
|
||||
@@ -222,8 +273,8 @@ type PendingView = {
|
||||
socket: string;
|
||||
label: string;
|
||||
glyph: string;
|
||||
/** Client options captured when the view was requested from a live control. */
|
||||
options: G2MirrorClientOptions;
|
||||
/** How to make the view's client, captured when it was requested from a live control. */
|
||||
options: ClientRecipe;
|
||||
};
|
||||
|
||||
const windows = new Map<string, TerminalWindow>();
|
||||
@@ -304,7 +355,13 @@ let screenOn = true;
|
||||
*/
|
||||
type ControlConnection = {
|
||||
config: TerminalConnection;
|
||||
client: G2MirrorClient | null;
|
||||
client: TerminalClient | null;
|
||||
/**
|
||||
* An SSH failure only the user can fix (host key to verify, password or
|
||||
* key needed). Shown on the host's heading with a row that opens the fix;
|
||||
* reconnects wait for it. Cleared on a successful connection.
|
||||
*/
|
||||
sshIssue: SshFailure | null;
|
||||
state: G2MirrorState | null;
|
||||
unsubscribers: Array<() => void>;
|
||||
reconnectTimer: ReturnType<typeof setTimeout> | null;
|
||||
@@ -513,7 +570,8 @@ onSettingsStoreChanged((key) => {
|
||||
reportIdle();
|
||||
return;
|
||||
case NEW_CONNECTION_DRAFT_KEY:
|
||||
// Live keystrokes from the phone editor; repaint the add screen.
|
||||
case SSH_PASSWORD_DRAFT_KEY:
|
||||
// Live keystrokes from the phone editor; repaint the add/password screen.
|
||||
renderHubWindows();
|
||||
return;
|
||||
case "terminal.autoReconnect":
|
||||
@@ -587,6 +645,7 @@ function openWindow(windowId: string, surfaceId: string, title: string, viewport
|
||||
list: null,
|
||||
sessionOrder: [],
|
||||
addError: "",
|
||||
page: null,
|
||||
});
|
||||
// The hub carries the app's assistant tools; declare them once it exists.
|
||||
post({ type: "set-tools", windowId, tools: TERMINAL_TOOLS });
|
||||
@@ -619,6 +678,10 @@ function closeWindow(windowId: string): void {
|
||||
// Window closed mid-add: shut the phone editor down.
|
||||
endAddConnection(window);
|
||||
}
|
||||
if (window.kind === "hub" && window.mode === "page") {
|
||||
// Likewise for a page's phone editor (the password draft).
|
||||
closeHubPage(window, "sessions");
|
||||
}
|
||||
// Likewise for a setting being edited from the window menu.
|
||||
window.menu?.close();
|
||||
windows.delete(windowId);
|
||||
@@ -636,17 +699,120 @@ function closeWindow(windowId: string): void {
|
||||
}
|
||||
}
|
||||
|
||||
/** Client options for a connection string; null if the string doesn't parse. */
|
||||
function clientOptionsFor(connection: TerminalConnection): G2MirrorClientOptions | null {
|
||||
const parsed = parseConnectionString(connection.url);
|
||||
/**
|
||||
* How to make clients for a connection: "g2mirror" dials a g2mirror server
|
||||
* directly, "ssh-g2mirror" reaches one through an SSH tunnel, "tmux" runs
|
||||
* tmux control mode over SSH.
|
||||
*/
|
||||
type ClientRecipe = {
|
||||
kind: "g2mirror" | "ssh-g2mirror" | "tmux";
|
||||
/**
|
||||
* `role` "control" watches bells (tmux keeps the bell bookkeeping for that
|
||||
* client only). `onSshFailure` hears why an SSH channel failed.
|
||||
*/
|
||||
create(cols: number, rows: number, role: "control" | "view", onSshFailure?: (failure: SshFailure) => void): TerminalClient;
|
||||
};
|
||||
|
||||
/** Client recipe for a connection string; null if the string doesn't parse. */
|
||||
function clientOptionsFor(connection: TerminalConnection): ClientRecipe | null {
|
||||
const parsed = parseAnyConnectionString(connection.url);
|
||||
if (!parsed) return null;
|
||||
if (parsed.kind === "g2mirror") {
|
||||
const { secure, host, port, authToken } = parsed;
|
||||
return {
|
||||
kind: "g2mirror",
|
||||
create: (cols, rows) => new G2MirrorClient({ secure, host, port, authToken, deviceName: DEVICE_NAME, cols, rows }),
|
||||
};
|
||||
}
|
||||
const connectionId = connection.id;
|
||||
const label = connectionStringHostLabel(connection.url);
|
||||
// Read at every channel open, so a newly trusted key or saved password
|
||||
// applies to the next (re)connect, views included.
|
||||
const endpoint = (): SshEndpoint => ({
|
||||
host: parsed.host,
|
||||
port: parsed.port,
|
||||
user: parsed.user,
|
||||
hostKeys: loadConnections().find((candidate) => candidate.id === connectionId)?.hostKeys ?? [],
|
||||
password: getSshSecret(sshPasswordSecretId(connectionId)),
|
||||
useKey: true,
|
||||
});
|
||||
if (parsed.mode === "g2mirror") {
|
||||
const { authToken, targetHost, targetPort } = parsed;
|
||||
const urlHost = targetHost.includes(":") && !targetHost.startsWith("[") ? `[${targetHost}]` : targetHost;
|
||||
const url = `ws://${urlHost}:${targetPort}/`;
|
||||
return {
|
||||
kind: "ssh-g2mirror",
|
||||
create: (cols, rows, _role, onSshFailure) =>
|
||||
new G2MirrorClient({
|
||||
secure: false,
|
||||
host: targetHost,
|
||||
port: targetPort,
|
||||
authToken,
|
||||
deviceName: DEVICE_NAME,
|
||||
cols,
|
||||
rows,
|
||||
transport: {
|
||||
label: `${label} over SSH`,
|
||||
open: (listener) => {
|
||||
const channel = openSshChannel(endpoint(), { type: "websocket", url }, {
|
||||
onOpen: () => listener.onOpen(),
|
||||
onText: (text) => listener.onTextMessage(text),
|
||||
onClosed: (info) => listener.onClosed(info.code ?? 1000, info.reason ?? ""),
|
||||
onFailure: (failure) => {
|
||||
onSshFailure?.(failure);
|
||||
listener.onFailure(describeSshFailure(failure));
|
||||
},
|
||||
});
|
||||
return { sendText: (text) => channel.send(text), sendBinary: () => false, close: () => channel.close() };
|
||||
},
|
||||
},
|
||||
}),
|
||||
};
|
||||
}
|
||||
return {
|
||||
...parsed,
|
||||
deviceName: DEVICE_NAME,
|
||||
...viewGrid(),
|
||||
kind: "tmux",
|
||||
create: (cols, rows, role, onSshFailure) => {
|
||||
const openChannel: OpenLineChannel = (command, listener) =>
|
||||
openSshChannel(endpoint(), { type: "exec", command }, {
|
||||
onOpen: () => listener.onOpen(),
|
||||
onText: (line) => listener.onLine(line),
|
||||
onStderr: (line) => listener.onStderr(line),
|
||||
onClosed: (info) => listener.onClosed(info.exitStatus ?? null),
|
||||
onFailure: (failure) => {
|
||||
onSshFailure?.(failure);
|
||||
listener.onFailure(describeSshFailure(failure));
|
||||
},
|
||||
});
|
||||
return new TmuxClient({ openChannel, label, cols, rows, stateKey: role === "control" ? connectionId : "" });
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function sshPasswordSecretId(connectionId: string): string {
|
||||
return `terminal.password.${connectionId}`;
|
||||
}
|
||||
|
||||
/** Failures that retrying can't fix: the user has to verify a key or supply credentials. */
|
||||
function sshFailureNeedsUser(failure: SshFailure): boolean {
|
||||
return failure.kind === "hostkey-unknown" || failure.kind === "hostkey-mismatch" || failure.kind === "auth";
|
||||
}
|
||||
|
||||
/**
|
||||
* A control's SSH channel failed. If the user has to act, remember why, and
|
||||
* if they're looking at the hub's lists, open the page that fixes it.
|
||||
*/
|
||||
function noteSshFailure(control: ControlConnection, failure: SshFailure): void {
|
||||
if (!sshFailureNeedsUser(failure) || controls.get(control.config.id) !== control || !control.client) return;
|
||||
control.sshIssue = failure;
|
||||
renderHubWindows();
|
||||
for (const window of windows.values()) {
|
||||
if (window.kind === "hub" && window.foreground && (window.mode === "sessions" || window.mode === "connections")) {
|
||||
openSshIssuePage(window, control);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reconcile the live control clients with the stored connection list: start
|
||||
* enabled connections, stop disabled or removed ones, restart ones whose
|
||||
@@ -672,6 +838,7 @@ function syncControlsFromSettings(): void {
|
||||
control = {
|
||||
config: connection,
|
||||
client: null,
|
||||
sshIssue: null,
|
||||
state: null,
|
||||
unsubscribers: [],
|
||||
reconnectTimer: null,
|
||||
@@ -693,12 +860,13 @@ function syncControlsFromSettings(): void {
|
||||
|
||||
function startControl(control: ControlConnection): void {
|
||||
stopControl(control);
|
||||
const options = clientOptionsFor(control.config);
|
||||
if (!options) {
|
||||
const recipe = clientOptionsFor(control.config);
|
||||
if (!recipe) {
|
||||
control.state = null;
|
||||
return;
|
||||
}
|
||||
const client = new G2MirrorClient(options);
|
||||
const grid = viewGrid();
|
||||
const client = recipe.create(grid.cols, grid.rows, "control", (failure) => noteSshFailure(control, failure));
|
||||
const connectionId = control.config.id;
|
||||
control.client = client;
|
||||
control.state = client.state();
|
||||
@@ -712,6 +880,7 @@ function startControl(control: ControlConnection): void {
|
||||
control.state = state;
|
||||
if (state.phase === "connected") {
|
||||
control.reconnectDelayMs = RECONNECT_MIN_DELAY_MS;
|
||||
control.sshIssue = null;
|
||||
maybeCacheServerName(control, state.serverName);
|
||||
}
|
||||
if (state.phase === "failed") scheduleControlReconnect(control);
|
||||
@@ -786,6 +955,8 @@ function scheduleControlReconnect(control: ControlConnection): void {
|
||||
if (!terminalAutoReconnectSetting.get()) return;
|
||||
if (windows.size === 0 && !hasTerminalBackgroundWork()) return;
|
||||
if (!control.config.enabled) return;
|
||||
// Waiting on the user (host key, password) or on the host (no usable tmux).
|
||||
if (control.sshIssue || control.state?.retryable === false) return;
|
||||
const delayMs = control.reconnectDelayMs;
|
||||
control.reconnectDelayMs = Math.min(control.reconnectDelayMs * 2, RECONNECT_MAX_DELAY_MS);
|
||||
control.reconnectTimer = setTimeout(() => {
|
||||
@@ -952,7 +1123,7 @@ function createViewWindow(
|
||||
const cell = getTerminalFontConfig();
|
||||
const gridCols = Math.floor(viewport.width / cell.cellWidth);
|
||||
const gridRows = Math.floor(viewport.height / cell.cellHeight);
|
||||
const client = new G2MirrorClient({ ...view.options, cols: gridCols, rows: gridRows });
|
||||
const client = view.options.create(gridCols, gridRows, "view");
|
||||
const window: ViewWindow = {
|
||||
kind: "view",
|
||||
hub: null,
|
||||
@@ -1247,6 +1418,11 @@ function handleInput(window: TerminalWindow, event: InputEvent, frameId: number)
|
||||
renderAndSubmit(window, frameId);
|
||||
return;
|
||||
}
|
||||
if (window.kind === "hub" && window.mode === "page") {
|
||||
window.page?.onBack();
|
||||
renderAndSubmit(window, frameId);
|
||||
return;
|
||||
}
|
||||
if (window.kind === "hub" && window.mode === "connections") {
|
||||
setHubMode(window, "sessions");
|
||||
renderAndSubmit(window, frameId);
|
||||
@@ -1424,6 +1600,154 @@ function setHubMode(window: HubWindow, mode: HubMode): void {
|
||||
window.addError = "";
|
||||
}
|
||||
|
||||
function openHubPage(window: HubWindow, page: HubPage): void {
|
||||
if (window.mode === "add") endAddConnection(window);
|
||||
if (window.mode === "page") window.page?.onLeave?.();
|
||||
window.page = page;
|
||||
window.mode = "page";
|
||||
scheduleRender(window);
|
||||
}
|
||||
|
||||
/** Leave the current page (if any) for `mode`. */
|
||||
function closeHubPage(window: HubWindow, mode: HubMode): void {
|
||||
const page = window.page;
|
||||
window.page = null;
|
||||
page?.onLeave?.();
|
||||
setHubMode(window, mode);
|
||||
scheduleRender(window);
|
||||
}
|
||||
|
||||
/** The list a page returns to: the one it was opened from. */
|
||||
function hubListMode(window: HubWindow): HubMode {
|
||||
return window.mode === "connections" ? "connections" : "sessions";
|
||||
}
|
||||
|
||||
function openSshIssuePage(window: HubWindow, control: ControlConnection): void {
|
||||
const issue = control.sshIssue;
|
||||
if (!issue) return;
|
||||
if (issue.kind === "hostkey-unknown" && issue.hostKey) {
|
||||
openHostKeyPage(window, control, issue.hostKey);
|
||||
} else if (issue.kind === "hostkey-mismatch" && issue.hostKey) {
|
||||
openHostKeyChangedPage(window, control, issue.hostKey);
|
||||
} else if (issue.kind === "auth" && issue.passwordAllowed) {
|
||||
openPasswordPage(window, control, Boolean(issue.passwordTried));
|
||||
} else if (issue.kind === "auth") {
|
||||
openClientKeyPage(window, `${connectionDisplayName(control.config)} didn't accept this device's key (and doesn't take passwords).\n`);
|
||||
}
|
||||
}
|
||||
|
||||
function hostKeyTypeName(type: string): string {
|
||||
if (type === "ssh-ed25519") return "ED25519";
|
||||
if (type.startsWith("ecdsa-")) return "ECDSA";
|
||||
if (type === "ssh-rsa") return "RSA";
|
||||
return type;
|
||||
}
|
||||
|
||||
function hostKeyFile(type: string): string {
|
||||
if (type === "ssh-ed25519") return "/etc/ssh/ssh_host_ed25519_key.pub";
|
||||
if (type.startsWith("ecdsa-")) return "/etc/ssh/ssh_host_ecdsa_key.pub";
|
||||
return "/etc/ssh/ssh_host_rsa_key.pub";
|
||||
}
|
||||
|
||||
/** First connection to an SSH host: show the key's fingerprint; click trusts it. */
|
||||
function openHostKeyPage(window: HubWindow, control: ControlConnection, hostKey: SshHostKey): void {
|
||||
const returnMode = hubListMode(window);
|
||||
openHubPage(window, {
|
||||
title: "Verify host key",
|
||||
body: () =>
|
||||
`First connection to ${connectionStringHostLabel(control.config.url)}. Its ${hostKeyTypeName(hostKey.type)} host key fingerprint is:\n` +
|
||||
`${hostKey.fingerprint}\n\n` +
|
||||
`To check it, run this on the host and compare:\nssh-keygen -lf ${hostKeyFile(hostKey.type)}`,
|
||||
hint: `click trust and connect ${GESTURE_DOUBLE_CLICK} cancel`,
|
||||
onClick: () => {
|
||||
const hostKeys = [...control.config.hostKeys.filter((key) => key !== hostKey.key), hostKey.key];
|
||||
control.config.hostKeys = hostKeys;
|
||||
updateConnection(control.config.id, { hostKeys });
|
||||
control.sshIssue = null;
|
||||
closeHubPage(window, returnMode);
|
||||
connectControl(control);
|
||||
},
|
||||
onBack: () => closeHubPage(window, returnMode),
|
||||
});
|
||||
}
|
||||
|
||||
function openHostKeyChangedPage(window: HubWindow, control: ControlConnection, hostKey: SshHostKey): void {
|
||||
const returnMode = hubListMode(window);
|
||||
openHubPage(window, {
|
||||
title: "HOST KEY CHANGED",
|
||||
body: () =>
|
||||
`${connectionStringHostLabel(control.config.url)} presented a different host key than the one trusted before: ` +
|
||||
`${hostKeyTypeName(hostKey.type)} ${hostKey.fingerprint}\n\n` +
|
||||
"Someone may be intercepting the connection, so Faceclaw won't connect. If the host was reinstalled or its keys " +
|
||||
'were regenerated, use "Forget host key" on this connection in Manage Connections, then verify the new fingerprint.',
|
||||
hint: `${GESTURE_DOUBLE_CLICK} back`,
|
||||
onBack: () => closeHubPage(window, returnMode),
|
||||
});
|
||||
}
|
||||
|
||||
/** Ask for the host's password on the phone (masked editor); click saves it and connects. */
|
||||
function openPasswordPage(window: HubWindow, control: ControlConnection, rejected: boolean): void {
|
||||
const returnMode = hubListMode(window);
|
||||
terminalSshPasswordSetting.set("");
|
||||
post({ type: "start-text-setting-edit", settingId: terminalSshPasswordSetting.id });
|
||||
openHubPage(window, {
|
||||
title: "SSH password",
|
||||
body: () => {
|
||||
const typed = terminalSshPasswordSetting.get();
|
||||
return (
|
||||
(rejected ? "The host refused the saved password.\n" : "") +
|
||||
`Type the password for ${connectionStringHostLabel(control.config.url)} in the phone app, then click to connect. ` +
|
||||
"It is saved encrypted on this phone.\n\n" +
|
||||
(typed ? "*".repeat(Math.min(typed.length, 32)) : "(nothing typed yet)")
|
||||
);
|
||||
},
|
||||
hint: `click connect ${GESTURE_DOUBLE_CLICK} cancel`,
|
||||
onClick: () => {
|
||||
const password = terminalSshPasswordSetting.get();
|
||||
if (!password) return;
|
||||
setSshSecret(sshPasswordSecretId(control.config.id), password);
|
||||
control.sshIssue = null;
|
||||
closeHubPage(window, returnMode);
|
||||
connectControl(control);
|
||||
},
|
||||
onBack: () => closeHubPage(window, returnMode),
|
||||
onLeave: () => {
|
||||
terminalSshPasswordSetting.set("");
|
||||
post({ type: "end-text-setting-edit" });
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/** This device's SSH public key (the private half never leaves the keystore); click copies it. */
|
||||
function openClientKeyPage(window: HubWindow, intro = ""): void {
|
||||
const returnMode = hubListMode(window);
|
||||
let key: { authorizedKey: string; fingerprint: string } | null = null;
|
||||
let error = "";
|
||||
try {
|
||||
key = sshClientKey(SSH_KEY_COMMENT);
|
||||
} catch (caught) {
|
||||
error = String((caught as Error)?.message ?? caught);
|
||||
}
|
||||
let copied = false;
|
||||
openHubPage(window, {
|
||||
title: "This device's SSH key",
|
||||
body: () =>
|
||||
key
|
||||
? `${intro}Add this line to ~/.ssh/authorized_keys on each host to log in with this phone's key:\n` +
|
||||
`${key.authorizedKey}\n${key.fingerprint}` +
|
||||
(copied ? "\n\nCopied to the phone's clipboard." : "")
|
||||
: `Couldn't create this device's key: ${error}`,
|
||||
hint: key ? `click copy to phone clipboard ${GESTURE_DOUBLE_CLICK} back` : `${GESTURE_DOUBLE_CLICK} back`,
|
||||
onClick: key
|
||||
? () => {
|
||||
copyToPhoneClipboard("SSH public key", key!.authorizedKey);
|
||||
copied = true;
|
||||
}
|
||||
: undefined,
|
||||
onBack: () => closeHubPage(window, returnMode),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* One control connection's sessions in this hub window's display order:
|
||||
* most-recently-updated first as of when the window became visible, with
|
||||
@@ -1479,6 +1803,7 @@ function hubSessionItems(window: HubWindow): HubItem[] {
|
||||
];
|
||||
const multiHost = controls.size > 1;
|
||||
const canLaunch = launchPresetNames().length > 0;
|
||||
const isTmux = (control: ControlConnection) => clientOptionsFor(control.config)?.kind === "tmux";
|
||||
// Every configured host is listed under its own heading, in stored order,
|
||||
// whatever its connection state: a connected host lists its sessions, any
|
||||
// other shows its state on the heading plus a Connect row (unless it is
|
||||
@@ -1488,10 +1813,17 @@ function hubSessionItems(window: HubWindow): HubItem[] {
|
||||
const name = connectionDisplayName(control.config);
|
||||
if (!isControlConnected(control)) {
|
||||
items.push({ label: `${name} (${controlStatusWord(control)})`, heading: true });
|
||||
if (control.sshIssue && control.config.enabled) {
|
||||
items.push({ label: sshIssueAction(control.sshIssue), onSelect: () => openSshIssuePage(window, control) });
|
||||
continue;
|
||||
}
|
||||
const connecting = control.config.enabled && control.state?.phase === "connecting";
|
||||
if (!connecting && clientOptionsFor(control.config)) {
|
||||
// A failure retrying can't fix (tmux missing or too old) says why;
|
||||
// selecting it retries once the host is fixed.
|
||||
const unfixable = control.config.enabled && control.state?.retryable === false;
|
||||
items.push({
|
||||
label: control.reconnectTimer ? "Connect now" : "Connect",
|
||||
label: unfixable ? control.state!.status : control.reconnectTimer ? "Connect now" : "Connect",
|
||||
onSelect: () => connectControl(control),
|
||||
});
|
||||
}
|
||||
@@ -1500,7 +1832,8 @@ function hubSessionItems(window: HubWindow): HubItem[] {
|
||||
items.push({
|
||||
label: name,
|
||||
heading: true,
|
||||
onSelect: canLaunch ? () => launchOnHost(window, control) : undefined,
|
||||
// tmux hosts can always start a shell, presets or not.
|
||||
onSelect: canLaunch || isTmux(control) ? () => launchOnHost(window, control) : undefined,
|
||||
});
|
||||
const sessions = orderedSessions(window, control);
|
||||
for (const session of sessions) {
|
||||
@@ -1516,7 +1849,11 @@ function hubSessionItems(window: HubWindow): HubItem[] {
|
||||
}
|
||||
if (!sessions.length) {
|
||||
items.push({
|
||||
label: multiHost ? "(no live sessions)" : "(no live sessions; run g2mirror <command>)",
|
||||
label: isTmux(control)
|
||||
? "(no tmux sessions; select the host to start one)"
|
||||
: multiHost
|
||||
? "(no live sessions)"
|
||||
: "(no live sessions; run g2mirror <command>)",
|
||||
onSelect: () => control.client?.listSessions(),
|
||||
});
|
||||
}
|
||||
@@ -1537,6 +1874,10 @@ function hubConnectionItems(window: HubWindow): HubItem[] {
|
||||
label: "Add connection",
|
||||
onSelect: () => beginAddConnection(window),
|
||||
},
|
||||
{
|
||||
label: "This device's SSH key",
|
||||
onSelect: () => openClientKeyPage(window),
|
||||
},
|
||||
{
|
||||
label: "Done",
|
||||
onSelect: () => setHubMode(window, "sessions"),
|
||||
@@ -1547,6 +1888,13 @@ function hubConnectionItems(window: HubWindow): HubItem[] {
|
||||
|
||||
function controlStatusWord(control: ControlConnection): string {
|
||||
if (!control.config.enabled) return "off";
|
||||
const issue = control.sshIssue;
|
||||
if (issue) {
|
||||
if (issue.kind === "hostkey-unknown") return "verify host key";
|
||||
if (issue.kind === "hostkey-mismatch") return "HOST KEY CHANGED";
|
||||
if (issue.passwordTried) return "password rejected";
|
||||
return issue.passwordAllowed ? "password needed" : "key not authorized";
|
||||
}
|
||||
switch (control.state?.phase) {
|
||||
case "connected":
|
||||
case "attached":
|
||||
@@ -1579,6 +1927,32 @@ function openConnectionActions(window: HubWindow, control: ControlConnection): v
|
||||
connectControl(control);
|
||||
},
|
||||
},
|
||||
...(control.config.hostKeys.length
|
||||
? [
|
||||
{
|
||||
label: "Forget host key",
|
||||
onSelect: (ctx: { stack: { pop(): unknown } }) => {
|
||||
ctx.stack.pop();
|
||||
control.config.hostKeys = [];
|
||||
updateConnection(control.config.id, { hostKeys: [] });
|
||||
control.sshIssue = null;
|
||||
if (control.config.enabled) startControl(control);
|
||||
renderHubWindows();
|
||||
},
|
||||
},
|
||||
]
|
||||
: []),
|
||||
...(isSshConnection(control) && getSshSecret(sshPasswordSecretId(control.config.id))
|
||||
? [
|
||||
{
|
||||
label: "Forget saved password",
|
||||
onSelect: (ctx: { stack: { pop(): unknown } }) => {
|
||||
ctx.stack.pop();
|
||||
removeSshSecret(sshPasswordSecretId(control.config.id));
|
||||
},
|
||||
},
|
||||
]
|
||||
: []),
|
||||
{
|
||||
label: `Remove ${name}`,
|
||||
onSelect: (ctx) => {
|
||||
@@ -1596,6 +1970,11 @@ function openConnectionActions(window: HubWindow, control: ControlConnection): v
|
||||
windowMenu(window).open(items);
|
||||
}
|
||||
|
||||
function isSshConnection(control: ControlConnection): boolean {
|
||||
const kind = clientOptionsFor(control.config)?.kind;
|
||||
return kind === "tmux" || kind === "ssh-g2mirror";
|
||||
}
|
||||
|
||||
/** Enable and (re)connect now; also the manual retry path, so reset backoff. */
|
||||
function connectControl(control: ControlConnection): void {
|
||||
control.reconnectDelayMs = RECONNECT_MIN_DELAY_MS;
|
||||
@@ -1616,6 +1995,7 @@ function disconnectControl(control: ControlConnection): void {
|
||||
|
||||
function removeControl(control: ControlConnection): void {
|
||||
stopControl(control);
|
||||
removeSshSecret(sshPasswordSecretId(control.config.id));
|
||||
controls.delete(control.config.id);
|
||||
saveConnections(loadConnections().filter((connection) => connection.id !== control.config.id));
|
||||
renderHubWindows();
|
||||
@@ -1624,7 +2004,7 @@ function removeControl(control: ControlConnection): void {
|
||||
/**
|
||||
* Enter the Add-connection screen: clear the draft and ask the shell to open
|
||||
* the phone text editor on it. The user types (or voice-inputs) the
|
||||
* g2mirror:// string, then clicks to save or double-clicks to cancel.
|
||||
* connection string, then clicks to save or double-clicks to cancel.
|
||||
*/
|
||||
function beginAddConnection(window: HubWindow): void {
|
||||
terminalNewConnectionSetting.set("");
|
||||
@@ -1634,15 +2014,15 @@ function beginAddConnection(window: HubWindow): void {
|
||||
|
||||
function saveAddConnection(window: HubWindow): void {
|
||||
const url = terminalNewConnectionSetting.get();
|
||||
if (!parseConnectionString(url)) {
|
||||
if (!parseAnyConnectionString(url)) {
|
||||
window.addError = url
|
||||
? "Not a g2mirror://token@host connection string."
|
||||
: "Enter a g2mirror:// connection string first.";
|
||||
? "Not an ssh://user@host or g2mirror://token@host string."
|
||||
: "Enter a connection string first.";
|
||||
scheduleRender(window);
|
||||
return;
|
||||
}
|
||||
const connections = loadConnections();
|
||||
connections.push({ id: `c${Date.now()}`, url, serverName: null, enabled: true });
|
||||
connections.push({ id: `c${Date.now()}`, url, serverName: null, enabled: true, hostKeys: [] });
|
||||
saveConnections(connections);
|
||||
endAddConnection(window);
|
||||
setHubMode(window, "connections");
|
||||
@@ -1672,6 +2052,15 @@ function handleHubInput(window: HubWindow, event: InputEvent, frameId: number):
|
||||
frameTimings.finishFrame(frameId, "discarded: terminal add-connection ignored input");
|
||||
return;
|
||||
}
|
||||
if (window.mode === "page") {
|
||||
if (event.type === "click" && window.page?.onClick) {
|
||||
window.page.onClick();
|
||||
renderAndSubmit(window, frameId);
|
||||
return;
|
||||
}
|
||||
frameTimings.finishFrame(frameId, "discarded: terminal page ignored input");
|
||||
return;
|
||||
}
|
||||
const list = hubMenu(window);
|
||||
list.setItems(hubItems(window));
|
||||
switch (event.type) {
|
||||
@@ -1859,6 +2248,11 @@ function launchPresetNames(): string[] {
|
||||
*/
|
||||
function launchOnHost(window: HubWindow, control: ControlConnection): void {
|
||||
const presets = launchPresetNames();
|
||||
if (presets.length === 0) {
|
||||
// A tmux host with no presets configured: a new session running the login shell.
|
||||
launchFromUi(control, "shell");
|
||||
return;
|
||||
}
|
||||
if (presets.length === 1) {
|
||||
launchFromUi(control, presets[0]!);
|
||||
return;
|
||||
@@ -1903,6 +2297,9 @@ function paintHub(window: HubWindow): GrayImage {
|
||||
if (window.mode === "add") {
|
||||
return paintAddConnection(window);
|
||||
}
|
||||
if (window.mode === "page" && window.page) {
|
||||
return paintHubPage(window, window.page);
|
||||
}
|
||||
const { viewportWidth: width, viewportHeight: height, padding } = window;
|
||||
const image = new GrayImage(width, height, 0);
|
||||
const font = chromeFont();
|
||||
@@ -1917,7 +2314,7 @@ function paintHub(window: HubWindow): GrayImage {
|
||||
|
||||
let listTop = header.listTop;
|
||||
if (window.mode === "sessions" && controls.size === 0) {
|
||||
image.drawText(font, header.titleX, listTop, "Add a g2mirror:// connection to get started, see:", 150);
|
||||
image.drawText(font, header.titleX, listTop, "Add an ssh:// (tmux) or g2mirror:// connection to get started, see:", 150);
|
||||
image.drawText(font, header.titleX, listTop + step, "https://github.com/jimrandomh/g2mirror", 190);
|
||||
listTop += 2 * step + 6;
|
||||
}
|
||||
@@ -1959,8 +2356,8 @@ function paintAddConnection(window: HubWindow): GrayImage {
|
||||
image.drawText(font, padding.left, padding.top, "Add connection", 220);
|
||||
const bodyX = padding.left + PAGE_BODY_INDENT;
|
||||
const instructionsY = padding.top + 10 + step;
|
||||
image.drawText(font, bodyX, instructionsY, "Type the g2mirror://token@host string in the", 170);
|
||||
image.drawText(font, bodyX, instructionsY + step, "phone app (or use voice input from the menu).", 170);
|
||||
image.drawText(font, bodyX, instructionsY, "Type ssh://user@host (tmux) or g2mirror://token@host in", 170);
|
||||
image.drawText(font, bodyX, instructionsY + step, "the phone app (or use voice input from the menu).", 170);
|
||||
const draftY = instructionsY + 3 * step;
|
||||
const draft = terminalNewConnectionSetting.get();
|
||||
image.drawText(font, bodyX, draftY, truncateLabel(draft || "(empty)", 52), 220);
|
||||
@@ -1971,6 +2368,34 @@ function paintAddConnection(window: HubWindow): GrayImage {
|
||||
return image;
|
||||
}
|
||||
|
||||
/** A page of text: title at the top padding, wrapped body, hint on the bottom padding. */
|
||||
function paintHubPage(window: HubWindow, page: HubPage): GrayImage {
|
||||
const { viewportWidth: width, viewportHeight: height, padding } = window;
|
||||
const image = new GrayImage(width, height, 0);
|
||||
const font = chromeFont();
|
||||
const step = lineStep(font);
|
||||
image.drawText(font, padding.left, padding.top, page.title, 220);
|
||||
const bodyX = padding.left + PAGE_BODY_INDENT;
|
||||
const hintY = height - padding.bottom - font.lineHeight;
|
||||
const lines = wrapText(font, page.body(), Math.max(1, width - padding.right - bodyX), { breakLongWords: true });
|
||||
let y = padding.top + 10 + step;
|
||||
for (const line of lines) {
|
||||
if (y + step > hintY) break;
|
||||
image.drawText(font, bodyX, y, line, 190);
|
||||
y += step;
|
||||
}
|
||||
image.drawText(font, bodyX, hintY, page.hint, 110);
|
||||
return image;
|
||||
}
|
||||
|
||||
/** The action row under a host whose SSH connection needs the user. */
|
||||
function sshIssueAction(issue: SshFailure): string {
|
||||
if (issue.kind === "hostkey-unknown") return "Verify host key...";
|
||||
if (issue.kind === "hostkey-mismatch") return "Host key changed!";
|
||||
if (issue.passwordAllowed) return issue.passwordTried ? "Re-enter password..." : "Enter password...";
|
||||
return "Show this device's SSH key...";
|
||||
}
|
||||
|
||||
function truncateLabel(text: string, maxLength: number): string {
|
||||
return text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 3))}...`;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
import type {
|
||||
G2MirrorHistoryReply,
|
||||
G2MirrorPhase,
|
||||
G2MirrorSession,
|
||||
G2MirrorState,
|
||||
} from "../../native/terminal-session-types";
|
||||
|
||||
/**
|
||||
* What the Terminal worker needs from a session backend. G2MirrorClient (a
|
||||
* g2mirror server, directly or tunnelled over SSH) and TmuxClient (tmux
|
||||
* control mode over SSH) both provide it. The model is g2mirror's: a client
|
||||
* starts "connecting", reaches "connected" (it can list and launch sessions,
|
||||
* and reports bells/activity/titles for them), and can then attach to one
|
||||
* session, view it (snapshot + live output), page its scrollback, and type
|
||||
* into it.
|
||||
*/
|
||||
export interface TerminalClient {
|
||||
state(): G2MirrorState;
|
||||
onStateChange(listener: (state: G2MirrorState) => void): () => void;
|
||||
/** Raw VT100/xterm bytes to feed the emulator. Snapshot implies reset-first. */
|
||||
onTerminalData(listener: (data: Uint8Array, kind: "snapshot" | "output") => void): () => void;
|
||||
onSessionAttached(listener: (command: string) => void): () => void;
|
||||
onSessionDetached(listener: (reason: string) => void): () => void;
|
||||
onBell(listener: (socket: string, lastBellAtMs: number) => void): () => void;
|
||||
onActivity(listener: (socket: string, lastOutputAtMs: number) => void): () => void;
|
||||
onTitle(listener: (socket: string, title: string) => void): () => void;
|
||||
/** Fired after a snapshot's terminal data, with its scrollback splice point. */
|
||||
onSnapshot(listener: (historyNext: number, historyOldest: number) => void): () => void;
|
||||
onHistoryLines(listener: (reply: G2MirrorHistoryReply) => void): () => void;
|
||||
setViewport(cols: number, rows: number): void;
|
||||
start(): void;
|
||||
stop(): void;
|
||||
listSessions(): void;
|
||||
launchSession(preset: string): Promise<string>;
|
||||
connectSession(socket: string): void;
|
||||
disconnectSession(): void;
|
||||
view(): void;
|
||||
unview(): void;
|
||||
requestHistory(before: number, limit?: number): void;
|
||||
sendInput(text: string): void;
|
||||
submitInput(text: string): void;
|
||||
}
|
||||
|
||||
export type { G2MirrorHistoryReply, G2MirrorPhase, G2MirrorSession, G2MirrorState };
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,5 +1,6 @@
|
||||
import { openSocket } from "./socket";
|
||||
import { openSocket, type SocketConnection, type SocketListener } from "./socket";
|
||||
import { toUint8Array } from "../util/array-util";
|
||||
import type { G2MirrorHistoryReply, G2MirrorPhase, G2MirrorSession, G2MirrorState } from "./terminal-session-types";
|
||||
|
||||
declare const android: any;
|
||||
declare const java: any;
|
||||
@@ -19,54 +20,7 @@ const LAUNCH_REPLY_TIMEOUT_MS = 10_000;
|
||||
// otherwise treat the "\r" as a pasted newline instead of the Enter key.
|
||||
const SUBMIT_DELAY_MS = 150;
|
||||
|
||||
export type G2MirrorSession = {
|
||||
socket: string;
|
||||
pid: number;
|
||||
cwdHint: string;
|
||||
/** Unix epoch ms of the terminal's last bell, or null if none observed. */
|
||||
lastBellAt: number | null;
|
||||
/**
|
||||
* Unix epoch ms (host clock) of the app's last output, or null if none
|
||||
* observed. Fresh to within the wrapper's 2s activity reporting interval
|
||||
* while we're connected; compare against other host timestamps, not the
|
||||
* phone clock (see the worker's local-receive-time activity tracking).
|
||||
*/
|
||||
lastOutputAt: number | null;
|
||||
/** Window title the app last set (xterm OSC 0/2), or null if none observed. */
|
||||
title: string | null;
|
||||
};
|
||||
|
||||
export type G2MirrorPhase =
|
||||
| "idle"
|
||||
| "connecting"
|
||||
| "connected" // handshake accepted; can list/attach
|
||||
| "attached" // relaying to one session
|
||||
| "failed";
|
||||
|
||||
export type G2MirrorState = {
|
||||
phase: G2MirrorPhase;
|
||||
status: string;
|
||||
sessions: G2MirrorSession[];
|
||||
attachedCommand: string;
|
||||
/**
|
||||
* server_name from the init success reply: a human-readable name for the
|
||||
* machine the server runs on. "" until the handshake succeeds (or when an
|
||||
* older server omits the field).
|
||||
*/
|
||||
serverName: string;
|
||||
};
|
||||
|
||||
/** A page of archived scrollback lines (see PROTOCOL.md "Scrollback history"). */
|
||||
export type G2MirrorHistoryReply = {
|
||||
/** Absolute index of lines[0]; the page covers [start, start + lines.length). */
|
||||
start: number;
|
||||
/** Oldest index still retained by the wrapper (older requests return nothing). */
|
||||
oldest: number;
|
||||
/** Current splice point (next line to be archived). */
|
||||
next: number;
|
||||
/** Plain text, ANSI-stripped, oldest-to-newest. */
|
||||
lines: string[];
|
||||
};
|
||||
export type { G2MirrorHistoryReply, G2MirrorPhase, G2MirrorSession, G2MirrorState };
|
||||
|
||||
export type G2MirrorClientOptions = {
|
||||
/** TLS (g2mirrors:// → wss) vs plain (g2mirror:// → ws). */
|
||||
@@ -77,6 +31,12 @@ export type G2MirrorClientOptions = {
|
||||
deviceName: string;
|
||||
cols: number;
|
||||
rows: number;
|
||||
/**
|
||||
* Opens the websocket some other way than dialing host:port directly
|
||||
* (e.g. through an SSH tunnel); `label` then names the endpoint in status
|
||||
* lines instead of host:port.
|
||||
*/
|
||||
transport?: { open: (listener: SocketListener) => SocketConnection; label: string };
|
||||
};
|
||||
|
||||
type TerminalDataKind = "snapshot" | "output";
|
||||
@@ -180,7 +140,8 @@ export class G2MirrorClient {
|
||||
this.stopped = false;
|
||||
const generation = ++this.connectionGeneration;
|
||||
const url = `${this.options.secure ? "wss" : "ws"}://${this.options.host}:${this.options.port}`;
|
||||
this.setState("connecting", `Connecting to ${this.options.host}:${this.options.port}...`);
|
||||
const transport = this.options.transport;
|
||||
this.setState("connecting", `Connecting to ${transport ? transport.label : `${this.options.host}:${this.options.port}`}...`);
|
||||
this.listenerProxy = {
|
||||
onOpen: () => {
|
||||
if (this.stopped || generation !== this.connectionGeneration) return;
|
||||
@@ -208,7 +169,7 @@ export class G2MirrorClient {
|
||||
},
|
||||
};
|
||||
try {
|
||||
this.ws = openSocket(url, this.listenerProxy);
|
||||
this.ws = transport ? transport.open(this.listenerProxy!) : openSocket(url, this.listenerProxy);
|
||||
} catch (error) {
|
||||
this.ws = null;
|
||||
this.handleConnectionLost(`Connection failed: ${shortenError(String((error as Error)?.message ?? error))}`);
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
/**
|
||||
* Platform-independent half of the SSH transport bindings (ssh.ts /
|
||||
* ssh.ios.ts): the types the app uses and the decoding of the Go
|
||||
* transport's events (native/ssh/faceclawssh.go, Listener).
|
||||
*/
|
||||
|
||||
/** Where and as whom to connect. */
|
||||
export type SshEndpoint = {
|
||||
host: string;
|
||||
port: number;
|
||||
user: string;
|
||||
/** Pinned host keys (SSH wire format, base64). Empty: first connection reports hostkey-unknown. */
|
||||
hostKeys: string[];
|
||||
/** Saved password, or "" to try only the device key. */
|
||||
password: string;
|
||||
/** Offer the device's client key. */
|
||||
useKey: boolean;
|
||||
};
|
||||
|
||||
export type SshChannelSpec =
|
||||
| {
|
||||
/** Run a command on the host; text is exchanged a line at a time. */
|
||||
type: "exec";
|
||||
command: string;
|
||||
}
|
||||
| {
|
||||
/** WebSocket to a URL resolved on the host's side (e.g. ws://127.0.0.1:8737/). */
|
||||
type: "websocket";
|
||||
url: string;
|
||||
};
|
||||
|
||||
export type SshHostKey = {
|
||||
/** SSH key type, e.g. "ssh-ed25519". */
|
||||
type: string;
|
||||
/** OpenSSH-style "SHA256:..." fingerprint. */
|
||||
fingerprint: string;
|
||||
/** SSH wire format, base64: the value to pin in SshEndpoint.hostKeys. */
|
||||
key: string;
|
||||
};
|
||||
|
||||
export type SshFailureKind =
|
||||
| "hostkey-unknown"
|
||||
| "hostkey-mismatch"
|
||||
| "auth"
|
||||
| "network"
|
||||
| "channel"
|
||||
| "config"
|
||||
| "internal";
|
||||
|
||||
export type SshFailure = {
|
||||
kind: SshFailureKind;
|
||||
message: string;
|
||||
/** For hostkey-*: the key the host presented. */
|
||||
hostKey?: SshHostKey;
|
||||
/** For auth: the host takes passwords / we sent one / we offered our key. */
|
||||
passwordAllowed?: boolean;
|
||||
passwordTried?: boolean;
|
||||
keyTried?: boolean;
|
||||
};
|
||||
|
||||
export type SshClosed = {
|
||||
/** Exec channels: the command's exit status (and signal, if killed). */
|
||||
exitStatus?: number;
|
||||
signal?: string;
|
||||
/** WebSocket channels: the close frame's code and reason. */
|
||||
code?: number;
|
||||
reason?: string;
|
||||
};
|
||||
|
||||
export type SshChannelListener = {
|
||||
onOpen(): void;
|
||||
onText(text: string): void;
|
||||
onStderr?(line: string): void;
|
||||
/** Terminal: the channel ended normally. */
|
||||
onClosed(info: SshClosed): void;
|
||||
/** Terminal: the channel couldn't open or was lost. */
|
||||
onFailure(failure: SshFailure): void;
|
||||
};
|
||||
|
||||
export type SshChannel = {
|
||||
/** Queue a websocket text frame / an exec stdin line. False once closed. */
|
||||
send(text: string): boolean;
|
||||
/** Flush queued sends, then end the channel. No events follow. */
|
||||
close(): void;
|
||||
};
|
||||
|
||||
export type SshClientKey = {
|
||||
/** "ecdsa-sha2-nistp256 AAAA... comment", for ~/.ssh/authorized_keys. */
|
||||
authorizedKey: string;
|
||||
fingerprint: string;
|
||||
};
|
||||
|
||||
/** Build the Go transport's openSpec JSON. */
|
||||
export function encodeSshSpec(endpoint: SshEndpoint, channel: SshChannelSpec): string {
|
||||
return JSON.stringify({
|
||||
host: endpoint.host,
|
||||
port: endpoint.port,
|
||||
user: endpoint.user,
|
||||
password: endpoint.password,
|
||||
hostKeys: endpoint.hostKeys,
|
||||
useKey: endpoint.useKey,
|
||||
channel,
|
||||
});
|
||||
}
|
||||
|
||||
/** Route one transport event to the listener. Unknown kinds are ignored. */
|
||||
export function dispatchSshEvent(listener: SshChannelListener, kind: string, payload: string): void {
|
||||
switch (kind) {
|
||||
case "open":
|
||||
listener.onOpen();
|
||||
return;
|
||||
case "text":
|
||||
listener.onText(payload);
|
||||
return;
|
||||
case "stderr":
|
||||
listener.onStderr?.(payload);
|
||||
return;
|
||||
case "closed":
|
||||
listener.onClosed(parseJson(payload) ?? {});
|
||||
return;
|
||||
case "failure": {
|
||||
const failure = parseJson(payload);
|
||||
listener.onFailure(
|
||||
failure && typeof failure.kind === "string"
|
||||
? failure
|
||||
: { kind: "internal", message: `bad failure payload: ${payload}` },
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function parseJson(text: string): any {
|
||||
try {
|
||||
return JSON.parse(text);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/** Human summary of a failure for status lines. */
|
||||
export function describeSshFailure(failure: SshFailure): string {
|
||||
switch (failure.kind) {
|
||||
case "hostkey-unknown":
|
||||
return "Host key not yet trusted.";
|
||||
case "hostkey-mismatch":
|
||||
return "HOST KEY CHANGED; refusing to connect.";
|
||||
case "auth":
|
||||
return failure.message || "Authentication failed.";
|
||||
default:
|
||||
return failure.message || failure.kind;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
import {
|
||||
dispatchSshEvent,
|
||||
encodeSshSpec,
|
||||
type SshChannel,
|
||||
type SshChannelListener,
|
||||
type SshChannelSpec,
|
||||
type SshClientKey,
|
||||
type SshEndpoint,
|
||||
} from "./ssh-common";
|
||||
|
||||
export * from "./ssh-common";
|
||||
|
||||
declare const FaceclawSshChannel: any;
|
||||
declare const FaceclawSshKeys: any;
|
||||
|
||||
// Like socket.ios.ts: Go delivers events on its own threads, so the native
|
||||
// side queues them and this isolate drains the queue on a timer.
|
||||
const POLL_INTERVAL_MS = 25;
|
||||
|
||||
/** iOS SSH transport: FaceclawSshChannel (ObjC) over the gomobile-bound Go package in native/ssh. */
|
||||
export function openSshChannel(endpoint: SshEndpoint, channel: SshChannelSpec, listener: SshChannelListener): SshChannel {
|
||||
const native = FaceclawSshChannel.alloc().initWithSpecUseKey(encodeSshSpec(endpoint, channel), endpoint.useKey);
|
||||
let ended = false;
|
||||
const stop = () => {
|
||||
if (ended) return;
|
||||
ended = true;
|
||||
clearInterval(timer);
|
||||
native.close();
|
||||
};
|
||||
const timer = setInterval(() => {
|
||||
const events = JSON.parse(String(native.takeEvents())) as Array<{ kind: string; payload: string }>;
|
||||
for (const event of events) {
|
||||
if (ended) break;
|
||||
if (event.kind === "closed" || event.kind === "failure") {
|
||||
// Terminal events: stop polling, then deliver.
|
||||
ended = true;
|
||||
clearInterval(timer);
|
||||
}
|
||||
dispatchSshEvent(listener, event.kind, event.payload);
|
||||
}
|
||||
}, POLL_INTERVAL_MS);
|
||||
return {
|
||||
send: (text) => !ended && native.send(text) === true,
|
||||
close: stop,
|
||||
};
|
||||
}
|
||||
|
||||
export function sshClientKey(comment: string): SshClientKey {
|
||||
const authorizedKey = FaceclawSshKeys.authorizedKeyWithComment(comment);
|
||||
const fingerprint = FaceclawSshKeys.fingerprint();
|
||||
if (!authorizedKey || !fingerprint) throw new Error("Could not create the SSH client key.");
|
||||
return { authorizedKey: String(authorizedKey), fingerprint: String(fingerprint) };
|
||||
}
|
||||
|
||||
export function getSshSecret(id: string): string {
|
||||
return String(FaceclawSshKeys.secretForId(id) ?? "");
|
||||
}
|
||||
|
||||
export function setSshSecret(id: string, value: string): void {
|
||||
FaceclawSshKeys.setSecretForId(value, id);
|
||||
}
|
||||
|
||||
export function removeSshSecret(id: string): void {
|
||||
FaceclawSshKeys.removeSecretForId(id);
|
||||
}
|
||||
|
||||
export function copyToPhoneClipboard(_label: string, text: string): void {
|
||||
FaceclawSshKeys.copyToClipboard(text);
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
import { Utils } from "@nativescript/core";
|
||||
import {
|
||||
dispatchSshEvent,
|
||||
encodeSshSpec,
|
||||
type SshChannel,
|
||||
type SshChannelListener,
|
||||
type SshChannelSpec,
|
||||
type SshClientKey,
|
||||
type SshEndpoint,
|
||||
} from "./ssh-common";
|
||||
|
||||
export * from "./ssh-common";
|
||||
|
||||
declare const com: any;
|
||||
|
||||
/**
|
||||
* Android SSH transport: FaceclawSshChannel (Kotlin) over the gomobile-bound
|
||||
* Go package in native/ssh. Callable from the main isolate or a worker;
|
||||
* events arrive on the calling isolate's thread.
|
||||
*/
|
||||
export function openSshChannel(endpoint: SshEndpoint, channel: SshChannelSpec, listener: SshChannelListener): SshChannel {
|
||||
let closed = false;
|
||||
const proxy = new com.faceclaw.app.FaceclawSshListener({
|
||||
onEvent: (kind: string, payload: string) => {
|
||||
if (closed) return;
|
||||
dispatchSshEvent(listener, String(kind), payload == null ? "" : String(payload));
|
||||
},
|
||||
});
|
||||
const native = new com.faceclaw.app.FaceclawSshChannel(encodeSshSpec(endpoint, channel), endpoint.useKey, proxy);
|
||||
return {
|
||||
send: (text) => !closed && native.send(text) === true,
|
||||
close: () => {
|
||||
if (closed) return;
|
||||
closed = true;
|
||||
native.close();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function context(): any {
|
||||
return Utils.android.getApplicationContext();
|
||||
}
|
||||
|
||||
/** The device's SSH client key (generated on first use). */
|
||||
export function sshClientKey(comment: string): SshClientKey {
|
||||
return {
|
||||
authorizedKey: String(com.faceclaw.app.FaceclawSshKeys.authorizedKey(comment)),
|
||||
fingerprint: String(com.faceclaw.app.FaceclawSshKeys.fingerprint()),
|
||||
};
|
||||
}
|
||||
|
||||
export function getSshSecret(id: string): string {
|
||||
return String(com.faceclaw.app.FaceclawSshKeys.getSecret(context(), id) ?? "");
|
||||
}
|
||||
|
||||
export function setSshSecret(id: string, value: string): void {
|
||||
com.faceclaw.app.FaceclawSshKeys.setSecret(context(), id, value);
|
||||
}
|
||||
|
||||
export function removeSshSecret(id: string): void {
|
||||
com.faceclaw.app.FaceclawSshKeys.removeSecret(context(), id);
|
||||
}
|
||||
|
||||
export function copyToPhoneClipboard(label: string, text: string): void {
|
||||
com.faceclaw.app.FaceclawSshKeys.copyToClipboard(context(), label, text);
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Session-list and connection-state types shared by the Terminal app's
|
||||
* backends (g2mirror-client.ts, apps/terminal/tmux-client.ts). Kept free of
|
||||
* platform imports so the tmux client can be unit-tested under node.
|
||||
*/
|
||||
|
||||
export type G2MirrorSession = {
|
||||
socket: string;
|
||||
pid: number;
|
||||
cwdHint: string;
|
||||
/** Unix epoch ms of the terminal's last bell, or null if none observed. */
|
||||
lastBellAt: number | null;
|
||||
/**
|
||||
* Unix epoch ms (host clock) of the app's last output, or null if none
|
||||
* observed. Fresh to within the wrapper's 2s activity reporting interval
|
||||
* while we're connected; compare against other host timestamps, not the
|
||||
* phone clock (see the worker's local-receive-time activity tracking).
|
||||
*/
|
||||
lastOutputAt: number | null;
|
||||
/** Window title the app last set (xterm OSC 0/2), or null if none observed. */
|
||||
title: string | null;
|
||||
};
|
||||
|
||||
export type G2MirrorPhase =
|
||||
| "idle"
|
||||
| "connecting"
|
||||
| "connected" // handshake accepted; can list/attach
|
||||
| "attached" // relaying to one session
|
||||
| "failed";
|
||||
|
||||
export type G2MirrorState = {
|
||||
phase: G2MirrorPhase;
|
||||
status: string;
|
||||
sessions: G2MirrorSession[];
|
||||
attachedCommand: string;
|
||||
/**
|
||||
* server_name from the init success reply: a human-readable name for the
|
||||
* machine the server runs on. "" until the handshake succeeds (or when an
|
||||
* older server omits the field).
|
||||
*/
|
||||
serverName: string;
|
||||
/**
|
||||
* False when reconnecting can't help until the user changes something on
|
||||
* the host (e.g. tmux missing or too old). Absent means retryable.
|
||||
*/
|
||||
retryable?: boolean;
|
||||
};
|
||||
|
||||
/** A page of archived scrollback lines (see PROTOCOL.md "Scrollback history"). */
|
||||
export type G2MirrorHistoryReply = {
|
||||
/** Absolute index of lines[0]; the page covers [start, start + lines.length). */
|
||||
start: number;
|
||||
/** Oldest index still retained by the wrapper (older requests return nothing). */
|
||||
oldest: number;
|
||||
/** Current splice point (next line to be archived). */
|
||||
next: number;
|
||||
/** Plain text, ANSI-stripped, oldest-to-newest. */
|
||||
lines: string[];
|
||||
};
|
||||
@@ -1340,11 +1340,28 @@ export const terminalNewConnectionSetting = new ConfigSettingString({
|
||||
label: "New connection",
|
||||
storageKey: "terminal.newConnectionDraft",
|
||||
defaultValue: "",
|
||||
editorTitle: "g2mirror connection string (g2mirror://token@host)",
|
||||
editorTitle: "Connection (ssh://user@host or g2mirror://token@host)",
|
||||
glassesEditTitle: "Add connection",
|
||||
normalize: (value) => (value ?? "").replace(/[\x00-\x1f]+/g, "").trim(),
|
||||
});
|
||||
|
||||
/**
|
||||
* Staging buffer for the Terminal app's SSH password prompt: the worker opens
|
||||
* the phone's (masked) text editor on it, then moves what was typed into the
|
||||
* platform keystore (app/native/ssh) and clears it as soon as the user
|
||||
* confirms or cancels on the glasses. Not listed in the Settings app.
|
||||
*/
|
||||
export const terminalSshPasswordSetting = new ConfigSettingString({
|
||||
id: "terminal-ssh-password",
|
||||
label: "SSH password",
|
||||
storageKey: "terminal.sshPasswordDraft",
|
||||
defaultValue: "",
|
||||
inputKind: "password",
|
||||
editorTitle: "SSH password",
|
||||
glassesEditTitle: "SSH password",
|
||||
normalize: (value) => (value ?? "").replace(/[\r\n]+/g, ""),
|
||||
});
|
||||
|
||||
/**
|
||||
* Staging buffer for the T3 Code app's Pair-environment screen: the phone
|
||||
* text editor types the `t3 pair` link into it, and the app reads it back
|
||||
|
||||
@@ -1,8 +1,11 @@
|
||||
const { buildKotlin, checkAndroidRuntime } = require('../../scripts/kotlin-build.cjs');
|
||||
const { buildGoSsh } = require('../../scripts/go-ssh-build.cjs');
|
||||
|
||||
module.exports = function (hookArgs) {
|
||||
// NativeScript parses hooks with an older JavaScript parser; avoid optional chaining.
|
||||
const { platform, release } = hookArgs.prepareData;
|
||||
if (platform === 'android') checkAndroidRuntime();
|
||||
return buildKotlin(platform, release ? 'release' : 'debug');
|
||||
return buildKotlin(platform, release ? 'release' : 'debug').then(function () {
|
||||
return buildGoSsh(platform);
|
||||
});
|
||||
};
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
/**
|
||||
* Events from FaceclawSshChannel, delivered on the thread that opened the
|
||||
* channel. See native/ssh/faceclawssh.go (Listener) for the kinds and payloads.
|
||||
*/
|
||||
interface FaceclawSshListener {
|
||||
fun onEvent(kind: String?, payload: String?): Unit
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
# Faceclaw SSH transport
|
||||
|
||||
The Terminal app's SSH client: a small Go package over
|
||||
[golang.org/x/crypto/ssh](https://pkg.go.dev/golang.org/x/crypto/ssh), bound
|
||||
into the apps with gomobile. It provides text-message channels over SSH:
|
||||
|
||||
- **exec**: run a command on the host, exchanging newline-delimited text
|
||||
(used for tmux control mode and the tmux session poller; see
|
||||
`app/apps/terminal/tmux-client.ts`).
|
||||
- **websocket**: a WebSocket to an address as seen from the host, through a
|
||||
`direct-tcpip` channel (used to tunnel g2mirror-server's protocol).
|
||||
|
||||
Channels to the same host and credentials share one SSH connection, with a
|
||||
keepalive that fails them promptly when the peer silently disappears. Host
|
||||
keys are pinned by the app (first connection reports the presented key so
|
||||
the user can verify its fingerprint). Authentication uses a non-exportable
|
||||
ECDSA P-256 key held by the platform keystore (Android Keystore/StrongBox,
|
||||
iOS Secure Enclave; see `FaceclawSsh.kt` / `FaceclawSsh.m`) and, if the
|
||||
server allows it, a password saved encrypted on the phone.
|
||||
|
||||
## Building
|
||||
|
||||
`scripts/go-ssh-build.cjs` runs `gomobile bind` (pinned in `go.mod`'s tool
|
||||
block) from the NativeScript before-prepare hook and stages
|
||||
`faceclaw-ssh.aar` / `Faceclawssh.xcframework` into the local
|
||||
`@faceclaw/kotlin` plugin. It needs Go 1.26+ on PATH, plus the Android NDK
|
||||
(Android) or Xcode (iOS); a content stamp skips rebuilds when the Go sources
|
||||
haven't changed.
|
||||
|
||||
## Testing
|
||||
|
||||
`go test -race ./...` runs the transport against an in-process SSH server
|
||||
(host-key pinning, password and keyboard-interactive auth, key auth through
|
||||
a fake platform signer, exec framing, the websocket tunnel, connection
|
||||
sharing and loss).
|
||||
|
||||
## Keeping it current
|
||||
|
||||
x/crypto/ssh is the security boundary against a malicious host or a
|
||||
man in the middle; update it promptly when advisories appear
|
||||
(`go get golang.org/x/crypto@latest && go mod tidy`). A Go panic in any
|
||||
goroutine terminates the app: the package recovers in the goroutines it
|
||||
owns, but not inside the library's own.
|
||||
@@ -0,0 +1,254 @@
|
||||
package faceclawssh
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
"golang.org/x/crypto/ssh"
|
||||
)
|
||||
|
||||
type closedPayload struct {
|
||||
ExitStatus *int `json:"exitStatus,omitempty"`
|
||||
Signal string `json:"signal,omitempty"`
|
||||
Code *int `json:"code,omitempty"`
|
||||
Reason string `json:"reason,omitempty"`
|
||||
}
|
||||
|
||||
// runExec runs command on the host and relays newline-delimited text both
|
||||
// ways until the command exits, the connection drops, or Close.
|
||||
func (c *Channel) runExec(conn *pooledConn, command string) {
|
||||
session, err := conn.client.NewSession()
|
||||
if err != nil {
|
||||
c.fail(channelOpenFailure(conn, err))
|
||||
return
|
||||
}
|
||||
defer session.Close()
|
||||
stdin, err1 := session.StdinPipe()
|
||||
stdout, err2 := session.StdoutPipe()
|
||||
stderr, err3 := session.StderrPipe()
|
||||
if err := errors.Join(err1, err2, err3); err != nil {
|
||||
c.fail(&failure{Kind: "channel", Message: err.Error()})
|
||||
return
|
||||
}
|
||||
if err := session.Start(command); err != nil {
|
||||
c.fail(&failure{Kind: "channel", Message: "could not run command: " + err.Error()})
|
||||
return
|
||||
}
|
||||
go func() {
|
||||
<-c.ctx.Done()
|
||||
session.Close()
|
||||
}()
|
||||
c.markOpen()
|
||||
go func() {
|
||||
defer c.guard()
|
||||
for text := range c.sendQ {
|
||||
if _, err := io.WriteString(stdin, text+"\n"); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
// Close was called and the queue has drained: EOF tells the command
|
||||
// we're done (tmux control mode detaches on it).
|
||||
stdin.Close()
|
||||
}()
|
||||
stderrDone := make(chan struct{})
|
||||
go func() {
|
||||
defer close(stderrDone)
|
||||
defer c.guard()
|
||||
readLines(stderr, func(line string) { c.emit("stderr", line) })
|
||||
}()
|
||||
readErr := readLines(stdout, func(line string) { c.emit("text", line) })
|
||||
// Deliver the command's last words (e.g. "tmux: command not found")
|
||||
// before the close event, but don't hang on a stderr that never ends.
|
||||
select {
|
||||
case <-stderrDone:
|
||||
case <-time.After(500 * time.Millisecond):
|
||||
}
|
||||
if c.ctx.Err() != nil {
|
||||
return
|
||||
}
|
||||
waitErr := session.Wait()
|
||||
var exitErr *ssh.ExitError
|
||||
var missing *ssh.ExitMissingError
|
||||
switch {
|
||||
case waitErr == nil:
|
||||
status := 0
|
||||
c.finish("closed", closedPayload{ExitStatus: &status})
|
||||
case errors.As(waitErr, &exitErr):
|
||||
status := exitErr.ExitStatus()
|
||||
c.finish("closed", closedPayload{ExitStatus: &status, Signal: exitErr.Signal()})
|
||||
case errors.As(waitErr, &missing):
|
||||
// The channel closed without an exit status: usually the connection
|
||||
// went away under it.
|
||||
c.fail(lostFailure(conn, readErr))
|
||||
default:
|
||||
c.fail(lostFailure(conn, waitErr))
|
||||
}
|
||||
}
|
||||
|
||||
// readLines calls emit for each line of r (without its newline) and returns
|
||||
// the read error that ended it (nil at EOF). Lines may be arbitrarily long.
|
||||
func readLines(r io.Reader, emit func(string)) error {
|
||||
reader := bufio.NewReaderSize(r, 64*1024)
|
||||
for {
|
||||
line, err := reader.ReadBytes('\n')
|
||||
if len(line) > 0 {
|
||||
if line[len(line)-1] == '\n' {
|
||||
line = line[:len(line)-1]
|
||||
}
|
||||
emit(escapeLine(line))
|
||||
}
|
||||
if err == io.EOF {
|
||||
return nil
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// escapeLine makes a line safe to hand across the gomobile boundary as a
|
||||
// string (which must be valid UTF-8). Valid UTF-8 passes through. Otherwise
|
||||
// every byte >= 0x80 becomes "\ooo" (backslash, three octal digits): the same
|
||||
// escape tmux control mode uses for control characters and backslashes in
|
||||
// %output, so a %output line split mid-character still decodes back to its
|
||||
// exact bytes. (Outside %output a literal backslash is ambiguous with this
|
||||
// escape; such lines are only ever displayed.)
|
||||
func escapeLine(line []byte) string {
|
||||
if utf8.Valid(line) {
|
||||
return string(line)
|
||||
}
|
||||
var b strings.Builder
|
||||
for _, c := range line {
|
||||
if c >= 0x80 {
|
||||
fmt.Fprintf(&b, "\\%03o", c)
|
||||
} else {
|
||||
b.WriteByte(c)
|
||||
}
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// runWebSocket opens rawURL (ws://host:port/path) through the SSH
|
||||
// connection — host:port is resolved on the SSH server's side — and relays
|
||||
// text frames.
|
||||
func (c *Channel) runWebSocket(conn *pooledConn, rawURL string) {
|
||||
parsed, err := url.Parse(rawURL)
|
||||
if err != nil || parsed.Scheme != "ws" || parsed.Host == "" {
|
||||
c.fail(&failure{Kind: "config", Message: fmt.Sprintf("bad websocket URL %q", rawURL)})
|
||||
return
|
||||
}
|
||||
target := parsed.Host
|
||||
if parsed.Port() == "" {
|
||||
target = net.JoinHostPort(parsed.Hostname(), "80")
|
||||
}
|
||||
dialer := websocket.Dialer{
|
||||
NetDialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
|
||||
forwarded, err := conn.client.DialContext(ctx, "tcp", target)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return noDeadlineConn{forwarded}, nil
|
||||
},
|
||||
}
|
||||
// The handshake timeout rides the context: SSH channels can't do deadlines.
|
||||
handshakeCtx, cancelHandshake := context.WithTimeout(c.ctx, defaultConnectTimeout)
|
||||
ws, _, err := dialer.DialContext(handshakeCtx, rawURL, nil)
|
||||
cancelHandshake()
|
||||
if err != nil {
|
||||
if c.ctx.Err() != nil {
|
||||
return
|
||||
}
|
||||
c.fail(channelOpenFailure(conn, fmt.Errorf("could not reach %s on the host: %w", target, err)))
|
||||
return
|
||||
}
|
||||
defer ws.Close()
|
||||
go func() {
|
||||
<-c.ctx.Done()
|
||||
ws.Close()
|
||||
}()
|
||||
c.markOpen()
|
||||
go func() {
|
||||
defer c.guard()
|
||||
for text := range c.sendQ {
|
||||
if err := ws.WriteMessage(websocket.TextMessage, []byte(text)); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
ws.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "bye"),
|
||||
time.Now().Add(time.Second))
|
||||
}()
|
||||
for {
|
||||
kind, data, err := ws.ReadMessage()
|
||||
if err != nil {
|
||||
if c.ctx.Err() != nil {
|
||||
return
|
||||
}
|
||||
var closeErr *websocket.CloseError
|
||||
if errors.As(err, &closeErr) {
|
||||
code := closeErr.Code
|
||||
c.finish("closed", closedPayload{Code: &code, Reason: closeErr.Text})
|
||||
return
|
||||
}
|
||||
c.fail(lostFailure(conn, err))
|
||||
return
|
||||
}
|
||||
if kind == websocket.TextMessage {
|
||||
c.emit("text", string(data))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// noDeadlineConn adapts an SSH direct-tcpip channel for the websocket
|
||||
// library, which sets deadlines the channel doesn't support. Timeouts come
|
||||
// from contexts and the SSH keepalive instead.
|
||||
type noDeadlineConn struct{ net.Conn }
|
||||
|
||||
func (noDeadlineConn) SetDeadline(time.Time) error { return nil }
|
||||
func (noDeadlineConn) SetReadDeadline(time.Time) error { return nil }
|
||||
func (noDeadlineConn) SetWriteDeadline(time.Time) error { return nil }
|
||||
|
||||
// channelOpenFailure classifies a failure to open a channel: if the SSH
|
||||
// connection itself is gone it's a network failure (reconnect), otherwise
|
||||
// the host refused this particular channel.
|
||||
func channelOpenFailure(conn *pooledConn, err error) *failure {
|
||||
if isConnDead(conn) {
|
||||
return &failure{Kind: "network", Message: "connection lost: " + err.Error()}
|
||||
}
|
||||
return &failure{Kind: "channel", Message: err.Error()}
|
||||
}
|
||||
|
||||
func lostFailure(conn *pooledConn, err error) *failure {
|
||||
message := "connection lost"
|
||||
if err != nil && !errors.Is(err, io.EOF) {
|
||||
message += ": " + err.Error()
|
||||
}
|
||||
if !isConnDead(conn) {
|
||||
// The connection is fine; only this channel ended abruptly.
|
||||
return &failure{Kind: "channel", Message: "channel closed unexpectedly"}
|
||||
}
|
||||
return &failure{Kind: "network", Message: message}
|
||||
}
|
||||
|
||||
func isConnDead(conn *pooledConn) bool {
|
||||
// client.Wait's goroutine marks the connection dead slightly after the
|
||||
// channels see their streams end; give it a moment to catch up.
|
||||
deadline := time.Now().Add(200 * time.Millisecond)
|
||||
for {
|
||||
poolMu.Lock()
|
||||
dead := conn.dead
|
||||
poolMu.Unlock()
|
||||
if dead || time.Now().After(deadline) {
|
||||
return dead
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,304 @@
|
||||
// Package faceclawssh is Faceclaw's SSH transport, bound into the Android and
|
||||
// iOS apps with gomobile. It exposes text-message channels over SSH:
|
||||
//
|
||||
// - "exec": run a command on the host and exchange newline-delimited text
|
||||
// with it (stdin lines in, stdout lines out). Used for tmux control mode
|
||||
// and the tmux session poller.
|
||||
// - "websocket": open a direct-tcpip channel to an address as seen from the
|
||||
// host (normally g2mirror-server on 127.0.0.1:8737) and speak WebSocket
|
||||
// text frames over it.
|
||||
//
|
||||
// Channels to the same host, user and credentials share one SSH connection
|
||||
// (see pool.go). Host keys are pinned by the caller: a connection whose host
|
||||
// presents a key that isn't in the spec's hostKeys fails with a
|
||||
// "hostkey-unknown" or "hostkey-mismatch" failure carrying the presented key,
|
||||
// so the app can show the fingerprint and retry once the user has trusted it.
|
||||
// Authentication uses a platform-held, non-exportable ECDSA P-256 key (the
|
||||
// Signer interface; Android Keystore / iOS Secure Enclave) and, if the server
|
||||
// allows it, a password.
|
||||
//
|
||||
// Everything crossing the gomobile boundary is a string, []byte or one of the
|
||||
// interfaces below; structured values are JSON strings.
|
||||
package faceclawssh
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"runtime/debug"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Signer is implemented by the platform: an ECDSA P-256 key whose private
|
||||
// half never leaves the device's keystore.
|
||||
type Signer interface {
|
||||
// PublicKey returns the key's public half, either as X.509
|
||||
// SubjectPublicKeyInfo DER (Android's PublicKey.getEncoded()) or as an
|
||||
// uncompressed X9.62 point, 0x04 || X || Y (iOS's
|
||||
// SecKeyCopyExternalRepresentation).
|
||||
PublicKey() []byte
|
||||
// Sign returns the ASN.1 DER ECDSA signature of SHA-256(data).
|
||||
Sign(data []byte) ([]byte, error)
|
||||
}
|
||||
|
||||
// Listener receives a channel's events. Calls arrive on arbitrary goroutines
|
||||
// (never concurrently for one channel); the platform wrapper hops them onto
|
||||
// the thread that owns the channel.
|
||||
//
|
||||
// Event kinds and payloads:
|
||||
// - "open": the channel is ready; payload empty. Sends made before this are
|
||||
// queued and delivered once open.
|
||||
// - "text": one message (websocket text frame, or one stdout line without
|
||||
// its newline). Exec lines that aren't valid UTF-8 have every byte >= 0x80
|
||||
// escaped as a backslash and three octal digits, matching tmux control
|
||||
// mode's escaping of control characters (see escapeLine).
|
||||
// - "stderr": one stderr line of an exec channel, escaped the same way.
|
||||
// - "closed": the channel ended normally; payload is JSON
|
||||
// {"exitStatus": n, "signal": "...", "code": n, "reason": "..."} with the
|
||||
// fields that apply (exec exit status/signal, websocket close code/reason).
|
||||
// Terminal: no events follow.
|
||||
// - "failure": the channel could not be opened or was lost; payload is a
|
||||
// JSON Failure. Terminal: no events follow.
|
||||
type Listener interface {
|
||||
OnEvent(kind string, payload string)
|
||||
}
|
||||
|
||||
// Failure describes why a channel failed, as the JSON payload of a "failure"
|
||||
// event.
|
||||
type failure struct {
|
||||
// "hostkey-unknown": no host key is pinned yet; HostKey is what the host
|
||||
// presented. "hostkey-mismatch": the host presented a key that isn't
|
||||
// pinned. "auth": the host refused every credential we have.
|
||||
// "network": couldn't reach the host, or the connection dropped.
|
||||
// "channel": the SSH connection is fine but the channel couldn't be
|
||||
// opened (exec refused, nothing listening at the forwarded address...).
|
||||
// "config": the spec was malformed. "internal": a bug.
|
||||
Kind string `json:"kind"`
|
||||
Message string `json:"message"`
|
||||
HostKey *hostKeyInfo `json:"hostKey,omitempty"`
|
||||
// For "auth": the host accepts password (or keyboard-interactive)
|
||||
// authentication, whether a password was sent, and whether our key was
|
||||
// offered.
|
||||
PasswordAllowed bool `json:"passwordAllowed,omitempty"`
|
||||
PasswordTried bool `json:"passwordTried,omitempty"`
|
||||
KeyTried bool `json:"keyTried,omitempty"`
|
||||
}
|
||||
|
||||
func (f *failure) Error() string { return f.Message }
|
||||
|
||||
type hostKeyInfo struct {
|
||||
// SSH key type, e.g. "ssh-ed25519".
|
||||
Type string `json:"type"`
|
||||
// OpenSSH-style SHA-256 fingerprint, "SHA256:<base64>".
|
||||
Fingerprint string `json:"fingerprint"`
|
||||
// The key in SSH wire format, base64: what goes in a spec's hostKeys.
|
||||
Key string `json:"key"`
|
||||
}
|
||||
|
||||
type channelSpec struct {
|
||||
// "exec" or "websocket".
|
||||
Type string `json:"type"`
|
||||
// exec: the command line, run by the user's login shell.
|
||||
Command string `json:"command"`
|
||||
// websocket: ws:// URL, resolved on the host's side of the connection.
|
||||
URL string `json:"url"`
|
||||
}
|
||||
|
||||
type openSpec struct {
|
||||
Host string `json:"host"`
|
||||
Port int `json:"port"`
|
||||
User string `json:"user"`
|
||||
Password string `json:"password"`
|
||||
// Pinned host keys, SSH wire format, base64. Empty: the first connection
|
||||
// fails with "hostkey-unknown".
|
||||
HostKeys []string `json:"hostKeys"`
|
||||
// Offer the platform key (the Signer passed to Open).
|
||||
UseKey bool `json:"useKey"`
|
||||
ConnectTimeoutMs int `json:"connectTimeoutMs"`
|
||||
KeepaliveIntervalMs int `json:"keepaliveIntervalMs"`
|
||||
Channel channelSpec `json:"channel"`
|
||||
}
|
||||
|
||||
const (
|
||||
defaultConnectTimeout = 15 * time.Second
|
||||
defaultKeepaliveInterval = 20 * time.Second
|
||||
// Messages queued on a channel before Send starts refusing them.
|
||||
sendQueueCapacity = 4096
|
||||
// How long Close waits for queued messages to flush and the far end to
|
||||
// finish before tearing the channel down.
|
||||
closeGracePeriod = 2 * time.Second
|
||||
)
|
||||
|
||||
// Channel is one open (or opening) channel. Methods are safe to call from
|
||||
// any thread.
|
||||
type Channel struct {
|
||||
listener Listener
|
||||
ctx context.Context
|
||||
cancel context.CancelFunc
|
||||
|
||||
mu sync.Mutex
|
||||
closed bool // Close was called: no more sends, no more events
|
||||
opened bool
|
||||
sendQ chan string
|
||||
|
||||
finishOnce sync.Once
|
||||
}
|
||||
|
||||
// Open starts opening a channel described by spec (a JSON openSpec) and
|
||||
// returns immediately; progress arrives as listener events. signer may be
|
||||
// nil (no key authentication).
|
||||
func Open(spec string, signer Signer, listener Listener) *Channel {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
c := &Channel{
|
||||
listener: listener,
|
||||
ctx: ctx,
|
||||
cancel: cancel,
|
||||
sendQ: make(chan string, sendQueueCapacity),
|
||||
}
|
||||
go c.run(spec, signer)
|
||||
return c
|
||||
}
|
||||
|
||||
// Send queues one message: a websocket text frame, or a line for an exec
|
||||
// channel's stdin (the newline is added). Returns false if the channel is
|
||||
// closed or its queue is full.
|
||||
func (c *Channel) Send(text string) bool {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
if c.closed {
|
||||
return false
|
||||
}
|
||||
select {
|
||||
case c.sendQ <- text:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Close ends the channel. Messages already queued are still sent (so a
|
||||
// parting "unview" reaches the host), then the channel's write side is
|
||||
// closed and, after a short grace period, the channel is torn down. No
|
||||
// events are delivered after Close.
|
||||
func (c *Channel) Close() {
|
||||
c.mu.Lock()
|
||||
if c.closed {
|
||||
c.mu.Unlock()
|
||||
return
|
||||
}
|
||||
c.closed = true
|
||||
opened := c.opened
|
||||
close(c.sendQ)
|
||||
c.mu.Unlock()
|
||||
if !opened {
|
||||
c.cancel()
|
||||
return
|
||||
}
|
||||
time.AfterFunc(closeGracePeriod, c.cancel)
|
||||
}
|
||||
|
||||
func (c *Channel) isClosed() bool {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
return c.closed
|
||||
}
|
||||
|
||||
func (c *Channel) emit(kind, payload string) {
|
||||
if c.isClosed() {
|
||||
return
|
||||
}
|
||||
c.listener.OnEvent(kind, payload)
|
||||
}
|
||||
|
||||
func (c *Channel) markOpen() {
|
||||
c.mu.Lock()
|
||||
c.opened = true
|
||||
c.mu.Unlock()
|
||||
c.emit("open", "")
|
||||
}
|
||||
|
||||
// finish delivers the channel's one terminal event ("closed" or "failure").
|
||||
func (c *Channel) finish(kind string, payload any) {
|
||||
c.finishOnce.Do(func() {
|
||||
encoded, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
encoded = []byte(`{"kind":"internal","message":"unencodable event"}`)
|
||||
}
|
||||
c.emit(kind, string(encoded))
|
||||
c.cancel()
|
||||
})
|
||||
}
|
||||
|
||||
func (c *Channel) fail(f *failure) { c.finish("failure", f) }
|
||||
|
||||
// guard turns a panic in one of our goroutines into a failure event instead
|
||||
// of crashing the app (an unrecovered Go panic kills the whole process).
|
||||
func (c *Channel) guard() {
|
||||
if r := recover(); r != nil {
|
||||
c.fail(&failure{Kind: "internal", Message: fmt.Sprintf("internal error: %v\n%s", r, debug.Stack())})
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Channel) run(specJSON string, signer Signer) {
|
||||
defer c.guard()
|
||||
var spec openSpec
|
||||
if err := json.Unmarshal([]byte(specJSON), &spec); err != nil {
|
||||
c.fail(&failure{Kind: "config", Message: "bad channel spec: " + err.Error()})
|
||||
return
|
||||
}
|
||||
if spec.Host == "" || spec.User == "" {
|
||||
c.fail(&failure{Kind: "config", Message: "host and user are required"})
|
||||
return
|
||||
}
|
||||
if spec.Port == 0 {
|
||||
spec.Port = 22
|
||||
}
|
||||
if !spec.UseKey {
|
||||
signer = nil
|
||||
}
|
||||
conn, err := acquire(c.ctx, &spec, signer)
|
||||
if err != nil {
|
||||
if c.ctx.Err() != nil {
|
||||
return
|
||||
}
|
||||
c.fail(asFailure(err))
|
||||
return
|
||||
}
|
||||
defer conn.release()
|
||||
switch spec.Channel.Type {
|
||||
case "exec":
|
||||
c.runExec(conn, spec.Channel.Command)
|
||||
case "websocket":
|
||||
c.runWebSocket(conn, spec.Channel.URL)
|
||||
default:
|
||||
c.fail(&failure{Kind: "config", Message: fmt.Sprintf("unknown channel type %q", spec.Channel.Type)})
|
||||
}
|
||||
}
|
||||
|
||||
func asFailure(err error) *failure {
|
||||
if f, ok := err.(*failure); ok {
|
||||
return f
|
||||
}
|
||||
return &failure{Kind: "network", Message: err.Error()}
|
||||
}
|
||||
|
||||
// AuthorizedKey formats a platform public key (see Signer.PublicKey) as an
|
||||
// authorized_keys line: "ecdsa-sha2-nistp256 AAAA... comment".
|
||||
func AuthorizedKey(publicKey []byte, comment string) (string, error) {
|
||||
key, err := sshPublicKey(publicKey)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return authorizedKeyLine(key, comment), nil
|
||||
}
|
||||
|
||||
// Fingerprint returns the OpenSSH SHA-256 fingerprint ("SHA256:...") of a
|
||||
// platform public key.
|
||||
func Fingerprint(publicKey []byte) (string, error) {
|
||||
key, err := sshPublicKey(publicKey)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return fingerprint(key), nil
|
||||
}
|
||||
@@ -0,0 +1,526 @@
|
||||
package faceclawssh
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/ecdsa"
|
||||
"crypto/ed25519"
|
||||
"crypto/elliptic"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"crypto/x509"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
"golang.org/x/crypto/ssh"
|
||||
)
|
||||
|
||||
// ---- test SSH server ----
|
||||
|
||||
type testServer struct {
|
||||
addr string
|
||||
hostKey ssh.Signer
|
||||
accepts atomic.Int32
|
||||
listener net.Listener
|
||||
}
|
||||
|
||||
type serverOptions struct {
|
||||
password string // "" = password auth disabled
|
||||
keyboardInteractive bool // offer the password via keyboard-interactive instead
|
||||
authorizedKey ssh.PublicKey
|
||||
}
|
||||
|
||||
func newTestServer(t *testing.T, opts serverOptions) *testServer {
|
||||
t.Helper()
|
||||
_, priv, _ := ed25519.GenerateKey(rand.Reader)
|
||||
hostKey, err := ssh.NewSignerFromKey(priv)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
config := &ssh.ServerConfig{}
|
||||
if opts.password != "" && !opts.keyboardInteractive {
|
||||
config.PasswordCallback = func(_ ssh.ConnMetadata, password []byte) (*ssh.Permissions, error) {
|
||||
if string(password) == opts.password {
|
||||
return nil, nil
|
||||
}
|
||||
return nil, fmt.Errorf("wrong password")
|
||||
}
|
||||
}
|
||||
if opts.password != "" && opts.keyboardInteractive {
|
||||
config.KeyboardInteractiveCallback = func(_ ssh.ConnMetadata, challenge ssh.KeyboardInteractiveChallenge) (*ssh.Permissions, error) {
|
||||
answers, err := challenge("", "", []string{"Password: "}, []bool{false})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(answers) == 1 && answers[0] == opts.password {
|
||||
return nil, nil
|
||||
}
|
||||
return nil, fmt.Errorf("wrong password")
|
||||
}
|
||||
}
|
||||
if opts.authorizedKey != nil {
|
||||
config.PublicKeyCallback = func(_ ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
|
||||
if string(key.Marshal()) == string(opts.authorizedKey.Marshal()) {
|
||||
return nil, nil
|
||||
}
|
||||
return nil, fmt.Errorf("unknown key")
|
||||
}
|
||||
}
|
||||
config.AddHostKey(hostKey)
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
server := &testServer{addr: listener.Addr().String(), hostKey: hostKey, listener: listener}
|
||||
t.Cleanup(func() { listener.Close() })
|
||||
go func() {
|
||||
for {
|
||||
tcp, err := listener.Accept()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
server.accepts.Add(1)
|
||||
go server.serve(tcp, config)
|
||||
}
|
||||
}()
|
||||
return server
|
||||
}
|
||||
|
||||
func (s *testServer) serve(tcp net.Conn, config *ssh.ServerConfig) {
|
||||
conn, chans, reqs, err := ssh.NewServerConn(tcp, config)
|
||||
if err != nil {
|
||||
tcp.Close()
|
||||
return
|
||||
}
|
||||
defer conn.Close()
|
||||
go ssh.DiscardRequests(reqs) // replies false to keepalives, which still counts as alive
|
||||
for newChannel := range chans {
|
||||
switch newChannel.ChannelType() {
|
||||
case "session":
|
||||
go serveSession(newChannel)
|
||||
case "direct-tcpip":
|
||||
go serveDirectTCPIP(newChannel)
|
||||
default:
|
||||
newChannel.Reject(ssh.UnknownChannelType, "nope")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// serveSession implements a few fake commands:
|
||||
// - "echo": echo stdin lines back with a "> " prefix until EOF, exit 0
|
||||
// - "bytes": print an invalid-UTF-8 line and a stderr line, exit 3
|
||||
func serveSession(newChannel ssh.NewChannel) {
|
||||
channel, requests, err := newChannel.Accept()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer channel.Close()
|
||||
for req := range requests {
|
||||
if req.Type != "exec" {
|
||||
req.Reply(false, nil)
|
||||
continue
|
||||
}
|
||||
var payload struct{ Command string }
|
||||
ssh.Unmarshal(req.Payload, &payload)
|
||||
req.Reply(true, nil)
|
||||
status := 0
|
||||
switch payload.Command {
|
||||
case "echo":
|
||||
scanner := bufio.NewScanner(channel)
|
||||
for scanner.Scan() {
|
||||
fmt.Fprintf(channel, "> %s\n", scanner.Text())
|
||||
}
|
||||
case "bytes":
|
||||
channel.Write([]byte("%output %1 caf\xc3\n%output %1 \xa9 ok\nplain ✓\n"))
|
||||
channel.Stderr().Write([]byte("oops\n"))
|
||||
status = 3
|
||||
default:
|
||||
channel.Stderr().Write([]byte("unknown command\n"))
|
||||
status = 127
|
||||
}
|
||||
channel.SendRequest("exit-status", false, ssh.Marshal(struct{ Status uint32 }{uint32(status)}))
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func serveDirectTCPIP(newChannel ssh.NewChannel) {
|
||||
var target struct {
|
||||
Host string
|
||||
Port uint32
|
||||
OriginHost string
|
||||
OriginPort uint32
|
||||
}
|
||||
if err := ssh.Unmarshal(newChannel.ExtraData(), &target); err != nil {
|
||||
newChannel.Reject(ssh.ConnectionFailed, "bad payload")
|
||||
return
|
||||
}
|
||||
upstream, err := net.Dial("tcp", net.JoinHostPort(target.Host, fmt.Sprint(target.Port)))
|
||||
if err != nil {
|
||||
newChannel.Reject(ssh.ConnectionFailed, err.Error())
|
||||
return
|
||||
}
|
||||
channel, requests, err := newChannel.Accept()
|
||||
if err != nil {
|
||||
upstream.Close()
|
||||
return
|
||||
}
|
||||
go ssh.DiscardRequests(requests)
|
||||
go func() { io.Copy(upstream, channel); upstream.Close() }()
|
||||
io.Copy(channel, upstream)
|
||||
channel.Close()
|
||||
}
|
||||
|
||||
// ---- test client plumbing ----
|
||||
|
||||
type event struct{ kind, payload string }
|
||||
|
||||
type recorder struct {
|
||||
events chan event
|
||||
}
|
||||
|
||||
func newRecorder() *recorder { return &recorder{events: make(chan event, 256)} }
|
||||
|
||||
func (r *recorder) OnEvent(kind, payload string) { r.events <- event{kind, payload} }
|
||||
|
||||
func (r *recorder) next(t *testing.T) event {
|
||||
t.Helper()
|
||||
select {
|
||||
case e := <-r.events:
|
||||
return e
|
||||
case <-time.After(10 * time.Second):
|
||||
t.Fatal("timed out waiting for event")
|
||||
return event{}
|
||||
}
|
||||
}
|
||||
|
||||
func (r *recorder) expect(t *testing.T, kind string) event {
|
||||
t.Helper()
|
||||
e := r.next(t)
|
||||
if e.kind != kind {
|
||||
t.Fatalf("got event %s(%s), want %s", e.kind, e.payload, kind)
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
func (r *recorder) expectFailure(t *testing.T) failure {
|
||||
t.Helper()
|
||||
e := r.expect(t, "failure")
|
||||
var f failure
|
||||
if err := json.Unmarshal([]byte(e.payload), &f); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
type softwareSigner struct{ key *ecdsa.PrivateKey }
|
||||
|
||||
func newSoftwareSigner(t *testing.T) *softwareSigner {
|
||||
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &softwareSigner{key: key}
|
||||
}
|
||||
|
||||
func (s *softwareSigner) PublicKey() []byte {
|
||||
der, _ := x509.MarshalPKIXPublicKey(&s.key.PublicKey)
|
||||
return der
|
||||
}
|
||||
|
||||
func (s *softwareSigner) Sign(data []byte) ([]byte, error) {
|
||||
digest := sha256.Sum256(data)
|
||||
return ecdsa.SignASN1(rand.Reader, s.key, digest[:])
|
||||
}
|
||||
|
||||
func (s *softwareSigner) sshKey(t *testing.T) ssh.PublicKey {
|
||||
key, err := ssh.NewPublicKey(&s.key.PublicKey)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return key
|
||||
}
|
||||
|
||||
func specFor(server *testServer, mutate func(*openSpec)) string {
|
||||
host, port, _ := net.SplitHostPort(server.addr)
|
||||
var portNumber int
|
||||
fmt.Sscan(port, &portNumber)
|
||||
spec := openSpec{
|
||||
Host: host,
|
||||
Port: portNumber,
|
||||
User: "jim",
|
||||
HostKeys: []string{base64.StdEncoding.EncodeToString(server.hostKey.PublicKey().Marshal())},
|
||||
Channel: channelSpec{Type: "exec", Command: "echo"},
|
||||
}
|
||||
if mutate != nil {
|
||||
mutate(&spec)
|
||||
}
|
||||
encoded, _ := json.Marshal(spec)
|
||||
return string(encoded)
|
||||
}
|
||||
|
||||
func resetPool() {
|
||||
poolMu.Lock()
|
||||
defer poolMu.Unlock()
|
||||
for key, conn := range pool {
|
||||
conn.client.Close()
|
||||
delete(pool, key)
|
||||
}
|
||||
}
|
||||
|
||||
// ---- tests ----
|
||||
|
||||
func TestHostKeyPinning(t *testing.T) {
|
||||
defer resetPool()
|
||||
server := newTestServer(t, serverOptions{password: "pw"})
|
||||
wantKey := base64.StdEncoding.EncodeToString(server.hostKey.PublicKey().Marshal())
|
||||
|
||||
rec := newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) { s.HostKeys = nil; s.Password = "pw" }), nil, rec)
|
||||
f := rec.expectFailure(t)
|
||||
if f.Kind != "hostkey-unknown" || f.HostKey == nil || f.HostKey.Key != wantKey ||
|
||||
f.HostKey.Type != ssh.KeyAlgoED25519 || !strings.HasPrefix(f.HostKey.Fingerprint, "SHA256:") {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
|
||||
_, otherPriv, _ := ed25519.GenerateKey(rand.Reader)
|
||||
other, _ := ssh.NewSignerFromKey(otherPriv)
|
||||
rec = newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) {
|
||||
s.HostKeys = []string{base64.StdEncoding.EncodeToString(other.PublicKey().Marshal())}
|
||||
s.Password = "pw"
|
||||
}), nil, rec)
|
||||
f = rec.expectFailure(t)
|
||||
if f.Kind != "hostkey-mismatch" || f.HostKey.Key != wantKey {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
|
||||
rec = newRecorder()
|
||||
ch := Open(specFor(server, func(s *openSpec) { s.Password = "pw" }), nil, rec)
|
||||
rec.expect(t, "open")
|
||||
ch.Close()
|
||||
}
|
||||
|
||||
func TestPasswordAuth(t *testing.T) {
|
||||
for _, interactive := range []bool{false, true} {
|
||||
t.Run(fmt.Sprintf("keyboardInteractive=%v", interactive), func(t *testing.T) {
|
||||
defer resetPool()
|
||||
server := newTestServer(t, serverOptions{password: "secret", keyboardInteractive: interactive})
|
||||
|
||||
rec := newRecorder()
|
||||
Open(specFor(server, nil), nil, rec)
|
||||
f := rec.expectFailure(t)
|
||||
if f.Kind != "auth" || !f.PasswordAllowed || f.PasswordTried {
|
||||
t.Fatalf("no password: %+v", f)
|
||||
}
|
||||
|
||||
rec = newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) { s.Password = "wrong" }), nil, rec)
|
||||
f = rec.expectFailure(t)
|
||||
if f.Kind != "auth" || !f.PasswordTried {
|
||||
t.Fatalf("wrong password: %+v", f)
|
||||
}
|
||||
|
||||
rec = newRecorder()
|
||||
ch := Open(specFor(server, func(s *openSpec) { s.Password = "secret" }), nil, rec)
|
||||
rec.expect(t, "open")
|
||||
ch.Send("hi")
|
||||
if e := rec.expect(t, "text"); e.payload != "> hi" {
|
||||
t.Fatalf("got %q", e.payload)
|
||||
}
|
||||
ch.Close()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestKeyAuth(t *testing.T) {
|
||||
defer resetPool()
|
||||
signer := newSoftwareSigner(t)
|
||||
server := newTestServer(t, serverOptions{authorizedKey: signer.sshKey(t)})
|
||||
|
||||
rec := newRecorder()
|
||||
ch := Open(specFor(server, func(s *openSpec) { s.UseKey = true }), signer, rec)
|
||||
rec.expect(t, "open")
|
||||
ch.Close()
|
||||
|
||||
// A key the server doesn't know, and no password support.
|
||||
resetPool()
|
||||
rec = newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) { s.UseKey = true }), newSoftwareSigner(t), rec)
|
||||
f := rec.expectFailure(t)
|
||||
if f.Kind != "auth" || !f.KeyTried || f.PasswordAllowed {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
|
||||
line, err := AuthorizedKey(signer.PublicKey(), "Faceclaw on my phone")
|
||||
if err != nil || !strings.HasPrefix(line, "ecdsa-sha2-nistp256 AAAA") || !strings.HasSuffix(line, " Faceclaw-on-my-phone") {
|
||||
t.Fatalf("AuthorizedKey = %q, %v", line, err)
|
||||
}
|
||||
parsed, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))
|
||||
if err != nil || string(parsed.Marshal()) != string(signer.sshKey(t).Marshal()) {
|
||||
t.Fatalf("authorized key does not round-trip: %v", err)
|
||||
}
|
||||
// The uncompressed-point form iOS hands us parses to the same key.
|
||||
point := elliptic.Marshal(elliptic.P256(), signer.key.X, signer.key.Y) //nolint:staticcheck
|
||||
fromPoint, err := Fingerprint(point)
|
||||
fromDER, _ := Fingerprint(signer.PublicKey())
|
||||
if err != nil || fromPoint != fromDER {
|
||||
t.Fatalf("fingerprints differ: %s vs %s (%v)", fromPoint, fromDER, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecFraming(t *testing.T) {
|
||||
defer resetPool()
|
||||
server := newTestServer(t, serverOptions{password: "pw"})
|
||||
rec := newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) { s.Password = "pw"; s.Channel.Command = "bytes" }), nil, rec)
|
||||
rec.expect(t, "open")
|
||||
var texts, stderr []string
|
||||
var closed closedPayload
|
||||
for done := false; !done; {
|
||||
e := rec.next(t)
|
||||
switch e.kind {
|
||||
case "text":
|
||||
texts = append(texts, e.payload)
|
||||
case "stderr":
|
||||
stderr = append(stderr, e.payload)
|
||||
case "closed":
|
||||
json.Unmarshal([]byte(e.payload), &closed)
|
||||
done = true
|
||||
default:
|
||||
t.Fatalf("unexpected %s(%s)", e.kind, e.payload)
|
||||
}
|
||||
}
|
||||
want := []string{`%output %1 caf\303`, `%output %1 \251 ok`, "plain ✓"}
|
||||
if strings.Join(texts, "|") != strings.Join(want, "|") {
|
||||
t.Fatalf("texts = %q, want %q", texts, want)
|
||||
}
|
||||
if len(stderr) != 1 || stderr[0] != "oops" {
|
||||
t.Fatalf("stderr = %q", stderr)
|
||||
}
|
||||
if closed.ExitStatus == nil || *closed.ExitStatus != 3 {
|
||||
t.Fatalf("closed = %+v", closed)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWebSocketTunnelAndSharing(t *testing.T) {
|
||||
defer resetPool()
|
||||
upgrader := websocket.Upgrader{}
|
||||
var serverConns sync.WaitGroup
|
||||
wsServer := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
conn, err := upgrader.Upgrade(w, r, nil)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
serverConns.Add(1)
|
||||
defer serverConns.Done()
|
||||
defer conn.Close()
|
||||
for {
|
||||
kind, data, err := conn.ReadMessage()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if string(data) == "quit" {
|
||||
conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(4000, "asked to quit"))
|
||||
return
|
||||
}
|
||||
conn.WriteMessage(kind, append([]byte("echo:"), data...))
|
||||
}
|
||||
})}
|
||||
wsListener, _ := net.Listen("tcp", "127.0.0.1:0")
|
||||
go wsServer.Serve(wsListener)
|
||||
defer wsServer.Close()
|
||||
|
||||
server := newTestServer(t, serverOptions{password: "pw"})
|
||||
wsSpec := specFor(server, func(s *openSpec) {
|
||||
s.Password = "pw"
|
||||
s.Channel = channelSpec{Type: "websocket", URL: "ws://" + wsListener.Addr().String() + "/"}
|
||||
})
|
||||
recA, recB := newRecorder(), newRecorder()
|
||||
a := Open(wsSpec, nil, recA)
|
||||
b := Open(wsSpec, nil, recB)
|
||||
// Sent before open: queued until the channel is up.
|
||||
a.Send(`{"type":"init"}`)
|
||||
recA.expect(t, "open")
|
||||
recB.expect(t, "open")
|
||||
if e := recA.expect(t, "text"); e.payload != `echo:{"type":"init"}` {
|
||||
t.Fatalf("got %q", e.payload)
|
||||
}
|
||||
b.Send("quit")
|
||||
e := recB.expect(t, "closed")
|
||||
var closed closedPayload
|
||||
json.Unmarshal([]byte(e.payload), &closed)
|
||||
if closed.Code == nil || *closed.Code != 4000 || closed.Reason != "asked to quit" {
|
||||
t.Fatalf("closed = %+v", closed)
|
||||
}
|
||||
if n := server.accepts.Load(); n != 1 {
|
||||
t.Fatalf("expected both channels on one SSH connection, got %d connections", n)
|
||||
}
|
||||
|
||||
// Close flushes queued messages before tearing down.
|
||||
a.Send("last words")
|
||||
a.Close()
|
||||
time.Sleep(300 * time.Millisecond)
|
||||
select {
|
||||
case e := <-recA.events:
|
||||
t.Fatalf("event after Close: %s(%s)", e.kind, e.payload)
|
||||
default:
|
||||
}
|
||||
|
||||
// Nothing listening at the forwarded address: a channel failure, not a
|
||||
// network one (the SSH connection is fine).
|
||||
recC := newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) {
|
||||
s.Password = "pw"
|
||||
s.Channel = channelSpec{Type: "websocket", URL: "ws://127.0.0.1:1/"}
|
||||
}), nil, recC)
|
||||
if f := recC.expectFailure(t); f.Kind != "channel" {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
}
|
||||
|
||||
func TestConnectionLoss(t *testing.T) {
|
||||
defer resetPool()
|
||||
server := newTestServer(t, serverOptions{password: "pw"})
|
||||
rec := newRecorder()
|
||||
Open(specFor(server, func(s *openSpec) { s.Password = "pw" }), nil, rec)
|
||||
rec.expect(t, "open")
|
||||
// Kill the SSH connection under the channel.
|
||||
poolMu.Lock()
|
||||
for _, conn := range pool {
|
||||
conn.client.Close()
|
||||
}
|
||||
poolMu.Unlock()
|
||||
if f := rec.expectFailure(t); f.Kind != "network" {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
// The next channel dials a fresh connection.
|
||||
rec = newRecorder()
|
||||
ch := Open(specFor(server, func(s *openSpec) { s.Password = "pw" }), nil, rec)
|
||||
rec.expect(t, "open")
|
||||
ch.Close()
|
||||
if n := server.accepts.Load(); n != 2 {
|
||||
t.Fatalf("expected a second connection, got %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkFailure(t *testing.T) {
|
||||
rec := newRecorder()
|
||||
Open(`{"host":"127.0.0.1","port":1,"user":"jim","channel":{"type":"exec","command":"x"}}`, nil, rec)
|
||||
if f := rec.expectFailure(t); f.Kind != "network" {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
rec = newRecorder()
|
||||
Open(`not json`, nil, rec)
|
||||
if f := rec.expectFailure(t); f.Kind != "config" {
|
||||
t.Fatalf("unexpected failure %+v", f)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
module github.com/jimrandomh/faceclaw/native/ssh
|
||||
|
||||
go 1.26.0
|
||||
|
||||
require (
|
||||
github.com/gorilla/websocket v1.5.3
|
||||
golang.org/x/crypto v0.59.0
|
||||
)
|
||||
|
||||
require (
|
||||
golang.org/x/mobile v0.0.0-20261011034528-197770444867 // indirect
|
||||
golang.org/x/mod v0.42.0 // indirect
|
||||
golang.org/x/sync v0.24.0 // indirect
|
||||
golang.org/x/sys v0.50.0 // indirect
|
||||
golang.org/x/tools v0.52.0 // indirect
|
||||
)
|
||||
|
||||
tool (
|
||||
golang.org/x/mobile/cmd/gobind
|
||||
golang.org/x/mobile/cmd/gomobile
|
||||
)
|
||||
@@ -0,0 +1,16 @@
|
||||
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
|
||||
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
|
||||
golang.org/x/crypto v0.59.0 h1:xS2jhqYbzNrpvkWP2YTDf4TJwBy3ykR03i8vFDxEc7c=
|
||||
golang.org/x/crypto v0.59.0/go.mod h1:veDyUwATGs3c+vN3VfTbzViMGXeTBk3WyhBOkn+F/4U=
|
||||
golang.org/x/mobile v0.0.0-20261011034528-197770444867 h1:rav73cdd7OQUPgt1aIFbZQTiPNnjfueKXvfOiLCY0Ss=
|
||||
golang.org/x/mobile v0.0.0-20261011034528-197770444867/go.mod h1:HR/iBzuQmVTl/us733QPwrqHp43a8m9ZLgyKXD3ST6U=
|
||||
golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg=
|
||||
golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs=
|
||||
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
|
||||
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||
golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs=
|
||||
golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
golang.org/x/term v0.48.0 h1:G6UU1eiSB8nl3DzeUGt7Mg+2SctI8tPS6Z5/mBt6cOk=
|
||||
golang.org/x/term v0.48.0/go.mod h1:BRDLHCZr2SUjIeBHHpRyQeC9xzSAVbzY2rvKgafnHf4=
|
||||
golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs=
|
||||
golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs=
|
||||
@@ -0,0 +1,58 @@
|
||||
package faceclawssh
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net"
|
||||
"os"
|
||||
"strconv"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestOpenSSHInterop checks the parts of the handshake that need no
|
||||
// credentials against a real sshd: key exchange, host key reporting and
|
||||
// pinning, and how an authentication refusal is classified. Opt-in:
|
||||
//
|
||||
// FACECLAW_SSH_INTEROP_ADDR=127.0.0.1:22 go test -run Interop -v
|
||||
//
|
||||
// Compare the logged fingerprint with `ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub`.
|
||||
// It makes one failed login attempt (no password, an unknown key) as
|
||||
// FACECLAW_SSH_INTEROP_USER (default: $USER).
|
||||
func TestOpenSSHInterop(t *testing.T) {
|
||||
addr := os.Getenv("FACECLAW_SSH_INTEROP_ADDR")
|
||||
if addr == "" {
|
||||
t.Skip("FACECLAW_SSH_INTEROP_ADDR not set")
|
||||
}
|
||||
defer resetPool()
|
||||
user := os.Getenv("FACECLAW_SSH_INTEROP_USER")
|
||||
if user == "" {
|
||||
user = os.Getenv("USER")
|
||||
}
|
||||
host, portText, err := net.SplitHostPort(addr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
port, _ := strconv.Atoi(portText)
|
||||
spec := func(hostKeys []string) string {
|
||||
encoded, _ := json.Marshal(openSpec{
|
||||
Host: host, Port: port, User: user, HostKeys: hostKeys, UseKey: true,
|
||||
Channel: channelSpec{Type: "exec", Command: "true"},
|
||||
})
|
||||
return string(encoded)
|
||||
}
|
||||
|
||||
rec := newRecorder()
|
||||
Open(spec(nil), newSoftwareSigner(t), rec)
|
||||
f := rec.expectFailure(t)
|
||||
if f.Kind != "hostkey-unknown" || f.HostKey == nil {
|
||||
t.Fatalf("first contact: %+v", f)
|
||||
}
|
||||
t.Logf("host key: %s %s", f.HostKey.Type, f.HostKey.Fingerprint)
|
||||
|
||||
rec = newRecorder()
|
||||
Open(spec([]string{f.HostKey.Key}), newSoftwareSigner(t), rec)
|
||||
auth := rec.expectFailure(t)
|
||||
if auth.Kind != "auth" || !auth.KeyTried {
|
||||
t.Fatalf("pinned, unknown key: %+v", auth)
|
||||
}
|
||||
t.Logf("auth refusal: %+v", auth)
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
package faceclawssh
|
||||
|
||||
import (
|
||||
"crypto/ecdsa"
|
||||
"crypto/elliptic"
|
||||
"crypto/sha256"
|
||||
"crypto/x509"
|
||||
"encoding/asn1"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"math/big"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/crypto/ssh"
|
||||
)
|
||||
|
||||
// platformSigner adapts the platform's keystore-backed Signer to ssh.Signer.
|
||||
// The platform signs SHA-256(data) with ECDSA P-256 and returns ASN.1 DER;
|
||||
// SSH wants the signature as two mpints (RFC 5656 §3.1.2).
|
||||
type platformSigner struct {
|
||||
signer Signer
|
||||
pub ssh.PublicKey
|
||||
}
|
||||
|
||||
func newPlatformSigner(signer Signer) (*platformSigner, error) {
|
||||
pub, err := sshPublicKey(signer.PublicKey())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &platformSigner{signer: signer, pub: pub}, nil
|
||||
}
|
||||
|
||||
func (p *platformSigner) PublicKey() ssh.PublicKey { return p.pub }
|
||||
|
||||
func (p *platformSigner) Sign(_ io.Reader, data []byte) (*ssh.Signature, error) {
|
||||
der, err := p.signer.Sign(data)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("platform key signing failed: %w", err)
|
||||
}
|
||||
var sig struct{ R, S *big.Int }
|
||||
rest, err := asn1.Unmarshal(der, &sig)
|
||||
if err != nil || len(rest) != 0 || sig.R == nil || sig.S == nil || sig.R.Sign() <= 0 || sig.S.Sign() <= 0 {
|
||||
return nil, errors.New("platform key returned a malformed signature")
|
||||
}
|
||||
blob := ssh.Marshal(struct{ R, S *big.Int }{sig.R, sig.S})
|
||||
return &ssh.Signature{Format: p.pub.Type(), Blob: blob}, nil
|
||||
}
|
||||
|
||||
// sshPublicKey parses a platform public key (SubjectPublicKeyInfo DER or an
|
||||
// uncompressed P-256 point) into an ecdsa-sha2-nistp256 SSH key.
|
||||
func sshPublicKey(encoded []byte) (ssh.PublicKey, error) {
|
||||
var pub *ecdsa.PublicKey
|
||||
if len(encoded) == 65 && encoded[0] == 4 {
|
||||
parsed, err := ecdsa.ParseUncompressedPublicKey(elliptic.P256(), encoded)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bad P-256 point: %v", err)
|
||||
}
|
||||
pub = parsed
|
||||
} else {
|
||||
parsed, err := x509.ParsePKIXPublicKey(encoded)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bad public key: %v", err)
|
||||
}
|
||||
ecdsaKey, ok := parsed.(*ecdsa.PublicKey)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("unsupported public key type %T", parsed)
|
||||
}
|
||||
pub = ecdsaKey
|
||||
}
|
||||
if pub.Curve != elliptic.P256() {
|
||||
return nil, errors.New("only P-256 keys are supported")
|
||||
}
|
||||
return ssh.NewPublicKey(pub)
|
||||
}
|
||||
|
||||
func authorizedKeyLine(key ssh.PublicKey, comment string) string {
|
||||
line := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(key)))
|
||||
comment = strings.Join(strings.Fields(comment), "-")
|
||||
if comment != "" {
|
||||
line += " " + comment
|
||||
}
|
||||
return line
|
||||
}
|
||||
|
||||
// fingerprint is OpenSSH's SHA256 fingerprint format (unpadded base64).
|
||||
func fingerprint(key ssh.PublicKey) string {
|
||||
sum := sha256.Sum256(key.Marshal())
|
||||
return "SHA256:" + base64.RawStdEncoding.EncodeToString(sum[:])
|
||||
}
|
||||
@@ -0,0 +1,416 @@
|
||||
package faceclawssh
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"net"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"golang.org/x/crypto/ssh"
|
||||
)
|
||||
|
||||
// SSH connections are shared between channels with the same host, port,
|
||||
// user, credentials and pinned keys: the Terminal app's session poller and
|
||||
// each of its view windows ride one TCP connection. A connection with no
|
||||
// channels left lingers briefly (a view window closing and reopening shouldn't
|
||||
// pay a fresh handshake) and is then closed. A keepalive probe closes
|
||||
// connections whose peer has silently gone away, which fails every channel on
|
||||
// them so the app's reconnect logic takes over.
|
||||
|
||||
const idleLinger = 15 * time.Second
|
||||
|
||||
type pooledConn struct {
|
||||
key string
|
||||
client *ssh.Client
|
||||
|
||||
// Guarded by poolMu.
|
||||
refs int
|
||||
dead bool
|
||||
linger *time.Timer
|
||||
}
|
||||
|
||||
type dialCall struct {
|
||||
done chan struct{}
|
||||
err error
|
||||
}
|
||||
|
||||
var (
|
||||
poolMu sync.Mutex
|
||||
pool = map[string]*pooledConn{}
|
||||
dialing = map[string]*dialCall{}
|
||||
)
|
||||
|
||||
func poolKey(spec *openSpec, signer *platformSigner) string {
|
||||
h := sha256.New()
|
||||
fmt.Fprintf(h, "%s\x00%d\x00%s\x00%s\x00", spec.Host, spec.Port, spec.User, spec.Password)
|
||||
for _, key := range spec.HostKeys {
|
||||
fmt.Fprintf(h, "%s\x00", key)
|
||||
}
|
||||
if signer != nil {
|
||||
h.Write(signer.pub.Marshal())
|
||||
}
|
||||
fmt.Fprintf(h, "\x00%d", spec.KeepaliveIntervalMs)
|
||||
return hex.EncodeToString(h.Sum(nil))
|
||||
}
|
||||
|
||||
// acquire returns a live pooled connection for spec, dialing one if needed
|
||||
// (concurrent callers for the same key share a single dial). The caller must
|
||||
// release() it.
|
||||
func acquire(ctx context.Context, spec *openSpec, signer Signer) (*pooledConn, error) {
|
||||
var ps *platformSigner
|
||||
if signer != nil {
|
||||
var err error
|
||||
if ps, err = newPlatformSigner(signer); err != nil {
|
||||
return nil, &failure{Kind: "config", Message: "client key unusable: " + err.Error()}
|
||||
}
|
||||
}
|
||||
key := poolKey(spec, ps)
|
||||
for {
|
||||
poolMu.Lock()
|
||||
if conn := pool[key]; conn != nil && !conn.dead {
|
||||
conn.refs++
|
||||
if conn.linger != nil {
|
||||
conn.linger.Stop()
|
||||
conn.linger = nil
|
||||
}
|
||||
poolMu.Unlock()
|
||||
return conn, nil
|
||||
}
|
||||
if call := dialing[key]; call != nil {
|
||||
poolMu.Unlock()
|
||||
select {
|
||||
case <-call.done:
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
if call.err != nil {
|
||||
return nil, call.err
|
||||
}
|
||||
continue
|
||||
}
|
||||
call := &dialCall{done: make(chan struct{})}
|
||||
dialing[key] = call
|
||||
poolMu.Unlock()
|
||||
|
||||
conn, err := dial(spec, ps, key)
|
||||
poolMu.Lock()
|
||||
delete(dialing, key)
|
||||
if err == nil {
|
||||
pool[key] = conn
|
||||
}
|
||||
call.err = err
|
||||
close(call.done)
|
||||
poolMu.Unlock()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Loop around to take a reference like any other caller.
|
||||
}
|
||||
}
|
||||
|
||||
func (conn *pooledConn) release() {
|
||||
poolMu.Lock()
|
||||
defer poolMu.Unlock()
|
||||
conn.refs--
|
||||
if conn.refs > 0 || conn.dead {
|
||||
return
|
||||
}
|
||||
conn.linger = time.AfterFunc(idleLinger, func() {
|
||||
poolMu.Lock()
|
||||
idle := conn.refs == 0 && !conn.dead
|
||||
if idle {
|
||||
conn.dead = true
|
||||
if pool[conn.key] == conn {
|
||||
delete(pool, conn.key)
|
||||
}
|
||||
}
|
||||
poolMu.Unlock()
|
||||
if idle {
|
||||
conn.client.Close()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// markDead removes a connection from the pool once its transport has ended,
|
||||
// so the next acquire dials afresh.
|
||||
func (conn *pooledConn) markDead() {
|
||||
poolMu.Lock()
|
||||
defer poolMu.Unlock()
|
||||
conn.dead = true
|
||||
if conn.linger != nil {
|
||||
conn.linger.Stop()
|
||||
conn.linger = nil
|
||||
}
|
||||
if pool[conn.key] == conn {
|
||||
delete(pool, conn.key)
|
||||
}
|
||||
}
|
||||
|
||||
// hostKeyChecker pins the host key: only keys listed in the spec are
|
||||
// accepted, and whatever the host presented is kept for the failure report.
|
||||
type hostKeyChecker struct {
|
||||
known [][]byte
|
||||
presented ssh.PublicKey
|
||||
rejected bool
|
||||
}
|
||||
|
||||
func newHostKeyChecker(encoded []string) (*hostKeyChecker, error) {
|
||||
checker := &hostKeyChecker{}
|
||||
for _, entry := range encoded {
|
||||
wire, err := base64.StdEncoding.DecodeString(strings.TrimSpace(entry))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bad pinned host key: %v", err)
|
||||
}
|
||||
if _, err := ssh.ParsePublicKey(wire); err != nil {
|
||||
return nil, fmt.Errorf("bad pinned host key: %v", err)
|
||||
}
|
||||
checker.known = append(checker.known, wire)
|
||||
}
|
||||
return checker, nil
|
||||
}
|
||||
|
||||
func (h *hostKeyChecker) check(_ string, _ net.Addr, key ssh.PublicKey) error {
|
||||
h.presented = key
|
||||
wire := key.Marshal()
|
||||
for _, known := range h.known {
|
||||
if bytes.Equal(known, wire) {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
h.rejected = true
|
||||
return errors.New("host key not trusted")
|
||||
}
|
||||
|
||||
// algorithms lists host key algorithms with the pinned keys' types first, so
|
||||
// a host with several host keys presents the one we pinned rather than
|
||||
// whichever the default preference order favors.
|
||||
func (h *hostKeyChecker) algorithms() []string {
|
||||
var preferred []string
|
||||
seen := map[string]bool{}
|
||||
add := func(algorithm string) {
|
||||
if !seen[algorithm] {
|
||||
seen[algorithm] = true
|
||||
preferred = append(preferred, algorithm)
|
||||
}
|
||||
}
|
||||
for _, wire := range h.known {
|
||||
key, err := ssh.ParsePublicKey(wire)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if key.Type() == ssh.KeyAlgoRSA {
|
||||
add(ssh.KeyAlgoRSASHA512)
|
||||
add(ssh.KeyAlgoRSASHA256)
|
||||
continue
|
||||
}
|
||||
add(key.Type())
|
||||
}
|
||||
if len(preferred) == 0 {
|
||||
return nil // the library default
|
||||
}
|
||||
for _, algorithm := range ssh.SupportedAlgorithms().HostKeys {
|
||||
add(algorithm)
|
||||
}
|
||||
return preferred
|
||||
}
|
||||
|
||||
func (h *hostKeyChecker) failure() *failure {
|
||||
if h.presented == nil {
|
||||
return nil
|
||||
}
|
||||
info := &hostKeyInfo{
|
||||
Type: h.presented.Type(),
|
||||
Fingerprint: fingerprint(h.presented),
|
||||
Key: base64.StdEncoding.EncodeToString(h.presented.Marshal()),
|
||||
}
|
||||
if len(h.known) == 0 {
|
||||
return &failure{Kind: "hostkey-unknown", Message: "Unknown host key " + info.Fingerprint, HostKey: info}
|
||||
}
|
||||
return &failure{Kind: "hostkey-mismatch", Message: "Host key changed: now " + info.Fingerprint, HostKey: info}
|
||||
}
|
||||
|
||||
// errNoPassword aborts authentication when the host would accept a password
|
||||
// but we don't have one; the "auth" failure then asks the app to prompt.
|
||||
var errNoPassword = errors.New("password required")
|
||||
|
||||
type authState struct {
|
||||
mu sync.Mutex
|
||||
passwordAllowed bool
|
||||
passwordTried bool
|
||||
keyTried bool
|
||||
}
|
||||
|
||||
func (a *authState) set(update func(*authState)) {
|
||||
a.mu.Lock()
|
||||
update(a)
|
||||
a.mu.Unlock()
|
||||
}
|
||||
|
||||
func authMethods(spec *openSpec, signer *platformSigner, state *authState) []ssh.AuthMethod {
|
||||
var methods []ssh.AuthMethod
|
||||
if signer != nil {
|
||||
methods = append(methods, ssh.PublicKeysCallback(func() ([]ssh.Signer, error) {
|
||||
state.set(func(a *authState) { a.keyTried = true })
|
||||
return []ssh.Signer{signer}, nil
|
||||
}))
|
||||
}
|
||||
password := spec.Password
|
||||
methods = append(methods,
|
||||
ssh.PasswordCallback(func() (string, error) {
|
||||
state.set(func(a *authState) { a.passwordAllowed = true })
|
||||
if password == "" {
|
||||
return "", errNoPassword
|
||||
}
|
||||
state.set(func(a *authState) { a.passwordTried = true })
|
||||
return password, nil
|
||||
}),
|
||||
// Many hosts (PAM-backed sshd, e.g. macOS) take passwords through
|
||||
// keyboard-interactive. Answer hidden prompts with the password and
|
||||
// visible ones with nothing.
|
||||
ssh.KeyboardInteractive(func(_, _ string, questions []string, echos []bool) ([]string, error) {
|
||||
if len(questions) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
state.set(func(a *authState) { a.passwordAllowed = true })
|
||||
if password == "" {
|
||||
return nil, errNoPassword
|
||||
}
|
||||
state.set(func(a *authState) { a.passwordTried = true })
|
||||
answers := make([]string, len(questions))
|
||||
for i := range questions {
|
||||
if !echos[i] {
|
||||
answers[i] = password
|
||||
}
|
||||
}
|
||||
return answers, nil
|
||||
}),
|
||||
)
|
||||
return methods
|
||||
}
|
||||
|
||||
func dial(spec *openSpec, signer *platformSigner, key string) (*pooledConn, error) {
|
||||
timeout := defaultConnectTimeout
|
||||
if spec.ConnectTimeoutMs > 0 {
|
||||
timeout = time.Duration(spec.ConnectTimeoutMs) * time.Millisecond
|
||||
}
|
||||
checker, err := newHostKeyChecker(spec.HostKeys)
|
||||
if err != nil {
|
||||
return nil, &failure{Kind: "config", Message: err.Error()}
|
||||
}
|
||||
addr := net.JoinHostPort(spec.Host, strconv.Itoa(spec.Port))
|
||||
dialer := net.Dialer{Timeout: timeout, KeepAlive: 30 * time.Second}
|
||||
tcp, err := dialer.Dial("tcp", addr)
|
||||
if err != nil {
|
||||
return nil, &failure{Kind: "network", Message: describeNetError(err)}
|
||||
}
|
||||
// Bound the whole handshake, not just the TCP connect.
|
||||
tcp.SetDeadline(time.Now().Add(timeout))
|
||||
state := &authState{}
|
||||
config := &ssh.ClientConfig{
|
||||
User: spec.User,
|
||||
Auth: authMethods(spec, signer, state),
|
||||
HostKeyCallback: checker.check,
|
||||
HostKeyAlgorithms: checker.algorithms(),
|
||||
ClientVersion: "SSH-2.0-Faceclaw",
|
||||
Timeout: timeout,
|
||||
}
|
||||
sshConn, chans, reqs, err := ssh.NewClientConn(tcp, addr, config)
|
||||
if err != nil {
|
||||
tcp.Close()
|
||||
if checker.rejected {
|
||||
return nil, checker.failure()
|
||||
}
|
||||
state.mu.Lock()
|
||||
defer state.mu.Unlock()
|
||||
if errors.Is(err, errNoPassword) || strings.Contains(err.Error(), "unable to authenticate") {
|
||||
message := "The host refused this device's key."
|
||||
switch {
|
||||
case state.passwordTried:
|
||||
message = "The host refused the password."
|
||||
case state.passwordAllowed:
|
||||
message = "The host wants a password."
|
||||
case signer == nil:
|
||||
message = "The host accepts neither passwords nor keys we have."
|
||||
}
|
||||
return nil, &failure{
|
||||
Kind: "auth",
|
||||
Message: message,
|
||||
PasswordAllowed: state.passwordAllowed,
|
||||
PasswordTried: state.passwordTried,
|
||||
KeyTried: state.keyTried,
|
||||
}
|
||||
}
|
||||
return nil, &failure{Kind: "network", Message: "SSH handshake failed: " + describeNetError(err)}
|
||||
}
|
||||
tcp.SetDeadline(time.Time{})
|
||||
client := ssh.NewClient(sshConn, chans, reqs)
|
||||
conn := &pooledConn{key: key, client: client}
|
||||
log.Printf("faceclawssh: connected to %s@%s", spec.User, addr)
|
||||
go func() {
|
||||
err := client.Wait()
|
||||
log.Printf("faceclawssh: connection to %s ended: %v", addr, err)
|
||||
conn.markDead()
|
||||
}()
|
||||
interval := defaultKeepaliveInterval
|
||||
if spec.KeepaliveIntervalMs > 0 {
|
||||
interval = time.Duration(spec.KeepaliveIntervalMs) * time.Millisecond
|
||||
}
|
||||
go keepalive(conn, interval)
|
||||
return conn, nil
|
||||
}
|
||||
|
||||
// keepalive probes the host every interval and closes the connection if a
|
||||
// probe goes unanswered for a whole interval, so a dead peer (phone switched
|
||||
// networks, laptop asleep) fails the channels promptly instead of hanging.
|
||||
func keepalive(conn *pooledConn, interval time.Duration) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
log.Printf("faceclawssh: keepalive panic: %v", r)
|
||||
conn.client.Close()
|
||||
}
|
||||
}()
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
for range ticker.C {
|
||||
poolMu.Lock()
|
||||
dead := conn.dead
|
||||
poolMu.Unlock()
|
||||
if dead {
|
||||
return
|
||||
}
|
||||
reply := make(chan error, 1)
|
||||
go func() {
|
||||
_, _, err := conn.client.SendRequest("keepalive@openssh.com", true, nil)
|
||||
reply <- err
|
||||
}()
|
||||
select {
|
||||
case err := <-reply:
|
||||
if err != nil {
|
||||
conn.client.Close()
|
||||
return
|
||||
}
|
||||
case <-time.After(interval):
|
||||
log.Printf("faceclawssh: keepalive timed out; closing")
|
||||
conn.client.Close()
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func describeNetError(err error) string {
|
||||
message := err.Error()
|
||||
// "dial tcp 1.2.3.4:22: connect: connection refused" → keep the tail.
|
||||
if index := strings.LastIndex(message, ": "); index >= 0 && strings.HasPrefix(message, "dial ") {
|
||||
return message[index+2:]
|
||||
}
|
||||
return message
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
// Builds the Go SSH transport (native/ssh) with gomobile and stages it into
|
||||
// the local @faceclaw/kotlin NativeScript plugin next to the shared Kotlin
|
||||
// artifacts: platforms/android/faceclaw-ssh.aar and
|
||||
// platforms/ios/Faceclawssh.xcframework. Run from the before-prepare hook;
|
||||
// a content stamp skips the (~10 s) gomobile build when nothing changed.
|
||||
const { spawn, spawnSync } = require('node:child_process');
|
||||
const crypto = require('node:crypto');
|
||||
const { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const root = path.resolve(__dirname, '..');
|
||||
const source = path.join(root, 'native/ssh');
|
||||
const buildDir = path.join(source, 'build');
|
||||
const plugin = path.join(root, 'native/kotlin/plugin/platforms');
|
||||
|
||||
// Bump to force a rebuild when the gomobile invocation below changes.
|
||||
const BUILD_RECIPE = 2;
|
||||
|
||||
function sourceHash(platform) {
|
||||
const hash = crypto.createHash('sha256');
|
||||
hash.update(`${BUILD_RECIPE}\n${platform}\n`);
|
||||
const files = readdirSync(source)
|
||||
.filter(name => (name.endsWith('.go') && !name.endsWith('_test.go')) || name === 'go.mod' || name === 'go.sum')
|
||||
.sort();
|
||||
for (const name of files) {
|
||||
hash.update(`${name}\n`);
|
||||
hash.update(readFileSync(path.join(source, name)));
|
||||
}
|
||||
return hash.digest('hex');
|
||||
}
|
||||
|
||||
function findGo() {
|
||||
const probe = spawnSync('go', ['version'], { encoding: 'utf8' });
|
||||
if (probe.status !== 0) {
|
||||
throw new Error('Building the SSH transport needs Go 1.26 or newer on PATH (e.g. "brew install go").');
|
||||
}
|
||||
}
|
||||
|
||||
function newestNdk() {
|
||||
if (process.env.ANDROID_NDK_HOME && existsSync(process.env.ANDROID_NDK_HOME)) return process.env.ANDROID_NDK_HOME;
|
||||
const sdk = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
|
||||
if (!sdk) throw new Error('ANDROID_HOME must be set to build the SSH transport for Android.');
|
||||
const ndkRoot = path.join(sdk, 'ndk');
|
||||
const versions = existsSync(ndkRoot) ? readdirSync(ndkRoot).sort((a, b) => b.localeCompare(a, undefined, { numeric: true })) : [];
|
||||
if (!versions.length) throw new Error(`No Android NDK under ${ndkRoot}; install one with the SDK manager.`);
|
||||
return path.join(ndkRoot, versions[0]);
|
||||
}
|
||||
|
||||
// gomobile's ObjC headers say "@import Foundation;", which fails wherever
|
||||
// Clang modules are off (the NativeScript app target's compile, and its
|
||||
// metadata generator). A plain #import means the same thing everywhere.
|
||||
function patchGomobileHeaders(xcframework) {
|
||||
const walk = (dir) => {
|
||||
for (const entry of readdirSync(dir, { withFileTypes: true })) {
|
||||
const file = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) walk(file);
|
||||
else if (entry.name.endsWith('.h')) {
|
||||
const text = readFileSync(file, 'utf8');
|
||||
const patched = text.replace(/^@import Foundation;$/gm, '#import <Foundation/Foundation.h>');
|
||||
if (patched !== text) writeFileSync(file, patched);
|
||||
}
|
||||
}
|
||||
};
|
||||
walk(xcframework);
|
||||
}
|
||||
|
||||
function run(command, args, env) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const child = spawn(command, args, { cwd: source, stdio: 'inherit', env });
|
||||
child.on('error', reject);
|
||||
child.on('exit', (code, signal) => {
|
||||
if (code === 0) resolve();
|
||||
else reject(new Error(`${command} ${args[0]} failed (${signal || code})`));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
async function buildGoSsh(platform) {
|
||||
if (!['android', 'ios'].includes(platform)) throw new Error(`Unsupported platform: ${platform}`);
|
||||
const stampFile = path.join(buildDir, `.stamp-${platform}`);
|
||||
const output = platform === 'android'
|
||||
? path.join(buildDir, 'faceclaw-ssh.aar')
|
||||
: path.join(buildDir, 'Faceclawssh.xcframework');
|
||||
const staged = platform === 'android'
|
||||
? path.join(plugin, 'android/faceclaw-ssh.aar')
|
||||
: path.join(plugin, 'ios/Faceclawssh.xcframework');
|
||||
const hash = sourceHash(platform);
|
||||
const fresh = existsSync(output) && existsSync(stampFile) && readFileSync(stampFile, 'utf8') === hash;
|
||||
if (!fresh) {
|
||||
findGo();
|
||||
console.log(`[go-ssh] Building ${platform}`);
|
||||
mkdirSync(path.join(buildDir, 'bin'), { recursive: true });
|
||||
const env = { ...process.env, PATH: `${path.join(buildDir, 'bin')}${path.delimiter}${process.env.PATH}` };
|
||||
// gomobile bind finds gobind on PATH; build both from the versions pinned
|
||||
// in go.mod's tool block.
|
||||
await run('go', ['build', '-o', path.join(buildDir, 'bin') + path.sep, 'golang.org/x/mobile/cmd/gomobile', 'golang.org/x/mobile/cmd/gobind'], env);
|
||||
const common = ['-ldflags=-s -w', '-trimpath'];
|
||||
rmSync(output, { recursive: true, force: true });
|
||||
if (platform === 'android') {
|
||||
env.ANDROID_NDK_HOME = newestNdk();
|
||||
await run('gomobile', ['bind', '-target=android/arm64', '-androidapi', '24', '-javapkg', 'com.faceclaw.ssh', ...common, '-o', output, '.'], env);
|
||||
} else {
|
||||
await run('gomobile', ['bind', '-target=ios,iossimulator', '-iosversion', '15.0', ...common, '-o', output, '.'], env);
|
||||
patchGomobileHeaders(output);
|
||||
}
|
||||
writeFileSync(stampFile, hash);
|
||||
}
|
||||
// Stage only when the staged copy is missing or stale; preserve mtimes on
|
||||
// no-op builds (NativeScript uses them to detect changes).
|
||||
const stagedStamp = path.join(buildDir, `.staged-${platform}`);
|
||||
if (existsSync(staged) && existsSync(stagedStamp) && readFileSync(stagedStamp, 'utf8') === hash) return;
|
||||
mkdirSync(path.dirname(staged), { recursive: true });
|
||||
rmSync(staged, { recursive: true, force: true });
|
||||
cpSync(output, staged, { recursive: true });
|
||||
writeFileSync(stagedStamp, hash);
|
||||
if (platform === 'android') {
|
||||
// As in kotlin-build.cjs: NativeScript's metadata task tracks jars by
|
||||
// path, so force it to regenerate for the new classes.
|
||||
rmSync(path.join(root, 'platforms/android/app/src/main/assets/metadata'), { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { buildGoSsh };
|
||||
if (require.main === module) {
|
||||
buildGoSsh(process.argv[2]).catch(error => {
|
||||
console.error(error);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
@@ -1,8 +1,11 @@
|
||||
const { buildKotlin, checkAndroidRuntime } = require('../../scripts/kotlin-build.cjs');
|
||||
const { buildGoSsh } = require('../../scripts/go-ssh-build.cjs');
|
||||
|
||||
module.exports = function (hookArgs) {
|
||||
// NativeScript parses hooks with an older JavaScript parser; avoid optional chaining.
|
||||
const { platform, release } = hookArgs.prepareData;
|
||||
if (platform === 'android') checkAndroidRuntime();
|
||||
return buildKotlin(platform, release ? 'release' : 'debug');
|
||||
return buildKotlin(platform, release ? 'release' : 'debug').then(function () {
|
||||
return buildGoSsh(platform);
|
||||
});
|
||||
};
|
||||
@@ -0,0 +1,56 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { loader } = require('./helpers/load-typescript.cjs');
|
||||
|
||||
const settings = new Map();
|
||||
const connections = loader({}, {
|
||||
'../../native/settings-store': {
|
||||
getStringSetting: (key, fallback) => (settings.has(key) ? settings.get(key) : fallback),
|
||||
setStringSetting: (key, value) => settings.set(key, value),
|
||||
},
|
||||
})('app/apps/terminal/connections.ts');
|
||||
|
||||
// vm-realm objects: compare as plain JSON.
|
||||
const plain = (value) => JSON.parse(JSON.stringify(value));
|
||||
|
||||
test('ssh:// strings select tmux by default', () => {
|
||||
assert.deepEqual(plain(connections.parseSshConnectionString('ssh://jim@laptop')), { user: 'jim', host: 'laptop', port: 22, mode: 'tmux' });
|
||||
assert.deepEqual(plain(connections.parseSshConnectionString('ssh://jim@laptop:2222/')), { user: 'jim', host: 'laptop', port: 2222, mode: 'tmux' });
|
||||
assert.deepEqual(plain(connections.parseSshConnectionString('ssh://jim@[fd7a::1]:22')), { user: 'jim', host: 'fd7a::1', port: 22, mode: 'tmux' });
|
||||
assert.equal(connections.parseSshConnectionString('ssh://jim%40corp@laptop').user, 'jim@corp');
|
||||
});
|
||||
|
||||
test('?g2mirror= tunnels a g2mirror server over ssh', () => {
|
||||
assert.deepEqual(plain(connections.parseSshConnectionString('ssh://jim@laptop?g2mirror=tok')), {
|
||||
user: 'jim', host: 'laptop', port: 22, mode: 'g2mirror', authToken: 'tok', targetHost: '127.0.0.1', targetPort: 8737,
|
||||
});
|
||||
const custom = connections.parseSshConnectionString('ssh://jim@laptop?g2mirror=tok@en@localhost:9000');
|
||||
assert.equal(custom.authToken, 'tok@en');
|
||||
assert.equal(custom.targetHost, 'localhost');
|
||||
assert.equal(custom.targetPort, 9000);
|
||||
});
|
||||
|
||||
test('malformed ssh:// strings are rejected', () => {
|
||||
for (const url of ['ssh://laptop', 'ssh://jim@', 'ssh://jim@laptop:0', 'ssh://jim@laptop?mode=tmux', 'ssh://jim@laptop?g2mirror=', 'ssh://jim@laptop?g2mirror=tok@host:99999', 'ssh://jim@laptop?g2mirror']) {
|
||||
assert.equal(connections.parseSshConnectionString(url), null, url);
|
||||
}
|
||||
});
|
||||
|
||||
test('any-kind parsing and host labels', () => {
|
||||
assert.equal(connections.parseAnyConnectionString('g2mirror://tok@laptop').kind, 'g2mirror');
|
||||
assert.equal(connections.parseAnyConnectionString('ssh://jim@laptop').kind, 'ssh');
|
||||
assert.equal(connections.parseAnyConnectionString('http://laptop'), null);
|
||||
assert.equal(connections.connectionStringHostLabel('ssh://jim@laptop?g2mirror=secret'), 'jim@laptop');
|
||||
assert.equal(connections.connectionStringHostLabel('ssh://jim@laptop:2222'), 'jim@laptop:2222');
|
||||
assert.equal(connections.connectionStringHostLabel('ssh://jim@[fd7a::1]'), 'jim@[fd7a::1]');
|
||||
assert.equal(connections.connectionStringHostLabel('g2mirror://tok@laptop'), 'laptop');
|
||||
});
|
||||
|
||||
test('stored connections keep pinned host keys', () => {
|
||||
connections.saveConnections([{ id: 'c1', url: 'ssh://jim@laptop', serverName: null, enabled: true, hostKeys: ['AAAA'] }]);
|
||||
connections.updateConnection('c1', { hostKeys: ['AAAA', 'BBBB'] });
|
||||
assert.deepEqual(plain(connections.loadConnections()[0].hostKeys), ['AAAA', 'BBBB']);
|
||||
// Entries saved before SSH support have no hostKeys.
|
||||
settings.set(connections.TERMINAL_CONNECTIONS_KEY, JSON.stringify([{ id: 'c2', url: 'g2mirror://t@h', enabled: true }]));
|
||||
assert.deepEqual(plain(connections.loadConnections()[0].hostKeys), []);
|
||||
});
|
||||
@@ -117,6 +117,12 @@ function terminal({ sessions = ['vim', 'top'], presets = '', bellWake = true } =
|
||||
},
|
||||
'../../ui/gestures': { GESTURE_DOUBLE_CLICK: 'double-tap' },
|
||||
'../../native/g2mirror-client': { G2MirrorClient: FakeClient },
|
||||
'../../native/ssh': {
|
||||
copyToPhoneClipboard() {}, describeSshFailure: (failure) => failure.message, getSshSecret: () => '',
|
||||
openSshChannel() { throw new Error('no SSH in this test'); }, removeSshSecret() {}, setSshSecret() {},
|
||||
sshClientKey: () => ({ authorizedKey: 'ecdsa-sha2-nistp256 AAAA test', fingerprint: 'SHA256:test' }),
|
||||
},
|
||||
'./tmux-client': { TmuxClient: class {} },
|
||||
'../../native/settings-store': { onSettingsStoreChanged() {} },
|
||||
'../../ui/dashboard-settings': {
|
||||
enumSettingMenuItem() {}, textSettingMenuItem() {}, toggleSettingMenuItem() {},
|
||||
@@ -124,6 +130,7 @@ function terminal({ sessions = ['vim', 'top'], presets = '', bellWake = true } =
|
||||
terminalDisplayLayoutSetting: setting('default'),
|
||||
terminalLaunchPresetsSetting: setting(presets),
|
||||
terminalNewConnectionSetting: setting(''),
|
||||
terminalSshPasswordSetting: setting(''),
|
||||
terminalWakeOnBellSetting: setting(bellWake),
|
||||
},
|
||||
'../../ui/font-picker': { terminalFontPickerMenuItem() {} },
|
||||
@@ -132,6 +139,8 @@ function terminal({ sessions = ['vim', 'top'], presets = '', bellWake = true } =
|
||||
connectionDisplayName: (config) => config.id,
|
||||
loadConnections: () => [{ id: 'c1', url: 'ok', serverName: 'host', enabled: true }],
|
||||
parseConnectionString: () => ({ host: 'host' }),
|
||||
parseAnyConnectionString: () => ({ kind: 'g2mirror', secure: false, host: 'host', port: 8737, authToken: 'token' }),
|
||||
connectionStringHostLabel: () => 'host',
|
||||
saveConnections() {}, updateConnection() {},
|
||||
},
|
||||
'./terminal-emulator': { TerminalEmulator: FakeEmulator },
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { spawn, spawnSync } = require('node:child_process');
|
||||
const fs = require('node:fs');
|
||||
const os = require('node:os');
|
||||
const path = require('node:path');
|
||||
|
||||
const tmux = require('../.test-build/app/apps/terminal/tmux-client.js');
|
||||
|
||||
// ---- pure helpers ----
|
||||
|
||||
test('tmux version gate', () => {
|
||||
assert.deepEqual(tmux.parseTmuxVersion('tmux 3.2a'), [3, 2]);
|
||||
assert.equal(tmux.tmuxVersionSupported('tmux 3.2a'), true);
|
||||
assert.equal(tmux.tmuxVersionSupported('tmux 3.8'), true);
|
||||
assert.equal(tmux.tmuxVersionSupported('tmux 3.1c'), false);
|
||||
assert.equal(tmux.tmuxVersionSupported('tmux 2.7'), false);
|
||||
assert.equal(tmux.tmuxVersionSupported('tmux next-3.9'), true);
|
||||
assert.equal(tmux.tmuxVersionSupported('tmux master'), true);
|
||||
});
|
||||
|
||||
test('decodeTmuxOutput undoes tmux and transport escaping', () => {
|
||||
const bytes = (text) => Array.from(tmux.decodeTmuxOutput(text));
|
||||
assert.deepEqual(bytes('a\\015\\012b'), [0x61, 0x0d, 0x0a, 0x62]);
|
||||
assert.deepEqual(bytes('back\\134slash'), [...Buffer.from('back\\slash')]);
|
||||
assert.deepEqual(bytes('héllo ✓'), [...Buffer.from('héllo ✓')]);
|
||||
// A UTF-8 character split across two %output lines arrives escaped.
|
||||
assert.deepEqual([...bytes('caf\\303'), ...bytes('\\251')], [...Buffer.from('café')]);
|
||||
// A lone backslash without three octal digits is literal.
|
||||
assert.deepEqual(bytes('\\9'), [0x5c, 0x39]);
|
||||
});
|
||||
|
||||
test('hostCommand keeps scripts portable across login shells', () => {
|
||||
assert.equal(tmux.hostCommand('echo hi'), "exec /bin/sh -c 'echo hi'");
|
||||
assert.throws(() => tmux.hostCommand("echo 'hi'"));
|
||||
assert.throws(() => tmux.hostCommand('echo \\\\'));
|
||||
for (const command of [tmux.pollerCommand(), tmux.viewerCommand('$3'), tmux.launchCommand('shell'), tmux.launchCommand('htop -d 5')]) {
|
||||
assert.match(command, /^exec \/bin\/sh -c '[^']*'$/);
|
||||
}
|
||||
assert.throws(() => tmux.viewerCommand('work'));
|
||||
assert.throws(() => tmux.launchCommand('rm -rf ~; echo $HOME'));
|
||||
});
|
||||
|
||||
test('pane rows and labels', () => {
|
||||
const fields = ['%3', '$1', 'work', '@2', '1', 'zsh', '2', '0', '4242', '0', '1700000000', '3', 'zsh', '/home/jim/src', 'build\twatcher'];
|
||||
const row = tmux.parsePaneRow(fields.join('\t'));
|
||||
assert.equal(row.title, 'build\twatcher');
|
||||
assert.equal(row.bells, 3);
|
||||
assert.equal(row.windowPanes, 2);
|
||||
assert.equal(tmux.paneLabel(row, 'laptop.local', '/home/jim'), 'work:1.0 build\twatcher');
|
||||
assert.equal(tmux.paneLabel({ ...row, title: 'laptop.local' }, 'laptop.local', '/home/jim'), 'work:1.0 zsh ~/src');
|
||||
assert.equal(tmux.paneLabel({ ...row, title: 'laptop', windowPanes: 1 }, 'laptop.local', '/home/jim'), 'work:1 zsh ~/src');
|
||||
assert.equal(tmux.parsePaneRow('garbage'), null);
|
||||
});
|
||||
|
||||
test('snapshot bytes restore cursor and key modes', () => {
|
||||
const state = tmux.parsePaneState('%1|4|1|1|1|0|1|0|0|0|1|80|2|10|57|5|0');
|
||||
assert.equal(state.historyNext, 57);
|
||||
assert.equal(state.historyOldest, 5);
|
||||
const text = Buffer.from(tmux.snapshotBytes(state, ['$ ls', 'a b'], [])).toString();
|
||||
assert.equal(text, '$ ls\x1b[0m\r\na b\x1b[0m\x1b[2;5H\x1b[?1h');
|
||||
// Without history_added (tmux < 3.8), history_size stands in.
|
||||
assert.equal(tmux.parsePaneState('%1|0|0|1|0|0|1|0|0|0|23|80|24|10||||').historyNext, 10);
|
||||
});
|
||||
|
||||
test('send-keys commands are hex and chunked', () => {
|
||||
const commands = tmux.sendKeysCommands('%4', new Uint8Array(300).fill(0x41));
|
||||
assert.equal(commands.length, 2);
|
||||
assert.match(commands[0], /^send-keys -t %4 -H 41 41 /);
|
||||
});
|
||||
|
||||
// ---- against a real tmux server ----
|
||||
|
||||
const tmuxVersion = spawnSync('tmux', ['-V'], { encoding: 'utf8' });
|
||||
const haveTmux = tmuxVersion.status === 0 && tmux.tmuxVersionSupported(tmuxVersion.stdout);
|
||||
|
||||
/** Mimic the SSH transport: run through a shell, split stdout/stderr into lines, escape non-UTF-8 lines. */
|
||||
function localChannel(env) {
|
||||
return (command, listener) => {
|
||||
const child = spawn('/bin/sh', ['-c', command], { env, stdio: ['pipe', 'pipe', 'pipe'] });
|
||||
let closed = false;
|
||||
// Like the SSH transport, a write to a channel whose command just exited is dropped, not thrown.
|
||||
child.stdin.on('error', () => {});
|
||||
const lines = (stream, emit) => {
|
||||
let buffered = Buffer.alloc(0);
|
||||
stream.on('data', (chunk) => {
|
||||
buffered = Buffer.concat([buffered, chunk]);
|
||||
let index;
|
||||
while ((index = buffered.indexOf(0x0a)) >= 0) {
|
||||
emit(escapeLine(buffered.subarray(0, index)));
|
||||
buffered = buffered.subarray(index + 1);
|
||||
}
|
||||
});
|
||||
};
|
||||
lines(child.stdout, (line) => !closed && listener.onLine(line));
|
||||
lines(child.stderr, (line) => !closed && listener.onStderr(line));
|
||||
child.on('spawn', () => listener.onOpen());
|
||||
child.on('exit', (status) => { if (!closed) { closed = true; listener.onClosed(status); } });
|
||||
return {
|
||||
send: (line) => { if (closed) return false; child.stdin.write(`${line}\n`); return true; },
|
||||
close: () => { if (closed) return; closed = true; child.stdin.end(); setTimeout(() => child.kill(), 500); },
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
function escapeLine(bytes) {
|
||||
const text = bytes.toString('utf8');
|
||||
if (Buffer.from(text, 'utf8').equals(bytes)) return text;
|
||||
return Array.from(bytes, (byte) => (byte >= 0x80 ? `\\${byte.toString(8).padStart(3, '0')}` : String.fromCharCode(byte))).join('');
|
||||
}
|
||||
|
||||
function waitFor(predicate, what, timeoutMs = 10_000) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const started = Date.now();
|
||||
const timer = setInterval(() => {
|
||||
let value;
|
||||
try { value = predicate(); } catch (error) { clearInterval(timer); reject(error); return; }
|
||||
if (value) { clearInterval(timer); resolve(value); }
|
||||
else if (Date.now() - started > timeoutMs) { clearInterval(timer); reject(new Error(`timed out waiting for ${what}`)); }
|
||||
}, 50);
|
||||
});
|
||||
}
|
||||
|
||||
test('TmuxClient against a local tmux server', { skip: !haveTmux && 'tmux >= 3.2 not installed' }, async () => {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fc-tmux-'));
|
||||
const env = { ...process.env, TMUX_TMPDIR: dir, SHELL: '/bin/sh', PS1: '$ ' };
|
||||
delete env.TMUX;
|
||||
const tm = (...args) => spawnSync('tmux', args, { env, encoding: 'utf8' });
|
||||
const openChannel = localChannel(env);
|
||||
const clients = [];
|
||||
try {
|
||||
tm('new-session', '-d', '-s', 'work', '-x', '120', '-y', '40', '/bin/sh');
|
||||
const control = new tmux.TmuxClient({ openChannel, label: 'test', cols: 80, rows: 20, stateKey: 'test-connection' });
|
||||
clients.push(control);
|
||||
const bells = [];
|
||||
control.onBell((socket) => bells.push(socket));
|
||||
control.start();
|
||||
await waitFor(() => control.state().phase === 'connected' && control.state().sessions.length === 1, 'listing');
|
||||
assert.equal(control.state().sessions[0].socket, '%0');
|
||||
assert.match(control.state().sessions[0].title, /^work:0 /);
|
||||
|
||||
// A bell in the session's current window (tmux's own bell flag misses these).
|
||||
tm('send-keys', '-t', '%0', '-l', "printf '\\a'");
|
||||
tm('send-keys', '-t', '%0', 'Enter');
|
||||
await waitFor(() => bells.includes('%0'), 'bell');
|
||||
|
||||
const launched = await control.launchSession('shell');
|
||||
assert.match(launched, /^%\d+$/);
|
||||
await waitFor(() => control.state().sessions.some((s) => s.socket === launched), 'launched pane in listing');
|
||||
|
||||
// View the original pane.
|
||||
const view = new tmux.TmuxClient({ openChannel, label: 'test', cols: 80, rows: 20, stateKey: '' });
|
||||
clients.push(view);
|
||||
let screen = '';
|
||||
const snapshots = [];
|
||||
const histories = [];
|
||||
view.onTerminalData((data, kind) => {
|
||||
if (kind === 'snapshot') { screen = ''; snapshots.push(Buffer.from(data).toString()); }
|
||||
screen += Buffer.from(data).toString();
|
||||
});
|
||||
view.onSnapshot((next, oldest) => snapshots.push({ next, oldest }));
|
||||
view.onHistoryLines((reply) => histories.push(reply));
|
||||
view.onStateChange((state) => {
|
||||
if (state.phase === 'connected' && !view.requested) { view.requested = true; view.connectSession('%0'); }
|
||||
});
|
||||
view.onSessionAttached(() => view.view());
|
||||
view.start();
|
||||
await waitFor(() => snapshots.length >= 2, 'snapshot');
|
||||
assert.equal(view.state().phase, 'attached');
|
||||
assert.equal(tm('display', '-p', '-t', '%0', '#{window_width}x#{window_height}').stdout.trim(), '80x20');
|
||||
|
||||
view.sendInput('for i in $(seq 1 60); do echo row$i; done\r');
|
||||
await waitFor(() => screen.includes('row60'), 'typed command output');
|
||||
|
||||
// Re-snapshot: rows have scrolled into the history; page some back.
|
||||
view.unview();
|
||||
view.view();
|
||||
await waitFor(() => snapshots.length >= 4, 'second snapshot');
|
||||
const { next } = snapshots[snapshots.length - 1];
|
||||
assert.ok(next > 20, `history should have grown, next=${next}`);
|
||||
view.requestHistory(next, 5);
|
||||
await waitFor(() => histories.length === 1, 'history page');
|
||||
assert.equal(histories[0].lines.length, 5);
|
||||
assert.equal(histories[0].start, next - 5);
|
||||
assert.ok(histories[0].lines.some((line) => /^row\d+$/.test(line)), JSON.stringify(histories[0].lines));
|
||||
|
||||
// Unviewing gives the window back its own size.
|
||||
view.unview();
|
||||
await waitFor(() => tm('display', '-p', '-t', '%0', '#{window_width}').stdout.trim() !== '80', 'size restored', 3000).catch(() => {});
|
||||
|
||||
// The pane going away ends the view.
|
||||
let detached = null;
|
||||
view.onSessionDetached((reason) => { detached = reason; });
|
||||
view.view();
|
||||
tm('kill-pane', '-t', '%0');
|
||||
await waitFor(() => detached !== null, 'detach on pane exit');
|
||||
} finally {
|
||||
for (const client of clients) client.stop();
|
||||
tm('kill-server');
|
||||
fs.rmSync(dir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
@@ -25,6 +25,9 @@
|
||||
"../app/g2/keyboard/key-router.ts",
|
||||
"../app/g2/keyboard/pointer.ts",
|
||||
"../app/apps/terminal/terminal-keys.ts",
|
||||
"../app/native/terminal-session-types.ts",
|
||||
"../app/apps/terminal/terminal-client.ts",
|
||||
"../app/apps/terminal/tmux-client.ts",
|
||||
"../app/phone-ui/ble-bandwidth-meter.ts",
|
||||
"../app/apps/terminal/hub-header.ts",
|
||||
"../app/g2/ios-peripheral-identity.ts",
|
||||
|
||||
Reference in new issue
Block a user