sigit-code 1.7.2__tar.gz → 1.7.4__tar.gz

{sigit_code-1.7.2 → sigit_code-1.7.4}/Cargo.lock

@@ -5945,7 +5945,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.7.2"
+version = "1.7.4"
 dependencies = [
  "agent-client-protocol",
  "anyhow",
@@ -5976,7 +5976,7 @@ dependencies = [
 
 [[package]]
 name = "sigit-agent"
-version = "1.7.2"
+version = "1.7.4"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.7.2 → sigit_code-1.7.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/cli", "crates/sigit-*"]
 
 [workspace.package]
-version = "1.7.2"
+version = "1.7.4"
 edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/getsigit/sigit"
@@ -16,7 +16,7 @@ authors = ["Seto Elkahfi <seto@sigit.si>", "paydii <193906237+paydii@users.norep
 # crates.io, so this resolves from the registry rather than the onde-ed checkout next door.
 ed-acp = { version = "1.3.0", default-features = false }
 ed-acp-testkit = "1.3.0"
-sigit-agent = { version = "1.7.2", default-features = false, path = "crates/sigit-agent" }
+sigit-agent = { version = "1.7.4", default-features = false, path = "crates/sigit-agent" }
 
 # ACP protocol SDK
 agent-client-protocol = { version = "2.2", features = ["unstable_session_fork"] }

{sigit_code-1.7.2 → sigit_code-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigit-code
-Version: 1.7.2
+Version: 1.7.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{sigit_code-1.7.2 → sigit_code-1.7.4}/crates/cli/src/main.rs

@@ -2587,7 +2587,7 @@ impl SiGitAgent {
         cancellation: &PromptCancellation,
     ) {
         if workspace.reacquire().await
-            && let Err(error) = self.activate_session(session_id).await
+            && let Err(error) = self.reinstall_for_tools(session_id).await
         {
             log::warn!(
                 "session({session_id}): could not reinstall mid-turn, cancelling the turn: {}",
@@ -2598,6 +2598,30 @@ impl SiGitAgent {
         }
     }
 
+    /// Make `session_id` the live session and check that its directory is still
+    /// there. Tools resolve relative paths against the process directory, and
+    /// `install_session` leaves that alone when the session's `cwd` is gone, so
+    /// a prompt or a tool run on such a session would act in the previous
+    /// session's directory. Load, resume and fork do not call this: they
+    /// succeed for a deleted project so a client can still show its history.
+    async fn reinstall_for_tools(
+        &self,
+        session_id: &SessionId,
+    ) -> agent_client_protocol::Result<()> {
+        self.activate_session(session_id).await?;
+        let cwd = self.session_cwd.lock().unwrap().clone();
+        match cwd {
+            Some(cwd) if !cwd.is_dir() => Err(agent_client_protocol::Error::new(
+                ErrorCode::ResourceNotFound.into(),
+                format!(
+                    "the working directory of session {session_id} no longer exists: {}",
+                    cwd.display()
+                ),
+            )),
+            _ => Ok(()),
+        }
+    }
+
     /// Point the process at `state`'s roots and load its conversation.
     ///
     /// The process follows `cwd` because tool calls may use relative paths; the
@@ -2619,9 +2643,12 @@ impl SiGitAgent {
         }
         workspace::replace_additional_roots(additional_roots.clone());
         mcp::set_session_servers(mcp_servers);
-        if cwd.is_dir()
-            && let Err(err) = std::env::set_current_dir(&cwd)
-        {
+        if !cwd.is_dir() {
+            log::warn!(
+                "session({key}): cwd {} no longer exists, prompts and tools on it will fail",
+                cwd.display()
+            );
+        } else if let Err(err) = std::env::set_current_dir(&cwd) {
             log::warn!("could not set cwd to {}: {err}", cwd.display());
         }
         *self.active_session.lock().unwrap() = Some(key.to_string());
@@ -3270,7 +3297,7 @@ impl SiGitAgent {
         if cancellation.cancelled.load(Ordering::Acquire) {
             return Ok(PromptResponse::new(StopReason::Cancelled));
         }
-        self.activate_session(&session_id).await?;
+        self.reinstall_for_tools(&session_id).await?;
         if cancellation.cancelled.load(Ordering::Acquire) {
             return Ok(PromptResponse::new(StopReason::Cancelled));
         }
@@ -7609,6 +7636,50 @@ mod tests {
         assert!(agent.active_session.lock().unwrap().is_none());
     }
 
+    #[tokio::test]
+    #[allow(clippy::await_holding_lock)] // the lock guards process-global env for the whole test
+    async fn a_session_whose_directory_is_gone_loads_but_refuses_tools() {
+        let _guard = crate::ENV_TEST_LOCK
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+        let agent = SiGitAgent::new(
+            Arc::new(ChatEngine::new()),
+            GgufModelConfig::qwen25_3b(),
+            Arc::new(AtomicBool::new(true)),
+            Arc::new(AtomicBool::new(false)),
+            Arc::new(std::sync::Mutex::new(None)),
+            false,
+            false,
+        );
+        let dir = std::env::temp_dir().join(format!("sigit_gone_cwd_{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let thread = SessionId::new("gone-cwd-thread");
+        agent
+            .sessions
+            .lock()
+            .unwrap()
+            .insert("gone-cwd-thread".into(), agent.session_state(&dir, &[]));
+        std::fs::remove_dir_all(&dir).unwrap();
+
+        // Load, resume and fork only activate, so they still succeed.
+        agent.activate_session(&thread).await.unwrap();
+
+        // A prompt or a tool run does not.
+        *agent.active_session.lock().unwrap() = None;
+        let error = agent.reinstall_for_tools(&thread).await.unwrap_err();
+        assert_eq!(error.code, ErrorCode::ResourceNotFound);
+        assert!(error.message.contains("no longer exists"));
+
+        let cancellation = PromptCancellation::default();
+        let mut workspace = WorkspaceHold::acquire(&agent.workspace_lock).await;
+        workspace.release();
+        *agent.active_session.lock().unwrap() = None;
+        agent
+            .resume_workspace(&mut workspace, &thread, &cancellation)
+            .await;
+        assert!(cancellation.cancelled.load(Ordering::Acquire));
+    }
+
     #[test]
     fn session_context_message_lists_every_root_of_a_multi_root_project() {
         let primary = PathBuf::from("/tmp/primary");

{sigit_code-1.7.2 → sigit_code-1.7.4}/crates/sigit-agent/src/browser_auth.rs

@@ -180,11 +180,27 @@ pub async fn complete_loopback(flow: Flow) -> Result<String, String> {
     let listener = listener.ok_or_else(|| "this sign-in has no local listener".to_string())?;
 
     let expected_state = state.clone();
-    let code = tokio::task::spawn_blocking(move || wait_for_code(listener, &expected_state))
-        .await
-        .map_err(|error| format!("sign-in was interrupted: {error}"))??;
-
-    exchange(&code, &verifier, &redirect_uri).await
+    let (code, mut stream) =
+        tokio::task::spawn_blocking(move || wait_for_code(listener, &expected_state))
+            .await
+            .map_err(|error| format!("sign-in was interrupted: {error}"))??;
+
+    // The browser is still waiting on its request. Answer it only once the
+    // exchange has settled, so the page never reports a sign-in that failed.
+    let result = exchange(&code, &verifier, &redirect_uri).await;
+    match &result {
+        Ok(_) => respond(
+            &mut stream,
+            "Signed in to siGit Code",
+            "You can close this tab.",
+        ),
+        Err(_) => respond(
+            &mut stream,
+            "Sign-in did not complete",
+            "Return to siGit Code and try again.",
+        ),
+    }
+    result
 }
 
 /// Redeem a code the person pasted in. Returns the signed-in email.
@@ -198,8 +214,12 @@ pub async fn complete_paste(flow: &Flow, code: &str) -> Result<String, String> {
 
 /// Accept connections until one carries our callback. Anything else on the
 /// port (a browser probe, a stray scan) is answered and ignored rather than
-/// ending the wait.
-fn wait_for_code(listener: TcpListener, expected_state: &str) -> Result<String, String> {
+/// ending the wait. On success the matching connection is returned unanswered,
+/// for the caller to respond to once the code has been redeemed.
+fn wait_for_code(
+    listener: TcpListener,
+    expected_state: &str,
+) -> Result<(String, std::net::TcpStream), String> {
     let deadline = std::time::Instant::now() + CALLBACK_TIMEOUT;
     listener
         .set_nonblocking(true)
@@ -243,7 +263,7 @@ fn wait_for_code(listener: TcpListener, expected_state: &str) -> Result<String,
                     }
                 }
                 Err(error) => {
-                    respond(&mut stream, "Could not read the sign-in callback.");
+                    respond(&mut stream, "Nothing to do here", "");
                     log::debug!("could not read browser callback: {error}");
                     continue 'connections;
                 }
@@ -255,7 +275,7 @@ fn wait_for_code(listener: TcpListener, expected_state: &str) -> Result<String,
             .next()
             .and_then(|line| line.split_whitespace().nth(1))
         else {
-            respond(&mut stream, "Bad request.");
+            respond(&mut stream, "Nothing to do here", "");
             continue;
         };
 
@@ -273,39 +293,68 @@ fn wait_for_code(listener: TcpListener, expected_state: &str) -> Result<String,
         }
 
         if let Some(error) = error {
-            respond(
-                &mut stream,
-                "Sign-in was cancelled. You can close this tab.",
-            );
+            respond(&mut stream, "Sign-in cancelled", "You can close this tab.");
             return Err(format!("sign-in was declined ({error})"));
         }
 
         let Some(code) = code else {
-            respond(&mut stream, "Nothing to do here.");
+            respond(&mut stream, "Nothing to do here", "");
             continue;
         };
 
         // The state proves this callback belongs to the flow we started, not
         // to a link someone else sent to this browser.
         if state.as_deref() != Some(expected_state) {
-            respond(&mut stream, "That sign-in did not come from siGit Code.");
+            respond(
+                &mut stream,
+                "Sign-in didn't match",
+                "That sign-in did not come from siGit Code.",
+            );
             return Err("the sign-in response did not match this request".to_string());
         }
 
-        respond(
-            &mut stream,
-            "Signed in to siGit Code. You can close this tab.",
-        );
-        return Ok(code);
+        return Ok((code, stream));
     }
 }
 
-fn respond(stream: &mut std::net::TcpStream, message: &str) {
-    let body = format!(
-        "<!doctype html><meta charset=\"utf-8\"><title>siGit Code</title>\
-         <body style=\"font:16px system-ui;display:grid;place-items:center;height:90vh\">\
-         <p>{message}</p></body>"
-    );
+/// The 64x64 app icon, inlined into the page so it needs no second request.
+const LOGO_PNG: &[u8] = include_bytes!("../assets/sign-in-logo.png");
+
+/// Renders the page the browser lands on. Self-contained: inline CSS and an
+/// inline logo, because the page is served from the loopback address and must
+/// not fetch anything. Title and hint are constants, so nothing is escaped.
+fn page(title: &str, hint: &str) -> String {
+    let logo = base64::engine::general_purpose::STANDARD.encode(LOGO_PNG);
+    let hint = if hint.is_empty() {
+        String::new()
+    } else {
+        format!("<p>{hint}</p>")
+    };
+    format!(
+        "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">\
+         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
+         <meta name=\"color-scheme\" content=\"dark\"><title>{title}</title><style>\
+         :root{{color-scheme:dark}}\
+         html,body{{margin:0;height:100%}}\
+         body{{display:flex;align-items:center;justify-content:center;background:#15171a;\
+         font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",Roboto,\"Helvetica Neue\",Arial,sans-serif}}\
+         main{{display:flex;flex-direction:column;align-items:center;text-align:center;\
+         padding:0 24px;transform:translateY(-6%);animation:fade-in 240ms ease-out}}\
+         img{{width:40px;height:40px;border-radius:9px;opacity:.8;\
+         box-shadow:0 0 0 1px rgb(255 255 255/.06)}}\
+         h1{{margin:16px 0 0;font-size:15px;line-height:20px;font-weight:500;\
+         letter-spacing:-.01em;color:#f3f4f6}}\
+         p{{margin:4px 0 0;font-size:13px;line-height:18px;color:#6b7280}}\
+         @keyframes fade-in{{from{{opacity:0}}to{{opacity:1}}}}\
+         @media(prefers-reduced-motion:reduce){{main{{animation:none}}}}\
+         </style></head><body><main>\
+         <img src=\"data:image/png;base64,{logo}\" alt=\"\" width=\"40\" height=\"40\">\
+         <h1>{title}</h1>{hint}</main></body></html>"
+    )
+}
+
+fn respond(stream: &mut std::net::TcpStream, title: &str, hint: &str) {
+    let body = page(title, hint);
     let response = format!(
         "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
         body.len(),
@@ -464,6 +513,19 @@ fn percent_decode(value: &str) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn page_carries_the_title_hint_and_an_inline_logo() {
+        let body = page("Signed in to siGit Code", "You can close this tab.");
+        assert!(body.contains("<h1>Signed in to siGit Code</h1>"));
+        assert!(body.contains("<p>You can close this tab.</p>"));
+        assert!(body.contains("data:image/png;base64,"));
+    }
+
+    #[test]
+    fn page_omits_the_hint_when_empty() {
+        assert!(!page("Nothing to do here", "").contains("<p>"));
+    }
+
     #[test]
     fn code_challenge_matches_rfc_7636_example() {
         // RFC 7636 Appendix B.