@tmux-web/ext-git-workflow 0.1.0

package/dist/backend/git.js

@@ -0,0 +1,214 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+const GIT_TIMEOUT_MS = 15_000;
+function git(args, cwd) {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }).trimEnd();
+}
+export function repoRoot(cwd) {
+    try {
+        return git(['rev-parse', '--show-toplevel'], cwd);
+    }
+    catch {
+        return null;
+    }
+}
+export function worktreeRootDir() {
+    return path.join(os.homedir(), '.worktrees');
+}
+export function classifyKind(cwd) {
+    const root = worktreeRootDir() + path.sep;
+    return cwd.startsWith(root) ? 'worktree' : 'local';
+}
+export function buildWorktreePath(org, repo, id) {
+    return path.join(worktreeRootDir(), org, repo, id);
+}
+export function generateWorktreeId() {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    const bytes = randomBytes(8);
+    let out = '';
+    for (let i = 0; i < 8; i++) {
+        out += chars[bytes[i] % chars.length];
+    }
+    return out;
+}
+export function resolveMainRepoPath(repoRootPath) {
+    try {
+        const out = git(['worktree', 'list', '--porcelain'], repoRootPath);
+        for (const line of out.split('\n')) {
+            if (line.startsWith('worktree ')) {
+                return line.slice('worktree '.length).trim();
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return repoRootPath;
+}
+export function parseCheckedOutBranches(worktreeListPorcelain) {
+    const branches = new Set();
+    for (const line of worktreeListPorcelain.split('\n')) {
+        if (!line.startsWith('branch '))
+            continue;
+        const ref = line.slice('branch '.length).trim();
+        if (ref.startsWith('refs/heads/')) {
+            branches.add(ref.slice('refs/heads/'.length));
+        }
+    }
+    return branches;
+}
+export function isBranchCheckedOut(repoRootPath, branch) {
+    const trimmed = branch.trim();
+    if (!trimmed)
+        return false;
+    try {
+        return parseCheckedOutBranches(git(['worktree', 'list', '--porcelain'], repoRootPath)).has(trimmed);
+    }
+    catch {
+        return false;
+    }
+}
+export function getGitStatus(repoRootPath) {
+    const branch = git(['branch', '--show-current'], repoRootPath) || 'HEAD';
+    let added = 0;
+    let removed = 0;
+    let dirty = false;
+    try {
+        const porcelain = git(['status', '--porcelain'], repoRootPath);
+        if (porcelain) {
+            dirty = true;
+            for (const line of porcelain.split('\n')) {
+                if (!line.trim())
+                    continue;
+                const idx = line.slice(0, 2);
+                if (idx[0] !== ' ' && idx[0] !== '?')
+                    added++;
+                if (idx[1] !== ' ' && idx[1] !== '?')
+                    removed++;
+                if (idx === '??')
+                    added++;
+            }
+        }
+    }
+    catch {
+        dirty = false;
+    }
+    let ahead = 0;
+    let behind = 0;
+    try {
+        const ab = git(['rev-list', '--left-right', '--count', '@{upstream}...HEAD'], repoRootPath);
+        const [b, a] = ab.split('\t').map((n) => parseInt(n, 10));
+        if (Number.isFinite(a))
+            ahead = a;
+        if (Number.isFinite(b))
+            behind = b;
+    }
+    catch {
+        // no upstream
+    }
+    return { branch, dirty, changes: { added, removed }, ahead, behind };
+}
+export function listBranchNames(repoRootPath) {
+    try {
+        const out = git(['branch', '-a', '--format=%(refname:short)'], repoRootPath);
+        const seen = new Set();
+        const branches = [];
+        for (const raw of out.split('\n')) {
+            let name = raw.trim();
+            if (!name)
+                continue;
+            if (name.startsWith('origin/'))
+                name = name.slice('origin/'.length);
+            if (name === 'HEAD' || name.includes('->'))
+                continue;
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            branches.push(name);
+        }
+        branches.sort((a, b) => a.localeCompare(b));
+        return branches;
+    }
+    catch {
+        return [];
+    }
+}
+export function branchExists(repoRootPath, branch) {
+    const trimmed = branch.trim();
+    if (!trimmed)
+        return { exists: false };
+    try {
+        const local = git(['branch', '--list', trimmed], repoRootPath);
+        if (local.trim())
+            return { exists: true, source: 'local' };
+    }
+    catch { /* ignore */ }
+    try {
+        const remote = git(['ls-remote', '--heads', 'origin', `refs/heads/${trimmed}`], repoRootPath);
+        if (remote.trim())
+            return { exists: true, source: 'remote' };
+    }
+    catch { /* ignore */ }
+    return { exists: false };
+}
+export function ensureLocalBranch(repoRootPath, branch) {
+    try {
+        const local = git(['branch', '--list', branch], repoRootPath);
+        if (local.trim())
+            return;
+    }
+    catch {
+        return;
+    }
+    execFileSync('git', ['fetch', 'origin', `${branch}:${branch}`], {
+        cwd: repoRootPath,
+        encoding: 'utf-8',
+        timeout: GIT_TIMEOUT_MS,
+    });
+}
+export function createWorktree(mainRepoRoot, worktreePath, branch, createBranch, startPoint) {
+    mkdirSync(path.dirname(worktreePath), { recursive: true });
+    if (createBranch) {
+        const args = ['worktree', 'add', '-b', branch, worktreePath];
+        if (startPoint)
+            args.push(startPoint);
+        execFileSync('git', args, {
+            cwd: mainRepoRoot,
+            encoding: 'utf-8',
+            timeout: GIT_TIMEOUT_MS,
+        });
+    }
+    else {
+        execFileSync('git', ['worktree', 'add', worktreePath, branch], {
+            cwd: mainRepoRoot,
+            encoding: 'utf-8',
+            timeout: GIT_TIMEOUT_MS,
+        });
+    }
+}
+export function buildHandoffBranchName(sourceBranch, id) {
+    return `tmux-web/${sourceBranch}/${id}`;
+}
+export function pickUniqueWorktreePath(org, repo) {
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const candidate = buildWorktreePath(org, repo, generateWorktreeId());
+        if (!existsSync(candidate))
+            return candidate;
+    }
+    throw new Error('Failed to allocate unique worktree directory');
+}
+export function commitAll(repoRootPath, message) {
+    git(['add', '-A'], repoRootPath);
+    git(['commit', '-m', message], repoRootPath);
+}
+export function push(repoRootPath) {
+    git(['push'], repoRootPath);
+}

package/dist/backend/pane-ready.js

@@ -0,0 +1,37 @@
+const SHELL_COMMANDS = new Set(['bash', 'zsh', 'fish', 'sh', 'dash']);
+function commandBasename(command) {
+    const trimmed = command.trim();
+    const slash = trimmed.lastIndexOf('/');
+    return (slash >= 0 ? trimmed.slice(slash + 1) : trimmed).toLowerCase();
+}
+function hasAgentBusyHints(screen) {
+    const lines = screen.split('\n').map((l) => l.replace(/\s+$/, '')).filter((l) => l.trim() !== '');
+    const live = lines.slice(-20);
+    const liveLower = live.join('\n').toLowerCase();
+    if (liveLower.includes('esc to interrupt')
+        || liveLower.includes('ctrl+c to interrupt')
+        || liveLower.includes('ctrl-c to interrupt')) {
+        return true;
+    }
+    return live.some((l) => /[❯>›]\s*\d+\.\s+\S/.test(l));
+}
+export function isPaneReady(input) {
+    if (input.alternateOn)
+        return false;
+    if (!SHELL_COMMANDS.has(commandBasename(input.paneCommand)))
+        return false;
+    if (input.paneScreen && hasAgentBusyHints(input.paneScreen))
+        return false;
+    return true;
+}
+export function paneNotReadyReason(input) {
+    if (input.alternateOn)
+        return 'Pane is in alternate screen mode';
+    if (!SHELL_COMMANDS.has(commandBasename(input.paneCommand))) {
+        return `Foreground process is not a shell (${input.paneCommand || 'unknown'})`;
+    }
+    if (input.paneScreen && hasAgentBusyHints(input.paneScreen)) {
+        return 'An interactive agent is active in this pane';
+    }
+    return 'Pane is not ready';
+}

package/dist/backend/routes/commit-push.js

@@ -0,0 +1,46 @@
+import { Hono } from 'hono';
+import { commitAll, getGitStatus, push, repoRoot } from '../git.js';
+import { getActivePaneInfo } from '../tmux.js';
+import { fetchSessionStatus } from '../status-service.js';
+export const commitPushRouter = new Hono();
+commitPushRouter.post('/commit-push', async (c) => {
+    const body = await c.req.json();
+    const session = body.session?.trim();
+    const message = body.message?.trim();
+    if (!session)
+        return c.json({ error: 'session is required' }, 400);
+    const pane = getActivePaneInfo(session);
+    if (!pane)
+        return c.json({ error: 'Could not resolve active tmux pane' }, 404);
+    const cwd = pane.panePath;
+    if (!cwd)
+        return c.json({ error: 'Could not detect pane working directory' }, 400);
+    const root = repoRoot(cwd);
+    if (!root)
+        return c.json({ error: 'Not a git repository' }, 400);
+    const before = getGitStatus(root);
+    if (!before.dirty && before.ahead === 0) {
+        return c.json({ error: 'Nothing to commit or push' }, 400);
+    }
+    if (before.dirty) {
+        if (!message)
+            return c.json({ error: 'Commit message is required when there are uncommitted changes' }, 400);
+        try {
+            commitAll(root, message);
+        }
+        catch (err) {
+            return c.json({ error: `Commit failed: ${err.message}` }, 500);
+        }
+    }
+    const afterCommit = getGitStatus(root);
+    if (afterCommit.ahead > 0) {
+        try {
+            push(root);
+        }
+        catch (err) {
+            return c.json({ error: `Push failed: ${err.message}` }, 500);
+        }
+    }
+    const status = await fetchSessionStatus(session);
+    return c.json({ ok: true, status });
+});

package/dist/backend/routes/handoff.js

@@ -0,0 +1,85 @@
+import { Hono } from 'hono';
+import { ghRepoView } from '@tmux-web/ext-gh-workflow';
+import path from 'node:path';
+import { branchExists, buildHandoffBranchName, createWorktree, ensureLocalBranch, isBranchCheckedOut, pickUniqueWorktreePath, repoRoot, resolveMainRepoPath, } from '../git.js';
+import { isPaneReady, paneNotReadyReason } from '../pane-ready.js';
+import { capturePaneTail, getActivePaneInfo, sendKeysToPane } from '../tmux.js';
+import { fetchSessionStatus } from '../status-service.js';
+export const handoffRouter = new Hono();
+handoffRouter.post('/handoff', async (c) => {
+    const body = await c.req.json();
+    const session = body.session?.trim();
+    const branch = body.branch?.trim();
+    const confirmCreate = body.confirmCreate === true;
+    if (!session || !branch) {
+        return c.json({ error: 'session and branch are required' }, 400);
+    }
+    const pane = getActivePaneInfo(session);
+    if (!pane)
+        return c.json({ error: 'Could not resolve active tmux pane' }, 404);
+    const cwd = pane.panePath;
+    if (!cwd)
+        return c.json({ error: 'Could not detect pane working directory' }, 400);
+    const root = repoRoot(cwd);
+    if (!root)
+        return c.json({ error: 'Not a git repository' }, 400);
+    const github = await ghRepoView(cwd);
+    if (!github) {
+        return c.json({ error: 'Works with GitHub repositories only' }, 400);
+    }
+    const mainRepoRoot = resolveMainRepoPath(root) ?? root;
+    const exists = branchExists(mainRepoRoot, branch);
+    if (!exists.exists && !confirmCreate) {
+        return c.json({ needsConfirmation: true, branch }, 409);
+    }
+    let worktreePath;
+    try {
+        worktreePath = pickUniqueWorktreePath(github.org, github.repo);
+    }
+    catch (err) {
+        return c.json({ error: String(err.message) }, 500);
+    }
+    let targetBranch = branch;
+    try {
+        if (exists.exists && exists.source === 'remote') {
+            ensureLocalBranch(mainRepoRoot, branch);
+        }
+        let createBranch = !exists.exists;
+        let startPoint;
+        if (exists.exists && isBranchCheckedOut(mainRepoRoot, branch)) {
+            targetBranch = buildHandoffBranchName(branch, path.basename(worktreePath));
+            createBranch = true;
+            startPoint = branch;
+        }
+        createWorktree(mainRepoRoot, worktreePath, targetBranch, createBranch, startPoint);
+    }
+    catch (err) {
+        return c.json({ error: `git worktree add failed: ${err.message}` }, 500);
+    }
+    const screen = capturePaneTail(pane.target, 20);
+    const readyInput = {
+        alternateOn: pane.alternateOn,
+        paneCommand: pane.paneCommand,
+        paneScreen: screen,
+    };
+    const paneReady = isPaneReady(readyInput);
+    let cdApplied = false;
+    let cdSkippedReason;
+    if (paneReady) {
+        sendKeysToPane(pane.target, `cd '${worktreePath.replace(/'/g, "'\\''")}'`);
+        cdApplied = true;
+    }
+    else {
+        cdSkippedReason = paneNotReadyReason(readyInput);
+    }
+    const status = await fetchSessionStatus(session);
+    return c.json({
+        worktreePath,
+        mainRepoPath: mainRepoRoot,
+        requestedBranch: branch,
+        branch: targetBranch,
+        cdApplied,
+        cdSkippedReason,
+        status,
+    });
+});

package/dist/backend/routes/send-keys.js

@@ -0,0 +1,31 @@
+import { Hono } from 'hono';
+import { getActivePaneInfo, sendKeysToPane, capturePaneTail } from '../tmux.js';
+import { isPaneReady } from '../pane-ready.js';
+export const sendKeysRouter = new Hono();
+sendKeysRouter.post('/send-keys', async (c) => {
+    const body = await c.req.json();
+    const session = body.session?.trim();
+    const text = body.text?.trim();
+    if (!session || !text) {
+        return c.json({ error: 'session and text are required' }, 400);
+    }
+    const pane = getActivePaneInfo(session);
+    if (!pane)
+        return c.json({ error: 'Could not resolve active tmux pane' }, 404);
+    const screen = capturePaneTail(pane.target, 20);
+    const ready = isPaneReady({
+        alternateOn: pane.alternateOn,
+        paneCommand: pane.paneCommand,
+        paneScreen: screen,
+    });
+    if (!ready) {
+        return c.json({ error: 'Pane is not ready to receive input' }, 409);
+    }
+    try {
+        sendKeysToPane(pane.target, text);
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        return c.json({ error: String(err.message) }, 500);
+    }
+});

package/dist/backend/routes/status.js

@@ -0,0 +1,10 @@
+import { Hono } from 'hono';
+import { fetchSessionStatus } from '../status-service.js';
+export const statusRouter = new Hono();
+statusRouter.get('/status', async (c) => {
+    const session = c.req.query('session');
+    if (!session)
+        return c.json({ error: 'session is required' }, 400);
+    const result = await fetchSessionStatus(session);
+    return c.json(result);
+});

package/dist/backend/server.js

@@ -0,0 +1,25 @@
+import { Hono } from 'hono';
+import { serve, createAdaptorServer } from '@hono/node-server';
+import { unlinkSync } from 'node:fs';
+import { statusRouter } from './routes/status.js';
+import { handoffRouter } from './routes/handoff.js';
+import { commitPushRouter } from './routes/commit-push.js';
+import { sendKeysRouter } from './routes/send-keys.js';
+const app = new Hono();
+app.route('/', statusRouter);
+app.route('/', handoffRouter);
+app.route('/', commitPushRouter);
+app.route('/', sendKeysRouter);
+const sockPath = process.env.EXT_SOCKET;
+if (sockPath) {
+    try {
+        unlinkSync(sockPath);
+    }
+    catch { }
+    const server = createAdaptorServer({ fetch: app.fetch });
+    server.listen(sockPath, () => console.log(`[git-workflow ext] listening on ${sockPath}`));
+}
+else {
+    const port = parseInt(process.env.EXT_PORT ?? '4101', 10);
+    serve({ fetch: app.fetch, port }, () => console.log(`[git-workflow ext] running on :${port}`));
+}

package/dist/backend/status-service.js

@@ -0,0 +1,110 @@
+import { ghRepoView, fetchPrForBranch, fetchPrChecks, fetchBranchHead } from '@tmux-web/ext-gh-workflow';
+import { capturePaneTail, getActivePaneInfo } from './tmux.js';
+import { isPaneReady } from './pane-ready.js';
+import { classifyKind, getGitStatus, listBranchNames, repoRoot, resolveMainRepoPath, } from './git.js';
+import { cacheKey, getCachedPane, setCachedPane } from './storage.js';
+async function buildPaneCache(session, pane) {
+    const panePath = pane.panePath;
+    if (!panePath) {
+        return { isRepo: false, isGithub: false, message: 'Could not detect pane working directory' };
+    }
+    const root = repoRoot(panePath);
+    if (!root) {
+        return {
+            isRepo: false,
+            isGithub: false,
+            paneId: pane.paneId,
+            windowIndex: pane.windowIndex,
+            panePath,
+            message: 'Not a git repository',
+        };
+    }
+    const github = await ghRepoView(panePath);
+    if (!github) {
+        return {
+            isRepo: true,
+            isGithub: false,
+            paneId: pane.paneId,
+            windowIndex: pane.windowIndex,
+            panePath,
+            message: 'Works with GitHub repositories only',
+        };
+    }
+    const screen = capturePaneTail(pane.target, 20);
+    const paneReady = isPaneReady({
+        alternateOn: pane.alternateOn,
+        paneCommand: pane.paneCommand,
+        paneScreen: screen,
+    });
+    const kind = classifyKind(panePath);
+    const gitStatus = getGitStatus(root);
+    const mainRepoPath = kind === 'worktree' ? resolveMainRepoPath(root) : root;
+    const branchSource = mainRepoPath ?? root;
+    let pr = null;
+    let branchChecks = null;
+    const branch = gitStatus.branch;
+    if (branch !== 'main' && branch !== 'master') {
+        try {
+            const prBase = await fetchPrForBranch(github.nameWithOwner, branch);
+            if (prBase) {
+                const checks = await fetchPrChecks(github.nameWithOwner, prBase.headSha);
+                pr = { ...prBase, checks };
+            }
+        }
+        catch {
+            // PR fetch is best-effort; don't fail the status response
+        }
+    }
+    else {
+        try {
+            const head = await fetchBranchHead(github.nameWithOwner, branch);
+            if (head) {
+                const checks = await fetchPrChecks(github.nameWithOwner, head.headSha);
+                branchChecks = { branch, headSha: head.headSha, url: head.url, checks };
+            }
+        }
+        catch {
+            // branch checks fetch is best-effort; don't fail the status response
+        }
+    }
+    const entry = {
+        session,
+        paneId: pane.paneId,
+        panePath,
+        windowIndex: pane.windowIndex,
+        branch,
+        kind,
+        mainRepoPath,
+        repoRoot: root,
+        github,
+        changes: gitStatus.changes,
+        dirty: gitStatus.dirty,
+        ahead: gitStatus.ahead,
+        behind: gitStatus.behind,
+        branches: listBranchNames(branchSource),
+        paneReady,
+        fetchedAt: Date.now(),
+        pr,
+        branchChecks,
+    };
+    const key = cacheKey(session, pane.paneId, panePath);
+    const prev = await getCachedPane(key);
+    await setCachedPane(key, entry);
+    return {
+        isRepo: true,
+        isGithub: true,
+        paneId: pane.paneId,
+        windowIndex: pane.windowIndex,
+        panePath,
+        paneReady,
+        cached: prev !== null,
+        data: entry,
+    };
+}
+export async function fetchSessionStatus(session) {
+    const pane = getActivePaneInfo(session);
+    if (!pane) {
+        return { isRepo: false, isGithub: false, message: 'Could not resolve active tmux pane' };
+    }
+    return buildPaneCache(session, pane);
+}

package/dist/backend/storage.js

@@ -0,0 +1,32 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+const DATA_ROOT = process.env.TMUX_WEB_DATA_ROOT
+    ?? path.join(os.homedir(), '.tmux-web');
+const DATA_DIR = process.env.EXT_DATA_DIR
+    ?? path.join(DATA_ROOT, 'extensions', 'git-workflow');
+const DATA_FILE = path.join(DATA_DIR, 'data.json');
+export function cacheKey(session, paneId, panePath) {
+    return `${session}|${paneId}|${panePath}`;
+}
+async function readStore() {
+    try {
+        return JSON.parse(await readFile(DATA_FILE, 'utf-8'));
+    }
+    catch {
+        return { panes: {} };
+    }
+}
+async function saveStore(store) {
+    await mkdir(DATA_DIR, { recursive: true });
+    await writeFile(DATA_FILE, JSON.stringify(store, null, 2));
+}
+export async function getCachedPane(key) {
+    const store = await readStore();
+    return store.panes[key] ?? null;
+}
+export async function setCachedPane(key, entry) {
+    const store = await readStore();
+    store.panes[key] = entry;
+    await saveStore(store);
+}

package/dist/backend/tmux.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'node:child_process';
+const TMUX_TIMEOUT_MS = 3000;
+const PANE_FORMAT = '#{pane_id}\t#{pane_index}\t#{window_index}\t#{pane_current_path}\t#{pane_current_command}\t#{alternate_on}\t#{pane_pid}';
+function tmux(args) {
+    return execFileSync('tmux', args, { encoding: 'utf-8', timeout: TMUX_TIMEOUT_MS }).trimEnd();
+}
+function resolvePanePath(reportedPath, pid) {
+    if (reportedPath?.trim())
+        return reportedPath.trim();
+    if (!Number.isFinite(pid) || pid <= 0)
+        return '';
+    try {
+        const out = execFileSync('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], { encoding: 'utf-8', timeout: TMUX_TIMEOUT_MS });
+        for (const line of out.split('\n')) {
+            if (line.startsWith('n'))
+                return line.slice(1).trim();
+        }
+    }
+    catch {
+        // lsof unavailable or permission denied
+    }
+    return '';
+}
+export function getActivePaneInfo(session) {
+    try {
+        const out = tmux(['display-message', '-p', '-t', session, '-F', PANE_FORMAT]);
+        const [paneId, paneIndex, windowIndex, panePath, paneCommand, alternateOn, panePid] = out.split('\t');
+        if (!paneId)
+            return null;
+        const winIdx = parseInt(windowIndex, 10);
+        const pIdx = parseInt(paneIndex, 10);
+        const pid = parseInt(panePid ?? '', 10);
+        return {
+            paneId,
+            paneIndex: Number.isFinite(pIdx) ? pIdx : 0,
+            windowIndex: Number.isFinite(winIdx) ? winIdx : 0,
+            panePath: resolvePanePath(panePath ?? '', pid),
+            paneCommand: paneCommand ?? '',
+            alternateOn: alternateOn === '1',
+            target: `${session}:${winIdx}.${pIdx}`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function sendKeysToPane(target, text) {
+    execFileSync('tmux', ['send-keys', '-t', target, '-l', text], { timeout: 5000 });
+    execFileSync('tmux', ['send-keys', '-t', target, 'Enter'], { timeout: 5000 });
+}
+export function capturePaneTail(target, lines) {
+    try {
+        return execFileSync('tmux', ['capture-pane', '-t', target, '-p', '-S', String(-lines)], { encoding: 'utf-8', timeout: TMUX_TIMEOUT_MS });
+    }
+    catch {
+        return '';
+    }
+}