@tmux-web/ext-gh-workflow 0.1.0

package/dist/gh-client.d.ts

@@ -0,0 +1,24 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+type SpawnFn = typeof nodeSpawn;
+/** @internal test hook */
+export declare function __setExecFileForTests(fn: SpawnFn | null): void;
+export type GhApiResult = {
+    status: number;
+    body: unknown;
+};
+export declare function parseGhIncludeOutput(stdout: string): GhApiResult;
+export declare function runGh(args: string[], input?: string): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function ghApi(endpoint: string, options?: {
+    method?: string;
+    body?: unknown;
+}): Promise<GhApiResult>;
+export declare function checkGhAuth(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+}>;
+export {};

package/dist/gh-client.js

@@ -0,0 +1,177 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+let spawnImpl = nodeSpawn;
+/** @internal test hook */
+export function __setExecFileForTests(fn) {
+    spawnImpl = fn ?? nodeSpawn;
+}
+function ghEnv() {
+    const env = { ...process.env };
+    if (env.GITHUB_PAT && !env.GH_TOKEN && !env.GITHUB_TOKEN) {
+        env.GH_TOKEN = env.GITHUB_PAT;
+    }
+    return env;
+}
+function normalizeEndpoint(endpoint) {
+    return endpoint.startsWith('/') ? endpoint.slice(1) : endpoint;
+}
+export function parseGhIncludeOutput(stdout) {
+    if (!stdout)
+        return { status: 204, body: null };
+    const sep = stdout.includes('\r\n\r\n') ? '\r\n\r\n' : '\n\n';
+    const splitIdx = stdout.indexOf(sep);
+    if (splitIdx === -1) {
+        const statusLine = stdout.trim().split(/\r?\n/)[0] ?? '';
+        const statusMatch = statusLine.match(/\s(\d{3})\s/);
+        if (statusMatch) {
+            return { status: Number(statusMatch[1]), body: null };
+        }
+        try {
+            return { status: 200, body: JSON.parse(stdout.trim()) };
+        }
+        catch {
+            return { status: 200, body: stdout.trim() };
+        }
+    }
+    const headerBlock = stdout.slice(0, splitIdx);
+    const bodyText = stdout.slice(splitIdx + sep.length).trim();
+    const statusLine = headerBlock.split(/\r?\n/)[0] ?? '';
+    const statusMatch = statusLine.match(/\s(\d{3})\s/);
+    const status = statusMatch ? Number(statusMatch[1]) : 200;
+    if (!bodyText)
+        return { status, body: null };
+    try {
+        return { status, body: JSON.parse(bodyText) };
+    }
+    catch {
+        return { status, body: bodyText };
+    }
+}
+function authErrorMessage(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes('gh auth login')
+        || lower.includes('not logged in')
+        || lower.includes('authentication')
+        || lower.includes('no oauth token')
+        || lower.includes('gh_token')) {
+        return 'GitHub CLI is not authenticated. Run `gh auth login` or set GH_TOKEN/GITHUB_PAT.';
+    }
+    return null;
+}
+function ghNotFoundMessage(err) {
+    if (err.code === 'ENOENT') {
+        return {
+            status: 503,
+            body: { error: 'GitHub CLI (gh) not found in PATH. Install gh or set GH_TOKEN/GITHUB_PAT.' },
+        };
+    }
+    return null;
+}
+export async function runGh(args, input) {
+    const options = {
+        env: ghEnv(),
+    };
+    return new Promise((resolve, reject) => {
+        const child = spawnImpl('gh', args, options);
+        const maxBuffer = 10 * 1024 * 1024;
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        function finishWithError(err) {
+            if (settled)
+                return;
+            settled = true;
+            err.stdout = stdout;
+            err.stderr = stderr;
+            reject(err);
+        }
+        child.stdout.on('data', (chunk) => {
+            stdout += String(chunk);
+            if (stdout.length + stderr.length > maxBuffer) {
+                child.kill();
+                finishWithError(Object.assign(new Error('gh output exceeded max buffer'), { code: 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' }));
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+            if (stdout.length + stderr.length > maxBuffer) {
+                child.kill();
+                finishWithError(Object.assign(new Error('gh output exceeded max buffer'), { code: 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' }));
+            }
+        });
+        child.on('error', (err) => finishWithError(err));
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (code && code !== 0) {
+                const err = Object.assign(new Error(`gh exited with code ${code}`), {
+                    code,
+                    stdout,
+                    stderr,
+                });
+                reject(err);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+        child.stdin.end(input);
+    });
+}
+export async function ghApi(endpoint, options) {
+    const args = ['api', '--include', normalizeEndpoint(endpoint)];
+    const method = options?.method?.toUpperCase();
+    if (method && method !== 'GET') {
+        args.push('-X', method);
+    }
+    const input = options?.body !== undefined ? JSON.stringify(options.body) : undefined;
+    if (input !== undefined) {
+        args.push('--input', '-');
+    }
+    try {
+        const { stdout } = await runGh(args, input);
+        return parseGhIncludeOutput(stdout);
+    }
+    catch (err) {
+        const execErr = err;
+        const notFound = ghNotFoundMessage(execErr);
+        if (notFound)
+            return notFound;
+        const combined = `${execErr.stdout ?? ''}\n${execErr.stderr ?? ''}`.trim();
+        const authMsg = authErrorMessage(combined);
+        if (authMsg)
+            return { status: 401, body: { error: authMsg } };
+        if (execErr.stdout?.trim()) {
+            const parsed = parseGhIncludeOutput(execErr.stdout);
+            if (parsed.status >= 400)
+                return parsed;
+        }
+        try {
+            const body = combined ? JSON.parse(combined) : { error: combined || 'GitHub CLI request failed' };
+            return { status: 502, body };
+        }
+        catch {
+            return { status: 502, body: { error: combined || 'GitHub CLI request failed' } };
+        }
+    }
+}
+export async function checkGhAuth() {
+    try {
+        await runGh(['auth', 'status']);
+        return { ok: true };
+    }
+    catch (err) {
+        const execErr = err;
+        const notFound = ghNotFoundMessage(execErr);
+        if (notFound)
+            return { ok: false, reason: String(notFound.body.error) };
+        if (process.env.GH_TOKEN || process.env.GITHUB_TOKEN || process.env.GITHUB_PAT) {
+            return { ok: true };
+        }
+        const combined = `${execErr.stdout ?? ''}\n${execErr.stderr ?? ''}`.trim();
+        const authMsg = authErrorMessage(combined);
+        return {
+            ok: false,
+            reason: authMsg ?? (combined || 'GitHub CLI authentication check failed'),
+        };
+    }
+}

package/dist/gh-repo.d.ts

@@ -0,0 +1,14 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+export interface GhRepoInfo {
+    nameWithOwner: string;
+    org: string;
+    repo: string;
+}
+type ExecFileFn = typeof nodeExecFile;
+/** @internal test hook */
+export declare function __setExecFileForRepoTests(fn: ExecFileFn | null): void;
+/** Resolve GitHub repo info from a directory (uses git root + gh repo view). */
+export declare function ghRepoView(cwd: string): Promise<GhRepoInfo | null>;
+/** @deprecated use ghRepoView */
+export declare const ghRepoViewFromDir: typeof ghRepoView;
+export {};

package/dist/gh-repo.js

@@ -0,0 +1,58 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+let execFileImpl = nodeExecFile;
+/** @internal test hook */
+export function __setExecFileForRepoTests(fn) {
+    execFileImpl = fn ?? nodeExecFile;
+}
+function gitRepoRoot(cwd) {
+    return new Promise((resolve) => {
+        execFileImpl('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], { encoding: 'utf-8' }, (err, stdout) => {
+            if (err)
+                resolve(null);
+            else
+                resolve(stdout?.trim() || null);
+        });
+    });
+}
+function runGhFromDir(dir, args) {
+    return new Promise((resolve, reject) => {
+        execFileImpl('gh', args, { cwd: dir, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err)
+                reject(err);
+            else
+                resolve({
+                    stdout: stdout == null ? '' : String(stdout),
+                    stderr: stderr == null ? '' : String(stderr),
+                });
+        });
+    });
+}
+/** Resolve GitHub repo info from a directory (uses git root + gh repo view). */
+export async function ghRepoView(cwd) {
+    const repoRoot = await gitRepoRoot(cwd);
+    if (!repoRoot)
+        return null;
+    try {
+        const { stdout } = await runGhFromDir(repoRoot, [
+            'repo', 'view',
+            '--json', 'nameWithOwner,name,owner',
+        ]);
+        const jsonText = stdout.trim();
+        if (!jsonText)
+            return null;
+        const data = JSON.parse(jsonText);
+        const nameWithOwner = data.nameWithOwner
+            ?? (data.owner?.login && data.name ? `${data.owner.login}/${data.name}` : null);
+        if (!nameWithOwner)
+            return null;
+        const [org, repo] = nameWithOwner.split('/');
+        if (!org || !repo)
+            return null;
+        return { nameWithOwner, org, repo };
+    }
+    catch {
+        return null;
+    }
+}
+/** @deprecated use ghRepoView */
+export const ghRepoViewFromDir = ghRepoView;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { __setExecFileForTests, checkGhAuth, ghApi, parseGhIncludeOutput, runGh, type GhApiResult, } from './gh-client.js';
+export { __setExecFileForRepoTests, ghRepoView, ghRepoViewFromDir, type GhRepoInfo, } from './gh-repo.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { __setExecFileForTests, checkGhAuth, ghApi, parseGhIncludeOutput, runGh, } from './gh-client.js';
+export { __setExecFileForRepoTests, ghRepoView, ghRepoViewFromDir, } from './gh-repo.js';

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tmux-web/ext-gh-workflow",
+  "version": "0.1.0",
+  "description": "Shared GitHub CLI helpers for tmux-web extensions",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ashutoshpw/tmux-web",
+    "directory": "packages/ext-gh-workflow"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.9"
+  }
+}