github-actions-watcher 0.1.1

package/dist/app.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    interval: number;
+}
+export declare function App({ interval }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/app.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { fetchRuns, fetchRunDetail } from "./lib/gh.js";
+import { useRepo } from "./hooks/use-repo.js";
+import { usePolling } from "./hooks/use-polling.js";
+import { Header } from "./components/header.js";
+import { Footer } from "./components/footer.js";
+import { RunList } from "./components/run-list.js";
+import { RunDetailView } from "./components/run-detail.js";
+import { RepoInput } from "./components/repo-input.js";
+export function App({ interval }) {
+    const { exit } = useApp();
+    const { repo, setRepo, error: repoError, loading: repoLoading } = useRepo();
+    const [view, setView] = useState("list");
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [selectedRunId, setSelectedRunId] = useState(null);
+    const [detailScrollOffset, setDetailScrollOffset] = useState(0);
+    // Detail state
+    const [detail, setDetail] = useState(null);
+    const [detailLoading, setDetailLoading] = useState(false);
+    const [detailError, setDetailError] = useState(null);
+    const runsFetcher = useCallback(() => {
+        if (!repo)
+            return Promise.resolve([]);
+        return fetchRuns(repo);
+    }, [repo]);
+    const { data: runs, setData: setRuns, loading: runsLoading, error: runsError, refresh: refreshRuns, } = usePolling(runsFetcher, interval, !!repo);
+    // Fetch detail
+    const fetchDetail = useCallback(async () => {
+        if (!repo || selectedRunId === null)
+            return;
+        setDetailLoading(true);
+        setDetailError(null);
+        try {
+            const d = await fetchRunDetail(repo, selectedRunId);
+            setDetail(d);
+        }
+        catch (err) {
+            setDetailError(err instanceof Error ? err.message : "Failed to fetch detail");
+        }
+        finally {
+            setDetailLoading(false);
+        }
+    }, [repo, selectedRunId]);
+    // Auto-fetch detail when entering detail view
+    useEffect(() => {
+        if (view === "detail" && selectedRunId !== null) {
+            fetchDetail();
+        }
+    }, [view, selectedRunId, fetchDetail]);
+    // Poll detail view
+    useEffect(() => {
+        if (view !== "detail" || selectedRunId === null)
+            return;
+        const id = setInterval(fetchDetail, interval);
+        return () => clearInterval(id);
+    }, [view, selectedRunId, interval, fetchDetail]);
+    // Global key handler for keys that don't belong to child components
+    useInput((input, key) => {
+        if (input === "q") {
+            exit();
+        }
+        else if (input === "s" && view === "list") {
+            setView("repo-input");
+        }
+        else if (input === "r" && view === "list") {
+            refreshRuns();
+        }
+    }, { isActive: view === "list" || view === "detail" });
+    const handleDrillIn = useCallback((run) => {
+        setSelectedRunId(run.databaseId);
+        setDetail(null);
+        setDetailScrollOffset(0);
+        setView("detail");
+    }, []);
+    const handleBack = useCallback(() => {
+        setView("list");
+        setSelectedRunId(null);
+        setDetail(null);
+    }, []);
+    const handleOpenInBrowser = useCallback(async () => {
+        if (!detail?.url)
+            return;
+        const openModule = await import("open");
+        openModule.default(detail.url);
+    }, [detail]);
+    const handleRepoConfirm = useCallback((newRepo) => {
+        setRepo(newRepo);
+        setRuns(null);
+        setSelectedIndex(0);
+        setView("list");
+    }, [setRepo, setRuns]);
+    const handleRepoCancel = useCallback(() => {
+        setView("list");
+    }, []);
+    // Loading state
+    if (repoLoading) {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Detecting repository..."] }));
+    }
+    if (repoError && !repo) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Error: ", repoError] }), _jsx(Text, { dimColor: true, children: "Run from a directory with a git remote, or press s to enter a repo manually." }), _jsx(RepoInput, { currentRepo: "", onConfirm: (r) => {
+                        setRepo(r);
+                        setView("list");
+                    }, onCancel: () => exit(), isActive: true })] }));
+    }
+    if (!repo)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { repo: repo, loading: runsLoading || detailLoading }), runsError && view === "list" && (_jsxs(Text, { color: "red", children: ["Error: ", runsError] })), view === "list" && runs && (_jsx(RunList, { runs: runs, selectedIndex: selectedIndex, onSelect: setSelectedIndex, onEnter: handleDrillIn, isActive: view === "list" })), view === "detail" && (_jsx(RunDetailView, { detail: detail, loading: detailLoading, error: detailError, onBack: handleBack, onOpen: handleOpenInBrowser, onRefresh: fetchDetail, isActive: view === "detail", scrollOffset: detailScrollOffset, onScroll: setDetailScrollOffset })), view === "repo-input" && (_jsx(RepoInput, { currentRepo: repo, onConfirm: handleRepoConfirm, onCancel: handleRepoCancel, isActive: view === "repo-input" })), _jsx(Footer, { view: view })] }));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import meow from "meow";
+import { App } from "./app.js";
+const cli = meow(`
+  Usage
+    $ gaw
+
+  Options
+    --interval, -i  Polling interval in seconds (default: 10)
+
+  Examples
+    $ gaw
+    $ gaw --interval 5
+    $ gaw -i 30
+`, {
+    importMeta: import.meta,
+    flags: {
+        interval: {
+            type: "number",
+            shortFlag: "i",
+            default: 10,
+        },
+    },
+});
+render(_jsx(App, { interval: cli.flags.interval * 1000 }));

package/dist/components/footer.d.ts

@@ -0,0 +1,6 @@
+import type { View } from "../lib/types.js";
+interface Props {
+    view: View;
+}
+export declare function Footer({ view }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/footer.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const keys = {
+    list: "up/down: navigate | enter: details | s: switch repo | r: refresh | q: quit",
+    detail: "up/down: scroll | esc: back | o: open in browser | r: refresh | q: quit",
+    "repo-input": "enter: confirm | esc: cancel",
+};
+export function Footer({ view }) {
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: keys[view] }) }));
+}

package/dist/components/header.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    repo: string;
+    loading: boolean;
+}
+export declare function Header({ repo, loading }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/header.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+export function Header({ repo, loading }) {
+    return (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "GitHub Actions" }), _jsx(Text, { children: " - " }), _jsx(Text, { bold: true, children: repo }), loading && (_jsxs(Text, { children: [" ", _jsx(Spinner, { type: "dots" })] }))] }));
+}

package/dist/components/repo-input.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    currentRepo: string;
+    onConfirm: (repo: string) => void;
+    onCancel: () => void;
+    isActive: boolean;
+}
+export declare function RepoInput({ currentRepo, onConfirm, onCancel, isActive }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/repo-input.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+export function RepoInput({ currentRepo, onConfirm, onCancel, isActive }) {
+    const [value, setValue] = useState(currentRepo);
+    useInput((_input, key) => {
+        if (key.escape) {
+            onCancel();
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Switch repository:" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: "owner/repo:" }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: (val) => {
+                            const trimmed = val.trim();
+                            if (trimmed && trimmed.includes("/")) {
+                                onConfirm(trimmed);
+                            }
+                        }, focus: isActive })] })] }));
+}

package/dist/components/run-detail.d.ts

@@ -0,0 +1,14 @@
+import type { RunDetail } from "../lib/types.js";
+interface Props {
+    detail: RunDetail | null;
+    loading: boolean;
+    error: string | null;
+    onBack: () => void;
+    onOpen: () => void;
+    onRefresh: () => void;
+    isActive: boolean;
+    scrollOffset: number;
+    onScroll: (offset: number) => void;
+}
+export declare function RunDetailView({ detail, loading, error, onBack, onOpen, onRefresh, isActive, scrollOffset, onScroll, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/run-detail.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { StatusBadge } from "./status-badge.js";
+import { duration } from "../lib/format.js";
+export function RunDetailView({ detail, loading, error, onBack, onOpen, onRefresh, isActive, scrollOffset, onScroll, }) {
+    useInput((input, key) => {
+        if (key.escape) {
+            onBack();
+        }
+        else if (input === "o") {
+            onOpen();
+        }
+        else if (input === "r") {
+            onRefresh();
+        }
+        else if (key.upArrow) {
+            onScroll(Math.max(0, scrollOffset - 1));
+        }
+        else if (key.downArrow) {
+            onScroll(scrollOffset + 1);
+        }
+    }, { isActive });
+    if (loading && !detail) {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Loading run details..."] }));
+    }
+    if (error) {
+        return _jsxs(Text, { color: "red", children: ["Error: ", error] });
+    }
+    if (!detail) {
+        return _jsx(Text, { dimColor: true, children: "No detail available." });
+    }
+    // Build flat list of lines to render, then apply scroll offset
+    const lines = [];
+    lines.push(_jsxs(Box, { gap: 1, children: [_jsx(StatusBadge, { status: detail.status, conclusion: detail.conclusion }), _jsx(Text, { bold: true, children: detail.displayTitle })] }, "title"));
+    lines.push(_jsxs(Box, { gap: 1, children: [_jsxs(Text, { dimColor: true, children: [detail.workflowName, " #", detail.number, " on ", detail.headBranch, " (", detail.event, ")"] }), loading && (_jsx(Text, { children: _jsx(Spinner, { type: "dots" }) }))] }, "meta"));
+    lines.push(_jsx(Text, { dimColor: true, children: "---" }, "sep"));
+    for (const job of detail.jobs) {
+        lines.push(_jsxs(Box, { gap: 1, marginTop: 1, children: [_jsx(StatusBadge, { status: job.status, conclusion: job.conclusion }), _jsx(Text, { bold: true, children: job.name }), job.startedAt && (_jsxs(Text, { dimColor: true, children: ["(", duration(job.startedAt, job.completedAt), ")"] }))] }, `job-${job.databaseId}`));
+        for (const step of job.steps) {
+            lines.push(_jsxs(Box, { gap: 1, paddingLeft: 2, children: [_jsx(StatusBadge, { status: step.status, conclusion: step.conclusion }), _jsx(Text, { children: step.name }), step.startedAt && step.completedAt && (_jsxs(Text, { dimColor: true, children: ["(", duration(step.startedAt, step.completedAt), ")"] }))] }, `step-${job.databaseId}-${step.number}`));
+        }
+    }
+    const visibleLines = lines.slice(scrollOffset);
+    return _jsx(Box, { flexDirection: "column", children: visibleLines });
+}

package/dist/components/run-list.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowRun } from "../lib/types.js";
+interface Props {
+    runs: WorkflowRun[];
+    selectedIndex: number;
+    onSelect: (index: number) => void;
+    onEnter: (run: WorkflowRun) => void;
+    isActive: boolean;
+}
+export declare function RunList({ runs, selectedIndex, onSelect, onEnter, isActive }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/run-list.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { StatusBadge } from "./status-badge.js";
+import { relativeTime, truncate } from "../lib/format.js";
+export function RunList({ runs, selectedIndex, onSelect, onEnter, isActive }) {
+    useInput((input, key) => {
+        if (key.upArrow) {
+            onSelect(Math.max(0, selectedIndex - 1));
+        }
+        else if (key.downArrow) {
+            onSelect(Math.min(runs.length - 1, selectedIndex + 1));
+        }
+        else if (key.return) {
+            const run = runs[selectedIndex];
+            if (run)
+                onEnter(run);
+        }
+    }, { isActive });
+    if (runs.length === 0) {
+        return _jsx(Text, { dimColor: true, children: "No workflow runs found." });
+    }
+    return (_jsx(Box, { flexDirection: "column", children: runs.map((run, i) => {
+            const selected = i === selectedIndex;
+            return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { children: selected ? ">" : " " }), _jsx(Box, { width: 14, children: _jsx(StatusBadge, { status: run.status, conclusion: run.conclusion }) }), _jsx(Box, { width: 20, children: _jsx(Text, { color: "blue", children: truncate(run.workflowName, 20) }) }), _jsx(Box, { width: 18, children: _jsx(Text, { color: "magenta", children: truncate(run.headBranch, 18) }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { children: truncate(run.displayTitle, 40) }) }), _jsx(Box, { width: 8, children: _jsx(Text, { dimColor: true, children: relativeTime(run.createdAt) }) })] }, run.databaseId));
+        }) }));
+}

package/dist/components/status-badge.d.ts

@@ -0,0 +1,7 @@
+import type { RunStatus, RunConclusion, StepStatus, StepConclusion } from "../lib/types.js";
+interface Props {
+    status: RunStatus | StepStatus;
+    conclusion: RunConclusion | StepConclusion;
+}
+export declare function StatusBadge({ status, conclusion }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/status-badge.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export function StatusBadge({ status, conclusion }) {
+    if (status === "in_progress") {
+        return _jsx(Text, { color: "yellow", children: "* running" });
+    }
+    if (status === "queued" || status === "waiting" || status === "pending" || status === "requested") {
+        return _jsx(Text, { color: "gray", children: "~ queued" });
+    }
+    switch (conclusion) {
+        case "success":
+            return _jsx(Text, { color: "green", children: "+ passed" });
+        case "failure":
+            return _jsx(Text, { color: "red", children: "x failed" });
+        case "cancelled":
+            return _jsx(Text, { color: "gray", children: "- cancelled" });
+        case "skipped":
+            return _jsx(Text, { color: "gray", children: "- skipped" });
+        case "timed_out":
+            return _jsx(Text, { color: "red", children: "! timed out" });
+        case "action_required":
+            return _jsx(Text, { color: "yellow", children: "! action req" });
+        default:
+            return _jsx(Text, { color: "gray", children: "? unknown" });
+    }
+}

package/dist/hooks/use-polling.d.ts

@@ -0,0 +1,7 @@
+export declare function usePolling<T>(fetcher: () => Promise<T>, intervalMs: number, enabled: boolean): {
+    data: T | null;
+    setData: import("react").Dispatch<import("react").SetStateAction<T | null>>;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};

package/dist/hooks/use-polling.js

@@ -0,0 +1,41 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+export function usePolling(fetcher, intervalMs, enabled) {
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const mountedRef = useRef(true);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await fetcher();
+            if (mountedRef.current) {
+                setData(result);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current) {
+                setError(err instanceof Error ? err.message : "Fetch failed");
+            }
+        }
+        finally {
+            if (mountedRef.current) {
+                setLoading(false);
+            }
+        }
+    }, [fetcher]);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        refresh();
+        const id = setInterval(refresh, intervalMs);
+        return () => clearInterval(id);
+    }, [enabled, intervalMs, refresh]);
+    return { data, setData, loading, error, refresh };
+}

package/dist/hooks/use-repo.d.ts

@@ -0,0 +1,6 @@
+export declare function useRepo(): {
+    repo: string | null;
+    setRepo: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    error: string | null;
+    loading: boolean;
+};

package/dist/hooks/use-repo.js

@@ -0,0 +1,19 @@
+import { useState, useEffect } from "react";
+import { detectRepo } from "../lib/gh.js";
+export function useRepo() {
+    const [repo, setRepo] = useState(null);
+    const [error, setError] = useState(null);
+    const [loading, setLoading] = useState(true);
+    useEffect(() => {
+        detectRepo()
+            .then((r) => {
+            setRepo(r);
+            setLoading(false);
+        })
+            .catch((err) => {
+            setError(err instanceof Error ? err.message : "Failed to detect repo");
+            setLoading(false);
+        });
+    }, []);
+    return { repo, setRepo, error, loading };
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,3 @@
+export declare function relativeTime(dateStr: string): string;
+export declare function duration(startStr: string, endStr: string | null): string;
+export declare function truncate(str: string, maxLen: number): string;

package/dist/lib/format.js

@@ -0,0 +1,36 @@
+export function relativeTime(dateStr) {
+    const now = Date.now();
+    const then = new Date(dateStr).getTime();
+    const diffSec = Math.floor((now - then) / 1000);
+    if (diffSec < 60)
+        return `${diffSec}s ago`;
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60)
+        return `${diffMin}m ago`;
+    const diffHr = Math.floor(diffMin / 60);
+    if (diffHr < 24)
+        return `${diffHr}h ago`;
+    const diffDay = Math.floor(diffHr / 24);
+    return `${diffDay}d ago`;
+}
+export function duration(startStr, endStr) {
+    if (!startStr)
+        return "";
+    const start = new Date(startStr).getTime();
+    const end = endStr ? new Date(endStr).getTime() : Date.now();
+    const diffSec = Math.floor((end - start) / 1000);
+    if (diffSec < 60)
+        return `${diffSec}s`;
+    const min = Math.floor(diffSec / 60);
+    const sec = diffSec % 60;
+    if (min < 60)
+        return `${min}m ${sec}s`;
+    const hr = Math.floor(min / 60);
+    const remMin = min % 60;
+    return `${hr}h ${remMin}m`;
+}
+export function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 1) + "\u2026";
+}

package/dist/lib/gh.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowRun, RunDetail } from "./types.js";
+export declare function fetchRuns(repo: string): Promise<WorkflowRun[]>;
+export declare function fetchRunDetail(repo: string, runId: number): Promise<RunDetail>;
+export declare function detectRepo(): Promise<string>;

package/dist/lib/gh.js

@@ -0,0 +1,63 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function gh(args) {
+    const { stdout } = await execFileAsync("gh", args, {
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return JSON.parse(stdout);
+}
+const RUN_FIELDS = [
+    "databaseId",
+    "displayTitle",
+    "event",
+    "headBranch",
+    "name",
+    "number",
+    "status",
+    "conclusion",
+    "createdAt",
+    "updatedAt",
+    "url",
+    "workflowName",
+].join(",");
+export async function fetchRuns(repo) {
+    return gh([
+        "run",
+        "list",
+        "--repo",
+        repo,
+        "--json",
+        RUN_FIELDS,
+        "--limit",
+        "20",
+    ]);
+}
+export async function fetchRunDetail(repo, runId) {
+    return gh([
+        "run",
+        "view",
+        String(runId),
+        "--repo",
+        repo,
+        "--json",
+        `${RUN_FIELDS},jobs`,
+    ]);
+}
+export async function detectRepo() {
+    const { stdout } = await execFileAsync("git", [
+        "remote",
+        "get-url",
+        "origin",
+    ]);
+    const url = stdout.trim();
+    // Handle SSH: git@github.com:owner/repo.git
+    const sshMatch = url.match(/git@github\.com:(.+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1];
+    // Handle HTTPS: https://github.com/owner/repo.git
+    const httpsMatch = url.match(/github\.com\/(.+?)(?:\.git)?$/);
+    if (httpsMatch)
+        return httpsMatch[1];
+    throw new Error(`Could not parse repo from remote URL: ${url}`);
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,52 @@
+export type RunStatus = "completed" | "in_progress" | "queued" | "requested" | "waiting" | "pending";
+export type RunConclusion = "success" | "failure" | "cancelled" | "skipped" | "timed_out" | "action_required" | "neutral" | "stale" | null;
+export type StepStatus = "completed" | "in_progress" | "queued" | "pending" | "waiting";
+export type StepConclusion = "success" | "failure" | "cancelled" | "skipped" | null;
+export interface WorkflowRun {
+    databaseId: number;
+    displayTitle: string;
+    event: string;
+    headBranch: string;
+    name: string;
+    number: number;
+    status: RunStatus;
+    conclusion: RunConclusion;
+    createdAt: string;
+    updatedAt: string;
+    url: string;
+    workflowName: string;
+}
+export interface Step {
+    name: string;
+    status: StepStatus;
+    conclusion: StepConclusion;
+    number: number;
+    startedAt: string;
+    completedAt: string;
+}
+export interface Job {
+    name: string;
+    status: StepStatus;
+    conclusion: StepConclusion;
+    startedAt: string;
+    completedAt: string;
+    steps: Step[];
+    url: string;
+    databaseId: number;
+}
+export interface RunDetail {
+    databaseId: number;
+    displayTitle: string;
+    event: string;
+    headBranch: string;
+    name: string;
+    number: number;
+    status: RunStatus;
+    conclusion: RunConclusion;
+    createdAt: string;
+    updatedAt: string;
+    url: string;
+    workflowName: string;
+    jobs: Job[];
+}
+export type View = "list" | "detail" | "repo-input";

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "github-actions-watcher",
+  "version": "0.1.1",
+  "description": "Terminal TUI for monitoring GitHub Actions workflow runs",
+  "type": "module",
+  "bin": {
+    "ghaw": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js"
+  },
+  "keywords": [
+    "github",
+    "actions",
+    "ci",
+    "tui",
+    "terminal",
+    "workflow",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/dzoba/github-actions-watcher.git"
+  },
+  "dependencies": {
+    "ink": "^5.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "meow": "^13.0.0",
+    "open": "^10.1.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "@types/react": "^18.3.12",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}