feat(profile): add secure profile persistence and IPC
这个提交存在于:
父节点
6a1eeabea8
当前提交
02fd25afaf
共有 4 个文件被更改,包括 813 次插入 和 3 次删除
|
|
@ -1,9 +1,11 @@
|
|||
mod profiles;
|
||||
|
||||
use std::{path::Path, sync::Mutex, time::Duration};
|
||||
|
||||
use rusqlite::{Connection, OptionalExtension, params};
|
||||
use thiserror::Error;
|
||||
|
||||
pub const CURRENT_SCHEMA_VERSION: u32 = 1;
|
||||
pub const CURRENT_SCHEMA_VERSION: u32 = 2;
|
||||
|
||||
pub struct ApplicationDatabase {
|
||||
store: Mutex<ProfileMessageStore>,
|
||||
|
|
@ -16,6 +18,13 @@ impl ApplicationDatabase {
|
|||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn in_memory() -> Result<Self, DatabaseError> {
|
||||
Ok(Self {
|
||||
store: Mutex::new(ProfileMessageStore::in_memory()?),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn schema_version(&self) -> Result<u32, DatabaseError> {
|
||||
self.store
|
||||
.lock()
|
||||
|
|
@ -143,6 +152,38 @@ fn migrate(connection: &mut Connection) -> Result<(), DatabaseError> {
|
|||
transaction.commit()?;
|
||||
}
|
||||
|
||||
if found <= 1 {
|
||||
let transaction = connection.transaction()?;
|
||||
transaction.execute_batch(
|
||||
"
|
||||
CREATE TABLE connection_profiles (
|
||||
id TEXT PRIMARY KEY NOT NULL,
|
||||
display_name TEXT NOT NULL CHECK(length(display_name) BETWEEN 1 AND 80),
|
||||
role TEXT NOT NULL CHECK(role IN ('companion', 'operations', 'general')),
|
||||
base_url TEXT NOT NULL,
|
||||
event_stream_url TEXT,
|
||||
authentication_type TEXT NOT NULL CHECK(authentication_type IN ('device-token', 'api-key')),
|
||||
credential_reference TEXT,
|
||||
allow_insecure_http INTEGER NOT NULL DEFAULT 0 CHECK(allow_insecure_http IN (0, 1)),
|
||||
pinned_certificate_fingerprint TEXT,
|
||||
auto_connect_slot TEXT CHECK(auto_connect_slot IS NULL OR auto_connect_slot IN ('companion', 'operations')),
|
||||
auto_connect INTEGER NOT NULL DEFAULT 0 CHECK(auto_connect IN (0, 1)),
|
||||
server_instance_id TEXT,
|
||||
server_version TEXT,
|
||||
protocol_version TEXT,
|
||||
local_tool_policy_id TEXT,
|
||||
last_connected_at TEXT,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX connection_profiles_role_idx
|
||||
ON connection_profiles(role);
|
||||
PRAGMA user_version = 2;
|
||||
",
|
||||
)?;
|
||||
transaction.commit()?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -154,6 +195,10 @@ pub enum DatabaseError {
|
|||
UnsupportedSchemaVersion { found: u32, supported: u32 },
|
||||
#[error("database state lock is unavailable")]
|
||||
LockPoisoned,
|
||||
#[error("database contains invalid profile data")]
|
||||
InvalidStoredProfile,
|
||||
#[error("connection profile was not found")]
|
||||
ProfileNotFound,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -196,6 +241,62 @@ mod tests {
|
|||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn migrates_v1_to_v2_without_losing_messages() {
|
||||
let directory = tempfile::tempdir().expect("temporary directory");
|
||||
let path = directory.path().join("v1.sqlite3");
|
||||
let connection = Connection::open(&path).expect("create v1 database");
|
||||
connection
|
||||
.execute_batch(
|
||||
"
|
||||
CREATE TABLE messages (
|
||||
profile_id TEXT NOT NULL,
|
||||
server_instance_id TEXT NOT NULL,
|
||||
conversation_id TEXT NOT NULL,
|
||||
message_id TEXT NOT NULL,
|
||||
content TEXT NOT NULL,
|
||||
PRIMARY KEY (profile_id, server_instance_id, conversation_id, message_id)
|
||||
);
|
||||
INSERT INTO messages (
|
||||
profile_id,
|
||||
server_instance_id,
|
||||
conversation_id,
|
||||
message_id,
|
||||
content
|
||||
) VALUES (
|
||||
'profile-a',
|
||||
'server-a',
|
||||
'conversation-a',
|
||||
'message-a',
|
||||
'preserved'
|
||||
);
|
||||
PRAGMA user_version = 1;
|
||||
",
|
||||
)
|
||||
.expect("create v1 schema");
|
||||
drop(connection);
|
||||
|
||||
let store = ProfileMessageStore::open(&path).expect("migrate database");
|
||||
assert_eq!(store.schema_version().expect("schema version"), 2);
|
||||
assert_eq!(
|
||||
store
|
||||
.message_content("profile-a", "server-a", "conversation-a", "message-a")
|
||||
.expect("query preserved message")
|
||||
.as_deref(),
|
||||
Some("preserved")
|
||||
);
|
||||
let profile_table_count: u32 = store
|
||||
.connection
|
||||
.query_row(
|
||||
"SELECT COUNT(*) FROM sqlite_master
|
||||
WHERE type = 'table' AND name = 'connection_profiles'",
|
||||
[],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.expect("query profile table");
|
||||
assert_eq!(profile_table_count, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_database_from_a_newer_schema_version() {
|
||||
let directory = tempfile::tempdir().expect("temporary directory");
|
||||
|
|
@ -209,7 +310,7 @@ mod tests {
|
|||
assert!(matches!(
|
||||
ProfileMessageStore::open(path),
|
||||
Err(DatabaseError::UnsupportedSchemaVersion {
|
||||
found: 2,
|
||||
found: 3,
|
||||
supported: CURRENT_SCHEMA_VERSION
|
||||
})
|
||||
));
|
||||
|
|
|
|||
349
src-tauri/src/database/profiles.rs
普通文件
349
src-tauri/src/database/profiles.rs
普通文件
|
|
@ -0,0 +1,349 @@
|
|||
use desktop_protocol::{ActiveSlotKind, AstrBotProfileRole, AuthenticationType, ConnectionProfile};
|
||||
use rusqlite::{Row, params};
|
||||
|
||||
use super::{ApplicationDatabase, DatabaseError, ProfileMessageStore};
|
||||
|
||||
const PROFILE_COLUMNS: &str = "
|
||||
id,
|
||||
display_name,
|
||||
role,
|
||||
base_url,
|
||||
event_stream_url,
|
||||
authentication_type,
|
||||
credential_reference,
|
||||
allow_insecure_http,
|
||||
pinned_certificate_fingerprint,
|
||||
auto_connect_slot,
|
||||
auto_connect,
|
||||
server_instance_id,
|
||||
server_version,
|
||||
protocol_version,
|
||||
local_tool_policy_id,
|
||||
last_connected_at,
|
||||
created_at,
|
||||
updated_at
|
||||
";
|
||||
|
||||
impl ApplicationDatabase {
|
||||
pub fn list_profiles(&self) -> Result<Vec<ConnectionProfile>, DatabaseError> {
|
||||
self.store
|
||||
.lock()
|
||||
.map_err(|_| DatabaseError::LockPoisoned)?
|
||||
.list_profiles()
|
||||
}
|
||||
|
||||
pub fn profile(&self, id: &str) -> Result<Option<ConnectionProfile>, DatabaseError> {
|
||||
self.store
|
||||
.lock()
|
||||
.map_err(|_| DatabaseError::LockPoisoned)?
|
||||
.profile(id)
|
||||
}
|
||||
|
||||
pub fn create_profile(&self, profile: &ConnectionProfile) -> Result<(), DatabaseError> {
|
||||
self.store
|
||||
.lock()
|
||||
.map_err(|_| DatabaseError::LockPoisoned)?
|
||||
.create_profile(profile)
|
||||
}
|
||||
|
||||
pub fn update_profile(&self, profile: &ConnectionProfile) -> Result<(), DatabaseError> {
|
||||
self.store
|
||||
.lock()
|
||||
.map_err(|_| DatabaseError::LockPoisoned)?
|
||||
.update_profile(profile)
|
||||
}
|
||||
|
||||
pub fn delete_profile(&self, id: &str) -> Result<(), DatabaseError> {
|
||||
self.store
|
||||
.lock()
|
||||
.map_err(|_| DatabaseError::LockPoisoned)?
|
||||
.delete_profile(id)
|
||||
}
|
||||
}
|
||||
|
||||
impl ProfileMessageStore {
|
||||
fn list_profiles(&self) -> Result<Vec<ConnectionProfile>, DatabaseError> {
|
||||
let mut statement = self.connection.prepare(&format!(
|
||||
"SELECT {PROFILE_COLUMNS}
|
||||
FROM connection_profiles
|
||||
ORDER BY display_name COLLATE NOCASE, id"
|
||||
))?;
|
||||
let mut rows = statement.query([])?;
|
||||
let mut profiles = Vec::new();
|
||||
while let Some(row) = rows.next()? {
|
||||
profiles.push(profile_from_row(row)?);
|
||||
}
|
||||
Ok(profiles)
|
||||
}
|
||||
|
||||
fn profile(&self, id: &str) -> Result<Option<ConnectionProfile>, DatabaseError> {
|
||||
let mut statement = self.connection.prepare(&format!(
|
||||
"SELECT {PROFILE_COLUMNS}
|
||||
FROM connection_profiles
|
||||
WHERE id = ?1"
|
||||
))?;
|
||||
let mut rows = statement.query(params![id])?;
|
||||
match rows.next()? {
|
||||
Some(row) => Ok(Some(profile_from_row(row)?)),
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
fn create_profile(&self, profile: &ConnectionProfile) -> Result<(), DatabaseError> {
|
||||
self.connection.execute(
|
||||
"
|
||||
INSERT INTO connection_profiles (
|
||||
id,
|
||||
display_name,
|
||||
role,
|
||||
base_url,
|
||||
event_stream_url,
|
||||
authentication_type,
|
||||
credential_reference,
|
||||
allow_insecure_http,
|
||||
pinned_certificate_fingerprint,
|
||||
auto_connect_slot,
|
||||
auto_connect,
|
||||
server_instance_id,
|
||||
server_version,
|
||||
protocol_version,
|
||||
local_tool_policy_id,
|
||||
last_connected_at,
|
||||
created_at,
|
||||
updated_at
|
||||
) VALUES (
|
||||
?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9,
|
||||
?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18
|
||||
)
|
||||
",
|
||||
params![
|
||||
profile.id,
|
||||
profile.display_name,
|
||||
role_to_str(profile.role),
|
||||
profile.base_url,
|
||||
profile.event_stream_url,
|
||||
authentication_to_str(profile.authentication_type),
|
||||
profile.credential_reference,
|
||||
profile.allow_insecure_http,
|
||||
profile.pinned_certificate_fingerprint,
|
||||
profile.auto_connect_slot.map(slot_to_str),
|
||||
profile.auto_connect,
|
||||
profile.server_instance_id,
|
||||
profile.server_version,
|
||||
profile.protocol_version,
|
||||
profile.local_tool_policy_id,
|
||||
profile.last_connected_at,
|
||||
profile.created_at,
|
||||
profile.updated_at,
|
||||
],
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn update_profile(&self, profile: &ConnectionProfile) -> Result<(), DatabaseError> {
|
||||
let changed = self.connection.execute(
|
||||
"
|
||||
UPDATE connection_profiles
|
||||
SET display_name = ?2,
|
||||
role = ?3,
|
||||
base_url = ?4,
|
||||
event_stream_url = ?5,
|
||||
authentication_type = ?6,
|
||||
credential_reference = ?7,
|
||||
allow_insecure_http = ?8,
|
||||
pinned_certificate_fingerprint = ?9,
|
||||
auto_connect_slot = ?10,
|
||||
auto_connect = ?11,
|
||||
server_instance_id = ?12,
|
||||
server_version = ?13,
|
||||
protocol_version = ?14,
|
||||
local_tool_policy_id = ?15,
|
||||
last_connected_at = ?16,
|
||||
created_at = ?17,
|
||||
updated_at = ?18
|
||||
WHERE id = ?1
|
||||
",
|
||||
params![
|
||||
profile.id,
|
||||
profile.display_name,
|
||||
role_to_str(profile.role),
|
||||
profile.base_url,
|
||||
profile.event_stream_url,
|
||||
authentication_to_str(profile.authentication_type),
|
||||
profile.credential_reference,
|
||||
profile.allow_insecure_http,
|
||||
profile.pinned_certificate_fingerprint,
|
||||
profile.auto_connect_slot.map(slot_to_str),
|
||||
profile.auto_connect,
|
||||
profile.server_instance_id,
|
||||
profile.server_version,
|
||||
profile.protocol_version,
|
||||
profile.local_tool_policy_id,
|
||||
profile.last_connected_at,
|
||||
profile.created_at,
|
||||
profile.updated_at,
|
||||
],
|
||||
)?;
|
||||
if changed == 0 {
|
||||
return Err(DatabaseError::ProfileNotFound);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn delete_profile(&self, id: &str) -> Result<(), DatabaseError> {
|
||||
if self
|
||||
.connection
|
||||
.execute("DELETE FROM connection_profiles WHERE id = ?1", params![id])?
|
||||
== 0
|
||||
{
|
||||
return Err(DatabaseError::ProfileNotFound);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn profile_from_row(row: &Row<'_>) -> Result<ConnectionProfile, DatabaseError> {
|
||||
let role = match row.get::<_, String>(2)?.as_str() {
|
||||
"companion" => AstrBotProfileRole::Companion,
|
||||
"operations" => AstrBotProfileRole::Operations,
|
||||
"general" => AstrBotProfileRole::General,
|
||||
_ => return Err(DatabaseError::InvalidStoredProfile),
|
||||
};
|
||||
let authentication_type = match row.get::<_, String>(5)?.as_str() {
|
||||
"device-token" => AuthenticationType::DeviceToken,
|
||||
"api-key" => AuthenticationType::ApiKey,
|
||||
_ => return Err(DatabaseError::InvalidStoredProfile),
|
||||
};
|
||||
let auto_connect_slot = match row.get::<_, Option<String>>(9)?.as_deref() {
|
||||
Some("companion") => Some(ActiveSlotKind::Companion),
|
||||
Some("operations") => Some(ActiveSlotKind::Operations),
|
||||
Some(_) => return Err(DatabaseError::InvalidStoredProfile),
|
||||
None => None,
|
||||
};
|
||||
|
||||
Ok(ConnectionProfile {
|
||||
id: row.get(0)?,
|
||||
display_name: row.get(1)?,
|
||||
role,
|
||||
base_url: row.get(3)?,
|
||||
event_stream_url: row.get(4)?,
|
||||
authentication_type,
|
||||
credential_reference: row.get(6)?,
|
||||
allow_insecure_http: row.get(7)?,
|
||||
pinned_certificate_fingerprint: row.get(8)?,
|
||||
auto_connect_slot,
|
||||
auto_connect: row.get(10)?,
|
||||
server_instance_id: row.get(11)?,
|
||||
server_version: row.get(12)?,
|
||||
protocol_version: row.get(13)?,
|
||||
local_tool_policy_id: row.get(14)?,
|
||||
last_connected_at: row.get(15)?,
|
||||
created_at: row.get(16)?,
|
||||
updated_at: row.get(17)?,
|
||||
})
|
||||
}
|
||||
|
||||
fn role_to_str(role: AstrBotProfileRole) -> &'static str {
|
||||
match role {
|
||||
AstrBotProfileRole::Companion => "companion",
|
||||
AstrBotProfileRole::Operations => "operations",
|
||||
AstrBotProfileRole::General => "general",
|
||||
}
|
||||
}
|
||||
|
||||
fn authentication_to_str(authentication_type: AuthenticationType) -> &'static str {
|
||||
match authentication_type {
|
||||
AuthenticationType::DeviceToken => "device-token",
|
||||
AuthenticationType::ApiKey => "api-key",
|
||||
}
|
||||
}
|
||||
|
||||
fn slot_to_str(slot: ActiveSlotKind) -> &'static str {
|
||||
match slot {
|
||||
ActiveSlotKind::Companion => "companion",
|
||||
ActiveSlotKind::Operations => "operations",
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn profile(index: usize) -> ConnectionProfile {
|
||||
ConnectionProfile {
|
||||
id: format!("00000000-0000-4000-8000-{index:012}"),
|
||||
display_name: format!("Profile {index}"),
|
||||
role: AstrBotProfileRole::General,
|
||||
base_url: format!("https://example-{index}.test/"),
|
||||
event_stream_url: None,
|
||||
authentication_type: AuthenticationType::DeviceToken,
|
||||
credential_reference: None,
|
||||
allow_insecure_http: false,
|
||||
pinned_certificate_fingerprint: None,
|
||||
auto_connect_slot: None,
|
||||
auto_connect: false,
|
||||
server_instance_id: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
local_tool_policy_id: None,
|
||||
last_connected_at: None,
|
||||
created_at: "2026-07-18T00:00:00Z".into(),
|
||||
updated_at: "2026-07-18T00:00:00Z".into(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stores_lists_updates_and_deletes_five_profiles() {
|
||||
let database = ApplicationDatabase::in_memory().expect("database");
|
||||
for index in 0..5 {
|
||||
database
|
||||
.create_profile(&profile(index))
|
||||
.expect("create profile");
|
||||
}
|
||||
assert_eq!(database.list_profiles().expect("list profiles").len(), 5);
|
||||
|
||||
let mut updated = database
|
||||
.profile(&profile(2).id)
|
||||
.expect("read profile")
|
||||
.expect("existing profile");
|
||||
updated.display_name = "Updated Profile".into();
|
||||
updated.updated_at = "2026-07-18T01:00:00Z".into();
|
||||
database.update_profile(&updated).expect("update profile");
|
||||
assert_eq!(
|
||||
database
|
||||
.profile(&updated.id)
|
||||
.expect("read updated profile")
|
||||
.expect("existing profile")
|
||||
.display_name,
|
||||
"Updated Profile"
|
||||
);
|
||||
|
||||
database
|
||||
.delete_profile(&updated.id)
|
||||
.expect("delete profile");
|
||||
assert_eq!(database.list_profiles().expect("list profiles").len(), 4);
|
||||
assert!(matches!(
|
||||
database.delete_profile(&updated.id),
|
||||
Err(DatabaseError::ProfileNotFound)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn profile_metadata_persists_after_reopening_database() {
|
||||
let directory = tempfile::tempdir().expect("temporary directory");
|
||||
let path = directory.path().join("profiles.sqlite3");
|
||||
let expected = profile(7);
|
||||
|
||||
{
|
||||
let store = ProfileMessageStore::open(&path).expect("open database");
|
||||
store.create_profile(&expected).expect("create profile");
|
||||
}
|
||||
|
||||
let reopened = ProfileMessageStore::open(&path).expect("reopen database");
|
||||
let actual = reopened
|
||||
.profile(&expected.id)
|
||||
.expect("read profile")
|
||||
.expect("persisted profile");
|
||||
assert_eq!(actual, expected);
|
||||
}
|
||||
}
|
||||
|
|
@ -3,6 +3,7 @@ pub mod diagnostics;
|
|||
pub mod file_transfer;
|
||||
pub mod logging;
|
||||
pub mod networking;
|
||||
pub mod profiles;
|
||||
pub mod secure_store;
|
||||
pub mod windows;
|
||||
|
||||
|
|
@ -85,7 +86,13 @@ pub fn run() {
|
|||
let _ = window.hide();
|
||||
}
|
||||
})
|
||||
.invoke_handler(tauri::generate_handler![bootstrap_status])
|
||||
.invoke_handler(tauri::generate_handler![
|
||||
bootstrap_status,
|
||||
profiles::list_connection_profiles,
|
||||
profiles::create_connection_profile,
|
||||
profiles::update_connection_profile,
|
||||
profiles::delete_connection_profile,
|
||||
])
|
||||
.run(tauri::generate_context!())
|
||||
.expect("failed to run AstrBot Desktop");
|
||||
}
|
||||
|
|
|
|||
353
src-tauri/src/profiles.rs
普通文件
353
src-tauri/src/profiles.rs
普通文件
|
|
@ -0,0 +1,353 @@
|
|||
use desktop_protocol::{AstrBotProfileRole, AuthenticationType, ConnectionProfile};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use time::{OffsetDateTime, format_description::well_known::Rfc3339};
|
||||
use url::Url;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::database::{ApplicationDatabase, DatabaseError};
|
||||
|
||||
const MAX_DISPLAY_NAME_CHARS: usize = 80;
|
||||
const MAX_URL_CHARS: usize = 2048;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub struct ConnectionProfileInput {
|
||||
pub display_name: String,
|
||||
pub role: AstrBotProfileRole,
|
||||
pub base_url: String,
|
||||
#[serde(default)]
|
||||
pub event_stream_url: Option<String>,
|
||||
pub authentication_type: AuthenticationType,
|
||||
#[serde(default)]
|
||||
pub allow_insecure_http: bool,
|
||||
#[serde(default)]
|
||||
pub pinned_certificate_fingerprint: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub struct UpdateConnectionProfileRequest {
|
||||
pub id: String,
|
||||
#[serde(flatten)]
|
||||
pub profile: ConnectionProfileInput,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ProfileCommandError {
|
||||
code: &'static str,
|
||||
message: &'static str,
|
||||
}
|
||||
|
||||
impl ProfileCommandError {
|
||||
fn validation(message: &'static str) -> Self {
|
||||
Self {
|
||||
code: "validationFailed",
|
||||
message,
|
||||
}
|
||||
}
|
||||
|
||||
fn database(error: DatabaseError) -> Self {
|
||||
match error {
|
||||
DatabaseError::ProfileNotFound => Self {
|
||||
code: "notFound",
|
||||
message: "The connection profile no longer exists.",
|
||||
},
|
||||
_ => Self {
|
||||
code: "databaseUnavailable",
|
||||
message: "The local profile database is unavailable.",
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
pub fn list_connection_profiles(
|
||||
database: tauri::State<'_, ApplicationDatabase>,
|
||||
) -> Result<Vec<ConnectionProfile>, ProfileCommandError> {
|
||||
list_profiles(&database)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
pub fn create_connection_profile(
|
||||
database: tauri::State<'_, ApplicationDatabase>,
|
||||
request: ConnectionProfileInput,
|
||||
) -> Result<ConnectionProfile, ProfileCommandError> {
|
||||
create_profile(&database, request)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
pub fn update_connection_profile(
|
||||
database: tauri::State<'_, ApplicationDatabase>,
|
||||
request: UpdateConnectionProfileRequest,
|
||||
) -> Result<ConnectionProfile, ProfileCommandError> {
|
||||
update_profile(&database, request)
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
pub fn delete_connection_profile(
|
||||
database: tauri::State<'_, ApplicationDatabase>,
|
||||
id: String,
|
||||
) -> Result<(), ProfileCommandError> {
|
||||
delete_profile(&database, &id)
|
||||
}
|
||||
|
||||
fn list_profiles(
|
||||
database: &ApplicationDatabase,
|
||||
) -> Result<Vec<ConnectionProfile>, ProfileCommandError> {
|
||||
database
|
||||
.list_profiles()
|
||||
.map_err(ProfileCommandError::database)
|
||||
}
|
||||
|
||||
fn create_profile(
|
||||
database: &ApplicationDatabase,
|
||||
request: ConnectionProfileInput,
|
||||
) -> Result<ConnectionProfile, ProfileCommandError> {
|
||||
let normalized = normalize_input(request)?;
|
||||
let now = timestamp()?;
|
||||
let profile = ConnectionProfile {
|
||||
id: Uuid::new_v4().to_string(),
|
||||
display_name: normalized.display_name,
|
||||
role: normalized.role,
|
||||
base_url: normalized.base_url,
|
||||
event_stream_url: normalized.event_stream_url,
|
||||
authentication_type: normalized.authentication_type,
|
||||
credential_reference: None,
|
||||
allow_insecure_http: normalized.allow_insecure_http,
|
||||
pinned_certificate_fingerprint: normalized.pinned_certificate_fingerprint,
|
||||
auto_connect_slot: None,
|
||||
auto_connect: false,
|
||||
server_instance_id: None,
|
||||
server_version: None,
|
||||
protocol_version: None,
|
||||
local_tool_policy_id: None,
|
||||
last_connected_at: None,
|
||||
created_at: now.clone(),
|
||||
updated_at: now,
|
||||
};
|
||||
database
|
||||
.create_profile(&profile)
|
||||
.map_err(ProfileCommandError::database)?;
|
||||
Ok(profile)
|
||||
}
|
||||
|
||||
fn update_profile(
|
||||
database: &ApplicationDatabase,
|
||||
request: UpdateConnectionProfileRequest,
|
||||
) -> Result<ConnectionProfile, ProfileCommandError> {
|
||||
validate_id(&request.id)?;
|
||||
let normalized = normalize_input(request.profile)?;
|
||||
let mut profile = database
|
||||
.profile(&request.id)
|
||||
.map_err(ProfileCommandError::database)?
|
||||
.ok_or_else(|| ProfileCommandError::database(DatabaseError::ProfileNotFound))?;
|
||||
|
||||
profile.display_name = normalized.display_name;
|
||||
profile.role = normalized.role;
|
||||
profile.base_url = normalized.base_url;
|
||||
profile.event_stream_url = normalized.event_stream_url;
|
||||
profile.authentication_type = normalized.authentication_type;
|
||||
profile.allow_insecure_http = normalized.allow_insecure_http;
|
||||
profile.pinned_certificate_fingerprint = normalized.pinned_certificate_fingerprint;
|
||||
profile.updated_at = timestamp()?;
|
||||
|
||||
database
|
||||
.update_profile(&profile)
|
||||
.map_err(ProfileCommandError::database)?;
|
||||
Ok(profile)
|
||||
}
|
||||
|
||||
fn delete_profile(database: &ApplicationDatabase, id: &str) -> Result<(), ProfileCommandError> {
|
||||
validate_id(id)?;
|
||||
database
|
||||
.delete_profile(id)
|
||||
.map_err(ProfileCommandError::database)
|
||||
}
|
||||
|
||||
fn normalize_input(
|
||||
request: ConnectionProfileInput,
|
||||
) -> Result<ConnectionProfileInput, ProfileCommandError> {
|
||||
let display_name = request.display_name.trim().to_owned();
|
||||
if display_name.is_empty()
|
||||
|| display_name.chars().count() > MAX_DISPLAY_NAME_CHARS
|
||||
|| display_name.chars().any(char::is_control)
|
||||
{
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Display name must contain 1 to 80 visible characters.",
|
||||
));
|
||||
}
|
||||
|
||||
let base_url = normalize_url(&request.base_url, request.allow_insecure_http)?;
|
||||
let event_stream_url = request
|
||||
.event_stream_url
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(|value| normalize_url(value, request.allow_insecure_http))
|
||||
.transpose()?;
|
||||
let pinned_certificate_fingerprint =
|
||||
normalize_fingerprint(request.pinned_certificate_fingerprint)?;
|
||||
|
||||
Ok(ConnectionProfileInput {
|
||||
display_name,
|
||||
role: request.role,
|
||||
base_url,
|
||||
event_stream_url,
|
||||
authentication_type: request.authentication_type,
|
||||
allow_insecure_http: request.allow_insecure_http,
|
||||
pinned_certificate_fingerprint,
|
||||
})
|
||||
}
|
||||
|
||||
fn normalize_url(value: &str, allow_insecure_http: bool) -> Result<String, ProfileCommandError> {
|
||||
let value = value.trim();
|
||||
if value.is_empty() || value.chars().count() > MAX_URL_CHARS {
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Connection URL is empty or too long.",
|
||||
));
|
||||
}
|
||||
|
||||
let mut url = Url::parse(value)
|
||||
.map_err(|_| ProfileCommandError::validation("Connection URL is invalid."))?;
|
||||
if !matches!(url.scheme(), "http" | "https") || url.host_str().is_none() {
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Connection URL must use HTTP or HTTPS and include a host.",
|
||||
));
|
||||
}
|
||||
if !url.username().is_empty() || url.password().is_some() {
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Credentials must not be embedded in a connection URL.",
|
||||
));
|
||||
}
|
||||
if url.query().is_some() || url.fragment().is_some() {
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Connection URLs must not contain query parameters or fragments.",
|
||||
));
|
||||
}
|
||||
if url.scheme() == "http" && !allow_insecure_http {
|
||||
return Err(ProfileCommandError::validation(
|
||||
"HTTP requires explicit insecure-transport approval.",
|
||||
));
|
||||
}
|
||||
url.set_fragment(None);
|
||||
Ok(url.to_string())
|
||||
}
|
||||
|
||||
fn normalize_fingerprint(value: Option<String>) -> Result<Option<String>, ProfileCommandError> {
|
||||
let Some(value) = value else {
|
||||
return Ok(None);
|
||||
};
|
||||
let normalized = value
|
||||
.trim()
|
||||
.chars()
|
||||
.filter(|character| *character != ':')
|
||||
.flat_map(char::to_uppercase)
|
||||
.collect::<String>();
|
||||
if normalized.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
if normalized.len() != 64
|
||||
|| !normalized
|
||||
.chars()
|
||||
.all(|character| character.is_ascii_hexdigit())
|
||||
{
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Pinned certificate fingerprint must be a SHA-256 hex value.",
|
||||
));
|
||||
}
|
||||
Ok(Some(normalized))
|
||||
}
|
||||
|
||||
fn validate_id(id: &str) -> Result<(), ProfileCommandError> {
|
||||
if Uuid::parse_str(id).is_err() {
|
||||
return Err(ProfileCommandError::validation(
|
||||
"Connection profile ID is invalid.",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn timestamp() -> Result<String, ProfileCommandError> {
|
||||
OffsetDateTime::now_utc()
|
||||
.format(&Rfc3339)
|
||||
.map_err(|_| ProfileCommandError {
|
||||
code: "clockUnavailable",
|
||||
message: "The system clock could not produce a profile timestamp.",
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn request(base_url: &str) -> ConnectionProfileInput {
|
||||
ConnectionProfileInput {
|
||||
display_name: " Test Profile ".into(),
|
||||
role: AstrBotProfileRole::General,
|
||||
base_url: base_url.into(),
|
||||
event_stream_url: None,
|
||||
authentication_type: AuthenticationType::DeviceToken,
|
||||
allow_insecure_http: false,
|
||||
pinned_certificate_fingerprint: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn creates_updates_lists_and_deletes_profile_metadata() {
|
||||
let database = ApplicationDatabase::in_memory().expect("database");
|
||||
let created =
|
||||
create_profile(&database, request("https://example.test")).expect("create profile");
|
||||
assert_eq!(created.display_name, "Test Profile");
|
||||
assert_eq!(created.base_url, "https://example.test/");
|
||||
assert!(created.credential_reference.is_none());
|
||||
assert!(!created.auto_connect);
|
||||
assert!(created.auto_connect_slot.is_none());
|
||||
|
||||
let updated = update_profile(
|
||||
&database,
|
||||
UpdateConnectionProfileRequest {
|
||||
id: created.id.clone(),
|
||||
profile: ConnectionProfileInput {
|
||||
display_name: "Updated".into(),
|
||||
role: AstrBotProfileRole::Companion,
|
||||
base_url: "https://updated.example.test".into(),
|
||||
event_stream_url: Some("https://updated.example.test/events".into()),
|
||||
authentication_type: AuthenticationType::ApiKey,
|
||||
allow_insecure_http: false,
|
||||
pinned_certificate_fingerprint: None,
|
||||
},
|
||||
},
|
||||
)
|
||||
.expect("update profile");
|
||||
assert_eq!(updated.display_name, "Updated");
|
||||
assert_eq!(list_profiles(&database).expect("list profiles").len(), 1);
|
||||
|
||||
delete_profile(&database, &created.id).expect("delete profile");
|
||||
assert!(list_profiles(&database).expect("list profiles").is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_insecure_or_credential_bearing_urls() {
|
||||
let database = ApplicationDatabase::in_memory().expect("database");
|
||||
assert!(create_profile(&database, request("http://example.test")).is_err());
|
||||
assert!(create_profile(&database, request("https://user:password@example.test")).is_err());
|
||||
assert!(create_profile(&database, request("https://example.test?token=fake")).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_secret_values_and_unknown_fields_at_the_ipc_boundary() {
|
||||
let result = serde_json::from_value::<ConnectionProfileInput>(serde_json::json!({
|
||||
"displayName": "Test Profile",
|
||||
"role": "general",
|
||||
"baseUrl": "https://example.test",
|
||||
"authenticationType": "device-token",
|
||||
"allowInsecureHttp": false,
|
||||
"token": "[REDACTED]",
|
||||
"password": "[REDACTED]",
|
||||
"apiKey": "[REDACTED]"
|
||||
}));
|
||||
|
||||
assert!(result.is_err());
|
||||
}
|
||||
}
|
||||
正在加载…
添加表格
在新工单中引用