restructure signed_app into flat modules and bump gpui-native-kit
Rust / build (macos-latest, stable) (push) Canceled after 0s
Rust / build (ubuntu-latest, stable) (push) Canceled after 0s
Rust / build (windows-latest, stable) (push) Canceled after 0s
Rust / build (macos-latest, stable) (pull_request) Canceled after 0s
Rust / build (ubuntu-latest, stable) (pull_request) Canceled after 0s
Rust / build (windows-latest, stable) (pull_request) Canceled after 0s
Rust / build (macos-latest, stable) (push) Canceled after 0s
Rust / build (ubuntu-latest, stable) (push) Canceled after 0s
Rust / build (windows-latest, stable) (push) Canceled after 0s
Rust / build (macos-latest, stable) (pull_request) Canceled after 0s
Rust / build (ubuntu-latest, stable) (pull_request) Canceled after 0s
Rust / build (windows-latest, stable) (pull_request) Canceled after 0s
This commit is contained in:
@@ -0,0 +1,346 @@
|
||||
use gpui::prelude::FluentBuilder as _;
|
||||
use gpui::{
|
||||
AnyElement, App, AppContext as _, Context, Entity, IntoElement, ParentElement as _, Render,
|
||||
Styled as _, Subscription, Task, Window, div, px,
|
||||
};
|
||||
use gpui_native_kit::button::Button;
|
||||
use gpui_native_kit::common::v_flex;
|
||||
use gpui_native_kit::dialog::Dialog;
|
||||
use gpui_native_kit::field::Field;
|
||||
use gpui_native_kit::input::{Input, InputState, InputStateEvent};
|
||||
use gpui_native_kit::theme::ActiveTheme as _;
|
||||
use signed_state::Backend;
|
||||
|
||||
use crate::shared::dialogs::close_global;
|
||||
use crate::shared::progress::{DialogProgress, error_row};
|
||||
|
||||
#[derive(Clone, Copy, Default, PartialEq, Eq)]
|
||||
enum Stage {
|
||||
#[default]
|
||||
Credential,
|
||||
/// An `nsec` was entered; ask for a passphrase to encrypt it with.
|
||||
Encrypt,
|
||||
/// An `ncryptsec` was entered; ask for its passphrase to decrypt it.
|
||||
Decrypt,
|
||||
}
|
||||
|
||||
/// The credential entered on the first step.
|
||||
enum Credential {
|
||||
Nsec(String),
|
||||
Ncryptsec(String),
|
||||
Bunker(String),
|
||||
}
|
||||
|
||||
impl Credential {
|
||||
fn parse(input: &str) -> Option<Self> {
|
||||
let input = input.trim();
|
||||
|
||||
if input.starts_with("nsec1") {
|
||||
Some(Self::Nsec(input.to_owned()))
|
||||
} else if input.starts_with("ncryptsec1") {
|
||||
Some(Self::Ncryptsec(input.to_owned()))
|
||||
} else if input.starts_with("bunker://") {
|
||||
Some(Self::Bunker(input.to_owned()))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// State of the import dialog, so the current step and async results can be rendered.
|
||||
#[derive(Default)]
|
||||
pub struct ImportState {
|
||||
stage: Stage,
|
||||
credential: String,
|
||||
progress: DialogProgress,
|
||||
}
|
||||
|
||||
pub struct ImportDialog {
|
||||
secret_input: Entity<InputState>,
|
||||
pass_input: Entity<InputState>,
|
||||
repass_input: Entity<InputState>,
|
||||
state: Entity<ImportState>,
|
||||
_subscriptions: Vec<Subscription>,
|
||||
}
|
||||
|
||||
impl ImportDialog {
|
||||
pub fn new(cx: &mut App) -> Entity<Self> {
|
||||
let state = cx.new(|_| ImportState::default());
|
||||
let secret_input = InputState::new(cx);
|
||||
|
||||
let pass_input = InputState::new(cx);
|
||||
pass_input.update(cx, |state, cx| state.set_password(true, cx));
|
||||
|
||||
let repass_input = InputState::new(cx);
|
||||
repass_input.update(cx, |state, cx| state.set_password(true, cx));
|
||||
|
||||
cx.new(|cx| {
|
||||
let mut subscriptions = Vec::new();
|
||||
|
||||
for input in [&secret_input, &pass_input, &repass_input] {
|
||||
let secret_input = secret_input.clone();
|
||||
let pass_input = pass_input.clone();
|
||||
let repass_input = repass_input.clone();
|
||||
let state = state.clone();
|
||||
|
||||
subscriptions.push(cx.subscribe(input, move |_this, _input, event, cx| {
|
||||
if matches!(event, InputStateEvent::Submitted) {
|
||||
submit(&secret_input, &pass_input, &repass_input, &state, cx);
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
||||
Self {
|
||||
secret_input,
|
||||
pass_input,
|
||||
repass_input,
|
||||
state,
|
||||
_subscriptions: subscriptions,
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Render for ImportDialog {
|
||||
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
|
||||
let state = self.state.clone();
|
||||
|
||||
let secret_input = self.secret_input.clone();
|
||||
let pass_input = self.pass_input.clone();
|
||||
let repass_input = self.repass_input.clone();
|
||||
|
||||
let action_state = state.clone();
|
||||
let action_secret = secret_input.clone();
|
||||
|
||||
let action_pass = pass_input.clone();
|
||||
let action_repass = repass_input.clone();
|
||||
|
||||
Dialog::new("import-dialog")
|
||||
.open(true)
|
||||
.min_width(px(520.))
|
||||
.on_change(|open, _, cx| {
|
||||
if !open {
|
||||
close_global(cx);
|
||||
}
|
||||
})
|
||||
.title("Import identity")
|
||||
.content(move |_window, cx| {
|
||||
let state = state.read(cx);
|
||||
let stage = state.stage;
|
||||
|
||||
let description = match stage {
|
||||
Stage::Credential => {
|
||||
"Paste the secret key or bunker URI of an existing identity."
|
||||
}
|
||||
Stage::Encrypt => "Choose a passphrase to encrypt your key on this device.",
|
||||
Stage::Decrypt => "Enter the passphrase used to encrypt this key.",
|
||||
};
|
||||
|
||||
let form = match stage {
|
||||
Stage::Credential => v_flex().gap_3().child(
|
||||
Field::new("secret-field", "Secret key or bunker URI")
|
||||
.child(Input::new("secret-input", secret_input.clone())),
|
||||
),
|
||||
Stage::Encrypt => v_flex()
|
||||
.gap_3()
|
||||
.child(
|
||||
Field::new("passphrase-field", "Passphrase")
|
||||
.child(Input::new("passphrase-input", pass_input.clone())),
|
||||
)
|
||||
.child(
|
||||
Field::new("repeat-field", "Repeat passphrase")
|
||||
.child(Input::new("repeat-input", repass_input.clone())),
|
||||
),
|
||||
Stage::Decrypt => v_flex().gap_3().child(
|
||||
Field::new("passphrase-field", "Passphrase")
|
||||
.child(Input::new("passphrase-input", pass_input.clone())),
|
||||
),
|
||||
};
|
||||
|
||||
v_flex()
|
||||
.gap_3()
|
||||
.child(
|
||||
div()
|
||||
.text_sm()
|
||||
.text_color(cx.theme().colors.muted_foreground)
|
||||
.child(description),
|
||||
)
|
||||
.child(form)
|
||||
.when_some(error_row(&state.progress.error, cx), |el, error| {
|
||||
el.child(error)
|
||||
})
|
||||
.into_any_element()
|
||||
})
|
||||
.actions(move |_, cx| {
|
||||
let state = action_state.read(cx);
|
||||
let busy = state.progress.busy;
|
||||
|
||||
let label = match state.stage {
|
||||
Stage::Credential => "Continue",
|
||||
Stage::Encrypt => "Import identity",
|
||||
Stage::Decrypt => "Unlock",
|
||||
};
|
||||
|
||||
let secret = action_secret.clone();
|
||||
let pass = action_pass.clone();
|
||||
let repass = action_repass.clone();
|
||||
let state = action_state.clone();
|
||||
|
||||
let import: AnyElement = Button::new("import-identity")
|
||||
.label(label)
|
||||
.loading(busy)
|
||||
.disabled(busy)
|
||||
.on_click(move |_, _, cx| {
|
||||
submit(&secret, &pass, &repass, &state, cx);
|
||||
})
|
||||
.into_any_element();
|
||||
|
||||
vec![import]
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn submit(
|
||||
secret_input: &Entity<InputState>,
|
||||
pass_input: &Entity<InputState>,
|
||||
repass_input: &Entity<InputState>,
|
||||
state: &Entity<ImportState>,
|
||||
cx: &mut App,
|
||||
) {
|
||||
if state.read(cx).progress.busy {
|
||||
return;
|
||||
}
|
||||
|
||||
match state.read(cx).stage {
|
||||
Stage::Credential => start_import(secret_input, state, cx),
|
||||
Stage::Encrypt => import_nsec(pass_input, repass_input, state, cx),
|
||||
Stage::Decrypt => import_ncryptsec(pass_input, state, cx),
|
||||
}
|
||||
}
|
||||
|
||||
/// Parses the entered credential and either moves to the passphrase step or connects to a bunker.
|
||||
fn start_import(secret_input: &Entity<InputState>, state: &Entity<ImportState>, cx: &mut App) {
|
||||
let credential = match Credential::parse(secret_input.read(cx).value()) {
|
||||
Some(credential) => credential,
|
||||
None => {
|
||||
state.update(cx, |state, cx| {
|
||||
state
|
||||
.progress
|
||||
.fail("Enter an nsec, ncryptsec or bunker:// URI");
|
||||
cx.notify();
|
||||
});
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
match credential {
|
||||
Credential::Nsec(secret) => {
|
||||
state.update(cx, |state, cx| {
|
||||
state.credential = secret;
|
||||
state.stage = Stage::Encrypt;
|
||||
state.progress.error = None;
|
||||
cx.notify();
|
||||
});
|
||||
}
|
||||
Credential::Ncryptsec(secret) => {
|
||||
state.update(cx, |state, cx| {
|
||||
state.credential = secret;
|
||||
state.stage = Stage::Decrypt;
|
||||
state.progress.error = None;
|
||||
cx.notify();
|
||||
});
|
||||
}
|
||||
Credential::Bunker(uri) => {
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.begin();
|
||||
cx.notify();
|
||||
});
|
||||
|
||||
let backend = Backend::global(cx);
|
||||
let task = backend.update(cx, |backend, cx| backend.import_bunker(&uri, cx));
|
||||
finish_import(task, state, cx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Encrypts the entered `nsec` with the passphrase and signs in with it.
|
||||
fn import_nsec(
|
||||
pass_input: &Entity<InputState>,
|
||||
repass_input: &Entity<InputState>,
|
||||
state: &Entity<ImportState>,
|
||||
cx: &mut App,
|
||||
) {
|
||||
let backend = Backend::global(cx);
|
||||
let nsec = state.read(cx).credential.clone();
|
||||
let pass = pass_input.read(cx).value().to_string();
|
||||
let repass = repass_input.read(cx).value().to_string();
|
||||
|
||||
if pass.is_empty() {
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.fail("Passphrase must not be empty");
|
||||
cx.notify();
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if pass != repass {
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.fail("Passphrases do not match");
|
||||
cx.notify();
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.begin();
|
||||
cx.notify();
|
||||
});
|
||||
|
||||
let task = backend.update(cx, |backend, cx| backend.import_nsec(&nsec, &pass, cx));
|
||||
finish_import(task, state, cx);
|
||||
}
|
||||
|
||||
/// Decrypts the entered `ncryptsec` with the passphrase and signs in with it.
|
||||
fn import_ncryptsec(pass_input: &Entity<InputState>, state: &Entity<ImportState>, cx: &mut App) {
|
||||
let backend = Backend::global(cx);
|
||||
let ncryptsec = state.read(cx).credential.clone();
|
||||
let pass = pass_input.read(cx).value().to_string();
|
||||
|
||||
if pass.is_empty() {
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.fail("Passphrase must not be empty");
|
||||
cx.notify();
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.begin();
|
||||
cx.notify();
|
||||
});
|
||||
|
||||
let task = backend.update(cx, |backend, cx| {
|
||||
backend.import_ncryptsec(&ncryptsec, &pass, cx)
|
||||
});
|
||||
finish_import(task, state, cx);
|
||||
}
|
||||
|
||||
/// Runs the import task to completion, closing the dialog on success.
|
||||
fn finish_import<T: 'static>(
|
||||
task: Task<Result<T, anyhow::Error>>,
|
||||
state: &Entity<ImportState>,
|
||||
cx: &mut App,
|
||||
) {
|
||||
let state = state.clone();
|
||||
|
||||
cx.spawn(async move |cx| match task.await {
|
||||
Ok(_) => cx.update(close_global),
|
||||
Err(error) => {
|
||||
state.update(cx, |state, cx| {
|
||||
state.progress.fail(error.to_string());
|
||||
cx.notify();
|
||||
});
|
||||
}
|
||||
})
|
||||
.detach();
|
||||
}
|
||||
Reference in New Issue
Block a user