Merge pull request #22 from lorem-dev/develop

release: 0.2.2

Author: lorem-dev

.github/workflows/backmerge.yml

@@ -21,7 +21,7 @@ jobs:
   open-backmerge-pr:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
 

.github/workflows/docs.yml

@@ -54,7 +54,7 @@ jobs:
           lfs: true
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v7
 
       - name: Configure git identity for mike
         run: |

.github/workflows/release.yml

@@ -387,7 +387,7 @@ jobs:
       # dir (linux/windows) and the cross-target dir (macOS --target).
       # -----------------------------------------------------------------------
       - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: skillkeeper-${{ github.ref_name }}-${{ matrix.target }}
           path: |
@@ -436,7 +436,7 @@ jobs:
         run: node scripts/release-notes.mjs
 
       - name: Download all artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           path: dist-all
 
@@ -505,7 +505,7 @@ jobs:
         run: node scripts/release-downloads.mjs "$GITHUB_REF_NAME" dist
 
       - name: Create GitHub release and attach artifacts
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v3
         with:
           files: dist/*
           body_path: RELEASE_NOTES.md

CHANGES.md

@@ -2,6 +2,83 @@
 
 ## Development
 
+## Version 0.2.2
+
+### Added
+
+- A documentation section on setting up an ssh-agent, with per-platform
+  instructions and a note on pinentry. When the terminal is raised for a
+  passphrase and no agent is running, the app now says so once per session and
+  links to it -- otherwise being asked on every single operation reads as the
+  app being broken rather than as a machine that needs setting up. The Windows
+  instructions call out that Git for Windows uses its own bundled `ssh`, which
+  ignores the Windows agent service until `core.sshCommand` points at the system
+  client.
+- A right-click menu in the terminal with Copy, Paste and Select all. Copying
+  was previously reachable only through a keyboard shortcut that differs per
+  platform (and where a bare Ctrl+C sends an interrupt instead), so getting text
+  out was easy to miss. Select all also covers the case where a full-screen
+  program has taken over the mouse and dragging cannot select.
+
+### Fixed
+
+- The terminal is raised for every prompt that needs an answer, not just the
+  first one of a session, and the caret lands in it so the answer can be typed
+  straight away instead of after a click nobody expects. Credential prompts over
+  HTTPS (`Username for ...`, `Password for ...`) now count as prompts too; only
+  an SSH passphrase and a host-key confirmation did before.
+- The update check skips a repository that was never cloned instead of fetching
+  in a directory that does not exist. Such a repository has no local commit to
+  compare against, so the check could only ever answer "no update" -- but it
+  answered it by running git first, which reported a fatal error into the
+  terminal on every startup, once per uncloned repository.
+- Windows: an SSH key passphrase can finally be entered, so cloning a repository
+  that needs one works. Git used to run in a pseudo-terminal of its own there,
+  and the passphrase prompt never surfaced in it -- git simply waited forever,
+  printing nothing. It now runs in the interactive terminal the user is already
+  looking at, exactly as it does on macOS and Linux: the prompt appears in the
+  terminal and can be answered. Because Windows shells take no prompt hook, the
+  command reports its exit code by printing a sentinel that is stripped from the
+  output before it is shown. An ssh-agent is still used when one holds the key,
+  in which case nothing is asked at all.
+- A git command that blocks on a prompt no longer wedges every later one. Git
+  runs in the terminal through its own pseudo-terminal, and the app waited for
+  it to exit without any bound -- so a clone stuck on an SSH key passphrase (a
+  prompt that does not reach that pseudo-terminal on Windows) held the git queue
+  for the rest of the session, and each following clone, sync or update check
+  blocked silently before it could print anything. The wait is now bounded by
+  SILENCE rather than runtime -- a large clone reports progress throughout, so
+  it is never affected -- and a command that produces nothing at all while still
+  running is stopped, with a message naming the likely cause.
+- Windows: the first repository operation that ran git in the terminal never
+  finished, and every later one silently did nothing. After git exited, the app
+  waited for the output reader to reach end-of-file while still holding the
+  command's pseudo-terminal open -- and Windows keeps a copy of the write handle
+  alive for exactly that long, so the end-of-file could never arrive. The call
+  never returned, its slot in the git queue was never released, and each
+  following clone, sync or update check blocked before it could print anything:
+  the terminal accepted typing but showed no git, an update check sat unfinished,
+  and adding a repository looked like nothing happened. The pseudo-terminal is
+  now released before the wait, and the wait itself is bounded.
+- A terminal that cannot start now says so instead of staying blank. The
+  renderer used to issue the start as a floating promise, so a failed shell
+  spawn produced no error anywhere -- and because repository git only runs
+  through the terminal while a session is live, the same dead session silently
+  reverted clone/sync to a headless git that prints nothing. The failure is now
+  shown in the terminal view, logged as a warning that explains git is still
+  running without visible output, and reported by a new `terminal_status`
+  command. Starting is retried up to three times before it is reported.
+- A pseudo-terminal backend that panics rather than returning an error -- Windows
+  hosts older than Windows 10 1809, where `CreatePseudoConsole` is not exported --
+  no longer unwinds through the command's worker task into an opaque join error.
+  The panic is caught and its message kept, so the terminal is unavailable with a
+  readable reason instead of failing anonymously.
+- Git launch failures on the standalone-process path (Windows and unintegrated
+  shells) are printed to the terminal instead of being swallowed into a bare
+  exit code, and a `git` that cannot be spawned names the likely cause: it is not
+  on the PATH this application inherited. Shell spawn errors likewise name the
+  shell and working directory they tried.
+
 ## Version 0.2.1
 
 ### Added

Cargo.lock

@@ -10,7 +10,7 @@ members = [
 
 [workspace.package]
 edition = "2021"
-version = "0.2.1"
+version = "0.2.2"
 license = "Apache-2.0"
 
 [workspace.dependencies]

Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "@skillkeeper/desktop",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": true,
   "description": "Install and manage skills and hooks for AI coding agents",
   "author": {

apps/desktop/package.json

@@ -64,6 +64,32 @@ fn has_inherited_agent() -> bool {
         .unwrap_or(false)
 }
 
+/// The named pipe the Windows OpenSSH agent service listens on. Windows sets no
+/// `SSH_AUTH_SOCK`, so its presence is the only way to tell the service is up.
+#[cfg(windows)]
+const WINDOWS_AGENT_PIPE: &str = r"\\.\pipe\openssh-ssh-agent";
+
+/// Whether an ssh-agent is available to hold a key for this session.
+///
+/// Consumed by the `ssh_agent_available` command: with no agent, every SSH
+/// operation has to ask for the key passphrase, so the app points the user at
+/// the setup documentation instead of leaving the repeated prompts unexplained.
+///
+/// This reports only that an agent EXISTS, not that it holds the right key --
+/// listing keys would mean running `ssh-add -l` on a path where a hung agent
+/// could block, and a false "available" only costs the hint, not correctness.
+pub fn is_available() -> bool {
+    if has_inherited_agent() {
+        return true;
+    }
+    #[cfg(windows)]
+    {
+        return std::path::Path::new(WINDOWS_AGENT_PIPE).exists();
+    }
+    #[cfg(not(windows))]
+    false
+}
+
 /// Load the default ssh keys once, best-effort, without ever blocking on a
 /// passphrase. No TTY (not a shell) plus `SSH_ASKPASS_REQUIRE=never` / empty
 /// `SSH_ASKPASS` / `DISPLAY` means an encrypted key absent from the keychain

apps/desktop/src-tauri/src/app/ssh_agent.rs

@@ -507,6 +507,14 @@ pub fn has_update(ctx: &AppContext, id: String) -> bool {
         Ok(Some(repo)) => repo,
         _ => return false,
     };
+    // A repository that was never cloned (its clone failed, or the directory was
+    // deleted) has no local commit to compare against, so there is nothing this
+    // can report. Checking first also keeps the update sweep from running
+    // `git -C <missing dir> fetch` -- which prints a `fatal:` into the terminal
+    // on every startup, once per such repository. Matches `list_branches`.
+    if !ctx.fs.exists(&repo.local_path).unwrap_or(false) {
+        return false;
+    }
     // Fetch in the terminal (visible, ssh-capable) like a pull; the rev-parse
     // comparisons below stay on the silent port.
     if fetch_op(ctx, &repo.local_path).is_err() {
@@ -887,6 +895,29 @@ mod tests {
         assert!(has_update(&app.ctx, repo.id.clone()));
     }
 
+    /// A tracked repository that was never cloned must not be fetched: there is
+    /// nothing to compare against, and running git in a directory that does not
+    /// exist only reports a fatal error into the terminal on every sweep.
+    #[test]
+    fn has_update_is_false_without_touching_git_when_the_clone_is_missing() {
+        if !git_available() {
+            eprintln!("skipping: git not available");
+            return;
+        }
+        let app = TempAppData::new();
+        let src = SourceRepo::new();
+        let repo = add_repo(&app, &src);
+        // Added but never cloned, so the recorded local path does not exist.
+        assert!(!Path::new(&repo.local_path).exists());
+        assert!(!has_update(&app.ctx, repo.id.clone()));
+
+        // And once it IS cloned, the same call reports normally again.
+        assert!(clone(&app.ctx, repo.id.clone()).ok);
+        assert!(!has_update(&app.ctx, repo.id.clone()));
+        src.advance("extra.txt");
+        assert!(has_update(&app.ctx, repo.id));
+    }
+
     #[test]
     fn update_edits_name_and_rederives_remote_fields() {
         if !git_available() {

apps/desktop/src-tauri/src/commands/repositories.rs

@@ -15,13 +15,39 @@
 //! setup. In-shell git (`run_git`) is exposed on the manager for Wave 4 to call
 //! and is not yet surfaced as a command.
 
+use serde::Serialize;
 use tauri::State;
 
 use std::sync::Arc;
 
 use super::blocking;
 use crate::state::AppContext;
 
+/// Whether a live shell session exists, and why not when it does not.
+///
+/// The repository commands run git through the PTY only while a session is
+/// live, falling back to the silent headless port otherwise. The renderer reads
+/// this to explain that fallback instead of leaving the user with a terminal
+/// that shows nothing during a clone.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TerminalStatus {
+    /// True once the shell has started (git output streams to the view).
+    pub started: bool,
+    /// The last shell/git launch failure, when there is one.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+
+/// `terminal:status` -- is the shell live, and if not, why not.
+#[tauri::command]
+pub fn terminal_status(state: State<'_, Arc<AppContext>>) -> TerminalStatus {
+    TerminalStatus {
+        started: state.terminal.is_started(),
+        error: state.terminal.last_error(),
+    }
+}
+
 /// `terminal:start` -- (re)ensure the shell is running at `cols` x `rows` and
 /// return its retained scrollback for the renderer to replay.
 #[tauri::command]
@@ -57,6 +83,16 @@ pub fn terminal_clear_buffer(state: State<'_, Arc<AppContext>>) -> Result<(), St
     Ok(())
 }
 
+/// `ssh:agentAvailable` -- whether an ssh-agent exists to hold a key.
+///
+/// Without one, every SSH operation has to ask for the passphrase again, so the
+/// renderer uses this to explain the repeated prompts and point at the setup
+/// documentation rather than leaving them unexplained.
+#[tauri::command]
+pub fn ssh_agent_available() -> bool {
+    crate::app::ssh_agent::is_available()
+}
+
 /// `terminal:runSshAdd` -- type `ssh-add` into the interactive shell so its key
 /// passphrase prompt appears in the terminal view (macOS adds
 /// `--apple-use-keychain`).