Replace NIDs in `AssigneeInput` with found alias. — radicle-desktop

Add alias tauri command
- Returns either null or string for a lookup of an alias.

 pub fn config(ctx: tauri::State<AppState>) -> Config {
     ctx.config()
 }
 #[tauri::command]
 pub fn alias(ctx: tauri::State<AppState>, nid: NodeId) -> Option<radicle::node::Alias> {
     ctx.alias(nid)
 }

             thread::create_issue_comment,
             thread::create_patch_comment,
             profile::config,
             profile::alias,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

             seeding_policy: p.config.node.seeding_policy,
         }
     }
     fn alias(&self, nid: NodeId) -> Option<radicle::node::Alias> {
         let p = self.profile();
         let aliases = p.aliases();
         aliases.alias(&nid)
     }
 }
 #[cfg(test)]

 <script lang="ts">
   import type { Author } from "@bindings/cob/Author";
   import { authorForNodeId, parseNodeId } from "@app/lib/utils";
   import {
     authorForNodeId,
     parseNodeId,
     publicKeyFromDid,
   } from "@app/lib/utils";
   import { invoke } from "@app/lib/invoke";
   import Icon from "@app/components/Icon.svelte";
   import NodeId from "@app/components/NodeId.svelte";

     allowedToEdit: boolean;
     assignees: Author[];
     submitInProgress: boolean;
     save: (updatedAssignees: string[]) => void;
     save: (updatedAssignees: Author[]) => void;
   }
   const {
     allowedToEdit = false,
     assignees,
     assignees = $bindable(),
     submitInProgress = false,
     save,
   }: Props = $props();

 use radicle::node::NodeId;
 use radicle_types::config::Config;
 use radicle_types::traits::Profile;

 use radicle::node::{AliasStore, NodeId};
 use crate::config::Config;
 pub mod auth;

     }
   });
   function addAssignee() {
   async function addAssignee() {
     if (valid && assignee) {
       updatedAssignees = [...updatedAssignees, { did: assignee }];
       const alias = await invoke<string | null>("alias", {
         nid: publicKeyFromDid(assignee),
       });
       updatedAssignees = [
         ...updatedAssignees,
         { did: assignee, alias: alias ?? undefined },
       ];
       inputValue = "";
       save($state.snapshot(updatedAssignees.map(x => x.did)));
       save($state.snapshot(updatedAssignees));
       showInput = false;
     }
   }

 <script lang="ts">
   import type { Author } from "@bindings/cob/Author";
   import type { Config } from "@bindings/config/Config";
   import type { Issue } from "@bindings/cob/issue/Issue";
   import type { RepoInfo } from "@bindings/repo/RepoInfo";

   const embeds: { name: string; content: string }[] = [];
   let assignees: string[] = $state([]);
   let assignees: Author[] = $state([]);
   let labels: string[] = $state([]);
   async function createIssue() {

         title,
         description,
         labels: $state.snapshot(labels),
         assignees: $state.snapshot(assignees),
         assignees: $state.snapshot(assignees.map(a => a.did)),
         embeds,
       },
       opts: { announce: $nodeRunning && $announce },

         <div class="metadata-section" style:flex="1">
           <AssigneeInput
             allowedToEdit={true}
             assignees={assignees.map(assignee => {
               return { did: assignee };
             })}
             bind:assignees
             submitInProgress={false}
             save={newAssignees => {
               assignees = newAssignees;

     }
   }
   async function saveAssignees(assignees: string[]) {
   async function saveAssignees(assignees: Author[]) {
     try {
       assigneesSaveInProgress = true;
       await invoke("edit_issue", {

         cobId: issue.id,
         action: {
           type: "assign",
           assignees,
           assignees: assignees.map(a => a.did),
         },
         opts: { announce: $nodeRunning && $announce },
       });