first-tree-staging 0.5.2-staging.23.1 → 0.5.2-staging.24.1

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as cliFetch, f as channelConfig, l as print, n as bindFeishuUser, o as CLI_USER_AGENT, r as documentContextSchema, s as COMMAND_VERSION, t as bindFeishuBot, u as setJsonMode } from "../feishu-DmpOdXci.mjs";
-import { $ as agentConfigSchema, A as installClientService, C as checkClientConfig, D as printResults, E as checkWebSocket, F as startClientService, G as loadCredentials, I as stopClientService, J as saveAgentConfig, M as isServiceUnitDriftDetected, O as reconcileAgentConfigs, P as restartClientService, Q as removeLocalAgent, R as ClientRuntime, S as checkBackgroundService, T as checkServerReachable, U as ensureFreshAccessToken, W as ensureFreshAdminToken, X as findStaleAliases, Y as saveCredentials, Z as formatStaleReason, _t as buildMessageDocumentSnapshots, a as declineUpdate, at as initConfig, b as migrateLocalAgentDirs, bt as applyClientLoggerConfig, c as detectInstallMode, ct as resetConfig, d as reconcileLocalRuntimeProviders, dt as setConfigValue, et as clientConfigSchema, f as uploadClientCapabilities, ft as ClientOrgMismatchError, gt as SessionRegistry, h as promptMissingFields, ht as SdkError, i as createExecuteUpdate, it as getConfigValue, j as isServiceSupported, k as getClientServiceStatus, l as fetchLatestVersion, lt as resetConfigMeta, m as promptAddAgent, mt as FirstTreeHubSDK, n as decodeJwtPayload, nt as defaultDataDir, o as promptUpdate, ot as loadAgents, pt as ClientUserMismatchError, q as resolveServerUrl, r as deriveHubUrlFromToken, rt as defaultHome, s as PACKAGE_NAME, st as readConfigFile, t as HubUrlDerivationError, tt as defaultConfigDir, u as installGlobalLatest, ut as resolveConfigReadonly, vt as cleanWorkspaces, w as checkNodeVersion, x as checkAgentConfigs, xt as configureClientLoggerForService, y as createApiNameResolver, yt as probeCapabilities, z as handleClientOrgMismatch } from "../connect-token-2AaEgnAr.mjs";
+import { $ as agentConfigSchema, A as installClientService, C as checkClientConfig, D as printResults, E as checkWebSocket, F as startClientService, G as loadCredentials, I as stopClientService, J as saveAgentConfig, M as isServiceUnitDriftDetected, O as reconcileAgentConfigs, P as restartClientService, Q as removeLocalAgent, R as ClientRuntime, S as checkBackgroundService, T as checkServerReachable, U as ensureFreshAccessToken, W as ensureFreshAdminToken, X as findStaleAliases, Y as saveCredentials, Z as formatStaleReason, _t as buildMessageDocumentSnapshots, a as declineUpdate, at as initConfig, b as migrateLocalAgentDirs, bt as applyClientLoggerConfig, c as detectInstallMode, ct as resetConfig, d as reconcileLocalRuntimeProviders, dt as setConfigValue, et as clientConfigSchema, f as uploadClientCapabilities, ft as ClientOrgMismatchError, gt as SessionRegistry, h as promptMissingFields, ht as SdkError, i as createExecuteUpdate, it as getConfigValue, j as isServiceSupported, k as getClientServiceStatus, l as fetchLatestVersion, lt as resetConfigMeta, m as promptAddAgent, mt as FirstTreeHubSDK, n as decodeJwtPayload, nt as defaultDataDir, o as promptUpdate, ot as loadAgents, pt as ClientUserMismatchError, q as resolveServerUrl, r as deriveHubUrlFromToken, rt as defaultHome, s as PACKAGE_NAME, st as readConfigFile, t as HubUrlDerivationError, tt as defaultConfigDir, u as installGlobalLatest, ut as resolveConfigReadonly, vt as cleanWorkspaces, w as checkNodeVersion, x as checkAgentConfigs, xt as configureClientLoggerForService, y as createApiNameResolver, yt as probeCapabilities, z as handleClientOrgMismatch } from "../connect-token-CJozTiUf.mjs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";

package/dist/{connect-token-2AaEgnAr.mjs → connect-token-CJozTiUf.mjs}

@@ -7332,6 +7332,33 @@ const DEFAULT_CLONE_TIMEOUT_MS = 300 * 1e3;
 const FETCH_REFSPEC = "+refs/heads/*:refs/remotes/origin/*";
 const SESSION_BRANCH_PREFIX = "hub-session";
 /**
+* Backoff schedule for retrying a remote-talking git op (`fetch`,
+* `remote set-head --auto`) on a transient network-layer failure. Each entry
+* is the wait BEFORE the next attempt, so this lays out 4 attempts total
+* (1 initial + 3 retries) with a worst-case sleep budget of ~5s **per
+* protocol attempt**.
+*
+* Per-call totals depend on whether the helper chains a primary + fallback:
+*   - `fetchOrigin` ≤ 5s sleep budget: the SSH fallback only fires when
+*     the primary's terminal failure is credential-shaped, which a transient
+*     stderr will never be. So a transient-only failure burns ~5s.
+*   - `setHeadAuto` ≤ 10s sleep budget: the fallback fires on ANY terminal
+*     primary failure, so a doubly-transient run burns ~5s + ~5s ≈ 10s.
+*
+* Tuned for the operator-visible case of session start/resume hitting a
+* proxy / VPN that flips a rule, restarts a TUN, or drops a TLS handshake
+* mid-flight. The user's own manual workaround in those cases is "@-mention
+* the agent again 2 seconds later" — this is that, automated.
+*
+* Per-step jitter (up to 25% of the delay) prevents thundering-herd retries
+* when several agents resume in lockstep against the same flaky proxy.
+*/
+const NETWORK_RETRY_DELAYS_MS = [
+	500,
+	1500,
+	3e3
+];
+/**
 * Hash a repo URL into the mirror directory name.
 *
 * The hash is computed over a *canonical* form (host + path, lowercased
@@ -7510,6 +7537,20 @@ function createGitMirrorManager(opts) {
 			return false;
 		}
 	}
+	async function gitWithNetworkRetry(args, cwd, timeoutMs, opLabel) {
+		return retryOnTransientNetwork(() => git(args, cwd, timeoutMs), {
+			delaysMs: NETWORK_RETRY_DELAYS_MS,
+			isRetryable: isLikelyTransientNetworkError,
+			onRetry: ({ attempt, nextDelayMs, message }) => {
+				log?.warn({
+					op: opLabel,
+					attempt,
+					nextDelayMs,
+					stderr: message.slice(0, 512)
+				}, "git remote op hit transient network error — retrying");
+			}
+		});
+	}
 	/**
 	* `git fetch --prune origin` with one-shot bidirectional protocol fallback.
 	*
@@ -7547,23 +7588,38 @@ function createGitMirrorManager(opts) {
 	* here: callers that need origin/HEAD already get a clear
 	* `GitMirrorError("Cannot resolve default branch …")` if both attempts fail.
 	*/
+	/**
+	* Worst-case sleep budget: ~10s (primary ~5s + fallback ~5s). Unlike
+	* `fetchOrigin`, which gates fallback on a credential-shaped terminal
+	* error, `setHeadAuto` always falls through on any primary failure, so
+	* a doubly-transient run pays both retry budgets. Per-call 30s timeout
+	* still caps each individual git invocation.
+	*/
 	async function setHeadAuto(mirrorPath, originUrl) {
-		if (await gitOk([
-			"remote",
-			"set-head",
-			"origin",
-			"--auto"
-		], mirrorPath, 3e4)) return true;
+		try {
+			await gitWithNetworkRetry([
+				"remote",
+				"set-head",
+				"origin",
+				"--auto"
+			], mirrorPath, 3e4, "set-head:primary");
+			return true;
+		} catch {}
 		const direction = pickFallbackDirection(originUrl);
 		if (!direction) return false;
-		return await gitOk([
-			"-c",
-			`url.${direction.peerBase}.insteadOf=${direction.originBase}`,
-			"remote",
-			"set-head",
-			"origin",
-			"--auto"
-		], mirrorPath, 3e4);
+		try {
+			await gitWithNetworkRetry([
+				"-c",
+				`url.${direction.peerBase}.insteadOf=${direction.originBase}`,
+				"remote",
+				"set-head",
+				"origin",
+				"--auto"
+			], mirrorPath, 3e4, "set-head:fallback");
+			return true;
+		} catch {
+			return false;
+		}
 	}
 	async function readOriginUrl(mirrorPath) {
 		try {
@@ -7580,11 +7636,11 @@ function createGitMirrorManager(opts) {
 	async function fetchOrigin(mirrorPath, originUrl) {
 		const direction = pickFallbackDirection(originUrl);
 		try {
-			const { elapsedMs } = await git([
+			const { elapsedMs } = await gitWithNetworkRetry([
 				"fetch",
 				"--prune",
 				"origin"
-			], mirrorPath, cloneTimeoutMs);
+			], mirrorPath, cloneTimeoutMs, "fetch:primary");
 			return {
 				elapsedMs,
 				usedFallback: false
@@ -7599,13 +7655,13 @@ function createGitMirrorManager(opts) {
 				peerBase: direction.peerBase
 			}, "fetch failed with credential-shaped error; retrying with peer-protocol insteadOf rewrite");
 			try {
-				const { elapsedMs } = await git([
+				const { elapsedMs } = await gitWithNetworkRetry([
 					"-c",
 					`url.${direction.peerBase}.insteadOf=${direction.originBase}`,
 					"fetch",
 					"--prune",
 					"origin"
-				], mirrorPath, cloneTimeoutMs);
+				], mirrorPath, cloneTimeoutMs, "fetch:fallback");
 				log?.info({
 					gitUrl: originUrl,
 					toProtocol: direction.toProtocol
@@ -8134,6 +8190,46 @@ function isLikelySshAuthFailure(message) {
 	return /Permission denied\s*(?:\(|,)/i.test(message) || /Could not read from remote repository/i.test(message) || /Host key verification failed/i.test(message) || /no matching host key type/i.test(message) || /no mutual signature algorithm/i.test(message);
 }
 /**
+* Heuristic for transient network-layer failures emitted by `git` over
+* HTTPS or SSH. These are the failure modes a brief proxy/VPN hiccup, TLS
+* handshake blip, or peer connection reset produces mid-fetch — exactly
+* what `SSL_connect: SSL_ERROR_SYSCALL` looks like when Surge / Clash
+* swaps a rule mid-flight, what `early EOF` looks like when an HTTP/2
+* stream is reset, and what `Connection refused` looks like when a local
+* proxy listener restarts.
+*
+* Used by the `gitWithNetworkRetry` wrapper around `fetch` and
+* `remote set-head --auto` to absorb the kind of hiccup that today
+* surfaces as `Session start/resume failed (…)` in chat and only goes
+* away when the operator manually @-mentions the agent again two seconds
+* later.
+*
+* Negative space (intentionally NOT matched):
+*   - credential failures — handled by the protocol-fallback path; retrying
+*     in the same protocol won't help.
+*   - `Repository not found`, `couldn't find remote ref` — deterministic
+*     content errors; a 500ms retry won't fix them.
+*   - `SSL certificate problem` — TLS trust failures; retrying won't help
+*     and silently masking them would hide a real misconfiguration.
+*   - `git … timed out after Xms` — our own per-call timeout. The op was
+*     making progress (or wasn't); either way another full timeout window
+*     is the wrong response.
+*
+* On localhost-proxy specifically (the common case for this codebase),
+* `ECONNREFUSED` IS a transient signal — when Surge / Clash bounces the
+* listener, the next attempt sees the same listener back up within
+* seconds. This is why we diverge from the SDK's `doFetch` policy (which
+* does NOT retry `ECONNREFUSED` because there the peer is the remote hub).
+*
+* Exported for unit testing.
+*/
+function isLikelyTransientNetworkError(message) {
+	if (!message) return false;
+	if (isLikelyHttpsAuthFailure(message) || isLikelySshAuthFailure(message)) return false;
+	if (/SSL certificate problem/i.test(message) || /server certificate verification failed/i.test(message) || /certificate verify failed/i.test(message) || /self.signed certificate/i.test(message) || /unable to get local issuer certificate/i.test(message) || /certificate has expired/i.test(message)) return false;
+	return /SSL_ERROR_SYSCALL/i.test(message) || /unexpected eof while reading/i.test(message) || /TLS handshake|gnutls_handshake|gnutls\s+recv\s+error/i.test(message) || /\bConnection reset(?:\s+by\s+peer)?\b/i.test(message) || /\bConnection refused\b/i.test(message) || /\bConnection timed out\b/i.test(message) || /\bOperation timed out\b/i.test(message) || /\bNetwork is unreachable\b/i.test(message) || /Could not resolve host(?:name)?/i.test(message) || /Temporary failure in name resolution/i.test(message) || /\bRPC failed\b/i.test(message) || /\bearly EOF\b/i.test(message) || /the remote end hung up unexpectedly/i.test(message) || /transfer closed with outstanding read data remaining/i.test(message) || /HTTP\/2 stream\s+\d+\s+was\s+(?:not\s+)?(?:reset|closed)/i.test(message) || /HTTP\/2 stream was reset/i.test(message) || /unexpected disconnect while reading sideband packet/i.test(message) || /fetch-pack: unexpected disconnect/i.test(message) || /\bsend-pack:\s+unexpected\s+disconnect\b/i.test(message);
+}
+/**
 * Map an HTTPS git URL to the `insteadOf` rewrite needed to make git resolve
 * it through SSH. Returns *base* strings (suitable for
 * `git -c url.<sshBase>.insteadOf=<httpsBase>`) — git's `insteadOf` is a
@@ -8250,6 +8346,44 @@ function truncate(text, max = 512) {
 	if (text.length <= max) return text;
 	return `${text.slice(0, max)}…[truncated]`;
 }
+/**
+* Run `op` once, and on a `isRetryable`-classified failure replay it on the
+* given backoff schedule. Non-retryable failures propagate to the caller
+* immediately — those won't be cured by waiting and silently retrying would
+* mask real bugs and exhaust the retry budget.
+*
+* Per-attempt timeouts (when `op` enforces one of its own) are NOT reset
+* across attempts: each attempt gets its own full budget. Right policy for
+* `git fetch` where a slow but progressing transfer on attempt N+1 should
+* not be aborted because attempt N ate part of a shared budget.
+*
+* Exported so unit tests can drive the retry policy with a mock `op`
+* instead of standing up a real flaky network. Module-scope so the helper
+* stays pure and side-effect-free.
+*/
+async function retryOnTransientNetwork(op, options) {
+	const { delaysMs, isRetryable, onRetry } = options;
+	const maxAttempts = delaysMs.length + 1;
+	let lastErr;
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+		return await op(attempt);
+	} catch (err) {
+		lastErr = err;
+		const message = err instanceof Error ? err.message : String(err);
+		if (!isRetryable(message)) throw err;
+		if (attempt === maxAttempts) throw err;
+		const baseDelay = delaysMs[attempt - 1];
+		if (baseDelay === void 0) throw err;
+		const delayMs = baseDelay + Math.floor(Math.random() * Math.max(1, Math.floor(baseDelay / 4)));
+		onRetry?.({
+			attempt,
+			nextDelayMs: delayMs,
+			message
+		});
+		await new Promise((r) => setTimeout(r, delayMs));
+	}
+	throw lastErr;
+}
 function contextTreeReposDir() {
 	return join(defaultDataDir$1(), "context-tree-repos");
 }

package/dist/index.mjs

@@ -1,3 +1,3 @@
 import { c as blank, d as status, n as bindFeishuUser, t as bindFeishuBot } from "./feishu-DmpOdXci.mjs";
-import { A as installClientService, B as rotateClientIdWithBackup, C as checkClientConfig, D as printResults, E as checkWebSocket, F as startClientService, H as AuthRefreshRateLimitedError, I as stopClientService, K as resolveAccessToken, L as uninstallClientService, N as resolveCliInvocation, P as restartClientService, R as ClientRuntime, T as checkServerReachable, U as ensureFreshAccessToken, V as AuthRefreshFailedError, W as ensureFreshAdminToken, _ as onboardCheck, g as formatCheckReport, h as promptMissingFields, ht as SdkError, j as isServiceSupported, k as getClientServiceStatus, m as promptAddAgent, mt as FirstTreeHubSDK, p as isInteractive, q as resolveServerUrl, r as deriveHubUrlFromToken, t as HubUrlDerivationError, v as onboardCreate, w as checkNodeVersion, x as checkAgentConfigs, z as handleClientOrgMismatch } from "./connect-token-2AaEgnAr.mjs";
+import { A as installClientService, B as rotateClientIdWithBackup, C as checkClientConfig, D as printResults, E as checkWebSocket, F as startClientService, H as AuthRefreshRateLimitedError, I as stopClientService, K as resolveAccessToken, L as uninstallClientService, N as resolveCliInvocation, P as restartClientService, R as ClientRuntime, T as checkServerReachable, U as ensureFreshAccessToken, V as AuthRefreshFailedError, W as ensureFreshAdminToken, _ as onboardCheck, g as formatCheckReport, h as promptMissingFields, ht as SdkError, j as isServiceSupported, k as getClientServiceStatus, m as promptAddAgent, mt as FirstTreeHubSDK, p as isInteractive, q as resolveServerUrl, r as deriveHubUrlFromToken, t as HubUrlDerivationError, v as onboardCreate, w as checkNodeVersion, x as checkAgentConfigs, z as handleClientOrgMismatch } from "./connect-token-CJozTiUf.mjs";
 export { AuthRefreshFailedError, AuthRefreshRateLimitedError, ClientRuntime, FirstTreeHubSDK, HubUrlDerivationError, SdkError, bindFeishuBot, bindFeishuUser, blank, checkAgentConfigs, checkClientConfig, checkNodeVersion, checkServerReachable, checkWebSocket, deriveHubUrlFromToken, ensureFreshAccessToken, ensureFreshAdminToken, formatCheckReport, getClientServiceStatus, handleClientOrgMismatch, installClientService, isInteractive, isServiceSupported, onboardCheck, onboardCreate, printResults, promptAddAgent, promptMissingFields, resolveAccessToken, resolveCliInvocation, resolveServerUrl, restartClientService, rotateClientIdWithBackup, startClientService, status, stopClientService, uninstallClientService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "first-tree-staging",
-  "version": "0.5.2-staging.23.1",
+  "version": "0.5.2-staging.24.1",
   "type": "module",
   "description": "First Tree — unified CLI for Context Tree onboarding, GitHub Scan automation, agent management, and Hub messaging. (Source-tree dev build; CI rewrites `name` and `bin` for prod / staging publishes — see docs/local-dev-isolation.md.)",
   "keywords": [