fix(gitlab): recognize self-hosted GitLab on non-default ports over SSH connections; stop one project failing the whole issues panel (#5400)
* fix(gitlab): port-aware self-hosted host recognition
Use the URL host (including a non-default web/API port) as the GitLab
host identity instead of the port-less hostname, and match known hosts
port-aware:
- A known-host entry without a port matches any port of the same
hostname (preserves legacy bare-host and gitlab.com recognition).
- A known-host entry WITH a port matches only that exact host:port, so
two services sharing a hostname on different ports (e.g. a GitLab and
a Gitea) are no longer conflated.
- For ssh/git remotes the port is a transport port (e.g. ssh :2222) and
is dropped; for http(s) remotes the port is the endpoint and kept.
- Also capture an optional :port in parseGlabAuthStatusHosts so a
self-hosted GitLab on a non-default port is discovered correctly.
* fix(gitlab): per-connection known-hosts cache + port-aware auth-status parsing
getGlabKnownHosts() was connection-blind and cached process-globally,
and on any failure it cached [gitlab.com] forever — so a repo on an SSH
connection never discovered its self-hosted host once a probe failed
before the tunnel was ready.
- getGlabKnownHosts(connectionId?) now caches per connection so a
connected repo's authenticated hosts don't leak into the local
context (or vice versa).
- The failure fallback (canonical default) is no longer cached, so a
later probe can re-discover the real host once auth/tunnel is ready.
- parseGlabAuthStatusHosts captures an optional :port on both the
'Logged in to <host>' and header-style lines, keeping two services on
the same hostname distinct by port.
* fix(gitlab): isolate unresolvable projects instead of cwd-fallback that hits exit 128
listIssues/getIssue fell back to an unscoped 'glab issue list' / 'glab
issue view' that infers the project from cwd. For a repo on an SSH
connection cwd is not the repo dir, so glab runs git resolution in a
non-repo dir and fails with 'git: exit status 128'. In an 'All projects'
aggregate one such failure could sink the whole issues panel.
When a projectRef cannot be resolved, return a structured, isolated
per-project result (listIssues: { items: [], error: not_found };
getIssue: null) and spawn no glab subprocess. Behavior is unchanged when
a projectRef IS resolved (the scoped '-R' / 'api projects/...' path).
* fix(gitlab): recognize modern /-/work_items/<iid> issue URLs
Modern GitLab emits issue URLs as /-/work_items/<iid> in addition to the
legacy /-/issues/<iid>. The URL classifiers only matched /-/issues/, so
work-item-form issue links went unrecognized.
Extend the gitlab-links parsers (parseGitLabIssueOrMRNumber /
parseGitLabIssueOrMRLink, which also backs isWorkItemLookupText) and
isGitLabIssueUrl to accept /-/work_items/<iid>, mapping it to an issue
work item with the same project-path + iid extraction.
* fix(gitlab): thread connectionId into getGlabKnownHosts call sites
Follow the existing connectionId-threading pattern: pass the repo's
connectionId into every getGlabKnownHosts() call (client.ts,
work-item-details.ts, orca-runtime.ts) so the per-connection known-hosts
cache is keyed correctly and self-hosted hosts are discovered against
the right glab context.
* docs(gitlab): use generic example hosts in comments
* fix(gitlab): pass self-hosted host:port via GITLAB_HOST (glab --hostname rejects ports)
* polish: satisfy oxlint curly + oxfmt on merged gitlab port-recognition code
Co-authored-by: Orca <help@stably.ai>
---------
Co-authored-by: Ptah-CT <auctor@xinfty.space>
Co-authored-by: Neil <4138956+nwparker@users.noreply.github.com>
Co-authored-by: Orca <help@stably.ai>
This commit is contained in:
co-authored by
Orca
Ptah-CT
Neil
parent
25896f2cdb
commit
a10e1d7584
@@ -20,7 +20,17 @@ export type LocalGitExecOptions = {
|
||||
const PROJECT_REF_CACHE_MAX_ENTRIES = 512
|
||||
const projectRefCache = new Map<string, ProjectRef | null>()
|
||||
|
||||
let knownHostsCache: readonly string[] | null = null
|
||||
// Why: known hosts are cached PER connection. A repo on an SSH connection
|
||||
// authenticates against a different glab context than the local one, so a
|
||||
// process-global cache would leak one connection's hosts into another (and
|
||||
// poison a connection that probes before its tunnel is ready). The local
|
||||
// context uses the `'local'` key.
|
||||
const LOCAL_CONNECTION_KEY = 'local'
|
||||
const knownHostsCacheByConnection = new Map<string, readonly string[]>()
|
||||
|
||||
function connectionCacheKey(connectionId?: string | null): string {
|
||||
return connectionId ?? LOCAL_CONNECTION_KEY
|
||||
}
|
||||
|
||||
/** @internal - exposed for tests only */
|
||||
export function _resetProjectRefCache(): void {
|
||||
@@ -35,7 +45,7 @@ export function _getProjectRefCacheSize(): number {
|
||||
|
||||
/** @internal - exposed for tests only */
|
||||
export function _resetKnownHostsCache(): void {
|
||||
knownHostsCache = null
|
||||
knownHostsCacheByConnection.clear()
|
||||
}
|
||||
|
||||
function rememberProjectRefCacheEntry(cacheKey: string, value: ProjectRef | null): void {
|
||||
@@ -108,7 +118,7 @@ async function resolveProjectRefForRemote(
|
||||
localGitOptions
|
||||
))
|
||||
) {
|
||||
rememberGlabKnownHost(remoteCandidate.host)
|
||||
rememberGlabKnownHost(remoteCandidate.host, connectionId)
|
||||
rememberProjectRefCacheEntry(cacheKey, remoteCandidate)
|
||||
return remoteCandidate
|
||||
}
|
||||
@@ -220,12 +230,14 @@ export function glabHostnameArgs(
|
||||
return connectionId && projectRef?.host ? ['--hostname', projectRef.host] : []
|
||||
}
|
||||
|
||||
function rememberGlabKnownHost(host: string): void {
|
||||
function rememberGlabKnownHost(host: string, connectionId?: string | null): void {
|
||||
const normalizedHost = normalizeGitLabHost(host)
|
||||
if (!knownHostsCache || knownHostsCache.map(normalizeGitLabHost).includes(normalizedHost)) {
|
||||
const key = connectionCacheKey(connectionId)
|
||||
const cached = knownHostsCacheByConnection.get(key)
|
||||
if (!cached || cached.map(normalizeGitLabHost).includes(normalizedHost)) {
|
||||
return
|
||||
}
|
||||
knownHostsCache = [...knownHostsCache, normalizedHost]
|
||||
knownHostsCacheByConnection.set(key, [...cached, normalizedHost])
|
||||
}
|
||||
|
||||
async function isGlabConfiguredForRemoteHost(
|
||||
@@ -251,30 +263,47 @@ async function isGlabConfiguredForRemoteHost(
|
||||
}
|
||||
}
|
||||
|
||||
export async function getGlabKnownHosts(): Promise<readonly string[]> {
|
||||
if (knownHostsCache) {
|
||||
return knownHostsCache
|
||||
export async function getGlabKnownHosts(connectionId?: string | null): Promise<readonly string[]> {
|
||||
const key = connectionCacheKey(connectionId)
|
||||
const cached = knownHostsCacheByConnection.get(key)
|
||||
if (cached) {
|
||||
return cached
|
||||
}
|
||||
try {
|
||||
// Why: `glab auth status` is host-scoped, not cwd-scoped — glab reads its
|
||||
// own config to list authenticated hosts. The connectionId is threaded so
|
||||
// the RESULT is cached per connection (a connected repo can have a
|
||||
// different set of authenticated self-hosted hosts than the local one),
|
||||
// mirroring how project-ref resolution caches per connection.
|
||||
const { stdout, stderr } = await glabExecFileAsync(['auth', 'status'])
|
||||
const hosts = parseGlabAuthStatusHosts(`${stdout}\n${stderr}`)
|
||||
knownHostsCache = Array.from(new Set([...DEFAULT_GITLAB_HOSTS, ...hosts]))
|
||||
return knownHostsCache
|
||||
const merged = Array.from(new Set([...DEFAULT_GITLAB_HOSTS, ...hosts]))
|
||||
knownHostsCacheByConnection.set(key, merged)
|
||||
return merged
|
||||
} catch {
|
||||
knownHostsCache = [...DEFAULT_GITLAB_HOSTS]
|
||||
return knownHostsCache
|
||||
// Auth check failed (glab not installed, no auth, tunnel not ready,
|
||||
// etc.) — fall back to the canonical default for THIS call, but do NOT
|
||||
// cache the fallback. A later probe (e.g. after the SSH tunnel comes
|
||||
// up) must be able to discover the real self-hosted host.
|
||||
return [...DEFAULT_GITLAB_HOSTS]
|
||||
}
|
||||
}
|
||||
|
||||
export function parseGlabAuthStatusHosts(output: string): string[] {
|
||||
const hosts = new Set<string>()
|
||||
for (const m of output.matchAll(/logged in to ([a-zA-Z0-9.-]+)/gi)) {
|
||||
// Why: self-hosted GitLab can run on a non-default port (e.g.
|
||||
// `gitlab.example.com:8443`); capture the optional `:port` so two services
|
||||
// on the same hostname but different ports stay distinct downstream.
|
||||
for (const m of output.matchAll(/logged in to ([a-zA-Z0-9.-]+(?::\d+)?)/gi)) {
|
||||
hosts.add(m[1].toLowerCase())
|
||||
}
|
||||
for (const line of output.split('\n')) {
|
||||
const bareLine = line.trim()
|
||||
const hostLine = bareLine.endsWith(':') ? bareLine.slice(0, -1) : bareLine
|
||||
if (line === bareLine && /^[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?$/.test(hostLine)) {
|
||||
if (
|
||||
line === bareLine &&
|
||||
/^[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?(?::\d+)?$/.test(hostLine)
|
||||
) {
|
||||
hosts.add(hostLine.toLowerCase())
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user