pi-git-auth 1.2.2 → 1.2.3

package/README.md

@@ -54,6 +54,7 @@ github.ts    GitHub REST client
 gitlab.ts    GitLab REST client
 details.ts   read-only repo details overlay (tree + commits + metadata)
 git-gate.ts  command rewriting that injects the token for a host
+git-helpers.ts detection of file-persisting credential helpers (status note)
 redact.ts    secret redaction of tool outputs (PAT / URL-credential patterns)
 ```
 
@@ -121,15 +122,28 @@ use that account's token for the account's host (`github.com` or
 
 ```
 export GIT_TERMINAL_PROMPT=0 \
-  GIT_CONFIG_COUNT=1 \
+  GIT_CONFIG_COUNT=2 \
   GIT_CONFIG_KEY_0="url.https://x-access-token:<token>@<host>/.insteadOf" \
-  GIT_CONFIG_VALUE_0="https://<host>/" && <command>
+  GIT_CONFIG_VALUE_0="https://<host>/" \
+  GIT_CONFIG_KEY_1="credential.helper" \
+  GIT_CONFIG_VALUE_1="" && <command>
 ```
 
 Forging hosts' git-over-HTTPS endpoints ignore `Authorization` headers
 and only accept URL-embedded credentials, hence the `insteadOf` rewrite.
 Only the active host is touched; other remotes are untouched.
 
+The empty `credential.helper` entry disables git's credential helpers for
+the instrumented process only (env config is read after all file configs,
+and an empty value clears previously defined helpers). This is required so
+that git's post-auth store phase does not persist the injected token — e.g.
+a user-configured `credential.helper = store` would otherwise write it
+plaintext to `~/.git-credentials`. All other standard auth mechanisms
+(URL-embedded credentials, `credential.<url>.*` config, `.netrc`, SSH) are
+unaffected; helpers remain fully active everywhere the gate does not run.
+If a file-persisting helper is detected in the user's config, `/auth
+status` notes it passively (one line, no prompt).
+
 ## Token storage
 
 Tokens are **never stored plaintext on disk**. Two backends are

package/auth.ts

@@ -117,7 +117,7 @@ export function activeService(data: StoreData): Service | undefined {
 }
 
 /** Human-readable status block: all accounts, details for the active one. */
-export function statusDetail(data: StoreData): string {
+export function statusDetail(data: StoreData, opts?: { credHelperSink?: { helper: string; target: string } }): string {
   const keys = Object.keys(data.accounts);
   if (keys.length === 0) return "No git accounts. Run /auth login.";
   const lines = ["Git accounts:"];
@@ -147,6 +147,11 @@ export function statusDetail(data: StoreData): string {
     storeLine += " (wallet locked on load — token unavailable)";
   }
   lines.push(storeLine);
+  if (opts?.credHelperSink) {
+    lines.push(
+      `Git: credential.helper=${opts.credHelperSink.helper} detected — git may also cache gate tokens in ${opts.credHelperSink.target} (the gate itself keeps the token keyring-only)`,
+    );
+  }
   if (active && activeKey) {
     lines.push("");
     lines.push(`Active: @${active.user ?? activeKey.slice(activeKey.indexOf(":") + 1)}  (${active.platform})`);

package/commands.ts

@@ -3,6 +3,7 @@ import { loadStore, activeAccount, retryKeyringLoad, type StoreData } from "./st
 import { SERVICES, type Service, type TreeEntry } from "./forge";
 import { buildDetailsText, RepoDetailsPanel } from "./details";
 import { activeService, accountName, loginWithPastedToken, removeAccount, setActiveAccount, statusDetail } from "./auth";
+import { detectCredHelperSink } from "./git-helpers";
 
 type Ctx = ExtensionCommandContext;
 
@@ -12,7 +13,8 @@ async function showStatus(ctx: Ctx): Promise<void> {
   if (Object.keys(data.accounts).length === 0) {
     ctx.ui.notify("git auth: not connected — run /auth login", "info");
   } else {
-    ctx.ui.notify(statusDetail(data), "info");
+    const sink = await detectCredHelperSink(); // cached, fail-silent
+    ctx.ui.notify(statusDetail(data, { credHelperSink: sink }), "info");
   }
 }
 

package/git-gate.ts

@@ -6,9 +6,11 @@
  * for that host, regardless of git's own credential configuration:
  *
  *   export GIT_TERMINAL_PROMPT=0 \
- *     GIT_CONFIG_COUNT=1 \
+ *     GIT_CONFIG_COUNT=2 \
  *     GIT_CONFIG_KEY_0="url.https://x-access-token:<token>@<host>/.insteadOf" \
- *     GIT_CONFIG_VALUE_0="https://<host>/" && <command>
+ *     GIT_CONFIG_VALUE_0="https://<host>/" \
+ *     GIT_CONFIG_KEY_1="credential.helper" \
+ *     GIT_CONFIG_VALUE_1="" && <command>
  *
  * Forging hosts' git-over-HTTPS endpoints ignore Authorization headers
  * and only accept URL-embedded (Basic) credentials, hence the insteadOf
@@ -19,6 +21,14 @@
  *  - GIT_TERMINAL_PROMPT=0: a failed auth surfaces as a clean error
  *    instead of an interactive prompt hanging the TUI.
  *  - Deterministic: no credential-helper races, same behavior every run.
+ *  - The token is never persisted by git's credential helpers: the empty
+ *    credential.helper entry (read after all file configs, where an empty
+ *    value clears previously defined helpers) disables helpers for the
+ *    instrumented process only. Without it, git's post-auth store phase
+ *    would hand the injected token to file-based helpers such as `store`,
+ *    persisting it plaintext to ~/.git-credentials. All other standard
+ *    auth mechanisms (URL-embedded credentials, credential.<url>.* config,
+ *    .netrc, SSH) are unaffected.
  *  - SSH-style URLs for the host are rewritten to HTTPS so the token applies.
  */
 
@@ -37,8 +47,10 @@ export function instrumentGit(command: string, host: string, token: string): str
     .replace(new RegExp(`git@${host}:`, "g"), `https://${host}/`);
   const prefix =
     `export GIT_TERMINAL_PROMPT=0 ` +
-    `GIT_CONFIG_COUNT=1 ` +
+    `GIT_CONFIG_COUNT=2 ` +
     `GIT_CONFIG_KEY_0="url.https://x-access-token:${token}@${host}/.insteadOf" ` +
-    `GIT_CONFIG_VALUE_0="https://${host}/" && `;
+    `GIT_CONFIG_VALUE_0="https://${host}/" ` +
+    `GIT_CONFIG_KEY_1="credential.helper" ` +
+    `GIT_CONFIG_VALUE_1="" && `;
   return prefix + rewritten;
 }

package/git-helpers.ts

@@ -0,0 +1,77 @@
+/**
+ * Detection of file-persisting git credential helpers.
+ *
+ * The git gate keeps its token out of helpers by disabling them for the
+ * instrumented process (see git-gate.ts). This module is the *advisory*
+ * side: it detects whether the user's normal git configuration would have
+ * persisted the injected token (e.g. `credential.helper = store` →
+ * ~/.git-credentials) so the status view can note it. Passive only — no
+ * prompt, no blocking, fail-silent (any error → `undefined`).
+ */
+import { execFile } from "node:child_process";
+
+export interface CredHelperSink {
+  /** The `credential.helper` value as configured (e.g. "store"). */
+  helper: string;
+  /** Where that helper persists credentials, for the status line. */
+  target: string;
+}
+
+const TTL_MS = 60_000;
+const TIMEOUT_MS = 3_000;
+
+let cache: { at: number; sink: CredHelperSink | undefined } | undefined;
+let inFlight: Promise<CredHelperSink | undefined> | undefined;
+
+function sinkFor(value: string): CredHelperSink | undefined {
+  const v = value.trim();
+  const base = v.split("/").pop() ?? v;
+  if (v === "store" || base === "credential-store" || v.endsWith("!store")) {
+    return { helper: v, target: "~/.git-credentials (plaintext)" };
+  }
+  if (v === "netrc" || base === "credential-netrc" || v.endsWith("!netrc")) {
+    return { helper: v, target: "~/.netrc" };
+  }
+  return undefined; // OS wallets (gnome-keyring, osxkeychain, …): fine, no note
+}
+
+/**
+ * Detect a file-persisting credential helper in the user's normal git
+ * config. Cached for 60 s, deduplicated in flight, and fail-silent:
+ * missing git, timeout, or no such helper → `undefined`.
+ */
+export function detectCredHelperSink(): Promise<CredHelperSink | undefined> {
+  const now = Date.now();
+  if (cache && now - cache.at < TTL_MS) return Promise.resolve(cache.sink);
+  if (inFlight) return inFlight;
+  inFlight = new Promise<CredHelperSink | undefined>((resolve) => {
+    let done = false;
+    const finish = (sink: CredHelperSink | undefined) => {
+      if (done) return;
+      done = true;
+      cache = { at: Date.now(), sink };
+      inFlight = undefined;
+      resolve(sink);
+    };
+    const timer = setTimeout(() => finish(undefined), TIMEOUT_MS);
+    execFile(
+      "git",
+      ["config", "--get-all", "--show-origin", "credential.helper"],
+      { timeout: TIMEOUT_MS },
+      (err, stdout) => {
+        clearTimeout(timer);
+        if (err) return finish(undefined);
+        // Lines: "<origin>\t<value>". Prefer the last (most specific) match.
+        let sink: CredHelperSink | undefined;
+        for (const line of stdout.split("\n")) {
+          const idx = line.indexOf("\t");
+          if (idx < 0) continue;
+          const found = sinkFor(line.slice(idx + 1));
+          if (found) sink = found;
+        }
+        finish(sink);
+      },
+    );
+  });
+  return inFlight;
+}

package/index.ts

@@ -5,6 +5,7 @@ import { loadStore, activeAccount, retryKeyringLoad } from "./store";
 import { SERVICES } from "./forge";
 import { findAccounts, setActiveAccount, statusDetail } from "./auth";
 import { instrumentGit } from "./git-gate";
+import { detectCredHelperSink } from "./git-helpers";
 import { redactSecrets } from "./redact";
 import { handleAuthCommand } from "./commands";
 
@@ -90,7 +91,8 @@ export default function (pi: ExtensionAPI) {
           retryKeyringLoad(); // prompt-safe: recovers the token once the wallet unlocks
           const data = loadStore();
           if (Object.keys(data.accounts).length === 0) return { ...text(notConnected), isError: true };
-          return text(statusDetail(data));
+          const sink = await detectCredHelperSink(); // cached, fail-silent
+          return text(statusDetail(data, { credHelperSink: sink }));
         }
 
         case "switch": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-git-auth",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "pi coding-agent extension: git auth for GitHub and GitLab: keyring-stored login tokens, account switching, transparent git auth, repo list/create with details overlay",
   "license": "MIT",
   "author": "Carlo Onofrio",