botmux 3.2.0 → 3.2.1

package/dist/services/skill-registry-store.js

@@ -1,10 +1,11 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { closeSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, realpathSync, rmSync, statSync } from 'node:fs';
 import { execFile, execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { atomicWriteFileSync } from '../utils/atomic-write.js';
 import { withFileLock, withFileLockSync } from '../utils/file-lock.js';
+import { githubGitAuthEnv } from '../core/github-auth.js';
 import { loadSkillPackage } from '../core/skills/package.js';
 import { skillRegistryPath, skillSourcesDir, skillStoreDir } from '../core/skills/registry-paths.js';
 import { assertAllowedGitProtocol, assertNoGitUrlCredentials, assertSafeGitRef, assertSafeGitSkillPath, githubToGitUrl, redactGitUrlCredentials } from '../core/skills/sources.js';
@@ -30,6 +31,79 @@ function writeSkillRegistry(registry) {
     mkdirSync(dirname(skillRegistryPath()), { recursive: true });
     atomicWriteFileSync(skillRegistryPath(), JSON.stringify(registry, null, 2) + '\n', { mode: 0o600 });
 }
+function shebangRuntime(path) {
+    const buffer = Buffer.alloc(256);
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+        const length = readSync(fd, buffer, 0, buffer.length, 0);
+        const line = buffer.subarray(0, length).toString('utf8').split(/\r?\n/, 1)[0];
+        const match = /^#!\s*(\S+)(?:\s+(\S+))?/.exec(line);
+        if (!match)
+            return undefined;
+        const command = basename(match[1]);
+        return command === 'env' && match[2] ? basename(match[2]) : command;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+/** Static, non-executing install audit. Paths are relative to the Skill root;
+ * source URLs and absolute host paths are deliberately excluded from logs. */
+export function buildSkillInstallAuditSummary(pkg) {
+    let files = 0;
+    let directories = 0;
+    let symlinks = 0;
+    let bytes = 0;
+    const executablePaths = [];
+    const runtimes = new Set();
+    const pending = [''];
+    while (pending.length > 0) {
+        const relDir = pending.pop();
+        const absDir = relDir ? join(pkg.rootDir, relDir) : pkg.rootDir;
+        for (const entry of readdirSync(absDir, { withFileTypes: true })) {
+            const rel = (relDir ? join(relDir, entry.name) : entry.name).replace(/\\/g, '/');
+            const abs = join(pkg.rootDir, rel);
+            if (entry.isSymbolicLink()) {
+                symlinks++;
+                continue;
+            }
+            if (entry.isDirectory()) {
+                directories++;
+                pending.push(rel);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            files++;
+            const stat = lstatSync(abs);
+            bytes += stat.size;
+            if ((stat.mode & 0o111) !== 0) {
+                executablePaths.push(rel);
+                runtimes.add(shebangRuntime(abs) ?? 'native');
+            }
+        }
+    }
+    executablePaths.sort();
+    const commit = pkg.source.type === 'git' || pkg.source.type === 'github' ? pkg.source.commit : undefined;
+    return {
+        name: pkg.name,
+        sourceType: pkg.source.type,
+        ...(commit ? { commit } : {}),
+        ...(pkg.version ? { version: pkg.version } : {}),
+        files,
+        directories,
+        symlinks,
+        bytes,
+        executables: executablePaths.slice(0, 32),
+        executablesTruncated: executablePaths.length > 32,
+        runtimes: [...runtimes].sort(),
+    };
+}
 export function installLocalSkill(dir, opts) {
     const sourceDir = resolve(dir);
     const provisional = loadSkillPackage(sourceDir, {
@@ -288,34 +362,62 @@ function formatGitFailure(args, err) {
 // transport ever reached this layer, git itself refuses anything outside the
 // allowlist. GIT_TERMINAL_PROMPT=0 also keeps a private repo from hanging on an
 // interactive credential prompt instead of failing fast.
-function gitEnv() {
+function isGithubHttpsUrl(raw) {
+    if (!raw)
+        return false;
+    try {
+        const url = new URL(raw);
+        return url.protocol === 'https:' && (url.hostname === 'github.com' || url.hostname === 'www.github.com');
+    }
+    catch {
+        return false;
+    }
+}
+function githubSshUrl(raw) {
+    if (!isGithubHttpsUrl(raw))
+        return null;
+    try {
+        const url = new URL(raw);
+        const path = url.pathname.replace(/^\/+/, '');
+        return path ? `git@github.com:${path}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isGitAuthenticationFailure(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return /authentication failed|could not read username|terminal prompts disabled|repository not found|unauthor|\b401\b|\b403\b/i.test(message);
+}
+function gitEnv(extraEnv) {
     return {
         ...process.env,
         GIT_ALLOW_PROTOCOL: 'https:http:ssh:git:file',
         GIT_TERMINAL_PROMPT: '0',
+        ...extraEnv,
     };
 }
-function git(args, cwd) {
+function git(args, cwd, extraEnv) {
     try {
         return execFileSync('git', args, {
             cwd,
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'pipe'],
             timeout: gitTimeoutMs(),
-            env: gitEnv(),
+            env: gitEnv(extraEnv),
         }).trim();
     }
     catch (err) {
         throw formatGitFailure(args, err);
     }
 }
-async function gitAsync(args, cwd) {
+async function gitAsync(args, cwd, extraEnv) {
     try {
         const result = await execFileAsync('git', args, {
             cwd,
             encoding: 'utf-8',
             timeout: gitTimeoutMs(),
-            env: gitEnv(),
+            env: gitEnv(extraEnv),
         });
         return String(result.stdout ?? '').trim();
     }
@@ -323,16 +425,144 @@ async function gitAsync(args, cwd) {
         throw formatGitFailure(args, err);
     }
 }
+function gitErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function gitFallbackFailure(httpsError, anonymousError, sshError) {
+    return new Error([
+        gitErrorMessage(httpsError),
+        ...(anonymousError && anonymousError !== httpsError
+            ? [`anonymous HTTPS retry failed: ${gitErrorMessage(anonymousError)}`]
+            : []),
+        ...(sshError ? [`ssh fallback failed: ${gitErrorMessage(sshError)}`] : []),
+    ].join('; '));
+}
+/**
+ * For GitHub HTTPS, try the botmux-resolved token first. If that credential is
+ * stale, retry the same operation without botmux's header so public repos and
+ * system credential helpers still work, then use SSH only after the anonymous
+ * HTTPS attempt also proves to be an authentication failure.
+ */
+function withGithubHttpsFallback(url, attemptHttps, attemptSsh) {
+    const sshUrl = githubSshUrl(url);
+    const authEnv = sshUrl ? githubGitAuthEnv() : {};
+    const hasBotmuxAuth = Object.keys(authEnv).length > 0;
+    try {
+        return attemptHttps(hasBotmuxAuth ? authEnv : undefined);
+    }
+    catch (httpsError) {
+        if (!sshUrl || !isGitAuthenticationFailure(httpsError))
+            throw httpsError;
+        let anonymousError = httpsError;
+        if (hasBotmuxAuth) {
+            try {
+                return attemptHttps();
+            }
+            catch (error) {
+                anonymousError = error;
+                if (!isGitAuthenticationFailure(error)) {
+                    throw gitFallbackFailure(httpsError, anonymousError);
+                }
+            }
+        }
+        try {
+            return attemptSsh(sshUrl);
+        }
+        catch (sshError) {
+            throw gitFallbackFailure(httpsError, anonymousError, sshError);
+        }
+    }
+}
+async function withGithubHttpsFallbackAsync(url, attemptHttps, attemptSsh) {
+    const sshUrl = githubSshUrl(url);
+    const authEnv = sshUrl ? githubGitAuthEnv() : {};
+    const hasBotmuxAuth = Object.keys(authEnv).length > 0;
+    try {
+        return await attemptHttps(hasBotmuxAuth ? authEnv : undefined);
+    }
+    catch (httpsError) {
+        if (!sshUrl || !isGitAuthenticationFailure(httpsError))
+            throw httpsError;
+        let anonymousError = httpsError;
+        if (hasBotmuxAuth) {
+            try {
+                return await attemptHttps();
+            }
+            catch (error) {
+                anonymousError = error;
+                if (!isGitAuthenticationFailure(error)) {
+                    throw gitFallbackFailure(httpsError, anonymousError);
+                }
+            }
+        }
+        try {
+            return await attemptSsh(sshUrl);
+        }
+        catch (sshError) {
+            throw gitFallbackFailure(httpsError, anonymousError, sshError);
+        }
+    }
+}
+function cloneGitSource(url, dir) {
+    withGithubHttpsFallback(url, authEnv => {
+        rmSync(dir, { recursive: true, force: true });
+        git(['clone', '--', url, dir], skillSourcesDir(), authEnv);
+    }, sshUrl => {
+        rmSync(dir, { recursive: true, force: true });
+        git(['clone', '--', sshUrl, dir], skillSourcesDir());
+        // The cache identity and registry keep the canonical HTTPS source. Future
+        // updates re-evaluate HTTPS credentials before falling back to SSH again.
+        git(['remote', 'set-url', 'origin', url], dir);
+    });
+}
+async function cloneGitSourceAsync(url, dir) {
+    await withGithubHttpsFallbackAsync(url, async (authEnv) => {
+        rmSync(dir, { recursive: true, force: true });
+        await gitAsync(['clone', '--', url, dir], skillSourcesDir(), authEnv);
+    }, async (sshUrl) => {
+        rmSync(dir, { recursive: true, force: true });
+        await gitAsync(['clone', '--', sshUrl, dir], skillSourcesDir());
+        await gitAsync(['remote', 'set-url', 'origin', url], dir);
+    });
+}
+function fetchGitSource(url, dir, args) {
+    if (isGithubHttpsUrl(url))
+        git(['remote', 'set-url', 'origin', url], dir);
+    return withGithubHttpsFallback(url, authEnv => git(args, dir, authEnv), sshUrl => {
+        git(['remote', 'set-url', 'origin', sshUrl], dir);
+        try {
+            return git(args, dir);
+        }
+        finally {
+            git(['remote', 'set-url', 'origin', url], dir);
+        }
+    });
+}
+async function fetchGitSourceAsync(url, dir, args) {
+    if (isGithubHttpsUrl(url))
+        await gitAsync(['remote', 'set-url', 'origin', url], dir);
+    return withGithubHttpsFallbackAsync(url, authEnv => gitAsync(args, dir, authEnv), async (sshUrl) => {
+        await gitAsync(['remote', 'set-url', 'origin', sshUrl], dir);
+        try {
+            return await gitAsync(args, dir);
+        }
+        finally {
+            await gitAsync(['remote', 'set-url', 'origin', url], dir);
+        }
+    });
+}
 function ensureGitSource(url) {
     assertNoGitUrlCredentials(url);
     assertAllowedGitProtocol(url);
     const dir = join(skillSourcesDir(), sourceId(url));
     mkdirSync(skillSourcesDir(), { recursive: true });
     if (existsSync(join(dir, '.git'))) {
-        git(['fetch', '--tags', '--prune'], dir);
+        fetchGitSource(url, dir, ['fetch', '--tags', '--prune']);
     }
     else {
-        git(['clone', '--', url, dir]);
+        // Never inherit the daemon's cwd for clone: a daemon can outlive the
+        // checkout it was launched from, leaving process.cwd() deleted.
+        cloneGitSource(url, dir);
     }
     return dir;
 }
@@ -341,7 +571,7 @@ function checkoutGitSource(url, refValue) {
     const sourceDir = ensureGitSource(url);
     const ref = refValue ?? 'HEAD';
     if (ref === 'HEAD') {
-        git(['fetch', 'origin', 'HEAD'], sourceDir);
+        fetchGitSource(url, sourceDir, ['fetch', 'origin', 'HEAD']);
         git(['checkout', 'FETCH_HEAD'], sourceDir);
     }
     else {
@@ -355,10 +585,12 @@ async function ensureGitSourceAsync(url) {
     const dir = join(skillSourcesDir(), sourceId(url));
     mkdirSync(skillSourcesDir(), { recursive: true });
     if (existsSync(join(dir, '.git'))) {
-        await gitAsync(['fetch', '--tags', '--prune'], dir);
+        await fetchGitSourceAsync(url, dir, ['fetch', '--tags', '--prune']);
     }
     else {
-        await gitAsync(['clone', '--', url, dir]);
+        // See the synchronous path above: dashboard jobs must also be independent
+        // from a stale/deleted daemon launch directory.
+        await cloneGitSourceAsync(url, dir);
     }
     return dir;
 }
@@ -367,7 +599,7 @@ async function checkoutGitSourceAsync(url, refValue) {
     const sourceDir = await ensureGitSourceAsync(url);
     const ref = refValue ?? 'HEAD';
     if (ref === 'HEAD') {
-        await gitAsync(['fetch', 'origin', 'HEAD'], sourceDir);
+        await fetchGitSourceAsync(url, sourceDir, ['fetch', 'origin', 'HEAD']);
         await gitAsync(['checkout', 'FETCH_HEAD'], sourceDir);
     }
     else {
@@ -375,31 +607,89 @@ async function checkoutGitSourceAsync(url, refValue) {
     }
     return { sourceDir, ref, commit: await gitAsync(['rev-parse', 'HEAD'], sourceDir) };
 }
-export function discoverGitSkillCandidates(opts) {
-    return withGitSourceLockSync(opts.url, () => {
-        const { sourceDir, commit } = checkoutGitSource(opts.url, opts.ref);
-        if (opts.path) {
-            const candidate = candidateFromDir(sourceDir, gitSkillDir(sourceDir, opts.path));
-            return { commit, skills: candidate ? [candidate] : [] };
+function discoverCheckedOutGitSource(sourceDir, commit, opts) {
+    if (opts.path) {
+        const candidate = candidateFromDir(sourceDir, gitSkillDir(sourceDir, opts.path));
+        return { commit, skills: candidate ? [candidate] : [] };
+    }
+    return {
+        commit,
+        skills: discoverLocalSkillCandidates(sourceDir, { fullDepth: opts.fullDepth }).skills,
+    };
+}
+function checkoutTemporaryGitSource(url, refValue) {
+    assertNoGitUrlCredentials(url);
+    assertAllowedGitProtocol(url);
+    assertSafeGitRef(refValue);
+    mkdirSync(skillSourcesDir(), { recursive: true });
+    const staging = mkdtempSync(join(skillSourcesDir(), '.discover-'));
+    const sourceDir = join(staging, 'repo');
+    try {
+        cloneGitSource(url, sourceDir);
+        const ref = refValue ?? 'HEAD';
+        if (ref === 'HEAD') {
+            fetchGitSource(url, sourceDir, ['fetch', 'origin', 'HEAD']);
+            git(['checkout', 'FETCH_HEAD'], sourceDir);
+        }
+        else {
+            git(['checkout', ref], sourceDir);
         }
         return {
-            commit,
-            skills: discoverLocalSkillCandidates(sourceDir, { fullDepth: opts.fullDepth }).skills,
+            sourceDir,
+            commit: git(['rev-parse', 'HEAD'], sourceDir),
+            cleanup: () => rmSync(staging, { recursive: true, force: true }),
         };
-    });
+    }
+    catch (error) {
+        rmSync(staging, { recursive: true, force: true });
+        throw error;
+    }
 }
-export async function discoverGitSkillCandidatesAsync(opts) {
-    return withGitSourceLock(opts.url, async () => {
-        const { sourceDir, commit } = await checkoutGitSourceAsync(opts.url, opts.ref);
-        if (opts.path) {
-            const candidate = candidateFromDir(sourceDir, gitSkillDir(sourceDir, opts.path));
-            return { commit, skills: candidate ? [candidate] : [] };
+async function checkoutTemporaryGitSourceAsync(url, refValue) {
+    assertNoGitUrlCredentials(url);
+    assertAllowedGitProtocol(url);
+    assertSafeGitRef(refValue);
+    mkdirSync(skillSourcesDir(), { recursive: true });
+    const staging = mkdtempSync(join(skillSourcesDir(), '.discover-'));
+    const sourceDir = join(staging, 'repo');
+    try {
+        await cloneGitSourceAsync(url, sourceDir);
+        const ref = refValue ?? 'HEAD';
+        if (ref === 'HEAD') {
+            await fetchGitSourceAsync(url, sourceDir, ['fetch', 'origin', 'HEAD']);
+            await gitAsync(['checkout', 'FETCH_HEAD'], sourceDir);
+        }
+        else {
+            await gitAsync(['checkout', ref], sourceDir);
         }
         return {
-            commit,
-            skills: discoverLocalSkillCandidates(sourceDir, { fullDepth: opts.fullDepth }).skills,
+            sourceDir,
+            commit: await gitAsync(['rev-parse', 'HEAD'], sourceDir),
+            cleanup: () => rmSync(staging, { recursive: true, force: true }),
         };
-    });
+    }
+    catch (error) {
+        rmSync(staging, { recursive: true, force: true });
+        throw error;
+    }
+}
+export function discoverGitSkillCandidates(opts) {
+    const checkout = checkoutTemporaryGitSource(opts.url, opts.ref);
+    try {
+        return discoverCheckedOutGitSource(checkout.sourceDir, checkout.commit, opts);
+    }
+    finally {
+        checkout.cleanup();
+    }
+}
+export async function discoverGitSkillCandidatesAsync(opts) {
+    const checkout = await checkoutTemporaryGitSourceAsync(opts.url, opts.ref);
+    try {
+        return discoverCheckedOutGitSource(checkout.sourceDir, checkout.commit, opts);
+    }
+    finally {
+        checkout.cleanup();
+    }
 }
 export function installGitSkill(opts) {
     return withGitSourceLockSync(opts.url, () => installGitSkillLocked(opts));
@@ -457,28 +747,34 @@ function sourceOverrideForCandidate(source, candidate) {
     return source;
 }
 export function installGitSkillsFromSource(opts) {
-    const discovery = discoverGitSkillCandidates({ url: opts.url, ref: opts.ref, fullDepth: opts.fullDepth });
-    const selected = selectDiscoveredSkills(discovery.skills, opts);
-    return selected.map(candidate => installGitSkill({
-        url: opts.url,
-        path: candidate.path,
-        ref: opts.ref,
-        sourceOverride: sourceOverrideForCandidate(opts.sourceOverride, candidate),
-    }));
-}
-export async function installGitSkillsFromSourceAsync(opts) {
-    const discovery = await discoverGitSkillCandidatesAsync({ url: opts.url, ref: opts.ref, fullDepth: opts.fullDepth });
-    const selected = selectDiscoveredSkills(discovery.skills, opts);
-    const installed = [];
-    for (const candidate of selected) {
-        installed.push(await installGitSkillAsync({
+    return withGitSourceLockSync(opts.url, () => {
+        const checkout = checkoutGitSource(opts.url, opts.ref);
+        const discovery = discoverCheckedOutGitSource(checkout.sourceDir, checkout.commit, { fullDepth: opts.fullDepth });
+        const selected = selectDiscoveredSkills(discovery.skills, opts);
+        return selected.map(candidate => installGitSkillLocked({
             url: opts.url,
             path: candidate.path,
             ref: opts.ref,
             sourceOverride: sourceOverrideForCandidate(opts.sourceOverride, candidate),
         }));
-    }
-    return installed;
+    });
+}
+export async function installGitSkillsFromSourceAsync(opts) {
+    return withGitSourceLock(opts.url, async () => {
+        const checkout = await checkoutGitSourceAsync(opts.url, opts.ref);
+        const discovery = discoverCheckedOutGitSource(checkout.sourceDir, checkout.commit, { fullDepth: opts.fullDepth });
+        const selected = selectDiscoveredSkills(discovery.skills, opts);
+        const installed = [];
+        for (const candidate of selected) {
+            installed.push(await installGitSkillAsyncLocked({
+                url: opts.url,
+                path: candidate.path,
+                ref: opts.ref,
+                sourceOverride: sourceOverrideForCandidate(opts.sourceOverride, candidate),
+            }));
+        }
+        return installed;
+    });
 }
 // --- agentbuddy (external CLI) skill source ---------------------------------
 //