claudial 0.7.1 → 0.8.0

package/README.md

@@ -2,10 +2,10 @@
 
 # ⚽ claudial
 
-### Live football inside Claude Code
+### Live football inside Claude Code, Cursor and your editor
 
-Your teams' scores sit under your prompt while you code.
-When one of them scores, your terminal celebrates.
+Your teams' scores sit in your status bar while you code: Claude Code, Cursor,
+VS Code, Antigravity, Windsurf. When one of them scores, it celebrates.
 
 ```
 npm install -g claudial && claudial setup
@@ -37,7 +37,7 @@ Europa League · Conference League · Super League Greece · World Cup**
 | You are… | Run |
 |---|---|
 | **New to claudial** | `npm install -g claudial`<br>`claudial setup` |
-| **Back from the World Cup** (you have 0.6.x) | `npm install -g claudial@latest`<br>`claudial --version` (should print 0.7.0 or newer)<br>`claudial follow` |
+| **Back from the World Cup** (you have 0.6.x) | `npm install -g claudial@latest`<br>`claudial --version` (should print 0.8.0 or newer)<br>`claudial follow` |
 
 Then restart Claude Code. World Cup users keep their status line as it is; `claudial follow`
 picks your leagues and teams, because the new version starts following nothing.
@@ -46,6 +46,29 @@ Still seeing "WORLD CUP 2026" after updating? An old copy comes first on your PA
 `which -a claudial` lists every copy; remove the old one with
 `npm uninstall -g --prefix <its folder> claudial` (e.g. `--prefix ~/.npm-global`).
 
+## Works where you code
+
+| Where you code | Run |
+|---|---|
+| **Claude Code** | `npm install -g claudial && claudial setup` |
+| **Cursor CLI** (`cursor-agent`) | `npm install -g claudial && claudial setup --cursor --yes` |
+| **VS Code** | `code --install-extension lefprog.claudial` |
+| **Cursor** | `cursor --install-extension lefprog.claudial` |
+| **Antigravity** | `antigravity --install-extension lefprog.claudial` |
+| **Windsurf** | `windsurf --install-extension lefprog.claudial` |
+| **Codex CLI** | not yet: Codex's status line can only show its own built-in items |
+
+In the editors you can also search **claudial** in the Extensions panel. Reload the
+window after installing; the score sits at the bottom right. Click it to pick your
+teams. The editor extension and the CLI share your device, so you follow the same
+teams everywhere.
+
+<div align="center">
+
+![claudial in the editor status bar: VS Code during Liverpool 6—0 and the GOOOL flash for 7—0, and Cursor showing the next kickoff](extension/images/statusbar.png)
+
+</div>
+
 ## The score, right under your prompt
 
 One command puts a live score line into Claude Code's status bar. It stays out
@@ -114,10 +137,11 @@ claudial follow       # pick leagues and teams
 
 Requires Node ≥ 18. No account, no sign-up, no API key.
 
-Scripting it? `claudial setup --statusline --yes` installs without
-prompts, and `claudial leagues`, `claudial teams <league>`,
-`claudial follow <id>...`, `claudial unfollow <id>...` and `claudial following`
-work without the UI. `claudial forget` deletes your device from the server.
+Scripting it? `claudial setup --statusline --yes` (Claude Code) and
+`claudial setup --cursor --yes` (Cursor CLI) install without prompts, and
+`claudial leagues`, `claudial teams <league>`, `claudial follow <id>...`,
+`claudial unfollow <id>...` and `claudial following` work without the UI.
+`claudial forget` deletes your device from the server.
 
 ## Status
 

package/dist/api/backend.js

@@ -3,8 +3,13 @@ import { deviceId } from './device.js';
 // TLS; scripts/check-release.mjs blocks an npm publish until this is https://.
 // CLAUDIAL_API_URL always wins (local dev: http://localhost:8080).
 export const DEFAULT_API_URL = 'http://161.97.67.12:30083';
+let serverOverride = null;
+/** For embedders (the editor extension): a server chosen in settings. The env var still wins. */
+export function setServerUrl(url) {
+    serverOverride = url && url.trim() ? url.trim() : null;
+}
 export function apiUrl(env = process.env) {
-    return (env.CLAUDIAL_API_URL || DEFAULT_API_URL).replace(/\/+$/, '');
+    return (env.CLAUDIAL_API_URL || serverOverride || DEFAULT_API_URL).replace(/\/+$/, '');
 }
 /** Thrown for any non-2xx answer, carrying the server's own error message. */
 export class ApiError extends Error {

package/dist/index.js

@@ -29,8 +29,9 @@ const HELP = `claudial: live football in your terminal and Claude Code's status
   claudial                             the live dashboard (keys: f follow · r refresh · q quit)
   claudial --ticker                    a 4-line strip for slim split panes
   claudial | cat                       plain snapshot for pipes and scripts
-  claudial setup                       install the Claude Code status line and pick your teams
-  claudial setup --statusline --yes    install the status line only, no prompts
+  claudial setup                       install the status line (Claude Code, Cursor CLI) and pick your teams
+  claudial setup --statusline --yes    Claude Code status line only, no prompts
+  claudial setup --cursor --yes        Cursor CLI status line only, no prompts
 ${USAGE.replace(/^usage:\n/, '')}
 
   CLAUDIAL_API_URL=<url>               use another claudial server`;

package/dist/setup/Wizard.js

@@ -2,10 +2,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput, useApp } from 'ink';
 import { ACCENT } from '../ui/Header.js';
 /**
- * A single confirmation: install the live-score statusline globally into Claude
- * Code. No scope or tmux prompts — global is the one supported path.
+ * A single confirmation: install the live-score statusline into Claude Code,
+ * and into the Cursor CLI too when Cursor is on this machine.
  */
-export function Wizard({ defaultShell, onDone }) {
+export function Wizard({ defaultShell, cursorFound, onDone }) {
     const { exit } = useApp();
     useInput((input, key) => {
         if (input === 'q' || input.toLowerCase() === 'n') {
@@ -13,9 +13,9 @@ export function Wizard({ defaultShell, onDone }) {
             return;
         }
         if (key.return || input.toLowerCase() === 'y') {
-            onDone({ statusline: true, scope: 'global', tmux: false, shell: defaultShell, yes: true, interactive: false });
+            onDone({ statusline: true, cursor: cursorFound, scope: 'global', tmux: false, shell: defaultShell, yes: true, interactive: false });
             exit();
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsx(Text, { bold: true, color: ACCENT, children: "claudial setup" }) }), _jsx(Text, { children: "Install the live-score statusline into Claude Code? (Y/n)" }), _jsx(Text, { dimColor: true, children: "  \u2022 statusline \u2192 global (~/.claude/settings.json)" }), _jsx(Text, { dimColor: true, children: "q to quit" })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsx(Text, { bold: true, color: ACCENT, children: "claudial setup" }) }), _jsx(Text, { children: "Install the live-score statusline? (Y/n)" }), _jsx(Text, { dimColor: true, children: "  \u2022 Claude Code \u2192 ~/.claude/settings.json" }), cursorFound ? _jsx(Text, { dimColor: true, children: "  \u2022 Cursor CLI \u2192 ~/.cursor/cli-config.json" }) : null, _jsx(Text, { dimColor: true, children: "q to quit" })] }));
 }

package/dist/setup/apply.js

@@ -1,13 +1,23 @@
 import { installStatusline } from './settings.js';
+import { installCursorStatusline } from './cursor.js';
 import { appendAlias } from './shellrc.js';
 export function applySetup(opts, ctx) {
-    const report = { statuslineWritten: false, statuslineBackedUp: false, statuslineWrapped: false, aliasAppended: false };
+    const report = {
+        statuslineWritten: false, statuslineBackedUp: false, statuslineWrapped: false,
+        cursorWritten: false, cursorBackedUp: false, cursorWrapped: false, aliasAppended: false,
+    };
     if (opts.statusline) {
         const r = installStatusline(ctx.settingsPath, ctx.command, ctx.conflict);
         report.statuslineWritten = r.written;
         report.statuslineBackedUp = r.backedUp;
         report.statuslineWrapped = r.wrapped;
     }
+    if (opts.cursor) {
+        const r = installCursorStatusline(ctx.cursorPath, ctx.command);
+        report.cursorWritten = r.written;
+        report.cursorBackedUp = r.backedUp;
+        report.cursorWrapped = r.wrapped;
+    }
     if (opts.tmux) {
         report.aliasAppended = appendAlias(ctx.rcPath, ctx.shell).appended;
     }

package/dist/setup/cursor.js

@@ -0,0 +1,48 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+// The Cursor CLI (cursor-agent) status line: the same `claudial --statusline`
+// command as Claude Code, in ~/.cursor/cli-config.json with Cursor's own keys.
+export function cursorConfigPath(home) {
+    return join(home, '.cursor', 'cli-config.json');
+}
+function block(command) {
+    return { type: 'command', command, padding: 0, updateIntervalMs: 1000, timeoutMs: 3000 };
+}
+/** Read → (wrap a foreign command) → merge → (backup) → write. Same rules as the Claude Code writer. */
+export function installCursorStatusline(path, command) {
+    const fileExists = existsSync(path);
+    let existing = {};
+    if (fileExists) {
+        try {
+            existing = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const theirs = typeof existing?.statusLine?.command === 'string' ? existing.statusLine.command : '';
+    let final = command;
+    let wrapped = false;
+    if (theirs.includes('claudial --statusline')) {
+        const w = theirs.indexOf(' --wrap ');
+        if (w >= 0) {
+            final = command + theirs.slice(w);
+            wrapped = true;
+        }
+    }
+    else if (theirs) {
+        final = `${command} --wrap '${theirs.replace(/'/g, `'\\''`)}'`;
+        wrapped = true;
+    }
+    const next = block(final);
+    if (JSON.stringify(existing.statusLine) === JSON.stringify(next))
+        return { written: false, backedUp: false, wrapped };
+    let backedUp = false;
+    if (fileExists) {
+        copyFileSync(path, `${path}.bak`);
+        backedUp = true;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...existing, statusLine: next }, null, 2) + '\n');
+    return { written: true, backedUp, wrapped };
+}

package/dist/setup/detect.js

@@ -1,4 +1,5 @@
 import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 export function detectShell(env = process.env) {
     const s = env.SHELL ?? '';
@@ -29,6 +30,10 @@ export function isOnPath(bin) {
         return false;
     }
 }
+/** Cursor (editor or CLI) has been used on this machine. */
+export function hasCursor(home) {
+    return existsSync(join(home, '.cursor'));
+}
 export function hasTmux() {
     return isOnPath('tmux');
 }

package/dist/setup/flags.js

@@ -5,10 +5,12 @@ export function parseFlags(args) {
     const shell = SHELLS.includes(shellArg) ? shellArg : null;
     const statusline = has('--statusline');
     const tmux = has('--tmux');
+    const cursor = has('--cursor');
     // any actionable flag (or --yes) means run without prompting
-    const interactive = !(statusline || tmux || has('--yes'));
+    const interactive = !(statusline || tmux || cursor || has('--yes'));
     return {
         statusline,
+        cursor,
         scope: has('--project') ? 'project' : 'global',
         tmux,
         shell,

package/dist/setup/index.js

@@ -3,7 +3,8 @@ import { join } from 'node:path';
 import React from 'react';
 import { render } from 'ink';
 import { parseFlags } from './flags.js';
-import { detectShell, rcPathFor, isOnPath } from './detect.js';
+import { detectShell, rcPathFor, isOnPath, hasCursor } from './detect.js';
+import { cursorConfigPath } from './cursor.js';
 import { applySetup } from './apply.js';
 import { Wizard } from './Wizard.js';
 function commandFor() {
@@ -15,6 +16,7 @@ function contextFor(opts) {
     const settingsPath = join(homedir(), '.claude', 'settings.json');
     return {
         settingsPath,
+        cursorPath: cursorConfigPath(homedir()),
         rcPath: rcPathFor(shell, homedir()),
         shell,
         command: commandFor(),
@@ -33,6 +35,16 @@ function printReport(opts, ctx, report) {
     else if (opts.statusline) {
         console.log('• statusline unchanged (an existing statusLine was kept).');
     }
+    if (report.cursorWritten) {
+        console.log(`✓ Cursor CLI statusline installed → ${ctx.cursorPath}`);
+        if (report.cursorWrapped)
+            console.log('  (kept your existing status line and appended the score)');
+        if (report.cursorBackedUp)
+            console.log(`  (previous config backed up to ${ctx.cursorPath}.bak)`);
+    }
+    else if (opts.cursor) {
+        console.log('• Cursor CLI statusline already installed.');
+    }
     if (report.aliasAppended) {
         console.log(`✓ tmux alias added → ${ctx.rcPath}`);
         console.log(`  Open a new shell, then run: claude-mundial`);
@@ -40,7 +52,7 @@ function printReport(opts, ctx, report) {
     else if (opts.tmux) {
         console.log('• tmux alias already present — left as-is.');
     }
-    if (!opts.statusline && !opts.tmux)
+    if (!opts.statusline && !opts.cursor && !opts.tmux)
         console.log('Nothing selected. Run `claudial setup` again to choose options.');
 }
 export async function runSetup(args) {
@@ -56,6 +68,7 @@ export async function runSetup(args) {
     await new Promise((resolve) => {
         const { waitUntilExit } = render(React.createElement(Wizard, {
             defaultShell: detectShell(),
+            cursorFound: hasCursor(homedir()),
             onDone: (final) => run(final),
         }));
         waitUntilExit().then(() => resolve());

package/dist/snapshot.js

@@ -1,9 +1,9 @@
 import { fetchLive, fetchRecent, fetchUpcoming, followsNothing } from './api/backend.js';
-import { kickoffColumn } from './ui/UpcomingSection.js';
+import { kickoffColumn, kickoffWidth } from './ui/kickoff.js';
 import { homeName, awayName } from './ui/flags.js';
-function line(m) {
+function line(m, width = 22) {
     if (m.status === 'upcoming')
-        return `o ${kickoffColumn(m.startTimestamp)}${homeName(m.home)} - ${awayName(m.away)}`;
+        return `o ${kickoffColumn(m.startTimestamp, Date.now(), width)}${homeName(m.home)} - ${awayName(m.away)}`;
     const label = m.status === 'finished' ? 'FT' : m.status === 'halftime' ? 'HT' : `${m.minute ?? '?'}'`;
     return `* ${label.padEnd(4)} ${homeName(m.home)} ${m.homeScore ?? '-'} - ${m.awayScore ?? '-'} ${awayName(m.away)}`;
 }
@@ -21,6 +21,8 @@ export async function printSnapshot(seasonId) {
         console.log(line(m));
     if (upcoming.length)
         console.log('UPCOMING');
-    for (const m of upcoming.slice(0, 8))
-        console.log(line(m));
+    const next = upcoming.slice(0, 8);
+    const width = kickoffWidth(next.map((m) => m.startTimestamp));
+    for (const m of next)
+        console.log(line(m, width));
 }

package/dist/statusline/line.js

@@ -1,4 +1,4 @@
-import { formatKickoff } from '../ui/UpcomingSection.js';
+import { formatKickoff } from '../ui/kickoff.js';
 import { homeName, awayName } from '../ui/flags.js';
 import { matchPrediction } from '../predictions/match.js';
 import { headline } from '../predictions/format.js';

package/dist/ui/MatchRow.js

@@ -1,7 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { ACCENT } from './Header.js';
-import { formatKickoff, kickoffColumn } from './UpcomingSection.js';
+import { formatKickoff, kickoffColumn } from './kickoff.js';
 import { homeName, awayName } from './flags.js';
 /** One side's goals grouped by scorer, in order of their first goal: "43' 50' C. Gakpo · 47' D. Núñez". */
 export function scorers(goals) {

package/dist/ui/Ticker.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { formatKickoff } from './UpcomingSection.js';
+import { formatKickoff } from './kickoff.js';
 import { ACCENT, RED } from './Header.js';
 import { spacedCaps } from '../banner.js';
 import { homeName, awayName } from './flags.js';

package/dist/ui/UpcomingSection.js

@@ -3,28 +3,14 @@ import { Box, Text } from 'ink';
 import { homeName, awayName } from './flags.js';
 import { matchPrediction } from '../predictions/match.js';
 import { fullSlate, headline } from '../predictions/format.js';
-export function formatKickoff(ts, now = Date.now()) {
-    const d = new Date(ts * 1000);
-    const time = d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
-    const sameDay = d.toDateString() === new Date(now).toDateString();
-    if (sameDay)
-        return time;
-    // Within the week a weekday is enough; further out (fixtures reach ~3 weeks) add the date.
-    const soon = ts * 1000 - now < 6 * 86_400_000;
-    const day = d.toLocaleDateString(undefined, soon ? { weekday: 'short' } : { weekday: 'short', day: 'numeric', month: 'short' });
-    return `${day} ${time}`;
-}
-/** The kickoff padded to `width` (default: fits the longest date format), always followed by a space. */
-export function kickoffColumn(ts, now = Date.now(), width = 22) {
-    const k = formatKickoff(ts, now);
-    return k.length >= width - 1 ? `${k} ` : k.padEnd(width);
-}
+export { formatKickoff, kickoffColumn } from './kickoff.js';
+import { formatKickoff, kickoffColumn, kickoffWidth } from './kickoff.js';
 export function UpcomingSection({ matches, compact, predictions = [], }) {
     const shown = matches.slice(0, compact ? 1 : 8);
     if (shown.length === 0)
         return null;
     // One column for the whole list: as wide as its longest kickoff, plus a gap.
-    const width = Math.max(...shown.map((m) => formatKickoff(m.startTimestamp).length)) + 2;
+    const width = kickoffWidth(shown.map((m) => m.startTimestamp));
     if (compact) {
         const m = shown[0];
         const pred = matchPrediction(m, predictions);

package/dist/ui/kickoff.js

@@ -0,0 +1,24 @@
+// Kickoff times as text. Plain functions with no UI imports, so the status line
+// and the editor extension can use them without pulling in Ink.
+export function formatKickoff(ts, now = Date.now()) {
+    const d = new Date(ts * 1000);
+    const time = d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+    const sameDay = d.toDateString() === new Date(now).toDateString();
+    if (sameDay)
+        return time;
+    // Within the week a weekday is enough; further out (fixtures reach ~3 weeks) add the date.
+    const soon = ts * 1000 - now < 6 * 86_400_000;
+    const day = d.toLocaleDateString(undefined, soon ? { weekday: 'short' } : { weekday: 'short', day: 'numeric', month: 'short' });
+    return `${day} ${time}`;
+}
+/** The kickoff padded to `width` (default: fits the longest date format), always followed by a space. */
+export function kickoffColumn(ts, now = Date.now(), width = 22) {
+    const k = formatKickoff(ts, now);
+    return k.length >= width - 1 ? `${k} ` : k.padEnd(width);
+}
+/** One column width for a list of kickoffs: its longest date plus a two-space gap. */
+export function kickoffWidth(timestamps, now = Date.now()) {
+    if (timestamps.length === 0)
+        return 22;
+    return Math.max(...timestamps.map((ts) => formatKickoff(ts, now).length)) + 2;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claudial",
-  "version": "0.7.1",
-  "description": "Live football scores for your leagues and teams, in your terminal and Claude Code's status bar — goal and red-card takeovers included",
+  "version": "0.8.0",
+  "description": "Live football for your teams in the status bar of Claude Code and Cursor CLI, plus a terminal dashboard with goal and red-card takeovers",
   "type": "module",
   "bin": {
     "claudial": "dist/index.js"
@@ -35,10 +35,13 @@
     "worldcup",
     "tui",
     "cli",
-    "football",
     "soccer",
     "live-scores",
-    "ink"
+    "ink",
+    "cursor",
+    "vscode",
+    "antigravity",
+    "statusline"
   ],
   "license": "MIT",
   "repository": {