timed out after s. If your network is slow, retry or set to…

Error message

${describeGitCommand(args)} timed out after ${timeoutSeconds(timeout)}s. If your network is slow, retry or set ${gitTimeoutEnvVar(args)} to a larger value.

What it means

gitRawIn runs a git command synchronously with execFileSync under a per-command timeout derived from the arguments. When git does not finish in time (isTimeoutLikeError), the raw git error is replaced with this clearer error naming the command, the timeout in seconds, and the environment variable that can raise the limit. It exists because network git operations (fetch/pull against GitHub) commonly stall on slow connections.

Solutions

Retry the command — transient network slowness often resolves on a second attempt.
Set the timeout environment variable named in the message (gitTimeoutEnvVar(args), e.g. CAREER_OPS_GIT_TIMEOUT_SECONDS) to a larger value and re-run.
Check connectivity to the git remote (git ls-remote <url> or ping the host) to rule out an outage or proxy issue.
If you are on a VPN/corporate proxy, try a network with direct access to the remote.

Example fix

// before
const out = gitRawIn(root, 'fetch', 'origin');

// after — raise the timeout via env before the call
process.env.CAREER_OPS_GIT_TIMEOUT_SECONDS = '600';
const out = gitRawIn(root, 'fetch', 'origin');

Defensive patterns

Strategy: try-catch

Validate before calling

const timeoutEnv = 'CAREER_OPS_GIT_TIMEOUT_SECONDS';
if (!process.env[timeoutEnv] && isSlowNetwork()) {
  process.env[timeoutEnv] = '600';
}

Type guard

null

Try / catch

try {
  const out = gitRawIn(root, 'fetch', 'origin');
} catch (err) {
  if (err.message.includes('timed out after')) {
    console.warn(`${err.message} — retrying once with a larger timeout`);
    process.env.CAREER_OPS_GIT_TIMEOUT_SECONDS = '600';
    // retry the operation
  } else throw err;
}

Prevention

Set CAREER_OPS_GIT_TIMEOUT_SECONDS generously (e.g. 600) on slow or metered connections.
Avoid running updates behind unstable VPNs or during known GitHub incidents.
Pre-warm the clone over a fast connection before scripted update runs.
Wrap automated update calls in a single retry with backoff.

When it happens

Trigger: Calling gitRawIn(root, ...args) for a network-bound command (e.g. fetch, pull, ls-remote, clone) whose execution exceeds gitTimeoutMs(args); the child process is killed by execFileSync's timeout option and the timeout-like error is converted to this throw.

Common situations: Running update-system.mjs apply/check on a slow or flaky network where `git fetch` of a large repo exceeds the default timeout; corporate proxies or VPNs adding latency; GitHub outages causing hangs; a cold clone over a slow link.

Understand the failure class

Background: Request timed out: what client-side request timeouts mean across libraries (Request timed out, TIMED_OUT, APITimeoutError) — this error's family across 39 libraries.

Timeouts: ETIMEDOUT, deadlines, and hung requests — what actually expires when a request times out.

Related errors

AI-assisted analysis of santifer/career-ops@e7abd431fc (2026-09-16). Data as JSON: /api/errors/483a6f7b8ddc0750. Report an issue: GitHub.

Appendix: source

Thrown at update-system.mjs:760

function gitTimeoutEnvVar(args) {
  return args[0] === 'fetch' ? 'CAREER_OPS_GIT_FETCH_TIMEOUT_MS' : 'CAREER_OPS_GIT_TIMEOUT_MS';
}

/**
 * gitIn without the trailing/leading trim.
 *
 * Needed for output where whitespace is significant: `--name-only -z` emits
 * NUL-delimited paths, and a path may legitimately begin or end with a space.
 * Trimming the whole buffer would rewrite such a path into a different one.
 * Everything else should keep using gitIn.
 */
export function gitRawIn(root, ...args) {
  const timeout = gitTimeoutMs(args);
  try {
    return execFileSync('git', args, { cwd: root, encoding: 'utf-8', timeout });
  } catch (err) {
    if (isTimeoutLikeError(err)) {
      throw new Error(`${describeGitCommand(args)} timed out after ${timeoutSeconds(timeout)}s. If your network is slow, retry or set ${gitTimeoutEnvVar(args)} to a larger value.`);
    }
    throw err;
  }
}

export function gitIn(root, ...args) {
  return gitRawIn(root, ...args).trim();
}

function git(...args) {
  return gitIn(ROOT, ...args);
}

/**
 * git(), but with the child's stderr piped instead of inherited.
 *
 * execFileSync inherits stderr by default, so a command whose failure is
 * expected and handled still prints git's raw error to the console. Use this

View on GitHub (pinned to e7abd431fc)