A local-first private AI assistant for everyday use. Runs on-device models with encrypted P2P sync, and supports sharing chats publicly on ATProto.
fix: code-signing on tar ball bundle + auto exit link process
+30
-16
+10
scripts/bundler.sh
+10
scripts/bundler.sh
···
16
16
17
17
cargo build -p tiles --${TARGET}
18
18
19
+
chmod +x "${CLI_BIN_PATH}/tiles"
20
+
21
+
# Signing the tiles binary
22
+
codesign --force \
23
+
--sign "$DEVELOPER_ID_APPLICATION"\
24
+
--options runtime \
25
+
--timestamp \
26
+
--strict \
27
+
"${CLI_BIN_PATH}/tiles"
28
+
19
29
# rm -rf "${DIST_DIR}"
20
30
21
31
mkdir -p "${DIST_DIR}/tmp"
+20
-16
tiles/src/core/network/mod.rs
+20
-16
tiles/src/core/network/mod.rs
···
31
31
};
32
32
use tokio::{
33
33
sync::{
34
-
mpsc::{self, Sender},
34
+
mpsc::{self},
35
35
oneshot::{self},
36
36
},
37
37
task::spawn_blocking,
···
108
108
let endpoint = create_endpoint(&user).await?;
109
109
let is_online = is_online(&endpoint).await;
110
110
let mut bootstrap_ids: Vec<EndpointId> = vec![];
111
+
let (sendx, mut recvx) = mpsc::channel(1);
111
112
// if ticket's there, then this is link enable sender's command, else receiver end
112
113
if let Some(ticket) = ticket {
113
114
let (endpoint_id, mut did, mut nickname, topic_value) = parse_link_ticket(&ticket)?;
···
147
148
user.clone(),
148
149
user_db_conn,
149
150
None,
151
+
sendx.clone(),
150
152
));
151
153
152
154
let link_req_msg =
···
157
159
158
160
println!("\nWaiting for response...");
159
161
160
-
tokio::signal::ctrl_c().await?;
162
+
recvx.recv().await;
161
163
recv_router.shutdown().await?;
162
164
} else {
163
165
// RECEIVER BLOCK
···
213
215
user.clone(),
214
216
user_db_conn,
215
217
Some(generated_ticket),
218
+
sendx.clone(),
216
219
));
217
-
218
-
// TODO: Maybe a better way is to use a oneshot channel to exit
219
-
// the terminal instead of SIGINT
220
-
tokio::signal::ctrl_c().await?;
220
+
recvx.recv().await;
221
221
recv_router.shutdown().await?;
222
222
}
223
223
endpoint.close().await;
···
230
230
user: accounts::User,
231
231
db_conn: Connection,
232
232
generated_ticket: Option<String>,
233
+
link_main_sender: tokio::sync::mpsc::Sender<u8>,
233
234
) -> Result<()> {
234
235
while let Some(event) = receiver.try_next().await? {
235
236
if cfg!(debug_assertions) {
···
294
295
);
295
296
NetworkMessage::new(&user, msg.is_online, MessageBody::LinkAccepted)
296
297
} else {
297
-
println!("You can exit now by ctrl-c");
298
298
NetworkMessage::new(
299
299
&user,
300
300
msg.is_online,
···
306
306
input.lock().unwrap().clear();
307
307
308
308
sender.broadcast(link_res_resp.to_bytes().into()).await?;
309
+
link_main_sender.send(0).await?;
309
310
}
310
311
MessageBody::LinkAccepted => {
311
312
println!("\nLink accepted by {}({})", msg.from_nickname, msg.from_did);
···
317
318
return Ok(());
318
319
}
319
320
320
-
println!("\nYou can exit now by ctrl-c");
321
-
322
-
continue;
321
+
link_main_sender.send(0).await?;
322
+
break;
323
323
}
324
324
MessageBody::LinkRejected { reason } => {
325
325
println!(
326
-
"Oops looks like your link request has been rejected by {}({}),\nreason: {},\nexit (ctrl-c) and try again",
326
+
"Oops looks like your link request has been rejected by {}({}),\nreason: {},\n Try again",
327
327
msg.from_nickname, msg.from_did, reason
328
328
);
329
+
link_main_sender.send(0).await?;
329
330
}
330
331
msg_body => {
331
332
eprintln!("Invalid link message {:?}", msg_body)
···
342
343
user: accounts::User,
343
344
store: MemStore,
344
345
endpoint: Endpoint,
345
-
sync_channel_sender: Sender<SyncOp>,
346
+
sync_channel_sender: tokio::sync::mpsc::Sender<SyncOp>,
346
347
sync_main_sender: tokio::sync::mpsc::Sender<u8>,
347
348
) -> Result<()> {
348
349
while let Some(event) = receiver.try_next().await? {
···
650
651
}
651
652
}
652
653
653
-
async fn fetch_last_row_counter(user_id: &str, sender: &Sender<SyncOp>) -> Result<i64> {
654
+
async fn fetch_last_row_counter(
655
+
user_id: &str,
656
+
sender: &tokio::sync::mpsc::Sender<SyncOp>,
657
+
) -> Result<i64> {
654
658
let (sendx, recvx) = oneshot::channel();
655
659
let sync_op_msg = SyncOp::GetLastRowCounter {
656
660
user_id: user_id.to_owned(),
···
663
667
664
668
async fn fetch_encoded_delta_ticket(
665
669
user_id: &str,
666
-
sender: &Sender<SyncOp>,
670
+
sender: &tokio::sync::mpsc::Sender<SyncOp>,
667
671
lrc: i64,
668
672
store: &MemStore,
669
673
delivered_from: PublicKey,
···
692
696
msg: &NetworkMessage,
693
697
delivered_from: PublicKey,
694
698
user: &accounts::User,
695
-
sync_channel_sender: &Sender<SyncOp>,
699
+
sync_channel_sender: &tokio::sync::mpsc::Sender<SyncOp>,
696
700
) -> Result<()> {
697
701
if let MessageBody::SyncStart {
698
702
last_row_counter: lrc,
···
732
736
delivered_from: PublicKey,
733
737
user: &accounts::User,
734
738
endpoint: &Endpoint,
735
-
sync_channel_sender: &Sender<SyncOp>,
739
+
sync_channel_sender: &tokio::sync::mpsc::Sender<SyncOp>,
736
740
) -> Result<()> {
737
741
if let MessageBody::SyncSendDeltaInfo {
738
742
blob_ticket,