@jack200714/mafw 4.5.1

package/gateway/dist/trajectory/trajectory-store.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrajectoryStore = void 0;
+const EMPTY_TOKENS = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+function rowToEvent(row) {
+    return {
+        id: row.id,
+        projectID: row.project_id,
+        sessionID: row.session_id,
+        turnID: row.turn_id,
+        seq: row.seq,
+        eventType: row.event_type,
+        toolName: row.tool_name ?? undefined,
+        callID: row.call_id ?? undefined,
+        toolState: row.tool_state ?? undefined,
+        agent: row.agent ?? undefined,
+        model: row.model ?? undefined,
+        inputSummary: row.input_summary ?? undefined,
+        outputSummary: row.output_summary ?? undefined,
+        error: row.error ?? undefined,
+        tokens: row.tokens ? JSON.parse(row.tokens) : undefined,
+        cost: row.cost ?? undefined,
+        finish: row.finish ?? undefined,
+        timeMs: row.time_ms,
+        durationMs: row.duration_ms ?? undefined,
+    };
+}
+function rowToTurn(row) {
+    return {
+        projectID: row.project_id,
+        sessionID: row.session_id,
+        turnID: row.turn_id,
+        turnStartMs: row.turn_start_ms,
+        turnEndMs: row.turn_end_ms,
+        durationMs: row.duration_ms,
+        toolCount: row.tool_count,
+        toolErrorCount: row.tool_error_count,
+        reasoningCount: row.reasoning_count,
+        agentSwitchCount: row.agent_switch_count,
+        tokens: row.tokens ? JSON.parse(row.tokens) : { ...EMPTY_TOKENS },
+        cost: row.cost,
+        finish: row.finish,
+        model: row.model,
+        provider: row.provider ?? null,
+        agent: row.agent,
+        userText: row.user_text,
+        assistantText: row.assistant_text ?? undefined,
+        workerRole: row.worker_role ?? undefined,
+    };
+}
+class TrajectoryStore {
+    db;
+    projectID;
+    constructor(db, projectID) {
+        this.db = db;
+        this.projectID = projectID;
+    }
+    get rawDb() {
+        return this.db.db;
+    }
+    recordEvent(evt) {
+        this.rawDb
+            .prepare(`INSERT INTO trajectory_events
+         (project_id, session_id, turn_id, seq, event_type, tool_name, call_id, tool_state,
+          agent, model, input_summary, output_summary, error, tokens, cost, finish, time_ms, duration_ms)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+            .run(evt.projectID, evt.sessionID, evt.turnID, evt.seq, evt.eventType, evt.toolName ?? null, evt.callID ?? null, evt.toolState ?? null, evt.agent ?? null, evt.model ?? null, evt.inputSummary ?? null, evt.outputSummary ?? null, evt.error ?? null, evt.tokens ? JSON.stringify(evt.tokens) : null, evt.cost ?? null, evt.finish ?? null, evt.timeMs, evt.durationMs ?? null);
+    }
+    upsertTurn(turn) {
+        this.rawDb
+            .prepare(`INSERT INTO trajectory_turns
+         (project_id, session_id, turn_id, turn_start_ms, turn_end_ms, duration_ms,
+          tool_count, tool_error_count, reasoning_count, agent_switch_count,
+          tokens, cost, finish, model, provider, agent, user_text, assistant_text, worker_role)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+         ON CONFLICT(session_id, turn_id) DO UPDATE SET
+           turn_end_ms = excluded.turn_end_ms,
+           duration_ms = excluded.duration_ms,
+           tool_count = excluded.tool_count,
+           tool_error_count = excluded.tool_error_count,
+           reasoning_count = excluded.reasoning_count,
+           agent_switch_count = excluded.agent_switch_count,
+           tokens = excluded.tokens,
+           cost = excluded.cost,
+           finish = excluded.finish,
+           model = excluded.model,
+           provider = excluded.provider,
+           agent = excluded.agent,
+           user_text = excluded.user_text,
+           assistant_text = excluded.assistant_text,
+           worker_role = COALESCE(excluded.worker_role, trajectory_turns.worker_role)`)
+            .run(turn.projectID, turn.sessionID, turn.turnID, turn.turnStartMs, turn.turnEndMs, turn.durationMs, turn.toolCount, turn.toolErrorCount, turn.reasoningCount, turn.agentSwitchCount, JSON.stringify(turn.tokens), turn.cost, turn.finish, turn.model, turn.provider ?? null, turn.agent, turn.userText, turn.assistantText ?? null, turn.workerRole ?? null);
+    }
+    getSessionTrajectory(sessionID, opts) {
+        const turns = this.rawDb
+            .prepare(`SELECT * FROM trajectory_turns WHERE session_id = ?
+         ${opts.beforeTurn !== undefined ? 'AND turn_id < ?' : ''}
+         ORDER BY turn_id DESC LIMIT ?`)
+            .all(...(opts.beforeTurn !== undefined ? [sessionID, opts.beforeTurn, opts.limit] : [sessionID, opts.limit]));
+        if (turns.length === 0) {
+            const allEvents = this.rawDb
+                .prepare('SELECT * FROM trajectory_events WHERE session_id = ? ORDER BY turn_id ASC, seq ASC')
+                .all(sessionID);
+            if (allEvents.length === 0) {
+                return { turns: [], events: [] };
+            }
+            return { turns: [], events: allEvents.map(rowToEvent) };
+        }
+        const turnIDs = turns.map((t) => t.turn_id);
+        const placeholders = turnIDs.map(() => '?').join(',');
+        const events = this.rawDb
+            .prepare(`SELECT * FROM trajectory_events
+         WHERE session_id = ? AND turn_id IN (${placeholders})
+         ORDER BY turn_id ASC, seq ASC`)
+            .all(sessionID, ...turnIDs).map(rowToEvent);
+        return {
+            turns: turns.map(rowToTurn),
+            events,
+        };
+    }
+    nextTurnId(sessionID) {
+        const row = this.rawDb
+            .prepare('SELECT COALESCE(MAX(turn_id), 0) AS m FROM trajectory_turns WHERE session_id = ?')
+            .get(sessionID);
+        return row.m + 1;
+    }
+    currentTurnId(sessionID) {
+        const row = this.rawDb
+            .prepare('SELECT COALESCE(MAX(turn_id), 0) AS m FROM trajectory_turns WHERE session_id = ?')
+            .get(sessionID);
+        return row.m;
+    }
+    deleteSession(sessionID) {
+        this.rawDb.prepare('DELETE FROM trajectory_events WHERE session_id = ?').run(sessionID);
+        this.rawDb.prepare('DELETE FROM trajectory_turns WHERE session_id = ?').run(sessionID);
+    }
+    pruneOlderThan(days) {
+        const cutoff = Math.floor(Date.now() / 1000) - days * 86400;
+        this.rawDb.prepare(`
+      DELETE FROM trajectory_events WHERE created_at < ?
+      AND session_id NOT IN (SELECT session_id FROM goal_sessions)
+    `).run(cutoff);
+        this.rawDb.prepare(`
+      DELETE FROM trajectory_turns WHERE created_at < ?
+      AND session_id NOT IN (SELECT session_id FROM goal_sessions)
+    `).run(cutoff);
+    }
+    getSessionTokenSummary(sessionID) {
+        const turns = this.rawDb
+            .prepare('SELECT tokens, cost FROM trajectory_turns WHERE session_id = ?')
+            .all(sessionID);
+        const total = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+        let totalCost = 0;
+        for (const row of turns) {
+            const t = row.tokens ? JSON.parse(row.tokens) : EMPTY_TOKENS;
+            total.input += t.input || 0;
+            total.output += t.output || 0;
+            total.reasoning += t.reasoning || 0;
+            total.cache.read += t.cache?.read || 0;
+            total.cache.write += t.cache?.write || 0;
+            totalCost += row.cost || 0;
+        }
+        const count = turns.length;
+        const avg = count > 0
+            ? {
+                input: Math.round(total.input / count),
+                output: Math.round(total.output / count),
+                reasoning: Math.round(total.reasoning / count),
+                cache: {
+                    read: Math.round(total.cache.read / count),
+                    write: Math.round(total.cache.write / count),
+                },
+            }
+            : { ...EMPTY_TOKENS };
+        return { totalTokens: total, totalCost, turnCount: count, avgTokensPerTurn: avg };
+    }
+    getProjectTokenSummary(projectID) {
+        const rows = this.rawDb
+            .prepare('SELECT tokens, cost, session_id FROM trajectory_turns WHERE project_id = ?')
+            .all(projectID);
+        const total = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+        let totalCost = 0;
+        const sessions = new Set();
+        for (const row of rows) {
+            const t = row.tokens ? JSON.parse(row.tokens) : EMPTY_TOKENS;
+            total.input += t.input || 0;
+            total.output += t.output || 0;
+            total.reasoning += t.reasoning || 0;
+            total.cache.read += t.cache?.read || 0;
+            total.cache.write += t.cache?.write || 0;
+            totalCost += row.cost || 0;
+            sessions.add(row.session_id);
+        }
+        return { totalTokens: total, totalCost, turnCount: rows.length, sessionCount: sessions.size };
+    }
+    getGlobalTokenSummary() {
+        const rows = this.rawDb
+            .prepare('SELECT tokens, cost, session_id FROM trajectory_turns')
+            .all();
+        const total = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+        let totalCost = 0;
+        const sessions = new Set();
+        for (const row of rows) {
+            const t = row.tokens ? JSON.parse(row.tokens) : EMPTY_TOKENS;
+            total.input += t.input || 0;
+            total.output += t.output || 0;
+            total.reasoning += t.reasoning || 0;
+            total.cache.read += t.cache?.read || 0;
+            total.cache.write += t.cache?.write || 0;
+            totalCost += row.cost || 0;
+            sessions.add(row.session_id);
+        }
+        return { totalTokens: total, totalCost, turnCount: rows.length, sessionCount: sessions.size };
+    }
+    getMemoryTokenSummary() {
+        const rows = this.rawDb
+            .prepare('SELECT tokens, cost, session_id, worker_role FROM trajectory_turns WHERE worker_role IS NOT NULL')
+            .all();
+        const total = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+        let totalCost = 0;
+        const sessions = new Set();
+        const byRole = {};
+        for (const row of rows) {
+            const t = row.tokens ? JSON.parse(row.tokens) : EMPTY_TOKENS;
+            total.input += t.input || 0;
+            total.output += t.output || 0;
+            total.reasoning += t.reasoning || 0;
+            total.cache.read += t.cache?.read || 0;
+            total.cache.write += t.cache?.write || 0;
+            totalCost += row.cost || 0;
+            sessions.add(row.session_id);
+            const role = row.worker_role || 'unknown';
+            if (!byRole[role]) {
+                byRole[role] = {
+                    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                    cost: 0,
+                    turns: 0,
+                    sessions: new Set(),
+                };
+            }
+            const r = byRole[role];
+            r.tokens.input += t.input || 0;
+            r.tokens.output += t.output || 0;
+            r.tokens.reasoning += t.reasoning || 0;
+            r.tokens.cache.read += t.cache?.read || 0;
+            r.tokens.cache.write += t.cache?.write || 0;
+            r.cost += row.cost || 0;
+            r.turns++;
+            r.sessions.add(row.session_id);
+        }
+        const byRoleResult = {};
+        for (const [role, data] of Object.entries(byRole)) {
+            byRoleResult[role] = {
+                totalTokens: data.tokens,
+                totalCost: data.cost,
+                turnCount: data.turns,
+                sessionCount: data.sessions.size,
+            };
+        }
+        return { totalTokens: total, totalCost, turnCount: rows.length, sessionCount: sessions.size, byRole: byRoleResult };
+    }
+    getProviderCostInWindow(provider, cutoffMs) {
+        const row = this.rawDb
+            .prepare('SELECT SUM(cost) as total FROM trajectory_turns WHERE provider = ? AND turn_start_ms >= ?')
+            .get(provider, cutoffMs);
+        return row?.total || 0;
+    }
+    getProviderTotalCost(provider) {
+        const row = this.rawDb
+            .prepare('SELECT SUM(cost) as total FROM trajectory_turns WHERE provider = ?')
+            .get(provider);
+        return row?.total || 0;
+    }
+    getProviderTokensInWindow(provider, cutoffMs) {
+        const rows = this.rawDb
+            .prepare('SELECT tokens FROM trajectory_turns WHERE provider = ? AND turn_start_ms >= ?')
+            .all(provider, cutoffMs);
+        return this.aggregateTokens(rows);
+    }
+    getProviderTotalTokens(provider) {
+        const rows = this.rawDb
+            .prepare('SELECT tokens FROM trajectory_turns WHERE provider = ?')
+            .all(provider);
+        return this.aggregateTokens(rows);
+    }
+    aggregateTokens(rows) {
+        const total = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+        for (const row of rows) {
+            const t = row.tokens ? JSON.parse(row.tokens) : EMPTY_TOKENS;
+            total.input += t.input || 0;
+            total.output += t.output || 0;
+            total.reasoning += t.reasoning || 0;
+            total.cache.read += t.cache?.read || 0;
+            total.cache.write += t.cache?.write || 0;
+        }
+        return total;
+    }
+    getProviderEarliestTurnInWindow(provider, cutoffMs) {
+        const row = this.rawDb
+            .prepare('SELECT MIN(turn_start_ms) as earliest FROM trajectory_turns WHERE provider = ? AND turn_start_ms >= ?')
+            .get(provider, cutoffMs);
+        return row?.earliest || null;
+    }
+    getDistinctProviders() {
+        const rows = this.rawDb
+            .prepare('SELECT DISTINCT provider FROM trajectory_turns WHERE provider IS NOT NULL')
+            .all();
+        return rows.map(r => r.provider);
+    }
+    getModelUsageStats(sinceEpochSec) {
+        const rows = this.rawDb
+            .prepare(`SELECT provider, model, COUNT(*) AS turns,
+                SUM(CAST(json_extract(tokens,'$.input') AS INTEGER)) AS input,
+                SUM(CAST(json_extract(tokens,'$.output') AS INTEGER)) AS output,
+                SUM(CAST(json_extract(tokens,'$.reasoning') AS INTEGER)) AS reasoning,
+                SUM(CAST(json_extract(tokens,'$.cache.read') AS INTEGER)) AS cache_read,
+                SUM(CAST(json_extract(tokens,'$.cache.write') AS INTEGER)) AS cache_write
+         FROM trajectory_turns
+         WHERE model IS NOT NULL${sinceEpochSec !== null ? ' AND created_at >= ?' : ''}
+         GROUP BY provider, model
+         ORDER BY (COALESCE(input,0)+COALESCE(output,0)+COALESCE(reasoning,0)+COALESCE(cache_read,0)+COALESCE(cache_write,0)) DESC`)
+            .all(...(sinceEpochSec !== null ? [sinceEpochSec] : []));
+        return rows.map((r) => ({
+            provider: r.provider ?? null,
+            model: r.model,
+            turns: r.turns,
+            tokens: {
+                input: r.input || 0,
+                output: r.output || 0,
+                reasoning: r.reasoning || 0,
+                cache: { read: r.cache_read || 0, write: r.cache_write || 0 },
+            },
+        }));
+    }
+}
+exports.TrajectoryStore = TrajectoryStore;

package/gateway/dist/trajectory/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRAJECTORY_EVENT_TYPES = void 0;
+exports.TRAJECTORY_EVENT_TYPES = [
+    'tool_start',
+    'tool_update',
+    'tool_end',
+    'reasoning_start',
+    'reasoning_end',
+    'agent_switch',
+    'model_switch',
+    'step_finish',
+    'turn_start',
+    'turn_end',
+    'text_start',
+    'text_end',
+];

package/gateway/dist/tray/index.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTray = startTray;
+exports.stopTray = stopTray;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const TRAY_PID_FILE = path.join(os.homedir(), '.config', 'mafw', 'tray.pid');
+const TRAY_SCRIPT = path.join(__dirname, 'tray.ps1');
+let trayProcess = null;
+function writePid(pid) {
+    try {
+        fs.writeFileSync(TRAY_PID_FILE, String(pid));
+    }
+    catch { }
+}
+function readPid() {
+    try {
+        if (!fs.existsSync(TRAY_PID_FILE))
+            return null;
+        const pid = Number(fs.readFileSync(TRAY_PID_FILE, 'utf-8').trim());
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function startTray(port) {
+    if (process.platform !== 'win32')
+        return;
+    if (process.env.MAFW_TRAY_ENABLED === '0' || process.env.MAFW_TRAY_ENABLED === 'false')
+        return;
+    if (trayProcess)
+        return;
+    if (!fs.existsSync(TRAY_SCRIPT))
+        return;
+    // Clear any stale tray left over from a hard-killed previous gateway.
+    const stalePid = readPid();
+    if (stalePid && isAlive(stalePid)) {
+        try {
+            process.kill(stalePid);
+        }
+        catch { }
+    }
+    try {
+        fs.unlinkSync(TRAY_PID_FILE);
+    }
+    catch { }
+    const child = (0, child_process_1.spawn)('powershell.exe', [
+        '-NoProfile',
+        '-STA',
+        '-WindowStyle', 'Hidden',
+        '-ExecutionPolicy', 'Bypass',
+        '-File', TRAY_SCRIPT,
+        '-Port', String(port),
+        '-PidFile', TRAY_PID_FILE,
+    ], { windowsHide: true });
+    trayProcess = child;
+    child.on('exit', (code) => {
+        if (trayProcess === child)
+            trayProcess = null;
+        if (code !== 0) {
+            console.log(`[Tray] tray exited with code ${code}`);
+        }
+    });
+    child.on('error', (err) => {
+        console.log(`[Tray] failed to start tray: ${err.message}`);
+        trayProcess = null;
+    });
+    console.log('[Tray] started on port ' + port);
+}
+function stopTray() {
+    const pid = readPid();
+    if (pid && isAlive(pid)) {
+        try {
+            process.kill(pid);
+        }
+        catch { }
+    }
+    try {
+        fs.unlinkSync(TRAY_PID_FILE);
+    }
+    catch { }
+    if (trayProcess) {
+        trayProcess.kill();
+        trayProcess = null;
+    }
+}

package/gateway/dist/tray/tray.ps1

@@ -0,0 +1,96 @@
+# MAFW Gateway system tray (Windows only)
+# Spawned by the gateway: powershell -NoProfile -STA -WindowStyle Hidden -ExecutionPolicy Bypass -File tray.ps1 -Port <port> -PidFile <path>
+param(
+    [int]$Port = 3000,
+    [string]$PidFile = ""
+)
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+[System.Windows.Forms.Application]::EnableVisualStyles()
+
+# Draw a simple icon programmatically so no binary asset is needed.
+function New-MafwIcon {
+    $bmp = New-Object System.Drawing.Bitmap 32, 32
+    $g = [System.Drawing.Graphics]::FromImage($bmp)
+    $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
+    $g.Clear([System.Drawing.Color]::Transparent)
+    $bg = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::FromArgb(255, 80, 120, 255))
+    $g.FillEllipse($bg, 1, 1, 30, 30)
+    $fg = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::White)
+    $font = New-Object System.Drawing.Font "Segoe UI", 16, ([System.Drawing.FontStyle]::Bold)
+    $sf = New-Object System.Drawing.StringFormat
+    $sf.Alignment = [System.Drawing.StringAlignment]::Center
+    $sf.LineAlignment = [System.Drawing.StringAlignment]::Center
+    $rect = New-Object System.Drawing.RectangleF 2, 2, 28, 28
+    $g.DrawString("M", $font, $fg, $rect, $sf)
+    $handle = $bmp.GetHicon()
+    $icon = [System.Drawing.Icon]::FromHandle($handle)
+    $g.Dispose()
+    $bmp.Dispose()
+    return $icon
+}
+
+$script:Tray = $null
+$script:ExitRequested = $false
+
+function Show-Dashboard {
+    try { Start-Process "http://localhost:$Port/" } catch {}
+}
+
+function Stop-Gateway {
+    try { Start-Process "mafw" -ArgumentList "stop" -WindowStyle Hidden } catch {}
+    # The gateway kills this tray on shutdown; exit anyway as a fallback.
+    [System.Windows.Forms.Application]::Exit()
+}
+
+$tray = New-Object System.Windows.Forms.NotifyIcon
+$tray.Icon = New-MafwIcon
+$tray.Text = "MAFW Gateway - http://localhost:$Port"
+$tray.Visible = $true
+
+$openItem = New-Object System.Windows.Forms.MenuItem "Open Dashboard"
+$openItem.add_Click({ Show-Dashboard })
+$stopItem = New-Object System.Windows.Forms.MenuItem "Stop Gateway"
+$stopItem.add_Click({ Stop-Gateway })
+$exitItem = New-Object System.Windows.Forms.MenuItem "Exit Tray"
+$exitItem.add_Click({
+    $tray.Visible = $false
+    $tray.Dispose()
+    [System.Windows.Forms.Application]::Exit()
+})
+
+$menu = New-Object System.Windows.Forms.ContextMenu
+$menu.MenuItems.AddRange(@($openItem, $stopItem, $exitItem))
+$tray.ContextMenu = $menu
+$tray.add_DoubleClick({ Show-Dashboard })
+
+# Write our own PID so the gateway can clean us up on shutdown.
+if ($PidFile) {
+    try { Set-Content -LiteralPath $PidFile -Value $PID -Encoding ASCII } catch {}
+}
+
+# Self-cleanup: if the gateway dies without telling us (e.g. hard kill on
+# Windows), exit after a few failed health checks.
+$healthFailures = 0
+$healthTimer = New-Object System.Windows.Forms.Timer
+$healthTimer.Interval = 5000
+$healthTimer.add_Tick({
+    try {
+        $resp = Invoke-WebRequest -Uri "http://127.0.0.1:$Port/health" -UseBasicParsing -TimeoutSec 3
+        $healthFailures = 0
+    } catch {
+        $healthFailures++
+        if ($healthFailures -ge 5) {
+            $healthTimer.Stop()
+            $tray.Visible = $false
+            $tray.Dispose()
+            [System.Windows.Forms.Application]::Exit()
+        }
+    }
+})
+$healthTimer.Start()
+
+[System.Windows.Forms.Application]::Run()
+$tray.Visible = $false
+$tray.Dispose()

package/gateway/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/gateway/dist/usage/builtin-plugins/commandcode.js

@@ -0,0 +1,71 @@
+// Builtin usage plugin: Command Code GOAT (token-plan type — 5h / 7d $ windows + monthly credits)
+module.exports = {
+  name: 'commandcode',
+  type: 'token-plan',
+  plan: 'GOAT',
+  async fetch(ctx) {
+    const cookie = ctx.cookie('commandcode');
+    if (!cookie) return null;
+    try {
+      const res = await ctx.fetch('https://api.commandcode.ai/internal/billing/credits', {
+        headers: { 'Cookie': cookie },
+      });
+      if (!res.ok) {
+        ctx.log.warn('[CommandCodePlugin] HTTP ' + res.status);
+        return null;
+      }
+      const body = await res.json();
+      const windowLimits = body?.windowLimits ?? body?.credits?.windowLimits;
+      if (!windowLimits) return null;
+
+      const windows = [];
+      for (const [key, label] of [['fiveHour', '5h'], ['weekly', '7d']]) {
+        const w = windowLimits[key];
+        const cap = num(w?.cap);
+        if (cap === undefined || cap <= 0) continue;
+        const used = num(w?.used) ?? 0;
+        const pct = Math.round((used / cap) * 100);
+        const resetMs = w?.resetAt ? Date.parse(w.resetAt) : undefined;
+        windows.push({
+          window: label,
+          used: Math.round(used * 100) / 100,
+          limit: Math.round(cap * 100) / 100,
+          unit: '$',
+          pct,
+          resetAt: Number.isFinite(resetMs) ? resetMs : undefined,
+        });
+      }
+
+      const monthlyCredits = num(body?.credits?.monthlyCredits);
+      if (monthlyCredits !== undefined) {
+        windows.push({
+          window: 'month',
+          used: monthlyCredits,
+          limit: 0,
+          unit: '$',
+          pct: 0,
+        });
+      }
+      if (windows.length === 0) return null;
+
+      return {
+        name: 'commandcode',
+        type: 'token-plan',
+        plan: 'GOAT',
+        windows,
+      };
+    } catch (err) {
+      ctx.log.warn('[CommandCodePlugin] fetch failed: ' + (err.message || err));
+      return null;
+    }
+  },
+};
+
+function num(v) {
+  if (typeof v === 'number' && Number.isFinite(v)) return v;
+  if (typeof v === 'string' && v.trim() !== '') {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return undefined;
+}