add CliRequest variants to store/erase docker credentials

package.json

@@ -1,6 +1,6 @@
 {
   "name": "creddy",
-  "version": "0.6.0",
+  "version": "0.5.4",
   "scripts": {
     "dev": "vite",
     "build": "vite build",

src-tauri/Cargo.lock

@@ -1241,7 +1241,7 @@ dependencies = [
 
 [[package]]
 name = "creddy"
-version = "0.6.0"
+version = "0.5.4"
 dependencies = [
  "argon2",
  "auto-launch",
@@ -1287,7 +1287,7 @@ dependencies = [
 
 [[package]]
 name = "creddy_cli"
-version = "0.6.0"
+version = "0.5.4"
 dependencies = [
  "anyhow",
  "clap",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "creddy"
-version = "0.6.0"
+version = "0.5.4"
 description = "A friendly AWS credentials manager"
 authors = ["Joseph Montanaro"]
 license = ""

src-tauri/creddy_cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "creddy_cli"
-version = "0.6.0"
+version = "0.5.4"
 edition = "2021"
 
 [dependencies]

src-tauri/creddy_cli/src/cli/docker.rs

@@ -13,7 +13,11 @@ use super::{
 pub fn docker_store(global_args: GlobalArgs) -> anyhow::Result<()> {
     let input: DockerCredential = serde_json::from_reader(io::stdin())?;
 
-    let req = CliRequest::StoreDockerCredential(input);
+    let req = CliRequest::SaveCredential {
+        name: input.username.clone(),
+        is_default: false, // is_default doesn't really mean anything for Docker credentials
+        credential: CliCredential::Docker(input),
+    };
 
     match super::make_request(global_args.server_addr, &req)?? {
         CliResponse::Empty => Ok(()),
@@ -37,17 +41,3 @@ pub fn docker_get(global_args: GlobalArgs) -> anyhow::Result<()> {
     }
     Ok(())
 }
-
-
-pub fn docker_erase(global_args: GlobalArgs) -> anyhow::Result<()> {
-    let mut server_url = String::new();
-    io::stdin().read_to_string(&mut server_url)?;
-    let req = CliRequest::EraseDockerCredential {
-        server_url: server_url.trim().to_owned()
-    };
-
-    match super::make_request(global_args.server_addr, &req)?? {
-        CliResponse::Empty => Ok(()),
-        r => bail!("Unexpected response from server: {r}"),
-    }
-}

src-tauri/creddy_cli/src/cli/mod.rs

@@ -193,7 +193,7 @@ pub fn exec(args: ExecArgs, global: GlobalArgs) -> anyhow::Result<()> {
 
 
 pub fn invoke_shortcut(args: InvokeArgs, global: GlobalArgs) -> anyhow::Result<()> {
-    let req = CliRequest::InvokeShortcut{action: args.shortcut_action};
+    let req = CliRequest::InvokeShortcut(args.shortcut_action);
     match make_request(global.server_addr, &req)?? {
         CliResponse::Empty => Ok(()),
         r => bail!("Unexpected response from server: {r}"),
@@ -205,7 +205,7 @@ pub fn docker_credential_helper(cmd: DockerCmd, global_args: GlobalArgs) -> anyh
     match cmd {
         DockerCmd::Get => docker::docker_get(global_args),
         DockerCmd::Store => docker::docker_store(global_args),
-        DockerCmd::Erase => docker::docker_erase(global_args),
+        DockerCmd::Erase => todo!(),
     }
 }
 

src-tauri/migrations/20240919135710_docker_creds.sql

@@ -7,6 +7,5 @@ CREATE TABLE docker_credentials (
     server_url TEXT UNIQUE NOT NULL,
     username TEXT NOT NULL,
     secret_enc BLOB NOT NULL,
-    nonce BLOB NOT NULL,
+    nonce BLOB NOT NULL
-    FOREIGN KEY(id) REFERENCES credentials(id) ON DELETE CASCADE
 );

src-tauri/src/clientinfo.rs

@@ -5,8 +5,7 @@ use sysinfo::{
     SystemExt,
     Pid,
     PidExt,
-    ProcessExt,
+    ProcessExt
-    UserExt,
 };
 use serde::{Serialize, Deserialize};
 
@@ -17,16 +16,13 @@ use crate::errors::*;
 pub struct Client {
     pub pid: u32,
     pub exe: Option<PathBuf>,
-    pub username: Option<String>,
 }
 
 
 pub fn get_client(pid: u32, parent: bool) -> Result<Client, ClientInfoError> {
     let sys_pid = Pid::from_u32(pid);
-    let mut sys = System::new();
+    let mut sys = System::new();   
     sys.refresh_process(sys_pid);
-    sys.refresh_users_list();
-
     let mut proc = sys.process(sys_pid)
         .ok_or(ClientInfoError::ProcessNotFound)?;
 
@@ -38,15 +34,10 @@ pub fn get_client(pid: u32, parent: bool) -> Result<Client, ClientInfoError> {
             .ok_or(ClientInfoError::ParentProcessNotFound)?;
     }
 
-    let username = proc.user_id()
-        .map(|uid| sys.get_user_by_id(uid))
-        .flatten()
-        .map(|u| u.name().to_owned());
-
     let exe = match proc.exe() {
         p if p == Path::new("") => None,
         p => Some(PathBuf::from(p)),
     };
 
-    Ok(Client { pid: proc.pid().as_u32(), exe, username })
+    Ok(Client { pid: proc.pid().as_u32(), exe })
 }

src-tauri/src/credentials/mod.rs

@@ -139,10 +139,3 @@ pub trait PersistentCredential: for<'a> Deserialize<'a> + Sized {
         Ok(creds)
     }
 }
-
-
-pub fn random_uuid() -> Uuid {
-    // a bit weird to use salt() for this, but it's convenient
-    let random_bytes = Crypto::salt();
-    Uuid::from_slice(&random_bytes[..16]).unwrap()
-}

src-tauri/src/ipc.rs

@@ -14,14 +14,6 @@ use crate::state::AppState;
 use crate::terminal;
 
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum RequestAction {
-    Access,
-    Delete,
-    Save,
-}
-
-
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct AwsRequestNotification {
     pub client: Client,
@@ -39,7 +31,6 @@ pub struct SshRequestNotification {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct DockerRequestNotification {
-    pub action: RequestAction,
     pub client: Client,
     pub server_url: String,
 }
@@ -62,8 +53,8 @@ impl RequestNotificationDetail {
         Self::Ssh(SshRequestNotification {client, key_name})
     }
 
-    pub fn new_docker(action: RequestAction, client: Client, server_url: String) -> Self {
+    pub fn new_docker(client: Client, server_url: String) -> Self {
-        Self::Docker(DockerRequestNotification {action, client, server_url})
+        Self::Docker(DockerRequestNotification {client, server_url})
     }
 }
 

src-tauri/src/srv/agent.rs

@@ -6,11 +6,12 @@ use ssh_agent_lib::proto::message::{
 };
 use tauri::{AppHandle, Manager};
 use tokio_stream::StreamExt;
+use tokio::sync::oneshot;
 use tokio_util::codec::Framed;
 
 use crate::clientinfo;
 use crate::errors::*;
-use crate::ipc::{Approval, RequestNotificationDetail};
+use crate::ipc::{Approval, RequestNotification, RequestNotificationDetail};
 use crate::state::AppState;
 
 use super::{CloseWaiter, Stream};

src-tauri/src/srv/creddy_server.rs

@@ -1,19 +1,16 @@
+use sqlx::types::uuid::Uuid;
 use tauri::{AppHandle, Manager};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::sync::oneshot;
 
 use crate::clientinfo::{self, Client};
 use crate::credentials::{
-    self,
     Credential,
     CredentialRecord,
-    DockerCredential,
+    Crypto
 };
 use crate::errors::*;
-use crate::ipc::{
+use crate::ipc::{Approval, AwsRequestNotification, RequestNotificationDetail, RequestResponse};
-    Approval,
-    RequestAction,
-    RequestNotificationDetail
-};
 use crate::shortcuts::{self, ShortcutAction};
 use crate::state::AppState;
 use super::{
@@ -58,16 +55,13 @@ async fn handle(
         CliRequest::GetAwsCredential{ name, base } => get_aws_credentials(
             name, base, client, app_handle, waiter
         ).await,
-        CliRequest::GetDockerCredential{ server_url } => get_docker_credential (
+        CliRequest::GetDockerCredential{ server_url } => get_docker_credentials (
             server_url, client, app_handle, waiter
         ).await,
-        CliRequest::StoreDockerCredential(docker_credential) => store_docker_credential(
+        CliRequest::SaveCredential{ name, is_default, credential } => save_credential(
-             docker_credential, app_handle, client, waiter
+            name, is_default, credential, app_handle
         ).await,
-        CliRequest::EraseDockerCredential { server_url } => erase_docker_credential(
+        CliRequest::InvokeShortcut(action) => invoke_shortcut(action).await,
-            server_url, app_handle, client, waiter
-        ).await,
-        CliRequest::InvokeShortcut{ action } => invoke_shortcut(action).await,
     };
 
     // doesn't make sense to send the error to the client if the client has already left
@@ -112,32 +106,17 @@ async fn get_aws_credentials(
     }
 }
 
-async fn get_docker_credential(
+async fn get_docker_credentials(
     server_url: String,
     client: Client,
     app_handle: AppHandle,
     waiter: CloseWaiter<'_>,
 ) -> Result<CliResponse, HandlerError> {
-    let state = app_handle.state::<AppState>();
+    let detail = RequestNotificationDetail::new_docker(client, server_url.clone());
-    let meta = state.docker_credential_meta(&server_url).await.unwrap_or(None);
-    if  meta.is_none() {
-        return Err(
-            HandlerError::NoCredentials(
-                GetCredentialsError::Load(
-                    LoadCredentialsError::NoCredentials
-                )
-            )
-        );
-    }
-
-    let detail = RequestNotificationDetail::new_docker(
-        RequestAction::Access,
-        client,
-        server_url.clone()
-    );
     let response = super::send_credentials_request(detail, app_handle.clone(), waiter).await?;
     match response.approval {
         Approval::Approved => {
+            let state = app_handle.state::<AppState>();
             let creds = state.get_docker_credential(&server_url).await?;
             Ok(CliResponse::Credential(CliCredential::Docker(creds)))
         },
@@ -147,77 +126,24 @@ async fn get_docker_credential(
     }
 }
 
-async fn store_docker_credential(
+pub async fn save_credential(
-    docker_credential: DockerCredential,
+    name: String,
+    is_default: bool,
+    credential: Credential,
     app_handle: AppHandle,
-    client: Client,
-    waiter: CloseWaiter<'_>,
 ) -> Result<CliResponse, HandlerError> {
     let state = app_handle.state::<AppState>();
 
-    // We want to do this before asking for confirmation from the user, because Docker has an annoying
+    // eventually ask the frontend to unlock here
-    // habit of calling `get` and then immediately turning around and calling `store` with the same
-    // data. In that case we want to avoid asking for confirmation at all.
-    match state.get_docker_credential(&docker_credential.server_url).await {
-        // if there is already a credential with this server_url, and it is unchanged, we're done
-        Ok(c) if c == docker_credential => return Ok(CliResponse::Empty),
-        // otherwise we are making an update, so proceed
-        Ok(_) => (),
-        // if the app is locked, then this isn't the situation described above, so proceed
-        Err(GetCredentialsError::Locked) => (),
-        // if the app is unlocked, and there is no matching credential, proceed
-        Err(GetCredentialsError::Load(LoadCredentialsError::NoCredentials)) => (),
-        // any other error is a failure
-        Err(e) => return Err(e.into()),
-    };
 
-    let detail = RequestNotificationDetail::new_docker(
+    // a bit weird but convenient
-        RequestAction::Save,
+    let random_bytes = Crypto::salt();
-        client,
+    let id = Uuid::from_slice(&random_bytes[..16]).unwrap();
-        docker_credential.server_url.clone(),
-    );
-    let response = super::send_credentials_request(detail, app_handle.clone(), waiter).await?;
-    if matches!(response.approval, Approval::Denied) {
-        return Err(HandlerError::Denied);
-    }
-
-    let (id, name) = state.docker_credential_meta(&docker_credential.server_url)
-        .await
-        .map_err(|e| GetCredentialsError::Load(e))?
-        .unwrap_or_else(|| (credentials::random_uuid(), docker_credential.server_url.clone()));
 
     let record = CredentialRecord {
-        id,
+        id, name, is_default, credential
-        name,
-        is_default: false,
-        credential: Credential::Docker(docker_credential)
     };
     state.save_credential(record).await?;
 
     Ok(CliResponse::Empty)
 }
-
-async fn erase_docker_credential(
-    server_url: String,
-    app_handle: AppHandle,
-    client: Client,
-    waiter: CloseWaiter<'_>
-) -> Result<CliResponse, HandlerError> {
-    let state = app_handle.state::<AppState>();
-
-    let detail = RequestNotificationDetail::new_docker(
-        RequestAction::Delete,
-        client,
-        server_url.clone(),
-    );
-    let resp = super::send_credentials_request(detail, app_handle.clone(), waiter).await?;
-    match resp.approval {
-        Approval::Approved => {
-            state.delete_credential_by_name(&server_url).await?;
-            Ok(CliResponse::Empty)
-        }
-        Approval::Denied => {
-            Err(HandlerError::Denied)
-        }
-    }
-}

src-tauri/src/srv/mod.rs

@@ -9,9 +9,11 @@ use tokio::io::AsyncReadExt;
 use tokio::sync::oneshot;
 use serde::{Serialize, Deserialize};
 
+use crate::clientinfo::Client;
 use crate::credentials::{
     AwsBaseCredential,
     AwsSessionCredential,
+    Credential,
     DockerCredential,
 };
 use crate::errors::*;
@@ -28,7 +30,6 @@ use platform::Stream;
 // so that we avoid polluting the standalone CLI with a bunch of dependencies
 // that would make it impossible to build a completely static-linked version
 #[derive(Debug, Serialize, Deserialize)]
-#[serde(tag = "type")]
 pub enum CliRequest {
     GetAwsCredential {
         name: Option<String>,
@@ -37,13 +38,12 @@ pub enum CliRequest {
     GetDockerCredential {
         server_url: String,
     },
-    StoreDockerCredential(DockerCredential),
+    SaveCredential {
-    EraseDockerCredential {
+        name: String,
-        server_url: String,
+        is_default: bool,
-    },
+        credential: Credential,
-    InvokeShortcut{
-        action: ShortcutAction,
     },
+    InvokeShortcut(ShortcutAction),
 }
 
 

src-tauri/src/state.rs

@@ -161,13 +161,6 @@ impl AppState {
         Ok(())
     }
 
-    pub async fn delete_credential_by_name(&self, name: &str) -> Result<(), SaveCredentialsError> {
-        sqlx::query!("DELETE FROM credentials WHERE name = ?", name)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
     pub async fn list_credentials(&self) -> Result<Vec<CredentialRecord>, GetCredentialsError> {
         let session = self.app_session.read().await;
         let crypto = session.try_get_crypto()?;
@@ -330,23 +323,6 @@ impl AppState {
         Ok(k)
     }
 
-    pub async fn docker_credential_meta(
-        &self, server_url: &str
-    ) -> Result<Option<(Uuid, String)>, LoadCredentialsError> {
-        let res = sqlx::query!(
-            r#"SELECT
-                c.id as "id: Uuid",
-                c.name
-            FROM
-                credentials c
-                JOIN docker_credentials d
-                    ON d.id = c.id
-            WHERE d.server_url = ?"#,
-            server_url
-        ).fetch_optional(&self.pool).await?;
-        Ok(res.map(|row| (row.id, row.name)))
-    }
-
     pub async fn get_docker_credential(&self, server_url: &str) -> Result<DockerCredential, GetCredentialsError> {
         let app_session = self.app_session.read().await;
         let crypto = app_session.try_get_crypto()?;

src-tauri/tauri.conf.json

@@ -50,7 +50,7 @@
     }
   },
   "productName": "creddy",
-  "version": "0.6.0",
+  "version": "0.5.4",
   "identifier": "creddy",
   "plugins": {},
   "app": {

src/ui/PassphraseInput.svelte

@@ -4,10 +4,10 @@
     export let value = '';
     export let placeholder = '';
     export let autofocus = false;
-    export let show = false;
     let classes = '';
     export {classes as class};
 
+    let show = false;
     let input;
 
     export function focus() {

src/views/Approve.svelte

@@ -7,7 +7,6 @@
     import ShowResponse from './approve/ShowResponse.svelte';
     import Unlock from './Unlock.svelte';
 
-    console.log($appState.currentRequest);
 
     // Extra 50ms so the window can finish disappearing before the redraw
     const rehideDelay = Math.min(5000, $appState.config.rehide_ms + 100);

src/views/ManageCredentials.svelte

@@ -6,8 +6,9 @@
 
     import AwsCredential from './credentials/AwsCredential.svelte';
     import ConfirmDelete from './credentials/ConfirmDelete.svelte';
-    import DockerCredential from './credentials/DockerCredential.svelte';
     import SshKey from './credentials/SshKey.svelte';
+    // import NewSshKey from './credentials/NewSshKey.svelte';
+    // import EditSshKey from './credentials/EditSshKey.svelte';
     import Icon from '../ui/Icon.svelte';
     import Nav from '../ui/Nav.svelte';
 
@@ -15,7 +16,6 @@
     let records = null
     $: awsRecords = (records || []).filter(r => r.credential.type === 'AwsBase');
     $: sshRecords = (records || []).filter(r => r.credential.type === 'Ssh');
-    $: dockerRecords = (records || []).filter(r => r.credential.type === 'Docker');
 
     let defaults = writable({});
     async function loadCreds() {
@@ -47,17 +47,6 @@
         records = records;
     }
 
-    function newDocker() {
-        records.push({
-            id: crypto.randomUUID(),
-            name: null,
-            is_default: false,
-            credential: {type: 'Docker', ServerURL: '', Username: '', Secret: ''},
-            isNew: true,
-        });
-        records = records;
-    }
-
     let confirmDelete;
     function handleDelete(evt) {
         const record = evt.detail;
@@ -128,29 +117,6 @@
         {/if}
     </div>
 
-    <div class="flex flex-col gap-y-4">
-        <div class="divider">
-            <h2 class="text-xl font-bold">Docker credentials</h2>
-        </div>
-
-        {#if dockerRecords.length > 0}
-            {#each dockerRecords as record (record.id)}
-                <DockerCredential {record} on:save={loadCreds} on:delete={handleDelete} />
-            {/each}
-            <button class="btn btn-primary btn-wide mx-auto" on:click={newDocker}>
-                <Icon name="plus-circle-mini" class="size-5" />
-                Add
-            </button>
-        {:else if records !== null}
-            <div class="flex flex-col gap-6 items-center rounded-box border-2 border-dashed border-neutral-content/30 p-6">
-                <div>You have no saved Docker credentials.</div>
-                <button class="btn btn-primary btn-wide mx-auto" on:click={newSsh}>
-                    <Icon name="plus-circle-mini" class="size-5" />
-                    Add
-                </button>
-            </div>
-        {/if}
-    </div>
 </div>
 
 <ConfirmDelete bind:this={confirmDelete} on:confirm={loadCreds} />

src/views/approve/CollectResponse.svelte

@@ -14,7 +14,7 @@
     // Extract executable name from full path
     const client = $appState.currentRequest.client;
     const m = client.exe?.match(/\/([^/]+?$)|\\([^\\]+?$)/);
-    const appName = m ? m[1] || m[2] : '';
+    const appName = m[1] || m[2];
 
     const dispatch = createEventDispatcher();
 
@@ -26,12 +26,6 @@
         };
         dispatch('response');
     }
-
-    const actionDescriptions = {
-        Access: 'access your',
-        Delete: 'delete your',
-        Save: 'create new',
-    };
 </script>
 
 
@@ -58,7 +52,7 @@
         {:else if $appState.currentRequest.type === 'Ssh'}
             {appName ? `"${appName}"` : 'An application'} would like to use your SSH key "{$appState.currentRequest.key_name}".
         {:else if $appState.currentRequest.type === 'Docker'}
-            {appName ? `"${appName}"` : 'An application'} would like to {actionDescriptions[$appState.currentRequest.action]} Docker credentials for <code>{$appState.currentRequest.server_url}</code>.
+            {appName ? `"${appName}"` : 'An application'} would like to use your Docker credentials for <code>{$appState.currentRequest.server_url}</code>.
         {/if}
     </h2>
 
@@ -67,8 +61,6 @@
         <code class="">{@html client.exe ? breakPath(client.exe) : 'Unknown'}</code>
         <div class="text-right">PID:</div>
         <code>{client.pid}</code>
-        <div class="text-right">User:</div>
-        <code>{client.username ?? 'Unknown'}</code>
     </div>
 </div>
 

src/views/credentials/AwsCredential.svelte

@@ -5,19 +5,20 @@
 
     import ErrorAlert from '../../ui/ErrorAlert.svelte';
     import Icon from '../../ui/Icon.svelte';
-    import PassphraseInput from '../../ui/PassphraseInput.svelte';
-
 
     export let record;
     export let defaults;
 
+    import PassphraseInput from '../../ui/PassphraseInput.svelte';
+
+
     const dispatch = createEventDispatcher();
 
     let showDetails = record.isNew ? true : false;
 
     let local = JSON.parse(JSON.stringify(record));
     $: isModified = JSON.stringify(local) !== JSON.stringify(record);
-
+    
     // explicitly subscribe to updates to `default`, so that we can update
     // our local copy even if the component hasn't been recreated
     // (sadly we can't use a reactive binding because reasons I guess)
@@ -30,7 +31,7 @@
         showDetails = false;
     }
 
-
+    
 </script>
 
 

src/views/credentials/ConfirmDelete.svelte

@@ -26,12 +26,9 @@
         if (record.credential.type === 'AwsBase') {
             return 'AWS credential';
         }
-        else if (record.credential.type === 'Ssh') {
+        if (record.credential.type === 'Ssh') {
             return 'SSH key';
         }
-        else {
-            return `${record.credential.type} credential`;
-        }
     }
 </script>
 

src/views/credentials/DockerCredential.svelte

@@ -1,112 +0,0 @@
-<script>
-
-    import { createEventDispatcher } from 'svelte';
-    import { fade, slide } from 'svelte/transition';
-    import { invoke } from '@tauri-apps/api/core';
-
-    import ErrorAlert from '../../ui/ErrorAlert.svelte';
-    import Icon from '../../ui/Icon.svelte';
-    import PassphraseInput from '../../ui/PassphraseInput.svelte';
-
-
-    export let record;
-
-    let local = JSON.parse(JSON.stringify(record));
-    $: isModified = JSON.stringify(local) !== JSON.stringify(record);
-    let showDetails = record?.isNew;
-
-    let alert;
-    const dispatch = createEventDispatcher();
-    async function saveCredential() {
-        await invoke('save_credential', {record: local});
-        dispatch('save', local);
-        showDetails = false;
-    }
-</script>
-
-<div class="rounded-box space-y-4 bg-base-200">
-    <div class="flex items-center px-6 py-4 gap-x-4">
-        {#if !record.isNew}
-            {#if showDetails}
-                <input
-                    type="text"
-                    class="input input-bordered bg-transparent text-lg font-bold grow"
-                    bind:value={local.name}
-                >
-            {:else}
-                <h3 class="text-lg font-bold break-all">
-                    {record.name}
-                </h3>
-            {/if}
-        {/if}
-
-        <div class="join ml-auto">
-            <button
-                type="button"
-                class="btn btn-outline join-item"
-                on:click={() => showDetails = !showDetails}
-            >
-                <Icon name="pencil" class="size-6" />
-            </button>
-            <button
-                type="button"
-                class="btn btn-outline btn-error join-item"
-                on:click={() => dispatch('delete', record)}
-            >
-                <Icon name="trash" class="size-6" />
-            </button>
-        </div>
-    </div>
-
-    {#if showDetails}
-        <form
-            transition:slide|local={{duration: 200}}
-            class=" px-6 pb-4 space-y-4"
-            on:submit|preventDefault={() => alert.run(saveCredential)}
-        >
-            <ErrorAlert bind:this={alert} />
-
-            <div class="grid grid-cols-[auto_1fr] items-center gap-4">
-                {#if record.isNew}
-                    <span class="justify-self-end">Name</span>
-                    <input
-                        type="text"
-                        class="input input-bordered bg-transparent"
-                        bind:value={local.name}
-                    >
-                {/if}
-
-                <span class="justify-self-end">Server URL</span>
-                <input
-                    type="text"
-                    class="input input-bordered font-mono bg-transparent"
-                    bind:value={local.credential.ServerURL}
-                >
-
-                <span class="justify-self-end">Username</span>
-                <input
-                    type="text"
-                    class="input input-bordered font-mono bg-transparent"
-                    bind:value={local.credential.Username}
-                >
-
-                <span>Password</span>
-                <div class="font-mono">
-                    <PassphraseInput class="bg-transparent" bind:value={local.credential.Secret} />
-                </div>
-            </div>
-
-            <div class="flex justify-end">
-                {#if isModified}
-                    <button
-                        transition:fade={{duration: 100}}
-                        type="submit"
-                        class="btn btn-primary"
-                    >
-                        Save
-                    </button>
-                {/if}
-            </div>
-        </form>
-    {/if}
-</div>

src/views/passphrase/EnterPassphrase.svelte

@@ -14,7 +14,6 @@
 
     const dispatch = createEventDispatcher();
 
-    let showPassphrase = false;
     let alert;
     let saving = false;
     let passphrase = '';
@@ -53,6 +52,7 @@
         try {
             await alert.run(async () => {
                 await invoke('set_passphrase', {passphrase})
+                throw('something bad happened');
                 $appState.sessionStatus = 'unlocked';
                 dispatch('save');
             });
@@ -73,7 +73,6 @@
         </div>
         <PassphraseInput
             bind:value={passphrase}
-            bind:show={showPassphrase}
             on:input={onInput}
             placeholder="correct horse battery staple"
         />
@@ -85,7 +84,6 @@
         </div>
         <PassphraseInput
             bind:value={confirmPassphrase}
-            bind:show={showPassphrase}
             on:input={onInput} on:change={onChange}
             placeholder="correct horse battery staple"
         />