@louisraetz/steamidled 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 louisraetz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# steamidled 🎮💤
+
+Steam game idler CLI and daemon. Rack up playtime while you touch grass. Run up to 32 games simultaneously, collect trading cards, and finally look like you have no life (in a good way).
+
+## ✨ Why does this exist?
+
+This is a hobby project, born from a weekend of vibe coding and questionable life choices. I wanted more hours in games I'll never actually play, and here we are.
+
+Built with love, caffeine, and Claude. No regrets. 🤖☕
+
+## 🚀 Features
+
+- **📱 QR Code Login** — Scan with Steam mobile app
+- **🔐 Traditional Login** — Username/password with Steam Guard (for the old school folks)
+- **🎯 Idle up to 32 games** — Because Steam said that's the limit and who are we to argue
+- **📊 Real-time tracking** — Watch numbers go up. Dopamine achieved.
+- **⭐ Favorites system** — Star your favorites so you can pretend you're organized
+- **⏸️ Auto-pause** — Automatically pauses when you actually play a game (rare occurrence)
+- **💾 Persistent sessions** — Remembers your login so you don't have to
+
+## 📦 Installation
+
+### npm
+
+```bash
+npm install -g @louisraetz/steamidled
+```
+
+### Homebrew 🍺
+
+```bash
+brew tap louisraetz/steamidled
+brew install steamidled
+```
+
+## 🎮 Usage
+
+```bash
+steamidled              # Interactive mode
+steamidled --headless   # Headless mode (auto-start favorites)
+```
+
+### Interactive mode
+
+1. **Pick your login method** — QR code is chef's kiss 👨‍🍳💋
+2. **Select your games** — Go wild, pick all of them, I won't judge
+3. **Watch the hours roll in** — This is what peak productivity looks like
+
+### Headless mode
+
+Automatically logs in and starts idling your favorited games. Perfect for running as a service. Requires running interactively first to log in and set up favorites.
+
+## ⌨️ Controls
+
+### Game Selection
+
+| Key | What it does |
+|-----|--------------|
+| `↑` `↓` | Navigate (you got this) |
+| `Space` | Toggle game on/off |
+| `F` | Favorite a game ⭐ |
+| `S` | Start all favorites |
+| `Enter` | Let's gooo 🚀 |
+
+### While Idling
+
+| Key | What it does |
+|-----|--------------|
+| `E` | Edit your selection (changed your mind?) |
+| `Q` | Quit gracefully (like a gentleman) |
+| `Ctrl+C` | Rage quit |
+
+## 🐧 Running 24/7 on Linux
+
+Want to idle games while you sleep? Same. Run it as a systemd service with `--headless` mode.
+
+### Prerequisites
+
+1. Run the tool interactively once to log in and set up favorites
+2. Find where it lives: `which steamidled`
+
+### Create the Service
+
+```bash
+sudo nano /etc/systemd/system/steamidled.service
+```
+
+```ini
+[Unit]
+Description=steamidled
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=YOUR_USERNAME
+ExecStart=/usr/bin/steamidled --headless
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Replace `YOUR_USERNAME` with your username.
+
+### Fire it up
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable steamidled
+sudo systemctl start steamidled
+```
+
+### Useful commands
+
+```bash
+sudo systemctl status steamidled   # Is it alive?
+journalctl -u steamidled -f        # What's it thinking?
+sudo systemctl stop steamidled     # Take a break
+sudo systemctl restart steamidled  # Turn it off and on again
+```
+
+## 📁 Where's my stuff?
+
+Everything lives in `~/.steam-idler/`:
+
+```
+~/.steam-idler/
+├── credentials.json          # Your login token (keep it secret 🤫)
+└── favorites-{username}.json # Your favorite games
+```
+
+## 📋 Requirements
+
+- Node.js 18+ (we're modern here)
+- A Steam account with games (shocking, I know)
+- Steam mobile app (optional, but makes login ✨fancy✨)
+
+## 🤝 Contributing
+
+Found a bug? Have an idea? PRs welcome! This is a hobby project so I might be slow, but I appreciate you. 💙
+
+## ⚠️ Disclaimer
+
+This is just a fun side project. Use responsibly. I'm not responsible if Valve gets mad at you or whatever. Probably don't idle 10,000 hours in a game you've never launched. Or do. I'm not your mom.
+
+## 📄 License
+
+MIT — Do whatever you want with it ✌️
+
+---
+
+*Made with mass vibe coding energy* 🌊✨

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import * as readline from 'node:readline';
+import { SteamClient } from './steam/client.js';
+import { loginWithQR, loginWithCredentials, loginWithStoredCredentials, hasStoredLogin, } from './steam/auth.js';
+import { promptAuthMethod } from './ui/prompts.js';
+import { selectGames } from './ui/gameSelector.js';
+import { showWelcome, showIdlingStatus, showLoginSuccess, showLoginError, showGoodbye, showError, } from './ui/display.js';
+import ora from 'ora';
+const client = new SteamClient();
+let isIdling = false;
+let idlingGames = [];
+let pausedGames = [];
+let allGames = [];
+let startTime = null;
+let updateInterval = null;
+let isInEditMode = false;
+let accountName = '';
+// Main entry point that orchestrates the application flow
+async function main() {
+    showWelcome();
+    process.on('SIGINT', handleShutdown);
+    process.on('SIGTERM', handleShutdown);
+    const loginResult = await handleLogin();
+    if (!loginResult.success) {
+        showLoginError(loginResult.error || 'Unknown error');
+        process.exit(1);
+    }
+    accountName = loginResult.accountName;
+    showLoginSuccess(accountName);
+    const spinner = ora('Fetching your game library...').start();
+    try {
+        allGames = await client.getOwnedGames();
+        spinner.succeed(`Found ${allGames.length} games in your library`);
+    }
+    catch (err) {
+        spinner.fail('Failed to fetch games');
+        showError(err.message);
+        process.exit(1);
+    }
+    if (allGames.length === 0) {
+        showError('No games found in your library');
+        process.exit(1);
+    }
+    const { selectedGames, quickStart } = await selectGames(allGames, accountName);
+    if (selectedGames.length === 0) {
+        showError('No games selected');
+        process.exit(1);
+    }
+    startIdling(selectedGames);
+    await new Promise(() => {
+    });
+}
+// Handles authentication method selection and login
+async function handleLogin() {
+    const hasStored = hasStoredLogin();
+    const method = await promptAuthMethod(hasStored);
+    switch (method) {
+        case 'stored':
+            return loginWithStoredCredentials(client);
+        case 'qr':
+            return loginWithQR(client);
+        case 'credentials':
+            return loginWithCredentials(client);
+        default:
+            return { success: false, error: 'Invalid login method' };
+    }
+}
+// Sets up raw mode keyboard input handling for edit and quit commands
+function setupKeyboardInput() {
+    if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('keypress', async (str, key) => {
+            if (key && key.ctrl && key.name === 'c') {
+                handleShutdown();
+                return;
+            }
+            if (isInEditMode) {
+                return;
+            }
+            if (str === 'e' || str === 'E') {
+                await enterEditMode();
+                return;
+            }
+            if (str === 'q' || str === 'Q') {
+                handleShutdown();
+                return;
+            }
+        });
+    }
+}
+// Creates an IdlingGame object from a GameSelection
+function createIdlingGame(game, steamGame) {
+    const initialPlaytime = steamGame?.playtime_forever ?? 0;
+    return {
+        appid: game.appid,
+        name: game.name,
+        initialPlaytime,
+        startTime: new Date(),
+        accumulatedMs: 0,
+    };
+}
+// Converts IdlingGame array back to GameSelection array for the selector
+function getGameCurrentSelection() {
+    return [...idlingGames, ...pausedGames].map((g) => ({
+        appid: g.appid,
+        name: g.name,
+    }));
+}
+// Handles edit mode for changing game selection while idling
+async function enterEditMode() {
+    isInEditMode = true;
+    if (updateInterval) {
+        clearInterval(updateInterval);
+        updateInterval = null;
+    }
+    const now = new Date();
+    for (const game of idlingGames) {
+        game.accumulatedMs += now.getTime() - game.startTime.getTime();
+    }
+    console.clear();
+    const currentSelection = getGameCurrentSelection();
+    const { selectedGames: newSelection } = await selectGames(allGames, accountName, currentSelection);
+    if (newSelection.length === 0) {
+        showError('No games selected - keeping current selection');
+        for (const game of idlingGames) {
+            game.startTime = new Date();
+        }
+    }
+    else {
+        const oldAppIds = new Set([...idlingGames, ...pausedGames].map((g) => g.appid));
+        const newAppIds = new Set(newSelection.map((g) => g.appid));
+        const keptIdlingGames = [];
+        const keptPausedGames = [];
+        for (const game of idlingGames) {
+            if (newAppIds.has(game.appid)) {
+                game.startTime = new Date();
+                keptIdlingGames.push(game);
+            }
+        }
+        for (const game of pausedGames) {
+            if (newAppIds.has(game.appid)) {
+                keptPausedGames.push(game);
+            }
+        }
+        for (const selection of newSelection) {
+            if (!oldAppIds.has(selection.appid)) {
+                const steamGame = allGames.find((g) => g.appid === selection.appid);
+                keptIdlingGames.push(createIdlingGame(selection, steamGame));
+            }
+        }
+        idlingGames = keptIdlingGames;
+        pausedGames = keptPausedGames;
+        const appIds = idlingGames.map((g) => g.appid);
+        client.setGamesPlaying(appIds);
+    }
+    if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+    }
+    isInEditMode = false;
+    if (startTime) {
+        showIdlingStatus(idlingGames, pausedGames);
+        updateInterval = setInterval(() => {
+            if (startTime && !isInEditMode) {
+                showIdlingStatus(idlingGames, pausedGames);
+            }
+        }, 60000);
+    }
+}
+// Handles state changes when user plays or stops playing a game on Steam
+function handlePlayingState(blocked, playingApp) {
+    if (isInEditMode)
+        return;
+    if (blocked) {
+        const gameIndex = idlingGames.findIndex((g) => g.appid === playingApp);
+        if (gameIndex !== -1) {
+            const game = idlingGames[gameIndex];
+            const now = new Date();
+            game.accumulatedMs += now.getTime() - game.startTime.getTime();
+            const [pausedGame] = idlingGames.splice(gameIndex, 1);
+            pausedGames.push(pausedGame);
+            const appIds = idlingGames.map((g) => g.appid);
+            client.setGamesPlaying(appIds);
+            showIdlingStatus(idlingGames, pausedGames);
+        }
+    }
+    else {
+        if (pausedGames.length > 0) {
+            const now = new Date();
+            for (const game of pausedGames) {
+                game.startTime = now;
+            }
+            idlingGames.push(...pausedGames);
+            pausedGames = [];
+            const appIds = idlingGames.map((g) => g.appid);
+            client.setGamesPlaying(appIds);
+            showIdlingStatus(idlingGames, pausedGames);
+        }
+    }
+}
+// Initializes the idling session and starts the display loop
+function startIdling(games) {
+    isIdling = true;
+    startTime = new Date();
+    idlingGames = games.map((game) => {
+        const steamGame = allGames.find((g) => g.appid === game.appid);
+        return createIdlingGame(game, steamGame);
+    });
+    pausedGames = [];
+    const appIds = games.map((g) => g.appid);
+    client.setGamesPlaying(appIds);
+    setupKeyboardInput();
+    showIdlingStatus(idlingGames, pausedGames);
+    updateInterval = setInterval(() => {
+        if (startTime && !isInEditMode) {
+            showIdlingStatus(idlingGames, pausedGames);
+        }
+    }, 60000);
+    client.onPlayingState(handlePlayingState);
+    client.onDisconnected((eresult, msg) => {
+        console.log(`\nDisconnected from Steam: ${msg} (${eresult})`);
+        handleShutdown();
+    });
+    client.onError((err) => {
+        console.log(`\nSteam error: ${err.message}`);
+        handleShutdown();
+    });
+}
+// Graceful shutdown handler that saves state and logs out
+function handleShutdown() {
+    console.log('\n');
+    if (updateInterval) {
+        clearInterval(updateInterval);
+        updateInterval = null;
+    }
+    if (isIdling) {
+        client.stopPlaying();
+        isIdling = false;
+    }
+    if (client.isLoggedIn) {
+        client.logout();
+    }
+    showGoodbye();
+    process.exit(0);
+}
+main().catch((err) => {
+    showError(err.message);
+    process.exit(1);
+});

package/dist/steam/auth.d.ts

@@ -0,0 +1,8 @@
+import type { SteamClient } from './client.js';
+import { clearCredentials } from '../storage/credentials.js';
+import type { LoginResult } from '../types/index.js';
+export declare function loginWithQR(client: SteamClient): Promise<LoginResult>;
+export declare function loginWithCredentials(client: SteamClient): Promise<LoginResult>;
+export declare function loginWithStoredCredentials(client: SteamClient): Promise<LoginResult>;
+export declare function hasStoredLogin(): boolean;
+export { clearCredentials };

package/dist/steam/auth.js

@@ -0,0 +1,142 @@
+import { LoginSession, EAuthTokenPlatformType, EAuthSessionGuardType } from 'steam-session';
+import qrcode from 'qrcode-terminal';
+import { input, password as passwordPrompt } from '@inquirer/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import { saveCredentials, loadCredentials, clearCredentials, hasStoredCredentials, } from '../storage/credentials.js';
+// Authenticates via QR code scanned with the Steam mobile app
+export async function loginWithQR(client) {
+    const session = new LoginSession(EAuthTokenPlatformType.SteamClient);
+    return new Promise((resolve) => {
+        session.on('authenticated', async () => {
+            const refreshToken = session.refreshToken;
+            const accountName = session.accountName;
+            if (!refreshToken || !accountName) {
+                resolve({ success: false, error: 'Failed to get credentials from QR login' });
+                return;
+            }
+            saveCredentials({
+                accountName,
+                refreshToken,
+            });
+            try {
+                await client.loginWithRefreshToken(refreshToken, accountName);
+                resolve({ success: true, accountName });
+            }
+            catch (err) {
+                resolve({ success: false, error: err.message });
+            }
+        });
+        session.on('timeout', () => {
+            resolve({ success: false, error: 'QR code timed out' });
+        });
+        session.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+        });
+        session.startWithQR().then((result) => {
+            if (result.qrChallengeUrl) {
+                console.log(chalk.cyan('\nScan this QR code with your Steam mobile app:\n'));
+                qrcode.generate(result.qrChallengeUrl);
+                console.log(chalk.gray('\nWaiting for approval...\n'));
+            }
+        });
+    });
+}
+// Authenticates via username and password with Steam Guard support
+export async function loginWithCredentials(client) {
+    const session = new LoginSession(EAuthTokenPlatformType.SteamClient);
+    const accountName = await input({
+        message: 'Steam username:',
+    });
+    const password = await passwordPrompt({
+        message: 'Steam password:',
+        mask: '*',
+    });
+    const spinner = ora('Logging in...').start();
+    return new Promise((resolve) => {
+        session.on('authenticated', async () => {
+            spinner.stop();
+            const refreshToken = session.refreshToken;
+            if (!refreshToken) {
+                resolve({ success: false, error: 'Failed to get refresh token' });
+                return;
+            }
+            saveCredentials({
+                accountName,
+                refreshToken,
+            });
+            try {
+                await client.loginWithRefreshToken(refreshToken, accountName);
+                resolve({ success: true, accountName });
+            }
+            catch (err) {
+                resolve({ success: false, error: err.message });
+            }
+        });
+        session.on('timeout', () => {
+            spinner.stop();
+            resolve({ success: false, error: 'Login timed out' });
+        });
+        session.on('error', (err) => {
+            spinner.stop();
+            resolve({ success: false, error: err.message });
+        });
+        session.on('steamGuardMachineToken', () => {
+        });
+        session.startWithCredentials({ accountName, password }).then(async (result) => {
+            if (result.actionRequired) {
+                spinner.stop();
+                for (const action of result.validActions || []) {
+                    if (action.type === EAuthSessionGuardType.EmailCode ||
+                        action.type === EAuthSessionGuardType.DeviceCode) {
+                        const guardType = action.type === EAuthSessionGuardType.EmailCode ? 'email' : 'mobile app';
+                        console.log(chalk.yellow(`\nSteam Guard code required (${guardType})`));
+                        const code = await input({
+                            message: 'Enter Steam Guard code:',
+                        });
+                        spinner.start('Verifying code...');
+                        try {
+                            await session.submitSteamGuardCode(code);
+                        }
+                        catch (err) {
+                            spinner.stop();
+                            resolve({ success: false, error: err.message });
+                        }
+                        break;
+                    }
+                    if (action.type === EAuthSessionGuardType.DeviceConfirmation) {
+                        console.log(chalk.yellow('\nPlease confirm the login request on your Steam mobile app...'));
+                        spinner.start('Waiting for confirmation...');
+                        break;
+                    }
+                }
+            }
+        }).catch((err) => {
+            spinner.stop();
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+// Logs in using a previously saved refresh token
+export async function loginWithStoredCredentials(client) {
+    const credentials = loadCredentials();
+    if (!credentials) {
+        return { success: false, error: 'No stored credentials' };
+    }
+    const spinner = ora(`Logging in as ${chalk.cyan(credentials.accountName)}...`).start();
+    try {
+        await client.loginWithRefreshToken(credentials.refreshToken, credentials.accountName);
+        spinner.succeed(`Logged in as ${chalk.cyan(credentials.accountName)}`);
+        return { success: true, accountName: credentials.accountName };
+    }
+    catch (err) {
+        spinner.fail('Stored credentials expired');
+        clearCredentials();
+        return { success: false, error: 'Stored credentials expired' };
+    }
+}
+// Checks if stored login credentials exist
+export function hasStoredLogin() {
+    return hasStoredCredentials();
+}
+export { clearCredentials };

package/dist/steam/client.d.ts

@@ -0,0 +1,22 @@
+import SteamUser from 'steam-user';
+import type { SteamGame } from '../types/index.js';
+export declare class SteamClient {
+    private client;
+    private _isLoggedIn;
+    private _accountName;
+    constructor();
+    get isLoggedIn(): boolean;
+    get accountName(): string | null;
+    get steamUser(): SteamUser;
+    loginWithRefreshToken(refreshToken: string, accountName?: string): Promise<void>;
+    loginWithCredentials(accountName: string, password: string): Promise<{
+        refreshToken: string;
+    }>;
+    getOwnedGames(): Promise<SteamGame[]>;
+    setGamesPlaying(appIds: number[]): void;
+    stopPlaying(): void;
+    logout(): void;
+    onDisconnected(callback: (eresult: number, msg: string) => void): void;
+    onError(callback: (err: Error) => void): void;
+    onPlayingState(callback: (blocked: boolean, playingApp: number) => void): void;
+}